The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_disk_mbr.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: subr_disk_mbr.c,v 1.4 2003/10/08 04:25:46 lukem Exp $  */
    2 
    3 /*
    4  * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. Neither the name of the University nor the names of its contributors
   16  *    may be used to endorse or promote products derived from this software
   17  *    without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  *
   31  *      @(#)ufs_disksubr.c      7.16 (Berkeley) 5/4/91
   32  */
   33 
   34 /*
   35  * Code to find a NetBSD label on a disk that contains an i386 style MBR.
   36  * The first NetBSD label found in the 2nd sector of a NetBSD partition
   37  * is used.
   38  * If we don't find a label searching the MBR, we look at the start of the
   39  * disk, if that fails then a label is faked up from the MBR.
   40  *
   41  * If there isn't a disklabel or anything in the MBR then partition a
   42  * is set to cover the whole disk.
   43  * Useful for files that contain single filesystems (etc).
   44  *
   45  * This code will read host endian netbsd labels from little endian MBR.
   46  *
   47  * Based on the i386 disksubr.c
   48  *
   49  * Since the mbr only has 32bit fields for sector addresses, we do the same.
   50  *
   51  * XXX There are potential problems writing labels to disks where there
   52  * is only space for 8 netbsd partitions but this code has been compiled
   53  * with MAXPARTITIONS=16.
   54  */
   55 
   56 #include <sys/cdefs.h>
   57 __KERNEL_RCSID(0, "$NetBSD: subr_disk_mbr.c,v 1.4 2003/10/08 04:25:46 lukem Exp $");
   58 
   59 #include <sys/param.h>
   60 #include <sys/systm.h>
   61 #include <sys/buf.h>
   62 #include <sys/disklabel.h>
   63 #include <sys/disk.h>
   64 #include <sys/syslog.h>
   65 
   66 #include "opt_mbr.h"
   67 
   68 #define MBR_LABELSECTOR 1
   69 
   70 #define SCAN_CONTINUE   0
   71 #define SCAN_FOUND      1
   72 #define SCAN_ERROR      2
   73 
   74 typedef struct mbr_args {
   75         struct disklabel *lp;
   76         void            (*strat)(struct buf *);
   77         struct buf      *bp;
   78         const char      *msg;
   79         int             error;
   80         int             written;        /* number of times we wrote label */
   81         uint            label_sector;   /* where we found the label */
   82 } mbr_args_t;
   83 
   84 #define READ_LABEL      1
   85 #define UPDATE_LABEL    2
   86 #define WRITE_LABEL     3
   87 static int validate_label(mbr_args_t *, uint, int);
   88 static int look_netbsd_part(mbr_args_t *, struct mbr_partition *, int, uint);
   89 static int write_netbsd_label(mbr_args_t *, struct mbr_partition *, int, uint);
   90 
   91 static int
   92 read_sector(mbr_args_t *a, uint sector)
   93 {
   94         struct buf *bp = a->bp;
   95         int error;
   96 
   97         bp->b_blkno = sector;
   98         bp->b_bcount = a->lp->d_secsize;
   99         bp->b_flags = (bp->b_flags & ~(B_WRITE | B_DONE)) | B_READ;
  100         bp->b_cylinder = sector / a->lp->d_secpercyl;
  101         (*a->strat)(bp);
  102         error = biowait(bp);
  103         if (error != 0)
  104                 a->error = error;
  105         return error;
  106 }
  107 
  108 /* 
  109  * Scan MBR for partitions, call 'action' routine for each.
  110  */
  111 
  112 static int
  113 scan_mbr(mbr_args_t *a, int (*actn)(mbr_args_t *, struct mbr_partition *, int, uint))
  114 {
  115         struct mbr_partition ptns[MBR_PART_COUNT];
  116         struct mbr_partition *dp;
  117         struct mbr_sector *mbr;
  118         uint ext_base, this_ext, next_ext;
  119         int rval;
  120         int i;
  121 #ifdef COMPAT_386BSD_MBRPART
  122         int dp_386bsd = -1;
  123 #endif
  124 
  125         ext_base = 0;
  126         this_ext = 0;
  127         for (;;) {
  128                 if (read_sector(a, this_ext)) {
  129                         a->msg = "dos partition I/O error";
  130                         return SCAN_ERROR;
  131                 }
  132 
  133                 /* Note: Magic number is little-endian. */
  134                 mbr = (void *)a->bp->b_data;
  135                 if (mbr->mbr_magic != htole16(MBR_MAGIC))
  136                         return SCAN_CONTINUE;
  137 
  138                 /* Copy data out of buffer so action can use bp */
  139                 memcpy(ptns, &mbr->mbr_parts, sizeof ptns);
  140 
  141                 /* look for NetBSD partition */
  142                 next_ext = 0;
  143                 dp = ptns;
  144                 for (i = 0; i < MBR_PART_COUNT; i++, dp++) {
  145                         if (dp->mbrp_type == 0)
  146                                 continue;
  147                         if (MBR_IS_EXTENDED(dp->mbrp_type)) {
  148                                 next_ext = le32toh(dp->mbrp_start);
  149                                 continue;
  150                         }
  151 #ifdef COMPAT_386BSD_MBRPART
  152                         if (dp->mbrp_type == MBR_PTYPE_386BSD) {
  153                                 /*
  154                                  * If more than one matches, take last,
  155                                  * as NetBSD install tool does.
  156                                  */
  157                                 if (this_ext == 0)
  158                                         dp_386bsd = i;
  159                                 continue;
  160                         }
  161 #endif
  162                         rval = (*actn)(a, dp, i, this_ext);
  163                         if (rval != SCAN_CONTINUE)
  164                                 return rval;
  165                 }
  166                 if (next_ext == 0)
  167                         break;
  168                 if (ext_base == 0) {
  169                         ext_base = next_ext;
  170                         next_ext = 0;
  171                 }
  172                 next_ext += ext_base;
  173                 if (next_ext <= this_ext)
  174                         break;
  175                 this_ext = next_ext;
  176         }
  177 #ifdef COMPAT_386BSD_MBRPART
  178         if (this_ext == 0 && dp_386bsd != -1)
  179                 return (*actn)(a, &ptns[dp_386bsd], dp_386bsd, 0);
  180 #endif
  181         return SCAN_CONTINUE;
  182 }
  183 
  184 /*
  185  * Attempt to read a disk label from a device
  186  * using the indicated strategy routine.
  187  * The label must be partly set up before this:
  188  * secpercyl, secsize and anything required for a block i/o read
  189  * operation in the driver's strategy/start routines
  190  * must be filled in before calling us.
  191  *
  192  * If dos partition table requested, attempt to load it and
  193  * find disklabel inside a DOS partition. Also, if bad block
  194  * table needed, attempt to extract it as well. Return buffer
  195  * for use in signalling errors if requested.
  196  *
  197  * Returns null on success and an error string on failure.
  198  */
  199 const char *
  200 readdisklabel(dev, strat, lp, osdep)
  201         dev_t dev;
  202         void (*strat)(struct buf *);
  203         struct disklabel *lp;
  204         struct cpu_disklabel *osdep;
  205 {
  206         struct dkbad *bdp;
  207         int rval;
  208         int i;
  209         mbr_args_t a;
  210 
  211         memset(&a, 0, sizeof a);
  212         a.lp = lp;
  213         a.strat = strat;
  214 
  215         /* minimal requirements for architypal disk label */
  216         if (lp->d_secsize == 0)
  217                 lp->d_secsize = DEV_BSIZE;
  218         if (lp->d_secperunit == 0)
  219                 lp->d_secperunit = 0x1fffffff;
  220         lp->d_npartitions = RAW_PART + 1;
  221         for (i = 0; i < RAW_PART; i++) {
  222                 lp->d_partitions[i].p_size = 0;
  223                 lp->d_partitions[i].p_offset = 0;
  224         }
  225         if (lp->d_partitions[RAW_PART].p_size == 0)
  226                 lp->d_partitions[RAW_PART].p_size = 0x1fffffff;
  227         lp->d_partitions[RAW_PART].p_offset = 0;
  228 
  229         /*
  230          * Set partition 'a' to be the whole disk.
  231          * Cleared if we find an mbr or a netbsd label.
  232          */
  233         lp->d_partitions[0].p_size = lp->d_partitions[RAW_PART].p_size;
  234         lp->d_partitions[0].p_fstype = FS_BSDFFS;
  235 
  236         /* get a buffer and initialize it */
  237         a.bp = geteblk((int)lp->d_secsize);
  238         a.bp->b_dev = dev;
  239 
  240         if (osdep)
  241                 /*
  242                  * Scan mbr searching for netbsd partition and saving
  243                  * bios partition information to use if the netbsd one
  244                  * is absent.
  245                  */
  246                 rval = scan_mbr(&a, look_netbsd_part);
  247         else
  248                 rval = SCAN_CONTINUE;
  249 
  250         if (rval == SCAN_CONTINUE) {
  251                 /* Look at start of disk */
  252                 rval = validate_label(&a, LABELSECTOR, READ_LABEL);
  253                 if (LABELSECTOR != 0 && rval == SCAN_CONTINUE)
  254                         rval = validate_label(&a, 0, READ_LABEL);
  255         }
  256 
  257 #if 0
  258         /*
  259          * Save sector where we found the label for the 'don't overwrite
  260          * the label' check in bounds_check_with_label.
  261          */
  262         if (rval == SCAN_FOUND)
  263                 xxx->label_sector = a.label_sector;
  264 #endif
  265 
  266         /* Obtain bad sector table if requested and present */
  267         if (rval == SCAN_FOUND && osdep && (lp->d_flags & D_BADSECT)) {
  268                 struct dkbad *db;
  269                 int blkno;
  270 
  271                 bdp = &osdep->bad;
  272                 i = 0;
  273                 rval = SCAN_ERROR;
  274                 do {
  275                         /* read a bad sector table */
  276                         blkno = lp->d_secperunit - lp->d_nsectors + i;
  277                         if (lp->d_secsize > DEV_BSIZE)
  278                                 blkno *= lp->d_secsize / DEV_BSIZE;
  279                         else
  280                                 blkno /= DEV_BSIZE / lp->d_secsize;
  281                         /* if successful, validate, otherwise try another */
  282                         if (read_sector(&a, blkno)) {
  283                                 a.msg = "bad sector table I/O error";
  284                                 continue;
  285                         }
  286                         db = (struct dkbad *)(a.bp->b_data);
  287 #define DKBAD_MAGIC 0x4321
  288                         if (db->bt_mbz != 0 || db->bt_flag != DKBAD_MAGIC) {
  289                                 a.msg = "bad sector table corrupted";
  290                                 continue;
  291                         }
  292                         rval = SCAN_FOUND;
  293                         *bdp = *db;
  294                         break;
  295                 } while ((a.bp->b_flags & B_ERROR) && (i += 2) < 10 &&
  296                         i < lp->d_nsectors);
  297         }
  298 
  299         brelse(a.bp);
  300         if (rval != SCAN_ERROR)
  301                 return NULL;
  302         return a.msg;
  303 }
  304 
  305 static int
  306 look_netbsd_part(mbr_args_t *a, struct mbr_partition *dp, int slot, uint ext_base)
  307 {
  308         struct partition *pp;
  309         int ptn_base = ext_base + le32toh(dp->mbrp_start);
  310         int rval;
  311 
  312         if (
  313 #ifdef COMPAT_386BSD_MBRPART
  314             dp->mbrp_type == MBR_PTYPE_386BSD ||
  315 #endif
  316             dp->mbrp_type == MBR_PTYPE_NETBSD) {
  317                 rval = validate_label(a, ptn_base + MBR_LABELSECTOR, READ_LABEL);
  318 
  319                 /* Put actual location where we found the label into ptn 2 */
  320                 if (RAW_PART != 2 && (rval == SCAN_FOUND ||
  321                                         a->lp->d_partitions[2].p_size == 0)) {
  322                         a->lp->d_partitions[2].p_size = le32toh(dp->mbrp_size);
  323                         a->lp->d_partitions[2].p_offset = ptn_base;
  324                 }
  325 
  326                 /* If we got a netbsd label look no further */
  327                 if (rval == SCAN_FOUND)
  328                         return rval;
  329         }
  330 
  331         /* Install main partitions into e..h and extended into i+ */
  332         if (ext_base == 0)
  333                 slot += 4;
  334         else {
  335                 slot = 4 + MBR_PART_COUNT;
  336                 pp = &a->lp->d_partitions[slot];
  337                 for (; slot < MAXPARTITIONS; pp++, slot++) {
  338                         /* This gets called twice - avoid duplicates */
  339                         if (pp->p_offset == ptn_base &&
  340                             pp->p_size == le32toh(dp->mbrp_size))
  341                                 break;
  342                         if (pp->p_size == 0)
  343                                 break;
  344                 }
  345         }
  346 
  347         if (slot < MAXPARTITIONS) {
  348                 /* Stop 'a' being the entire disk */
  349                 a->lp->d_partitions[0].p_size = 0;
  350                 a->lp->d_partitions[0].p_fstype = 0;
  351 
  352                 /* save partition info */
  353                 pp = &a->lp->d_partitions[slot];
  354                 pp->p_offset = ptn_base;
  355                 pp->p_size = le32toh(dp->mbrp_size);
  356                 pp->p_fstype = xlat_mbr_fstype(dp->mbrp_type);
  357 
  358                 if (slot >= a->lp->d_npartitions)
  359                         a->lp->d_npartitions = slot + 1;
  360         }
  361 
  362         return SCAN_CONTINUE;
  363 }
  364 
  365 
  366 static int
  367 validate_label(mbr_args_t *a, uint label_sector, int action)
  368 {
  369         struct disklabel *dlp;
  370         char *dlp_lim;
  371         int error;
  372 
  373         /* Next, dig out disk label */
  374         if (read_sector(a, label_sector)) {
  375                 a->msg = "disk label read failed";
  376                 return SCAN_ERROR;
  377         }
  378 
  379         /* Locate disk label within block and validate */
  380         /*
  381          * XXX (dsl) This search may be a waste of time, a lot of other i386
  382          * code assumes the label is at offset LABELOFFSET (=0) in the sector.
  383          *
  384          * If we want to support disks from other netbsd ports, then the
  385          * code should also allow for a shorter label nearer the end of
  386          * the disk sector, and (IIRC) labels within 8k of the disk start.
  387          */
  388         dlp = (void *)a->bp->b_data;
  389         if (action != WRITE_LABEL) {
  390                 dlp_lim = a->bp->b_data + a->lp->d_secsize - sizeof(*dlp);
  391                 for (;; dlp = (void *)((char *)dlp + sizeof(long))) {
  392                         if ((char *)dlp > dlp_lim)
  393                                 return SCAN_CONTINUE;
  394                         if (dlp->d_magic != DISKMAGIC
  395                             || dlp->d_magic2 != DISKMAGIC)
  396                                 continue;
  397                         if (dlp->d_npartitions > MAXPARTITIONS
  398                             || dkcksum(dlp) != 0) {
  399                                 a->msg = "disk label corrupted";
  400                                 continue;
  401                         }
  402                         break;
  403                 }
  404         }
  405 
  406         switch (action) {
  407         case READ_LABEL:
  408                 *a->lp = *dlp;
  409                 a->label_sector = label_sector;
  410                 return SCAN_FOUND;
  411         case UPDATE_LABEL:
  412         case WRITE_LABEL:
  413                 *dlp = *a->lp;
  414                 a->bp->b_flags &= ~(B_READ|B_DONE);
  415                 a->bp->b_flags |= B_WRITE;
  416                 (*a->strat)(a->bp);
  417                 error = biowait(a->bp);
  418                 if (error != 0) {
  419                         a->error = error;
  420                         a->msg = "disk label write failed";
  421                         return SCAN_ERROR;
  422                 }
  423                 a->written++;
  424                 /* Write label to all mbr partitions */
  425                 return SCAN_CONTINUE;
  426         default:
  427                 return SCAN_ERROR;
  428         }
  429 }
  430 
  431 /*
  432  * Check new disk label for sensibility
  433  * before setting it.
  434  */
  435 int
  436 setdisklabel(olp, nlp, openmask, osdep)
  437         struct disklabel *olp, *nlp;
  438         u_long openmask;
  439         struct cpu_disklabel *osdep;
  440 {
  441         int i;
  442         struct partition *opp, *npp;
  443 
  444         /* sanity clause */
  445         if (nlp->d_secpercyl == 0 || nlp->d_secsize == 0
  446                 || (nlp->d_secsize % DEV_BSIZE) != 0)
  447                         return (EINVAL);
  448 
  449         /* special case to allow disklabel to be invalidated */
  450         if (nlp->d_magic == 0xffffffff) {
  451                 *olp = *nlp;
  452                 return (0);
  453         }
  454 
  455         if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
  456             dkcksum(nlp) != 0)
  457                 return (EINVAL);
  458 
  459         /* XXX missing check if other dos partitions will be overwritten */
  460 
  461         while (openmask != 0) {
  462                 i = ffs(openmask) - 1;
  463                 openmask &= ~(1 << i);
  464                 if (i > nlp->d_npartitions)
  465                         return (EBUSY);
  466                 opp = &olp->d_partitions[i];
  467                 npp = &nlp->d_partitions[i];
  468                 /*
  469                  * Copy internally-set partition information
  470                  * if new label doesn't include it.             XXX
  471                  */
  472                 if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
  473                         *npp = *opp;
  474                         continue;
  475                 }
  476                 if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
  477                         return (EBUSY);
  478         }
  479         nlp->d_checksum = 0;
  480         nlp->d_checksum = dkcksum(nlp);
  481         *olp = *nlp;
  482         return (0);
  483 }
  484 
  485 
  486 /*
  487  * Write disk label back to device after modification.
  488  */
  489 int
  490 writedisklabel(dev, strat, lp, osdep)
  491         dev_t dev;
  492         void (*strat)(struct buf *);
  493         struct disklabel *lp;
  494         struct cpu_disklabel *osdep;
  495 {
  496         mbr_args_t a;
  497 
  498         memset(&a, 0, sizeof a);
  499         a.lp = lp;
  500         a.strat = strat;
  501 
  502         /* get a buffer and initialize it */
  503         a.bp = geteblk((int)lp->d_secsize);
  504         a.bp->b_dev = dev;
  505 
  506         if (osdep)
  507                 /* Write the label to every netbsd mbr partition */
  508                 scan_mbr(&a, write_netbsd_label);
  509 
  510         /* and overwrite any label at the start of the volume */
  511         validate_label(&a, LABELSECTOR, UPDATE_LABEL);
  512         if (LABELSECTOR != 0)
  513                 validate_label(&a, 0, UPDATE_LABEL);
  514 
  515         if (a.written == 0 && a.error == 0)
  516                 a.error = ESRCH;
  517 
  518         brelse(a.bp);
  519         return a.error;
  520 }
  521 
  522 static int
  523 write_netbsd_label(mbr_args_t *a, struct mbr_partition *dp, int slot, uint ext_base)
  524 {
  525         int ptn_base = ext_base + le32toh(dp->mbrp_start);
  526 
  527         if (dp->mbrp_type != MBR_PTYPE_NETBSD)
  528                 return SCAN_CONTINUE;
  529 
  530         return validate_label(a, ptn_base + MBR_LABELSECTOR, WRITE_LABEL);
  531 }
  532 
  533 
  534 /*
  535  * Determine the size of the transfer, and make sure it is
  536  * within the boundaries of the partition. Adjust transfer
  537  * if needed, and signal errors or early completion.
  538  */
  539 int
  540 bounds_check_with_label(dk, bp, wlabel)
  541         struct disk *dk;
  542         struct buf *bp;
  543         int wlabel;
  544 {
  545         struct disklabel *lp = dk->dk_label;
  546         struct partition *p = lp->d_partitions + DISKPART(bp->b_dev);
  547         int labelsector = lp->d_partitions[2].p_offset + LABELSECTOR;
  548         int sz;
  549 
  550         sz = howmany(bp->b_bcount, lp->d_secsize);
  551 
  552         if (bp->b_blkno + sz > p->p_size) {
  553                 sz = p->p_size - bp->b_blkno;
  554                 if (sz == 0) {
  555                         /* If exactly at end of disk, return EOF. */
  556                         bp->b_resid = bp->b_bcount;
  557                         return (0);
  558                 }
  559                 if (sz < 0) {
  560                         /* If past end of disk, return EINVAL. */
  561                         bp->b_error = EINVAL;
  562                         goto bad;
  563                 }
  564                 /* Otherwise, truncate request. */
  565                 bp->b_bcount = sz << DEV_BSHIFT;
  566         }
  567 
  568         /* Overwriting disk label? */
  569         if (bp->b_blkno + p->p_offset <= labelsector &&
  570             bp->b_blkno + p->p_offset + sz > labelsector &&
  571             (bp->b_flags & B_READ) == 0 && !wlabel) {
  572                 bp->b_error = EROFS;
  573                 goto bad;
  574         }
  575 
  576         /* calculate cylinder for disksort to order transfers with */
  577         bp->b_cylinder = (bp->b_blkno + p->p_offset) /
  578             (lp->d_secsize / DEV_BSIZE) / lp->d_secpercyl;
  579         return (1);
  580 
  581 bad:
  582         bp->b_flags |= B_ERROR;
  583         return (-1);
  584 }

Cache object: 317d6e431c1922b4d7d013ce78661c13


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.