lib/libdevinfo/devinfo.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2000 Michael Smith
   5  * Copyright (c) 2000 BSDi
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    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
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 /*
  34  * An interface to the FreeBSD kernel's bus/device information interface.
  35  *
  36  * This interface is implemented with the
  37  *
  38  * hw.bus
  39  * hw.bus.devices
  40  * hw.bus.rman
  41  *
  42  * sysctls.  The interface is not meant for general user application
  43  * consumption.
  44  *
  45  * Device information is obtained by scanning a linear list of all devices
  46  * maintained by the kernel.  The actual device structure pointers are
  47  * handed out as opaque handles in order to allow reconstruction of the
  48  * logical toplogy in user space.
  49  *
  50  * Resource information is obtained by scanning the kernel's resource
  51  * managers and fetching their contents.  Ownership of resources is
  52  * tracked using the device's structure pointer again as a handle.
  53  *
  54  * In order to ensure coherency of the library's picture of the kernel,
  55  * a generation count is maintained by the kernel.  The initial generation
  56  * count is obtained (along with the interface version) from the hw.bus
  57  * sysctl, and must be passed in with every request.  If the generation
  58  * number supplied by the library does not match the kernel's current
  59  * generation number, the request is failed and the library must discard
  60  * the data it has received and rescan.
  61  *
  62  * The information obtained from the kernel is exported to consumers of
  63  * this library through a variety of interfaces.
  64  */
  65
  66 #include <sys/param.h>
  67 #include <sys/types.h>
  68 #include <sys/sysctl.h>
  69 #include <err.h>
  70 #include <errno.h>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include "devinfo.h"
  75 #include "devinfo_var.h"
  76
  77 static int      devinfo_init_devices(int generation);
  78 static int      devinfo_init_resources(int generation);
  79 static void     devinfo_free_dev(struct devinfo_i_dev *dd);
  80
  81 TAILQ_HEAD(,devinfo_i_dev)      devinfo_dev;
  82 TAILQ_HEAD(,devinfo_i_rman)     devinfo_rman;
  83 TAILQ_HEAD(,devinfo_i_res)      devinfo_res;
  84
  85 static int      devinfo_initted = 0;
  86 static int      devinfo_generation = 0;
  87
  88 #if 0
  89 # define debug(...)     do { \
  90         fprintf(stderr, "%s:", __func__); \
  91         fprintf(stderr, __VA_ARGS__); \
  92         fprintf(stderr, "\n"); \
  93 } while (0)
  94 #else
  95 # define debug(...)
  96 #endif
  97
  98 /*
  99  * Initialise our local database with the contents of the kernel's
 100  * tables.
 101  */
 102 int
 103 devinfo_init(void)
 104 {
 105         struct u_businfo        ubus;
 106         size_t          ub_size;
 107         int                     error, retries;
 108
 109         if (!devinfo_initted) {
 110                 TAILQ_INIT(&devinfo_dev);
 111                 TAILQ_INIT(&devinfo_rman);
 112                 TAILQ_INIT(&devinfo_res);
 113         }
 114
 115         /*
 116          * Get the generation count and interface version, verify that we
 117          * are compatible with the kernel.
 118          */
 119         for (retries = 0; retries < 10; retries++) {
 120                 debug("get interface version");
 121                 ub_size = sizeof(ubus);
 122                 if (sysctlbyname("hw.bus.info", &ubus,
 123                     &ub_size, NULL, 0) != 0) {
 124                         warn("sysctlbyname(\"hw.bus.info\", ...) failed");
 125                         return(EINVAL);
 126                 }
 127                 if ((ub_size != sizeof(ubus)) ||
 128                     (ubus.ub_version != BUS_USER_VERSION)) {
 129                         warnx("kernel bus interface version mismatch: kernel %d expected %d",
 130                             ubus.ub_version, BUS_USER_VERSION);
 131                         return(EINVAL);
 132                 }
 133                 debug("generation count is %d", ubus.ub_generation);
 134
 135                 /*
 136                  * Don't rescan if the generation count hasn't changed.
 137                  */
 138                 if (ubus.ub_generation == devinfo_generation)
 139                         return(0);
 140
 141                 /*
 142                  * Generation count changed, rescan
 143                  */
 144                 devinfo_free();
 145                 devinfo_initted = 0;
 146                 devinfo_generation = 0;
 147
 148                 if ((error = devinfo_init_devices(ubus.ub_generation)) != 0) {
 149                         devinfo_free();
 150                         if (error == EINVAL)
 151                                 continue;
 152                         break;
 153                 }
 154                 if ((error = devinfo_init_resources(ubus.ub_generation)) != 0) {
 155                         devinfo_free();
 156                         if (error == EINVAL)
 157                                 continue;
 158                         break;
 159                 }
 160                 devinfo_initted = 1;
 161                 devinfo_generation = ubus.ub_generation;
 162                 return(0);
 163         }
 164         debug("scan failed after %d retries", retries);
 165         errno = error;
 166         return(1);
 167 }
 168
 169 static int
 170 devinfo_init_devices(int generation)
 171 {
 172         struct u_device         udev;
 173         struct devinfo_i_dev    *dd;
 174         int                     dev_idx;
 175         int                     dev_ptr;
 176         int                     name2oid[2];
 177         int                     oid[CTL_MAXNAME + 12];
 178         size_t                  oidlen, rlen;
 179         char                    *name, *walker, *ep;
 180         int                     error;
 181
 182         /*
 183          * Find the OID for the rman interface node.
 184          * This is just the usual evil, undocumented sysctl juju.
 185          */
 186         name2oid[0] = 0;
 187         name2oid[1] = 3;
 188         oidlen = sizeof(oid);
 189         name = "hw.bus.devices";
 190         error = sysctl(name2oid, 2, oid, &oidlen, name, strlen(name));
 191         if (error < 0) {
 192                 warnx("can't find hw.bus.devices sysctl node");
 193                 return(ENOENT);
 194         }
 195         oidlen /= sizeof(int);
 196         if (oidlen > CTL_MAXNAME) {
 197                 warnx("hw.bus.devices oid is too large");
 198                 return(EINVAL);
 199         }
 200         oid[oidlen++] = generation;
 201         dev_ptr = oidlen++;
 202
 203         /*
 204          * Scan devices.
 205          *
 206          * Stop after a fairly insane number to avoid death in the case
 207          * of kernel corruption.
 208          */
 209         for (dev_idx = 0; dev_idx < 10000; dev_idx++) {
 210
 211                 /*
 212                  * Get the device information.
 213                  */
 214                 oid[dev_ptr] = dev_idx;
 215                 rlen = sizeof(udev);
 216                 error = sysctl(oid, oidlen, &udev, &rlen, NULL, 0);
 217                 if (error < 0) {
 218                         if (errno == ENOENT)    /* end of list */
 219                                 break;
 220                         if (errno != EINVAL)    /* gen count skip, restart */
 221                                 warn("sysctl hw.bus.devices.%d", dev_idx);
 222                         return(errno);
 223                 }
 224                 if (rlen != sizeof(udev)) {
 225                         warnx("sysctl returned wrong data %zd bytes instead of %zd",
 226                             rlen, sizeof(udev));
 227                         return (EINVAL);
 228                 }
 229                 if ((dd = calloc(1, sizeof(*dd))) == NULL)
 230                         return(ENOMEM);
 231                 dd->dd_dev.dd_handle = udev.dv_handle;
 232                 dd->dd_dev.dd_parent = udev.dv_parent;
 233                 dd->dd_dev.dd_devflags = udev.dv_devflags;
 234                 dd->dd_dev.dd_flags = udev.dv_flags;
 235                 dd->dd_dev.dd_state = udev.dv_state;
 236
 237                 walker = udev.dv_fields;
 238                 ep = walker + sizeof(udev.dv_fields);
 239                 dd->dd_name = NULL;
 240                 dd->dd_desc = NULL;
 241                 dd->dd_drivername = NULL;
 242                 dd->dd_pnpinfo = NULL;
 243                 dd->dd_location = NULL;
 244 #define UNPACK(x)                                                       \
 245                 dd->dd_dev.x = dd->x = strdup(walker);                  \
 246                 if (dd->x == NULL) {                                    \
 247                         devinfo_free_dev(dd);                           \
 248                         return(ENOMEM);                                 \
 249                 }                                                       \
 250                 if (walker + strnlen(walker, ep - walker) >= ep) {      \
 251                         devinfo_free_dev(dd);                           \
 252                         return(EINVAL);                                 \
 253                 }                                                       \
 254                 walker += strlen(walker) + 1;
 255
 256                 UNPACK(dd_name);
 257                 UNPACK(dd_desc);
 258                 UNPACK(dd_drivername);
 259                 UNPACK(dd_pnpinfo);
 260                 UNPACK(dd_location);
 261 #undef UNPACK
 262                 TAILQ_INSERT_TAIL(&devinfo_dev, dd, dd_link);
 263         }
 264         debug("fetched %d devices", dev_idx);
 265         return(0);
 266 }
 267
 268 static int
 269 devinfo_init_resources(int generation)
 270 {
 271         struct u_rman           urman;
 272         struct devinfo_i_rman   *dm;
 273         struct u_resource       ures;
 274         struct devinfo_i_res    *dr;
 275         int                     rman_idx, res_idx;
 276         int                     rman_ptr, res_ptr;
 277         int                     name2oid[2];
 278         int                     oid[CTL_MAXNAME + 12];
 279         size_t                  oidlen, rlen;
 280         char                    *name;
 281         int                     error;
 282
 283         /*
 284          * Find the OID for the rman interface node.
 285          * This is just the usual evil, undocumented sysctl juju.
 286          */
 287         name2oid[0] = 0;
 288         name2oid[1] = 3;
 289         oidlen = sizeof(oid);
 290         name = "hw.bus.rman";
 291         error = sysctl(name2oid, 2, oid, &oidlen, name, strlen(name));
 292         if (error < 0) {
 293                 warnx("can't find hw.bus.rman sysctl node");
 294                 return(ENOENT);
 295         }
 296         oidlen /= sizeof(int);
 297         if (oidlen > CTL_MAXNAME) {
 298                 warnx("hw.bus.rman oid is too large");
 299                 return(EINVAL);
 300         }
 301         oid[oidlen++] = generation;
 302         rman_ptr = oidlen++;
 303         res_ptr = oidlen++;
 304
 305         /*
 306          * Scan resource managers.
 307          *
 308          * Stop after a fairly insane number to avoid death in the case
 309          * of kernel corruption.
 310          */
 311         for (rman_idx = 0; rman_idx < 255; rman_idx++) {
 312
 313                 /*
 314                  * Get the resource manager information.
 315                  */
 316                 oid[rman_ptr] = rman_idx;
 317                 oid[res_ptr] = -1;
 318                 rlen = sizeof(urman);
 319                 error = sysctl(oid, oidlen, &urman, &rlen, NULL, 0);
 320                 if (error < 0) {
 321                         if (errno == ENOENT)    /* end of list */
 322                                 break;
 323                         if (errno != EINVAL)    /* gen count skip, restart */
 324                                 warn("sysctl hw.bus.rman.%d", rman_idx);
 325                         return(errno);
 326                 }
 327                 if ((dm = malloc(sizeof(*dm))) == NULL)
 328                         return(ENOMEM);
 329                 dm->dm_rman.dm_handle = urman.rm_handle;
 330                 dm->dm_rman.dm_start = urman.rm_start;
 331                 dm->dm_rman.dm_size = urman.rm_size;
 332                 snprintf(dm->dm_desc, DEVINFO_STRLEN, "%s", urman.rm_descr);
 333                 dm->dm_rman.dm_desc = &dm->dm_desc[0];
 334                 TAILQ_INSERT_TAIL(&devinfo_rman, dm, dm_link);
 335
 336                 /*
 337                  * Scan resources on this resource manager.
 338                  *
 339                  * Stop after a fairly insane number to avoid death in the case
 340                  * of kernel corruption.
 341                  */
 342                 for (res_idx = 0; res_idx < 1000; res_idx++) {
 343                         /*
 344                          * Get the resource information.
 345                          */
 346                         oid[res_ptr] = res_idx;
 347                         rlen = sizeof(ures);
 348                         error = sysctl(oid, oidlen, &ures, &rlen, NULL, 0);
 349                         if (error < 0) {
 350                                 if (errno == ENOENT)    /* end of list */
 351                                         break;
 352                                 if (errno != EINVAL)    /* gen count skip */
 353                                         warn("sysctl hw.bus.rman.%d.%d",
 354                                             rman_idx, res_idx);
 355                                 return(errno);
 356                         }
 357                         if ((dr = malloc(sizeof(*dr))) == NULL)
 358                                 return(ENOMEM);
 359                         dr->dr_res.dr_handle = ures.r_handle;
 360                         dr->dr_res.dr_rman = ures.r_parent;
 361                         dr->dr_res.dr_device = ures.r_device;
 362                         dr->dr_res.dr_start = ures.r_start;
 363                         dr->dr_res.dr_size = ures.r_size;
 364                         TAILQ_INSERT_TAIL(&devinfo_res, dr, dr_link);
 365                 }
 366                 debug("fetched %d resources", res_idx);
 367         }
 368         debug("scanned %d resource managers", rman_idx);
 369         return(0);
 370 }
 371
 372 /*
 373  * Free an individual dev.
 374  */
 375 static void
 376 devinfo_free_dev(struct devinfo_i_dev *dd)
 377 {
 378         free(dd->dd_name);
 379         free(dd->dd_desc);
 380         free(dd->dd_drivername);
 381         free(dd->dd_pnpinfo);
 382         free(dd->dd_location);
 383         free(dd);
 384 }
 385
 386 /*
 387  * Free the list contents.
 388  */
 389 void
 390 devinfo_free(void)
 391 {
 392         struct devinfo_i_dev    *dd;
 393         struct devinfo_i_rman   *dm;
 394         struct devinfo_i_res    *dr;
 395
 396         while ((dd = TAILQ_FIRST(&devinfo_dev)) != NULL) {
 397                 TAILQ_REMOVE(&devinfo_dev, dd, dd_link);
 398                 devinfo_free_dev(dd);
 399         }
 400         while ((dm = TAILQ_FIRST(&devinfo_rman)) != NULL) {
 401                 TAILQ_REMOVE(&devinfo_rman, dm, dm_link);
 402                 free(dm);
 403         }
 404         while ((dr = TAILQ_FIRST(&devinfo_res)) != NULL) {
 405                 TAILQ_REMOVE(&devinfo_res, dr, dr_link);
 406                 free(dr);
 407         }
 408         devinfo_initted = 0;
 409         devinfo_generation = 0;
 410 }
 411
 412 /*
 413  * Find a device by its handle.
 414  */
 415 struct devinfo_dev *
 416 devinfo_handle_to_device(devinfo_handle_t handle)
 417 {
 418         struct devinfo_i_dev    *dd;
 419
 420         /*
 421          * Find the root device, whose parent is NULL
 422          */
 423         if (handle == DEVINFO_ROOT_DEVICE) {
 424                 TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 425                     if (dd->dd_dev.dd_parent == DEVINFO_ROOT_DEVICE)
 426                             return(&dd->dd_dev);
 427                 return(NULL);
 428         }
 429
 430         /*
 431          * Scan for the device
 432          */
 433         TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 434             if (dd->dd_dev.dd_handle == handle)
 435                     return(&dd->dd_dev);
 436         return(NULL);
 437 }
 438
 439 /*
 440  * Find a resource by its handle.
 441  */
 442 struct devinfo_res *
 443 devinfo_handle_to_resource(devinfo_handle_t handle)
 444 {
 445         struct devinfo_i_res    *dr;
 446
 447         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 448             if (dr->dr_res.dr_handle == handle)
 449                     return(&dr->dr_res);
 450         return(NULL);
 451 }
 452
 453 /*
 454  * Find a resource manager by its handle.
 455  */
 456 struct devinfo_rman *
 457 devinfo_handle_to_rman(devinfo_handle_t handle)
 458 {
 459         struct devinfo_i_rman   *dm;
 460
 461         TAILQ_FOREACH(dm, &devinfo_rman, dm_link)
 462             if (dm->dm_rman.dm_handle == handle)
 463                     return(&dm->dm_rman);
 464         return(NULL);
 465 }
 466
 467 /*
 468  * Iterate over the children of a device, calling (fn) on each.  If
 469  * (fn) returns nonzero, abort the scan and return.
 470  */
 471 int
 472 devinfo_foreach_device_child(struct devinfo_dev *parent,
 473     int (* fn)(struct devinfo_dev *child, void *arg),
 474     void *arg)
 475 {
 476         struct devinfo_i_dev    *dd;
 477         int                             error;
 478
 479         TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 480             if (dd->dd_dev.dd_parent == parent->dd_handle)
 481                     if ((error = fn(&dd->dd_dev, arg)) != 0)
 482                             return(error);
 483         return(0);
 484 }
 485
 486 /*
 487  * Iterate over all the resources owned by a device, calling (fn) on each.
 488  * If (fn) returns nonzero, abort the scan and return.
 489  */
 490 int
 491 devinfo_foreach_device_resource(struct devinfo_dev *dev,
 492     int (* fn)(struct devinfo_dev *dev, struct devinfo_res *res, void *arg),
 493     void *arg)
 494 {
 495         struct devinfo_i_res    *dr;
 496         int                             error;
 497
 498         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 499             if (dr->dr_res.dr_device == dev->dd_handle)
 500                     if ((error = fn(dev, &dr->dr_res, arg)) != 0)
 501                             return(error);
 502         return(0);
 503 }
 504
 505 /*
 506  * Iterate over all the resources owned by a resource manager, calling (fn)
 507  * on each.  If (fn) returns nonzero, abort the scan and return.
 508  */
 509 extern int
 510 devinfo_foreach_rman_resource(struct devinfo_rman *rman,
 511     int (* fn)(struct devinfo_res *res, void *arg),
 512     void *arg)
 513 {
 514         struct devinfo_i_res    *dr;
 515         int                             error;
 516
 517         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 518             if (dr->dr_res.dr_rman == rman->dm_handle)
 519                     if ((error = fn(&dr->dr_res, arg)) != 0)
 520                             return(error);
 521         return(0);
 522 }
 523
 524 /*
 525  * Iterate over all the resource managers, calling (fn) on each.  If (fn)
 526  * returns nonzero, abort the scan and return.
 527  */
 528 extern int
 529 devinfo_foreach_rman(int (* fn)(struct devinfo_rman *rman, void *arg),
 530     void *arg)
 531 {
 532     struct devinfo_i_rman       *dm;
 533     int                         error;
 534
 535     TAILQ_FOREACH(dm, &devinfo_rman, dm_link)
 536         if ((error = fn(&dm->dm_rman, arg)) != 0)
 537             return(error);
 538     return(0);
 539 }