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