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