Cleanups for 4.4BSD-Lite

[unix-history] / usr / src / sys / ufs / ffs / ufs_disksubr.c

diff --git a/usr/src/sys/ufs/ffs/ufs_disksubr.c b/usr/src/sys/ufs/ffs/ufs_disksubr.c
index 4b53405..e63e109 100644 (file)
--- a/usr/src/sys/ufs/ffs/ufs_disksubr.c
+++ b/usr/src/sys/ufs/ffs/ufs_disksubr.c
@@ -1,81 +1,86 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1982, 1986, 1988, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  *

- *     @(#)ufs_disksubr.c      7.4 (Berkeley) %G%
+ * %sccs.include.redist.c%
+ *
+ *     @(#)ufs_disksubr.c      8.2 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "systm.h"
-#include "buf.h"
-#include "disklabel.h"
-
-#include "dir.h"
-#include "user.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/disklabel.h>
+#include <sys/syslog.h>

 
 /*
 
 /*

- * Seek sort for disks.  We depend on the driver
- * which calls us using b_resid as the current cylinder number.
+ * Seek sort for disks.  We depend on the driver which calls us using b_resid
+ * as the current cylinder number.

  *
  *

- * The argument dp structure holds a b_actf activity chain pointer
- * on which we keep two queues, sorted in ascending cylinder order.
- * The first queue holds those requests which are positioned after
- * the current cylinder (in the first request); the second holds
- * requests which came in after their cylinder number was passed.
- * Thus we implement a one way scan, retracting after reaching the
- * end of the drive to the first request on the second queue,
- * at which time it becomes the first queue.
+ * The argument dp structure holds a b_actf activity chain pointer on which we
+ * keep two queues, sorted in ascending cylinder order.  The first queue holds
+ * those requests which are positioned after the current cylinder (in the first
+ * request); the second holds requests which came in after their cylinder number
+ * was passed.  Thus we implement a one way scan, retracting after reaching the
+ * end of the drive to the first request on the second queue, at which time it
+ * becomes the first queue.

  *
  *

- * A one-way scan is natural because of the way UNIX read-ahead
- * blocks are allocated.
+ * A one-way scan is natural because of the way UNIX read-ahead blocks are
+ * allocated.

  */
 
  */
 

-#define        b_cylin b_resid
+/*
+ * For portability with historic industry practice, the
+ * cylinder number has to be maintained in the `b_resid'
+ * field.
+ */
+#define        b_cylinder      b_resid

 
 

+void

 disksort(dp, bp)
        register struct buf *dp, *bp;
 {
 disksort(dp, bp)
        register struct buf *dp, *bp;
 {

-       register struct buf *ap;
+       register struct buf *bq;

 
 

-       /*
-        * If nothing on the activity queue, then
-        * we become the only thing.
-        */
-       ap = dp->b_actf;
-       if(ap == NULL) {
+       /* If the queue is empty, then it's easy. */
+       if (dp->b_actf == NULL) {
+               bp->b_actf = NULL;

                dp->b_actf = bp;
                dp->b_actf = bp;

-               dp->b_actl = bp;
-               bp->av_forw = NULL;

                return;
        }
                return;
        }

+

        /*
        /*

-        * If we lie after the first (currently active)
-        * request, then we must locate the second request list
-        * and add ourselves to it.
+        * If we lie after the first (currently active) request, then we
+        * must locate the second request list and add ourselves to it.

         */
         */

-       if (bp->b_cylin < ap->b_cylin) {
-               while (ap->av_forw) {
+       bq = dp->b_actf;
+       if (bp->b_cylinder < bq->b_cylinder) {
+               while (bq->b_actf) {

                        /*
                        /*

-                        * Check for an ``inversion'' in the
-                        * normally ascending cylinder numbers,
-                        * indicating the start of the second request list.
+                        * Check for an ``inversion'' in the normally ascending
+                        * cylinder numbers, indicating the start of the second
+                        * request list.

                         */
                         */

-                       if (ap->av_forw->b_cylin < ap->b_cylin) {
+                       if (bq->b_actf->b_cylinder < bq->b_cylinder) {

                                /*
                                /*

-                                * Search the second request list
-                                * for the first request at a larger
-                                * cylinder number.  We go before that;
-                                * if there is no such request, we go at end.
+                                * Search the second request list for the first
+                                * request at a larger cylinder number.  We go
+                                * before that; if there is no such request, we
+                                * go at end.

                                 */
                                do {
                                 */
                                do {

-                                       if (bp->b_cylin < ap->av_forw->b_cylin)
+                                       if (bp->b_cylinder <
+                                           bq->b_actf->b_cylinder)

                                                goto insert;
                                                goto insert;

-                                       ap = ap->av_forw;
-                               } while (ap->av_forw);
+                                       if (bp->b_cylinder ==
+                                           bq->b_actf->b_cylinder &&
+                                           bp->b_blkno < bq->b_actf->b_blkno)
+                                               goto insert;
+                                       bq = bq->b_actf;
+                               } while (bq->b_actf);

                                goto insert;            /* after last */
                        }
                                goto insert;            /* after last */
                        }

-                       ap = ap->av_forw;
+                       bq = bq->b_actf;

                }
                /*
                 * No inversions... we will go after the last, and
                }
                /*
                 * No inversions... we will go after the last, and


@@ -87,37 +92,34 @@ disksort(dp, bp)
         * Request is at/after the current request...
         * sort in the first request list.
         */
         * Request is at/after the current request...
         * sort in the first request list.
         */

-       while (ap->av_forw) {
+       while (bq->b_actf) {

                /*
                /*

-                * We want to go after the current request
-                * if there is an inversion after it (i.e. it is
-                * the end of the first request list), or if
-                * the next request is a larger cylinder than our request.
+                * We want to go after the current request if there is an
+                * inversion after it (i.e. it is the end of the first
+                * request list), or if the next request is a larger cylinder
+                * than our request.

                 */
                 */

-               if (ap->av_forw->b_cylin < ap->b_cylin ||
-                   bp->b_cylin < ap->av_forw->b_cylin)
+               if (bq->b_actf->b_cylinder < bq->b_cylinder ||
+                   bp->b_cylinder < bq->b_actf->b_cylinder ||
+                   (bp->b_cylinder == bq->b_actf->b_cylinder &&
+                   bp->b_blkno < bq->b_actf->b_blkno))

                        goto insert;
                        goto insert;

-               ap = ap->av_forw;
+               bq = bq->b_actf;

        }
        /*
        }
        /*

-        * Neither a second list nor a larger
-        * request... we go at the end of the first list,
-        * which is the same as the end of the whole schebang.
+        * Neither a second list nor a larger request... we go at the end of
+        * the first list, which is the same as the end of the whole schebang.

         */
         */

-insert:
-       bp->av_forw = ap->av_forw;
-       ap->av_forw = bp;
-       if (ap == dp->b_actl)
-               dp->b_actl = bp;
+insert:        bp->b_actf = bq->b_actf;
+       bq->b_actf = bp;

 }
 
 /*
 }
 
 /*

- * Attempt to read a disk label from a device
- * using the indicated stategy routine.
- * The label must be partly set up before this:
- * secpercyl and anything required in the strategy routine
- * (e.g., sector size) must be filled in before calling us.
- * Returns null on success and an error string on failure.
+ * Attempt to read a disk label from a device using the indicated stategy
+ * routine.  The label must be partly set up before this: secpercyl and
+ * anything required in the strategy routine (e.g., sector size) must be
+ * filled in before calling us.  Returns NULL on success and an error
+ * string on failure.

  */
 char *
 readdisklabel(dev, strat, lp)
  */
 char *
 readdisklabel(dev, strat, lp)


@@ -136,24 +138,23 @@ readdisklabel(dev, strat, lp)
                lp->d_partitions[0].p_size = 0x1fffffff;
        lp->d_partitions[0].p_offset = 0;
 
                lp->d_partitions[0].p_size = 0x1fffffff;
        lp->d_partitions[0].p_offset = 0;
 

-       bp = geteblk(lp->d_secsize);
+       bp = geteblk((int)lp->d_secsize);

        bp->b_dev = dev;
        bp->b_blkno = LABELSECTOR;
        bp->b_bcount = lp->d_secsize;
        bp->b_flags = B_BUSY | B_READ;
        bp->b_dev = dev;
        bp->b_blkno = LABELSECTOR;
        bp->b_bcount = lp->d_secsize;
        bp->b_flags = B_BUSY | B_READ;

-       bp->b_cylin = LABELSECTOR / lp->d_secpercyl;
+       bp->b_cylinder = LABELSECTOR / lp->d_secpercyl;

        (*strat)(bp);
        (*strat)(bp);

-       biowait(bp);
-       if (bp->b_flags & B_ERROR) {
-               u.u_error = 0;          /* XXX */
+       if (biowait(bp))

                msg = "I/O error";
                msg = "I/O error";

-       } else for (dlp = (struct disklabel *)bp->b_un.b_addr;
+       else for (dlp = (struct disklabel *)bp->b_un.b_addr;

            dlp <= (struct disklabel *)(bp->b_un.b_addr+DEV_BSIZE-sizeof(*dlp));
            dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
                if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
                        if (msg == NULL)
                                msg = "no disk label";
            dlp <= (struct disklabel *)(bp->b_un.b_addr+DEV_BSIZE-sizeof(*dlp));
            dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
                if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
                        if (msg == NULL)
                                msg = "no disk label";

-               } else if (dkcksum(dlp) != 0)
+               } else if (dlp->d_npartitions > MAXPARTITIONS ||
+                          dkcksum(dlp) != 0)

                        msg = "disk label corrupted";
                else {
                        *lp = *dlp;
                        msg = "disk label corrupted";
                else {
                        *lp = *dlp;


@@ -161,13 +162,103 @@ readdisklabel(dev, strat, lp)
                        break;
                }
        }
                        break;
                }
        }

-       if (lp->d_npartitions > MAXPARTITIONS)
-               lp->d_npartitions = MAXPARTITIONS;

        bp->b_flags = B_INVAL | B_AGE;
        brelse(bp);
        return (msg);
 }
 
        bp->b_flags = B_INVAL | B_AGE;
        brelse(bp);
        return (msg);
 }
 

+/*
+ * Check new disk label for sensibility before setting it.
+ */
+int
+setdisklabel(olp, nlp, openmask)
+       register struct disklabel *olp, *nlp;
+       u_long openmask;
+{
+       register i;
+       register struct partition *opp, *npp;
+
+       if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
+           dkcksum(nlp) != 0)
+               return (EINVAL);
+       while ((i = ffs((long)openmask)) != 0) {
+               i--;
+               openmask &= ~(1 << i);
+               if (nlp->d_npartitions <= i)
+                       return (EBUSY);
+               opp = &olp->d_partitions[i];
+               npp = &nlp->d_partitions[i];
+               if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
+                       return (EBUSY);
+               /*
+                * Copy internally-set partition information
+                * if new label doesn't include it.             XXX
+                */
+               if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
+                       npp->p_fstype = opp->p_fstype;
+                       npp->p_fsize = opp->p_fsize;
+                       npp->p_frag = opp->p_frag;
+                       npp->p_cpg = opp->p_cpg;
+               }
+       }
+       nlp->d_checksum = 0;
+       nlp->d_checksum = dkcksum(nlp);
+       *olp = *nlp;
+       return (0);
+}
+
+/* encoding of disk minor numbers, should be elsewhere... */
+#define dkunit(dev)            (minor(dev) >> 3)
+#define dkpart(dev)            (minor(dev) & 07)
+#define dkminor(unit, part)    (((unit) << 3) | (part))
+
+/*
+ * Write disk label back to device after modification.
+ */
+int
+writedisklabel(dev, strat, lp)
+       dev_t dev;
+       int (*strat)();
+       register struct disklabel *lp;
+{
+       struct buf *bp;
+       struct disklabel *dlp;
+       int labelpart;
+       int error = 0;
+
+       labelpart = dkpart(dev);
+       if (lp->d_partitions[labelpart].p_offset != 0) {
+               if (lp->d_partitions[0].p_offset != 0)
+                       return (EXDEV);                 /* not quite right */
+               labelpart = 0;
+       }
+       bp = geteblk((int)lp->d_secsize);
+       bp->b_dev = makedev(major(dev), dkminor(dkunit(dev), labelpart));
+       bp->b_blkno = LABELSECTOR;
+       bp->b_bcount = lp->d_secsize;
+       bp->b_flags = B_READ;
+       (*strat)(bp);
+       if (error = biowait(bp))
+               goto done;
+       for (dlp = (struct disklabel *)bp->b_un.b_addr;
+           dlp <= (struct disklabel *)
+             (bp->b_un.b_addr + lp->d_secsize - sizeof(*dlp));
+           dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
+               if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC &&
+                   dkcksum(dlp) == 0) {
+                       *dlp = *lp;
+                       bp->b_flags = B_WRITE;
+                       (*strat)(bp);
+                       error = biowait(bp);
+                       goto done;
+               }
+       }
+       error = ESRCH;
+done:
+       brelse(bp);
+       return (error);
+}
+

 /*
  * Compute checksum for disk label.
  */
 /*
  * Compute checksum for disk label.
  */


@@ -183,3 +274,59 @@ dkcksum(lp)
                sum ^= *start++;
        return (sum);
 }
                sum ^= *start++;
        return (sum);
 }

+
+/*
+ * Disk error is the preface to plaintive error messages
+ * about failing disk transfers.  It prints messages of the form
+
+hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
+
+ * if the offset of the error in the transfer and a disk label
+ * are both available.  blkdone should be -1 if the position of the error
+ * is unknown; the disklabel pointer may be null from drivers that have not
+ * been converted to use them.  The message is printed with printf
+ * if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
+ * The message should be completed (with at least a newline) with printf
+ * or addlog, respectively.  There is no trailing space.
+ */
+void
+diskerr(bp, dname, what, pri, blkdone, lp)
+       register struct buf *bp;
+       char *dname, *what;
+       int pri, blkdone;
+       register struct disklabel *lp;
+{
+       int unit = dkunit(bp->b_dev), part = dkpart(bp->b_dev);
+       register void (*pr) __P((const char *, ...));
+       char partname = 'a' + part;
+       int sn;
+
+       if (pri != LOG_PRINTF) {
+               log(pri, "");
+               pr = addlog;
+       } else
+               pr = printf;
+       (*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what,
+           bp->b_flags & B_READ ? "read" : "writ");
+       sn = bp->b_blkno;
+       if (bp->b_bcount <= DEV_BSIZE)
+               (*pr)("%d", sn);
+       else {
+               if (blkdone >= 0) {
+                       sn += blkdone;
+                       (*pr)("%d of ", sn);
+               }
+               (*pr)("%d-%d", bp->b_blkno,
+                   bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
+       }
+       if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
+#ifdef tahoe
+               sn *= DEV_BSIZE / lp->d_secsize;                /* XXX */
+#endif
+               sn += lp->d_partitions[part].p_offset;
+               (*pr)(" (%s%d bn %d; cn %d", dname, unit, sn,
+                   sn / lp->d_secpercyl);
+               sn %= lp->d_secpercyl;
+               (*pr)(" tn %d sn %d)", sn / lp->d_nsectors, sn % lp->d_nsectors);
+       }
+}