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