2 * Copyright (c) 2007 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
34 * $DragonFly: src/sys/kern/subr_disklabel64.c,v 1.5 2007/07/20 17:21:51 dillon Exp $
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
41 #include <sys/disklabel.h>
42 #include <sys/disklabel64.h>
43 #include <sys/diskslice.h>
45 #include <sys/kern_syscall.h>
49 * Retrieve the partition start and extent, in blocks. Return 0 on success,
53 l64_getpartbounds(struct diskslices *ssp, disklabel_t lp, u_int32_t part,
54 u_int64_t *start, u_int64_t *blocks)
56 struct partition64 *pp;
58 if (part >= lp.lab64->d_npartitions)
61 pp = &lp.lab64->d_partitions[part];
63 if ((pp->p_boffset & (ssp->dss_secsize - 1)) ||
64 (pp->p_bsize & (ssp->dss_secsize - 1))) {
67 *start = pp->p_boffset / ssp->dss_secsize;
68 *blocks = pp->p_bsize / ssp->dss_secsize;
73 * Get the filesystem type XXX - diskslices code needs to use uuids
76 l64_loadpartinfo(disklabel_t lp, u_int32_t part, struct partinfo *dpart)
78 struct partition64 *pp;
79 const size_t uuid_size = sizeof(struct uuid);
81 if (part < lp.lab64->d_npartitions) {
82 pp = &lp.lab64->d_partitions[part];
83 dpart->fstype_uuid = pp->p_type_uuid;
84 dpart->storage_uuid = pp->p_stor_uuid;
85 dpart->fstype = pp->p_fstype;
87 bzero(&dpart->fstype_uuid, uuid_size);
88 bzero(&dpart->storage_uuid, uuid_size);
94 * Get the number of partitions
97 l64_getnumparts(disklabel_t lp)
99 return(lp.lab64->d_npartitions);
103 * Attempt to read a disk label from a device. 64 bit disklabels are
104 * sector-agnostic and begin at offset 0 on the device. 64 bit disklabels
105 * may only be used with GPT partitioning schemes.
107 * Returns NULL on sucess, and an error string on failure.
110 l64_readdisklabel(cdev_t dev, struct diskslice *sp, disklabel_t *lpp,
111 struct disk_info *info)
114 struct disklabel64 *dlp;
122 * XXX I/O size is subject to device DMA limitations
124 secsize = info->d_media_blksize;
125 bpsize = (sizeof(*dlp) + secsize - 1) & ~(secsize - 1);
127 bp = geteblk(bpsize);
128 bp->b_bio1.bio_offset = 0;
129 bp->b_bio1.bio_done = biodone_sync;
130 bp->b_bio1.bio_flags |= BIO_SYNC;
131 bp->b_bcount = bpsize;
132 bp->b_flags &= ~B_INVAL;
133 bp->b_cmd = BUF_CMD_READ;
134 dev_dstrategy(dev, &bp->b_bio1);
136 if (biowait(&bp->b_bio1, "labrd")) {
139 dlp = (struct disklabel64 *)bp->b_data;
140 dlpcrcsize = offsetof(struct disklabel64,
141 d_partitions[dlp->d_npartitions]) -
142 offsetof(struct disklabel64, d_magic);
143 savecrc = dlp->d_crc;
145 if (dlp->d_magic != DISKMAGIC64) {
146 msg = "no disk label";
147 } else if (dlp->d_npartitions > MAXPARTITIONS64) {
148 msg = "disklabel64 corrupted, too many partitions";
149 } else if (savecrc != crc32(&dlp->d_magic, dlpcrcsize)) {
150 msg = "disklabel64 corrupted, bad CRC";
152 dlp->d_crc = savecrc;
153 (*lpp).lab64 = kmalloc(sizeof(*dlp),
154 M_DEVBUF, M_WAITOK|M_ZERO);
155 *(*lpp).lab64 = *dlp;
159 bp->b_flags |= B_INVAL | B_AGE;
165 * If everything is good, copy olpx to nlpx. Check to see if any
166 * open partitions would change.
169 l64_setdisklabel(disklabel_t olpx, disklabel_t nlpx, struct diskslices *ssp,
170 struct diskslice *sp, u_int32_t *openmask)
172 struct disklabel64 *olp, *nlp;
173 struct partition64 *opp, *npp;
183 slicebsize = (uint64_t)sp->ds_size * ssp->dss_secsize;
185 if (nlp->d_magic != DISKMAGIC64)
187 if (nlp->d_npartitions > MAXPARTITIONS64)
189 savecrc = nlp->d_crc;
191 nlpcrcsize = offsetof(struct disklabel64,
192 d_partitions[nlp->d_npartitions]) -
193 offsetof(struct disklabel64, d_magic);
194 if (crc32(&nlp->d_magic, nlpcrcsize) != savecrc) {
195 nlp->d_crc = savecrc;
198 nlp->d_crc = savecrc;
201 * Check if open partitions have changed
205 if (openmask[i >> 5] == 0) {
209 if ((openmask[i >> 5] & (1 << (i & 31))) == 0) {
213 if (nlp->d_npartitions <= i)
215 opp = &olp->d_partitions[i];
216 npp = &nlp->d_partitions[i];
217 if (npp->p_boffset != opp->p_boffset ||
218 npp->p_bsize < opp->p_bsize) {
223 * Do not allow p_type_uuid or p_stor_uuid to change if
224 * the partition is currently open.
226 if (bcmp(&npp->p_type_uuid, &opp->p_type_uuid,
227 sizeof(npp->p_type_uuid)) != 0) {
230 if (bcmp(&npp->p_stor_uuid, &opp->p_stor_uuid,
231 sizeof(npp->p_stor_uuid)) != 0) {
238 * Make sure the label and partition offsets and sizes are sane.
240 if (nlp->d_total_size > slicebsize)
242 if (nlp->d_total_size & (ssp->dss_secsize - 1))
244 if (nlp->d_bbase & (ssp->dss_secsize - 1))
246 if (nlp->d_pbase & (ssp->dss_secsize - 1))
248 if (nlp->d_pstop & (ssp->dss_secsize - 1))
250 if (nlp->d_abase & (ssp->dss_secsize - 1))
253 for (part = 0; part < nlp->d_npartitions; ++part) {
254 npp = &nlp->d_partitions[i];
255 if (npp->p_bsize == 0) {
256 if (npp->p_boffset != 0)
260 if (npp->p_boffset & (ssp->dss_secsize - 1))
262 if (npp->p_bsize & (ssp->dss_secsize - 1))
264 if (npp->p_boffset < nlp->d_pbase)
266 if (npp->p_boffset + npp->p_bsize > nlp->d_total_size)
271 * Structurally we may add code to make modifications above in the
272 * future, so regenerate the crc anyway.
275 nlp->d_crc = crc32(&nlp->d_magic, nlpcrcsize);
282 * Write disk label back to device after modification.
285 l64_writedisklabel(cdev_t dev, struct diskslices *ssp,
286 struct diskslice *sp, disklabel_t lpx)
288 struct disklabel64 *lp;
289 struct disklabel64 *dlp;
298 * XXX I/O size is subject to device DMA limitations
300 secsize = ssp->dss_secsize;
301 bpsize = (sizeof(*lp) + secsize - 1) & ~(secsize - 1);
303 bp = geteblk(bpsize);
304 bp->b_bio1.bio_offset = 0;
305 bp->b_bio1.bio_done = biodone_sync;
306 bp->b_bio1.bio_flags |= BIO_SYNC;
307 bp->b_bcount = bpsize;
310 * Because our I/O is larger then the label, and because we do not
311 * write the d_reserved0[] area, do a read-modify-write.
313 bp->b_flags &= ~B_INVAL;
314 bp->b_cmd = BUF_CMD_READ;
315 KKASSERT(dkpart(dev) == WHOLE_SLICE_PART);
316 dev_dstrategy(dev, &bp->b_bio1);
317 error = biowait(&bp->b_bio1, "labrd");
321 dlp = (void *)bp->b_data;
322 bcopy(&lp->d_magic, &dlp->d_magic,
323 sizeof(*lp) - offsetof(struct disklabel64, d_magic));
324 bp->b_cmd = BUF_CMD_WRITE;
325 bp->b_bio1.bio_done = biodone_sync;
326 bp->b_bio1.bio_flags |= BIO_SYNC;
327 KKASSERT(dkpart(dev) == WHOLE_SLICE_PART);
328 dev_dstrategy(dev, &bp->b_bio1);
329 error = biowait(&bp->b_bio1, "labwr");
331 bp->b_flags |= B_INVAL | B_AGE;
337 * Create a disklabel based on a disk_info structure for the purposes of
338 * DSO_COMPATLABEL - cases where no real label exists on the storage medium.
340 * If a diskslice is passed, the label is truncated to the slice.
342 * NOTE! This is not a legal label because d_bbase and d_pbase are both
346 l64_clone_label(struct disk_info *info, struct diskslice *sp)
348 struct disklabel64 *lp;
350 uint32_t blksize = info->d_media_blksize;
353 lp = kmalloc(sizeof *lp, M_DEVBUF, M_WAITOK | M_ZERO);
356 lp->d_total_size = (uint64_t)sp->ds_size * blksize;
358 lp->d_total_size = info->d_media_blocks * blksize;
360 lp->d_magic = DISKMAGIC64;
361 lp->d_align = blksize;
362 lp->d_npartitions = MAXPARTITIONS64;
363 lp->d_pstop = lp->d_total_size;
366 * Create a dummy 'c' part and a dummy 'a' part (if requested).
367 * Note that the 'c' part is really a hack. 64 bit disklabels
368 * do not use 'c' to mean the raw partition.
371 lp->d_partitions[2].p_boffset = 0;
372 lp->d_partitions[2].p_bsize = lp->d_total_size;
373 /* XXX SET FS TYPE */
375 if (info->d_dsflags & DSO_COMPATPARTA) {
376 lp->d_partitions[0].p_boffset = 0;
377 lp->d_partitions[0].p_bsize = lp->d_total_size;
378 /* XXX SET FS TYPE */
381 lpcrcsize = offsetof(struct disklabel64,
382 d_partitions[lp->d_npartitions]) -
383 offsetof(struct disklabel64, d_magic);
385 lp->d_crc = crc32(&lp->d_magic, lpcrcsize);
391 * Create a virgin disklabel64 suitable for writing to the media.
393 * disklabel64 always reserves 32KB for a boot area and leaves room
394 * for up to RESPARTITIONS64 partitions.
397 l64_makevirginlabel(disklabel_t lpx, struct diskslices *ssp,
398 struct diskslice *sp, struct disk_info *info)
400 struct disklabel64 *lp = lpx.lab64;
401 struct partition64 *pp;
404 uint64_t blkmask; /* 64 bits so we can ~ */
408 * Setup the initial label. Use of a block size of at least 4KB
409 * for calculating the initial reserved areas to allow some degree
410 * of portability between media with different sector sizes.
412 * Note that the modified blksize is stored in d_align as a hint
413 * to the disklabeling program.
415 bzero(lp, sizeof(*lp));
416 if ((blksize = info->d_media_blksize) < 4096)
418 blkmask = blksize - 1;
421 lp->d_total_size = (uint64_t)sp->ds_size * ssp->dss_secsize;
423 lp->d_total_size = info->d_media_blocks * info->d_media_blksize;
425 lp->d_magic = DISKMAGIC64;
426 lp->d_align = blksize;
427 lp->d_npartitions = MAXPARTITIONS64;
428 kern_uuidgen(&lp->d_stor_uuid, 1);
430 ressize = offsetof(struct disklabel64, d_partitions[RESPARTITIONS64]);
431 ressize = (ressize + (uint32_t)blkmask) & ~blkmask;
433 lp->d_bbase = ressize;
434 lp->d_pbase = lp->d_bbase + ((32768 + blkmask) & ~blkmask);
435 lp->d_pstop = (lp->d_total_size - lp->d_bbase) & ~blkmask;
436 lp->d_abase = lp->d_pstop;
439 * All partitions are left empty unless DSO_COMPATPARTA is set
442 if (info->d_dsflags & DSO_COMPATPARTA) {
443 pp = &lp->d_partitions[0];
444 pp->p_boffset = lp->d_pbase;
445 pp->p_bsize = lp->d_pstop - lp->d_pbase;
446 /* XXX SET FS TYPE */
449 lpcrcsize = offsetof(struct disklabel64,
450 d_partitions[lp->d_npartitions]) -
451 offsetof(struct disklabel64, d_magic);
452 lp->d_crc = crc32(&lp->d_magic, lpcrcsize);
456 * Set the number of blocks at the beginning of the slice which have
457 * been reserved for label operations. This area will be write-protected
458 * when accessed via the slice.
460 * For now just protect the label area proper. Do not protect the
461 * boot area. Note partitions in 64 bit disklabels do not overlap
462 * the disklabel or boot area.
465 l64_adjust_label_reserved(struct diskslices *ssp, int slice,
466 struct diskslice *sp)
468 struct disklabel64 *lp = sp->ds_label.lab64;
470 sp->ds_reserved = lp->d_bbase / ssp->dss_secsize;
473 struct disklabel_ops disklabel64_ops = {
474 .labelsize = sizeof(struct disklabel64),
475 .op_readdisklabel = l64_readdisklabel,
476 .op_setdisklabel = l64_setdisklabel,
477 .op_writedisklabel = l64_writedisklabel,
478 .op_clone_label = l64_clone_label,
479 .op_adjust_label_reserved = l64_adjust_label_reserved,
480 .op_getpartbounds = l64_getpartbounds,
481 .op_loadpartinfo = l64_loadpartinfo,
482 .op_getnumparts = l64_getnumparts,
483 .op_makevirginlabel = l64_makevirginlabel