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-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
SearchContext: - none - 3 - 10
1 /* $NetBSD: subr_disk_mbr.c,v 1.22 2006/11/25 11:59:58 scw 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.22 2006/11/25 11:59:58 scw 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 typedef struct mbr_partition mbr_partition_t; 69 70 /* 71 * We allocate a buffer 2 sectors large, and look in both.... 72 * That means we find labels written by other ports with different offsets. 73 * LABELSECTOR and LABELOFFSET are only used if the disk doesn't have a label. 74 */ 75 #if LABELSECTOR > 1 || LABELOFFSET > 512 76 #error Invalid LABELSECTOR or LABELOFFSET 77 #endif 78 79 #define MBR_LABELSECTOR 1 80 81 #define SCAN_CONTINUE 0 82 #define SCAN_FOUND 1 83 #define SCAN_ERROR 2 84 85 typedef struct mbr_args { 86 struct disklabel *lp; 87 void (*strat)(struct buf *); 88 struct buf *bp; 89 const char *msg; 90 int error; 91 int written; /* number of times we wrote label */ 92 int found_mbr; /* set if disk has a valid mbr */ 93 uint label_sector; /* where we found the label */ 94 int action; 95 #define READ_LABEL 1 96 #define UPDATE_LABEL 2 97 #define WRITE_LABEL 3 98 } mbr_args_t; 99 100 static int validate_label(mbr_args_t *, uint); 101 static int look_netbsd_part(mbr_args_t *, mbr_partition_t *, int, uint); 102 static int write_netbsd_label(mbr_args_t *, mbr_partition_t *, int, uint); 103 104 static int 105 read_sector(mbr_args_t *a, uint sector, int count) 106 { 107 struct buf *bp = a->bp; 108 int error; 109 110 if (a->lp->d_secpercyl == 0) 111 return EINVAL; 112 113 bp->b_blkno = sector; 114 bp->b_bcount = count * a->lp->d_secsize; 115 bp->b_flags = (bp->b_flags & ~(B_WRITE | B_DONE)) | B_READ; 116 bp->b_cylinder = sector / a->lp->d_secpercyl; 117 (*a->strat)(bp); 118 error = biowait(bp); 119 if (error != 0) 120 a->error = error; 121 return error; 122 } 123 124 /* 125 * Scan MBR for partitions, call 'action' routine for each. 126 */ 127 128 static int 129 scan_mbr(mbr_args_t *a, int (*actn)(mbr_args_t *, mbr_partition_t *, int, uint)) 130 { 131 mbr_partition_t ptns[MBR_PART_COUNT]; 132 mbr_partition_t *dp; 133 struct mbr_sector *mbr; 134 uint ext_base, this_ext, next_ext; 135 int rval; 136 int i; 137 int j; 138 #ifdef COMPAT_386BSD_MBRPART 139 int dp_386bsd = -1; 140 int ap_386bsd = -1; 141 #endif 142 143 ext_base = 0; 144 this_ext = 0; 145 for (;;) { 146 if (read_sector(a, this_ext, 1)) { 147 a->msg = "dos partition I/O error"; 148 return SCAN_ERROR; 149 } 150 151 /* Note: Magic number is little-endian. */ 152 mbr = (void *)a->bp->b_data; 153 if (mbr->mbr_magic != htole16(MBR_MAGIC)) 154 return SCAN_CONTINUE; 155 156 /* Copy data out of buffer so action can use bp */ 157 memcpy(ptns, &mbr->mbr_parts, sizeof ptns); 158 159 /* Look for drivers and skip them */ 160 if (ext_base == 0 && ptns[0].mbrp_type == MBR_PTYPE_DM6_DDO) { 161 /* We've found a DM6 DDO partition type (used by 162 * the Ontrack Disk Manager drivers). 163 * 164 * Ensure that there are no other partitions in the 165 * MBR and jump to the real partition table (stored 166 * in the first sector of the second track). */ 167 boolean_t ok = TRUE; 168 169 for (i = 1; i < MBR_PART_COUNT; i++) 170 if (ptns[i].mbrp_type != MBR_PTYPE_UNUSED) 171 ok = FALSE; 172 173 if (ok) { 174 this_ext = le32toh(a->lp->d_secpercyl / 175 a->lp->d_ntracks); 176 continue; 177 } 178 } 179 180 /* look for NetBSD partition */ 181 next_ext = 0; 182 dp = ptns; 183 j = 0; 184 for (i = 0; i < MBR_PART_COUNT; i++, dp++) { 185 if (dp->mbrp_type == MBR_PTYPE_UNUSED) 186 continue; 187 /* Check end of partition is inside disk limits */ 188 if ((uint64_t)ext_base + le32toh(dp->mbrp_start) + 189 le32toh(dp->mbrp_size) > a->lp->d_secperunit) { 190 /* This mbr doesn't look good.... */ 191 a->msg = "mbr partition exceeds disk size"; 192 /* ...but don't report this as an error (yet) */ 193 return SCAN_CONTINUE; 194 } 195 a->found_mbr = 1; 196 if (MBR_IS_EXTENDED(dp->mbrp_type)) { 197 next_ext = le32toh(dp->mbrp_start); 198 continue; 199 } 200 #ifdef COMPAT_386BSD_MBRPART 201 if (dp->mbrp_type == MBR_PTYPE_386BSD) { 202 /* 203 * If more than one matches, take last, 204 * as NetBSD install tool does. 205 */ 206 if (this_ext == 0) { 207 dp_386bsd = i; 208 ap_386bsd = j; 209 } 210 continue; 211 } 212 #endif 213 rval = (*actn)(a, dp, j, this_ext); 214 if (rval != SCAN_CONTINUE) 215 return rval; 216 j++; 217 } 218 if (next_ext == 0) 219 break; 220 if (ext_base == 0) { 221 ext_base = next_ext; 222 next_ext = 0; 223 } 224 next_ext += ext_base; 225 if (next_ext <= this_ext) 226 break; 227 this_ext = next_ext; 228 } 229 #ifdef COMPAT_386BSD_MBRPART 230 if (this_ext == 0 && dp_386bsd != -1) 231 return (*actn)(a, &ptns[dp_386bsd], ap_386bsd, 0); 232 #endif 233 return SCAN_CONTINUE; 234 } 235 236 /* 237 * Attempt to read a disk label from a device 238 * using the indicated strategy routine. 239 * The label must be partly set up before this: 240 * secpercyl, secsize and anything required for a block i/o read 241 * operation in the driver's strategy/start routines 242 * must be filled in before calling us. 243 * 244 * If dos partition table requested, attempt to load it and 245 * find disklabel inside a DOS partition. Also, if bad block 246 * table needed, attempt to extract it as well. Return buffer 247 * for use in signalling errors if requested. 248 * 249 * Returns null on success and an error string on failure. 250 */ 251 const char * 252 readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, 253 struct cpu_disklabel *osdep) 254 { 255 struct dkbad *bdp; 256 int rval; 257 int i; 258 mbr_args_t a; 259 260 memset(&a, 0, sizeof a); 261 a.lp = lp; 262 a.strat = strat; 263 a.action = READ_LABEL; 264 265 /* minimal requirements for architypal disk label */ 266 if (lp->d_secsize == 0) 267 lp->d_secsize = DEV_BSIZE; 268 if (lp->d_secperunit == 0) 269 lp->d_secperunit = 0x1fffffff; 270 lp->d_npartitions = RAW_PART + 1; 271 for (i = 0; i < RAW_PART; i++) { 272 lp->d_partitions[i].p_size = 0; 273 lp->d_partitions[i].p_offset = 0; 274 } 275 if (lp->d_partitions[RAW_PART].p_size == 0) 276 lp->d_partitions[RAW_PART].p_size = lp->d_secperunit; 277 lp->d_partitions[RAW_PART].p_offset = 0; 278 279 /* 280 * Set partition 'a' to be the whole disk. 281 * Cleared if we find an mbr or a netbsd label. 282 */ 283 lp->d_partitions[0].p_size = lp->d_partitions[RAW_PART].p_size; 284 lp->d_partitions[0].p_fstype = FS_BSDFFS; 285 286 /* get a buffer and initialize it */ 287 a.bp = geteblk(2 * (int)lp->d_secsize); 288 a.bp->b_dev = dev; 289 290 if (osdep) 291 /* 292 * Scan mbr searching for netbsd partition and saving 293 * bios partition information to use if the netbsd one 294 * is absent. 295 */ 296 rval = scan_mbr(&a, look_netbsd_part); 297 else 298 rval = SCAN_CONTINUE; 299 300 if (rval == SCAN_CONTINUE) { 301 /* Look at start of disk */ 302 rval = validate_label(&a, 0); 303 } 304 305 #if 0 306 /* 307 * Save sector where we found the label for the 'don't overwrite 308 * the label' check in bounds_check_with_label. 309 */ 310 if (rval == SCAN_FOUND) 311 xxx->label_sector = a.label_sector; 312 #endif 313 314 /* Obtain bad sector table if requested and present */ 315 if (rval == SCAN_FOUND && osdep && (lp->d_flags & D_BADSECT)) { 316 struct dkbad *db; 317 int blkno; 318 319 bdp = &osdep->bad; 320 i = 0; 321 rval = SCAN_ERROR; 322 do { 323 /* read a bad sector table */ 324 blkno = lp->d_secperunit - lp->d_nsectors + i; 325 if (lp->d_secsize > DEV_BSIZE) 326 blkno *= lp->d_secsize / DEV_BSIZE; 327 else 328 blkno /= DEV_BSIZE / lp->d_secsize; 329 /* if successful, validate, otherwise try another */ 330 if (read_sector(&a, blkno, 1)) { 331 a.msg = "bad sector table I/O error"; 332 continue; 333 } 334 db = (struct dkbad *)(a.bp->b_data); 335 #define DKBAD_MAGIC 0x4321 336 if (db->bt_mbz != 0 || db->bt_flag != DKBAD_MAGIC) { 337 a.msg = "bad sector table corrupted"; 338 continue; 339 } 340 rval = SCAN_FOUND; 341 *bdp = *db; 342 break; 343 } while ((a.bp->b_flags & B_ERROR) && (i += 2) < 10 && 344 i < lp->d_nsectors); 345 } 346 347 brelse(a.bp); 348 if (rval == SCAN_ERROR || rval == SCAN_CONTINUE) 349 return a.msg; 350 return NULL; 351 } 352 353 static int 354 look_netbsd_part(mbr_args_t *a, mbr_partition_t *dp, int slot, uint ext_base) 355 { 356 struct partition *pp; 357 int ptn_base = ext_base + le32toh(dp->mbrp_start); 358 int rval; 359 360 if ( 361 #ifdef COMPAT_386BSD_MBRPART 362 dp->mbrp_type == MBR_PTYPE_386BSD || 363 #endif 364 dp->mbrp_type == MBR_PTYPE_NETBSD) { 365 rval = validate_label(a, ptn_base); 366 367 #if RAW_PART == 3 368 /* Put actual location where we found the label into ptn 2 */ 369 if (rval == SCAN_FOUND || a->lp->d_partitions[2].p_size == 0) { 370 a->lp->d_partitions[2].p_size = le32toh(dp->mbrp_size); 371 a->lp->d_partitions[2].p_offset = ptn_base; 372 } 373 #endif 374 375 /* If we got a netbsd label look no further */ 376 if (rval == SCAN_FOUND) 377 return rval; 378 } 379 380 /* Install main partitions into e..h and extended into i+ */ 381 if (ext_base == 0) 382 slot += 4; 383 else { 384 slot = 4 + MBR_PART_COUNT; 385 pp = &a->lp->d_partitions[slot]; 386 for (; slot < MAXPARTITIONS; pp++, slot++) { 387 /* This gets called twice - avoid duplicates */ 388 if (pp->p_offset == ptn_base && 389 pp->p_size == le32toh(dp->mbrp_size)) 390 break; 391 if (pp->p_size == 0) 392 break; 393 } 394 } 395 396 if (slot < MAXPARTITIONS) { 397 /* Stop 'a' being the entire disk */ 398 a->lp->d_partitions[0].p_size = 0; 399 a->lp->d_partitions[0].p_fstype = 0; 400 401 /* save partition info */ 402 pp = &a->lp->d_partitions[slot]; 403 pp->p_offset = ptn_base; 404 pp->p_size = le32toh(dp->mbrp_size); 405 pp->p_fstype = xlat_mbr_fstype(dp->mbrp_type); 406 407 if (slot >= a->lp->d_npartitions) 408 a->lp->d_npartitions = slot + 1; 409 } 410 411 return SCAN_CONTINUE; 412 } 413 414 415 static int 416 validate_label(mbr_args_t *a, uint label_sector) 417 { 418 struct disklabel *dlp; 419 char *dlp_lim, *dlp_byte; 420 int error; 421 422 /* Next, dig out disk label */ 423 if (read_sector(a, label_sector, 2)) { 424 a->msg = "disk label read failed"; 425 return SCAN_ERROR; 426 } 427 428 /* Locate disk label within block and validate */ 429 /* 430 * XXX (dsl) This search may be a waste of time, a lot of other i386 431 * code assumes the label is at offset LABELOFFSET (=0) in the sector. 432 * 433 * If we want to support disks from other netbsd ports, then the 434 * code should also allow for a shorter label nearer the end of 435 * the disk sector, and (IIRC) labels within 8k of the disk start. 436 */ 437 dlp = (void *)a->bp->b_data; 438 dlp_lim = a->bp->b_data + a->bp->b_bcount - sizeof *dlp; 439 for (;; dlp = (void *)((char *)dlp + sizeof(long))) { 440 if ((char *)dlp > dlp_lim) { 441 if (a->action != WRITE_LABEL) 442 return SCAN_CONTINUE; 443 /* Write at arch. dependant default location */ 444 dlp_byte = a->bp->b_data + LABELOFFSET; 445 if (label_sector) 446 dlp_byte += MBR_LABELSECTOR * a->lp->d_secsize; 447 else 448 dlp_byte += LABELSECTOR * a->lp->d_secsize; 449 dlp = (void *)dlp_byte; 450 break; 451 } 452 if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) 453 continue; 454 if (dlp->d_npartitions > MAXPARTITIONS || dkcksum(dlp) != 0) { 455 a->msg = "disk label corrupted"; 456 continue; 457 } 458 break; 459 } 460 461 switch (a->action) { 462 case READ_LABEL: 463 *a->lp = *dlp; 464 a->label_sector = label_sector; 465 return SCAN_FOUND; 466 case UPDATE_LABEL: 467 case WRITE_LABEL: 468 *dlp = *a->lp; 469 a->bp->b_flags &= ~(B_READ|B_DONE); 470 a->bp->b_flags |= B_WRITE; 471 (*a->strat)(a->bp); 472 error = biowait(a->bp); 473 if (error != 0) { 474 a->error = error; 475 a->msg = "disk label write failed"; 476 return SCAN_ERROR; 477 } 478 a->written++; 479 /* Write label to all mbr partitions */ 480 return SCAN_CONTINUE; 481 default: 482 return SCAN_ERROR; 483 } 484 } 485 486 /* 487 * Check new disk label for sensibility 488 * before setting it. 489 */ 490 int 491 setdisklabel(struct disklabel *olp, struct disklabel *nlp, u_long openmask, 492 struct cpu_disklabel *osdep) 493 { 494 int i; 495 struct partition *opp, *npp; 496 497 /* sanity clause */ 498 if (nlp->d_secpercyl == 0 || nlp->d_secsize == 0 499 || (nlp->d_secsize % DEV_BSIZE) != 0) 500 return (EINVAL); 501 502 /* special case to allow disklabel to be invalidated */ 503 if (nlp->d_magic == 0xffffffff) { 504 *olp = *nlp; 505 return (0); 506 } 507 508 if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC || 509 dkcksum(nlp) != 0) 510 return (EINVAL); 511 512 /* XXX missing check if other dos partitions will be overwritten */ 513 514 while (openmask != 0) { 515 i = ffs(openmask) - 1; 516 openmask &= ~(1 << i); 517 if (i > nlp->d_npartitions) 518 return (EBUSY); 519 opp = &olp->d_partitions[i]; 520 npp = &nlp->d_partitions[i]; 521 /* 522 * Copy internally-set partition information 523 * if new label doesn't include it. XXX 524 */ 525 if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) { 526 *npp = *opp; 527 continue; 528 } 529 if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size) 530 return (EBUSY); 531 } 532 nlp->d_checksum = 0; 533 nlp->d_checksum = dkcksum(nlp); 534 *olp = *nlp; 535 return (0); 536 } 537 538 539 /* 540 * Write disk label back to device after modification. 541 */ 542 int 543 writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, 544 struct cpu_disklabel *osdep) 545 { 546 mbr_args_t a; 547 548 memset(&a, 0, sizeof a); 549 a.lp = lp; 550 a.strat = strat; 551 552 /* get a buffer and initialize it */ 553 a.bp = geteblk(2 * (int)lp->d_secsize); 554 a.bp->b_dev = dev; 555 556 /* osdep => we expect an mbr with label in netbsd ptn */ 557 a.action = osdep != NULL ? WRITE_LABEL : UPDATE_LABEL; 558 559 /* Write/update the label to every netbsd mbr partition */ 560 scan_mbr(&a, write_netbsd_label); 561 562 /* Old write the label at the start of the volume on disks that 563 * don't have a valid mbr (always update an existing one) */ 564 a.action = a.found_mbr ? UPDATE_LABEL : WRITE_LABEL; 565 validate_label(&a, 0); 566 567 if (a.written == 0 && a.error == 0) 568 a.error = ESRCH; 569 570 brelse(a.bp); 571 return a.error; 572 } 573 574 static int 575 write_netbsd_label(mbr_args_t *a, mbr_partition_t *dp, int slot, uint ext_base) 576 { 577 int ptn_base = ext_base + le32toh(dp->mbrp_start); 578 579 if (dp->mbrp_type != MBR_PTYPE_NETBSD) 580 return SCAN_CONTINUE; 581 582 return validate_label(a, ptn_base); 583 }
Cache object: 11780520c3f03eb507d03da76c410d89
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]