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