Whamcloud - gitweb
just remove unused macro as i can't get it to work right anyway
[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
92   /* metaDataClients 2.1.5 */
93   { MDCNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,5,1 } },
94
95   /* metaDataClients.mdcTable.mdcEntry 2.1.5.2.1 */
96   { MDCUUID             , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,2 } },
97   { MDCCOMMONNAME       , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,3 } },
98   { MDCMDSSERVERUUID    , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,4 } },
99   { MDCCAPACITY         , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,5 } },
100   { MDCFREECAPACITY     , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,6 } },
101   { MDCOBJECTS          , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,7 } },
102   { MDCFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,8 } },
103
104   /* lustreClients 2.1.6 */
105   { CLIMOUNTNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,6,1 } },
106
107   /* lustreClients.cliMountTable.cliMountEntry 2.1.6.2.1 */
108   { CLIUUID             , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,2 } },
109   { CLICOMMONNAME       , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,3 } },
110   { CLIMDCUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,4 } },
111   { CLIMDCCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,5 } },
112   { CLIUSESLOV          , ASN_INTEGER ,   RONLY , var_cliTable, 6, { 2,1,6,2,1,6 } },
113   { CLILOVUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,7 } },
114   { CLILOVCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,8 } },
115
116   /* logicalObjectVolume 2.1.7 */
117   { LOVNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,7,1 } },
118
119   /* logicalObjectVolume.osdTable.lovTable 2.1.2.2.1 */
120   { LOVUUID             , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,2 } },
121   { LOVCOMMONNAME       , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,3 } },
122   { LOVNUMOBD           , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,4 } },
123   { LOVNUMACTIVEOBD     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,5 } },
124   { LOVCAPACITY         , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,6 } },
125   { LOVFREECAPACITY     , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,7 } },
126   { LOVFILES            , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,8 } },
127   { LOVFREEFILES        , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,9 } },
128   { LOVSTRIPECOUNT      , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,10} },
129   { LOVSTRIPEOFFSET     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,11} },
130   { LOVSTRIPESIZE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,12} },
131   { LOVSTRIPETYPE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,13} },
132
133   /* lustreLDLM 2.1.8 */
134   { LDLMNUMBER          , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,8,1 } },
135
136   /* lustreLDLM.ldlmTable.ldlmEntry 2.1.8.2.1 */
137   { LDLMNAMESPACE       , ASN_OCTET_STR , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,2 } },
138   { LDLMLOCKCOUNT       , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,3 } },
139   { LDLMUNUSEDLOCKCOUNT , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,4 } },
140   { LDLMRESOURCECOUNT   , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,5 } },
141
142 };
143
144 /*****************************************************************************
145  * Function: init_cfsNetSNMPPlugin
146  *
147  * Description: Called when the agent starts up
148  *
149  * Input:   void
150  *
151  * Output:  None
152  *
153  ****************************************************************************/
154  
155 void init_lustresnmp(void) {
156
157   /* register ourselves with the agent to handle our mib tree */
158   REGISTER_MIB("clusterFileSystems", clusterFileSystems_variables, variable7,
159                clusterFileSystems_variables_oid);
160                
161    initilize_trap_handler();
162
163   DEBUGMSGTL(("lsnmpd", "%s %s \n", __FUNCTION__, "Initialization Done"));
164 }
165
166 /*****************************************************************************
167  * Function: deinit_cfsNetSNMPPlugin
168  *
169  * Description: Called when the agent terminates up
170  *
171  * Input:   void
172  *
173  * Output:  None
174  *
175  ****************************************************************************/
176
177 void deinit_lustresnmp(void) {
178
179   /* deregister ourselves with the agent */
180   unregister_mib(clusterFileSystems_variables_oid,
181     sizeof(clusterFileSystems_variables_oid)/sizeof(clusterFileSystems_variables_oid));
182   
183   terminate_trap_handler();
184   
185   DEBUGMSGTL(("lsnmpd", "%s %s \n", __FUNCTION__, "Termination Done"));
186 }
187
188 /*****************************************************************************
189  * Function: var_clusterFileSystems
190  *
191  ****************************************************************************/
192 unsigned char *
193 var_clusterFileSystems(struct variable *vp, 
194                 oid     *name, 
195                 size_t  *length, 
196                 int     exact, 
197                 size_t  *var_len, 
198                 WriteMethod **write_method)
199 {
200
201
202   /* variables we may use later */
203   static long long_ret;
204   static u_long ulong_ret;
205   static unsigned char string[SPRINT_MAX_LEN];
206   char file_path[MAX_PATH_SIZE];
207   uint32_t num;
208   char *dir_list;
209
210   if (header_generic(vp,name,length,exact,var_len,write_method)
211                                   == MATCH_FAILED )
212     return NULL;
213
214
215   /* 
216    * this is where we do the value assignments for the mib results.
217    */
218   switch(vp->magic) {
219
220     case SYSVERSION:
221         sprintf(file_path, "%s%s", LUSTRE_PATH,"version");
222         if( SUCCESS != read_string(file_path, string,sizeof(string)))
223             return NULL;
224         *var_len = strlen(string);
225         return (unsigned char *) string;
226
227     case SYSKERNELVERSION:
228         sprintf(file_path, "%s%s", LUSTRE_PATH,"kernel_version");
229         if( SUCCESS != read_string(file_path, string,sizeof(string)))
230             return NULL;
231         *var_len = strlen(string);
232         return (unsigned char *) string;
233
234     case SYSHEALTHCHECK:
235         sprintf(file_path, "%s%s", LUSTRE_PATH,FILENAME_SYSHEALTHCHECK);
236         if( SUCCESS != read_string(file_path, string,sizeof(string)))
237             return NULL;
238         *var_len = strlen(string);
239         return (unsigned char *) string;
240
241     case SYSSTATUS:
242         *write_method = write_sysStatus;
243         long_ret = (long) get_sysstatus();
244         if (long_ret != ERROR)
245           return (unsigned char *) &long_ret;
246         return NULL;
247                       
248     case OSDNUMBER:
249         if( 0 == (dir_list = get_file_list(OSD_PATH, DIR_TYPE, &num)))
250             return NULL;
251         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSD_PATH,num));  
252         ulong_ret =  num;
253         free(dir_list);
254         return (unsigned char *) &ulong_ret;
255
256     case OSCNUMBER:
257         if( 0 == (dir_list = get_file_list(OSC_PATH, DIR_TYPE, &num)))
258             return NULL;
259         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSC_PATH,num));  
260         ulong_ret =  num;
261         free(dir_list);
262         return (unsigned char *) &ulong_ret;
263
264     case MDDNUMBER:
265         if( 0 == (dir_list = get_file_list(MDS_PATH, DIR_TYPE, &num)))
266             return NULL;
267         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDS_PATH,num));  
268         ulong_ret =  num;
269         free(dir_list);
270         return (unsigned char *) &ulong_ret;
271
272     case MDCNUMBER:
273         if( 0 == (dir_list = get_file_list(MDC_PATH, DIR_TYPE, &num)))
274             return NULL;
275         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDC_PATH,num));  
276         ulong_ret =  num;
277         free(dir_list);
278         return (unsigned char *) &ulong_ret;
279
280     case CLIMOUNTNUMBER:
281         if( 0 == (dir_list = get_file_list(CLIENT_PATH, DIR_TYPE, &num)))
282             return NULL;
283         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",CLIENT_PATH,num));  
284         ulong_ret =  num;
285         free(dir_list);
286         return (unsigned char *) &ulong_ret;
287
288     case LOVNUMBER:
289         if( 0 == (dir_list = get_file_list(LOV_PATH, DIR_TYPE, &num)))
290             return NULL;
291         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LOV_PATH,num));  
292         ulong_ret =  num;
293         free(dir_list);
294         return (unsigned char *) &ulong_ret;
295
296     case LDLMNUMBER:
297         if( 0 == (dir_list = get_file_list(LDLM_PATH, DIR_TYPE, &num)))
298             return NULL;
299         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LDLM_PATH,num));  
300         ulong_ret =  num;
301         free(dir_list);
302         return (unsigned char *) &ulong_ret;
303
304     default:
305       ERROR_MSG("");
306   }
307   return NULL;
308 }
309
310 struct oid_table osd_table[] =
311
312     { OSDUUID,FILENAME_UUID,oid_table_string_handler},
313     { OSDCOMMONNAME,0,oid_table_obj_name_handler},
314     { OSDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
315     { OSDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
316     { OSDOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
317     { OSDFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
318     { 0,0,0 } /*End of table*/
319 };
320
321
322 /*****************************************************************************
323  * Function: var_osdTable
324  *
325  ****************************************************************************/
326 unsigned char *
327 var_osdTable(struct variable *vp,
328             oid     *name,
329             size_t  *length,
330             int     exact,
331             size_t  *var_len,
332             WriteMethod **write_method)
333 {
334     return var_genericTable(vp,name,length,exact,var_len,write_method,
335         OSD_PATH,osd_table);
336 }
337
338 struct oid_table osc_table[] =
339
340     { OSCUUID,FILENAME_UUID,oid_table_string_handler},
341     { OSCCOMMONNAME,0,oid_table_obj_name_handler},
342     { OSCOSTSERVERUUID,"ost_server_uuid",oid_table_string_handler},
343     { OSCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
344     { OSCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
345     { OSCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
346     { OSCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
347     { 0,0,0 } /*End of table*/
348 };
349
350 /*****************************************************************************
351  * Function: var_oscTable
352  *
353  ****************************************************************************/
354 unsigned char *
355 var_oscTable(struct variable *vp,
356             oid     *name,
357             size_t  *length,
358             int     exact,
359             size_t  *var_len,
360             WriteMethod **write_method)
361 {
362     return var_genericTable(vp,name,length,exact,var_len,write_method,
363         OSC_PATH,osc_table);
364 }
365
366 struct oid_table mds_table[] =
367
368     { MDDUUID,FILENAME_UUID,oid_table_string_handler},
369     { MDDCOMMONNAME,0,oid_table_obj_name_handler},
370     { MDDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
371     { MDDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
372     { MDDFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
373     { MDDFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
374     { 0,0,0 } /*End of table*/
375 };
376
377 /*****************************************************************************
378  * Function: var_mdsTable
379  *
380  ****************************************************************************/
381 unsigned char *
382 var_mdsTable(struct variable *vp,
383             oid     *name,
384             size_t  *length,
385             int     exact,
386             size_t  *var_len,
387             WriteMethod **write_method)
388 {
389     return var_genericTable(vp,name,length,exact,var_len,write_method,
390         MDS_PATH,mds_table);
391 }
392
393 struct oid_table mdc_table[] =
394
395     { MDCUUID,FILENAME_UUID,oid_table_string_handler},
396     { MDCCOMMONNAME,0,oid_table_obj_name_handler},
397     { MDCMDSSERVERUUID,"mds_server_uuid",oid_table_string_handler},
398     { MDCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
399     { MDCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
400     { MDCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
401     { MDCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
402     { 0,0,0 } /*End of table*/
403 };
404
405
406 /*****************************************************************************
407  * Function: var_mdcTable
408  *
409  ****************************************************************************/
410 unsigned char *
411 var_mdcTable(struct variable *vp,
412             oid     *name,
413             size_t  *length,
414             int     exact,
415             size_t  *var_len,
416             WriteMethod **write_method)
417 {
418     return var_genericTable(vp,name,length,exact,var_len,write_method,
419         MDC_PATH,mdc_table);
420 }
421
422
423 struct oid_table cli_table[] =
424
425     { CLIUUID,FILENAME_UUID,oid_table_string_handler},
426     { CLICOMMONNAME,0,oid_table_obj_name_handler},
427     { CLIMDCUUID,"mdc/" FILENAME_UUID,oid_table_string_handler},
428     { CLIMDCCOMMONNAME,"mdc/" FILENAME_COMMON_NAME,oid_table_string_handler},
429     { CLIUSESLOV,"lov/",oid_table_is_directory_handler},
430     { CLILOVUUID,"lov/" FILENAME_UUID,oid_table_string_handler},
431     { CLILOVCOMMONNAME,"lov/" FILENAME_COMMON_NAME,oid_table_string_handler},
432     { 0,0,0 } /*End of table*/
433 };
434
435 /*****************************************************************************
436  * Function: var_cliTable
437  *
438  ****************************************************************************/
439 unsigned char *
440 var_cliTable(struct variable *vp,
441             oid     *name,
442             size_t  *length,
443             int     exact,
444             size_t  *var_len,
445             WriteMethod **write_method)
446 {
447     return var_genericTable(vp,name,length,exact,var_len,write_method,
448         CLIENT_PATH,cli_table);
449 }
450
451
452 struct oid_table lov_table[] =
453
454     { LOVUUID,FILENAME_UUID,oid_table_string_handler},
455     { LOVCOMMONNAME,0,oid_table_obj_name_handler},
456     { LOVNUMOBD,"numobd", oid_table_ulong_handler},
457     { LOVNUMACTIVEOBD,"activeobd", oid_table_ulong_handler},
458     { LOVCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
459     { LOVFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
460     { LOVFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
461     { LOVFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
462     { LOVSTRIPECOUNT,"stripecount", oid_table_ulong_handler},
463     { LOVSTRIPEOFFSET,"stripeoffset", oid_table_ulong_handler},
464     { LOVSTRIPESIZE,"stripesize", oid_table_ulong_handler},
465     { LOVSTRIPETYPE,"stripetype", oid_table_ulong_handler},
466     { 0,0,0 } /*End of table*/
467 };
468
469
470 /*****************************************************************************
471  * Function: var_lovTable
472  *
473  ****************************************************************************/
474 unsigned char *
475 var_lovTable(struct variable *vp,
476             oid     *name,
477             size_t  *length,
478             int     exact,
479             size_t  *var_len,
480             WriteMethod **write_method)
481 {
482     return var_genericTable(vp,name,length,exact,var_len,write_method,
483         LOV_PATH,lov_table);
484 }
485
486 struct oid_table ldlm_table[] =
487
488     { LDLMNAMESPACE,0,oid_table_obj_name_handler},
489     { LDLMLOCKCOUNT,"lock_count", oid_table_ulong_handler},
490     { LDLMUNUSEDLOCKCOUNT,"lock_unused_count", oid_table_ulong_handler},
491     { LDLMRESOURCECOUNT,"resource_count", oid_table_ulong_handler},
492     { 0,0,0 } /*End of table*/
493 };
494
495
496 /*****************************************************************************
497  * Function: var_ldlmTable
498  *
499  ****************************************************************************/
500 unsigned char *
501 var_ldlmTable(struct variable *vp,
502             oid     *name,
503             size_t  *length,
504             int     exact,
505             size_t  *var_len,
506             WriteMethod **write_method)
507 {
508     return var_genericTable(vp,name,length,exact,var_len,write_method,
509         LDLM_PATH,ldlm_table);
510 }
511
512
513 /*****************************************************************************
514  * Function: write_sysStatus
515  *
516  ****************************************************************************/
517 int
518 write_sysStatus(int      action,
519             u_char   *var_val,
520             u_char   var_val_type,
521             size_t   var_val_len,
522             u_char   *statP,
523             oid      *name,
524             size_t   name_len)
525 {
526   static long *long_ret;
527   int size;
528   int pid, new_value;
529
530
531
532   switch ( action ) {
533         case RESERVE1:
534           if (var_val_type != ASN_INTEGER){
535               fprintf(stderr, "write to sysStatus not ASN_INTEGER\n");
536               return SNMP_ERR_WRONGTYPE;
537           }
538           if (var_val_len > sizeof(long_ret)){
539               fprintf(stderr,"write to sysStatus: bad length\n");
540               return SNMP_ERR_WRONGLENGTH;
541           }
542           if ((*var_val != ONLINE) &&
543               (*var_val !=  OFFLINE) &&
544               (*var_val !=  RESTART)){
545               report("%s %s:line %d %s", __FILE__, __FUNCTION__, __LINE__,
546                      "sysStatus value is invalid.");
547               return SNMP_ERR_WRONGVALUE;
548           }
549           break;
550
551
552         case RESERVE2:
553           size = var_val_len;
554           long_ret = (long *) var_val;
555
556
557           break;
558
559
560         case FREE:
561              /* Release any resources that have been allocated */
562           break;
563
564
565         case ACTION:
566              /* The variable has been stored in long_ret for
567              you to use, and you have just been asked to do something with
568              it.  Note that anything done here must be reversable in the UNDO case */
569           new_value = *(int *) var_val;
570           switch (new_value) {
571             case ONLINE:
572                 lustrefs_ctrl(ONLINE);
573                 break;
574
575             case OFFLINE:
576                 lustrefs_ctrl(OFFLINE);
577                 break;
578
579             case RESTART:
580                 lustrefs_ctrl(RESTART);
581                 break;
582
583             default:
584                 break;
585           }
586           break;
587
588
589         case UNDO:
590              /* Back out any changes made in the ACTION case */
591           break;
592
593
594         case COMMIT:
595              /* Things are working well, so it's now safe to make the change
596              permanently.  Make sure that anything done here can't fail! */
597           break;
598   }
599   return SNMP_ERR_NOERROR;
600 }
601