DEVFS - Remove numerous leftovers of the old device code.
authorMatthew Dillon <dillon@apollo.backplane.com>
Thu, 6 Aug 2009 00:30:32 +0000 (17:30 -0700)
committerMatthew Dillon <dillon@apollo.backplane.com>
Thu, 6 Aug 2009 00:30:32 +0000 (17:30 -0700)
* Remove hashdev(), make_adhoc_dev(), make_sub_dev(), cdev_terminate(),
 dkmodpart(), and dkmodslice().

* Minor cleanup of pty code.

sys/kern/kern_conf.c
sys/kern/subr_diskslice.c
sys/kern/tty_pty.c
sys/sys/diskslice.h

index 3a7b4cf..4a47dbd 100644 (file)
 
 #include <vfs/devfs/devfs.h>
 
-
-static void cdev_terminate(struct cdev *dev);
-
 MALLOC_DEFINE(M_DEVT, "cdev_t", "dev_t storage");
 
-/*
- * SYSREF Integration - reference counting, allocation,
- * sysid and syslink integration.
- */
-static struct sysref_class     cdev_sysref_class = {
-       .name =         "cdev",
-       .mtype =        M_DEVT,
-       .proto =        SYSREF_PROTO_DEV,
-       .offset =       offsetof(struct cdev, si_sysref),
-       .objsize =      sizeof(struct cdev),
-       .mag_capacity = 32,
-       .flags =        0,
-       .ops =  {
-               .terminate = (sysref_terminate_func_t)cdev_terminate
-       }
-};
-
-/*
- * This is the number of hash-buckets.  Experiements with 'real-life'
- * udev_t's show that a prime halfway between two powers of two works
- * best.
- */
-#define DEVT_HASH 128  /* must be power of 2 */
-static LIST_HEAD(, cdev) dev_hash[DEVT_HASH];
-
 static int free_devt;
 SYSCTL_INT(_debug, OID_AUTO, free_devt, CTLFLAG_RW, &free_devt, 0, "");
 int dev_ref_debug = 0;
@@ -123,68 +95,6 @@ lminor(cdev_t dev)
        return ((y & 0xff) | (y >> 8));
 }
 
-/*
- * This is a bit complex because devices are always created relative to
- * a particular cdevsw, including 'hidden' cdevsw's (such as the raw device
- * backing a disk subsystem overlay), so we have to compare both the
- * devsw and udev fields to locate the correct device.
- *
- * The device is created if it does not already exist.  If SI_ADHOC is not
- * set the device will be referenced (once) and SI_ADHOC will be set.
- * The caller must explicitly add additional references to the device if
- * the caller wishes to track additional references.
- *
- * NOTE: The passed ops vector must normally match the device.  This is
- * because the kernel may create shadow devices that are INVISIBLE TO
- * USERLAND.  For example, the block device backing a disk is created
- * as a shadow underneath the user-visible disklabel management device.
- * Sometimes a device ops vector can be overridden, such as by /dev/console.
- * In this case and this case only we allow a match when the ops vector
- * otherwise would not match.
- */
-static
-int
-__devthash(int x, int y)
-{
-       return(((x << 2) ^ y) & (DEVT_HASH - 1));
-}
-
-static
-cdev_t
-hashdev(struct dev_ops *ops, int x, int y, int allow_intercept)
-{
-       struct cdev *si;
-       int hash;
-
-       hash = __devthash(x, y);
-       LIST_FOREACH(si, &dev_hash[hash], si_hash) {
-               if (si->si_umajor == x && si->si_uminor == y) {
-                       if (si->si_ops == ops)
-                               return (si);
-                       if (allow_intercept && (si->si_flags & SI_INTERCEPTED))
-                               return (si);
-               }
-       }
-       si = sysref_alloc(&cdev_sysref_class);
-       si->si_ops = ops;
-       si->si_flags |= SI_HASHED | SI_ADHOC;
-       si->si_umajor = x;
-       si->si_uminor = y;
-       si->si_inode = 0;
-       LIST_INSERT_HEAD(&dev_hash[hash], si, si_hash);
-       sysref_activate(&si->si_sysref);
-
-       dev_dclone(si);
-       if (ops != &dead_dev_ops)
-               ++ops->head.refs;
-       if (dev_ref_debug & 1) {
-               kprintf("create    dev %p %s(minor=%08x) refs=%d\n", 
-                       si, devtoname(si), y,
-                       si->si_sysref.refcnt);
-       }
-        return (si);
-}
-
 /*
  * Convert a device pointer to an old style device number.  Return NOUDEV
  * if the device is invalid or if the device (maj,min) cannot be converted
@@ -373,39 +283,6 @@ destroy_only_dev(cdev_t dev)
        release_dev(dev);
 }
 
-
-/*
- * This function is similar to make_dev() but no cred information or name
- * need be specified.
- */
-cdev_t
-make_adhoc_dev(struct dev_ops *ops, int minor)
-{
-       cdev_t dev;
-
-       dev = hashdev(ops, ops->head.maj, minor, FALSE);
-       return(dev);
-}
-
-/*
- * This function is similar to make_dev() except the new device is created
- * using an old device as a template.
- */
-cdev_t
-make_sub_dev(cdev_t odev, int minor)
-{
-       cdev_t  dev;
-
-       dev = hashdev(odev->si_ops, odev->si_umajor, minor, FALSE);
-
-       /*
-        * Copy cred requirements and name info XXX DEVFS.
-        */
-       if (dev->si_name[0] == 0 && odev->si_name[0])
-               bcopy(odev->si_name, dev->si_name, sizeof(dev->si_name));
-       return (dev);
-}
-
 /*
  * destroy_dev() removes the adhoc association for a device and revectors
  * its ops to &dead_dev_ops.
@@ -420,8 +297,6 @@ make_sub_dev(cdev_t odev, int minor)
 void
 destroy_dev(cdev_t dev)
 {
-       int hash;
-
        if (dev) {
                devfs_debug(DEVFS_DEBUG_DEBUG,
                            "destroy_dev called for %s\n",
@@ -511,62 +386,6 @@ release_dev(cdev_t dev)
        sysref_put(&dev->si_sysref);
 }
 
-static
-void
-cdev_terminate(struct cdev *dev)
-{
-       int messedup = 0;
-
-       if (dev_ref_debug & 4) {
-               kprintf("release   dev %p %s(minor=%08x) refs=%d\n", 
-                       dev, devtoname(dev), dev->si_uminor,
-                       dev->si_sysref.refcnt);
-       }
-       if (dev->si_flags & SI_ADHOC) {
-               kprintf("Warning: illegal final release on ADHOC"
-                       " device %p(%s), the device was never"
-                       " destroyed!\n",
-                       dev, devtoname(dev));
-               if (dev_ref_debug & 0x8000)
-                       Debugger("cdev_terminate");
-               messedup = 1;
-       }
-       if (dev->si_flags & SI_HASHED) {
-               kprintf("Warning: last release on device, no call"
-                       " to destroy_dev() was made! dev %p(%s)\n",
-                       dev, devtoname(dev));
-               if (dev_ref_debug & 0x8000)
-                       Debugger("cdev_terminate");
-               reference_dev(dev);
-               destroy_dev(dev);
-               messedup = 1;
-       }
-       if (dev->si_flags & SI_DEVFS_LINKED) {
-               kprintf("Warning: last release on device, still "
-                       "devfs-linked dev %p(%s)\n",
-                       dev, devtoname(dev));
-               if (dev_ref_debug & 0x8000)
-                       Debugger("cdev_terminate");
-               reference_dev(dev);
-               destroy_dev(dev);
-               messedup = 1;
-       }
-       if (SLIST_FIRST(&dev->si_hlist) != NULL) {
-               kprintf("Warning: last release on device, vnode"
-                       " associations still exist! dev %p(%s)\n",
-                       dev, devtoname(dev));
-               if (dev_ref_debug & 0x8000)
-                       Debugger("cdev_terminate");
-               messedup = 1;
-       }
-       if (dev->si_ops && dev->si_ops != &dead_dev_ops) {
-               dev_ops_release(dev->si_ops);
-               dev->si_ops = NULL;
-       }
-       if (messedup == 0) 
-               sysref_put(&dev->si_sysref);
-}
-
 const char *
 devtoname(cdev_t dev)
 {
index df59d18..6c5763c 100644 (file)
@@ -610,48 +610,6 @@ dsioctl(cdev_t dev, u_long cmd, caddr_t data, int flags,
 
                disk_msg_send_sync(DISK_DISK_REPROBE, dev->si_disk, NULL);
                return 0;
-#if 0
-               /*
-                * Temporarily forget the current slices struct and read
-                * the current one.
-                *
-                * NOTE:
-                *
-                * XXX should wait for current accesses on this disk to
-                * complete, then lock out future accesses and opens.
-                */
-               kprintf("dsioctl messed with our stuff!\n");
-               *sspp = NULL;
-               error = dsopen(dev, S_IFCHR, ssp->dss_oflags, sspp, info);
-               if (error != 0) {
-                       *sspp = ssp;
-                       return (error);
-               }
-
-               /*
-                * Reopen everything.  This is a no-op except in the "force"
-                * case and when the raw bdev and cdev are both open.  Abort
-                * if anything fails.
-                */
-               for (slice = 0; slice < ssp->dss_nslices; slice++) {
-                       for (part = 0; part < DKMAXPARTITIONS; ++part) {
-                               if (!dschkmask(&ssp->dss_slices[slice], part))
-                                       continue;
-                               error = dsopen(dkmodslice(dkmodpart(dev, part),
-                                                         slice),
-                                              S_IFCHR, ssp->dss_oflags, sspp,
-                                              info);
-                               if (error != 0) {
-                                       *sspp = ssp;
-                                       return (EBUSY);
-                               }
-                       }
-               }
-
-               //XXX: recheck this...
-               dsgone(&ssp);
-               return (0);
-#endif
 
        case DIOCWDINFO32:
        case DIOCWDINFO64:
@@ -763,7 +721,7 @@ dsname(cdev_t dev, int unit, int slice, int part, char *partname)
  */
 int
 dsopen(cdev_t dev, int mode, u_int flags, 
-       struct diskslices **sspp, struct disk_info *info)
+       struct diskslices **sspp, struct disk_info *info)
 {
        cdev_t dev1;
        int error;
@@ -781,165 +739,6 @@ dsopen(cdev_t dev, int mode, u_int flags,
        dssetmask(sp, part);
 
        return 0;
-
-       /*
-        * Do not attempt to read the slice table or disk label when
-        * accessing the whole-disk slice or a while-slice partition.
-        */
-       if (dkslice(dev) == WHOLE_DISK_SLICE)
-               flags |= DSO_ONESLICE | DSO_NOLABELS;
-       if (dkpart(dev) == WHOLE_SLICE_PART)
-               flags |= DSO_NOLABELS;
-
-       /*
-        * Reinitialize the slice table unless there is an open device
-        * on the unit.
-        *
-        * It would be nice if we didn't have to do this but when a
-        * user is slicing and partitioning up a disk it is a lot safer
-        * to not take any chances.
-        */
-       ssp = *sspp;
-       need_init = !dsisopen(ssp);
-       if (ssp != NULL && need_init)
-               dsgone(sspp);
-       if (need_init) {
-               /*
-                * Allocate a minimal slices "struct".  This will become
-                * the final slices "struct" if we don't want real slices
-                * or if we can't find any real slices.
-                *
-                * Then scan the disk
-                */
-               *sspp = dsmakeslicestruct(BASE_SLICE, info);
-
-               if ((flags & DSO_ONESLICE) == 0) {
-                       error = mbrinit(dev, info, sspp);
-                       if (error != 0) {
-                               dsgone(sspp);
-                               return (error);
-                       }
-               }
-               ssp = *sspp;
-               ssp->dss_oflags = flags;
-
-               /*
-                * If there are no real slices, then make the compatiblity
-                * slice cover the whole disk.
-                */
-               if (ssp->dss_nslices == BASE_SLICE) {
-                       sp = &ssp->dss_slices[COMPATIBILITY_SLICE];
-
-                       sp->ds_size = info->d_media_blocks;
-                       sp->ds_reserved = 0;
-               }
-
-               /*
-                * Set dss_first_bsd_slice to point at the first BSD
-                * slice, if any.
-                */
-               for (slice = BASE_SLICE; slice < ssp->dss_nslices; slice++) {
-                       sp = &ssp->dss_slices[slice];
-                       if (sp->ds_type == DOSPTYP_386BSD /* XXX */) {
-#if 0
-                               struct diskslice *csp;
-#endif
-
-                               ssp->dss_first_bsd_slice = slice;
-#if 0
-                               /*
-                                * no longer supported, s0 is a real slice
-                                * for GPT
-                                */
-                               csp = &ssp->dss_slices[COMPATIBILITY_SLICE];
-                               csp->ds_offset = sp->ds_offset;
-                               csp->ds_size = sp->ds_size;
-                               csp->ds_type = sp->ds_type;
-                               csp->ds_reserved = sp->ds_reserved;
-#endif
-                               break;
-                       }
-               }
-
-               /*
-                * By definition accesses via the whole-disk device do not
-                * specify any reserved areas.  The whole disk may be read
-                * or written by the whole-disk device.
-                *
-                * The whole-disk slice does not ever have a label.
-                */
-               sp = &ssp->dss_slices[WHOLE_DISK_SLICE];
-               sp->ds_wlabel = TRUE;
-               sp->ds_reserved = 0;
-       }
-
-       /*
-        * Load the disklabel for the slice being accessed unless it is
-        * a whole-disk-slice or a whole-slice-partition (as determined
-        * by DSO_NOLABELS).
-        *
-        * We could scan all slices here and try to load up their
-        * disklabels, but that would cause us to access slices that
-        * the user may otherwise not intend us to access, or corrupted
-        * slices, etc.
-        *
-        * XXX if there are no opens on the slice we may want to re-read
-        * the disklabel anyway, even if we have one cached.
-        */
-       slice = dkslice(dev);
-       if (slice >= ssp->dss_nslices)
-               return (ENXIO);
-       sp = &ssp->dss_slices[slice];
-       part = dkpart(dev);
-
-       if ((flags & DSO_NOLABELS) == 0 && sp->ds_label.opaque == NULL) {
-               dev1 = dkmodslice(dkmodpart(dev, WHOLE_SLICE_PART), slice);
-
-               /*
-                * If opening a raw disk we do not try to
-                * read the disklabel now.  No interpretation of raw disks
-                * (e.g. like 'da0') ever occurs.  We will try to read the
-                * disklabel for a raw slice if asked to via DIOC* ioctls.
-                *
-                * Access to the label area is disallowed by default.  Note
-                * however that accesses via WHOLE_DISK_SLICE, and accesses
-                * via WHOLE_SLICE_PART for slices without valid disklabels,
-                * will allow writes and ignore the flag.
-                */
-               set_ds_wlabel(ssp, slice, FALSE);
-               dsreadandsetlabel(dev1, flags, ssp, sp, info);
-       }
-
-       /*
-        * If opening a particular partition the disklabel must exist and
-        * the partition must be present in the label.
-        *
-        * If the partition is the special whole-disk-slice no partition
-        * table need exist.
-        */
-       if (part != WHOLE_SLICE_PART && slice != WHOLE_DISK_SLICE) {
-               if (sp->ds_label.opaque == NULL ||
-                   part >= sp->ds_ops->op_getnumparts(sp->ds_label)) {
-                       return (EINVAL);
-               }
-       }
-
-       /*
-        * Do not allow special raw-extension partitions to be opened
-        * if the device doesn't support them.  Raw-extension partitions
-        * are typically used to handle CD tracks.
-        */
-       if (slice == WHOLE_DISK_SLICE && part >= 128 &&
-           part != WHOLE_SLICE_PART) {
-               if ((info->d_dsflags & DSO_RAWEXTENSIONS) == 0)
-                       return (EINVAL);
-       }
-
-       /*
-        * Ok, we are open
-        */
-       dssetmask(sp, part);
-       return (0);
 }
 
 /*
index 787ed8f..fd2596d 100644 (file)
@@ -81,7 +81,9 @@ static        d_close_t       ptcclose;
 static d_read_t        ptcread;
 static d_write_t       ptcwrite;
 static d_poll_t        ptcpoll;
+#if 0
 static d_clone_t       ptyclone;
+#endif
 
 #define        CDEV_MAJOR_S    5
 static struct dev_ops pts_ops = {
@@ -160,6 +162,7 @@ ptyinit(int n)
        ttyregister(&pt->pt_tty);
 }
 
+#if 0
 static int
 ptyclone(struct dev_clone_args *ap)
 {
@@ -186,6 +189,7 @@ ptyclone(struct dev_clone_args *ap)
 
        return 0;
 }
+#endif
 
 /*ARGSUSED*/
 static int
@@ -194,26 +198,8 @@ ptsopen(struct dev_open_args *ap)
        cdev_t dev = ap->a_head.a_dev;
        struct tty *tp;
        int error;
-#if 0
-       int minr;
-       cdev_t nextdev;
-#endif
        struct pt_ioctl *pti;
 
-#if 0
-       minr = lminor(dev);
-       /*
-        * REMOVED gross hack for devfs.  also note that makedev()
-        * no longer exists in this form and reference counting makes
-        * this a problem if we don't clean it out later.
-        */
-       if (minr < 255) {
-               nextdev = make_sub_dev(dev, minr + 1);
-               if (!nextdev->si_drv1) {
-                       ptyinit(minr + 1);
-               }
-       }
-#endif
        if (!dev->si_drv1)
                ptyinit(minor(dev));
        if (!dev->si_drv1)
index 9fe748f..a3e2a7c 100644 (file)
@@ -327,27 +327,6 @@ dkpart(cdev_t dev)
        return(val);
 }
 
-/*
- * dkmodpart() - create sub-device
- */
-static __inline cdev_t
-dkmodpart(cdev_t dev, int part)
-{
-       u_int32_t val;
-
-       val = (minor(dev) & ~dkmakepart(-1)) | dkmakepart(part);
-       return (make_sub_dev(dev, val));
-}
-
-static __inline cdev_t
-dkmodslice(cdev_t dev, int slice)
-{
-       u_int32_t val;
-
-       val = (minor(dev) & ~dkmakeslice(-1)) | dkmakeslice(slice);
-       return (make_sub_dev(dev, val));
-}
-
 #endif
 
 /*