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