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