usr.sbin/bsnmpd/modules/snmp_hostres/hostres_diskstorage_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 the hrDiskStorageTable
  34  */
  35
  36 #include <sys/types.h>
  37 #include <sys/param.h>
  38 #include <sys/ata.h>
  39 #include <sys/disk.h>
  40 #include <sys/linker.h>
  41 #include <sys/mdioctl.h>
  42 #include <sys/module.h>
  43 #include <sys/sysctl.h>
  44
  45 #include <assert.h>
  46 #include <ctype.h>
  47 #include <err.h>
  48 #include <errno.h>
  49 #include <paths.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <syslog.h>
  53 #include <unistd.h>
  54
  55 #include "hostres_snmp.h"
  56 #include "hostres_oid.h"
  57 #include "hostres_tree.h"
  58
  59 enum hrDiskStrorageAccess {
  60         DS_READ_WRITE = 1,
  61         DS_READ_ONLY  = 2
  62 };
  63
  64 enum hrDiskStrorageMedia {
  65         DSM_OTHER       =       1,
  66         DSM_UNKNOWN     =       2,
  67         DSM_HARDDISK    =       3,
  68         DSM_FLOPPYDISK  =       4,
  69         DSM_OPTICALDISKROM=     5,
  70         DSM_OPTICALDISKWORM=    6,
  71         DSM_OPTICALDISKRW=      7,
  72         DSM_RAMDISK     =       8
  73 };
  74
  75 /*
  76  * This structure is used to hold a SNMP table entry for HOST-RESOURCES-MIB's
  77  * hrDiskStorageTable. Note that index is external being allocated and
  78  * maintained by the hrDeviceTable code.
  79  *
  80  * NOTE: according to MIB removable means removable media, not the
  81  * device itself (like a USB card reader)
  82  */
  83 struct disk_entry {
  84         int32_t         index;
  85         int32_t         access;         /* enum hrDiskStrorageAccess */
  86         int32_t         media;          /* enum hrDiskStrorageMedia*/
  87         int32_t         removable;      /* enum snmpTCTruthValue*/
  88         int32_t         capacity;
  89         TAILQ_ENTRY(disk_entry) link;
  90         /*
  91          * next items are not from the SNMP mib table, only to be used
  92          * internally
  93          */
  94 #define HR_DISKSTORAGE_FOUND    0x001
  95 #define HR_DISKSTORAGE_ATA      0x002 /* belongs to the ATA subsystem */
  96 #define HR_DISKSTORAGE_MD       0x004 /* it is a MD (memory disk) */
  97         uint32_t        flags;
  98         uint64_t        r_tick;
  99         u_char          dev_name[32];   /* device name, i.e. "ad4" or "acd0" */
 100 };
 101 TAILQ_HEAD(disk_tbl, disk_entry);
 102
 103 /* the head of the list with hrDiskStorageTable's entries */
 104 static struct disk_tbl disk_tbl =
 105     TAILQ_HEAD_INITIALIZER(disk_tbl);
 106
 107 /* last tick when hrFSTable was updated */
 108 static uint64_t disk_storage_tick;
 109
 110 /* minimum number of ticks between refreshs */
 111 uint32_t disk_storage_tbl_refresh = HR_DISK_TBL_REFRESH * 100;
 112
 113 /* fd for "/dev/mdctl"*/
 114 static int md_fd = -1;
 115
 116 /* buffer for sysctl("kern.disks") */
 117 static char *disk_list;
 118 static size_t disk_list_len;
 119
 120 /* some constants */
 121 static const struct asn_oid OIDX_hrDeviceDiskStorage_c =
 122     OIDX_hrDeviceDiskStorage;
 123
 124 /**
 125  * Load the MD driver if it isn't loaded already.
 126  */
 127 static void
 128 mdmaybeload(void)
 129 {
 130         char name1[64], name2[64];
 131
 132         snprintf(name1, sizeof(name1), "g_%s", MD_NAME);
 133         snprintf(name2, sizeof(name2), "geom_%s", MD_NAME);
 134         if (modfind(name1) == -1) {
 135                 /* Not present in kernel, try loading it. */
 136                 if (kldload(name2) == -1 || modfind(name1) == -1) {
 137                         if (errno != EEXIST) {
 138                                 errx(EXIT_FAILURE,
 139                                     "%s module not available!", name2);
 140                         }
 141                 }
 142         }
 143 }
 144
 145 /**
 146  * Create a new entry into the DiskStorageTable.
 147  */
 148 static struct disk_entry *
 149 disk_entry_create(const struct device_entry *devEntry)
 150 {
 151         struct disk_entry *entry;
 152
 153         assert(devEntry != NULL);
 154         if (devEntry == NULL)
 155                 return NULL;
 156
 157         if ((entry = malloc(sizeof(*entry))) == NULL) {
 158                 syslog(LOG_WARNING, "hrDiskStorageTable: %s: %m", __func__);
 159                 return (NULL);
 160         }
 161
 162         memset(entry, 0, sizeof(*entry));
 163         entry->index = devEntry->index;
 164         INSERT_OBJECT_INT(entry, &disk_tbl);
 165
 166         return (entry);
 167 }
 168
 169 /**
 170  * Delete a disk table entry.
 171  */
 172 static void
 173 disk_entry_delete(struct disk_entry *entry)
 174 {
 175         struct device_entry *devEntry;
 176
 177         assert(entry != NULL);
 178         TAILQ_REMOVE(&disk_tbl, entry, link);
 179
 180         devEntry = device_find_by_index(entry->index);
 181
 182         free(entry);
 183
 184         /*
 185          * Also delete the respective device entry -
 186          * this is needed for disk devices that are not
 187          * detected by libdevinfo
 188          */
 189         if (devEntry != NULL &&
 190             (devEntry->flags & HR_DEVICE_IMMUTABLE) == HR_DEVICE_IMMUTABLE)
 191                 device_entry_delete(devEntry);
 192 }
 193
 194 /**
 195  * Find a disk storage entry given its index.
 196  */
 197 static struct disk_entry *
 198 disk_find_by_index(int32_t idx)
 199 {
 200         struct disk_entry *entry;
 201
 202         TAILQ_FOREACH(entry, &disk_tbl, link)
 203                 if (entry->index == idx)
 204                         return (entry);
 205
 206         return (NULL);
 207 }
 208
 209 /**
 210  * Get the disk parameters
 211  */
 212 static void
 213 disk_query_disk(struct disk_entry *entry)
 214 {
 215         char dev_path[128];
 216         int fd;
 217         off_t mediasize;
 218
 219         if (entry == NULL || entry->dev_name[0] == '\0')
 220                 return;
 221
 222         snprintf(dev_path, sizeof(dev_path),
 223             "%s%s", _PATH_DEV, entry->dev_name);
 224         entry->capacity = 0;
 225
 226         HRDBG("OPENING device %s", dev_path);
 227         if ((fd = open(dev_path, O_RDONLY|O_NONBLOCK)) == -1) {
 228                 HRDBG("OPEN device %s failed: %s", dev_path, strerror(errno));
 229                 return;
 230         }
 231
 232         if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) < 0) {
 233                 HRDBG("DIOCGMEDIASIZE for device %s failed: %s",
 234                     dev_path, strerror(errno));
 235                 (void)close(fd);
 236                 return;
 237         }
 238
 239         mediasize = mediasize / 1024;
 240         entry->capacity = (mediasize > INT_MAX ? INT_MAX : mediasize);
 241         partition_tbl_handle_disk(entry->index, entry->dev_name);
 242
 243         (void)close(fd);
 244 }
 245
 246 /**
 247  * Find all ATA disks in the device table.
 248  */
 249 static void
 250 disk_OS_get_ATA_disks(void)
 251 {
 252         struct device_map_entry *map;
 253         struct device_entry *entry;
 254         struct disk_entry *disk_entry;
 255         const struct disk_entry *found;
 256
 257         /* Things we know are ata disks */
 258         static const struct disk_entry lookup[] = {
 259                 {
 260                     .dev_name = "ad",
 261                     .media = DSM_HARDDISK,
 262                     .removable = SNMP_FALSE
 263                 },
 264                 {
 265                     .dev_name = "ar",
 266                     .media = DSM_OTHER,
 267                     .removable = SNMP_FALSE
 268                 },
 269                 {
 270                     .dev_name = "acd",
 271                     .media = DSM_OPTICALDISKROM,
 272                     .removable = SNMP_TRUE
 273                 },
 274                 {
 275                     .dev_name = "afd",
 276                     .media = DSM_FLOPPYDISK,
 277                     .removable = SNMP_TRUE
 278                 },
 279                 {
 280                     .dev_name = "ast",
 281                     .media = DSM_OTHER,
 282                     .removable = SNMP_TRUE
 283                 },
 284
 285                 { .media = DSM_UNKNOWN }
 286         };
 287
 288         /* Walk over the device table looking for ata disks */
 289         STAILQ_FOREACH(map, &device_map, link) {
 290                 for (found = lookup; found->media != DSM_UNKNOWN; found++) {
 291                         if (strncmp(map->name_key, found->dev_name,
 292                             strlen(found->dev_name)) != 0)
 293                                 continue;
 294
 295                         /*
 296                          * Avoid false disk devices. For example adw(4) and
 297                          * adv(4) - they are not disks!
 298                          */
 299                         if (strlen(map->name_key) > strlen(found->dev_name) &&
 300                             !isdigit(map->name_key[strlen(found->dev_name)]))
 301                                 continue;
 302
 303                         /* First get the entry from the hrDeviceTbl */
 304                         entry = map->entry_p;
 305                         entry->type = &OIDX_hrDeviceDiskStorage_c;
 306
 307                         /* Then check hrDiskStorage table for this device */
 308                         disk_entry = disk_find_by_index(entry->index);
 309                         if (disk_entry == NULL) {
 310                                 disk_entry = disk_entry_create(entry);
 311                                 if (disk_entry == NULL)
 312                                         continue;
 313
 314                                 disk_entry->access = DS_READ_WRITE;
 315                                 strlcpy(disk_entry->dev_name, entry->name,
 316                                     sizeof(disk_entry->dev_name));
 317
 318                                 disk_entry->media = found->media;
 319                                 disk_entry->removable = found->removable;
 320                         }
 321
 322                         disk_entry->flags |= HR_DISKSTORAGE_FOUND;
 323                         disk_entry->flags |= HR_DISKSTORAGE_ATA;
 324
 325                         disk_query_disk(disk_entry);
 326                         disk_entry->r_tick = this_tick;
 327                 }
 328         }
 329 }
 330
 331 /**
 332  * Find MD disks in the device table.
 333  */
 334 static void
 335 disk_OS_get_MD_disks(void)
 336 {
 337         struct device_map_entry *map;
 338         struct device_entry *entry;
 339         struct disk_entry *disk_entry;
 340         struct md_ioctl mdio;
 341         int unit;
 342
 343         if (md_fd <= 0)
 344                 return;
 345
 346         /* Look for md devices */
 347         STAILQ_FOREACH(map, &device_map, link) {
 348                 if (sscanf(map->name_key, "md%d", &unit) != 1)
 349                         continue;
 350
 351                 /* First get the entry from the hrDeviceTbl */
 352                 entry = device_find_by_index(map->hrIndex);
 353                 entry->type = &OIDX_hrDeviceDiskStorage_c;
 354
 355                 /* Then check hrDiskStorage table for this device */
 356                 disk_entry = disk_find_by_index(entry->index);
 357                 if (disk_entry == NULL) {
 358                         disk_entry = disk_entry_create(entry);
 359                         if (disk_entry == NULL)
 360                                 continue;
 361
 362                         memset(&mdio, 0, sizeof(mdio));
 363                         mdio.md_version = MDIOVERSION;
 364                         mdio.md_unit = unit;
 365
 366                         if (ioctl(md_fd, MDIOCQUERY, &mdio) < 0) {
 367                                 syslog(LOG_ERR,
 368                                     "hrDiskStorageTable: Couldnt ioctl");
 369                                 continue;
 370                         }
 371
 372                         if ((mdio.md_options & MD_READONLY) == MD_READONLY)
 373                                 disk_entry->access = DS_READ_ONLY;
 374                         else
 375                                 disk_entry->access = DS_READ_WRITE;
 376
 377                         strlcpy(disk_entry->dev_name, entry->name,
 378                             sizeof(disk_entry->dev_name));
 379
 380                         disk_entry->media = DSM_RAMDISK;
 381                         disk_entry->removable = SNMP_FALSE;
 382                 }
 383
 384                 disk_entry->flags |= HR_DISKSTORAGE_FOUND;
 385                 disk_entry->flags |= HR_DISKSTORAGE_MD;
 386                 disk_entry->r_tick = this_tick;
 387         }
 388 }
 389
 390 /**
 391  * Find rest of disks
 392  */
 393 static void
 394 disk_OS_get_disks(void)
 395 {
 396         size_t disk_cnt = 0;
 397         struct device_entry *entry;
 398         struct disk_entry *disk_entry;
 399
 400         size_t need = 0;
 401
 402         if (sysctlbyname("kern.disks", NULL, &need, NULL, 0) == -1) {
 403                 syslog(LOG_ERR, "%s: sysctl_1 kern.disks failed: %m", __func__);
 404                 return;
 405         }
 406
 407         if (need == 0)
 408                 return;
 409
 410         if (disk_list_len != need + 1 || disk_list == NULL) {
 411                 disk_list_len = need + 1;
 412                 disk_list = reallocf(disk_list, disk_list_len);
 413         }
 414
 415         if (disk_list == NULL) {
 416                 syslog(LOG_ERR, "%s: reallocf failed", __func__);
 417                 disk_list_len = 0;
 418                 return;
 419         }
 420
 421         memset(disk_list, 0, disk_list_len);
 422
 423         if (sysctlbyname("kern.disks", disk_list, &need, NULL, 0) == -1 ||
 424             disk_list[0] == 0) {
 425                 syslog(LOG_ERR, "%s: sysctl_2 kern.disks failed: %m", __func__);
 426                 return;
 427         }
 428
 429         for (disk_cnt = 0; disk_cnt < need; disk_cnt++) {
 430                 char *disk = NULL;
 431                 char disk_device[128] = "";
 432
 433                 disk = strsep(&disk_list, " ");
 434                 if (disk == NULL)
 435                         break;
 436
 437                 snprintf(disk_device, sizeof(disk_device),
 438                     "%s%s", _PATH_DEV, disk);
 439
 440                 /* First check if the disk is in the hrDeviceTable. */
 441                 if ((entry = device_find_by_name(disk)) == NULL) {
 442                         /*
 443                          * not found there - insert it as immutable
 444                          */
 445                         syslog(LOG_WARNING, "%s: device '%s' not in "
 446                             "device list", __func__, disk);
 447
 448                         if ((entry = device_entry_create(disk, "", "")) == NULL)
 449                                 continue;
 450
 451                         entry->flags |= HR_DEVICE_IMMUTABLE;
 452                 }
 453
 454                 entry->type = &OIDX_hrDeviceDiskStorage_c;
 455
 456                 /* Then check hrDiskStorage table for this device */
 457                 disk_entry = disk_find_by_index(entry->index);
 458                 if (disk_entry == NULL) {
 459                         disk_entry = disk_entry_create(entry);
 460                         if (disk_entry == NULL)
 461                                 continue;
 462                 }
 463
 464                 disk_entry->flags |= HR_DISKSTORAGE_FOUND;
 465
 466                 if ((disk_entry->flags & HR_DISKSTORAGE_ATA) ||
 467                     (disk_entry->flags & HR_DISKSTORAGE_MD)) {
 468                         /*
 469                          * ATA/MD detection is running before this one,
 470                          * so don't waste the time here
 471                          */
 472                         continue;
 473                 }
 474
 475                 disk_entry->access = DS_READ_WRITE;
 476                 disk_entry->media = DSM_UNKNOWN;
 477                 disk_entry->removable = SNMP_FALSE;
 478
 479                 if (strncmp(disk_entry->dev_name, "da", 2) == 0) {
 480                         disk_entry->media = DSM_HARDDISK;
 481                         disk_entry->removable = SNMP_FALSE;
 482                 } else if (strncmp(disk_entry->dev_name, "cd", 2) == 0) {
 483                         disk_entry->media = DSM_OPTICALDISKROM;
 484                         disk_entry->removable = SNMP_TRUE;
 485                 } else {
 486                         disk_entry->media = DSM_UNKNOWN;
 487                         disk_entry->removable = SNMP_FALSE;
 488                 }
 489
 490                 strlcpy((char *)disk_entry->dev_name, disk,
 491                     sizeof(disk_entry->dev_name));
 492
 493                 disk_query_disk(disk_entry);
 494                 disk_entry->r_tick = this_tick;
 495         }
 496 }
 497
 498 /**
 499  * Refresh routine for hrDiskStorageTable
 500  * Usable for polling the system for any changes.
 501  */
 502 void
 503 refresh_disk_storage_tbl(int force)
 504 {
 505         struct disk_entry *entry, *entry_tmp;
 506
 507         if (disk_storage_tick != 0 && !force &&
 508             this_tick - disk_storage_tick < disk_storage_tbl_refresh) {
 509                 HRDBG("no refresh needed");
 510                 return;
 511         }
 512
 513         partition_tbl_pre_refresh();
 514
 515         /* mark each entry as missing */
 516         TAILQ_FOREACH(entry, &disk_tbl, link)
 517                 entry->flags &= ~HR_DISKSTORAGE_FOUND;
 518
 519         disk_OS_get_ATA_disks();        /* this must be called first ! */
 520         disk_OS_get_MD_disks();
 521         disk_OS_get_disks();
 522
 523         /*
 524          * Purge items that disappeared
 525          */
 526         TAILQ_FOREACH_SAFE(entry, &disk_tbl, link, entry_tmp)
 527                 if (!(entry->flags & HR_DISKSTORAGE_FOUND))
 528                         /* XXX remove IMMUTABLE entries that have disappeared */
 529                         disk_entry_delete(entry);
 530
 531         disk_storage_tick = this_tick;
 532
 533         partition_tbl_post_refresh();
 534
 535         HRDBG("refresh DONE");
 536 }
 537
 538 /*
 539  * Init the things for both of hrDiskStorageTable
 540  */
 541 int
 542 init_disk_storage_tbl(void)
 543 {
 544         char mddev[32] = "";
 545
 546         /* Try to load md.ko if not loaded already */
 547         mdmaybeload();
 548
 549         md_fd = -1;
 550         snprintf(mddev, sizeof(mddev) - 1, "%s%s", _PATH_DEV, MDCTL_NAME);
 551         if ((md_fd = open(mddev, O_RDWR)) == -1) {
 552                 syslog(LOG_ERR, "open %s failed - will not include md(4) "
 553                     "info: %m", mddev);
 554         }
 555
 556         refresh_disk_storage_tbl(1);
 557
 558         return (0);
 559 }
 560
 561 /*
 562  * Finalization routine for hrDiskStorageTable
 563  * It destroys the lists and frees any allocated heap memory
 564  */
 565 void
 566 fini_disk_storage_tbl(void)
 567 {
 568         struct disk_entry *n1;
 569
 570         while ((n1 = TAILQ_FIRST(&disk_tbl)) != NULL) {
 571                 TAILQ_REMOVE(&disk_tbl, n1, link);
 572                 free(n1);
 573         }
 574
 575         free(disk_list);
 576
 577         if (md_fd > 0) {
 578                 if (close(md_fd) == -1)
 579                         syslog(LOG_ERR,"close (/dev/mdctl) failed: %m");
 580                 md_fd = -1;
 581         }
 582 }
 583
 584 /*
 585  * This is the implementation for a generated (by our SNMP "compiler" tool)
 586  * function prototype, see hostres_tree.h
 587  * It handles the SNMP operations for hrDiskStorageTable
 588  */
 589 int
 590 op_hrDiskStorageTable(struct snmp_context *ctx __unused,
 591     struct snmp_value *value, u_int sub, u_int iidx __unused,
 592     enum snmp_op curr_op)
 593 {
 594         struct disk_entry *entry;
 595
 596         refresh_disk_storage_tbl(0);
 597
 598         switch (curr_op) {
 599
 600         case SNMP_OP_GETNEXT:
 601                 if ((entry = NEXT_OBJECT_INT(&disk_tbl,
 602                     &value->var, sub)) == NULL)
 603                         return (SNMP_ERR_NOSUCHNAME);
 604                 value->var.len = sub + 1;
 605                 value->var.subs[sub] = entry->index;
 606                 goto get;
 607
 608         case SNMP_OP_GET:
 609                 if ((entry = FIND_OBJECT_INT(&disk_tbl,
 610                     &value->var, sub)) == NULL)
 611                         return (SNMP_ERR_NOSUCHNAME);
 612                 goto get;
 613
 614         case SNMP_OP_SET:
 615                 if ((entry = FIND_OBJECT_INT(&disk_tbl,
 616                     &value->var, sub)) == NULL)
 617                         return (SNMP_ERR_NO_CREATION);
 618                 return (SNMP_ERR_NOT_WRITEABLE);
 619
 620         case SNMP_OP_ROLLBACK:
 621         case SNMP_OP_COMMIT:
 622                 abort();
 623         }
 624         abort();
 625
 626   get:
 627         switch (value->var.subs[sub - 1]) {
 628
 629         case LEAF_hrDiskStorageAccess:
 630                 value->v.integer = entry->access;
 631                 return (SNMP_ERR_NOERROR);
 632
 633         case LEAF_hrDiskStorageMedia:
 634                 value->v.integer = entry->media;
 635                 return (SNMP_ERR_NOERROR);
 636
 637         case LEAF_hrDiskStorageRemoveble:
 638                 value->v.integer = entry->removable;
 639                 return (SNMP_ERR_NOERROR);
 640
 641         case LEAF_hrDiskStorageCapacity:
 642                 value->v.integer = entry->capacity;
 643                 return (SNMP_ERR_NOERROR);
 644         }
 645         abort();
 646 }