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
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
39 #include <sys/disklabel.h>
40 #include <sys/disklabel64.h>
41 #include <sys/diskslice.h>
43 #include <sys/kern_syscall.h>
47 * Alignment against physical start (verses slice start). We use a megabyte
48 * here. Why do we use a megabyte? Because SSDs already use large 128K
49 * blocks internally (for MLC) and who the hell knows in the future.
51 * This way if the sysop picks sane values for partition sizes everything
52 * will be nicely aligned, particularly swap for e.g. swapcache, and
53 * clustered operations against larger physical sector sizes for newer HDs,
56 #define PALIGN_SIZE (1024 * 1024)
57 #define PALIGN_MASK (PALIGN_SIZE - 1)
60 * Retrieve the partition start and extent, in blocks. Return 0 on success,
64 l64_getpartbounds(struct diskslices
*ssp
, disklabel_t lp
, u_int32_t part
,
65 u_int64_t
*start
, u_int64_t
*blocks
)
67 struct partition64
*pp
;
69 if (part
>= lp
.lab64
->d_npartitions
)
72 pp
= &lp
.lab64
->d_partitions
[part
];
74 if ((pp
->p_boffset
& (ssp
->dss_secsize
- 1)) ||
75 (pp
->p_bsize
& (ssp
->dss_secsize
- 1))) {
78 *start
= pp
->p_boffset
/ ssp
->dss_secsize
;
79 *blocks
= pp
->p_bsize
/ ssp
->dss_secsize
;
84 * Get the filesystem type XXX - diskslices code needs to use uuids
87 l64_loadpartinfo(disklabel_t lp
, u_int32_t part
, struct partinfo
*dpart
)
89 struct partition64
*pp
;
90 const size_t uuid_size
= sizeof(struct uuid
);
92 if (part
< lp
.lab64
->d_npartitions
) {
93 pp
= &lp
.lab64
->d_partitions
[part
];
94 dpart
->fstype_uuid
= pp
->p_type_uuid
;
95 dpart
->storage_uuid
= pp
->p_stor_uuid
;
96 dpart
->fstype
= pp
->p_fstype
;
98 bzero(&dpart
->fstype_uuid
, uuid_size
);
99 bzero(&dpart
->storage_uuid
, uuid_size
);
105 * Get the number of partitions
108 l64_getnumparts(disklabel_t lp
)
110 return(lp
.lab64
->d_npartitions
);
114 l64_freedisklabel(disklabel_t
*lpp
)
116 kfree((*lpp
).lab64
, M_DEVBUF
);
121 * Attempt to read a disk label from a device. 64 bit disklabels are
122 * sector-agnostic and begin at offset 0 on the device.
124 * Returns NULL on sucess, and an error string on failure.
127 l64_readdisklabel(cdev_t dev
, struct diskslice
*sp
, disklabel_t
*lpp
,
128 struct disk_info
*info
)
131 struct disklabel64
*dlp
;
139 * XXX I/O size is subject to device DMA limitations
141 secsize
= info
->d_media_blksize
;
142 bpsize
= roundup2(sizeof(*dlp
), secsize
);
144 bp
= getpbuf_mem(NULL
);
145 KKASSERT(bpsize
<= bp
->b_bufsize
);
146 bp
->b_bio1
.bio_offset
= 0;
147 bp
->b_bio1
.bio_done
= biodone_sync
;
148 bp
->b_bio1
.bio_flags
|= BIO_SYNC
;
149 bp
->b_bcount
= bpsize
;
150 bp
->b_flags
&= ~B_INVAL
;
151 bp
->b_flags
|= B_FAILONDIS
;
152 bp
->b_cmd
= BUF_CMD_READ
;
153 dev_dstrategy(dev
, &bp
->b_bio1
);
155 if (biowait(&bp
->b_bio1
, "labrd")) {
158 dlp
= (struct disklabel64
*)bp
->b_data
;
159 dlpcrcsize
= offsetof(struct disklabel64
,
160 d_partitions
[dlp
->d_npartitions
]) -
161 offsetof(struct disklabel64
, d_magic
);
162 savecrc
= dlp
->d_crc
;
164 if (dlp
->d_magic
!= DISKMAGIC64
) {
165 msg
= "no disk label";
166 } else if (dlp
->d_npartitions
> MAXPARTITIONS64
) {
167 msg
= "disklabel64 corrupted, too many partitions";
168 } else if (savecrc
!= crc32(&dlp
->d_magic
, dlpcrcsize
)) {
169 msg
= "disklabel64 corrupted, bad CRC";
171 dlp
->d_crc
= savecrc
;
172 (*lpp
).lab64
= kmalloc(sizeof(*dlp
),
173 M_DEVBUF
, M_WAITOK
|M_ZERO
);
174 *(*lpp
).lab64
= *dlp
;
178 bp
->b_flags
|= B_INVAL
| B_AGE
;
185 * If everything is good, copy olpx to nlpx. Check to see if any
186 * open partitions would change.
189 l64_setdisklabel(disklabel_t olpx
, disklabel_t nlpx
, struct diskslices
*ssp
,
190 struct diskslice
*sp
, u_int32_t
*openmask
)
192 struct disklabel64
*olp
, *nlp
;
193 struct partition64
*opp
, *npp
;
202 slicebsize
= (uint64_t)sp
->ds_size
* ssp
->dss_secsize
;
204 if (nlp
->d_magic
!= DISKMAGIC64
)
206 if (nlp
->d_npartitions
> MAXPARTITIONS64
)
208 savecrc
= nlp
->d_crc
;
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
;
217 nlp
->d_crc
= savecrc
;
220 * Check if open partitions have changed
223 while (i
< MAXPARTITIONS64
) {
224 if (openmask
[i
>> 5] == 0) {
228 if ((openmask
[i
>> 5] & (1 << (i
& 31))) == 0) {
232 if (nlp
->d_npartitions
<= i
)
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
) {
242 * Do not allow p_type_uuid or p_stor_uuid to change if
243 * the partition is currently open.
245 if (bcmp(&npp
->p_type_uuid
, &opp
->p_type_uuid
,
246 sizeof(npp
->p_type_uuid
)) != 0) {
249 if (bcmp(&npp
->p_stor_uuid
, &opp
->p_stor_uuid
,
250 sizeof(npp
->p_stor_uuid
)) != 0) {
257 * Make sure the label and partition offsets and sizes are sane.
259 if (nlp
->d_total_size
> slicebsize
)
261 if (nlp
->d_total_size
& (ssp
->dss_secsize
- 1))
263 if (nlp
->d_bbase
& (ssp
->dss_secsize
- 1))
265 if (nlp
->d_pbase
& (ssp
->dss_secsize
- 1))
267 if (nlp
->d_pstop
& (ssp
->dss_secsize
- 1))
269 if (nlp
->d_abase
& (ssp
->dss_secsize
- 1))
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)
279 if (npp
->p_boffset
& (ssp
->dss_secsize
- 1))
281 if (npp
->p_bsize
& (ssp
->dss_secsize
- 1))
283 if (npp
->p_boffset
< nlp
->d_pbase
)
285 if (npp
->p_boffset
+ npp
->p_bsize
> nlp
->d_total_size
)
290 * Structurally we may add code to make modifications above in the
291 * future, so regenerate the crc anyway.
294 nlp
->d_crc
= crc32(&nlp
->d_magic
, nlpcrcsize
);
301 * Write disk label back to device after modification.
304 l64_writedisklabel(cdev_t dev
, struct diskslices
*ssp
,
305 struct diskslice
*sp
, disklabel_t lpx
)
307 struct disklabel64
*lp
;
308 struct disklabel64
*dlp
;
317 * XXX I/O size is subject to device DMA limitations
319 secsize
= ssp
->dss_secsize
;
320 bpsize
= roundup2(sizeof(*lp
), secsize
);
322 bp
= getpbuf_mem(NULL
);
323 KKASSERT(bpsize
<= bp
->b_bufsize
);
324 bp
->b_bio1
.bio_offset
= 0;
325 bp
->b_bio1
.bio_done
= biodone_sync
;
326 bp
->b_bio1
.bio_flags
|= BIO_SYNC
;
327 bp
->b_bcount
= bpsize
;
328 bp
->b_flags
|= B_FAILONDIS
;
331 * Because our I/O is larger then the label, and because we do not
332 * write the d_reserved0[] area, do a read-modify-write.
334 bp
->b_flags
&= ~B_INVAL
;
335 bp
->b_cmd
= BUF_CMD_READ
;
336 KKASSERT(dkpart(dev
) == WHOLE_SLICE_PART
);
337 dev_dstrategy(dev
, &bp
->b_bio1
);
338 error
= biowait(&bp
->b_bio1
, "labrd");
342 dlp
= (void *)bp
->b_data
;
343 bcopy(&lp
->d_magic
, &dlp
->d_magic
,
344 sizeof(*lp
) - offsetof(struct disklabel64
, d_magic
));
345 bp
->b_cmd
= BUF_CMD_WRITE
;
346 bp
->b_bio1
.bio_done
= biodone_sync
;
347 bp
->b_bio1
.bio_flags
|= BIO_SYNC
;
348 KKASSERT(dkpart(dev
) == WHOLE_SLICE_PART
);
349 dev_dstrategy(dev
, &bp
->b_bio1
);
350 error
= biowait(&bp
->b_bio1
, "labwr");
352 bp
->b_flags
|= B_INVAL
| B_AGE
;
359 * Create a disklabel based on a disk_info structure for the purposes of
360 * DSO_COMPATLABEL - cases where no real label exists on the storage medium.
362 * If a diskslice is passed, the label is truncated to the slice.
364 * NOTE! This is not a legal label because d_bbase and d_pbase are both
368 l64_clone_label(struct disk_info
*info
, struct diskslice
*sp
)
370 struct disklabel64
*lp
;
372 uint32_t blksize
= info
->d_media_blksize
;
375 lp
= kmalloc(sizeof *lp
, M_DEVBUF
, M_WAITOK
| M_ZERO
);
378 lp
->d_total_size
= (uint64_t)sp
->ds_size
* blksize
;
380 lp
->d_total_size
= info
->d_media_blocks
* blksize
;
382 lp
->d_magic
= DISKMAGIC64
;
383 lp
->d_align
= blksize
;
384 lp
->d_npartitions
= MAXPARTITIONS64
;
385 lp
->d_pstop
= lp
->d_total_size
;
388 * Create a dummy 'c' part and a dummy 'a' part (if requested).
389 * Note that the 'c' part is really a hack. 64 bit disklabels
390 * do not use 'c' to mean the raw partition.
393 lp
->d_partitions
[2].p_boffset
= 0;
394 lp
->d_partitions
[2].p_bsize
= lp
->d_total_size
;
395 /* XXX SET FS TYPE */
397 if (info
->d_dsflags
& DSO_COMPATPARTA
) {
398 lp
->d_partitions
[0].p_boffset
= 0;
399 lp
->d_partitions
[0].p_bsize
= lp
->d_total_size
;
400 /* XXX SET FS TYPE */
403 lpcrcsize
= offsetof(struct disklabel64
,
404 d_partitions
[lp
->d_npartitions
]) -
405 offsetof(struct disklabel64
, d_magic
);
407 lp
->d_crc
= crc32(&lp
->d_magic
, lpcrcsize
);
413 * Create a virgin disklabel64 suitable for writing to the media.
415 * disklabel64 always reserves 32KB for a boot area and leaves room
416 * for up to RESPARTITIONS64 partitions.
419 l64_makevirginlabel(disklabel_t lpx
, struct diskslices
*ssp
,
420 struct diskslice
*sp
, struct disk_info
*info
)
422 struct disklabel64
*lp
= lpx
.lab64
;
423 struct partition64
*pp
;
426 uint64_t blkmask
; /* 64 bits so we can ~ */
430 doffset
= sp
->ds_offset
* info
->d_media_blksize
;
433 * Setup the initial label. Use of a block size of at least 4KB
434 * for calculating the initial reserved areas to allow some degree
435 * of portability between media with different sector sizes.
437 * Note that the modified blksize is stored in d_align as a hint
438 * to the disklabeling program.
440 bzero(lp
, sizeof(*lp
));
441 if ((blksize
= info
->d_media_blksize
) < 4096)
443 blkmask
= blksize
- 1;
446 lp
->d_total_size
= (uint64_t)sp
->ds_size
* ssp
->dss_secsize
;
448 lp
->d_total_size
= info
->d_media_blocks
* info
->d_media_blksize
;
450 lp
->d_magic
= DISKMAGIC64
;
451 lp
->d_align
= blksize
;
452 lp
->d_npartitions
= MAXPARTITIONS64
;
453 kern_uuidgen(&lp
->d_stor_uuid
, 1);
455 ressize
= offsetof(struct disklabel64
, d_partitions
[RESPARTITIONS64
]);
456 ressize
= (ressize
+ (uint32_t)blkmask
) & ~blkmask
;
458 /* Reserve space for the stage2 boot code */
459 lp
->d_bbase
= ressize
;
460 lp
->d_pbase
= lp
->d_bbase
+ ((BOOT2SIZE64
+ blkmask
) & ~blkmask
);
462 /* Reserve space for the backup label at the slice end */
463 lp
->d_abase
= lp
->d_total_size
- ressize
;
466 * NOTE: The pbase and pstop are calculated to align to PALIGN_SIZE
467 * and adjusted with the slice offset, so the partitions are
468 * aligned relative to the start of the physical disk.
470 lp
->d_pbase
= ((doffset
+ lp
->d_pbase
+ PALIGN_MASK
) &
471 ~(uint64_t)PALIGN_MASK
) - doffset
;
472 lp
->d_pstop
= ((lp
->d_abase
- lp
->d_pbase
) &
473 ~(uint64_t)PALIGN_MASK
) + lp
->d_pbase
;
476 * All partitions are left empty unless DSO_COMPATPARTA is set
479 if (info
->d_dsflags
& DSO_COMPATPARTA
) {
480 pp
= &lp
->d_partitions
[0];
481 pp
->p_boffset
= lp
->d_pbase
;
482 pp
->p_bsize
= lp
->d_pstop
- lp
->d_pbase
;
483 /* XXX SET FS TYPE */
486 lpcrcsize
= offsetof(struct disklabel64
,
487 d_partitions
[lp
->d_npartitions
]) -
488 offsetof(struct disklabel64
, d_magic
);
489 lp
->d_crc
= crc32(&lp
->d_magic
, lpcrcsize
);
493 * Set the number of blocks at the beginning of the slice which have
494 * been reserved for label operations. This area will be write-protected
495 * when accessed via the slice.
497 * For now just protect the label area proper. Do not protect the
498 * boot area. Note partitions in 64 bit disklabels do not overlap
499 * the disklabel or boot area.
502 l64_adjust_label_reserved(struct diskslices
*ssp
, int slice
,
503 struct diskslice
*sp
)
505 struct disklabel64
*lp
= sp
->ds_label
.lab64
;
507 sp
->ds_reserved
= lp
->d_bbase
/ ssp
->dss_secsize
;
510 struct disklabel_ops disklabel64_ops
= {
511 .labelsize
= sizeof(struct disklabel64
),
512 .op_readdisklabel
= l64_readdisklabel
,
513 .op_setdisklabel
= l64_setdisklabel
,
514 .op_writedisklabel
= l64_writedisklabel
,
515 .op_clone_label
= l64_clone_label
,
516 .op_adjust_label_reserved
= l64_adjust_label_reserved
,
517 .op_getpartbounds
= l64_getpartbounds
,
518 .op_loadpartinfo
= l64_loadpartinfo
,
519 .op_getnumparts
= l64_getnumparts
,
520 .op_makevirginlabel
= l64_makevirginlabel
,
521 .op_freedisklabel
= l64_freedisklabel