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