Whamcloud - gitweb
LU-7521 ldlm: LDLM_DEBUG() shouldn't be passed \n
[fs/lustre-release.git] / snmp / lustre-snmp-util.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  * Lustre is a trademark of Sun Microsystems, Inc.
33  *
34  * snmp/lustre-snmp-util.c
35  *
36  * Author: PJ Kirner <pjkirner@clusterfs.com>
37  */
38
39 /*
40  *   include important headers
41  */
42
43 #include <net-snmp/net-snmp-config.h>
44 #include <net-snmp/net-snmp-includes.h>
45 #include <net-snmp/agent/net-snmp-agent-includes.h>
46
47 /*
48  *  include our .h file
49  */ 
50
51 #include <sys/types.h>
52 #include <sys/vfs.h>
53 #include <dirent.h>
54 #include <sys/stat.h>
55 #include <unistd.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <string.h>
59 #include "lustre-snmp-util.h"
60
61 /*********************************************************************
62  * Function:    get_file_list
63  *
64  * Description: For the given valid directory  path, returns the list
65  *              all directories or files in that path.
66  *
67  * Input:   'dirname' the directory path.
68  *          'file_type' if this takes the value DIR_TYPE then
69  *              returns the list of directories in that path.
70  *          If its of type FILE_TYPE then returns the list of files
71  *          in that path.
72  *          'count' pointer to number of elements returned in the
73  *          return string. 
74  *
75  * Output:  List of  directories/files in that path.
76  *
77  *********************************************************************/
78
79 char *get_file_list(const char *dirname, int file_type, uint32_t *count)
80 {
81
82     DIR           *pdir = NULL;
83     struct dirent *pdirent = NULL;
84     int           curr_offset = 0;
85     int           byte_count = 0;
86     int           file_count = 0;
87     char          *ret_str = NULL;
88     char          filename[MAX_PATH_SIZE];
89     int           cond1, cond2;
90
91     if ((dirname == NULL) || ((pdir = opendir(dirname)) == NULL )) {
92         if (dirname == NULL) {
93             report("%s %s:line %d %s", __FILE__, __FUNCTION__, __LINE__,
94                    "NULL directory is passed as parameter to funtion");
95         } else {
96             report("%s %s:line %d Error in opening the dir %s", __FILE__,
97                    __FUNCTION__, __LINE__, dirname);
98         }
99         if (count)
100             *count = 0;
101         return NULL;
102     }
103
104     while (1) {
105         if ((pdirent = readdir(pdir)) == NULL)
106             break;
107
108         /* Skip over '.' and '..' directores */
109         if ((pdirent->d_name[0] == '.') ||
110             !strcmp(pdirent->d_name, FILENAME_NUM_REF))
111             continue;
112         
113         sprintf(filename, "%s/%s", dirname, pdirent->d_name);
114         cond1 = (file_type == FILE_TYPE) && is_directory(filename);
115         cond2 = (file_type == DIR_TYPE) && (!is_directory(filename));
116
117         if (cond1 || cond2)
118             continue;
119
120         /* Calculate the number of bytes for this new entry.*/                    
121         byte_count += strlen(pdirent->d_name) + 1;
122         file_count++;
123     }
124     if (count)
125         *count = file_count;
126     
127     if (file_count != 0) {
128         
129         /* need one extra one for the finall NULL terminator*/
130         if ((ret_str = (char *) malloc(byte_count + 1)) == NULL) {
131             report("get_file_list() failed to malloc(%d)",byte_count+1);
132             closedir(pdir);
133             return NULL;
134         }    
135         
136         rewinddir(pdir);
137         
138         while (file_count != 0) {
139             if ((pdirent = readdir(pdir)) == NULL)
140                 break;
141
142             if ((pdirent->d_name[0] == '.') ||
143                 !strcmp(pdirent->d_name, FILENAME_NUM_REF))
144                 continue;
145             
146             sprintf(filename, "%s/%s", dirname, pdirent->d_name);
147             cond1 = (file_type == FILE_TYPE) && is_directory(filename);
148             cond2 = (file_type == DIR_TYPE) && (!is_directory(filename));
149
150             if (cond1 || cond2)
151                 continue;
152
153             strcpy(ret_str + curr_offset, pdirent->d_name);
154             curr_offset = curr_offset + strlen(pdirent->d_name) + 1;
155             file_count--;
156         }
157         /* Put in the finall null terminator*/
158         ret_str[byte_count] = '\0';
159     }
160     closedir(pdir);
161     return ret_str;
162 }
163
164
165 /*********************************************************************
166  * Function:    is_directory
167  *
168  * Description: Checks if given filename is a directory or not.
169  *              all directories or files in that path.
170  *
171  * Input:   'filename' the directory path to be checked.
172  *
173  * Output:  Returns 1 if its a directory else 0.
174  *
175  *********************************************************************/
176
177 int is_directory(const char *filename)
178 {
179
180     struct stat statf;
181     int result;
182
183     result = stat(filename, &statf);
184     return ((result == SUCCESS) && (statf.st_mode & S_IFDIR));
185 }
186
187 /*********************************************************************
188  * Function:    read_string
189  *
190  * Description: For the given valid file path, reads the data in
191  *              that file.
192  *
193  * Input:   'filepath' the file whose data is to be accessed.
194  *          'lustre_var' the data from the file is read into
195  *           this variable, returned to the requestor.
196  *          'var_max_size' the max size of the string
197  *          'report_error' boolean if error should be reported on 
198  *           missing filepath
199  *
200  * Output:  Returns SUCCESS if read successfully from file else
201  *          returns ERROR.
202  *********************************************************************/
203  
204 int  read_string(const char *filepath, char *lustre_var, size_t var_max_size)
205 {
206     FILE    *fptr = NULL;
207     int     len = 0;
208     int     ret_val = SUCCESS;
209     int     report_error = 1;
210
211     if ((filepath == NULL) || (lustre_var == NULL)) {
212         report("%s %s:line %d %s", __FILE__, __FUNCTION__, __LINE__,
213                "Input parameter is NULL");
214         ret_val = ERROR;
215     } else {
216         fptr = fopen(filepath, "r");
217
218         if (fptr == NULL) {
219             if(report_error)
220                 report("%s %s:line %d Unable to open the file %s", __FILE__,
221                        __FUNCTION__, __LINE__, filepath);
222             ret_val = ERROR;
223         } else {
224             if (fgets(lustre_var, var_max_size, fptr) == NULL) {
225                 report("%s %s:line %d read failed for file %s", __FILE__,
226                        __FUNCTION__, __LINE__, filepath);
227                  ret_val = ERROR;
228             } else {
229                 len = strlen(lustre_var);
230                 /*
231                     Last char is EOF, before string ends,
232                     so '\0' is moved to last but one.
233                 */
234                 lustre_var[len-1] = lustre_var[len];
235             }
236             fclose(fptr);
237         }
238     }
239     return ret_val;
240 }
241
242 /**************************************************************************
243  * Function:   lustrefs_ctrl
244  *
245  * Description: Execute /etc/init.d/lustre script for starting,
246  *              stopping and restarting Lustre services in child process.
247  *
248  * Input:  Start/Stop/Restart Command Number.
249  * Output: Returns  void
250  *
251  **************************************************************************/
252
253 void lustrefs_ctrl(int command)
254 {
255     char *cmd[3];
256
257     cmd[0] = LUSTRE_SERVICE;
258     switch (command) {
259     case ONLINE:
260         cmd[1] = "start";
261         break;
262     case OFFLINE:
263         cmd[1] = "stop";
264         break;
265     case RESTART:
266         cmd[1] = "restart";
267         break;
268     default:
269         return;
270     }
271
272     cmd[2] = (char *)0;
273
274     if (fork() == 0) {
275         execvp(cmd[0], cmd);
276         report("failed to execvp(\'%s %s\')",cmd[0],cmd[1]);
277     }
278     return;
279 }
280
281 /*****************************************************************************
282  * Function:     get_sysstatus
283  *
284  * Description:  Read /var/lustre/sysStatus file, and based on file contents
285  *               return the status of Lustre services.
286  *
287  * Input:   void
288  * Output:  Return ONLINE/OFFLINE/ONLINE PENDING/OFFLINE PENDING status
289  *          values.
290  *
291  ****************************************************************************/
292
293 int get_sysstatus(void)
294 {
295     int     ret_val = ERROR ;
296     char    sys_status[50] = {0};
297     
298     if(SUCCESS == read_string(FILENAME_SYS_STATUS,sys_status,sizeof(sys_status)))
299     {
300         if (memcmp(sys_status, STR_ONLINE_PENDING,strlen(STR_ONLINE_PENDING)) == 0)
301             ret_val = ONLINE_PENDING;
302         else if (memcmp(sys_status, STR_ONLINE, strlen(STR_ONLINE)) == 0)
303             ret_val = ONLINE;
304         else if (memcmp(sys_status, STR_OFFLINE_PENDING,strlen(STR_OFFLINE_PENDING)) == 0)
305             ret_val = OFFLINE_PENDING;
306         else if (memcmp(sys_status, STR_OFFLINE, strlen(STR_OFFLINE)) == 0)
307             ret_val = OFFLINE;
308         else
309             report("%s %s:line %d Bad Contents in file %s \'%s\'", __FILE__,
310                 __FUNCTION__, __LINE__, FILENAME_SYS_STATUS,sys_status);
311     }
312     return ret_val;
313 }
314
315
316 /*****************************************************************************
317  * Function:     read_ulong
318  *
319  * Description:  Read long values from lproc and copy to the location
320  *               pointed by input parameter.
321  *
322  * Input:   file path, and pointer for data to be copied
323  *
324  * Output:  Return ERROR or SUCCESS.
325  *
326  ****************************************************************************/
327
328 int read_ulong(const char *file_path, unsigned long *valuep)
329 {
330     char    file_data[MAX_LINE_SIZE];
331     int     ret_val;
332
333     if ((ret_val = read_string(file_path, file_data,sizeof(file_data))) == SUCCESS){
334         *valuep = strtoul(file_data,NULL,10);
335     }
336     return ret_val;
337 }
338
339 /*****************************************************************************
340  * Function:     read_counter64
341  *
342  * Description:  Read counter64 values from lproc and copy to the location
343  *               pointed by input parameter.
344  *
345  * Input:   file path, and pointer for data to be copied
346  *
347  * Output:  Return ERROR or SUCCESS.
348  *
349  ****************************************************************************/
350
351 int read_counter64(const char *file_path, counter64 *c64,int factor)
352 {
353     char    file_data[MAX_LINE_SIZE];
354     int     ret_val;
355     unsigned long long tmp = 0;
356
357     if ((ret_val = read_string(file_path, file_data,sizeof(file_data))) == SUCCESS) {
358         tmp = atoll(file_data) * factor;
359         c64->low = (unsigned long) (0x0FFFFFFFF & tmp);
360         tmp >>= 32; /* Shift right by 4 bytes */
361         c64->high = (unsigned long) (0x0FFFFFFFF & tmp);
362     }
363     return ret_val;
364 }
365
366 /*****************************************************************************
367  * Function:     get_nth_entry_from_list
368  *
369  * Description:  Find the n'th entry from a null terminated list of string
370  *
371  * Input:   dir_list - the list
372  *          num - the number of elements in the list
373  *          index - the index we are looking for
374  *
375  * Output:  Return NULL on failure, or the string name on success.
376  *
377  ****************************************************************************/
378
379 const char *get_nth_entry_from_list(const char* dir_list,int num,int index)
380 {
381     int i;
382     int cur_ptr = 0;
383     for(i=0;i<num;i++){
384         
385         /* 
386          * if we've reached the end of the list for some reason
387          * because num was wrong then stop processing
388          */
389         if( *(dir_list+cur_ptr) == 0)
390             break;
391             
392         /* If we've found the right one */    
393         if( i == index )
394             return dir_list+cur_ptr;
395             
396         /* Move to the next one*/            
397         cur_ptr += strlen(dir_list + cur_ptr)+1;
398     }
399     return NULL;
400 }
401
402 /*****************************************************************************
403  * Function:    report
404  *
405  * Description: This function used to report error msg to stderr and log into
406  *    log file(default file:/var/log/snmpd.log) when agent is started with
407  *    debug option -Dlsnmpd
408  * Input:   format string and variable arguments.
409  * Output:  void
410  ****************************************************************************/
411
412 void report(const char *fmt, ...)
413 {
414     char buf[1024];
415
416     va_list arg_list;
417     va_start(arg_list, fmt);
418     vsprintf(buf, fmt, arg_list);
419     va_end(arg_list);
420
421     DEBUGMSGTL(("lsnmpd", "%s\n", buf));
422     fprintf(stderr, "%s\n", buf);
423     return;
424 }
425
426
427
428 /**************************************************************************
429  * Function:   oid_table_ulong_handler
430  *
431  * Description: Fetch a unsigned long from the given location.
432  *              Setup var_len, and return a pointer to the data.
433  *
434  * Input:  file_path, and var_len pointer
435  *
436  * Output: NULL on failure, or pointer to data
437  *
438  **************************************************************************/
439
440 unsigned char* 
441     oid_table_ulong_handler(
442         const char* file_path,
443         size_t  *var_len)
444 {
445     static unsigned long ulong_ret;
446     if (SUCCESS != read_ulong(file_path,&ulong_ret))
447         return NULL;
448     *var_len = sizeof(ulong_ret);
449     return  (unsigned char *) &ulong_ret;
450 }
451
452 /**************************************************************************
453  * Function:   oid_table_c64_handler
454  *
455  * Description: Fetch a counter64 from the given location.
456  *              Setup var_len, and return a pointer to the data.
457  *
458  * Input:  file_path, and var_len pointer
459  *
460  * Output: NULL on failure, or pointer to data
461  *
462  **************************************************************************/
463
464 unsigned char* oid_table_c64_handler(const char* file_path,size_t  *var_len)
465 {
466     static counter64 c64;
467     if (SUCCESS != read_counter64(file_path,&c64,1))
468         return NULL;
469     *var_len = sizeof(c64);
470     return (unsigned char *) &c64;
471 }
472
473 /**************************************************************************
474  * Function:   oid_table_c64_kb_handler
475  *
476  * Description: Fetch a counter64 from the given location.
477  *              Setup var_len, and return a pointer to the data.
478  *              Different than oid_table_c64_handler in that
479  *              the original value is multiplied by 1024 before converting
480  *              to a counter64.  (e.g. turn KB into a Byte scaled value)
481  *
482  * Input:  file_path, and var_len pointer
483  *
484  * Output: NULL on failure, or pointer to data
485  *
486  **************************************************************************/
487
488 unsigned char* oid_table_c64_kb_handler(const char* file_path,size_t  *var_len)
489 {
490     static counter64 c64;
491     /* scale by factor of 1024*/
492     if (SUCCESS != read_counter64(file_path,&c64,1024))
493         return NULL;
494     *var_len = sizeof(c64);
495     return (unsigned char *) &c64;
496 }
497
498 /**************************************************************************
499  * Function:   oid_table_obj_name_handler
500  *
501  * Description: Just copy the file_path and return as the output value.
502  *
503  * Input:  file_path, and var_len pointer
504  *
505  * Output: NULL on failure, or pointer to data
506  *
507  **************************************************************************/
508
509 unsigned char* 
510     oid_table_obj_name_handler(
511         const char* file_path,
512         size_t  *var_len)
513 {
514     static unsigned char string[SPRINT_MAX_LEN];
515     *var_len = strlen(file_path);
516     *var_len = MIN_LEN(*var_len, sizeof(string));
517     memcpy(string, file_path, *var_len);
518     return (unsigned char *) string;
519 }
520
521 /**************************************************************************
522  * Function:   oid_table_string_handler
523  *
524  * Description: Fetch a string from the given location.
525  *              Setup var_len, and return a pointer to the data.
526  *
527  * Input:  file_path, and var_len pointer
528  *
529  * Output: NULL on failure, or pointer to data
530  *
531  **************************************************************************/
532
533 unsigned char* 
534     oid_table_string_handler(
535         const char* file_path,
536         size_t  *var_len)
537 {
538     static unsigned char string[SPRINT_MAX_LEN];
539     if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
540         return NULL;
541     *var_len = strlen((char *)string);
542     return (unsigned char *) string;
543 }
544
545
546 /**************************************************************************
547  * Function:   oid_table_is_directory_handler
548  *
549  * Description: Determine if the file_path is a directory.  
550  *              Setup a boolean return value.
551  *              Setup var_len, and return a pointer to the data.
552  *
553  * Input:  file_path, and var_len pointer
554  *
555  * Output: NULL on failure, or pointer to data
556  *
557  **************************************************************************/
558
559 unsigned char* 
560     oid_table_is_directory_handler(
561         const char* file_path,
562         size_t *var_len)
563 {
564     static long long_ret;
565     long_ret =  is_directory(file_path);
566     *var_len = sizeof(long_ret);
567     return (unsigned char *) &long_ret;
568 }
569
570 /**************************************************************************
571  * Function:   var_genericTable
572  *
573  * Description: Handle Table driven OID processing
574  *
575  **************************************************************************/
576
577 unsigned char *
578 var_genericTable(struct variable *vp,
579             oid     *name,
580             size_t  *length,
581             int     exact,
582             size_t  *var_len,
583             WriteMethod **write_method,
584             const char *path,
585             struct oid_table *ptable)
586 {
587     char *dir_list;
588     uint32_t num;
589     int  deviceindex;
590     unsigned char *ret_val = NULL;
591     int i=0;
592     const char* obj_name;
593     
594     
595     /*
596      * Get the list of file.  If there are no elements
597      * return nothing
598      */
599     if( 0 == (dir_list = get_file_list(path, DIR_TYPE, &num)))
600         return NULL;
601
602     /*
603      * Setup the table
604      */
605     if (header_simple_table(vp,name,length,exact,var_len,write_method, num)
606                                                 == MATCH_FAILED )
607         goto cleanup_and_exit;
608
609     /*
610      * The number of the device we're looking at
611      */
612     deviceindex = name[*length - 1] - 1;
613
614     /*
615      * If we couldn't find this element
616      * something must have recently changed return
617      * nothing
618      */
619     if(deviceindex >= num){
620         report("deviceindex=%d exceeds number of elements=%d",deviceindex,num);
621         goto cleanup_and_exit;
622     }
623
624     /*
625      * Fetch the object name from the list
626      */
627     obj_name = get_nth_entry_from_list(dir_list,num,deviceindex);
628     if(obj_name == NULL){
629         /*
630          * Note this should never really happen because we check deviceindex >=num
631          * above.  And dir_list should be consitent with num
632          * but just in case...
633          */
634         report("object name not found in list",deviceindex,num);
635         goto cleanup_and_exit;
636     }
637
638     /*
639      * Find the matching magic - or the end of the list
640      */
641     while(ptable[i].magic != vp->magic && ptable[i].magic != 0)
642         i++;
643
644     /*
645      * If we didn't find a matching entry return
646      */
647     if(ptable[i].magic==0)
648         goto cleanup_and_exit;
649
650     /*
651      * If the name is NULL is a special case and 
652      * just just pass the obj_name as the file_path
653      * otherwise we create a file path from the given components
654      */
655     if(ptable[i].name != 0){
656         char file_path[MAX_PATH_SIZE];
657         sprintf(file_path, "%s%s/%s",path,obj_name,ptable[i].name);
658         ret_val =  ptable[i].fhandler(file_path,var_len);
659     }
660     else
661         ret_val =  ptable[i].fhandler(obj_name,var_len);
662
663 cleanup_and_exit:
664     free(dir_list);
665     return ret_val;
666 };
667
668 /**************************************************************************
669  * Function:   stats_values
670  *
671  * Description: Setup nb_sample, min, max, sum and sum_square stats values
672                 for name_value from filepath.
673  *
674  * Input:  filepath, name_value,
675  *         pointer to nb_sample, min, max, sum, sum_square
676  *
677  * Output: SUCCESS or ERROR on failure
678  *
679  **************************************************************************/
680 int stats_values(char * filepath,char * name_value, unsigned long long * nb_sample, unsigned long long * min, unsigned long long * max, unsigned long long * sum, unsigned long long * sum_square)
681 {
682   FILE * statfile;
683   char line[MAX_LINE_SIZE];
684   int nbReadValues = 0;
685
686   if( (statfile=fopen(filepath,"r")) == NULL) {
687     report("stats_value() failed to open %s",filepath);
688     return ERROR;
689   }
690 /*find the good line for name_value*/
691   do {
692     if( fgets(line,MAX_LINE_SIZE,statfile) == NULL ) {
693       report("stats_values() failed to find %s values in %s stat_file",name_value,statfile);
694       goto error_out;
695     }
696   } while ( strstr(line,name_value) == NULL );
697 /*get stats*/
698   if((nbReadValues=sscanf(line,"%*s %llu %*s %*s %llu %llu %llu %llu",nb_sample,min,max,sum,sum_square)) == 5) {
699     goto success_out;
700   } else if( nbReadValues == 1 && *nb_sample == 0) {
701     *min = *max = *sum = *sum_square = 0;
702     goto success_out;
703   } else {
704     report("stats_values() failed to read stats_values for %s value in %s stat_file",name_value,statfile);
705     goto error_out;
706   }
707
708 success_out :
709   fclose(statfile);
710   return SUCCESS;
711 error_out :
712   fclose(statfile);
713   return ERROR;
714 }
715
716 /**************************************************************************
717  * Function:   mds_stats_values
718  *
719  * Description: Setup nb_sample, min, max, sum and sum_square stats values
720                 for mds stats name_value .
721  *
722  * Input:  name_value,
723  *         pointer to nb_sample, min, max, sum, sum_square
724  *
725  * Output: SUCCESS or ERROR on failure
726  *
727  **************************************************************************/
728 extern int mds_stats_values(char * name_value, unsigned long long * nb_sample, unsigned long long * min, unsigned long long * max, unsigned long long * sum, unsigned long long * sum_square)
729 {
730   unsigned long long tmp_nb_sample=0,tmp_min=0,tmp_max=0,tmp_sum=0,tmp_sum_square=0;
731   glob_t path;
732
733 /*we parse the three MDS stat files and sum values*/
734   if (cfs_get_param_paths(&path, "mdt/MDS/mds/stats") != 0)
735     return ERROR;
736   if( stats_values(path.gl_pathv[0],name_value,&tmp_nb_sample,&tmp_min,&tmp_max,&tmp_sum,&tmp_sum_square) == ERROR ) {
737     cfs_free_param_data(&path);
738     return ERROR;
739   } else {
740     *nb_sample=tmp_nb_sample;
741     *min=tmp_min;
742     *max=tmp_max;
743     *sum=tmp_sum;
744     *sum_square=tmp_sum_square;
745   }
746   cfs_free_param_data(&path);
747
748   if (cfs_get_param_paths(&path, "mdt/MDS/mds_readpage/stats") != 0)
749     return ERROR;
750   if( stats_values(path.gl_pathv[0],name_value,&tmp_nb_sample,&tmp_min,&tmp_max,&tmp_sum,&tmp_sum_square) == ERROR ) {
751     cfs_free_param_data(&path);
752     return ERROR;
753   } else {
754     *nb_sample += tmp_nb_sample;
755     *min += tmp_min;
756     *max += tmp_max;
757     *sum += tmp_sum;
758     *sum_square += tmp_sum_square;
759   }
760   cfs_free_param_data(&path);
761
762   if (cfs_get_param_paths(&path, "mdt/MDS/mds_setattr/stats") != 0)
763     return ERROR;
764   if( stats_values(path.gl_pathv[0],name_value,&tmp_nb_sample,&tmp_min,&tmp_max,&tmp_sum,&tmp_sum_square) == ERROR ) {
765     cfs_free_param_data(&path);
766     return ERROR;
767   } else {
768     *nb_sample += tmp_nb_sample;
769     *min += tmp_min;
770     *max += tmp_max;
771     *sum += tmp_sum;
772     *sum_square += tmp_sum_square;
773   }
774   cfs_free_param_data(&path);
775   
776   return SUCCESS;
777 }
778
779 void convert_ull(counter64 *c64, unsigned long long ull, size_t *var_len)
780 {
781         *var_len  = sizeof(*c64);
782         c64->low  = (unsigned long long) (0x0ffffffff & ull);
783         ull >>= 32;
784         c64->high = (unsigned long long) (0x0ffffffff & ull);
785 }
786