snmp/lustre-snmp.c

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