dkwedge_bsdlabel.c revision 1.11
1 /* $NetBSD: dkwedge_bsdlabel.c,v 1.11 2007/03/01 21:38:17 martin Exp $ */ 2 3 /*- 4 * Copyright (c) 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Adapted from kern/subr_disk_mbr.c: 41 * 42 * Copyright (c) 1982, 1986, 1988 Regents of the University of California. 43 * All rights reserved. 44 * 45 * Redistribution and use in source and binary forms, with or without 46 * modification, are permitted provided that the following conditions 47 * are met: 48 * 1. Redistributions of source code must retain the above copyright 49 * notice, this list of conditions and the following disclaimer. 50 * 2. Redistributions in binary form must reproduce the above copyright 51 * notice, this list of conditions and the following disclaimer in the 52 * documentation and/or other materials provided with the distribution. 53 * 3. Neither the name of the University nor the names of its contributors 54 * may be used to endorse or promote products derived from this software 55 * without specific prior written permission. 56 * 57 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 58 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 59 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 60 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 61 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 62 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 63 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 64 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 65 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 66 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 67 * SUCH DAMAGE. 68 * 69 * @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91 70 */ 71 72 /* 73 * 4.4BSD disklabel support for disk wedges 74 * 75 * Here is the basic search algorithm in use here: 76 * 77 * For historical reasons, we scan for x86-style MBR partitions looking 78 * for a MBR_PTYPE_NETBSD (or MBR_PTYPE_386BSD) partition. The first 79 * 4.4BSD disklabel found in the 2nd sector of such a partition is used. 80 * We assume that the 4.4BSD disklabel describes all partitions on the 81 * disk; we do not use any partition information from the MBR partition 82 * table. 83 * 84 * If that fails, then we fall back on a table of known locations for 85 * various platforms. 86 */ 87 88 #include <sys/cdefs.h> 89 __KERNEL_RCSID(0, "$NetBSD: dkwedge_bsdlabel.c,v 1.11 2007/03/01 21:38:17 martin Exp $"); 90 91 #include <sys/param.h> 92 #ifdef _KERNEL 93 #include <sys/systm.h> 94 #endif 95 #include <sys/proc.h> 96 #include <sys/errno.h> 97 #include <sys/disk.h> 98 #include <sys/vnode.h> 99 #include <sys/malloc.h> 100 101 #include <sys/bootblock.h> 102 #include <sys/disklabel.h> 103 104 #define BSD44_MBR_LABELSECTOR 1 105 106 #define DISKLABEL_SIZE(x) \ 107 (offsetof(struct disklabel, d_partitions) + \ 108 (sizeof(struct partition) * (x))) 109 110 /* 111 * Note the smallest MAXPARTITIONS was 8, so we allow a disklabel 112 * that size to be locted at the end of the sector. 113 */ 114 #define DISKLABEL_MINSIZE DISKLABEL_SIZE(8) 115 116 /* 117 * Table of known platform-specific disklabel locations. 118 */ 119 static const struct disklabel_location { 120 daddr_t label_sector; /* sector containing label */ 121 size_t label_offset; /* byte offset of label in sector */ 122 } disklabel_locations[] = { 123 { 0, 0 }, /* mvme68k, next68k */ 124 { 0, 64 }, /* algor, alpha, amiga, amigappc, evbmips, evbppc, 125 luna68k, mac68k, macppc, news68k, newsmips, 126 pc532, pdp11, pmax, vax, x68k */ 127 { 0, 128 }, /* sparc, sun68k */ 128 { 1, 0 }, /* amd64, arc, arm, bebox, cobalt, evbppc, hp700, 129 hpcarm, hpcmips, i386, ibmnws, mipsco, mvmeppc, 130 ofppc, playstation2, pmppc, prep, sandpoint, 131 sbmips, sgimips, sh3, sh5 */ 132 /* XXX atari is weird */ 133 { 2, 0 }, /* cesfic, hp300 */ 134 135 { -1, 0 }, 136 }; 137 138 #define SCAN_CONTINUE 0 139 #define SCAN_FOUND 1 140 #define SCAN_ERROR 2 141 142 typedef struct mbr_args { 143 struct disk *pdk; 144 struct vnode *vp; 145 void *buf; 146 int error; 147 } mbr_args_t; 148 149 static const char * 150 bsdlabel_fstype_to_str(uint8_t fstype) 151 { 152 const char *str; 153 154 switch (fstype) { 155 case FS_UNUSED: str = DKW_PTYPE_UNUSED; break; 156 case FS_SWAP: str = DKW_PTYPE_SWAP; break; 157 case FS_BSDFFS: str = DKW_PTYPE_FFS; break; 158 case FS_MSDOS: str = DKW_PTYPE_FAT; break; 159 case FS_BSDLFS: str = DKW_PTYPE_LFS; break; 160 case FS_ISO9660: str = DKW_PTYPE_ISO9660; break; 161 case FS_ADOS: str = DKW_PTYPE_AMIGADOS; break; 162 case FS_HFS: str = DKW_PTYPE_APPLEHFS; break; 163 case FS_FILECORE: str = DKW_PTYPE_FILECORE; break; 164 case FS_EX2FS: str = DKW_PTYPE_EXT2FS; break; 165 case FS_NTFS: str = DKW_PTYPE_NTFS; break; 166 case FS_RAID: str = DKW_PTYPE_RAIDFRAME; break; 167 case FS_CCD: str = DKW_PTYPE_CCD; break; 168 case FS_APPLEUFS: str = DKW_PTYPE_APPLEUFS; break; 169 default: str = NULL; break; 170 } 171 172 return (str); 173 } 174 175 static void 176 swap_disklabel(struct disklabel *lp) 177 { 178 int i; 179 180 #define SWAP16(x) lp->x = bswap16(lp->x) 181 #define SWAP32(x) lp->x = bswap32(lp->x) 182 183 SWAP32(d_magic); 184 SWAP16(d_type); 185 SWAP16(d_subtype); 186 SWAP32(d_secsize); 187 SWAP32(d_nsectors); 188 SWAP32(d_ntracks); 189 SWAP32(d_ncylinders); 190 SWAP32(d_secpercyl); 191 SWAP32(d_secperunit); 192 SWAP16(d_sparespertrack); 193 SWAP16(d_sparespercyl); 194 SWAP32(d_acylinders); 195 SWAP16(d_rpm); 196 SWAP16(d_interleave); 197 SWAP16(d_trackskew); 198 SWAP16(d_cylskew); 199 SWAP32(d_headswitch); 200 SWAP32(d_trkseek); 201 SWAP32(d_flags); 202 203 for (i = 0; i < NDDATA; i++) 204 SWAP32(d_drivedata[i]); 205 for (i = 0; i < NSPARE; i++) 206 SWAP32(d_spare[i]); 207 208 SWAP32(d_magic2); 209 SWAP16(d_checksum); 210 SWAP16(d_npartitions); 211 SWAP32(d_bbsize); 212 SWAP32(d_sbsize); 213 214 for (i = 0; i < lp->d_npartitions; i++) { 215 SWAP32(d_partitions[i].p_size); 216 SWAP32(d_partitions[i].p_offset); 217 SWAP32(d_partitions[i].p_fsize); 218 SWAP16(d_partitions[i].p_cpg); 219 } 220 221 #undef SWAP16 222 #undef SWAP32 223 } 224 225 static int 226 validate_label(mbr_args_t *a, daddr_t label_sector, size_t label_offset) 227 { 228 struct disklabel *lp; 229 caddr_t lp_lim; 230 int i, error; 231 u_int checksum; 232 233 error = dkwedge_read(a->pdk, a->vp, label_sector, a->buf, DEV_BSIZE); 234 if (error) { 235 aprint_error("%s: unable to read BSD disklabel @ %" PRId64 236 ", error = %d\n", a->pdk->dk_name, label_sector, error); 237 a->error = error; 238 return (SCAN_ERROR); 239 } 240 241 /* 242 * We ignore label_offset; this seems to have not been used 243 * consistently in the old code, requiring us to do the search 244 * in the sector. 245 */ 246 lp = a->buf; 247 lp_lim = (caddr_t)a->buf + DEV_BSIZE - DISKLABEL_MINSIZE; 248 for (;; lp = (void *)((caddr_t)lp + sizeof(uint32_t))) { 249 if ((caddr_t)lp > lp_lim) 250 return (SCAN_CONTINUE); 251 label_offset = (size_t)((caddr_t)lp - (caddr_t)a->buf); 252 if (lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC) { 253 if (lp->d_magic == bswap32(DISKMAGIC) && 254 lp->d_magic2 == bswap32(DISKMAGIC)) { 255 /* 256 * Label is in the other byte order; validate 257 * its length, then byte-swap it. 258 */ 259 if ((caddr_t)lp + 260 DISKLABEL_SIZE(bswap16(lp->d_npartitions)) > 261 (caddr_t)a->buf + DEV_BSIZE) { 262 aprint_error("%s: BSD disklabel @ " 263 "%" PRId64 264 "+%zd has bogus partition " 265 "count (%u)\n", a->pdk->dk_name, 266 label_sector, label_offset, 267 bswap16(lp->d_npartitions)); 268 continue; 269 } 270 checksum = dkcksum_sized(lp, 271 bswap16(lp->d_npartitions)); 272 swap_disklabel(lp); 273 } else 274 continue; 275 } else { 276 /* 277 * Validate the disklabel length. 278 */ 279 if ((caddr_t)lp + DISKLABEL_SIZE(lp->d_npartitions) > 280 (caddr_t)a->buf + DEV_BSIZE) { 281 aprint_error("%s: BSD disklabel @ %" PRId64 282 "+%zd has bogus partition count (%u)\n", 283 a->pdk->dk_name, label_sector, 284 label_offset, lp->d_npartitions); 285 continue; 286 } 287 checksum = dkcksum(lp); 288 } 289 290 /* 291 * Disklabel is now in the right order and we have validated 292 * the partition count, checksum it as the final check. 293 */ 294 if (checksum != 0) { 295 aprint_error("%s: BSD disklabel @ %" PRId64 296 "+%zd has bad checksum\n", a->pdk->dk_name, 297 label_sector, label_offset); 298 continue; 299 } 300 301 /* 302 * Ok, we have a valid NetBSD disklabel, add wedges for it. 303 */ 304 for (i = 0; i < lp->d_npartitions; i++) { 305 struct dkwedge_info dkw; 306 struct partition *p; 307 const char *ptype; 308 309 p = &lp->d_partitions[i]; 310 311 if (p->p_fstype == FS_UNUSED) 312 continue; 313 if ((ptype = 314 bsdlabel_fstype_to_str(p->p_fstype)) == NULL) { 315 /* 316 * XXX Should probably just add these... 317 * XXX maybe just have an empty ptype? 318 */ 319 aprint_verbose("%s: skipping partition %d, " 320 "type %d\n", a->pdk->dk_name, i, 321 p->p_fstype); 322 continue; 323 } 324 strcpy(dkw.dkw_ptype, ptype); 325 326 strcpy(dkw.dkw_parent, a->pdk->dk_name); 327 dkw.dkw_offset = p->p_offset; 328 dkw.dkw_size = p->p_size; 329 330 /* 331 * These get historical disk naming style 332 * wedge names. 333 */ 334 snprintf((char *)&dkw.dkw_wname, sizeof(dkw.dkw_wname), 335 "%s%c", a->pdk->dk_name, 'a' + i); 336 337 error = dkwedge_add(&dkw); 338 if (error == EEXIST) 339 aprint_error("%s: wedge named '%s' already " 340 "exists, manual intervention required\n", 341 a->pdk->dk_name, dkw.dkw_wname); 342 else if (error) 343 aprint_error("%s: error %d adding partition " 344 "%d type %d\n", a->pdk->dk_name, error, 345 i, p->p_fstype); 346 } 347 return (SCAN_FOUND); 348 } 349 } 350 351 static int 352 scan_mbr(mbr_args_t *a, int (*actn)(mbr_args_t *, struct mbr_partition *, 353 int, u_int)) 354 { 355 struct mbr_partition ptns[MBR_PART_COUNT]; 356 struct mbr_partition *dp; 357 struct mbr_sector *mbr; 358 u_int ext_base, this_ext, next_ext; 359 int i, rval; 360 #ifdef COMPAT_386BSD_MBRPART 361 int dp_386bsd = -1; 362 #endif 363 364 ext_base = 0; 365 this_ext = 0; 366 for (;;) { 367 a->error = dkwedge_read(a->pdk, a->vp, this_ext, a->buf, 368 DEV_BSIZE); 369 if (a->error) { 370 aprint_error("%s: unable to read MBR @ %u, " 371 "error = %d\n", a->pdk->dk_name, this_ext, 372 a->error); 373 return (SCAN_ERROR); 374 } 375 376 mbr = a->buf; 377 if (mbr->mbr_magic != htole16(MBR_MAGIC)) 378 return (SCAN_CONTINUE); 379 380 /* Copy data out of buffer so action can use the buffer. */ 381 memcpy(ptns, &mbr->mbr_parts, sizeof(ptns)); 382 383 /* Looks for NetBSD partition. */ 384 next_ext = 0; 385 dp = ptns; 386 for (i = 0; i < MBR_PART_COUNT; i++, dp++) { 387 if (dp->mbrp_type == 0) 388 continue; 389 if (MBR_IS_EXTENDED(dp->mbrp_type)) { 390 next_ext = le32toh(dp->mbrp_start); 391 continue; 392 } 393 #ifdef COMPAT_386BSD_MBRPART 394 if (dp->mbrp_type == MBR_PTYPE_386BSD) { 395 /* 396 * If more than one matches, take last, 397 * as NetBSD install tool does. 398 */ 399 if (this_ext == 0) 400 dp_386bsd = i; 401 continue; 402 } 403 #endif 404 rval = (*actn)(a, dp, i, this_ext); 405 if (rval != SCAN_CONTINUE) 406 return (rval); 407 } 408 if (next_ext == 0) 409 break; 410 if (ext_base == 0) { 411 ext_base = next_ext; 412 next_ext = 0; 413 } 414 next_ext += ext_base; 415 if (next_ext <= this_ext) 416 break; 417 this_ext = next_ext; 418 } 419 #ifdef COMPAT_386BSD_MBRPART 420 if (this_ext == 0 && dp_386bsd != -1) 421 return ((*actn)(a, &ptns[dp_386bsd], dp_386bsd, 0)); 422 #endif 423 return (SCAN_CONTINUE); 424 } 425 426 static int 427 look_netbsd_part(mbr_args_t *a, struct mbr_partition *dp, int slot, 428 u_int ext_base) 429 { 430 int ptn_base = ext_base + le32toh(dp->mbrp_start); 431 int rval; 432 433 if ( 434 #ifdef COMPAT_386BSD_MBRPART 435 dp->mbrp_type == MBR_PTYPE_386BSD || 436 #endif 437 dp->mbrp_type == MBR_PTYPE_NETBSD) { 438 rval = validate_label(a, ptn_base + BSD44_MBR_LABELSECTOR, 0); 439 440 /* If we got a NetBSD label, look no further. */ 441 if (rval == SCAN_FOUND) 442 return (rval); 443 } 444 445 return (SCAN_CONTINUE); 446 } 447 448 #ifdef _KERNEL 449 #define DKW_MALLOC(SZ) malloc((SZ), M_DEVBUF, M_WAITOK) 450 #define DKW_FREE(PTR) free((PTR), M_DEVBUF) 451 #else 452 #define DKW_MALLOC(SZ) malloc((SZ)) 453 #define DKW_FREE(PTR) free((PTR)) 454 #endif 455 456 static int 457 dkwedge_discover_bsdlabel(struct disk *pdk, struct vnode *vp) 458 { 459 mbr_args_t a; 460 const struct disklabel_location *dl; 461 int rval; 462 463 a.pdk = pdk; 464 a.vp = vp; 465 a.buf = DKW_MALLOC(DEV_BSIZE); 466 a.error = 0; 467 468 /* MBR search. */ 469 rval = scan_mbr(&a, look_netbsd_part); 470 if (rval != SCAN_CONTINUE) { 471 if (rval == SCAN_FOUND) 472 a.error = 0; /* found it, wedges installed */ 473 goto out; 474 } 475 476 /* Known location search. */ 477 for (dl = disklabel_locations; dl->label_sector != -1; dl++) { 478 rval = validate_label(&a, dl->label_sector, dl->label_offset); 479 if (rval != SCAN_CONTINUE) { 480 if (rval == SCAN_FOUND) 481 a.error = 0; /* found it, wedges installed */ 482 goto out; 483 } 484 } 485 486 /* No NetBSD disklabel found. */ 487 a.error = ESRCH; 488 out: 489 DKW_FREE(a.buf); 490 return (a.error); 491 } 492 493 #ifdef _KERNEL 494 DKWEDGE_DISCOVERY_METHOD_DECL(BSD44, 5, dkwedge_discover_bsdlabel); 495 #endif 496
Indexes created Mon Sep 29 21:09:56 GMT 2025