sys/kern/kern_conf.c

   1 /*-
   2  * Parts Copyright (c) 1995 Terrence R. Lambert
   3  * Copyright (c) 1995 Julian R. Elischer
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by Terrence R. Lambert.
  17  * 4. The name Terrence R. Lambert may not be used to endorse or promote
  18  *    products derived from this software without specific prior written
  19  *    permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY Julian R. Elischer ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE TERRENCE R. LAMBERT BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $FreeBSD: src/sys/kern/kern_conf.c,v 1.73.2.3 2003/03/10 02:18:25 imp Exp $
  34  * $DragonFly: src/sys/kern/kern_conf.c,v 1.23 2007/05/09 00:53:34 dillon Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/kernel.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/systm.h>
  41 #include <sys/module.h>
  42 #include <sys/malloc.h>
  43 #include <sys/conf.h>
  44 #include <sys/vnode.h>
  45 #include <sys/queue.h>
  46 #include <sys/device.h>
  47 #include <sys/disk.h>
  48 #include <machine/stdarg.h>
  49
  50 #include <sys/sysref2.h>
  51
  52 #include <sys/devfs.h>
  53
  54 MALLOC_DEFINE(M_DEVT, "cdev_t", "dev_t storage");
  55
  56 static int free_devt;
  57 SYSCTL_INT(_debug, OID_AUTO, free_devt, CTLFLAG_RW, &free_devt, 0, "");
  58 int dev_ref_debug = 0;
  59 SYSCTL_INT(_debug, OID_AUTO, dev_refs, CTLFLAG_RW, &dev_ref_debug, 0, "");
  60
  61 /*
  62  * cdev_t and u_dev_t primitives.  Note that the major number is always
  63  * extracted from si_umajor, not from si_devsw, because si_devsw is replaced
  64  * when a device is destroyed.
  65  */
  66 int
  67 major(cdev_t dev)
  68 {
  69         if (dev == NULL)
  70                 return NOUDEV;
  71         return(dev->si_umajor);
  72 }
  73
  74 int
  75 minor(cdev_t dev)
  76 {
  77         if (dev == NULL)
  78                 return NOUDEV;
  79         return(dev->si_uminor);
  80 }
  81
  82 /*
  83  * Compatibility function with old udev_t format to convert the
  84  * non-consecutive minor space into a consecutive minor space.
  85  */
  86 int
  87 lminor(cdev_t dev)
  88 {
  89         int y;
  90
  91         if (dev == NULL)
  92                 return NOUDEV;
  93         y = dev->si_uminor;
  94         if (y & 0x0000ff00)
  95                 return NOUDEV;
  96         return ((y & 0xff) | (y >> 8));
  97 }
  98
  99 /*
 100  * Convert a device pointer to an old style device number.  Return NOUDEV
 101  * if the device is invalid or if the device (maj,min) cannot be converted
 102  * to an old style udev_t.
 103  */
 104 udev_t
 105 dev2udev(cdev_t dev)
 106 {
 107         if (dev == NULL)
 108                 return NOUDEV;
 109
 110         return (udev_t)dev->si_inode;
 111 }
 112
 113 /*
 114  * Convert a device number to a device pointer.  The device is referenced
 115  * ad-hoc, meaning that the caller should call reference_dev() if it wishes
 116  * to keep ahold of the returned structure long term.
 117  *
 118  * The returned device is associated with the currently installed cdevsw
 119  * for the requested major number.  NULL is returned if the major number
 120  * has not been registered.
 121  */
 122 cdev_t
 123 udev2dev(udev_t x, int b)
 124 {
 125         if (x == NOUDEV || b != 0)
 126                 return(NULL);
 127
 128         return devfs_find_device_by_udev(x);
 129 }
 130
 131 int
 132 dev_is_good(cdev_t dev)
 133 {
 134         if (dev != NULL && dev->si_ops != &dead_dev_ops)
 135                 return(1);
 136         return(0);
 137 }
 138
 139 /*
 140  * Various user device number extraction and conversion routines
 141  */
 142 int
 143 uminor(udev_t dev)
 144 {
 145         if (dev == NOUDEV)
 146                 return(-1);
 147         return(dev & 0xffff00ff);
 148 }
 149
 150 int
 151 umajor(udev_t dev)
 152 {
 153         if (dev == NOUDEV)
 154                 return(-1);
 155         return((dev & 0xff00) >> 8);
 156 }
 157
 158 udev_t
 159 makeudev(int x, int y)
 160 {
 161         if ((x & 0xffffff00) || (y & 0x0000ff00))
 162                 return NOUDEV;
 163         return ((x << 8) | y);
 164 }
 165
 166 /*
 167  * Create an internal or external device.
 168  *
 169  * This routine creates and returns an unreferenced ad-hoc entry for the
 170  * device which will remain intact until the device is destroyed.  If the
 171  * caller intends to store the device pointer it must call reference_dev()
 172  * to retain a real reference to the device.
 173  *
 174  * If an entry already exists, this function will set (or override)
 175  * its cred requirements and name (XXX DEVFS interface).
 176  */
 177 cdev_t
 178 make_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
 179         int perms, const char *fmt, ...)
 180 {
 181         cdev_t  devfs_dev;
 182         __va_list ap;
 183
 184         /*
 185          * compile the cdevsw and install the device
 186          */
 187         compile_dev_ops(ops);
 188
 189         devfs_dev = devfs_new_cdev(ops, minor, NULL);
 190         __va_start(ap, fmt);
 191         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
 192                     32, fmt, ap);
 193         __va_end(ap);
 194
 195         devfs_debug(DEVFS_DEBUG_INFO,
 196                     "make_dev called for %s\n",
 197                     devfs_dev->si_name);
 198         devfs_create_dev(devfs_dev, uid, gid, perms);
 199
 200         return (devfs_dev);
 201 }
 202
 203 /*
 204  * make_dev_covering has equivalent functionality to make_dev, except that it
 205  * also takes the cdev of the underlying device. Hence this function should
 206  * only be used by systems and drivers which create devices covering others
 207  */
 208 cdev_t
 209 make_dev_covering(struct dev_ops *ops, struct dev_ops *bops, int minor,
 210             uid_t uid, gid_t gid, int perms, const char *fmt, ...)
 211 {
 212         cdev_t  devfs_dev;
 213         __va_list ap;
 214
 215         /*
 216          * compile the cdevsw and install the device
 217          */
 218         compile_dev_ops(ops);
 219
 220         devfs_dev = devfs_new_cdev(ops, minor, bops);
 221         __va_start(ap, fmt);
 222         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
 223                     32, fmt, ap);
 224         __va_end(ap);
 225
 226         devfs_debug(DEVFS_DEBUG_INFO,
 227                     "make_dev called for %s\n",
 228                     devfs_dev->si_name);
 229         devfs_create_dev(devfs_dev, uid, gid, perms);
 230
 231         return (devfs_dev);
 232 }
 233
 234
 235
 236 cdev_t
 237 make_only_devfs_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
 238         int perms, const char *fmt, ...)
 239 {
 240         cdev_t  devfs_dev;
 241         __va_list ap;
 242
 243         /*
 244          * compile the cdevsw and install the device
 245          */
 246         compile_dev_ops(ops);
 247         devfs_dev = devfs_new_cdev(ops, minor, NULL);
 248
 249         /*
 250          * Set additional fields (XXX DEVFS interface goes here)
 251          */
 252         __va_start(ap, fmt);
 253         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
 254                     32, fmt, ap);
 255         __va_end(ap);
 256
 257         devfs_create_dev(devfs_dev, uid, gid, perms);
 258
 259         return (devfs_dev);
 260 }
 261
 262 cdev_t
 263 make_only_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
 264         int perms, const char *fmt, ...)
 265 {
 266         cdev_t  devfs_dev;
 267         __va_list ap;
 268
 269         /*
 270          * compile the cdevsw and install the device
 271          */
 272         compile_dev_ops(ops);
 273         devfs_dev = devfs_new_cdev(ops, minor, NULL);
 274         devfs_dev->si_perms = perms;
 275         devfs_dev->si_uid = uid;
 276         devfs_dev->si_gid = gid;
 277
 278         /*
 279          * Set additional fields (XXX DEVFS interface goes here)
 280          */
 281         __va_start(ap, fmt);
 282         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
 283                     32, fmt, ap);
 284         __va_end(ap);
 285
 286         reference_dev(devfs_dev);
 287
 288         return (devfs_dev);
 289 }
 290
 291 cdev_t
 292 make_only_dev_covering(struct dev_ops *ops, struct dev_ops *bops, int minor,
 293         uid_t uid, gid_t gid, int perms, const char *fmt, ...)
 294 {
 295         cdev_t  devfs_dev;
 296         __va_list ap;
 297
 298         /*
 299          * compile the cdevsw and install the device
 300          */
 301         compile_dev_ops(ops);
 302         devfs_dev = devfs_new_cdev(ops, minor, bops);
 303         devfs_dev->si_perms = perms;
 304         devfs_dev->si_uid = uid;
 305         devfs_dev->si_gid = gid;
 306
 307         /*
 308          * Set additional fields (XXX DEVFS interface goes here)
 309          */
 310         __va_start(ap, fmt);
 311         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
 312                     32, fmt, ap);
 313         __va_end(ap);
 314
 315         reference_dev(devfs_dev);
 316
 317         return (devfs_dev);
 318 }
 319
 320 void
 321 destroy_only_dev(cdev_t dev)
 322 {
 323         release_dev(dev);
 324         release_dev(dev);
 325         release_dev(dev);
 326 }
 327
 328 /*
 329  * destroy_dev() removes the adhoc association for a device and revectors
 330  * its ops to &dead_dev_ops.
 331  *
 332  * This routine releases the reference count associated with the ADHOC
 333  * entry, plus releases the reference count held by the caller.  What this
 334  * means is that you should not call destroy_dev(make_dev(...)), because
 335  * make_dev() does not bump the reference count (beyond what it needs to
 336  * create the ad-hoc association).  Any procedure that intends to destroy
 337  * a device must have its own reference to it first.
 338  */
 339 void
 340 destroy_dev(cdev_t dev)
 341 {
 342         if (dev) {
 343                 devfs_debug(DEVFS_DEBUG_DEBUG,
 344                             "destroy_dev called for %s\n",
 345                             dev->si_name);
 346                 devfs_destroy_dev(dev);
 347         }
 348 }
 349
 350 /*
 351  * Make sure all asynchronous disk and devfs related operations have
 352  * completed.
 353  *
 354  * Typically called prior to mountroot to ensure that all disks have
 355  * been completely probed and on module unload to ensure that ops
 356  * structures have been dereferenced.
 357  */
 358 void
 359 sync_devs(void)
 360 {
 361         disk_config(NULL);
 362         devfs_config();
 363         disk_config(NULL);
 364         devfs_config();
 365 }
 366
 367 int
 368 make_dev_alias(cdev_t target, const char *fmt, ...)
 369 {
 370         __va_list ap;
 371         char *name;
 372
 373         __va_start(ap, fmt);
 374         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
 375         __va_end(ap);
 376
 377         devfs_make_alias(name, target);
 378         kvasfree(&name);
 379
 380         return 0;
 381 }
 382
 383 int
 384 destroy_dev_alias(cdev_t target, const char *fmt, ...)
 385 {
 386         __va_list ap;
 387         char *name;
 388
 389         __va_start(ap, fmt);
 390         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
 391         __va_end(ap);
 392
 393         devfs_destroy_alias(name, target);
 394         kvasfree(&name);
 395
 396         return 0;
 397 }
 398
 399 extern struct dev_ops default_dev_ops;
 400
 401 cdev_t
 402 make_autoclone_dev(struct dev_ops *ops, struct devfs_bitmap *bitmap,
 403                 d_clone_t *nhandler, uid_t uid, gid_t gid, int perms, const char *fmt, ...)
 404 {
 405         __va_list ap;
 406         cdev_t dev;
 407         char *name;
 408
 409         __va_start(ap, fmt);
 410         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
 411         __va_end(ap);
 412
 413         if (bitmap != NULL)
 414                 devfs_clone_bitmap_init(bitmap);
 415
 416         devfs_clone_handler_add(name, nhandler);
 417         dev = make_dev_covering(&default_dev_ops, ops, 0xffff00ff,
 418                        uid, gid, perms, "%s", name);
 419         kvasfree(&name);
 420         return dev;
 421 }
 422
 423 void
 424 destroy_autoclone_dev(cdev_t dev, struct devfs_bitmap *bitmap)
 425 {
 426         if (dev == NULL)
 427                 return;
 428
 429         devfs_clone_handler_del(dev->si_name);
 430
 431         if (bitmap != NULL)
 432                 devfs_clone_bitmap_uninit(bitmap);
 433
 434         destroy_dev(dev);
 435 }
 436
 437
 438 /*
 439  * Add a reference to a device.  Callers generally add their own references
 440  * when they are going to store a device node in a variable for long periods
 441  * of time, to prevent a disassociation from free()ing the node.
 442  *
 443  * Also note that a caller that intends to call destroy_dev() must first
 444  * obtain a reference on the device.  The ad-hoc reference you get with
 445  * make_dev() and friends is NOT sufficient to be able to call destroy_dev().
 446  */
 447 cdev_t
 448 reference_dev(cdev_t dev)
 449 {
 450         //kprintf("reference_dev\n");
 451
 452         if (dev != NULL) {
 453                 sysref_get(&dev->si_sysref);
 454                 if (dev_ref_debug & 2) {
 455                         kprintf("reference dev %p %s(minor=%08x) refs=%d\n",
 456                             dev, devtoname(dev), dev->si_uminor,
 457                             dev->si_sysref.refcnt);
 458                 }
 459         }
 460         return(dev);
 461 }
 462
 463 /*
 464  * release a reference on a device.  The device will be terminated when the
 465  * last reference has been released.
 466  *
 467  * NOTE: we must use si_umajor to figure out the original major number,
 468  * because si_ops could already be pointing at dead_dev_ops.
 469  */
 470 void
 471 release_dev(cdev_t dev)
 472 {
 473         //kprintf("release_dev\n");
 474
 475         if (dev == NULL)
 476                 return;
 477         sysref_put(&dev->si_sysref);
 478 }
 479
 480 const char *
 481 devtoname(cdev_t dev)
 482 {
 483         int mynor;
 484         int len;
 485         char *p;
 486         const char *dname;
 487
 488         if (dev == NULL)
 489                 return("#nodev");
 490         if (dev->si_name[0] == '#' || dev->si_name[0] == '\0') {
 491                 p = dev->si_name;
 492                 len = sizeof(dev->si_name);
 493                 if ((dname = dev_dname(dev)) != NULL)
 494                         ksnprintf(p, len, "#%s/", dname);
 495                 else
 496                         ksnprintf(p, len, "#%d/", major(dev));
 497                 len -= strlen(p);
 498                 p += strlen(p);
 499                 mynor = minor(dev);
 500                 if (mynor < 0 || mynor > 255)
 501                         ksnprintf(p, len, "%#x", (u_int)mynor);
 502                 else
 503                         ksnprintf(p, len, "%d", mynor);
 504         }
 505         return (dev->si_name);
 506 }
 507