usr.sbin/bsnmpd/modules/snmp_hostres/hostres_storage_tbl.c

   1 /*-
   2  * Copyright (c) 2005-2006 The FreeBSD Project
   3  * All rights reserved.
   4  *
   5  * Author: Victor Cruceru <soc-victor@freebsd.org>
   6  *
   7  * Redistribution of this software and documentation and use in source and
   8  * binary forms, with or without modification, are permitted provided that
   9  * the following conditions are met:
  10  *
  11  * 1. Redistributions of source code or documentation must retain the above
  12  *    copyright notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD$
  30  */
  31
  32 /*
  33  * Host Resources MIB for SNMPd. Implementation for hrStorageTable
  34  */
  35
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38 #include <sys/sysctl.h>
  39 #include <sys/vmmeter.h>
  40 #include <sys/mount.h>
  41
  42 #include <vm/vm_param.h>
  43
  44 #include <assert.h>
  45 #include <err.h>
  46 #include <limits.h>
  47 #include <memstat.h>
  48 #include <paths.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <syslog.h>
  52 #include <unistd.h> /* for getpagesize() */
  53 #include <sysexits.h>
  54
  55 #include "hostres_snmp.h"
  56 #include "hostres_oid.h"
  57 #include "hostres_tree.h"
  58
  59 /* maximum length for descritpion string according to MIB */
  60 #define SE_DESC_MLEN    (255 + 1)
  61
  62 /*
  63  * This structure is used to hold a SNMP table entry
  64  * for HOST-RESOURCES-MIB's hrStorageTable
  65  */
  66 struct storage_entry {
  67         int32_t         index;
  68         const struct asn_oid *type;
  69         u_char          *descr;
  70         int32_t         allocationUnits;
  71         int32_t         size;
  72         int32_t         used;
  73         uint32_t        allocationFailures;
  74 #define HR_STORAGE_FOUND 0x001
  75         uint32_t        flags;  /* to be used internally*/
  76         TAILQ_ENTRY(storage_entry) link;
  77 };
  78 TAILQ_HEAD(storage_tbl, storage_entry);
  79
  80 /*
  81  * Next structure is used to keep o list of mappings from a specific name
  82  * (a_name) to an entry in the hrStorageTblEntry. We are trying to keep the
  83  * same index for a specific name at least for the duration of one SNMP agent
  84  * run.
  85  */
  86 struct storage_map_entry {
  87         int32_t         hrIndex; /* used for storage_entry::index */
  88
  89         /* map key, also used for storage_entry::descr */
  90         u_char          *a_name;
  91
  92         /*
  93          * next may be NULL if the respective storage_entry
  94          * is (temporally) gone
  95          */
  96         struct storage_entry *entry;
  97         STAILQ_ENTRY(storage_map_entry) link;
  98 };
  99 STAILQ_HEAD(storage_map, storage_map_entry);
 100
 101 /* the head of the list with table's entries */
 102 static struct storage_tbl storage_tbl = TAILQ_HEAD_INITIALIZER(storage_tbl);
 103
 104 /*for consistent table indexing*/
 105 static struct storage_map storage_map =
 106     STAILQ_HEAD_INITIALIZER(storage_map);
 107
 108 /* last (agent) tick when hrStorageTable was updated */
 109 static uint64_t storage_tick;
 110
 111 /* maximum number of ticks between two refreshs */
 112 uint32_t storage_tbl_refresh = HR_STORAGE_TBL_REFRESH * 100;
 113
 114 /* for kvm_getswapinfo, malloc'd */
 115 static struct kvm_swap *swap_devs;
 116 static size_t swap_devs_len;            /* item count for swap_devs */
 117
 118 /* for getfsstat, malloc'd */
 119 static struct statfs *fs_buf;
 120 static size_t fs_buf_count;             /* item count for fs_buf */
 121
 122 static struct vmtotal mem_stats;
 123
 124 /* next int available for indexing the hrStorageTable */
 125 static uint32_t next_storage_index = 1;
 126
 127 /* start of list for memory detailed stats */
 128 static struct memory_type_list *mt_list;
 129
 130 /* Constants */
 131 static const struct asn_oid OIDX_hrStorageRam_c = OIDX_hrStorageRam;
 132 static const struct asn_oid OIDX_hrStorageVirtualMemory_c =
 133     OIDX_hrStorageVirtualMemory;
 134
 135 /**
 136  * Create a new entry into the storage table and, if necessary, an
 137  * entry into the storage map.
 138  */
 139 static struct storage_entry *
 140 storage_entry_create(const char *name)
 141 {
 142         struct storage_entry *entry;
 143         struct storage_map_entry *map;
 144         size_t name_len;
 145
 146         assert(name != NULL);
 147         assert(strlen(name) > 0);
 148
 149         STAILQ_FOREACH(map, &storage_map, link)
 150                 if (strcmp(map->a_name, name) == 0)
 151                         break;
 152
 153         if (map == NULL) {
 154                 /* new object - get a new index */
 155                 if (next_storage_index > INT_MAX) {
 156                         syslog(LOG_ERR,
 157                             "%s: hrStorageTable index wrap", __func__);
 158                         errx(EX_SOFTWARE, "hrStorageTable index wrap");
 159                 }
 160
 161                 if ((map = malloc(sizeof(*map))) == NULL) {
 162                         syslog(LOG_ERR, "hrStorageTable: %s: %m", __func__ );
 163                         return (NULL);
 164                 }
 165
 166                 name_len = strlen(name) + 1;
 167                 if (name_len > SE_DESC_MLEN)
 168                         name_len = SE_DESC_MLEN;
 169
 170                 if ((map->a_name = malloc(name_len)) == NULL) {
 171                         free(map);
 172                         return (NULL);
 173                 }
 174
 175                 strlcpy(map->a_name, name, name_len);
 176                 map->hrIndex = next_storage_index++;
 177
 178                 STAILQ_INSERT_TAIL(&storage_map, map, link);
 179
 180                 HRDBG("%s added into hrStorageMap at index=%d",
 181                     name, map->hrIndex);
 182         } else {
 183                 HRDBG("%s exists in hrStorageMap index=%d\n",
 184                     name, map->hrIndex);
 185         }
 186
 187         if ((entry = malloc(sizeof(*entry))) == NULL) {
 188                 syslog(LOG_WARNING, "%s: %m", __func__);
 189                 return (NULL);
 190         }
 191         memset(entry, 0, sizeof(*entry));
 192
 193         entry->index = map->hrIndex;
 194
 195         if ((entry->descr = strdup(map->a_name)) == NULL) {
 196                 free(entry);
 197                 return (NULL);
 198         }
 199
 200         map->entry = entry;
 201
 202         INSERT_OBJECT_INT(entry, &storage_tbl);
 203
 204         return (entry);
 205 }
 206
 207 /**
 208  * Delete an entry from the storage table.
 209  */
 210 static void
 211 storage_entry_delete(struct storage_entry *entry)
 212 {
 213         struct storage_map_entry *map;
 214
 215         assert(entry != NULL);
 216
 217         TAILQ_REMOVE(&storage_tbl, entry, link);
 218         STAILQ_FOREACH(map, &storage_map, link)
 219                 if (map->entry == entry) {
 220                         map->entry = NULL;
 221                         break;
 222                 }
 223         free(entry->descr);
 224         free(entry);
 225 }
 226
 227 /**
 228  * Find a table entry by its name.
 229  */
 230 static struct storage_entry *
 231 storage_find_by_name(const char *name)
 232 {
 233         struct storage_entry *entry;
 234
 235         TAILQ_FOREACH(entry, &storage_tbl, link)
 236                 if (strcmp(entry->descr, name) == 0)
 237                         return (entry);
 238
 239         return (NULL);
 240 }
 241
 242 /*
 243  * VM info.
 244  */
 245 static void
 246 storage_OS_get_vm(void)
 247 {
 248         int mib[2] = { CTL_VM, VM_TOTAL };
 249         size_t len = sizeof(mem_stats);
 250         int page_size_bytes;
 251         struct storage_entry *entry;
 252
 253         if (sysctl(mib, 2, &mem_stats, &len, NULL, 0) < 0) {
 254                 syslog(LOG_ERR,
 255                     "hrStoragetable: %s: sysctl({CTL_VM, VM_METER}) "
 256                     "failed: %m", __func__);
 257                 assert(0);
 258                 return;
 259         }
 260
 261         page_size_bytes = getpagesize();
 262
 263         /* Real Memory Metrics */
 264         if ((entry = storage_find_by_name("Real Memory Metrics")) == NULL &&
 265             (entry = storage_entry_create("Real Memory Metrics")) == NULL)
 266                 return; /* I'm out of luck now, maybe next time */
 267
 268         entry->flags |= HR_STORAGE_FOUND;
 269         entry->type = &OIDX_hrStorageRam_c;
 270         entry->allocationUnits = page_size_bytes;
 271         entry->size = mem_stats.t_rm;
 272         entry->used = mem_stats.t_arm; /* ACTIVE is not USED - FIXME */
 273         entry->allocationFailures = 0;
 274
 275         /* Shared Real Memory Metrics */
 276         if ((entry = storage_find_by_name("Shared Real Memory Metrics")) ==
 277             NULL &&
 278             (entry = storage_entry_create("Shared Real Memory Metrics")) ==
 279             NULL)
 280                 return;
 281
 282         entry->flags |= HR_STORAGE_FOUND;
 283         entry->type = &OIDX_hrStorageRam_c;
 284         entry->allocationUnits = page_size_bytes;
 285         entry->size = mem_stats.t_rmshr;
 286         /* ACTIVE is not USED - FIXME */
 287         entry->used = mem_stats.t_armshr;
 288         entry->allocationFailures = 0;
 289 }
 290
 291 static void
 292 storage_OS_get_memstat(void)
 293 {
 294         struct memory_type *mt_item;
 295         struct storage_entry *entry;
 296
 297         if (mt_list == NULL) {
 298                 if ((mt_list = memstat_mtl_alloc()) == NULL)
 299                         /* again? we have a serious problem */
 300                 return;
 301         }
 302
 303         if (memstat_sysctl_all(mt_list, 0) < 0) {
 304                 syslog(LOG_ERR, "memstat_sysctl_all failed: %s",
 305                     memstat_strerror(memstat_mtl_geterror(mt_list)) );
 306                 return;
 307         }
 308
 309         if ((mt_item = memstat_mtl_first(mt_list)) == NULL) {
 310                 /* usually this is not an error, no errno for this failure*/
 311                 HRDBG("memstat_mtl_first failed");
 312                 return;
 313         }
 314
 315         do {
 316                 const char *memstat_name;
 317                 uint64_t tmp_size;
 318                 int allocator;
 319                 char alloc_descr[SE_DESC_MLEN];
 320
 321                 memstat_name = memstat_get_name(mt_item);
 322
 323                 if (memstat_name == NULL || strlen(memstat_name) == 0)
 324                         continue;
 325
 326                 switch (allocator = memstat_get_allocator(mt_item)) {
 327
 328                   case ALLOCATOR_MALLOC:
 329                         snprintf(alloc_descr, sizeof(alloc_descr),
 330                             "MALLOC: %s", memstat_name);
 331                         break;
 332
 333                   case ALLOCATOR_UMA:
 334                         snprintf(alloc_descr, sizeof(alloc_descr),
 335                             "UMA: %s", memstat_name);
 336                         break;
 337
 338                   default:
 339                         snprintf(alloc_descr, sizeof(alloc_descr),
 340                             "UNKNOWN%d: %s", allocator, memstat_name);
 341                         break;
 342                 }
 343
 344                 if ((entry = storage_find_by_name(alloc_descr)) == NULL &&
 345                     (entry = storage_entry_create(alloc_descr)) == NULL)
 346                         return;
 347
 348                 entry->flags |= HR_STORAGE_FOUND;
 349                 entry->type = &OIDX_hrStorageRam_c;
 350
 351                 if ((tmp_size = memstat_get_size(mt_item)) == 0)
 352                         tmp_size = memstat_get_sizemask(mt_item);
 353                 entry->allocationUnits =
 354                     (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);
 355
 356                 tmp_size  = memstat_get_countlimit(mt_item);
 357                 entry->size =
 358                     (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);
 359
 360                 tmp_size = memstat_get_count(mt_item);
 361                 entry->used =
 362                     (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);
 363
 364                 tmp_size = memstat_get_failures(mt_item);
 365                 entry->allocationFailures =
 366                     (tmp_size  > INT_MAX ? INT_MAX : (int32_t)tmp_size);
 367
 368         } while((mt_item = memstat_mtl_next(mt_item)) != NULL);
 369 }
 370
 371 /**
 372  * Get swap info
 373  */
 374 static void
 375 storage_OS_get_swap(void)
 376 {
 377         int nswapdev = 0;
 378         size_t len = sizeof(nswapdev);
 379         struct storage_entry *entry;
 380         char swap_w_prefix[SE_DESC_MLEN];
 381
 382         if (sysctlbyname("vm.nswapdev", &nswapdev, &len, NULL,0 ) < 0) {
 383                 syslog(LOG_ERR,
 384                     "hrStorageTable: sysctlbyname(\"vm.nswapdev\") "
 385                     "failed. %m");
 386                 assert(0);
 387                 return;
 388         }
 389
 390         if (nswapdev <= 0) {
 391                 HRDBG("vm.nswapdev is %d", nswapdev);
 392                 return;
 393         }
 394
 395         if (nswapdev + 1 != (int)swap_devs_len || swap_devs == NULL) {
 396                 swap_devs_len = nswapdev + 1;
 397                 swap_devs = reallocf(swap_devs,
 398                     swap_devs_len * sizeof(struct kvm_swap));
 399
 400                 assert(swap_devs != NULL);
 401                 if (swap_devs == NULL) {
 402                         swap_devs_len = 0;
 403                         return;
 404                 }
 405         }
 406
 407         nswapdev = kvm_getswapinfo(hr_kd, swap_devs, swap_devs_len, 0);
 408         if (nswapdev < 0) {
 409                 syslog(LOG_ERR,
 410                     "hrStorageTable: kvm_getswapinfo failed. %m\n");
 411                 assert(0);
 412                 return;
 413         }
 414
 415         for (len = 0; len < (size_t)nswapdev; len++) {
 416                 memset(&swap_w_prefix[0], '\0', sizeof(swap_w_prefix));
 417                 snprintf(swap_w_prefix, sizeof(swap_w_prefix) - 1,
 418                     "Swap:%s%s", _PATH_DEV, swap_devs[len].ksw_devname);
 419
 420                 entry = storage_find_by_name(swap_w_prefix);
 421                 if (entry == NULL)
 422                         entry = storage_entry_create(swap_w_prefix);
 423
 424                 assert (entry != NULL);
 425                 if (entry == NULL)
 426                         return; /* Out of luck */
 427
 428                 entry->flags |= HR_STORAGE_FOUND;
 429                 entry->type = &OIDX_hrStorageVirtualMemory_c;
 430                 entry->allocationUnits = getpagesize();
 431                 entry->size = swap_devs[len].ksw_total;
 432                 entry->used = swap_devs[len].ksw_used;
 433                 entry->allocationFailures = 0;
 434         }
 435 }
 436
 437 /**
 438  * Query the underlaying OS for the mounted file systems
 439  * anf fill in the respective lists (for hrStorageTable and for hrFSTable)
 440  */
 441 static void
 442 storage_OS_get_fs(void)
 443 {
 444         struct storage_entry *entry;
 445         uint64_t size, used;
 446         int i, mounted_fs_count, units;
 447         char fs_string[SE_DESC_MLEN];
 448
 449         if ((mounted_fs_count = getfsstat(NULL, 0, MNT_NOWAIT)) < 0) {
 450                 syslog(LOG_ERR, "hrStorageTable: getfsstat() failed: %m");
 451                 return; /* out of luck this time */
 452         }
 453
 454         if (mounted_fs_count != (int)fs_buf_count || fs_buf == NULL) {
 455                 fs_buf_count = mounted_fs_count;
 456                 fs_buf = reallocf(fs_buf, fs_buf_count * sizeof(struct statfs));
 457                 if (fs_buf == NULL) {
 458                         fs_buf_count = 0;
 459                         assert(0);
 460                         return;
 461                 }
 462         }
 463
 464         if ((mounted_fs_count = getfsstat(fs_buf,
 465             fs_buf_count * sizeof(struct statfs), MNT_NOWAIT)) < 0) {
 466                 syslog(LOG_ERR, "hrStorageTable: getfsstat() failed: %m");
 467                 return; /* out of luck this time */
 468         }
 469
 470         HRDBG("got %d mounted FS", mounted_fs_count);
 471
 472         fs_tbl_pre_refresh();
 473
 474         for (i = 0; i < mounted_fs_count; i++) {
 475                 snprintf(fs_string, sizeof(fs_string),
 476                     "%s, type: %s, dev: %s", fs_buf[i].f_mntonname,
 477                     fs_buf[i].f_fstypename, fs_buf[i].f_mntfromname);
 478
 479                 entry = storage_find_by_name(fs_string);
 480                 if (entry == NULL)
 481                         entry = storage_entry_create(fs_string);
 482
 483                 assert (entry != NULL);
 484                 if (entry == NULL)
 485                         return; /* Out of luck */
 486
 487                 entry->flags |= HR_STORAGE_FOUND;
 488                 entry->type = fs_get_type(&fs_buf[i]); /*XXX - This is wrong*/
 489
 490                 units = fs_buf[i].f_bsize;
 491                 size = fs_buf[i].f_blocks;
 492                 used = fs_buf[i].f_blocks - fs_buf[i].f_bfree;
 493                 while (size > INT_MAX) {
 494                         units <<= 1;
 495                         size >>= 1;
 496                         used >>= 1;
 497                 }
 498                 entry->allocationUnits = units;
 499                 entry->size = size;
 500                 entry->used = used;
 501
 502                 entry->allocationFailures = 0;
 503
 504                 /* take care of hrFSTable */
 505                 fs_tbl_process_statfs_entry(&fs_buf[i], entry->index);
 506         }
 507
 508         fs_tbl_post_refresh();
 509 }
 510
 511 /**
 512  * Initialize storage table and populate it.
 513  */
 514 void
 515 init_storage_tbl(void)
 516 {
 517         if ((mt_list = memstat_mtl_alloc()) == NULL)
 518                 syslog(LOG_ERR,
 519                     "hrStorageTable: memstat_mtl_alloc() failed: %m");
 520
 521         refresh_storage_tbl(1);
 522 }
 523
 524 void
 525 fini_storage_tbl(void)
 526 {
 527         struct storage_map_entry *n1;
 528
 529         if (swap_devs != NULL) {
 530                 free(swap_devs);
 531                 swap_devs = NULL;
 532         }
 533         swap_devs_len = 0;
 534
 535         if (fs_buf != NULL) {
 536                 free(fs_buf);
 537                 fs_buf = NULL;
 538         }
 539         fs_buf_count = 0;
 540
 541         while ((n1 = STAILQ_FIRST(&storage_map)) != NULL) {
 542                 STAILQ_REMOVE_HEAD(&storage_map, link);
 543                 if (n1->entry != NULL) {
 544                         TAILQ_REMOVE(&storage_tbl, n1->entry, link);
 545                         free(n1->entry->descr);
 546                         free(n1->entry);
 547                 }
 548                 free(n1->a_name);
 549                 free(n1);
 550         }
 551         assert(TAILQ_EMPTY(&storage_tbl));
 552 }
 553
 554 void
 555 refresh_storage_tbl(int force)
 556 {
 557         struct storage_entry *entry, *entry_tmp;
 558
 559         if (!force && storage_tick != 0 &&
 560             this_tick - storage_tick < storage_tbl_refresh) {
 561                 HRDBG("no refresh needed");
 562                 return;
 563         }
 564
 565         /* mark each entry as missing */
 566         TAILQ_FOREACH(entry, &storage_tbl, link)
 567                 entry->flags &= ~HR_STORAGE_FOUND;
 568
 569         storage_OS_get_vm();
 570         storage_OS_get_swap();
 571         storage_OS_get_fs();
 572         storage_OS_get_memstat();
 573
 574         /*
 575          * Purge items that disappeared
 576          */
 577         TAILQ_FOREACH_SAFE(entry, &storage_tbl, link, entry_tmp)
 578                 if (!(entry->flags & HR_STORAGE_FOUND))
 579                         storage_entry_delete(entry);
 580
 581         storage_tick = this_tick;
 582
 583         HRDBG("refresh DONE");
 584 }
 585
 586 /*
 587  * This is the implementation for a generated (by our SNMP tool)
 588  * function prototype, see hostres_tree.h
 589  * It handles the SNMP operations for hrStorageTable
 590  */
 591 int
 592 op_hrStorageTable(struct snmp_context *ctx __unused, struct snmp_value *value,
 593     u_int sub, u_int iidx __unused, enum snmp_op curr_op)
 594 {
 595         struct storage_entry *entry;
 596
 597         refresh_storage_tbl(0);
 598
 599         switch (curr_op) {
 600
 601         case SNMP_OP_GETNEXT:
 602                 if ((entry = NEXT_OBJECT_INT(&storage_tbl,
 603                     &value->var, sub)) == NULL)
 604                         return (SNMP_ERR_NOSUCHNAME);
 605
 606                 value->var.len = sub + 1;
 607                 value->var.subs[sub] = entry->index;
 608                 goto get;
 609
 610         case SNMP_OP_GET:
 611                 if ((entry = FIND_OBJECT_INT(&storage_tbl,
 612                     &value->var, sub)) == NULL)
 613                         return (SNMP_ERR_NOSUCHNAME);
 614                 goto get;
 615
 616         case SNMP_OP_SET:
 617                 if ((entry = FIND_OBJECT_INT(&storage_tbl,
 618                     &value->var, sub)) == NULL)
 619                         return (SNMP_ERR_NO_CREATION);
 620                 return (SNMP_ERR_NOT_WRITEABLE);
 621
 622         case SNMP_OP_ROLLBACK:
 623         case SNMP_OP_COMMIT:
 624                 abort();
 625         }
 626         abort();
 627
 628   get:
 629         switch (value->var.subs[sub - 1]) {
 630
 631         case LEAF_hrStorageIndex:
 632                 value->v.integer = entry->index;
 633                 return (SNMP_ERR_NOERROR);
 634
 635         case LEAF_hrStorageType:
 636                 assert(entry->type != NULL);
 637                 value->v.oid = *entry->type;
 638                 return (SNMP_ERR_NOERROR);
 639
 640         case LEAF_hrStorageDescr:
 641                 assert(entry->descr != NULL);
 642                 return (string_get(value, entry->descr, -1));
 643                 break;
 644
 645         case LEAF_hrStorageAllocationUnits:
 646                 value->v.integer = entry->allocationUnits;
 647                 return (SNMP_ERR_NOERROR);
 648
 649         case LEAF_hrStorageSize:
 650                 value->v.integer = entry->size;
 651                 return (SNMP_ERR_NOERROR);
 652
 653         case LEAF_hrStorageUsed:
 654                 value->v.integer = entry->used;
 655                 return (SNMP_ERR_NOERROR);
 656
 657         case LEAF_hrStorageAllocationFailures:
 658                 value->v.uint32 = entry->allocationFailures;
 659                 return (SNMP_ERR_NOERROR);
 660         }
 661         abort();
 662 }