snmp/lustre-snmp.c

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