root/kern/subr_disk.c

DEFINITIONS

1. disksort
2. dkcksum
3. initdisklabel
4. checkdisklabel
5. readdoslabel
6. setdisklabel
7. bounds_check_with_label
8. diskerr
9. disk_init
10. disk_construct
11. disk_attach
12. disk_detach
13. disk_busy
14. disk_unbusy
15. disk_lock
16. disk_unlock
17. dk_mountroot
18. bufq_default_alloc
19. bufq_default_free
20. bufq_default_add
21. bufq_default_get
22. getdisk
23. parsedisk
24. setroot
25. findblkmajor
26. findblkname

    1 /*      $OpenBSD: subr_disk.c,v 1.64 2007/08/05 04:26:21 krw Exp $      */
    2 /*      $NetBSD: subr_disk.c,v 1.17 1996/03/16 23:17:08 christos Exp $  */
    4 /*
    5  * Copyright (c) 1995 Jason R. Thorpe.  All rights reserved.
    6  * Copyright (c) 1982, 1986, 1988, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  * (c) UNIX System Laboratories, Inc.
    9  * All or some portions of this file are derived from material licensed
   10  * to the University of California by American Telephone and Telegraph
   11  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
   12  * the permission of UNIX System Laboratories, Inc.
   13  *
   14  * Redistribution and use in source and binary forms, with or without
   15  * modification, are permitted provided that the following conditions
   16  * are met:
   17  * 1. Redistributions of source code must retain the above copyright
   18  *    notice, this list of conditions and the following disclaimer.
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  * 3. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)ufs_disksubr.c      8.5 (Berkeley) 1/21/94
   39  */
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/kernel.h>
   44 #include <sys/malloc.h>
   45 #include <sys/fcntl.h>
   46 #include <sys/buf.h>
   47 #include <sys/stat.h>
   48 #include <sys/syslog.h>
   49 #include <sys/device.h>
   50 #include <sys/time.h>
   51 #include <sys/disklabel.h>
   52 #include <sys/conf.h>
   53 #include <sys/lock.h>
   54 #include <sys/disk.h>
   55 #include <sys/reboot.h>
   56 #include <sys/dkio.h>
   57 #include <sys/dkstat.h>         /* XXX */
   58 #include <sys/proc.h>
   59 #include <uvm/uvm_extern.h>
   61 #include <dev/rndvar.h>
   62 #include <dev/cons.h>
   64 /*
   65  * A global list of all disks attached to the system.  May grow or
   66  * shrink over time.
   67  */
   68 struct  disklist_head disklist; /* TAILQ_HEAD */
   69 int     disk_count;             /* number of drives in global disklist */
   70 int     disk_change;            /* set if a disk has been attached/detached
   71                                  * since last we looked at this variable. This
   72                                  * is reset by hw_sysctl()
   73                                  */
   75 /*
   76  * Seek sort for disks.  We depend on the driver which calls us using b_resid
   77  * as the current cylinder number.
   78  *
   79  * The argument ap structure holds a b_actf activity chain pointer on which we
   80  * keep two queues, sorted in ascending cylinder order.  The first queue holds
   81  * those requests which are positioned after the current cylinder (in the first
   82  * request); the second holds requests which came in after their cylinder number
   83  * was passed.  Thus we implement a one way scan, retracting after reaching the
   84  * end of the drive to the first request on the second queue, at which time it
   85  * becomes the first queue.
   86  *
   87  * A one-way scan is natural because of the way UNIX read-ahead blocks are
   88  * allocated.
   89  */
   91 void
disksort(struct buf *ap, struct buf *bp)
   93 {
   94         struct buf *bq;
   96         /* If the queue is empty, then it's easy. */
   97         if (ap->b_actf == NULL) {
bp->b_actf = NULL;
ap->b_actf = bp;
  100                 return;
  101         }
  103         /*
  104          * If we lie after the first (currently active) request, then we
  105          * must locate the second request list and add ourselves to it.
  106          */
bq = ap->b_actf;
  108         if (bp->b_cylinder < bq->b_cylinder) {
  109                 while (bq->b_actf) {
  110                         /*
  111                          * Check for an ``inversion'' in the normally ascending
  112                          * cylinder numbers, indicating the start of the second
  113                          * request list.
  114                          */
  115                         if (bq->b_actf->b_cylinder < bq->b_cylinder) {
  116                                 /*
  117                                  * Search the second request list for the first
  118                                  * request at a larger cylinder number.  We go
  119                                  * before that; if there is no such request, we
  120                                  * go at end.
  121                                  */
  122                                 do {
  123                                         if (bp->b_cylinder <
bq->b_actf->b_cylinder)
  125                                                 goto insert;
  126                                         if (bp->b_cylinder ==
bq->b_actf->b_cylinder &&
bp->b_blkno < bq->b_actf->b_blkno)
  129                                                 goto insert;
bq = bq->b_actf;
  131                                 } while (bq->b_actf);
  132                                 goto insert;            /* after last */
  133                         }
bq = bq->b_actf;
  135                 }
  136                 /*
  137                  * No inversions... we will go after the last, and
  138                  * be the first request in the second request list.
  139                  */
  140                 goto insert;
  141         }
  142         /*
  143          * Request is at/after the current request...
  144          * sort in the first request list.
  145          */
  146         while (bq->b_actf) {
  147                 /*
  148                  * We want to go after the current request if there is an
  149                  * inversion after it (i.e. it is the end of the first
  150                  * request list), or if the next request is a larger cylinder
  151                  * than our request.
  152                  */
  153                 if (bq->b_actf->b_cylinder < bq->b_cylinder ||
bp->b_cylinder < bq->b_actf->b_cylinder ||
  155                     (bp->b_cylinder == bq->b_actf->b_cylinder &&
bp->b_blkno < bq->b_actf->b_blkno))
  157                         goto insert;
bq = bq->b_actf;
  159         }
  160         /*
  161          * Neither a second list nor a larger request... we go at the end of
  162          * the first list, which is the same as the end of the whole schebang.
  163          */
insert: bp->b_actf = bq->b_actf;
bq->b_actf = bp;
  166 }
  168 /*
  169  * Compute checksum for disk label.
  170  */
u_int
dkcksum(struct disklabel *lp)
  173 {
u_int16_t *start, *end;
u_int16_t sum = 0;
start = (u_int16_t *)lp;
end = (u_int16_t *)&lp->d_partitions[lp->d_npartitions];
  179         while (start < end)
sum ^= *start++;
  181         return (sum);
  182 }
  184 char *
initdisklabel(struct disklabel *lp)
  186 {
  187         int i;
  189         /* minimal requirements for archetypal disk label */
  190         if (lp->d_secsize < DEV_BSIZE)
lp->d_secsize = DEV_BSIZE;
  192         if (DL_GETDSIZE(lp) == 0)
DL_SETDSIZE(lp, MAXDISKSIZE);
  194         if (lp->d_secpercyl == 0)
  195                 return ("invalid geometry");
lp->d_npartitions = RAW_PART + 1;
  197         for (i = 0; i < RAW_PART; i++) {
DL_SETPSIZE(&lp->d_partitions[i], 0);
DL_SETPOFFSET(&lp->d_partitions[i], 0);
  200         }
  201         if (DL_GETPSIZE(&lp->d_partitions[RAW_PART]) == 0)
DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp->d_version = 1;
lp->d_bbsize = 8192;
lp->d_sbsize = 64*1024;                 /* XXX ? */
  207         return (NULL);
  208 }
  210 /*
  211  * Check an incoming block to make sure it is a disklabel, convert it to
  212  * a newer version if needed, etc etc.
  213  */
  214 char *
checkdisklabel(void *rlp, struct disklabel *lp)
  216 {
  217         struct disklabel *dlp = rlp;
  218         struct __partitionv0 *v0pp;
  219         struct partition *pp;
daddr64_t disksize;
  221         char *msg = NULL;
  222         int i;
  224         if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC)
msg = "no disk label";
  226         else if (dlp->d_npartitions > MAXPARTITIONS)
msg = "unreasonable partition count";
  228         else if (dkcksum(dlp) != 0)
msg = "disk label corrupted";
  231         if (msg) {
u_int16_t *start, *end, sum = 0;
  234                 /* If it is byte-swapped, attempt to convert it */
  235                 if (swap32(dlp->d_magic) != DISKMAGIC ||
swap32(dlp->d_magic2) != DISKMAGIC ||
swap16(dlp->d_npartitions) > MAXPARTITIONS)
  238                         return (msg);
  240                 /*
  241                  * Need a byte-swap aware dkcksum varient
  242                  * inlined, because dkcksum uses a sub-field
  243                  */
start = (u_int16_t *)dlp;
end = (u_int16_t *)&dlp->d_partitions[
swap16(dlp->d_npartitions)];
  247                 while (start < end)
sum ^= *start++;
  249                 if (sum != 0)
  250                         return (msg);
dlp->d_magic = swap32(dlp->d_magic);
dlp->d_type = swap16(dlp->d_type);
dlp->d_subtype = swap16(dlp->d_subtype);
  256                 /* d_typename and d_packname are strings */
dlp->d_secsize = swap32(dlp->d_secsize);
dlp->d_nsectors = swap32(dlp->d_nsectors);
dlp->d_ntracks = swap32(dlp->d_ntracks);
dlp->d_ncylinders = swap32(dlp->d_ncylinders);
dlp->d_secpercyl = swap32(dlp->d_secpercyl);
dlp->d_secperunit = swap32(dlp->d_secperunit);
dlp->d_sparespertrack = swap16(dlp->d_sparespertrack);
dlp->d_sparespercyl = swap16(dlp->d_sparespercyl);
dlp->d_acylinders = swap32(dlp->d_acylinders);
dlp->d_rpm = swap16(dlp->d_rpm);
dlp->d_interleave = swap16(dlp->d_interleave);
dlp->d_trackskew = swap16(dlp->d_trackskew);
dlp->d_cylskew = swap16(dlp->d_cylskew);
dlp->d_headswitch = swap32(dlp->d_headswitch);
dlp->d_trkseek = swap32(dlp->d_trkseek);
dlp->d_flags = swap32(dlp->d_flags);
  278                 for (i = 0; i < NDDATA; i++)
dlp->d_drivedata[i] = swap32(dlp->d_drivedata[i]);
dlp->d_secperunith = swap16(dlp->d_secperunith);
dlp->d_version = swap16(dlp->d_version);
  284                 for (i = 0; i < NSPARE; i++)
dlp->d_spare[i] = swap32(dlp->d_spare[i]);
dlp->d_magic2 = swap32(dlp->d_magic2);
dlp->d_checksum = swap16(dlp->d_checksum);
dlp->d_npartitions = swap16(dlp->d_npartitions);
dlp->d_bbsize = swap32(dlp->d_bbsize);
dlp->d_sbsize = swap32(dlp->d_sbsize);
  294                 for (i = 0; i < MAXPARTITIONS; i++) {
pp = &dlp->d_partitions[i];
pp->p_size = swap32(pp->p_size);
pp->p_offset = swap32(pp->p_offset);
  298                         if (dlp->d_version == 0) {
v0pp = (struct __partitionv0 *)pp;
v0pp->p_fsize = swap32(v0pp->p_fsize);
  301                         } else {
pp->p_offseth = swap16(pp->p_offseth);
pp->p_sizeh = swap16(pp->p_sizeh);
  304                         }
pp->p_cpg = swap16(pp->p_cpg);
  306                 }
dlp->d_checksum = 0;
dlp->d_checksum = dkcksum(dlp);
msg = NULL;
  311         }
  313         /* XXX should verify lots of other fields and whine a lot */
  315         if (msg)
  316                 return (msg);
  318         /* Initial passed in lp contains the real disk size. */
disksize = DL_GETDSIZE(lp);
  321         if (lp != dlp)
  322                 *lp = *dlp;
  324         if (lp->d_version == 0) {
lp->d_version = 1;
lp->d_secperunith = 0;
v0pp = (struct __partitionv0 *)lp->d_partitions;
pp = lp->d_partitions;
  330                 for (i = 0; i < lp->d_npartitions; i++, pp++, v0pp++) {
pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(v0pp->
p_fsize, v0pp->p_frag);
pp->p_offseth = 0;
pp->p_sizeh = 0;
  335                 }
  336         }
  338 #ifdef DEBUG
  339         if (DL_GETDSIZE(lp) != disksize)
printf("on-disk disklabel has incorrect disksize (%lld)\n",
DL_GETDSIZE(lp));
  342         if (DL_GETPSIZE(&lp->d_partitions[RAW_PART]) != disksize)
printf("on-disk disklabel RAW_PART has incorrect size (%lld)\n",
DL_GETPSIZE(&lp->d_partitions[RAW_PART]));
  345         if (DL_GETPOFFSET(&lp->d_partitions[RAW_PART]) != 0)
printf("on-disk disklabel RAW_PART offset != 0 (%lld)\n",
DL_GETPOFFSET(&lp->d_partitions[RAW_PART]));
  348 #endif
DL_SETDSIZE(lp, disksize);
DL_SETPSIZE(&lp->d_partitions[RAW_PART], disksize);
DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp->d_checksum = 0;
lp->d_checksum = dkcksum(lp);
  355         return (msg);
  356 }
  358 /*
  359  * If dos partition table requested, attempt to load it and
  360  * find disklabel inside a DOS partition. Return buffer
  361  * for use in signalling errors if requested.
  362  *
  363  * We would like to check if each MBR has a valid BOOT_MAGIC, but
  364  * we cannot because it doesn't always exist. So.. we assume the
  365  * MBR is valid.
  366  */
  367 char *
readdoslabel(struct buf *bp, void (*strat)(struct buf *),
  369     struct disklabel *lp, int *partoffp, int spoofonly)
  370 {
  371         struct dos_partition dp[NDOSPART], *dp2;
u_int32_t extoff = 0;
daddr64_t part_blkno = DOSBBSECTOR;
  374         int dospartoff = 0, i, ourpart = -1;
  375         int wander = 1, n = 0, loop = 0;
  377         if (lp->d_secpercyl == 0)
  378                 return ("invalid label, d_secpercyl == 0");
  379         if (lp->d_secsize == 0)
  380                 return ("invalid label, d_secsize == 0");
  382         /* do DOS partitions in the process of getting disklabel? */
  384         /*
  385          * Read dos partition table, follow extended partitions.
  386          * Map the partitions to disklabel entries i-p
  387          */
  388         while (wander && n < 8 && loop < 8) {
loop++;
wander = 0;
  391                 if (part_blkno < extoff)
part_blkno = extoff;
  394                 /* read boot record */
bp->b_blkno = part_blkno;
bp->b_bcount = lp->d_secsize;
bp->b_flags = B_BUSY | B_READ;
  398                 (*strat)(bp);
  399                 if (biowait(bp)) {
  400 /*wrong*/               if (partoffp)
  401 /*wrong*/                       *partoffp = -1;
  402                         return ("dos partition I/O error");
  403                 }
bcopy(bp->b_data + DOSPARTOFF, dp, sizeof(dp));
  407                 if (ourpart == -1 && part_blkno == DOSBBSECTOR) {
  408                         /* Search for our MBR partition */
  409                         for (dp2=dp, i=0; i < NDOSPART && ourpart == -1;
i++, dp2++)
  411                                 if (letoh32(dp2->dp_size) &&
dp2->dp_typ == DOSPTYP_OPENBSD)
ourpart = i;
  414                         if (ourpart == -1)
  415                                 goto donot;
  416                         /*
  417                          * This is our MBR partition. need sector
  418                          * address for SCSI/IDE, cylinder for
  419                          * ESDI/ST506/RLL
  420                          */
dp2 = &dp[ourpart];
dospartoff = letoh32(dp2->dp_start) + part_blkno;
  424                         /* found our OpenBSD partition, finish up */
  425                         if (partoffp)
  426                                 goto notfat;
  428                         if (lp->d_ntracks == 0)
lp->d_ntracks = dp2->dp_ehd + 1;
  430                         if (lp->d_nsectors == 0)
lp->d_nsectors = DPSECT(dp2->dp_esect);
  432                         if (lp->d_secpercyl == 0)
lp->d_secpercyl = lp->d_ntracks *
lp->d_nsectors;
  435                 }
donot:
  437                 /*
  438                  * In case the disklabel read below fails, we want to
  439                  * provide a fake label in i-p.
  440                  */
  441                 for (dp2=dp, i=0; i < NDOSPART && n < 8; i++, dp2++) {
  442                         struct partition *pp = &lp->d_partitions[8+n];
  444                         if (dp2->dp_typ == DOSPTYP_OPENBSD)
  445                                 continue;
  446                         if (letoh32(dp2->dp_size) > DL_GETDSIZE(lp))
  447                                 continue;
  448                         if (letoh32(dp2->dp_start) > DL_GETDSIZE(lp))
  449                                 continue;
  450                         if (letoh32(dp2->dp_size) == 0)
  451                                 continue;
  452                         if (letoh32(dp2->dp_start))
DL_SETPOFFSET(pp,
letoh32(dp2->dp_start) + part_blkno);
DL_SETPSIZE(pp, letoh32(dp2->dp_size));
  458                         switch (dp2->dp_typ) {
  459                         case DOSPTYP_UNUSED:
pp->p_fstype = FS_UNUSED;
n++;
  462                                 break;
  464                         case DOSPTYP_LINUX:
pp->p_fstype = FS_EXT2FS;
n++;
  467                                 break;
  469                         case DOSPTYP_FAT12:
  470                         case DOSPTYP_FAT16S:
  471                         case DOSPTYP_FAT16B:
  472                         case DOSPTYP_FAT16L:
  473                         case DOSPTYP_FAT32:
  474                         case DOSPTYP_FAT32L:
pp->p_fstype = FS_MSDOS;
n++;
  477                                 break;
  478                         case DOSPTYP_EXTEND:
  479                         case DOSPTYP_EXTENDL:
part_blkno = letoh32(dp2->dp_start) + extoff;
  481                                 if (!extoff) {
extoff = letoh32(dp2->dp_start);
part_blkno = 0;
  484                                 }
wander = 1;
  486                                 break;
  487                         default:
pp->p_fstype = FS_OTHER;
n++;
  490                                 break;
  491                         }
  492                 }
  493         }
lp->d_npartitions = MAXPARTITIONS;
  496         if (n == 0 && part_blkno == DOSBBSECTOR) {
u_int16_t fattest;
  499                 /* Check for a short jump instruction. */
fattest = ((bp->b_data[0] << 8) & 0xff00) |
  501                     (bp->b_data[2] & 0xff);
  502                 if (fattest != 0xeb90 && fattest != 0xe900)
  503                         goto notfat;
  505                 /* Check for a valid bytes per sector value. */
fattest = ((bp->b_data[12] << 8) & 0xff00) |
  507                     (bp->b_data[11] & 0xff);
  508                 if (fattest < 512 || fattest > 4096 || (fattest % 512 != 0))
  509                         goto notfat;
  511                 /* Check the end of sector marker. */
fattest = ((bp->b_data[510] << 8) & 0xff00) |
  513                     (bp->b_data[511] & 0xff);
  514                 if (fattest != 0x55aa)
  515                         goto notfat;
  517                 /* Looks like a FAT filesystem. Spoof 'i'. */
DL_SETPSIZE(&lp->d_partitions['i' - 'a'],
DL_GETPSIZE(&lp->d_partitions[RAW_PART]));
DL_SETPOFFSET(&lp->d_partitions['i' - 'a'], 0);
lp->d_partitions['i' - 'a'].p_fstype = FS_MSDOS;
  522         }
notfat:
  525         /* record the OpenBSD partition's placement for the caller */
  526         if (partoffp)
  527                 *partoffp = dospartoff;
  529         /* don't read the on-disk label if we are in spoofed-only mode */
  530         if (spoofonly)
  531                 return (NULL);
bp->b_blkno = dospartoff + DOS_LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags = B_BUSY | B_READ;
  536         (*strat)(bp);
  537         if (biowait(bp))
  538                 return ("disk label I/O error");
  540         /* sub-MBR disklabels are always at a LABELOFFSET of 0 */
  541         return checkdisklabel(bp->b_data, lp);
  542 }
  544 /*
  545  * Check new disk label for sensibility
  546  * before setting it.
  547  */
  548 int
setdisklabel(struct disklabel *olp, struct disklabel *nlp, u_int openmask)
  550 {
  551         int i;
  552         struct partition *opp, *npp;
  554         /* sanity clause */
  555         if (nlp->d_secpercyl == 0 || nlp->d_secsize == 0 ||
  556             (nlp->d_secsize % DEV_BSIZE) != 0)
  557                 return (EINVAL);
  559         /* special case to allow disklabel to be invalidated */
  560         if (nlp->d_magic == 0xffffffff) {
  561                 *olp = *nlp;
  562                 return (0);
  563         }
  565         if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
dkcksum(nlp) != 0)
  567                 return (EINVAL);
  569         /* XXX missing check if other dos partitions will be overwritten */
  571         while (openmask != 0) {
i = ffs(openmask) - 1;
openmask &= ~(1 << i);
  574                 if (nlp->d_npartitions <= i)
  575                         return (EBUSY);
opp = &olp->d_partitions[i];
npp = &nlp->d_partitions[i];
  578                 if (DL_GETPOFFSET(npp) != DL_GETPOFFSET(opp) ||
DL_GETPSIZE(npp) < DL_GETPSIZE(opp))
  580                         return (EBUSY);
  581                 /*
  582                  * Copy internally-set partition information
  583                  * if new label doesn't include it.             XXX
  584                  */
  585                 if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
npp->p_fstype = opp->p_fstype;
npp->p_fragblock = opp->p_fragblock;
npp->p_cpg = opp->p_cpg;
  589                 }
  590         }
nlp->d_checksum = 0;
nlp->d_checksum = dkcksum(nlp);
  593         *olp = *nlp;
  594         return (0);
  595 }
  597 /*
  598  * Determine the size of the transfer, and make sure it is within the
  599  * boundaries of the partition. Adjust transfer if needed, and signal errors or
  600  * early completion.
  601  */
  602 int
bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
  604 {
  605 #define blockpersec(count, lp) ((count) * (((lp)->d_secsize) / DEV_BSIZE))
  606         struct partition *p = &lp->d_partitions[DISKPART(bp->b_dev)];
daddr64_t sz = howmany(bp->b_bcount, DEV_BSIZE);
  609         /* avoid division by zero */
  610         if (lp->d_secpercyl == 0)
  611                 goto bad;
  613         /* beyond partition? */
  614         if (bp->b_blkno + sz > blockpersec(DL_GETPSIZE(p), lp)) {
sz = blockpersec(DL_GETPSIZE(p), lp) - bp->b_blkno;
  616                 if (sz == 0) {
  617                         /* If exactly at end of disk, return EOF. */
bp->b_resid = bp->b_bcount;
  619                         return (-1);
  620                 }
  621                 if (sz < 0)
  622                         /* If past end of disk, return EINVAL. */
  623                         goto bad;
  625                 /* Otherwise, truncate request. */
bp->b_bcount = sz << DEV_BSHIFT;
  627         }
  629         /* calculate cylinder for disksort to order transfers with */
bp->b_cylinder = (bp->b_blkno + blockpersec(DL_GETPOFFSET(p), lp)) /
blockpersec(lp->d_secpercyl, lp);
  632         return (1);
bad:
bp->b_error = EINVAL;
bp->b_flags |= B_ERROR;
  637         return (-1);
  638 }
  640 /*
  641  * Disk error is the preface to plaintive error messages
  642  * about failing disk transfers.  It prints messages of the form
  643 
  644 hp0g: hard error reading fsbn 12345 of 12344-12347 (hp0 bn %d cn %d tn %d sn %d)
  645 
  646  * if the offset of the error in the transfer and a disk label
  647  * are both available.  blkdone should be -1 if the position of the error
  648  * is unknown; the disklabel pointer may be null from drivers that have not
  649  * been converted to use them.  The message is printed with printf
  650  * if pri is LOG_PRINTF, otherwise it uses log at the specified priority.
  651  * The message should be completed (with at least a newline) with printf
  652  * or addlog, respectively.  There is no trailing space.
  653  */
  654 void
diskerr(struct buf *bp, char *dname, char *what, int pri, int blkdone,
  656     struct disklabel *lp)
  657 {
  658         int unit = DISKUNIT(bp->b_dev), part = DISKPART(bp->b_dev);
  659         int (*pr)(const char *, ...);
  660         char partname = 'a' + part;
daddr64_t sn;
  663         if (pri != LOG_PRINTF) {
  664                 static const char fmt[] = "";
log(pri, fmt);
pr = addlog;
  667         } else
pr = printf;
  669         (*pr)("%s%d%c: %s %sing fsbn ", dname, unit, partname, what,
bp->b_flags & B_READ ? "read" : "writ");
sn = bp->b_blkno;
  672         if (bp->b_bcount <= DEV_BSIZE)
  673                 (*pr)("%lld", sn);
  674         else {
  675                 if (blkdone >= 0) {
sn += blkdone;
  677                         (*pr)("%lld of ", sn);
  678                 }
  679                 (*pr)("%lld-%lld", bp->b_blkno,
bp->b_blkno + (bp->b_bcount - 1) / DEV_BSIZE);
  681         }
  682         if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
sn += DL_GETPOFFSET(&lp->d_partitions[part]);
  684                 (*pr)(" (%s%d bn %lld; cn %lld", dname, unit, sn,
sn / lp->d_secpercyl);
sn %= lp->d_secpercyl;
  687                 (*pr)(" tn %lld sn %lld)", sn / lp->d_nsectors,
sn % lp->d_nsectors);
  689         }
  690 }
  692 /*
  693  * Initialize the disklist.  Called by main() before autoconfiguration.
  694  */
  695 void
disk_init(void)
  697 {
TAILQ_INIT(&disklist);
disk_count = disk_change = 0;
  701 }
  703 int
disk_construct(struct disk *diskp, char *lockname)
  705 {
rw_init(&diskp->dk_lock, lockname);
diskp->dk_flags |= DKF_CONSTRUCTED;
  710         return (0);
  711 }
  713 /*
  714  * Attach a disk.
  715  */
  716 void
disk_attach(struct disk *diskp)
  718 {
  720         if (!ISSET(diskp->dk_flags, DKF_CONSTRUCTED))
disk_construct(diskp, diskp->dk_name);
  723         /*
  724          * Allocate and initialize the disklabel structures.  Note that
  725          * it's not safe to sleep here, since we're probably going to be
  726          * called during autoconfiguration.
  727          */
diskp->dk_label = malloc(sizeof(struct disklabel), M_DEVBUF, M_NOWAIT);
  729         if (diskp->dk_label == NULL)
panic("disk_attach: can't allocate storage for disklabel");
bzero(diskp->dk_label, sizeof(struct disklabel));
  734         /*
  735          * Set the attached timestamp.
  736          */
microuptime(&diskp->dk_attachtime);
  739         /*
  740          * Link into the disklist.
  741          */
TAILQ_INSERT_TAIL(&disklist, diskp, dk_link);
  743         ++disk_count;
disk_change = 1;
  745 }
  747 /*
  748  * Detach a disk.
  749  */
  750 void
disk_detach(struct disk *diskp)
  752 {
  754         /*
  755          * Free the space used by the disklabel structures.
  756          */
free(diskp->dk_label, M_DEVBUF);
  759         /*
  760          * Remove from the disklist.
  761          */
TAILQ_REMOVE(&disklist, diskp, dk_link);
disk_change = 1;
  764         if (--disk_count < 0)
panic("disk_detach: disk_count < 0");
  766 }
  768 /*
  769  * Increment a disk's busy counter.  If the counter is going from
  770  * 0 to 1, set the timestamp.
  771  */
  772 void
disk_busy(struct disk *diskp)
  774 {
  776         /*
  777          * XXX We'd like to use something as accurate as microtime(),
  778          * but that doesn't depend on the system TOD clock.
  779          */
  780         if (diskp->dk_busy++ == 0) {
microuptime(&diskp->dk_timestamp);
  782         }
  783 }
  785 /*
  786  * Decrement a disk's busy counter, increment the byte count, total busy
  787  * time, and reset the timestamp.
  788  */
  789 void
disk_unbusy(struct disk *diskp, long bcount, int read)
  791 {
  792         struct timeval dv_time, diff_time;
  794         if (diskp->dk_busy-- == 0)
printf("disk_unbusy: %s: dk_busy < 0\n", diskp->dk_name);
microuptime(&dv_time);
timersub(&dv_time, &diskp->dk_timestamp, &diff_time);
timeradd(&diskp->dk_time, &diff_time, &diskp->dk_time);
diskp->dk_timestamp = dv_time;
  803         if (bcount > 0) {
  804                 if (read) {
diskp->dk_rbytes += bcount;
diskp->dk_rxfer++;
  807                 } else {
diskp->dk_wbytes += bcount;
diskp->dk_wxfer++;
  810                 }
  811         } else
diskp->dk_seek++;
add_disk_randomness(bcount ^ diff_time.tv_usec);
  815 }
  817 int
disk_lock(struct disk *dk)
  819 {
  820         int error;
error = rw_enter(&dk->dk_lock, RW_WRITE|RW_INTR);
  824         return (error);
  825 }
  827 void
disk_unlock(struct disk *dk)
  829 {
rw_exit(&dk->dk_lock);
  831 }
  833 int
dk_mountroot(void)
  835 {
dev_t rawdev, rrootdev;
  837         int part = DISKPART(rootdev);
  838         int (*mountrootfn)(void);
  839         struct disklabel dl;
  840         int error;
rrootdev = blktochr(rootdev);
rawdev = MAKEDISKDEV(major(rrootdev), DISKUNIT(rootdev), RAW_PART);
  844 #ifdef DEBUG
printf("rootdev=0x%x rrootdev=0x%x rawdev=0x%x\n", rootdev,
rrootdev, rawdev);
  847 #endif
  849         /*
  850          * open device, ioctl for the disklabel, and close it.
  851          */
error = (cdevsw[major(rrootdev)].d_open)(rawdev, FREAD,
S_IFCHR, curproc);
  854         if (error)
panic("cannot open disk, 0x%x/0x%x, error %d",
rootdev, rrootdev, error);
error = (cdevsw[major(rrootdev)].d_ioctl)(rawdev, DIOCGDINFO,
  858             (caddr_t)&dl, FREAD, curproc);
  859         if (error)
panic("cannot read disk label, 0x%x/0x%x, error %d",
rootdev, rrootdev, error);
  862         (void) (cdevsw[major(rrootdev)].d_close)(rawdev, FREAD,
S_IFCHR, curproc);
  865         if (DL_GETPSIZE(&dl.d_partitions[part]) == 0)
panic("root filesystem has size 0");
  867         switch (dl.d_partitions[part].p_fstype) {
  868 #ifdef EXT2FS
  869         case FS_EXT2FS:
  870                 {
  871                 extern int ext2fs_mountroot(void);
mountrootfn = ext2fs_mountroot;
  873                 }
  874                 break;
  875 #endif
  876 #ifdef FFS
  877         case FS_BSDFFS:
  878                 {
  879                 extern int ffs_mountroot(void);
mountrootfn = ffs_mountroot;
  881                 }
  882                 break;
  883 #endif
  884 #ifdef CD9660
  885         case FS_ISO9660:
  886                 {
  887                 extern int cd9660_mountroot(void);
mountrootfn = cd9660_mountroot;
  889                 }
  890                 break;
  891 #endif
  892         default:
  893 #ifdef FFS
  894                 { 
  895                 extern int ffs_mountroot(void);
printf("filesystem type %d not known.. assuming ffs\n",
dl.d_partitions[part].p_fstype);
mountrootfn = ffs_mountroot;
  900                 }
  901 #else
panic("disk 0x%x/0x%x filesystem type %d not known", 
rootdev, rrootdev, dl.d_partitions[part].p_fstype);
  904 #endif
  905         }
  906         return (*mountrootfn)();
  907 }
  909 struct bufq *
bufq_default_alloc(void)
  911 {
  912         struct bufq_default *bq;
bq = malloc(sizeof(*bq), M_DEVBUF, M_NOWAIT);
  915         if (bq == NULL)
panic("bufq_default_alloc: no memory");
memset(bq, 0, sizeof(*bq));
bq->bufq.bufq_free = bufq_default_free;
bq->bufq.bufq_add = bufq_default_add;
bq->bufq.bufq_get = bufq_default_get;
  923         return ((struct bufq *)bq);
  924 }
  926 void
bufq_default_free(struct bufq *bq)
  928 {
free(bq, M_DEVBUF);
  930 }
  932 void
bufq_default_add(struct bufq *bq, struct buf *bp)
  934 {
  935         struct bufq_default *bufq = (struct bufq_default *)bq;
  936         struct proc *p = bp->b_proc;
  937         struct buf *head;
  939         if (p == NULL || p->p_nice < NZERO)
head = &bufq->bufq_head[0];
  941         else if (p->p_nice == NZERO)
head = &bufq->bufq_head[1];
  943         else
head = &bufq->bufq_head[2];
disksort(head, bp);
  947 }
  949 struct buf *
bufq_default_get(struct bufq *bq)
  951 {
  952         struct bufq_default *bufq = (struct bufq_default *)bq;
  953         struct buf *bp, *head;
  954         int i;
  956         for (i = 0; i < 3; i++) {
head = &bufq->bufq_head[i];
  958                 if ((bp = head->b_actf))
  959                         break;
  960         }
  961         if (bp == NULL)
  962                 return (NULL);
head->b_actf = bp->b_actf;
  964         return (bp);
  965 }
  967 #ifdef RAMDISK_HOOKS
  968 static struct device fakerdrootdev = { DV_DISK, {}, NULL, 0, "rd0", NULL };
  969 #endif
  971 struct device *
getdisk(char *str, int len, int defpart, dev_t *devp)
  973 {
  974         struct device *dv;
  976         if ((dv = parsedisk(str, len, defpart, devp)) == NULL) {
printf("use one of: exit");
  978 #ifdef RAMDISK_HOOKS
printf(" %s[a-p]", fakerdrootdev.dv_xname);
  980 #endif
TAILQ_FOREACH(dv, &alldevs, dv_list) {
  982                         if (dv->dv_class == DV_DISK)
printf(" %s[a-p]", dv->dv_xname);
  984 #if defined(NFSCLIENT)
  985                         if (dv->dv_class == DV_IFNET)
printf(" %s", dv->dv_xname);
  987 #endif
  988                 }
printf("\n");
  990         }
  991         return (dv);
  992 }
  994 struct device *
parsedisk(char *str, int len, int defpart, dev_t *devp)
  996 {
  997         struct device *dv;
  998         char c;
  999         int majdev, part;
 1001         if (len == 0)
 1002                 return (NULL);
c = str[len-1];
 1004         if (c >= 'a' && (c - 'a') < MAXPARTITIONS) {
part = c - 'a';
len -= 1;
 1007         } else
part = defpart;
 1010 #ifdef RAMDISK_HOOKS
 1011         if (strcmp(str, fakerdrootdev.dv_xname) == 0) {
dv = &fakerdrootdev;
 1013                 goto gotdisk;
 1014         }
 1015 #endif
TAILQ_FOREACH(dv, &alldevs, dv_list) {
 1018                 if (dv->dv_class == DV_DISK &&
strncmp(str, dv->dv_xname, len) == 0 &&
dv->dv_xname[len] == '\0') {
 1021 #ifdef RAMDISK_HOOKS
gotdisk:
 1023 #endif
majdev = findblkmajor(dv);
 1025                         if (majdev < 0)
panic("parsedisk");
 1027                         *devp = MAKEDISKDEV(majdev, dv->dv_unit, part);
 1028                         break;
 1029                 }
 1030 #if defined(NFSCLIENT)
 1031                 if (dv->dv_class == DV_IFNET &&
strncmp(str, dv->dv_xname, len) == 0 &&
dv->dv_xname[len] == '\0') {
 1034                         *devp = NODEV;
 1035                         break;
 1036                 }
 1037 #endif
 1038         }
 1040         return (dv);
 1041 }
 1043 void
setroot(struct device *bootdv, int part, int exitflags)
 1045 {
 1046         int majdev, unit, len, s;
 1047         struct swdevt *swp;
 1048         struct device *rootdv, *dv;
dev_t nrootdev, nswapdev = NODEV, temp = NODEV;
 1050         char buf[128];
 1051 #if defined(NFSCLIENT)
 1052         extern char *nfsbootdevname;
 1053 #endif
 1055         if (boothowto & RB_DFLTROOT)
 1056                 return;
 1058 #ifdef RAMDISK_HOOKS
bootdv = &fakerdrootdev;
mountroot = NULL;
part = 0;
 1062 #endif
 1064         /*
 1065          * If `swap generic' and we couldn't determine boot device,
 1066          * ask the user.
 1067          */
 1068         if (mountroot == NULL && bootdv == NULL)
boothowto |= RB_ASKNAME;
 1070         if (boothowto & RB_ASKNAME) {
 1071                 while (1) {
printf("root device");
 1073                         if (bootdv != NULL) {
printf(" (default %s", bootdv->dv_xname);
 1075                                 if (bootdv->dv_class == DV_DISK)
printf("%c", 'a' + part);
printf(")");
 1078                         }
printf(": ");
s = splhigh();
cnpollc(TRUE);
len = getsn(buf, sizeof(buf));
cnpollc(FALSE);
splx(s);
 1085                         if (strcmp(buf, "exit") == 0)
boot(exitflags);
 1087                         if (len == 0 && bootdv != NULL) {
strlcpy(buf, bootdv->dv_xname, sizeof buf);
len = strlen(buf);
 1090                         }
 1091                         if (len > 0 && buf[len - 1] == '*') {
buf[--len] = '\0';
dv = getdisk(buf, len, part, &nrootdev);
 1094                                 if (dv != NULL) {
rootdv = dv;
nswapdev = nrootdev;
 1097                                         goto gotswap;
 1098                                 }
 1099                         }
dv = getdisk(buf, len, part, &nrootdev);
 1101                         if (dv != NULL) {
rootdv = dv;
 1103                                 break;
 1104                         }
 1105                 }
 1107                 if (rootdv->dv_class == DV_IFNET)
 1108                         goto gotswap;
 1110                 /* try to build swap device out of new root device */
 1111                 while (1) {
printf("swap device");
 1113                         if (rootdv != NULL)
printf(" (default %s%s)", rootdv->dv_xname,
rootdv->dv_class == DV_DISK ? "b" : "");
printf(": ");
s = splhigh();
cnpollc(TRUE);
len = getsn(buf, sizeof(buf));
cnpollc(FALSE);
splx(s);
 1122                         if (strcmp(buf, "exit") == 0)
boot(exitflags);
 1124                         if (len == 0 && rootdv != NULL) {
 1125                                 switch (rootdv->dv_class) {
 1126                                 case DV_IFNET:
nswapdev = NODEV;
 1128                                         break;
 1129                                 case DV_DISK:
nswapdev = MAKEDISKDEV(major(nrootdev),
DISKUNIT(nrootdev), 1);
 1132                                         if (nswapdev == nrootdev)
 1133                                                 continue;
 1134                                         break;
 1135                                 default:
 1136                                         break;
 1137                                 }
 1138                                 break;
 1139                         }
dv = getdisk(buf, len, 1, &nswapdev);
 1141                         if (dv) {
 1142                                 if (dv->dv_class == DV_IFNET)
nswapdev = NODEV;
 1144                                 if (nswapdev == nrootdev)
 1145                                         continue;
 1146                                 break;
 1147                         }
 1148                 }
gotswap:
rootdev = nrootdev;
dumpdev = nswapdev;
swdevt[0].sw_dev = nswapdev;
swdevt[1].sw_dev = NODEV;
 1154 #if defined(NFSCLIENT)
 1155         } else if (mountroot == nfs_mountroot) {
rootdv = bootdv;
rootdev = dumpdev = swapdev = NODEV;
 1158 #endif
 1159         } else if (mountroot == NULL) {
 1160                 /* `swap generic': Use the device the ROM told us to use */
rootdv = bootdv;
majdev = findblkmajor(rootdv);
 1163                 if (majdev >= 0) {
 1164                         /*
 1165                          * Root and swap are on the disk.
 1166                          * Assume swap is on partition b.
 1167                          */
rootdev = MAKEDISKDEV(majdev, rootdv->dv_unit, part);
nswapdev = MAKEDISKDEV(majdev, rootdv->dv_unit, 1);
 1170                 } else {
 1171                         /*
 1172                          * Root and swap are on a net.
 1173                          */
nswapdev = NODEV;
 1175                 }
dumpdev = nswapdev;
swdevt[0].sw_dev = nswapdev;
 1178                 /* swdevt[1].sw_dev = NODEV; */
 1179         } else {
 1180                 /* Completely pre-configured, but we want rootdv .. */
majdev = major(rootdev);
 1182                 if (findblkname(majdev) == NULL)
 1183                         return;
unit = DISKUNIT(rootdev);
part = DISKPART(rootdev);
snprintf(buf, sizeof buf, "%s%d%c",
findblkname(majdev), unit, 'a' + part);
rootdv = parsedisk(buf, strlen(buf), 0, &nrootdev);
 1189         }
 1191         switch (rootdv->dv_class) {
 1192 #if defined(NFSCLIENT)
 1193         case DV_IFNET:
mountroot = nfs_mountroot;
nfsbootdevname = rootdv->dv_xname;
 1196                 return;
 1197 #endif
 1198         case DV_DISK:
mountroot = dk_mountroot;
part = DISKPART(rootdev);
 1201                 break;
 1202         default:
printf("can't figure root, hope your kernel is right\n");
 1204                 return;
 1205         }
printf("root on %s%c", rootdv->dv_xname, 'a' + part);
 1209         /*
 1210          * Make the swap partition on the root drive the primary swap.
 1211          */
 1212         for (swp = swdevt; swp->sw_dev != NODEV; swp++) {
 1213                 if (major(rootdev) == major(swp->sw_dev) &&
DISKUNIT(rootdev) == DISKUNIT(swp->sw_dev)) {
temp = swdevt[0].sw_dev;
swdevt[0].sw_dev = swp->sw_dev;
swp->sw_dev = temp;
 1218                         break;
 1219                 }
 1220         }
 1221         if (swp->sw_dev != NODEV) {
 1222                 /*
 1223                  * If dumpdev was the same as the old primary swap device,
 1224                  * move it to the new primary swap device.
 1225                  */
 1226                 if (temp == dumpdev)
dumpdev = swdevt[0].sw_dev;
 1228         }
 1229         if (swdevt[0].sw_dev != NODEV)
printf(" swap on %s%d%c", findblkname(major(swdevt[0].sw_dev)),
DISKUNIT(swdevt[0].sw_dev),
 1232                     'a' + DISKPART(swdevt[0].sw_dev));
 1233         if (dumpdev != NODEV)
printf(" dump on %s%d%c", findblkname(major(dumpdev)),
DISKUNIT(dumpdev), 'a' + DISKPART(dumpdev));
printf("\n");
 1237 }
 1239 extern struct nam2blk nam2blk[];
 1241 int
findblkmajor(struct device *dv)
 1243 {
 1244         char *name = dv->dv_xname;
 1245         int i;
 1247         for (i = 0; nam2blk[i].name; i++)
 1248                 if (!strncmp(name, nam2blk[i].name, strlen(nam2blk[i].name)))
 1249                         return (nam2blk[i].maj);
 1250         return (-1);
 1251 }
 1253 char *
findblkname(int maj)
 1255 {
 1256         int i;
 1258         for (i = 0; nam2blk[i].name; i++)
 1259                 if (nam2blk[i].maj == maj)
 1260                         return (nam2blk[i].name);
 1261         return (NULL);
 1262 }