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_disklabel64.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
    3  * 
    4  * This code is derived from software contributed to The DragonFly Project
    5  * by Matthew Dillon <dillon@backplane.com>
    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  * 
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in
   15  *    the documentation and/or other materials provided with the
   16  *    distribution.
   17  * 3. Neither the name of The DragonFly Project nor the names of its
   18  *    contributors may be used to endorse or promote products derived
   19  *    from this software without specific, prior written permission.
   20  * 
   21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
   25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
   27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  * 
   34  * $DragonFly: src/sys/kern/subr_disklabel64.c,v 1.5 2007/07/20 17:21:51 dillon Exp $
   35  */
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/kernel.h>
   40 #include <sys/conf.h>
   41 #include <sys/disklabel.h>
   42 #include <sys/disklabel64.h>
   43 #include <sys/diskslice.h>
   44 #include <sys/disk.h>
   45 #include <sys/kern_syscall.h>
   46 #include <sys/buf2.h>
   47 
   48 /*
   49  * Alignment against physical start (verses slice start).  We use a megabyte
   50  * here.  Why do we use a megabyte?  Because SSDs already use large 128K
   51  * blocks internally (for MLC) and who the hell knows in the future.
   52  *
   53  * This way if the sysop picks sane values for partition sizes everything
   54  * will be nicely aligned, particularly swap for e.g. swapcache, and
   55  * clustered operations against larger physical sector sizes for newer HDs,
   56  * and so forth.
   57  */
   58 #define PALIGN_SIZE     (1024 * 1024)
   59 #define PALIGN_MASK     (PALIGN_SIZE - 1)
   60 
   61 /*
   62  * Retrieve the partition start and extent, in blocks.  Return 0 on success,
   63  * EINVAL on error.
   64  */
   65 static int
   66 l64_getpartbounds(struct diskslices *ssp, disklabel_t lp, u_int32_t part,
   67                   u_int64_t *start, u_int64_t *blocks)
   68 {
   69         struct partition64 *pp;
   70 
   71         if (part >= lp.lab64->d_npartitions)
   72                 return (EINVAL);
   73 
   74         pp = &lp.lab64->d_partitions[part];
   75 
   76         if ((pp->p_boffset & (ssp->dss_secsize - 1)) ||
   77             (pp->p_bsize & (ssp->dss_secsize - 1))) {
   78                 return (EINVAL);
   79         }
   80         *start = pp->p_boffset / ssp->dss_secsize;
   81         *blocks = pp->p_bsize / ssp->dss_secsize;
   82         return(0);
   83 }
   84 
   85 /*
   86  * Get the filesystem type XXX - diskslices code needs to use uuids
   87  */
   88 static void
   89 l64_loadpartinfo(disklabel_t lp, u_int32_t part, struct partinfo *dpart)
   90 {
   91         struct partition64 *pp;
   92         const size_t uuid_size = sizeof(struct uuid);
   93 
   94         if (part < lp.lab64->d_npartitions) {
   95                 pp = &lp.lab64->d_partitions[part];
   96                 dpart->fstype_uuid = pp->p_type_uuid;
   97                 dpart->storage_uuid = pp->p_stor_uuid;
   98                 dpart->fstype = pp->p_fstype;
   99         } else {
  100                 bzero(&dpart->fstype_uuid, uuid_size);
  101                 bzero(&dpart->storage_uuid, uuid_size);
  102                 dpart->fstype = 0;
  103         }
  104 }
  105 
  106 /*
  107  * Get the number of partitions
  108  */
  109 static u_int32_t
  110 l64_getnumparts(disklabel_t lp)
  111 {
  112         return(lp.lab64->d_npartitions);
  113 }
  114 
  115 static void
  116 l64_freedisklabel(disklabel_t *lpp)
  117 {
  118         kfree((*lpp).lab64, M_DEVBUF);
  119         (*lpp).lab64 = NULL;
  120 }
  121 
  122 /*
  123  * Attempt to read a disk label from a device.  64 bit disklabels are
  124  * sector-agnostic and begin at offset 0 on the device.  64 bit disklabels
  125  * may only be used with GPT partitioning schemes.
  126  *
  127  * Returns NULL on sucess, and an error string on failure.
  128  */
  129 static const char *
  130 l64_readdisklabel(cdev_t dev, struct diskslice *sp, disklabel_t *lpp,
  131                   struct disk_info *info)
  132 {
  133         struct buf *bp;
  134         struct disklabel64 *dlp;
  135         const char *msg;
  136         uint32_t savecrc;
  137         size_t dlpcrcsize;
  138         size_t bpsize;
  139         int secsize;
  140 
  141         /*
  142          * XXX I/O size is subject to device DMA limitations
  143          */
  144         secsize = info->d_media_blksize;
  145         bpsize = (sizeof(*dlp) + secsize - 1) & ~(secsize - 1);
  146 
  147         bp = geteblk(bpsize);
  148         bp->b_bio1.bio_offset = 0;
  149         bp->b_bio1.bio_done = biodone_sync;
  150         bp->b_bio1.bio_flags |= BIO_SYNC;
  151         bp->b_bcount = bpsize;
  152         bp->b_flags &= ~B_INVAL;
  153         bp->b_cmd = BUF_CMD_READ;
  154         dev_dstrategy(dev, &bp->b_bio1);
  155 
  156         if (biowait(&bp->b_bio1, "labrd")) {
  157                 msg = "I/O error";
  158         } else {
  159                 dlp = (struct disklabel64 *)bp->b_data;
  160                 dlpcrcsize = offsetof(struct disklabel64,
  161                                       d_partitions[dlp->d_npartitions]) -
  162                              offsetof(struct disklabel64, d_magic);
  163                 savecrc = dlp->d_crc;
  164                 dlp->d_crc = 0;
  165                 if (dlp->d_magic != DISKMAGIC64) {
  166                         msg = "no disk label";
  167                 } else if (dlp->d_npartitions > MAXPARTITIONS64) {
  168                         msg = "disklabel64 corrupted, too many partitions";
  169                 } else if (savecrc != crc32(&dlp->d_magic, dlpcrcsize)) {
  170                         msg = "disklabel64 corrupted, bad CRC";
  171                 } else {
  172                         dlp->d_crc = savecrc;
  173                         (*lpp).lab64 = kmalloc(sizeof(*dlp),
  174                                                M_DEVBUF, M_WAITOK|M_ZERO);
  175                         *(*lpp).lab64 = *dlp;
  176                         msg = NULL;
  177                 }
  178         }
  179         bp->b_flags |= B_INVAL | B_AGE;
  180         brelse(bp);
  181         return (msg);
  182 }
  183 
  184 /*
  185  * If everything is good, copy olpx to nlpx.  Check to see if any
  186  * open partitions would change.
  187  */
  188 static int
  189 l64_setdisklabel(disklabel_t olpx, disklabel_t nlpx, struct diskslices *ssp,
  190                  struct diskslice *sp, u_int32_t *openmask)
  191 {
  192         struct disklabel64 *olp, *nlp;
  193         struct partition64 *opp, *npp;
  194         uint32_t savecrc;
  195         uint64_t slicebsize;
  196         size_t nlpcrcsize;
  197         int i;
  198 
  199         olp = olpx.lab64;
  200         nlp = nlpx.lab64;
  201 
  202         slicebsize = (uint64_t)sp->ds_size * ssp->dss_secsize;
  203 
  204         if (nlp->d_magic != DISKMAGIC64)
  205                 return (EINVAL);
  206         if (nlp->d_npartitions > MAXPARTITIONS64)
  207                 return (EINVAL);
  208         savecrc = nlp->d_crc;
  209         nlp->d_crc = 0;
  210         nlpcrcsize = offsetof(struct disklabel64, 
  211                               d_partitions[nlp->d_npartitions]) -
  212                      offsetof(struct disklabel64, d_magic);
  213         if (crc32(&nlp->d_magic, nlpcrcsize) != savecrc) {
  214                 nlp->d_crc = savecrc;
  215                 return (EINVAL);
  216         }
  217         nlp->d_crc = savecrc;
  218 
  219         /*
  220          * Check if open partitions have changed
  221          */
  222         i = 0;
  223         while (i < MAXPARTITIONS64) {
  224                 if (openmask[i >> 5] == 0) {
  225                         i += 32;
  226                         continue;
  227                 }
  228                 if ((openmask[i >> 5] & (1 << (i & 31))) == 0) {
  229                         ++i;
  230                         continue;
  231                 }
  232                 if (nlp->d_npartitions <= i)
  233                         return (EBUSY);
  234                 opp = &olp->d_partitions[i];
  235                 npp = &nlp->d_partitions[i];
  236                 if (npp->p_boffset != opp->p_boffset ||
  237                     npp->p_bsize < opp->p_bsize) {
  238                         return (EBUSY);
  239                 }
  240 
  241                 /*
  242                  * Do not allow p_type_uuid or p_stor_uuid to change if
  243                  * the partition is currently open.
  244                  */
  245                 if (bcmp(&npp->p_type_uuid, &opp->p_type_uuid,
  246                      sizeof(npp->p_type_uuid)) != 0) {
  247                         return (EBUSY);
  248                 }
  249                 if (bcmp(&npp->p_stor_uuid, &opp->p_stor_uuid,
  250                      sizeof(npp->p_stor_uuid)) != 0) {
  251                         return (EBUSY);
  252                 }
  253                 ++i;
  254         }
  255 
  256         /*
  257          * Make sure the label and partition offsets and sizes are sane.
  258          */
  259         if (nlp->d_total_size > slicebsize)
  260                 return (ENOSPC);
  261         if (nlp->d_total_size & (ssp->dss_secsize - 1))
  262                 return (EINVAL);
  263         if (nlp->d_bbase & (ssp->dss_secsize - 1))
  264                 return (EINVAL);
  265         if (nlp->d_pbase & (ssp->dss_secsize - 1))
  266                 return (EINVAL);
  267         if (nlp->d_pstop & (ssp->dss_secsize - 1))
  268                 return (EINVAL);
  269         if (nlp->d_abase & (ssp->dss_secsize - 1))
  270                 return (EINVAL);
  271 
  272         for (i = 0; i < nlp->d_npartitions; ++i) {
  273                 npp = &nlp->d_partitions[i];
  274                 if (npp->p_bsize == 0) {
  275                         if (npp->p_boffset != 0)
  276                                 return (EINVAL);
  277                         continue;
  278                 }
  279                 if (npp->p_boffset & (ssp->dss_secsize - 1))
  280                         return (EINVAL);
  281                 if (npp->p_bsize & (ssp->dss_secsize - 1))
  282                         return (EINVAL);
  283                 if (npp->p_boffset < nlp->d_pbase)
  284                         return (ENOSPC);
  285                 if (npp->p_boffset + npp->p_bsize > nlp->d_total_size)
  286                         return (ENOSPC);
  287         }
  288 
  289         /*
  290          * Structurally we may add code to make modifications above in the
  291          * future, so regenerate the crc anyway.
  292          */
  293         nlp->d_crc = 0;
  294         nlp->d_crc = crc32(&nlp->d_magic, nlpcrcsize);
  295         *olp = *nlp;
  296 
  297         return (0);
  298 }
  299 
  300 /*
  301  * Write disk label back to device after modification.
  302  */
  303 static int
  304 l64_writedisklabel(cdev_t dev, struct diskslices *ssp,
  305                    struct diskslice *sp, disklabel_t lpx)
  306 {
  307         struct disklabel64 *lp;
  308         struct disklabel64 *dlp;
  309         struct buf *bp;
  310         int error = 0;
  311         size_t bpsize;
  312         int secsize;
  313 
  314         lp = lpx.lab64;
  315 
  316         /*
  317          * XXX I/O size is subject to device DMA limitations
  318          */
  319         secsize = ssp->dss_secsize;
  320         bpsize = (sizeof(*lp) + secsize - 1) & ~(secsize - 1);
  321 
  322         bp = geteblk(bpsize);
  323         bp->b_bio1.bio_offset = 0;
  324         bp->b_bio1.bio_done = biodone_sync;
  325         bp->b_bio1.bio_flags |= BIO_SYNC;
  326         bp->b_bcount = bpsize;
  327 
  328         /*
  329          * Because our I/O is larger then the label, and because we do not
  330          * write the d_reserved0[] area, do a read-modify-write.
  331          */
  332         bp->b_flags &= ~B_INVAL;
  333         bp->b_cmd = BUF_CMD_READ;
  334         KKASSERT(dkpart(dev) == WHOLE_SLICE_PART);
  335         dev_dstrategy(dev, &bp->b_bio1);
  336         error = biowait(&bp->b_bio1, "labrd");
  337         if (error)
  338                 goto done;
  339 
  340         dlp = (void *)bp->b_data;
  341         bcopy(&lp->d_magic, &dlp->d_magic,
  342               sizeof(*lp) - offsetof(struct disklabel64, d_magic));
  343         bp->b_cmd = BUF_CMD_WRITE;
  344         bp->b_bio1.bio_done = biodone_sync;
  345         bp->b_bio1.bio_flags |= BIO_SYNC;
  346         KKASSERT(dkpart(dev) == WHOLE_SLICE_PART);
  347         dev_dstrategy(dev, &bp->b_bio1);
  348         error = biowait(&bp->b_bio1, "labwr");
  349 done:
  350         bp->b_flags |= B_INVAL | B_AGE;
  351         brelse(bp);
  352         return (error);
  353 }
  354 
  355 /*
  356  * Create a disklabel based on a disk_info structure for the purposes of
  357  * DSO_COMPATLABEL - cases where no real label exists on the storage medium.
  358  *
  359  * If a diskslice is passed, the label is truncated to the slice.
  360  *
  361  * NOTE!  This is not a legal label because d_bbase and d_pbase are both
  362  * set to 0.
  363  */
  364 static disklabel_t
  365 l64_clone_label(struct disk_info *info, struct diskslice *sp)
  366 {
  367         struct disklabel64 *lp;
  368         disklabel_t res;
  369         uint32_t blksize = info->d_media_blksize;
  370         size_t lpcrcsize;
  371 
  372         lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK | M_ZERO);
  373 
  374         if (sp)
  375                 lp->d_total_size = (uint64_t)sp->ds_size * blksize;
  376         else
  377                 lp->d_total_size = info->d_media_blocks * blksize;
  378 
  379         lp->d_magic = DISKMAGIC64;
  380         lp->d_align = blksize;
  381         lp->d_npartitions = MAXPARTITIONS64;
  382         lp->d_pstop = lp->d_total_size;
  383 
  384         /*
  385          * Create a dummy 'c' part and a dummy 'a' part (if requested).
  386          * Note that the 'c' part is really a hack.  64 bit disklabels
  387          * do not use 'c' to mean the raw partition.
  388          */
  389 
  390         lp->d_partitions[2].p_boffset = 0;
  391         lp->d_partitions[2].p_bsize = lp->d_total_size;
  392         /* XXX SET FS TYPE */
  393 
  394         if (info->d_dsflags & DSO_COMPATPARTA) {
  395                 lp->d_partitions[0].p_boffset = 0;
  396                 lp->d_partitions[0].p_bsize = lp->d_total_size;
  397                 /* XXX SET FS TYPE */
  398         }
  399 
  400         lpcrcsize = offsetof(struct disklabel64,
  401                              d_partitions[lp->d_npartitions]) -
  402                     offsetof(struct disklabel64, d_magic);
  403 
  404         lp->d_crc = crc32(&lp->d_magic, lpcrcsize);
  405         res.lab64 = lp;
  406         return (res);
  407 }
  408 
  409 /*
  410  * Create a virgin disklabel64 suitable for writing to the media.
  411  *
  412  * disklabel64 always reserves 32KB for a boot area and leaves room
  413  * for up to RESPARTITIONS64 partitions.  
  414  */
  415 static void
  416 l64_makevirginlabel(disklabel_t lpx, struct diskslices *ssp,
  417                     struct diskslice *sp, struct disk_info *info)
  418 {
  419         struct disklabel64 *lp = lpx.lab64;
  420         struct partition64 *pp;
  421         uint32_t blksize;
  422         uint32_t ressize;
  423         uint64_t blkmask;       /* 64 bits so we can ~ */
  424         size_t lpcrcsize;
  425 
  426         /*
  427          * Setup the initial label.  Use of a block size of at least 4KB
  428          * for calculating the initial reserved areas to allow some degree
  429          * of portability between media with different sector sizes.
  430          *
  431          * Note that the modified blksize is stored in d_align as a hint
  432          * to the disklabeling program.
  433          */
  434         bzero(lp, sizeof(*lp));
  435         if ((blksize = info->d_media_blksize) < 4096)
  436                 blksize = 4096;
  437         blkmask = blksize - 1;
  438 
  439         if (sp)
  440                 lp->d_total_size = (uint64_t)sp->ds_size * ssp->dss_secsize;
  441         else
  442                 lp->d_total_size = info->d_media_blocks * info->d_media_blksize;
  443 
  444         lp->d_magic = DISKMAGIC64;
  445         lp->d_align = blksize;
  446         lp->d_npartitions = MAXPARTITIONS64;
  447         kern_uuidgen(&lp->d_stor_uuid, 1);
  448 
  449         ressize = offsetof(struct disklabel64, d_partitions[RESPARTITIONS64]);
  450         ressize = (ressize + (uint32_t)blkmask) & ~blkmask;
  451 
  452         /*
  453          * NOTE: When calculating pbase take into account the slice offset
  454          *       so the partitions are at least 32K-aligned relative to the
  455          *       start of the physical disk.  This will accomodate efficient
  456          *       access to 4096 byte physical sector drives.
  457          */
  458         lp->d_bbase = ressize;
  459         lp->d_pbase = lp->d_bbase + ((32768 + blkmask) & ~blkmask);
  460         lp->d_pbase = (lp->d_pbase + PALIGN_MASK) & ~(uint64_t)PALIGN_MASK;
  461 
  462         /* adjust for slice offset so we are physically aligned */
  463         lp->d_pbase += 32768 - (sp->ds_offset * info->d_media_blksize) % 32768;
  464 
  465         lp->d_pstop = (lp->d_total_size - lp->d_bbase) & ~blkmask;
  466         lp->d_abase = lp->d_pstop;
  467 
  468         /*
  469          * All partitions are left empty unless DSO_COMPATPARTA is set
  470          */
  471 
  472         if (info->d_dsflags & DSO_COMPATPARTA) {
  473                 pp = &lp->d_partitions[0];
  474                 pp->p_boffset = lp->d_pbase;
  475                 pp->p_bsize = lp->d_pstop - lp->d_pbase;
  476                 /* XXX SET FS TYPE */
  477         }
  478 
  479         lpcrcsize = offsetof(struct disklabel64,
  480                              d_partitions[lp->d_npartitions]) -
  481                     offsetof(struct disklabel64, d_magic);
  482         lp->d_crc = crc32(&lp->d_magic, lpcrcsize);
  483 }
  484 
  485 /*
  486  * Set the number of blocks at the beginning of the slice which have
  487  * been reserved for label operations.  This area will be write-protected
  488  * when accessed via the slice.
  489  *
  490  * For now just protect the label area proper.  Do not protect the
  491  * boot area.  Note partitions in 64 bit disklabels do not overlap
  492  * the disklabel or boot area.
  493  */
  494 static void
  495 l64_adjust_label_reserved(struct diskslices *ssp, int slice,
  496                           struct diskslice *sp)
  497 {
  498         struct disklabel64 *lp = sp->ds_label.lab64;
  499 
  500         sp->ds_reserved = lp->d_bbase / ssp->dss_secsize;
  501 }
  502 
  503 struct disklabel_ops disklabel64_ops = {
  504         .labelsize = sizeof(struct disklabel64),
  505         .op_readdisklabel = l64_readdisklabel,
  506         .op_setdisklabel = l64_setdisklabel,
  507         .op_writedisklabel = l64_writedisklabel,
  508         .op_clone_label = l64_clone_label,
  509         .op_adjust_label_reserved = l64_adjust_label_reserved,
  510         .op_getpartbounds = l64_getpartbounds,
  511         .op_loadpartinfo = l64_loadpartinfo,
  512         .op_getnumparts = l64_getnumparts,
  513         .op_makevirginlabel = l64_makevirginlabel,
  514         .op_freedisklabel = l64_freedisklabel
  515 };
  516 

Cache object: a08ecedba8b36396cb61a2bd968bd521


[ 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.