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
|