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
  80 TAILQ_HEAD(,devinfo_i_dev)      devinfo_dev;
  81 TAILQ_HEAD(,devinfo_i_rman)     devinfo_rman;
  82 TAILQ_HEAD(,devinfo_i_res)      devinfo_res;
  83
  84 static int      devinfo_initted = 0;
  85 static int      devinfo_generation = 0;
  86
  87 #if 0
  88 # define debug(...)     do { \
  89         fprintf(stderr, "%s:", __func__); \
  90         fprintf(stderr, __VA_ARGS__); \
  91         fprintf(stderr, "\n"); \
  92 } while (0)
  93 #else
  94 # define debug(...)
  95 #endif
  96
  97 /*
  98  * Initialise our local database with the contents of the kernel's
  99  * tables.
 100  */
 101 int
 102 devinfo_init(void)
 103 {
 104         struct u_businfo        ubus;
 105         size_t          ub_size;
 106         int                     error, retries;
 107
 108         if (!devinfo_initted) {
 109                 TAILQ_INIT(&devinfo_dev);
 110                 TAILQ_INIT(&devinfo_rman);
 111                 TAILQ_INIT(&devinfo_res);
 112         }
 113
 114         /*
 115          * Get the generation count and interface version, verify that we
 116          * are compatible with the kernel.
 117          */
 118         for (retries = 0; retries < 10; retries++) {
 119                 debug("get interface version");
 120                 ub_size = sizeof(ubus);
 121                 if (sysctlbyname("hw.bus.info", &ubus,
 122                     &ub_size, NULL, 0) != 0) {
 123                         warn("sysctlbyname(\"hw.bus.info\", ...) failed");
 124                         return(EINVAL);
 125                 }
 126                 if ((ub_size != sizeof(ubus)) ||
 127                     (ubus.ub_version != BUS_USER_VERSION)) {
 128                         warnx("kernel bus interface version mismatch: kernel %d expected %d",
 129                             ubus.ub_version, BUS_USER_VERSION);
 130                         return(EINVAL);
 131                 }
 132                 debug("generation count is %d", ubus.ub_generation);
 133
 134                 /*
 135                  * Don't rescan if the generation count hasn't changed.
 136                  */
 137                 if (ubus.ub_generation == devinfo_generation)
 138                         return(0);
 139
 140                 /*
 141                  * Generation count changed, rescan
 142                  */
 143                 devinfo_free();
 144                 devinfo_initted = 0;
 145                 devinfo_generation = 0;
 146
 147                 if ((error = devinfo_init_devices(ubus.ub_generation)) != 0) {
 148                         devinfo_free();
 149                         if (error == EINVAL)
 150                                 continue;
 151                         break;
 152                 }
 153                 if ((error = devinfo_init_resources(ubus.ub_generation)) != 0) {
 154                         devinfo_free();
 155                         if (error == EINVAL)
 156                                 continue;
 157                         break;
 158                 }
 159                 devinfo_initted = 1;
 160                 devinfo_generation = ubus.ub_generation;
 161                 return(0);
 162         }
 163         debug("scan failed after %d retries", retries);
 164         errno = error;
 165         return(1);
 166 }
 167
 168 static int
 169 devinfo_init_devices(int generation)
 170 {
 171         struct u_device         udev;
 172         struct devinfo_i_dev    *dd;
 173         int                     dev_idx;
 174         int                     dev_ptr;
 175         int                     name2oid[2];
 176         int                     oid[CTL_MAXNAME + 12];
 177         size_t                  oidlen, rlen;
 178         char                    *name;
 179         int                     error;
 180
 181         /*
 182          * Find the OID for the rman interface node.
 183          * This is just the usual evil, undocumented sysctl juju.
 184          */
 185         name2oid[0] = 0;
 186         name2oid[1] = 3;
 187         oidlen = sizeof(oid);
 188         name = "hw.bus.devices";
 189         error = sysctl(name2oid, 2, oid, &oidlen, name, strlen(name));
 190         if (error < 0) {
 191                 warnx("can't find hw.bus.devices sysctl node");
 192                 return(ENOENT);
 193         }
 194         oidlen /= sizeof(int);
 195         if (oidlen > CTL_MAXNAME) {
 196                 warnx("hw.bus.devices oid is too large");
 197                 return(EINVAL);
 198         }
 199         oid[oidlen++] = generation;
 200         dev_ptr = oidlen++;
 201
 202         /*
 203          * Scan devices.
 204          *
 205          * Stop after a fairly insane number to avoid death in the case
 206          * of kernel corruption.
 207          */
 208         for (dev_idx = 0; dev_idx < 10000; dev_idx++) {
 209
 210                 /*
 211                  * Get the device information.
 212                  */
 213                 oid[dev_ptr] = dev_idx;
 214                 rlen = sizeof(udev);
 215                 error = sysctl(oid, oidlen, &udev, &rlen, NULL, 0);
 216                 if (error < 0) {
 217                         if (errno == ENOENT)    /* end of list */
 218                                 break;
 219                         if (errno != EINVAL)    /* gen count skip, restart */
 220                                 warn("sysctl hw.bus.devices.%d", dev_idx);
 221                         return(errno);
 222                 }
 223                 if (rlen != sizeof(udev)) {
 224                         warnx("sysctl returned wrong data %zd bytes instead of %zd",
 225                             rlen, sizeof(udev));
 226                         return (EINVAL);
 227                 }
 228                 if ((dd = malloc(sizeof(*dd))) == NULL)
 229                         return(ENOMEM);
 230                 dd->dd_dev.dd_handle = udev.dv_handle;
 231                 dd->dd_dev.dd_parent = udev.dv_parent;
 232                 snprintf(dd->dd_name, sizeof(dd->dd_name), "%s", udev.dv_name);
 233                 dd->dd_dev.dd_name = &dd->dd_name[0];
 234                 snprintf(dd->dd_desc, sizeof(dd->dd_desc), "%s", udev.dv_desc);
 235                 dd->dd_dev.dd_desc = &dd->dd_desc[0];
 236                 snprintf(dd->dd_drivername, sizeof(dd->dd_drivername), "%s",
 237                     udev.dv_drivername);
 238                 dd->dd_dev.dd_drivername = &dd->dd_drivername[0];
 239                 snprintf(dd->dd_pnpinfo, sizeof(dd->dd_pnpinfo), "%s",
 240                     udev.dv_pnpinfo);
 241                 dd->dd_dev.dd_pnpinfo = &dd->dd_pnpinfo[0];
 242                 snprintf(dd->dd_location, sizeof(dd->dd_location), "%s",
 243                     udev.dv_location);
 244                 dd->dd_dev.dd_location = &dd->dd_location[0];
 245                 dd->dd_dev.dd_devflags = udev.dv_devflags;
 246                 dd->dd_dev.dd_flags = udev.dv_flags;
 247                 dd->dd_dev.dd_state = udev.dv_state;
 248                 TAILQ_INSERT_TAIL(&devinfo_dev, dd, dd_link);
 249         }
 250         debug("fetched %d devices", dev_idx);
 251         return(0);
 252 }
 253
 254 static int
 255 devinfo_init_resources(int generation)
 256 {
 257         struct u_rman           urman;
 258         struct devinfo_i_rman   *dm;
 259         struct u_resource       ures;
 260         struct devinfo_i_res    *dr;
 261         int                     rman_idx, res_idx;
 262         int                     rman_ptr, res_ptr;
 263         int                     name2oid[2];
 264         int                     oid[CTL_MAXNAME + 12];
 265         size_t                  oidlen, rlen;
 266         char                    *name;
 267         int                     error;
 268
 269         /*
 270          * Find the OID for the rman interface node.
 271          * This is just the usual evil, undocumented sysctl juju.
 272          */
 273         name2oid[0] = 0;
 274         name2oid[1] = 3;
 275         oidlen = sizeof(oid);
 276         name = "hw.bus.rman";
 277         error = sysctl(name2oid, 2, oid, &oidlen, name, strlen(name));
 278         if (error < 0) {
 279                 warnx("can't find hw.bus.rman sysctl node");
 280                 return(ENOENT);
 281         }
 282         oidlen /= sizeof(int);
 283         if (oidlen > CTL_MAXNAME) {
 284                 warnx("hw.bus.rman oid is too large");
 285                 return(EINVAL);
 286         }
 287         oid[oidlen++] = generation;
 288         rman_ptr = oidlen++;
 289         res_ptr = oidlen++;
 290
 291         /*
 292          * Scan resource managers.
 293          *
 294          * Stop after a fairly insane number to avoid death in the case
 295          * of kernel corruption.
 296          */
 297         for (rman_idx = 0; rman_idx < 255; rman_idx++) {
 298
 299                 /*
 300                  * Get the resource manager information.
 301                  */
 302                 oid[rman_ptr] = rman_idx;
 303                 oid[res_ptr] = -1;
 304                 rlen = sizeof(urman);
 305                 error = sysctl(oid, oidlen, &urman, &rlen, NULL, 0);
 306                 if (error < 0) {
 307                         if (errno == ENOENT)    /* end of list */
 308                                 break;
 309                         if (errno != EINVAL)    /* gen count skip, restart */
 310                                 warn("sysctl hw.bus.rman.%d", rman_idx);
 311                         return(errno);
 312                 }
 313                 if ((dm = malloc(sizeof(*dm))) == NULL)
 314                         return(ENOMEM);
 315                 dm->dm_rman.dm_handle = urman.rm_handle;
 316                 dm->dm_rman.dm_start = urman.rm_start;
 317                 dm->dm_rman.dm_size = urman.rm_size;
 318                 snprintf(dm->dm_desc, DEVINFO_STRLEN, "%s", urman.rm_descr);
 319                 dm->dm_rman.dm_desc = &dm->dm_desc[0];
 320                 TAILQ_INSERT_TAIL(&devinfo_rman, dm, dm_link);
 321
 322                 /*
 323                  * Scan resources on this resource manager.
 324                  *
 325                  * Stop after a fairly insane number to avoid death in the case
 326                  * of kernel corruption.
 327                  */
 328                 for (res_idx = 0; res_idx < 1000; res_idx++) {
 329                         /*
 330                          * Get the resource information.
 331                          */
 332                         oid[res_ptr] = res_idx;
 333                         rlen = sizeof(ures);
 334                         error = sysctl(oid, oidlen, &ures, &rlen, NULL, 0);
 335                         if (error < 0) {
 336                                 if (errno == ENOENT)    /* end of list */
 337                                         break;
 338                                 if (errno != EINVAL)    /* gen count skip */
 339                                         warn("sysctl hw.bus.rman.%d.%d",
 340                                             rman_idx, res_idx);
 341                                 return(errno);
 342                         }
 343                         if ((dr = malloc(sizeof(*dr))) == NULL)
 344                                 return(ENOMEM);
 345                         dr->dr_res.dr_handle = ures.r_handle;
 346                         dr->dr_res.dr_rman = ures.r_parent;
 347                         dr->dr_res.dr_device = ures.r_device;
 348                         dr->dr_res.dr_start = ures.r_start;
 349                         dr->dr_res.dr_size = ures.r_size;
 350                         TAILQ_INSERT_TAIL(&devinfo_res, dr, dr_link);
 351                 }
 352                 debug("fetched %d resources", res_idx);
 353         }
 354         debug("scanned %d resource managers", rman_idx);
 355         return(0);
 356 }
 357
 358 /*
 359  * Free the list contents.
 360  */
 361 void
 362 devinfo_free(void)
 363 {
 364         struct devinfo_i_dev    *dd;
 365         struct devinfo_i_rman   *dm;
 366         struct devinfo_i_res    *dr;
 367
 368         while ((dd = TAILQ_FIRST(&devinfo_dev)) != NULL) {
 369                 TAILQ_REMOVE(&devinfo_dev, dd, dd_link);
 370                 free(dd);
 371         }
 372         while ((dm = TAILQ_FIRST(&devinfo_rman)) != NULL) {
 373                 TAILQ_REMOVE(&devinfo_rman, dm, dm_link);
 374                 free(dm);
 375         }
 376         while ((dr = TAILQ_FIRST(&devinfo_res)) != NULL) {
 377                 TAILQ_REMOVE(&devinfo_res, dr, dr_link);
 378                 free(dr);
 379         }
 380         devinfo_initted = 0;
 381         devinfo_generation = 0;
 382 }
 383
 384 /*
 385  * Find a device by its handle.
 386  */
 387 struct devinfo_dev *
 388 devinfo_handle_to_device(devinfo_handle_t handle)
 389 {
 390         struct devinfo_i_dev    *dd;
 391
 392         /*
 393          * Find the root device, whose parent is NULL
 394          */
 395         if (handle == DEVINFO_ROOT_DEVICE) {
 396                 TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 397                     if (dd->dd_dev.dd_parent == DEVINFO_ROOT_DEVICE)
 398                             return(&dd->dd_dev);
 399                 return(NULL);
 400         }
 401
 402         /*
 403          * Scan for the device
 404          */
 405         TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 406             if (dd->dd_dev.dd_handle == handle)
 407                     return(&dd->dd_dev);
 408         return(NULL);
 409 }
 410
 411 /*
 412  * Find a resource by its handle.
 413  */
 414 struct devinfo_res *
 415 devinfo_handle_to_resource(devinfo_handle_t handle)
 416 {
 417         struct devinfo_i_res    *dr;
 418
 419         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 420             if (dr->dr_res.dr_handle == handle)
 421                     return(&dr->dr_res);
 422         return(NULL);
 423 }
 424
 425 /*
 426  * Find a resource manager by its handle.
 427  */
 428 struct devinfo_rman *
 429 devinfo_handle_to_rman(devinfo_handle_t handle)
 430 {
 431         struct devinfo_i_rman   *dm;
 432
 433         TAILQ_FOREACH(dm, &devinfo_rman, dm_link)
 434             if (dm->dm_rman.dm_handle == handle)
 435                     return(&dm->dm_rman);
 436         return(NULL);
 437 }
 438
 439 /*
 440  * Iterate over the children of a device, calling (fn) on each.  If
 441  * (fn) returns nonzero, abort the scan and return.
 442  */
 443 int
 444 devinfo_foreach_device_child(struct devinfo_dev *parent,
 445     int (* fn)(struct devinfo_dev *child, void *arg),
 446     void *arg)
 447 {
 448         struct devinfo_i_dev    *dd;
 449         int                             error;
 450
 451         TAILQ_FOREACH(dd, &devinfo_dev, dd_link)
 452             if (dd->dd_dev.dd_parent == parent->dd_handle)
 453                     if ((error = fn(&dd->dd_dev, arg)) != 0)
 454                             return(error);
 455         return(0);
 456 }
 457
 458 /*
 459  * Iterate over all the resources owned by a device, calling (fn) on each.
 460  * If (fn) returns nonzero, abort the scan and return.
 461  */
 462 int
 463 devinfo_foreach_device_resource(struct devinfo_dev *dev,
 464     int (* fn)(struct devinfo_dev *dev, struct devinfo_res *res, void *arg),
 465     void *arg)
 466 {
 467         struct devinfo_i_res    *dr;
 468         int                             error;
 469
 470         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 471             if (dr->dr_res.dr_device == dev->dd_handle)
 472                     if ((error = fn(dev, &dr->dr_res, arg)) != 0)
 473                             return(error);
 474         return(0);
 475 }
 476
 477 /*
 478  * Iterate over all the resources owned by a resource manager, calling (fn)
 479  * on each.  If (fn) returns nonzero, abort the scan and return.
 480  */
 481 extern int
 482 devinfo_foreach_rman_resource(struct devinfo_rman *rman,
 483     int (* fn)(struct devinfo_res *res, void *arg),
 484     void *arg)
 485 {
 486         struct devinfo_i_res    *dr;
 487         int                             error;
 488
 489         TAILQ_FOREACH(dr, &devinfo_res, dr_link)
 490             if (dr->dr_res.dr_rman == rman->dm_handle)
 491                     if ((error = fn(&dr->dr_res, arg)) != 0)
 492                             return(error);
 493         return(0);
 494 }
 495
 496 /*
 497  * Iterate over all the resource managers, calling (fn) on each.  If (fn)
 498  * returns nonzero, abort the scan and return.
 499  */
 500 extern int
 501 devinfo_foreach_rman(int (* fn)(struct devinfo_rman *rman, void *arg),
 502     void *arg)
 503 {
 504     struct devinfo_i_rman       *dm;
 505     int                         error;
 506
 507     TAILQ_FOREACH(dm, &devinfo_rman, dm_link)
 508         if ((error = fn(&dm->dm_rman, arg)) != 0)
 509             return(error);
 510     return(0);
 511 }