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  * Copyright (c) 2012, Intel Corporation.
  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 #define LNET_CHECK_INTERVAL 500
  49
  50 /*
  51  * clusterFileSystems_variables_oid:
  52  *   this is the top level oid that we want to register under.  This
  53  *   is essentially a prefix, with the suffix appearing in the
  54  *   variable below.
  55  */
  56
  57
  58 oid clusterFileSystems_variables_oid[] = { 1,3,6,1,4,1,13140 };
  59
  60
  61 /*
  62  * variable7 clusterFileSystems_variables:
  63  *   this variable defines function callbacks and type return information
  64  *   for the clusterFileSystems mib section
  65  */
  66
  67
  68 struct variable7 clusterFileSystems_variables[] = {
  69 /*  magic number        , variable type , ro/rw , callback fn  , L, oidsuffix */
  70
  71   /* sytemInformation 2.1.1. */
  72   { SYSVERSION          , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,1 } },
  73   { SYSKERNELVERSION    , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,2 } },
  74   { SYSHEALTHCHECK      , ASN_OCTET_STR , RONLY , var_clusterFileSystems, 4, { 2,1,1,3 } },
  75   { SYSSTATUS           , ASN_INTEGER   , RWRITE, var_clusterFileSystems, 4, { 2,1,1,4 } },
  76
  77   /* objectStorageTargets 2.1.2 */
  78   { OSDNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,2,1 } },
  79
  80   /* objectStorageTargets.osdTable.osdEntry 2.1.2.2.1 */
  81   { OSDUUID             , ASN_OCTET_STR , RONLY , var_osdTable, 6, { 2,1,2,2,1,2 } },
  82   { OSDCOMMONNAME       , ASN_OCTET_STR , RONLY , var_osdTable, 6, { 2,1,2,2,1,3 } },
  83   { OSDCAPACITY         , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,4 } },
  84   { OSDFREECAPACITY     , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,5 } },
  85   { OSDOBJECTS          , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,6 } },
  86   { OSDFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_osdTable, 6, { 2,1,2,2,1,7 } },
  87
  88   /* objectStorageClients 2.1.3 */
  89   { OSCNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,3,1 } },
  90
  91   /* objectStorageClients.oscTable.oscEntry 2.1.3.2.1 */
  92   { OSCUUID             , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,2 } },
  93   { OSCCOMMONNAME       , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,3 } },
  94   { OSCOSTSERVERUUID    , ASN_OCTET_STR , RONLY , var_oscTable, 6, { 2,1,3,2,1,4 } },
  95   { OSCCAPACITY         , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,5 } },
  96   { OSCFREECAPACITY     , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,6 } },
  97   { OSCOBJECTS          , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,7 } },
  98   { OSCFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_oscTable, 6, { 2,1,3,2,1,8 } },
  99
 100
 101   /* metaDataServers 2.1.4 */
 102   { MDDNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,4,1 } },
 103
 104   /* metaDataServers.mddTable.mddEntry 2.1.4.2.1 */
 105   { MDDUUID             , ASN_OCTET_STR , RONLY , var_mdsTable, 6, { 2,1,4,2,1,2 } },
 106   { MDDCOMMONNAME       , ASN_OCTET_STR , RONLY , var_mdsTable, 6, { 2,1,4,2,1,3 } },
 107   { MDDCAPACITY         , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,4 } },
 108   { MDDFREECAPACITY     , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,5 } },
 109   { MDDFILES            , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,6 } },
 110   { MDDFREEFILES        , ASN_COUNTER64 , RONLY , var_mdsTable, 6, { 2,1,4,2,1,7 } },
 111   { MDSNBSAMPLEDREQ     , ASN_COUNTER64 , RONLY , var_mdsNbSampledReq, 4, { 2,1,4,3 } },
 112
 113   /* metaDataClients 2.1.5 */
 114   { MDCNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,5,1 } },
 115
 116   /* metaDataClients.mdcTable.mdcEntry 2.1.5.2.1 */
 117   { MDCUUID             , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,2 } },
 118   { MDCCOMMONNAME       , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,3 } },
 119   { MDCMDSSERVERUUID    , ASN_OCTET_STR , RONLY , var_mdcTable, 6, { 2,1,5,2,1,4 } },
 120   { MDCCAPACITY         , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,5 } },
 121   { MDCFREECAPACITY     , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,6 } },
 122   { MDCOBJECTS          , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,7 } },
 123   { MDCFREEOBJECTS      , ASN_COUNTER64 , RONLY , var_mdcTable, 6, { 2,1,5,2,1,8 } },
 124
 125   /* lustreClients 2.1.6 */
 126   { CLIMOUNTNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,6,1 } },
 127
 128   /* lustreClients.cliMountTable.cliMountEntry 2.1.6.2.1 */
 129   { CLIUUID             , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,2 } },
 130   { CLICOMMONNAME       , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,3 } },
 131   { CLIMDCUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,4 } },
 132   { CLIMDCCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,5 } },
 133   { CLIUSESLOV          , ASN_INTEGER ,   RONLY , var_cliTable, 6, { 2,1,6,2,1,6 } },
 134   { CLILOVUUID          , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,7 } },
 135   { CLILOVCOMMONNAME    , ASN_OCTET_STR , RONLY , var_cliTable, 6, { 2,1,6,2,1,8 } },
 136
 137   /* logicalObjectVolume 2.1.7 */
 138   { LOVNUMBER           , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,7,1 } },
 139
 140   /* logicalObjectVolume.osdTable.lovTable 2.1.7.2.1 */
 141   { LOVUUID             , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,2 } },
 142   { LOVCOMMONNAME       , ASN_OCTET_STR , RONLY , var_lovTable, 6, { 2,1,7,2,1,3 } },
 143   { LOVNUMOBD           , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,4 } },
 144   { LOVNUMACTIVEOBD     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,5 } },
 145   { LOVCAPACITY         , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,6 } },
 146   { LOVFREECAPACITY     , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,7 } },
 147   { LOVFILES            , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,8 } },
 148   { LOVFREEFILES        , ASN_COUNTER64 , RONLY , var_lovTable, 6, { 2,1,7,2,1,9 } },
 149   { LOVSTRIPECOUNT      , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,10} },
 150   { LOVSTRIPEOFFSET     , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,11} },
 151   { LOVSTRIPESIZE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,12} },
 152   { LOVSTRIPETYPE       , ASN_UNSIGNED ,  RONLY , var_lovTable, 6, { 2,1,7,2,1,13} },
 153
 154   /* lustreLDLM 2.1.8 */
 155   { LDLMNUMBER          , ASN_UNSIGNED  , RONLY , var_clusterFileSystems, 4, { 2,1,8,1 } },
 156
 157   /* lustreLDLM.ldlmTable.ldlmEntry 2.1.8.2.1 */
 158   { LDLMNAMESPACE       , ASN_OCTET_STR , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,2 } },
 159   { LDLMLOCKCOUNT       , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,3 } },
 160   { LDLMUNUSEDLOCKCOUNT , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,4 } },
 161   { LDLMRESOURCECOUNT   , ASN_UNSIGNED  , RONLY , var_ldlmTable, 6, { 2,1,8,2,1,5 } },
 162
 163   /* lnetInformation 2.1.9 */
 164   { LNETMSGSALLOC,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,1 } },
 165   { LNETMSGSMAX,    ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,2 } },
 166   { LNETERRORS,     ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,3 } },
 167   { LNETSENDCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,4 } },
 168   { LNETRECVCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,5 } },
 169   { LNETROUTECOUNT, ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,6 } },
 170   { LNETDROPCOUNT,  ASN_UNSIGNED,  RONLY, var_lnetInformation, 4, { 2,1,9,7 } },
 171   { LNETSENDBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,8 } },
 172   { LNETRECVBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,9 } },
 173   { LNETROUTEBYTES, ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,10 } },
 174   { LNETDROPBYTES,  ASN_COUNTER64, RONLY, var_lnetInformation, 4, { 2,1,9,11 } },
 175 };
 176
 177 /*****************************************************************************
 178  * Function: init_cfsNetSNMPPlugin
 179  *
 180  * Description: Called when the agent starts up
 181  *
 182  * Input:   void
 183  *
 184  * Output:  None
 185  *
 186  ****************************************************************************/
 187
 188 void init_lustresnmp(void) {
 189
 190         /* register ourselves with the agent to handle our mib tree */
 191         REGISTER_MIB("clusterFileSystems",
 192                      clusterFileSystems_variables, variable7,
 193                      clusterFileSystems_variables_oid);
 194
 195         initialize_trap_handler();
 196
 197         DEBUGMSGTL(("lsnmpd", "%s %s\n", __func__, "Initialization Done"));
 198 }
 199
 200 /*****************************************************************************
 201  * Function: deinit_cfsNetSNMPPlugin
 202  *
 203  * Description: Called when the agent terminates up
 204  *
 205  * Input:   void
 206  *
 207  * Output:  None
 208  *
 209  ****************************************************************************/
 210
 211 void deinit_lustresnmp(void) {
 212
 213         /* deregister ourselves with the agent */
 214         unregister_mib(clusterFileSystems_variables_oid,
 215                        sizeof(clusterFileSystems_variables_oid)/
 216                        sizeof(clusterFileSystems_variables_oid));
 217
 218         terminate_trap_handler();
 219
 220         DEBUGMSGTL(("lsnmpd", "%s %s\n", __func__, "Termination Done"));
 221 }
 222
 223 /*****************************************************************************
 224  * Function: var_clusterFileSystems
 225  *
 226  ****************************************************************************/
 227 unsigned char *
 228 var_clusterFileSystems(struct variable *vp,
 229                 oid     *name,
 230                 size_t  *length,
 231                 int     exact,
 232                 size_t  *var_len,
 233                 WriteMethod **write_method)
 234 {
 235
 236
 237   /* variables we may use later */
 238   static long long_ret;
 239   static u_long ulong_ret;
 240   static unsigned char string[SPRINT_MAX_LEN];
 241   char file_path[MAX_PATH_SIZE];
 242   uint32_t num;
 243   char *dir_list;
 244
 245   if (header_generic(vp,name,length,exact,var_len,write_method)
 246                                   == MATCH_FAILED )
 247     return NULL;
 248
 249
 250   /*
 251    * this is where we do the value assignments for the mib results.
 252    */
 253   switch(vp->magic) {
 254
 255     case SYSVERSION:
 256         sprintf(file_path, "%s%s", LUSTRE_PATH,"version");
 257         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
 258             return NULL;
 259         *var_len = strlen((char *)string);
 260         return (unsigned char *) string;
 261
 262     case SYSKERNELVERSION:
 263         sprintf(file_path, "%s%s", LUSTRE_PATH,"kernel_version");
 264         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
 265             return NULL;
 266         *var_len = strlen((char *)string);
 267         return (unsigned char *) string;
 268
 269     case SYSHEALTHCHECK:
 270         sprintf(file_path, "%s%s", LUSTRE_PATH,FILENAME_SYSHEALTHCHECK);
 271         if( SUCCESS != read_string(file_path, (char *)string,sizeof(string)))
 272             return NULL;
 273         *var_len = strlen((char*)string);
 274         return (unsigned char *) string;
 275
 276     case SYSSTATUS:
 277         *write_method = write_sysStatus;
 278         long_ret = (long) get_sysstatus();
 279         if (long_ret != ERROR)
 280           return (unsigned char *) &long_ret;
 281         return NULL;
 282
 283     case OSDNUMBER:
 284         if( 0 == (dir_list = get_file_list(OSD_PATH, DIR_TYPE, &num)))
 285             return NULL;
 286         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSD_PATH,num));
 287         ulong_ret =  num;
 288         free(dir_list);
 289         return (unsigned char *) &ulong_ret;
 290
 291     case OSCNUMBER:
 292         if( 0 == (dir_list = get_file_list(OSC_PATH, DIR_TYPE, &num)))
 293             return NULL;
 294         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",OSC_PATH,num));
 295         ulong_ret =  num;
 296         free(dir_list);
 297         return (unsigned char *) &ulong_ret;
 298
 299     case MDDNUMBER:
 300         if( 0 == (dir_list = get_file_list(MDS_PATH, DIR_TYPE, &num)))
 301             return NULL;
 302         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDS_PATH,num));
 303         ulong_ret =  num;
 304         free(dir_list);
 305         return (unsigned char *) &ulong_ret;
 306
 307     case MDCNUMBER:
 308         if( 0 == (dir_list = get_file_list(MDC_PATH, DIR_TYPE, &num)))
 309             return NULL;
 310         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",MDC_PATH,num));
 311         ulong_ret =  num;
 312         free(dir_list);
 313         return (unsigned char *) &ulong_ret;
 314
 315     case CLIMOUNTNUMBER:
 316         if( 0 == (dir_list = get_file_list(CLIENT_PATH, DIR_TYPE, &num)))
 317             return NULL;
 318         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",CLIENT_PATH,num));
 319         ulong_ret =  num;
 320         free(dir_list);
 321         return (unsigned char *) &ulong_ret;
 322
 323     case LOVNUMBER:
 324         if( 0 == (dir_list = get_file_list(LOV_PATH, DIR_TYPE, &num)))
 325             return NULL;
 326         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LOV_PATH,num));
 327         ulong_ret =  num;
 328         free(dir_list);
 329         return (unsigned char *) &ulong_ret;
 330
 331     case LDLMNUMBER:
 332         if( 0 == (dir_list = get_file_list(LDLM_PATH, DIR_TYPE, &num)))
 333             return NULL;
 334         DEBUGMSGTL(("lsnmpd","num(%s)=%d\n",LDLM_PATH,num));
 335         ulong_ret =  num;
 336         free(dir_list);
 337         return (unsigned char *) &ulong_ret;
 338
 339     default:
 340       ERROR_MSG("");
 341   }
 342   return NULL;
 343 }
 344
 345 struct oid_table osd_table[] =
 346 {
 347     { OSDUUID,FILENAME_UUID,oid_table_string_handler},
 348     { OSDCOMMONNAME,0,oid_table_obj_name_handler},
 349     { OSDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
 350     { OSDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
 351     { OSDOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
 352     { OSDFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
 353     { 0,0,0 } /*End of table*/
 354 };
 355
 356
 357 /*****************************************************************************
 358  * Function: var_osdTable
 359  *
 360  ****************************************************************************/
 361 unsigned char *
 362 var_osdTable(struct variable *vp,
 363             oid     *name,
 364             size_t  *length,
 365             int     exact,
 366             size_t  *var_len,
 367             WriteMethod **write_method)
 368 {
 369     return var_genericTable(vp,name,length,exact,var_len,write_method,
 370         OSD_PATH,osd_table);
 371 }
 372
 373 struct oid_table osc_table[] =
 374 {
 375     { OSCUUID,FILENAME_UUID,oid_table_string_handler},
 376     { OSCCOMMONNAME,0,oid_table_obj_name_handler},
 377     { OSCOSTSERVERUUID,"ost_server_uuid",oid_table_string_handler},
 378     { OSCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
 379     { OSCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
 380     { OSCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
 381     { OSCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
 382     { 0,0,0 } /*End of table*/
 383 };
 384
 385 /*****************************************************************************
 386  * Function: var_oscTable
 387  *
 388  ****************************************************************************/
 389 unsigned char *
 390 var_oscTable(struct variable *vp,
 391             oid     *name,
 392             size_t  *length,
 393             int     exact,
 394             size_t  *var_len,
 395             WriteMethod **write_method)
 396 {
 397     return var_genericTable(vp,name,length,exact,var_len,write_method,
 398         OSC_PATH,osc_table);
 399 }
 400
 401 struct oid_table mds_table[] =
 402 {
 403     { MDDUUID,FILENAME_UUID,oid_table_string_handler},
 404     { MDDCOMMONNAME,0,oid_table_obj_name_handler},
 405     { MDDCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
 406     { MDDFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
 407     { MDDFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
 408     { MDDFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
 409     { 0,0,0 } /*End of table*/
 410 };
 411
 412 /*****************************************************************************
 413  * Function: var_mdsTable
 414  *
 415  ****************************************************************************/
 416 unsigned char *
 417 var_mdsTable(struct variable *vp,
 418             oid     *name,
 419             size_t  *length,
 420             int     exact,
 421             size_t  *var_len,
 422             WriteMethod **write_method)
 423 {
 424     return var_genericTable(vp,name,length,exact,var_len,write_method,
 425         MDS_PATH,mds_table);
 426 }
 427
 428 struct oid_table mdc_table[] =
 429 {
 430     { MDCUUID,FILENAME_UUID,oid_table_string_handler},
 431     { MDCCOMMONNAME,0,oid_table_obj_name_handler},
 432     { MDCMDSSERVERUUID,"mds_server_uuid",oid_table_string_handler},
 433     { MDCCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
 434     { MDCFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
 435     { MDCOBJECTS,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
 436     { MDCFREEOBJECTS,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
 437     { 0,0,0 } /*End of table*/
 438 };
 439
 440
 441 /*****************************************************************************
 442  * Function: var_mdcTable
 443  *
 444  ****************************************************************************/
 445 unsigned char *
 446 var_mdcTable(struct variable *vp,
 447             oid     *name,
 448             size_t  *length,
 449             int     exact,
 450             size_t  *var_len,
 451             WriteMethod **write_method)
 452 {
 453     return var_genericTable(vp,name,length,exact,var_len,write_method,
 454         MDC_PATH,mdc_table);
 455 }
 456
 457
 458 struct oid_table cli_table[] =
 459 {
 460     { CLIUUID,FILENAME_UUID,oid_table_string_handler},
 461     { CLICOMMONNAME,0,oid_table_obj_name_handler},
 462     { CLIMDCUUID,"mdc/" FILENAME_UUID,oid_table_string_handler},
 463     { CLIMDCCOMMONNAME,"mdc/" FILENAME_COMMON_NAME,oid_table_string_handler},
 464     { CLIUSESLOV,"lov/",oid_table_is_directory_handler},
 465     { CLILOVUUID,"lov/" FILENAME_UUID,oid_table_string_handler},
 466     { CLILOVCOMMONNAME,"lov/" FILENAME_COMMON_NAME,oid_table_string_handler},
 467     { 0,0,0 } /*End of table*/
 468 };
 469
 470 /*****************************************************************************
 471  * Function: var_cliTable
 472  *
 473  ****************************************************************************/
 474 unsigned char *
 475 var_cliTable(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         CLIENT_PATH,cli_table);
 484 }
 485
 486
 487 struct oid_table lov_table[] =
 488 {
 489     { LOVUUID,FILENAME_UUID,oid_table_string_handler},
 490     { LOVCOMMONNAME,0,oid_table_obj_name_handler},
 491     { LOVNUMOBD,"numobd", oid_table_ulong_handler},
 492     { LOVNUMACTIVEOBD,"activeobd", oid_table_ulong_handler},
 493     { LOVCAPACITY,FILENAME_KBYTES_TOTAL, oid_table_c64_kb_handler},
 494     { LOVFREECAPACITY,FILENAME_KBYTES_FREE, oid_table_c64_kb_handler},
 495     { LOVFILES,FILENAME_FILES_TOTAL, oid_table_c64_kb_handler},
 496     { LOVFREEFILES,FILENAME_FILES_FREE, oid_table_c64_kb_handler},
 497     { LOVSTRIPECOUNT,"stripecount", oid_table_ulong_handler},
 498     { LOVSTRIPEOFFSET,"stripeoffset", oid_table_ulong_handler},
 499     { LOVSTRIPESIZE,"stripesize", oid_table_ulong_handler},
 500     { LOVSTRIPETYPE,"stripetype", oid_table_ulong_handler},
 501     { 0,0,0 } /*End of table*/
 502 };
 503
 504
 505 /*****************************************************************************
 506  * Function: var_lovTable
 507  *
 508  ****************************************************************************/
 509 unsigned char *
 510 var_lovTable(struct variable *vp,
 511             oid     *name,
 512             size_t  *length,
 513             int     exact,
 514             size_t  *var_len,
 515             WriteMethod **write_method)
 516 {
 517     return var_genericTable(vp,name,length,exact,var_len,write_method,
 518         LOV_PATH,lov_table);
 519 }
 520
 521 struct oid_table ldlm_table[] =
 522 {
 523     { LDLMNAMESPACE,0,oid_table_obj_name_handler},
 524     { LDLMLOCKCOUNT,"lock_count", oid_table_ulong_handler},
 525     { LDLMUNUSEDLOCKCOUNT,"lock_unused_count", oid_table_ulong_handler},
 526     { LDLMRESOURCECOUNT,"resource_count", oid_table_ulong_handler},
 527     { 0,0,0 } /*End of table*/
 528 };
 529
 530
 531 /*****************************************************************************
 532  * Function: var_ldlmTable
 533  *
 534  ****************************************************************************/
 535 unsigned char *
 536 var_ldlmTable(struct variable *vp,
 537             oid     *name,
 538             size_t  *length,
 539             int     exact,
 540             size_t  *var_len,
 541             WriteMethod **write_method)
 542 {
 543     return var_genericTable(vp,name,length,exact,var_len,write_method,
 544         LDLM_PATH,ldlm_table);
 545 }
 546
 547 /*****************************************************************************
 548  * Function: var_lnetInformation
 549  *
 550  ****************************************************************************/
 551 unsigned char *
 552 var_lnetInformation(struct variable *vp,
 553                     oid             *name,
 554                     size_t          *length,
 555                     int              exact,
 556                     size_t          *var_len,
 557                     WriteMethod    **write_method)
 558 {
 559         /* variables we may use later */
 560         static unsigned char      string[SPRINT_MAX_LEN];
 561         static unsigned int       i[7];
 562         static unsigned long long ull[4];
 563         static unsigned long      next_update;
 564         static counter64          c64;
 565         static unsigned int       c32;
 566         struct timeval            current_tv;
 567         unsigned long             current;
 568         char                      file_path[MAX_PATH_SIZE];
 569
 570         /* Update at most every LNET_STATS_INTERVAL milliseconds */
 571         gettimeofday(&current_tv, NULL);
 572         current = current_tv.tv_sec * 1000000 + current_tv.tv_usec;
 573         if (current >= next_update) {
 574                 sprintf(file_path, "%s%s", LNET_PATH, "stats");
 575                 if (read_string(file_path, (char *) string, sizeof(string))
 576                     != SUCCESS)
 577                         return NULL;
 578
 579                 sscanf((char *) string,
 580                        "%u %u %u %u %u %u %u %llu %llu %llu %llu",
 581                        &i[0], &i[1], &i[2], &i[3], &i[4], &i[5], &i[6],
 582                        &ull[0], &ull[1], &ull[2], &ull[3]);
 583
 584                 next_update = current + (LNET_CHECK_INTERVAL * 1000);
 585         }
 586
 587         if (header_generic(vp, name, length, exact, var_len, write_method)
 588             == MATCH_FAILED)
 589                 return NULL;
 590
 591         switch (vp->magic) {
 592         case LNETMSGSALLOC:
 593                 *var_len = sizeof(c32);
 594                 c32 = i[0];
 595                 return (unsigned char *) &c32;
 596         case LNETMSGSMAX:
 597                 *var_len = sizeof(c32);
 598                 c32 = i[1];
 599                 return (unsigned char *) &c32;
 600         case LNETERRORS:
 601                 *var_len = sizeof(c32);
 602                 c32 = i[2];
 603                 return (unsigned char *) &c32;
 604         case LNETSENDCOUNT:
 605                 *var_len = sizeof(c32);
 606                 c32 = i[3];
 607                 return (unsigned char *) &c32;
 608         case LNETRECVCOUNT:
 609                 *var_len = sizeof(c32);
 610                 c32 = i[4];
 611                 return (unsigned char *) &c32;
 612         case LNETROUTECOUNT:
 613                 *var_len = sizeof(c32);
 614                 c32 = i[5];
 615                 return (unsigned char *) &c32;
 616         case LNETDROPCOUNT:
 617                 *var_len = sizeof(c32);
 618                 c32 = i[6];
 619                 return (unsigned char *) &c32;
 620         case LNETSENDBYTES:
 621                 convert_ull(&c64, ull[0], var_len);
 622                 return (unsigned char *) &c64;
 623         case LNETRECVBYTES:
 624                 convert_ull(&c64, ull[1], var_len);
 625                 return (unsigned char *) &c64;
 626         case LNETROUTEBYTES:
 627                 convert_ull(&c64, ull[2], var_len);
 628                 return (unsigned char *) &c64;
 629         case LNETDROPBYTES:
 630                 convert_ull(&c64, ull[3], var_len);
 631                 return (unsigned char *) &c64;
 632         default:
 633                 return NULL;
 634         }
 635 }
 636
 637 /*****************************************************************************
 638  * Function: var_mdsNbSampledReq
 639  *
 640  ****************************************************************************/
 641 unsigned char *
 642 var_mdsNbSampledReq(struct variable *vp,
 643             oid     *name,
 644             size_t  *length,
 645             int     exact,
 646             size_t  *var_len,
 647             WriteMethod **write_method)
 648 {
 649   unsigned long long nb_sample=0,min=0,max=0,sum=0,sum_square=0;
 650   static counter64 c64;
 651
 652   if (header_generic(vp,name,length,exact,var_len,write_method)
 653                                   == MATCH_FAILED )
 654     return NULL;
 655
 656   if( mds_stats_values(STR_REQ_WAITIME,&nb_sample,&min,&max,&sum,&sum_square) == ERROR) return NULL;
 657
 658   c64.low = (u_long) (0x0FFFFFFFF & nb_sample);
 659   nb_sample >>= 32;
 660   c64.high = (u_long) (0x0FFFFFFFF & nb_sample);
 661
 662   *var_len = sizeof(c64);
 663   return (unsigned char *) &c64;
 664 }
 665
 666
 667 /*****************************************************************************
 668  * Function: write_sysStatus
 669  *
 670  ****************************************************************************/
 671 int
 672 write_sysStatus(int      action,
 673             u_char   *var_val,
 674             u_char   var_val_type,
 675             size_t   var_val_len,
 676             u_char   *statP,
 677             oid      *name,
 678             size_t   name_len)
 679 {
 680   static long *long_ret;
 681   int new_value;
 682
 683
 684
 685   switch ( action ) {
 686         case RESERVE1:
 687           if (var_val_type != ASN_INTEGER){
 688               fprintf(stderr, "write to sysStatus not ASN_INTEGER\n");
 689               return SNMP_ERR_WRONGTYPE;
 690           }
 691           if (var_val_len > sizeof(long_ret)){
 692               fprintf(stderr,"write to sysStatus: bad length\n");
 693               return SNMP_ERR_WRONGLENGTH;
 694           }
 695           if ((*var_val != ONLINE) &&
 696               (*var_val !=  OFFLINE) &&
 697               (*var_val !=  RESTART)){
 698               report("%s %s:line %d %s", __FILE__, __FUNCTION__, __LINE__,
 699                      "sysStatus value is invalid.");
 700               return SNMP_ERR_WRONGVALUE;
 701           }
 702           break;
 703
 704
 705         case RESERVE2:
 706           long_ret = (long *) var_val;
 707
 708
 709           break;
 710
 711
 712         case FREE:
 713              /* Release any resources that have been allocated */
 714           break;
 715
 716
 717         case ACTION:
 718              /* The variable has been stored in long_ret for
 719              you to use, and you have just been asked to do something with
 720              it.  Note that anything done here must be reversable in the UNDO case */
 721           new_value = *(int *) var_val;
 722           switch (new_value) {
 723             case ONLINE:
 724                 lustrefs_ctrl(ONLINE);
 725                 break;
 726
 727             case OFFLINE:
 728                 lustrefs_ctrl(OFFLINE);
 729                 break;
 730
 731             case RESTART:
 732                 lustrefs_ctrl(RESTART);
 733                 break;
 734
 735             default:
 736                 break;
 737           }
 738           break;
 739
 740
 741         case UNDO:
 742              /* Back out any changes made in the ACTION case */
 743           break;
 744
 745
 746         case COMMIT:
 747              /* Things are working well, so it's now safe to make the change
 748              permanently.  Make sure that anything done here can't fail! */
 749           break;
 750   }
 751   return SNMP_ERR_NOERROR;
 752 }