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         /* Look for md devices */
 344         STAILQ_FOREACH(map, &device_map, link) {
 345                 if (sscanf(map->name_key, "md%d", &unit) != 1)
 346                         continue;
 347
 348                 /* First get the entry from the hrDeviceTbl */
 349                 entry = device_find_by_index(map->hrIndex);
 350                 entry->type = &OIDX_hrDeviceDiskStorage_c;
 351
 352                 /* Then check hrDiskStorage table for this device */
 353                 disk_entry = disk_find_by_index(entry->index);
 354                 if (disk_entry == NULL) {
 355                         disk_entry = disk_entry_create(entry);
 356                         if (disk_entry == NULL)
 357                                 continue;
 358
 359                         memset(&mdio, 0, sizeof(mdio));
 360                         mdio.md_version = MDIOVERSION;
 361                         mdio.md_unit = unit;
 362
 363                         if (ioctl(md_fd, MDIOCQUERY, &mdio) < 0) {
 364                                 syslog(LOG_ERR,
 365                                     "hrDiskStorageTable: Couldnt ioctl");
 366                                 continue;
 367                         }
 368
 369                         if ((mdio.md_options & MD_READONLY) == MD_READONLY)
 370                                 disk_entry->access = DS_READ_ONLY;
 371                         else
 372                                 disk_entry->access = DS_READ_WRITE;
 373
 374                         strlcpy(disk_entry->dev_name, entry->name,
 375                             sizeof(disk_entry->dev_name));
 376
 377                         disk_entry->media = DSM_RAMDISK;
 378                         disk_entry->removable = SNMP_FALSE;
 379                 }
 380
 381                 disk_entry->flags |= HR_DISKSTORAGE_FOUND;
 382                 disk_entry->flags |= HR_DISKSTORAGE_MD;
 383                 disk_entry->r_tick = this_tick;
 384         }
 385 }
 386
 387 /**
 388  * Find rest of disks
 389  */
 390 static void
 391 disk_OS_get_disks(void)
 392 {
 393         size_t disk_cnt = 0;
 394         struct device_entry *entry;
 395         struct disk_entry *disk_entry;
 396
 397         size_t need = 0;
 398
 399         if (sysctlbyname("kern.disks", NULL, &need, NULL, 0) == -1) {
 400                 syslog(LOG_ERR, "%s: sysctl_1 kern.disks failed: %m", __func__);
 401                 return;
 402         }
 403
 404         if (need == 0)
 405                 return;
 406
 407         if (disk_list_len != need + 1 || disk_list == NULL) {
 408                 disk_list_len = need + 1;
 409                 disk_list = reallocf(disk_list, disk_list_len);
 410         }
 411
 412         if (disk_list == NULL) {
 413                 syslog(LOG_ERR, "%s: reallocf failed", __func__);
 414                 disk_list_len = 0;
 415                 return;
 416         }
 417
 418         memset(disk_list, 0, disk_list_len);
 419
 420         if (sysctlbyname("kern.disks", disk_list, &need, NULL, 0) == -1 ||
 421             disk_list[0] == 0) {
 422                 syslog(LOG_ERR, "%s: sysctl_2 kern.disks failed: %m", __func__);
 423                 return;
 424         }
 425
 426         for (disk_cnt = 0; disk_cnt < need; disk_cnt++) {
 427                 char *disk = NULL;
 428                 char disk_device[128] = "";
 429
 430                 disk = strsep(&disk_list, " ");
 431                 if (disk == NULL)
 432                         break;
 433
 434                 snprintf(disk_device, sizeof(disk_device),
 435                     "%s%s", _PATH_DEV, disk);
 436
 437                 /* First check if the disk is in the hrDeviceTable. */
 438                 if ((entry = device_find_by_name(disk)) == NULL) {
 439                         /*
 440                          * not found there - insert it as immutable
 441                          */
 442                         syslog(LOG_WARNING, "%s: device '%s' not in "
 443                             "device list", __func__, disk);
 444
 445                         if ((entry = device_entry_create(disk, "", "")) == NULL)
 446                                 continue;
 447
 448                         entry->flags |= HR_DEVICE_IMMUTABLE;
 449                 }
 450
 451                 entry->type = &OIDX_hrDeviceDiskStorage_c;
 452
 453                 /* Then check hrDiskStorage table for this device */
 454                 disk_entry = disk_find_by_index(entry->index);
 455                 if (disk_entry == NULL) {
 456                         disk_entry = disk_entry_create(entry);
 457                         if (disk_entry == NULL)
 458                                 continue;
 459                 }
 460
 461                 disk_entry->flags |= HR_DISKSTORAGE_FOUND;
 462
 463                 if ((disk_entry->flags & HR_DISKSTORAGE_ATA) ||
 464                     (disk_entry->flags & HR_DISKSTORAGE_MD)) {
 465                         /*
 466                          * ATA/MD detection is running before this one,
 467                          * so don't waste the time here
 468                          */
 469                         continue;
 470                 }
 471
 472                 disk_entry->access = DS_READ_WRITE;
 473                 disk_entry->media = DSM_UNKNOWN;
 474                 disk_entry->removable = SNMP_FALSE;
 475
 476                 if (strncmp(disk_entry->dev_name, "da", 2) == 0) {
 477                         disk_entry->media = DSM_HARDDISK;
 478                         disk_entry->removable = SNMP_FALSE;
 479                 } else if (strncmp(disk_entry->dev_name, "cd", 2) == 0) {
 480                         disk_entry->media = DSM_OPTICALDISKROM;
 481                         disk_entry->removable = SNMP_TRUE;
 482                 } else {
 483                         disk_entry->media = DSM_UNKNOWN;
 484                         disk_entry->removable = SNMP_FALSE;
 485                 }
 486
 487                 strlcpy((char *)disk_entry->dev_name, disk,
 488                     sizeof(disk_entry->dev_name));
 489
 490                 disk_query_disk(disk_entry);
 491                 disk_entry->r_tick = this_tick;
 492         }
 493 }
 494
 495 /**
 496  * Refresh routine for hrDiskStorageTable
 497  * Usable for polling the system for any changes.
 498  */
 499 void
 500 refresh_disk_storage_tbl(int force)
 501 {
 502         struct disk_entry *entry, *entry_tmp;
 503
 504         if (disk_storage_tick != 0 && !force &&
 505             this_tick - disk_storage_tick < disk_storage_tbl_refresh) {
 506                 HRDBG("no refresh needed");
 507                 return;
 508         }
 509
 510         partition_tbl_pre_refresh();
 511
 512         /* mark each entry as missing */
 513         TAILQ_FOREACH(entry, &disk_tbl, link)
 514                 entry->flags &= ~HR_DISKSTORAGE_FOUND;
 515
 516         disk_OS_get_ATA_disks();        /* this must be called first ! */
 517         disk_OS_get_MD_disks();
 518         disk_OS_get_disks();
 519
 520         /*
 521          * Purge items that disappeared
 522          */
 523         TAILQ_FOREACH_SAFE(entry, &disk_tbl, link, entry_tmp)
 524                 if (!(entry->flags & HR_DISKSTORAGE_FOUND))
 525                         /* XXX remove IMMUTABLE entries that have disappeared */
 526                         disk_entry_delete(entry);
 527
 528         disk_storage_tick = this_tick;
 529
 530         partition_tbl_post_refresh();
 531
 532         HRDBG("refresh DONE");
 533 }
 534
 535 /*
 536  * Init the things for both of hrDiskStorageTable
 537  */
 538 int
 539 init_disk_storage_tbl(void)
 540 {
 541         char mddev[32] = "";
 542
 543         /* Try to load md.ko if not loaded already */
 544         mdmaybeload();
 545
 546         md_fd = -1;
 547         snprintf(mddev, sizeof(mddev) - 1, "%s%s", _PATH_DEV, MDCTL_NAME);
 548         if ((md_fd = open(mddev, O_RDWR)) == -1) {
 549                 syslog(LOG_ERR, "open %s failed: %m", mddev);
 550                 return (-1);
 551         }
 552
 553         refresh_disk_storage_tbl(1);
 554
 555         return (0);
 556 }
 557
 558 /*
 559  * Finalization routine for hrDiskStorageTable
 560  * It destroys the lists and frees any allocated heap memory
 561  */
 562 void
 563 fini_disk_storage_tbl(void)
 564 {
 565         struct disk_entry *n1;
 566
 567         while ((n1 = TAILQ_FIRST(&disk_tbl)) != NULL) {
 568                 TAILQ_REMOVE(&disk_tbl, n1, link);
 569                 free(n1);
 570         }
 571
 572         free(disk_list);
 573
 574         if (md_fd > 0) {
 575                 if (close(md_fd) == -1)
 576                         syslog(LOG_ERR,"close (/dev/mdctl) failed: %m");
 577                 md_fd = -1;
 578         }
 579 }
 580
 581 /*
 582  * This is the implementation for a generated (by our SNMP "compiler" tool)
 583  * function prototype, see hostres_tree.h
 584  * It handles the SNMP operations for hrDiskStorageTable
 585  */
 586 int
 587 op_hrDiskStorageTable(struct snmp_context *ctx __unused,
 588     struct snmp_value *value, u_int sub, u_int iidx __unused,
 589     enum snmp_op curr_op)
 590 {
 591         struct disk_entry *entry;
 592
 593         refresh_disk_storage_tbl(0);
 594
 595         switch (curr_op) {
 596
 597         case SNMP_OP_GETNEXT:
 598                 if ((entry = NEXT_OBJECT_INT(&disk_tbl,
 599                     &value->var, sub)) == NULL)
 600                         return (SNMP_ERR_NOSUCHNAME);
 601                 value->var.len = sub + 1;
 602                 value->var.subs[sub] = entry->index;
 603                 goto get;
 604
 605         case SNMP_OP_GET:
 606                 if ((entry = FIND_OBJECT_INT(&disk_tbl,
 607                     &value->var, sub)) == NULL)
 608                         return (SNMP_ERR_NOSUCHNAME);
 609                 goto get;
 610
 611         case SNMP_OP_SET:
 612                 if ((entry = FIND_OBJECT_INT(&disk_tbl,
 613                     &value->var, sub)) == NULL)
 614                         return (SNMP_ERR_NO_CREATION);
 615                 return (SNMP_ERR_NOT_WRITEABLE);
 616
 617         case SNMP_OP_ROLLBACK:
 618         case SNMP_OP_COMMIT:
 619                 abort();
 620         }
 621         abort();
 622
 623   get:
 624         switch (value->var.subs[sub - 1]) {
 625
 626         case LEAF_hrDiskStorageAccess:
 627                 value->v.integer = entry->access;
 628                 return (SNMP_ERR_NOERROR);
 629
 630         case LEAF_hrDiskStorageMedia:
 631                 value->v.integer = entry->media;
 632                 return (SNMP_ERR_NOERROR);
 633
 634         case LEAF_hrDiskStorageRemoveble:
 635                 value->v.integer = entry->removable;
 636                 return (SNMP_ERR_NOERROR);
 637
 638         case LEAF_hrDiskStorageCapacity:
 639                 value->v.integer = entry->capacity;
 640                 return (SNMP_ERR_NOERROR);
 641         }
 642         abort();
 643 }