dkwedge_bsdlabel.c revision 1.6
1 /* $NetBSD: dkwedge_bsdlabel.c,v 1.6 2006/08/13 18:45:08 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.6 2006/08/13 18:45:08 martin Exp $"); 90 91 #include "opt_dkwedge.h" 92 #ifdef DKWEDGE_METHOD_BSDLABEL 93 94 #include <sys/param.h> 95 #include <sys/systm.h> 96 #include <sys/proc.h> 97 #include <sys/errno.h> 98 #include <sys/disk.h> 99 #include <sys/vnode.h> 100 #include <sys/malloc.h> 101 102 #include <sys/bootblock.h> 103 #include <sys/disklabel.h> 104 105 #define BSD44_MBR_LABELSECTOR 1 106 107 #define DISKLABEL_SIZE(x) \ 108 (offsetof(struct disklabel, d_partitions) + \ 109 (sizeof(struct partition) * (x))) 110 111 /* 112 * Note the smallest MAXPARTITIONS was 8, so we allow a disklabel 113 * that size to be locted at the end of the sector. 114 */ 115 #define DISKLABEL_MINSIZE DISKLABEL_SIZE(8) 116 117 /* 118 * Table of known platform-specific disklabel locations. 119 */ 120 static const struct disklabel_location { 121 daddr_t label_sector; /* sector containing label */ 122 size_t label_offset; /* byte offset of label in sector */ 123 } disklabel_locations[] = { 124 { 0, 0 }, /* mvme68k, next68k */ 125 { 0, 64 }, /* algor, alpha, amiga, amigappc, evbmips, evbppc, 126 luna68k, mac68k, macppc, news68k, newsmips, 127 pc532, pdp11, pmax, vax, x68k */ 128 { 0, 128 }, /* sparc, sun68k */ 129 { 1, 0 }, /* amd64, arc, arm, bebox, cobalt, evbppc, hp700, 130 hpcarm, hpcmips, i386, ibmnws, mipsco, mvmeppc, 131 ofppc, playstation2, pmppc, prep, sandpoint, 132 sbmips, sgimips, sh3, sh5 */ 133 /* XXX atari is weird */ 134 { 2, 0 }, /* cesfic, hp300 */ 135 136 { -1, 0 }, 137 }; 138 139 #define SCAN_CONTINUE 0 140 #define SCAN_FOUND 1 141 #define SCAN_ERROR 2 142 143 typedef struct mbr_args { 144 struct disk *pdk; 145 struct vnode *vp; 146 void *buf; 147 int error; 148 } mbr_args_t; 149 150 static const char * 151 bsdlabel_fstype_to_str(uint8_t fstype) 152 { 153 const char *str; 154 155 switch (fstype) { 156 case FS_UNUSED: str = DKW_PTYPE_UNUSED; break; 157 case FS_SWAP: str = DKW_PTYPE_SWAP; break; 158 case FS_BSDFFS: str = DKW_PTYPE_FFS; break; 159 case FS_MSDOS: str = DKW_PTYPE_FAT; break; 160 case FS_BSDLFS: str = DKW_PTYPE_LFS; break; 161 case FS_ISO9660: str = DKW_PTYPE_ISO9660; break; 162 case FS_ADOS: str = DKW_PTYPE_AMIGADOS; break; 163 case FS_HFS: str = DKW_PTYPE_APPLEHFS; break; 164 case FS_FILECORE: str = DKW_PTYPE_FILECORE; break; 165 case FS_EX2FS: str = DKW_PTYPE_EXT2FS; break; 166 case FS_NTFS: str = DKW_PTYPE_NTFS; break; 167 case FS_RAID: str = DKW_PTYPE_RAIDFRAME; break; 168 case FS_CCD: str = DKW_PTYPE_CCD; break; 169 case FS_APPLEUFS: str = DKW_PTYPE_APPLEUFS; break; 170 default: str = NULL; break; 171 } 172 173 return (str); 174 } 175 176 static void 177 swap_disklabel(struct disklabel *lp) 178 { 179 int i; 180 181 #define SWAP16(x) lp->x = bswap16(lp->x) 182 #define SWAP32(x) lp->x = bswap32(lp->x) 183 184 SWAP32(d_magic); 185 SWAP16(d_type); 186 SWAP16(d_subtype); 187 SWAP32(d_secsize); 188 SWAP32(d_nsectors); 189 SWAP32(d_ntracks); 190 SWAP32(d_ncylinders); 191 SWAP32(d_secpercyl); 192 SWAP32(d_secperunit); 193 SWAP16(d_sparespertrack); 194 SWAP16(d_sparespercyl); 195 SWAP32(d_acylinders); 196 SWAP16(d_rpm); 197 SWAP16(d_interleave); 198 SWAP16(d_trackskew); 199 SWAP16(d_cylskew); 200 SWAP32(d_headswitch); 201 SWAP32(d_trkseek); 202 SWAP32(d_flags); 203 204 for (i = 0; i < NDDATA; i++) 205 SWAP32(d_drivedata[i]); 206 for (i = 0; i < NSPARE; i++) 207 SWAP32(d_spare[i]); 208 209 SWAP32(d_magic2); 210 SWAP16(d_checksum); 211 SWAP16(d_npartitions); 212 SWAP32(d_bbsize); 213 SWAP32(d_sbsize); 214 215 for (i = 0; i < lp->d_npartitions; i++) { 216 SWAP32(d_partitions[i].p_size); 217 SWAP32(d_partitions[i].p_offset); 218 SWAP32(d_partitions[i].p_fsize); 219 SWAP16(d_partitions[i].p_cpg); 220 } 221 222 #undef SWAP16 223 #undef SWAP32 224 } 225 226 static int 227 validate_label(mbr_args_t *a, daddr_t label_sector, size_t label_offset) 228 { 229 struct disklabel *lp; 230 caddr_t lp_lim; 231 int i, error; 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 swap_disklabel(lp); 271 } else 272 continue; 273 } else { 274 /* 275 * Validate the disklabel length. 276 */ 277 if ((caddr_t)lp + DISKLABEL_SIZE(lp->d_npartitions) > 278 (caddr_t)a->buf + DEV_BSIZE) { 279 aprint_error("%s: BSD disklabel @ %" PRId64 280 "+%zd has bogus partition count (%u)\n", 281 a->pdk->dk_name, label_sector, 282 label_offset, lp->d_npartitions); 283 continue; 284 } 285 } 286 287 /* 288 * Disklabel is now in the right order and we have validated 289 * the partition count, checksum it as the final check. 290 */ 291 if (dkcksum(lp) != 0) { 292 aprint_error("%s: BSD disklabel @ %" PRId64 293 "+%zd has bad checksum\n", a->pdk->dk_name, 294 label_sector, label_offset); 295 continue; 296 } 297 298 /* 299 * Ok, we have a valid NetBSD disklabel, add wedges for it. 300 */ 301 for (i = 0; i < lp->d_npartitions; i++) { 302 struct dkwedge_info dkw; 303 struct partition *p; 304 const char *ptype; 305 306 p = &lp->d_partitions[i]; 307 308 if (p->p_fstype == FS_UNUSED) 309 continue; 310 if ((ptype = 311 bsdlabel_fstype_to_str(p->p_fstype)) == NULL) { 312 /* 313 * XXX Should probably just add these... 314 * XXX maybe just have an empty ptype? 315 */ 316 aprint_verbose("%s: skipping partition %d, " 317 "type %d\n", a->pdk->dk_name, i, 318 p->p_fstype); 319 continue; 320 } 321 strcpy(dkw.dkw_ptype, ptype); 322 323 strcpy(dkw.dkw_parent, a->pdk->dk_name); 324 dkw.dkw_offset = p->p_offset; 325 dkw.dkw_size = p->p_size; 326 327 /* 328 * These get historical disk naming style 329 * wedge names. 330 */ 331 snprintf(dkw.dkw_wname, sizeof(dkw.dkw_wname), 332 "%s%c", a->pdk->dk_name, 'a' + i); 333 334 error = dkwedge_add(&dkw); 335 if (error == EEXIST) 336 aprint_error("%s: wedge named '%s' already " 337 "exists, manual intervention required\n", 338 a->pdk->dk_name, dkw.dkw_wname); 339 else if (error) 340 aprint_error("%s: error %d adding partition " 341 "%d type %d\n", a->pdk->dk_name, error, 342 i, p->p_fstype); 343 } 344 return (SCAN_FOUND); 345 } 346 } 347 348 static int 349 scan_mbr(mbr_args_t *a, int (*actn)(mbr_args_t *, struct mbr_partition *, 350 int, u_int)) 351 { 352 struct mbr_partition ptns[MBR_PART_COUNT]; 353 struct mbr_partition *dp; 354 struct mbr_sector *mbr; 355 u_int ext_base, this_ext, next_ext; 356 int i, rval; 357 #ifdef COMPAT_386BSD_MBRPART 358 int dp_386bsd = -1; 359 #endif 360 361 ext_base = 0; 362 this_ext = 0; 363 for (;;) { 364 a->error = dkwedge_read(a->pdk, a->vp, this_ext, a->buf, 365 DEV_BSIZE); 366 if (a->error) { 367 aprint_error("%s: unable to read MBR @ %u, " 368 "error = %d\n", a->pdk->dk_name, this_ext, 369 a->error); 370 return (SCAN_ERROR); 371 } 372 373 mbr = a->buf; 374 if (mbr->mbr_magic != htole16(MBR_MAGIC)) 375 return (SCAN_CONTINUE); 376 377 /* Copy data out of buffer so action can use the buffer. */ 378 memcpy(ptns, &mbr->mbr_parts, sizeof(ptns)); 379 380 /* Looks for NetBSD partition. */ 381 next_ext = 0; 382 dp = ptns; 383 for (i = 0; i < MBR_PART_COUNT; i++, dp++) { 384 if (dp->mbrp_type == 0) 385 continue; 386 if (MBR_IS_EXTENDED(dp->mbrp_type)) { 387 next_ext = le32toh(dp->mbrp_start); 388 continue; 389 } 390 #ifdef COMPAT_386BSD_MBRPART 391 if (dp->mbrp_type == MBR_PTYPE_386BSD) { 392 /* 393 * If more than one matches, take last, 394 * as NetBSD install tool does. 395 */ 396 if (this_ext == 0) 397 dp_386bsd = i; 398 continue; 399 } 400 #endif 401 rval = (*actn)(a, dp, i, this_ext); 402 if (rval != SCAN_CONTINUE) 403 return (rval); 404 } 405 if (next_ext == 0) 406 break; 407 if (ext_base == 0) { 408 ext_base = next_ext; 409 next_ext = 0; 410 } 411 next_ext += ext_base; 412 if (next_ext <= this_ext) 413 break; 414 this_ext = next_ext; 415 } 416 #ifdef COMPAT_386BSD_MBRPART 417 if (this_ext == 0 && dp_386bsd != -1) 418 return ((*actn)(a, &ptns[dp_386bsd], dp_386bsd, 0)); 419 #endif 420 return (SCAN_CONTINUE); 421 } 422 423 static int 424 look_netbsd_part(mbr_args_t *a, struct mbr_partition *dp, int slot, 425 u_int ext_base) 426 { 427 int ptn_base = ext_base + le32toh(dp->mbrp_start); 428 int rval; 429 430 if ( 431 #ifdef COMPAT_386BSD_MBRPART 432 dp->mbrp_type == MBR_PTYPE_386BSD || 433 #endif 434 dp->mbrp_type == MBR_PTYPE_NETBSD) { 435 rval = validate_label(a, ptn_base + BSD44_MBR_LABELSECTOR, 0); 436 437 /* If we got a NetBSD label, look no further. */ 438 if (rval == SCAN_FOUND) 439 return (rval); 440 } 441 442 return (SCAN_CONTINUE); 443 } 444 445 static int 446 dkwedge_discover_bsdlabel(struct disk *pdk, struct vnode *vp) 447 { 448 mbr_args_t a; 449 const struct disklabel_location *dl; 450 int rval; 451 452 a.pdk = pdk; 453 a.vp = vp; 454 a.buf = malloc(DEV_BSIZE, M_DEVBUF, M_WAITOK); 455 a.error = 0; 456 457 /* MBR search. */ 458 rval = scan_mbr(&a, look_netbsd_part); 459 if (rval != SCAN_CONTINUE) { 460 if (rval == SCAN_FOUND) 461 a.error = 0; /* found it, wedges installed */ 462 goto out; 463 } 464 465 /* Known location search. */ 466 for (dl = disklabel_locations; dl->label_sector != -1; dl++) { 467 rval = validate_label(&a, dl->label_sector, dl->label_offset); 468 if (rval != SCAN_CONTINUE) { 469 if (rval == SCAN_FOUND) 470 a.error = 0; /* found it, wedges installed */ 471 goto out; 472 } 473 } 474 475 /* No NetBSD disklabel found. */ 476 a.error = ESRCH; 477 out: 478 free(a.buf, M_DEVBUF); 479 return (a.error); 480 } 481 482 DKWEDGE_DISCOVERY_METHOD_DECL(BSD44, 5, dkwedge_discover_bsdlabel); 483 484 #endif 485
Indexes created Sat Oct 25 10:09:55 GMT 2025