Whamcloud - gitweb
LU-4478 ldiskfs: fix problem when ldiskfs_acct_on() fails
[fs/lustre-release.git] / snmp / lustre-snmp.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  * Copyright (c) 2012, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * snmp/lustre-snmp.c
37  *
38  * Author: PJ Kirner <pjkirner@clusterfs.com>
39  */
40  
41 #include <net-snmp/net-snmp-config.h>
42 #include <net-snmp/net-snmp-includes.h>
43 #include <net-snmp/agent/net-snmp-agent-includes.h>
44 #include <net-snmp/utilities.h>
45 #include <pthread.h>
46 #include "lustre-snmp.h"
47
48 #define LNET_CHECK_INTERVAL 500
49
50 /* 
51  * clusterFileSystems_variables_oid:
52  *   this is the top level oid that we want to register under.  This
53  *   is essentially a prefix, with the suffix appearing in the
54  *   variable below.
55  */
56
57
58 oid clusterFileSystems_variables_oid[] = { 1,3,6,1,4,1,13140 };
59
60
61 /* 
62  * variable7 clusterFileSystems_variables:
63  *   this variable defines function callbacks and type return information 
64  *   for the clusterFileSystems mib section 
65  */
66
67
68 struct variable7 clusterFileSystems_variables[] = {
69 /*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
70
71   /* sytemInformation 2.1.1. */
72   { SYSVERSION          , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,1 } },
73   { SYSKERNELVERSION    , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,2 } },
74   { SYSHEALTHCHECK      , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,3 } },
75   { SYSSTATUS           , ASN_INTEGER   , RWRITE, var_clusterFileSystems, 4, { 2,1,1,4 } },
76
77   /* objectStorageTargets 2.1.2 */
78   { OSDNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,2,1 } },
79
80   /* objectStorageTargets.osdTable.osdEntry 2.1.2.2.1 */
81   { OSDUUID             , ASN_OCTET_STR , RONLY , var_osdTable, 6, { 2,1,2,2,1,2 } },
82   { OSDCOMMONNAME       , ASN_OCTET_STR , RONLY , var_osdTable, 6, { 2,1,2,2,1,3 } },
83   { OSDCAPACITY         , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,4 } },
84   { OSDFREECAPACITY     , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,5 } },
85   { OSDOBJECTS          , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,6 } },
86   { OSDFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,7 } },
87
88   /* objectStorageClients 2.1.3 */
89   { OSCNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,3,1 } },
90
91   /* objectStorageClients.oscTable.oscEntry 2.1.3.2.1 */
92   { OSCUUID             , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,2 } },
93   { OSCCOMMONNAME       , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,3 } },
94   { OSCOSTSERVERUUID    , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,4 } },
95   { OSCCAPACITY         , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,5 } },
96   { OSCFREECAPACITY     , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,6 } },
97   { OSCOBJECTS          , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,7 } },
98   { OSCFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,8 } },
99
100
101   /* metaDataServers 2.1.4 */
102   { MDDNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,4,1 } },
103
104   /* metaDataServers.mddTable.mddEntry 2.1.4.2.1 */
105   { MDDUUID             , ASN_OCTET_STR , RONLY , var_mdsTable, 6, { 2,1,4,2,1,2 } },
106   { MDDCOMMONNAME       , ASN_OCTET_STR , RONLY , var_mdsTable, 6, { 2,1,4,2,1,3 } },
107   { MDDCAPACITY         , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,4 } },
108   { MDDFREECAPACITY     , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,5 } },
109   { MDDFILES            , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,6 } },
110   { MDDFREEFILES        , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,7 } },
111   { MDSNBSAMPLEDREQ     , ASN_COUNTER64 , RONLY , var_mdsNbSampledReq, 4, { 2,1,4,3 } },
112
113   /* metaDataClients 2.1.5 */
114   { MDCNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,5,1 } },
115
116   /* metaDataClients.mdcTable.mdcEntry 2.1.5.2.1 */
117   { MDCUUID             , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,2 } },
118   { MDCCOMMONNAME       , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,3 } },
119   { MDCMDSSERVERUUID    , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,4 } },
120   { MDCCAPACITY         , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,5 } },
121   { MDCFREECAPACITY     , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,6 } },
122   { MDCOBJECTS          , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,7 } },
123   { MDCFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,8 } },
124
125   /* lustreClients 2.1.6 */
126   { CLIMOUNTNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,6,1 } },
127
128   /* lustreClients.cliMountTable.cliMountEntry 2.1.6.2.1 */
129   { CLIUUID             , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,2 } },
130   { CLICOMMONNAME       , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,3 } },
131   { CLIMDCUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,4 } },
132   { CLIMDCCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,5 } },
133   { CLIUSESLOV          , ASN_INTEGER ,   RONLY , var_cliTable, 6, { 2,1,6,2,1,6 } },
134   { CLILOVUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,7 } },
135   { CLILOVCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,8 } },
136
137   /* logicalObjectVolume 2.1.7 */
138   { LOVNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,7,1 } },
139
140   /* logicalObjectVolume.osdTable.lovTable 2.1.7.2.1 */
141   { LOVUUID             , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,2 } },
142   { LOVCOMMONNAME       , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,3 } },
143   { LOVNUMOBD           , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,4 } },
144   { LOVNUMACTIVEOBD     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,5 } },
145   { LOVCAPACITY         , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,6 } },
146   { LOVFREECAPACITY     , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,7 } },
147   { LOVFILES            , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,8 } },
148   { LOVFREEFILES        , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,9 } },
149   { LOVSTRIPECOUNT      , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,10} },
150   { LOVSTRIPEOFFSET     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,11} },
151   { LOVSTRIPESIZE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,12} },
152   { LOVSTRIPETYPE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,13} },
153
154   /* lustreLDLM 2.1.8 */
155   { LDLMNUMBER          , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,8,1 } },
156
157   /* lustreLDLM.ldlmTable.ldlmEntry 2.1.8.2.1 */
158   { LDLMNAMESPACE       , ASN_OCTET_STR , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,2 } },
159   { LDLMLOCKCOUNT       , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,3 } },
160   { LDLMUNUSEDLOCKCOUNT , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,4 } },
161   { LDLMRESOURCECOUNT   , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,5 } },
162
163   /* lnetInformation 2.1.9 */
164   { LNETMSGSALLOC,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,1 } },
165   { LNETMSGSMAX,    ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,2 } },
166   { LNETERRORS,     ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,3 } },
167   { LNETSENDCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,4 } },
168   { LNETRECVCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,5 } },
169   { LNETROUTECOUNT, ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,6 } },
170   { LNETDROPCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,7 } },
171   { LNETSENDBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,8 } },
172   { LNETRECVBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,9 } },
173   { LNETROUTEBYTES, ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,10 } },
174   { LNETDROPBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,11 } },
175 };
176
177 /*****************************************************************************
178  * Function: init_cfsNetSNMPPlugin
179  *
180  * Description: Called when the agent starts up
181  *
182  * Input:   void
183  *
184  * Output:  None
185  *
186  ****************************************************************************/
187  
188 void init_lustresnmp(void) {
189
190   /* register ourselves with the agent to handle our mib tree */
191   REGISTER_MIB("clusterFileSystems", clusterFileSystems_variables, variable7,
192                clusterFileSystems_variables_oid);
193                
194    initilize_trap_handler();
195
196   DEBUGMSGTL(("lsnmpd", "%s %s \n", __FUNCTION__, "Initialization Done"));
197 }
198
199 /*****************************************************************************
200  * Function: deinit_cfsNetSNMPPlugin
201  *
202  * Description: Called when the agent terminates up
203  *
204  * Input:   void
205  *
206  * Output:  None
207  *
208  ****************************************************************************/
209
210 void deinit_lustresnmp(void) {
211
212   /* deregister ourselves with the agent */
213   unregister_mib(clusterFileSystems_variables_oid,
214     sizeof(clusterFileSystems_variables_oid)/sizeof(clusterFileSystems_variables_oid));
215   
216   terminate_trap_handler();
217   
218   DEBUGMSGTL(("lsnmpd", "%s %s \n", __FUNCTION__, "Termination Done"));
219 }
220
221 /*****************************************************************************
222  * Function: var_clusterFileSystems
223  *
224  ****************************************************************************/
225 unsigned char *
226 var_clusterFileSystems(struct variable *vp, 
227                 oid     *name, 
228                 size_t  *length, 
229                 int     exact, 
230                 size_t  *var_len, 
231                 WriteMethod **write_method)
232 {
233
234
235   /* variables we may use later */
236   static long long_ret;
237   static u_long ulong_ret;
238   static unsigned char string[SPRINT_MAX_LEN];
239   char file_path[MAX_PATH_SIZE];
240   uint32_t num;
241   char *dir_list;
242
243   if (header_generic(vp,name,length,exact,var_len,write_method)
244                                   == MATCH_FAILED )
245     return NULL;
246
247
248   /* 
249    * this is where we do the value assignments for the mib results.
250    */
251   switch(vp->magic) {
252
253     case SYSVERSION:
254         sprintf(file_path, "%s%s", LUSTRE_PATH,"version");
255         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
256             return NULL;
257         *var_len = strlen((char *)string);
258         return (unsigned char *) string;
259
260     case SYSKERNELVERSION:
261         sprintf(file_path, "%s%s", LUSTRE_PATH,"kernel_version");
262         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
263             return NULL;
264         *var_len = strlen((char *)string);
265         return (unsigned char *) string;
266
267     case SYSHEALTHCHECK:
268         sprintf(file_path, "%s%s", LUSTRE_PATH,FILENAME_SYSHEALTHCHECK);
269         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
270             return NULL;
271         *var_len = strlen((char*)string);
272         return (unsigned char *) string;
273
274     case SYSSTATUS:
275         *write_method = write_sysStatus;
276         long_ret = (long) get_sysstatus();
277         if (long_ret != ERROR)
278           return (unsigned char *) &long_ret;
279         return NULL;
280                       
281     case OSDNUMBER:
282         if( 0 == (dir_list = get_file_list(OSD_PATH, DIR_TYPE, &num)))
283             return NULL;
284         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSD_PATH,num));  
285         ulong_ret =  num;
286         free(dir_list);
287         return (unsigned char *) &ulong_ret;
288
289     case OSCNUMBER:
290         if( 0 == (dir_list = get_file_list(OSC_PATH, DIR_TYPE, &num)))
291             return NULL;
292         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSC_PATH,num));  
293         ulong_ret =  num;
294         free(dir_list);
295         return (unsigned char *) &ulong_ret;
296
297     case MDDNUMBER:
298         if( 0 == (dir_list = get_file_list(MDS_PATH, DIR_TYPE, &num)))
299             return NULL;
300         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDS_PATH,num));  
301         ulong_ret =  num;
302         free(dir_list);
303         return (unsigned char *) &ulong_ret;
304
305     case MDCNUMBER:
306         if( 0 == (dir_list = get_file_list(MDC_PATH, DIR_TYPE, &num)))
307             return NULL;
308         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDC_PATH,num));  
309         ulong_ret =  num;
310         free(dir_list);
311         return (unsigned char *) &ulong_ret;
312
313     case CLIMOUNTNUMBER:
314         if( 0 == (dir_list = get_file_list(CLIENT_PATH, DIR_TYPE, &num)))
315             return NULL;
316         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",CLIENT_PATH,num));  
317         ulong_ret =  num;
318         free(dir_list);
319         return (unsigned char *) &ulong_ret;
320
321     case LOVNUMBER:
322         if( 0 == (dir_list = get_file_list(LOV_PATH, DIR_TYPE, &num)))
323             return NULL;
324         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LOV_PATH,num));  
325         ulong_ret =  num;
326         free(dir_list);
327         return (unsigned char *) &ulong_ret;
328
329     case LDLMNUMBER:
330         if( 0 == (dir_list = get_file_list(LDLM_PATH, DIR_TYPE, &num)))
331             return NULL;
332         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LDLM_PATH,num));  
333         ulong_ret =  num;
334         free(dir_list);
335         return (unsigned char *) &ulong_ret;
336
337     default:
338       ERROR_MSG("");
339   }
340   return NULL;
341 }
342
343 struct oid_table osd_table[] =
344
345     { OSDUUID,FILENAME_UUID,oid_table_string_handler},
346     { OSDCOMMONNAME,0,oid_table_obj_name_handler},
347     { OSDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
348     { OSDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
349     { OSDOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
350     { OSDFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
351     { 0,0,0 } /*End of table*/
352 };
353
354
355 /*****************************************************************************
356  * Function: var_osdTable
357  *
358  ****************************************************************************/
359 unsigned char *
360 var_osdTable(struct variable *vp,
361             oid     *name,
362             size_t  *length,
363             int     exact,
364             size_t  *var_len,
365             WriteMethod **write_method)
366 {
367     return var_genericTable(vp,name,length,exact,var_len,write_method,
368         OSD_PATH,osd_table);
369 }
370
371 struct oid_table osc_table[] =
372
373     { OSCUUID,FILENAME_UUID,oid_table_string_handler},
374     { OSCCOMMONNAME,0,oid_table_obj_name_handler},
375     { OSCOSTSERVERUUID,"ost_server_uuid",oid_table_string_handler},
376     { OSCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
377     { OSCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
378     { OSCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
379     { OSCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
380     { 0,0,0 } /*End of table*/
381 };
382
383 /*****************************************************************************
384  * Function: var_oscTable
385  *
386  ****************************************************************************/
387 unsigned char *
388 var_oscTable(struct variable *vp,
389             oid     *name,
390             size_t  *length,
391             int     exact,
392             size_t  *var_len,
393             WriteMethod **write_method)
394 {
395     return var_genericTable(vp,name,length,exact,var_len,write_method,
396         OSC_PATH,osc_table);
397 }
398
399 struct oid_table mds_table[] =
400
401     { MDDUUID,FILENAME_UUID,oid_table_string_handler},
402     { MDDCOMMONNAME,0,oid_table_obj_name_handler},
403     { MDDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
404     { MDDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
405     { MDDFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
406     { MDDFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
407     { 0,0,0 } /*End of table*/
408 };
409
410 /*****************************************************************************
411  * Function: var_mdsTable
412  *
413  ****************************************************************************/
414 unsigned char *
415 var_mdsTable(struct variable *vp,
416             oid     *name,
417             size_t  *length,
418             int     exact,
419             size_t  *var_len,
420             WriteMethod **write_method)
421 {
422     return var_genericTable(vp,name,length,exact,var_len,write_method,
423         MDS_PATH,mds_table);
424 }
425
426 struct oid_table mdc_table[] =
427
428     { MDCUUID,FILENAME_UUID,oid_table_string_handler},
429     { MDCCOMMONNAME,0,oid_table_obj_name_handler},
430     { MDCMDSSERVERUUID,"mds_server_uuid",oid_table_string_handler},
431     { MDCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
432     { MDCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
433     { MDCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
434     { MDCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
435     { 0,0,0 } /*End of table*/
436 };
437
438
439 /*****************************************************************************
440  * Function: var_mdcTable
441  *
442  ****************************************************************************/
443 unsigned char *
444 var_mdcTable(struct variable *vp,
445             oid     *name,
446             size_t  *length,
447             int     exact,
448             size_t  *var_len,
449             WriteMethod **write_method)
450 {
451     return var_genericTable(vp,name,length,exact,var_len,write_method,
452         MDC_PATH,mdc_table);
453 }
454
455
456 struct oid_table cli_table[] =
457
458     { CLIUUID,FILENAME_UUID,oid_table_string_handler},
459     { CLICOMMONNAME,0,oid_table_obj_name_handler},
460     { CLIMDCUUID,"mdc/" FILENAME_UUID,oid_table_string_handler},
461     { CLIMDCCOMMONNAME,"mdc/" FILENAME_COMMON_NAME,oid_table_string_handler},
462     { CLIUSESLOV,"lov/",oid_table_is_directory_handler},
463     { CLILOVUUID,"lov/" FILENAME_UUID,oid_table_string_handler},
464     { CLILOVCOMMONNAME,"lov/" FILENAME_COMMON_NAME,oid_table_string_handler},
465     { 0,0,0 } /*End of table*/
466 };
467
468 /*****************************************************************************
469  * Function: var_cliTable
470  *
471  ****************************************************************************/
472 unsigned char *
473 var_cliTable(struct variable *vp,
474             oid     *name,
475             size_t  *length,
476             int     exact,
477             size_t  *var_len,
478             WriteMethod **write_method)
479 {
480     return var_genericTable(vp,name,length,exact,var_len,write_method,
481         CLIENT_PATH,cli_table);
482 }
483
484
485 struct oid_table lov_table[] =
486
487     { LOVUUID,FILENAME_UUID,oid_table_string_handler},
488     { LOVCOMMONNAME,0,oid_table_obj_name_handler},
489     { LOVNUMOBD,"numobd", oid_table_ulong_handler},
490     { LOVNUMACTIVEOBD,"activeobd", oid_table_ulong_handler},
491     { LOVCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
492     { LOVFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
493     { LOVFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
494     { LOVFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
495     { LOVSTRIPECOUNT,"stripecount", oid_table_ulong_handler},
496     { LOVSTRIPEOFFSET,"stripeoffset", oid_table_ulong_handler},
497     { LOVSTRIPESIZE,"stripesize", oid_table_ulong_handler},
498     { LOVSTRIPETYPE,"stripetype", oid_table_ulong_handler},
499     { 0,0,0 } /*End of table*/
500 };
501
502
503 /*****************************************************************************
504  * Function: var_lovTable
505  *
506  ****************************************************************************/
507 unsigned char *
508 var_lovTable(struct variable *vp,
509             oid     *name,
510             size_t  *length,
511             int     exact,
512             size_t  *var_len,
513             WriteMethod **write_method)
514 {
515     return var_genericTable(vp,name,length,exact,var_len,write_method,
516         LOV_PATH,lov_table);
517 }
518
519 struct oid_table ldlm_table[] =
520
521     { LDLMNAMESPACE,0,oid_table_obj_name_handler},
522     { LDLMLOCKCOUNT,"lock_count", oid_table_ulong_handler},
523     { LDLMUNUSEDLOCKCOUNT,"lock_unused_count", oid_table_ulong_handler},
524     { LDLMRESOURCECOUNT,"resource_count", oid_table_ulong_handler},
525     { 0,0,0 } /*End of table*/
526 };
527
528
529 /*****************************************************************************
530  * Function: var_ldlmTable
531  *
532  ****************************************************************************/
533 unsigned char *
534 var_ldlmTable(struct variable *vp,
535             oid     *name,
536             size_t  *length,
537             int     exact,
538             size_t  *var_len,
539             WriteMethod **write_method)
540 {
541     return var_genericTable(vp,name,length,exact,var_len,write_method,
542         LDLM_PATH,ldlm_table);
543 }
544
545 /*****************************************************************************
546  * Function: var_lnetInformation
547  *
548  ****************************************************************************/
549 unsigned char *
550 var_lnetInformation(struct variable *vp,
551                     oid             *name,
552                     size_t          *length,
553                     int              exact,
554                     size_t          *var_len,
555                     WriteMethod    **write_method)
556 {
557         /* variables we may use later */
558         static unsigned char      string[SPRINT_MAX_LEN];
559         static unsigned int       i[7];
560         static unsigned long long ull[4];
561         static unsigned long      next_update;
562         static counter64          c64;
563         static unsigned int       c32;
564         struct timeval            current_tv;
565         unsigned long             current;
566         char                      file_path[MAX_PATH_SIZE];
567
568         /* Update at most every LNET_STATS_INTERVAL milliseconds */
569         gettimeofday(&current_tv, NULL);
570         current = current_tv.tv_sec * 1000000 + current_tv.tv_usec;
571         if (current >= next_update) {
572                 sprintf(file_path, "%s%s", LNET_PATH, "stats");
573                 if (read_string(file_path, (char *) string, sizeof(string))
574                     != SUCCESS)
575                         return NULL;
576
577                 sscanf((char *) string,
578                        "%u %u %u %u %u %u %u %llu %llu %llu %llu",
579                        &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6],
580                        &ull[0], &ull[1], &ull[2], &ull[3]);
581
582                 next_update = current + (LNET_CHECK_INTERVAL * 1000);
583         }
584
585         if (header_generic(vp, name, length, exact, var_len, write_method)
586             == MATCH_FAILED)
587                 return NULL;
588
589         switch (vp->magic) {
590         case LNETMSGSALLOC:
591                 *var_len = sizeof(c32);
592                 c32 = i[0];
593                 return (unsigned char *) &c32;
594         case LNETMSGSMAX:
595                 *var_len = sizeof(c32);
596                 c32 = i[1];
597                 return (unsigned char *) &c32;
598         case LNETERRORS:
599                 *var_len = sizeof(c32);
600                 c32 = i[2];
601                 return (unsigned char *) &c32;
602         case LNETSENDCOUNT:
603                 *var_len = sizeof(c32);
604                 c32 = i[3];
605                 return (unsigned char *) &c32;
606         case LNETRECVCOUNT:
607                 *var_len = sizeof(c32);
608                 c32 = i[4];
609                 return (unsigned char *) &c32;
610         case LNETROUTECOUNT:
611                 *var_len = sizeof(c32);
612                 c32 = i[5];
613                 return (unsigned char *) &c32;
614         case LNETDROPCOUNT:
615                 *var_len = sizeof(c32);
616                 c32 = i[6];
617                 return (unsigned char *) &c32;
618         case LNETSENDBYTES:
619                 convert_ull(&c64, ull[0], var_len);
620                 return (unsigned char *) &c64;
621         case LNETRECVBYTES:
622                 convert_ull(&c64, ull[1], var_len);
623                 return (unsigned char *) &c64;
624         case LNETROUTEBYTES:
625                 convert_ull(&c64, ull[2], var_len);
626                 return (unsigned char *) &c64;
627         case LNETDROPBYTES:
628                 convert_ull(&c64, ull[3], var_len);
629                 return (unsigned char *) &c64;
630         default:
631                 return NULL;
632         }
633 }
634
635 /*****************************************************************************
636  * Function: var_mdsNbSampledReq
637  *
638  ****************************************************************************/
639 unsigned char *
640 var_mdsNbSampledReq(struct variable *vp,
641             oid     *name,
642             size_t  *length,
643             int     exact,
644             size_t  *var_len,
645             WriteMethod **write_method)
646 {
647   unsigned long long nb_sample=0,min=0,max=0,sum=0,sum_square=0;
648   static counter64 c64;
649
650   if (header_generic(vp,name,length,exact,var_len,write_method)
651                                   == MATCH_FAILED )
652     return NULL;
653
654   if( mds_stats_values(STR_REQ_WAITIME,&nb_sample,&min,&max,&sum,&sum_square) == ERROR) return NULL;
655
656   c64.low = (u_long) (0x0FFFFFFFF & nb_sample);
657   nb_sample >>= 32;
658   c64.high = (u_long) (0x0FFFFFFFF & nb_sample);
659
660   *var_len = sizeof(c64);
661   return (unsigned char *) &c64;
662 }
663
664
665 /*****************************************************************************
666  * Function: write_sysStatus
667  *
668  ****************************************************************************/
669 int
670 write_sysStatus(int      action,
671             u_char   *var_val,
672             u_char   var_val_type,
673             size_t   var_val_len,
674             u_char   *statP,
675             oid      *name,
676             size_t   name_len)
677 {
678   static long *long_ret;
679   int new_value;
680
681
682
683   switch ( action ) {
684         case RESERVE1:
685           if (var_val_type != ASN_INTEGER){
686               fprintf(stderr, "write to sysStatus not ASN_INTEGER\n");
687               return SNMP_ERR_WRONGTYPE;
688           }
689           if (var_val_len > sizeof(long_ret)){
690               fprintf(stderr,"write to sysStatus: bad length\n");
691               return SNMP_ERR_WRONGLENGTH;
692           }
693           if ((*var_val != ONLINE) &&
694               (*var_val !=  OFFLINE) &&
695               (*var_val !=  RESTART)){
696               report("%s %s:line %d %s", __FILE__, __FUNCTION__, __LINE__,
697                      "sysStatus value is invalid.");
698               return SNMP_ERR_WRONGVALUE;
699           }
700           break;
701
702
703         case RESERVE2:
704           long_ret = (long *) var_val;
705
706
707           break;
708
709
710         case FREE:
711              /* Release any resources that have been allocated */
712           break;
713
714
715         case ACTION:
716              /* The variable has been stored in long_ret for
717              you to use, and you have just been asked to do something with
718              it.  Note that anything done here must be reversable in the UNDO case */
719           new_value = *(int *) var_val;
720           switch (new_value) {
721             case ONLINE:
722                 lustrefs_ctrl(ONLINE);
723                 break;
724
725             case OFFLINE:
726                 lustrefs_ctrl(OFFLINE);
727                 break;
728
729             case RESTART:
730                 lustrefs_ctrl(RESTART);
731                 break;
732
733             default:
734                 break;
735           }
736           break;
737
738
739         case UNDO:
740              /* Back out any changes made in the ACTION case */
741           break;
742
743
744         case COMMIT:
745              /* Things are working well, so it's now safe to make the change
746              permanently.  Make sure that anything done here can't fail! */
747           break;
748   }
749   return SNMP_ERR_NOERROR;
750 }