1 /* $NetBSD: disksubr.c,v 1.32 2024/06/02 19:20:09 andvar 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 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: disksubr.c,v 1.32 2024/06/02 19:20:09 andvar Exp $"); 36 37 #include "opt_mbr.h" 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/buf.h> 42 #include <sys/disklabel.h> 43 #include <sys/disk.h> 44 #include <sys/syslog.h> 45 46 #include <sys/bswap.h> 47 48 int fat_types[] = { MBR_PTYPE_FAT12, MBR_PTYPE_FAT16S, 49 MBR_PTYPE_FAT16B, MBR_PTYPE_FAT32, 50 MBR_PTYPE_FAT32L, MBR_PTYPE_FAT16L, 51 -1 }; 52 53 #define NO_MBR_SIGNATURE ((struct mbr_partition *) -1) 54 55 #ifdef BSDDISKLABEL_EI 56 void swap_endian_disklabel(struct disklabel *, struct disklabel *); 57 uint16_t dkcksum_re(struct disklabel *); 58 #endif 59 #ifdef COMPAT_MMEYE_OLDLABEL 60 void swap_mmeye_disklabel(struct disklabel *, struct disklabel *); 61 uint16_t dkcksum_mmeye(struct disklabel *); 62 #endif 63 64 static struct mbr_partition *mbr_findslice(struct mbr_partition *, 65 struct buf *); 66 67 #ifdef BSDDISKLABEL_EI 68 void 69 swap_endian_disklabel(struct disklabel *nlp, struct disklabel *olp) 70 { 71 int i; 72 #define SW16(X) nlp->X = bswap16(olp->X) 73 #define SW32(X) nlp->X = bswap32(olp->X) 74 75 SW32(d_magic); 76 SW16(d_type); 77 SW16(d_subtype); 78 79 /* no need to swap char strings */ 80 memcpy(nlp->d_typename, olp->d_typename, sizeof(nlp->d_typename)); 81 82 /* XXX What should we do for d_un (an union of char and pointers) ? */ 83 memcpy(nlp->d_packname, olp->d_packname, sizeof(nlp->d_packname)); 84 85 SW32(d_secsize); 86 SW32(d_nsectors); 87 SW32(d_ntracks); 88 SW32(d_ncylinders); 89 SW32(d_secpercyl); 90 SW32(d_secperunit); 91 92 SW16(d_sparespertrack); 93 SW16(d_sparespercyl); 94 95 SW32(d_acylinders); 96 97 SW16(d_rpm); 98 SW16(d_interleave); 99 SW16(d_trackskew); /* sector 0 skew, per track */ 100 SW16(d_cylskew); /* sector 0 skew, per cylinder */ 101 SW32(d_headswitch); /* head switch time, usec */ 102 SW32(d_trkseek); /* track-to-track seek, usec */ 103 SW32(d_flags); /* generic flags */ 104 105 for (i = 0; i < NDDATA; i++) 106 SW32(d_drivedata[i]); /* drive-type specific information */ 107 108 for (i = 0; i < NSPARE; i++) 109 SW32(d_spare[i]); /* reserved for future use */ 110 111 SW32(d_magic2); /* the magic number (again) */ 112 SW16(d_checksum); /* xor of data incl. partitions */ 113 114 /* filesystem and partition information: */ 115 SW16(d_npartitions); /* number of partitions in following */ 116 SW32(d_bbsize); /* size of boot area at sn0, bytes */ 117 SW32(d_sbsize); /* max size of fs superblock, bytes */ 118 119 for (i = 0; i < MAXPARTITIONS; i++) { 120 SW32(d_partitions[i].p_size); 121 SW32(d_partitions[i].p_offset); 122 SW32(d_partitions[i].p_fsize); 123 /* p_fstype and p_frag is uint8_t, so no need to swap */ 124 nlp->d_partitions[i].p_fstype = olp->d_partitions[i].p_fstype; 125 nlp->d_partitions[i].p_frag = olp->d_partitions[i].p_frag; 126 SW16(d_partitions[i].p_cpg); 127 } 128 #undef SW32 129 #undef SW16 130 } 131 132 uint16_t 133 dkcksum_re(struct disklabel *lp) 134 { 135 uint16_t *start, *end; 136 uint16_t sum = 0; 137 138 start = (uint16_t *)lp; 139 end = (uint16_t *)&lp->d_partitions[bswap16(lp->d_npartitions)]; 140 while (start < end) 141 sum ^= *start++; 142 return (sum); 143 } 144 #endif 145 146 #ifdef COMPAT_MMEYE_OLDLABEL 147 void 148 swap_mmeye_disklabel(struct disklabel *nlp, struct disklabel *olp) 149 { 150 int i; 151 uint16_t *np, *op; 152 153 #if BYTE_ORDER == BIG_ENDIAN 154 #define SW16(X) nlp->X = bswap16(olp->X) 155 #define SW32(X) nlp->X = bswap32(olp->X) 156 #else 157 #define SW16(X) nlp->X = olp->X 158 #define SW32(X) nlp->X = olp->X 159 #endif 160 161 SW32(d_magic); 162 SW16(d_type); 163 SW16(d_subtype); 164 165 op = (uint16_t *)&olp->d_typename[0]; 166 np = (uint16_t *)&nlp->d_typename[0]; 167 for (i = 0; i < sizeof(olp->d_typename) / sizeof(uint16_t); i++) 168 *np++ = bswap16(*op++); 169 170 op = (uint16_t *)&olp->d_un.un_d_packname[0]; 171 np = (uint16_t *)&nlp->d_un.un_d_packname[0]; 172 for (i = 0; i < sizeof(olp->d_un) / sizeof(uint16_t); i++) 173 *np++ = bswap16(*op++); 174 175 SW32(d_secsize); 176 SW32(d_nsectors); 177 SW32(d_ntracks); 178 SW32(d_ncylinders); 179 SW32(d_secpercyl); 180 SW32(d_secperunit); 181 182 SW16(d_sparespertrack); 183 SW16(d_sparespercyl); 184 185 SW32(d_acylinders); 186 187 SW16(d_rpm); 188 SW16(d_interleave); 189 SW16(d_trackskew); /* sector 0 skew, per track */ 190 SW16(d_cylskew); /* sector 0 skew, per cylinder */ 191 SW32(d_headswitch); /* head switch time, usec */ 192 SW32(d_trkseek); /* track-to-track seek, usec */ 193 SW32(d_flags); /* generic flags */ 194 195 for (i = 0; i < NDDATA; i++) 196 SW32(d_drivedata[i]); /* drive-type specific information */ 197 198 for (i = 0; i < NSPARE; i++) 199 SW32(d_spare[i]); /* reserved for future use */ 200 201 SW32(d_magic2); /* the magic number (again) */ 202 SW16(d_checksum); /* xor of data incl. partitions */ 203 204 /* filesystem and partition information: */ 205 SW16(d_npartitions); /* number of partitions in following */ 206 SW32(d_bbsize); /* size of boot area at sn0, bytes */ 207 SW32(d_sbsize); /* max size of fs superblock, bytes */ 208 209 for (i = 0; i < MAXPARTITIONS; i++) { 210 SW32(d_partitions[i].p_size); 211 SW32(d_partitions[i].p_offset); 212 SW32(d_partitions[i].p_fsize); 213 nlp->d_partitions[i].p_fstype = olp->d_partitions[i].p_fstype; 214 nlp->d_partitions[i].p_frag = olp->d_partitions[i].p_frag; 215 SW16(d_partitions[i].p_cpg); 216 } 217 #undef SW32 218 #undef SW16 219 } 220 221 uint16_t 222 dkcksum_mmeye(struct disklabel *lp) 223 { 224 struct disklabel tdl; 225 int i, offset; 226 uint16_t *start, *end, *fstype; 227 uint16_t sum = 0; 228 229 tdl = *lp; 230 231 for (i = 0; i < MAXPARTITIONS; i++) { 232 fstype = (uint16_t *)&tdl.d_partitions[i].p_fstype; 233 *fstype = bswap16(*fstype); 234 } 235 236 offset = offsetof(struct disklabel, 237 d_partitions[le16toh(lp->d_npartitions)]); 238 start = (uint16_t *)&tdl; 239 end = start + offset; 240 241 while (start < end) 242 sum ^= *start++; 243 244 #ifdef COMPAT_MMEYE_OLDLABEL_BROKEN 245 if (sum != 0 && 246 tdl.d_checksum == 0) { 247 printf("disklabel: mmeye oldlabel broken found\n"); 248 sum = 0; /* XXXX */ 249 } 250 #endif 251 252 return (sum); 253 } 254 #endif 255 256 /* 257 * Scan MBR for NetBSD partition. Return NO_MBR_SIGNATURE if no MBR found 258 * Otherwise, copy valid MBR partition-table into dp, and if a NetBSD 259 * partition is found, return a pointer to it; else return NULL. 260 */ 261 static struct mbr_partition * 262 mbr_findslice(struct mbr_partition *dp, struct buf *bp) 263 { 264 struct mbr_partition *ourdp = NULL; 265 uint16_t *mbrmagicp; 266 int i; 267 268 /* Note: Magic number is little-endian. */ 269 mbrmagicp = (uint16_t *)((char *)bp->b_data + MBR_MAGIC_OFFSET); 270 if (le16toh(*mbrmagicp) != MBR_MAGIC) 271 return (NO_MBR_SIGNATURE); 272 273 /* XXX how do we check veracity/bounds of this? */ 274 memcpy(dp, (char *)bp->b_data + MBR_PART_OFFSET, 275 MBR_PART_COUNT * sizeof(*dp)); 276 277 /* look for NetBSD partition */ 278 for (i = 0; i < MBR_PART_COUNT; i++) { 279 if (dp[i].mbrp_type == MBR_PTYPE_NETBSD) { 280 ourdp = &dp[i]; 281 break; 282 } 283 } 284 285 return (ourdp); 286 } 287 288 289 /* 290 * Attempt to read a disk label from a device 291 * using the indicated strategy routine. 292 * The label must be partly set up before this: 293 * secpercyl, secsize and anything required for a block i/o read 294 * operation in the driver's strategy/start routines 295 * must be filled in before calling us. 296 * 297 * If dos partition table requested, attempt to load it and 298 * find disklabel inside a DOS partition. Also, if bad block 299 * table needed, attempt to extract it as well. Return buffer 300 * for use in signalling errors if requested. 301 * 302 * Returns null on success and an error string on failure. 303 */ 304 const char * 305 readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, 306 struct cpu_disklabel *osdep) 307 { 308 struct mbr_partition *dp; 309 struct partition *pp; 310 struct dkbad *bdp; 311 struct buf *bp; 312 struct disklabel *dlp; 313 const char *msg = NULL; 314 int dospartoff, cyl, i, *ip; 315 316 /* minimal requirements for archtypal disk label */ 317 if (lp->d_secsize == 0) 318 lp->d_secsize = DEV_BSIZE; 319 if (lp->d_secperunit == 0) 320 lp->d_secperunit = 0x1fffffff; 321 #if 0 322 if (lp->d_ncylinders == 16383) { 323 printf("disklabel: Disk > 8G ... readjusting chs %d/%d/%d to ", 324 lp->d_ncylinders, lp->d_ntracks, lp->d_nsectors); 325 lp->d_ncylinders = lp->d_secperunit / lp->d_ntracks / lp->d_nsectors; 326 printf("%d/%d/%d\n", 327 lp->d_ncylinders, lp->d_ntracks, lp->d_nsectors); 328 } 329 #endif 330 lp->d_npartitions = RAW_PART + 1; 331 for (i = 0; i < RAW_PART; i++) { 332 lp->d_partitions[i].p_size = 0; 333 lp->d_partitions[i].p_offset = 0; 334 } 335 if (lp->d_partitions[i].p_size == 0) 336 lp->d_partitions[i].p_size = 0x1fffffff; 337 lp->d_partitions[i].p_offset = 0; 338 339 /* get a buffer and initialize it */ 340 bp = geteblk((int)lp->d_secsize); 341 bp->b_dev = dev; 342 343 /* do dos partitions in the process of getting disklabel? */ 344 dospartoff = 0; 345 cyl = LABELSECTOR / lp->d_secpercyl; 346 if (!osdep) 347 goto nombrpart; 348 dp = osdep->mbrparts; 349 350 /* read master boot record */ 351 bp->b_blkno = MBR_BBSECTOR; 352 bp->b_bcount = lp->d_secsize; 353 bp->b_flags |= B_READ; 354 bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl; 355 (*strat)(bp); 356 357 /* if successful, wander through dos partition table */ 358 if (biowait(bp)) { 359 msg = "dos partition I/O error"; 360 goto done; 361 } else { 362 struct mbr_partition *ourdp = NULL; 363 364 ourdp = mbr_findslice(dp, bp); 365 if (ourdp == NO_MBR_SIGNATURE) 366 goto nombrpart; 367 368 for (i = 0; i < MBR_PART_COUNT; i++, dp++) { 369 /* Install in partition e, f, g, or h. */ 370 pp = &lp->d_partitions[RAW_PART + 1 + i]; 371 pp->p_offset = le32toh(dp->mbrp_start); 372 pp->p_size = le32toh(dp->mbrp_size); 373 for (ip = fat_types; *ip != -1; ip++) { 374 if (dp->mbrp_type == *ip) 375 pp->p_fstype = FS_MSDOS; 376 } 377 if (dp->mbrp_type == MBR_PTYPE_LNXEXT2) 378 pp->p_fstype = FS_EX2FS; 379 380 if (dp->mbrp_type == MBR_PTYPE_NTFS) 381 pp->p_fstype = FS_NTFS; 382 383 /* is this ours? */ 384 if (dp == ourdp) { 385 /* need sector address for SCSI/IDE, 386 cylinder for ESDI/ST506/RLL */ 387 dospartoff = le32toh(dp->mbrp_start); 388 cyl = MBR_PCYL(dp->mbrp_scyl, dp->mbrp_ssect); 389 390 /* update disklabel with details */ 391 lp->d_partitions[2].p_size = 392 le32toh(dp->mbrp_size); 393 lp->d_partitions[2].p_offset = 394 le32toh(dp->mbrp_start); 395 #if 0 396 if (lp->d_ntracks != dp->mbrp_ehd + 1 || 397 lp->d_nsectors != MBR_PSECT(dp->mbrp_esect)) { 398 printf("disklabel: BIOS sees chs %d/%d/%d as ", 399 lp->d_ncylinders, lp->d_ntracks, 400 lp->d_nsectors); 401 lp->d_ntracks = dp->mbrp_ehd + 1; 402 lp->d_nsectors = MBR_PSECT(dp->mbrp_esect); 403 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 404 lp->d_ncylinders = lp->d_secperunit / lp->d_secpercyl; 405 if (! lp->d_ncylinders) 406 lp->d_ncylinders = 1; 407 printf("%d/%d/%d\n", 408 lp->d_ncylinders, lp->d_ntracks, 409 lp->d_nsectors); 410 } 411 #endif 412 } 413 } 414 lp->d_npartitions = RAW_PART + 1 + i; 415 } 416 417 nombrpart: 418 /* next, dig out disk label */ 419 bp->b_blkno = dospartoff + LABELSECTOR; 420 bp->b_cylinder = cyl; 421 bp->b_bcount = lp->d_secsize; 422 bp->b_oflags &= ~(BO_DONE); 423 bp->b_flags |= B_READ; 424 (*strat)(bp); 425 426 /* if successful, locate disk label within block and validate */ 427 if (biowait(bp)) { 428 msg = "disk label I/O error"; 429 goto done; 430 } 431 for (dlp = (struct disklabel *)bp->b_data; 432 dlp <= (struct disklabel *)((char *)bp->b_data + lp->d_secsize - 433 sizeof(*dlp)); 434 dlp = (struct disklabel *)((char *)dlp + sizeof(long))) { 435 if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC) { 436 /* disklabel is written in host's endian */ 437 if (dlp->d_npartitions > MAXPARTITIONS || 438 dkcksum(dlp) != 0) 439 msg = "disk label corrupted"; 440 else { 441 *lp = *dlp; 442 msg = NULL; 443 break; 444 } 445 } 446 #ifdef BSDDISKLABEL_EI 447 if (bswap32(dlp->d_magic) == DISKMAGIC && 448 bswap32(dlp->d_magic2) == DISKMAGIC) { 449 /* disklabel is written in reversed endian */ 450 if (bswap16(dlp->d_npartitions) > MAXPARTITIONS || 451 dkcksum_re(dlp) != 0) 452 msg = "disk label corrupted"; 453 else { 454 swap_endian_disklabel(lp, dlp); 455 /* recalculate cksum in host's endian */ 456 lp->d_checksum = 0; 457 lp->d_checksum = dkcksum(lp); 458 459 msg = NULL; 460 break; 461 } 462 } 463 #endif 464 #ifdef COMPAT_MMEYE_OLDLABEL 465 if (le32toh(dlp->d_magic) == DISKMAGIC && 466 le32toh(dlp->d_magic2) == DISKMAGIC) { 467 if (le16toh(dlp->d_npartitions) > MAXPARTITIONS || 468 dkcksum_mmeye(dlp) != 0) 469 msg = "disk label corrupted"; 470 else { 471 /* disklabel is written in old mmeye's way */ 472 swap_mmeye_disklabel(lp, dlp); 473 /* recalculate cksum in host's endian */ 474 lp->d_checksum = 0; 475 lp->d_checksum = dkcksum(lp); 476 477 msg = NULL; 478 break; 479 } 480 } 481 #endif 482 if (msg == NULL) 483 msg = "no disk label"; 484 } 485 486 if (msg) 487 goto done; 488 489 /* obtain bad sector table if requested and present */ 490 if (osdep && (lp->d_flags & D_BADSECT)) { 491 struct dkbad *db; 492 493 bdp = &osdep->bad; 494 i = 0; 495 do { 496 /* read a bad sector table */ 497 bp->b_oflags &= ~(BO_DONE); 498 bp->b_flags |= B_READ; 499 bp->b_blkno = lp->d_secperunit - lp->d_nsectors + i; 500 if (lp->d_secsize > DEV_BSIZE) 501 bp->b_blkno *= lp->d_secsize / DEV_BSIZE; 502 else 503 bp->b_blkno /= DEV_BSIZE / lp->d_secsize; 504 bp->b_bcount = lp->d_secsize; 505 bp->b_cylinder = lp->d_ncylinders - 1; 506 (*strat)(bp); 507 508 /* if successful, validate, otherwise try another */ 509 if (biowait(bp)) { 510 msg = "bad sector table I/O error"; 511 } else { 512 db = (struct dkbad *)(bp->b_data); 513 #define DKBAD_MAGIC 0x4321 514 if (db->bt_mbz == 0 515 && db->bt_flag == DKBAD_MAGIC) { 516 msg = NULL; 517 *bdp = *db; 518 break; 519 } else 520 msg = "bad sector table corrupted"; 521 } 522 } while (bp->b_error != 0 && (i += 2) < 10 && 523 i < lp->d_nsectors); 524 } 525 526 done: 527 brelse(bp, 0); 528 return (msg); 529 } 530 531 /* 532 * Write disk label back to device after modification. 533 */ 534 int 535 writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, 536 struct cpu_disklabel *osdep) 537 { 538 struct mbr_partition *dp; 539 struct buf *bp; 540 struct disklabel *dlp; 541 int error, dospartoff, cyl; 542 543 /* get a buffer and initialize it */ 544 bp = geteblk((int)lp->d_secsize); 545 bp->b_dev = dev; 546 547 /* do dos partitions in the process of getting disklabel? */ 548 dospartoff = 0; 549 cyl = LABELSECTOR / lp->d_secpercyl; 550 if (!osdep) 551 goto nombrpart; 552 dp = osdep->mbrparts; 553 554 /* read master boot record */ 555 bp->b_blkno = MBR_BBSECTOR; 556 bp->b_bcount = lp->d_secsize; 557 bp->b_flags |= B_READ; 558 bp->b_cylinder = MBR_BBSECTOR / lp->d_secpercyl; 559 (*strat)(bp); 560 561 if ((error = biowait(bp)) == 0) { 562 struct mbr_partition *ourdp = NULL; 563 564 ourdp = mbr_findslice(dp, bp); 565 if (ourdp == NO_MBR_SIGNATURE) 566 goto nombrpart; 567 568 if (ourdp) { 569 /* need sector address for SCSI/IDE, 570 cylinder for ESDI/ST506/RLL */ 571 dospartoff = le32toh(ourdp->mbrp_start); 572 cyl = MBR_PCYL(ourdp->mbrp_scyl, ourdp->mbrp_ssect); 573 } 574 } 575 576 nombrpart: 577 #ifdef maybe 578 /* disklabel in appropriate location? */ 579 if (lp->d_partitions[2].p_offset != 0 580 && lp->d_partitions[2].p_offset != dospartoff) { 581 error = EXDEV; 582 goto done; 583 } 584 #endif 585 586 /* next, dig out disk label */ 587 bp->b_blkno = dospartoff + LABELSECTOR; 588 bp->b_cylinder = cyl; 589 bp->b_bcount = lp->d_secsize; 590 bp->b_oflags &= ~(BO_DONE); 591 bp->b_flags |= B_READ; 592 (*strat)(bp); 593 594 /* if successful, locate disk label within block and validate */ 595 if ((error = biowait(bp)) != 0) 596 goto done; 597 for (dlp = (struct disklabel *)bp->b_data; 598 dlp <= (struct disklabel *)((char *)bp->b_data + lp->d_secsize - 599 sizeof(*dlp)); 600 dlp = (struct disklabel *)((char *)dlp + sizeof(long))) { 601 if (dlp->d_magic == DISKMAGIC && dlp->d_magic2 == DISKMAGIC && 602 dlp->d_npartitions <= MAXPARTITIONS && 603 dkcksum(dlp) == 0) { 604 /* found disklabel in host's endian */ 605 *dlp = *lp; 606 goto found; 607 #ifdef BSDDISKLABEL_EI 608 } else if (bswap32(dlp->d_magic) == DISKMAGIC && 609 bswap32(dlp->d_magic2) == DISKMAGIC && 610 bswap16(dlp->d_npartitions) <= MAXPARTITIONS && 611 dkcksum_re(dlp) == 0) { 612 /* found disklabel in the opposite endian */ 613 swap_endian_disklabel(dlp, lp); 614 /* recalculate cksum in reversed endian */ 615 dlp->d_checksum = 0; 616 dlp->d_checksum = dkcksum_re(dlp); 617 goto found; 618 #endif 619 #ifdef COMPAT_MMEYE_OLDLABEL 620 } else if (le32toh(dlp->d_magic) == DISKMAGIC && 621 le32toh(dlp->d_magic2) == DISKMAGIC && 622 le16toh(dlp->d_npartitions) <= MAXPARTITIONS && 623 dkcksum_mmeye(dlp) == 0) { 624 /* found disklabel by old mmeye's rule */ 625 swap_mmeye_disklabel(dlp, lp); 626 /* recalculate cksum for it */ 627 dlp->d_checksum = 0; 628 dlp->d_checksum = dkcksum_mmeye(dlp); 629 goto found; 630 #endif 631 } 632 } 633 /* No valid disklabel found on disk */ 634 error = ESRCH; 635 goto done; 636 637 found: 638 bp->b_oflags &= ~(BO_DONE); 639 bp->b_flags &= ~(B_READ); 640 bp->b_flags |= B_WRITE; 641 (*strat)(bp); 642 error = biowait(bp); 643 644 done: 645 brelse(bp, 0); 646 return (error); 647 } 648
Indexes created Sun Sep 28 16:09:52 GMT 2025