Annotation of sys/arch/sparc64/sparc64/disksubr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: disksubr.c,v 1.46 2007/06/20 18:15:46 deraadt Exp $ */
! 2: /* $NetBSD: disksubr.c,v 1.13 2000/12/17 22:39:18 pk Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994, 1995 Gordon W. Ross
! 6: * Copyright (c) 1994 Theo de Raadt
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. The name of the author may not be used to endorse or promote products
! 18: * derived from this software without specific prior written permission
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 21: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 22: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 23: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 24: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 25: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 26: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 27: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 28: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 29: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 30: */
! 31:
! 32: #include <sys/param.h>
! 33: #include <sys/systm.h>
! 34: #include <sys/buf.h>
! 35: #include <sys/disklabel.h>
! 36: #include <sys/disk.h>
! 37:
! 38: #include <dev/sun/disklabel.h>
! 39:
! 40: #include "cd.h"
! 41:
! 42: static char *disklabel_sun_to_bsd(struct sun_disklabel *, struct disklabel *);
! 43: static int disklabel_bsd_to_sun(struct disklabel *, struct sun_disklabel *);
! 44: static __inline u_int sun_extended_sum(struct sun_disklabel *, void *);
! 45:
! 46: #if NCD > 0
! 47: extern void cdstrategy(struct buf *);
! 48: #endif
! 49:
! 50: /*
! 51: * Attempt to read a disk label from a device
! 52: * using the indicated strategy routine.
! 53: * The label must be partly set up before this:
! 54: * secpercyl, secsize and anything required for a block i/o read
! 55: * operation in the driver's strategy/start routines
! 56: * must be filled in before calling us.
! 57: *
! 58: * Return buffer for use in signalling errors if requested.
! 59: *
! 60: * Returns null on success and an error string on failure.
! 61: */
! 62: char *
! 63: readdisklabel(dev_t dev, void (*strat)(struct buf *),
! 64: struct disklabel *lp, int spoofonly)
! 65: {
! 66: struct sun_disklabel *slp;
! 67: struct buf *bp = NULL;
! 68: char *msg;
! 69:
! 70: if ((msg = initdisklabel(lp)))
! 71: goto done;
! 72:
! 73: /*
! 74: * On sparc64 we check for a CD label first, because our
! 75: * CD install media contains both sparc & sparc64 labels.
! 76: * We want the sparc64 machine to find the "CD label", not
! 77: * the SunOS label, for loading it's kernel.
! 78: */
! 79: #if NCD > 0
! 80: if (strat == cdstrategy) {
! 81: #if defined(CD9660)
! 82: if (iso_disklabelspoof(dev, strat, lp) == 0)
! 83: goto done;
! 84: #endif
! 85: #if defined(UDF)
! 86: if (udf_disklabelspoof(dev, strat, lp) == 0)
! 87: goto done;
! 88: #endif
! 89: }
! 90: #endif /* NCD > 0 */
! 91:
! 92: /* get buffer and initialize it */
! 93: bp = geteblk((int)lp->d_secsize);
! 94: bp->b_dev = dev;
! 95:
! 96: if (spoofonly)
! 97: goto doslabel;
! 98:
! 99: bp->b_blkno = LABELSECTOR;
! 100: bp->b_bcount = lp->d_secsize;
! 101: bp->b_flags = B_BUSY | B_READ;
! 102: (*strat)(bp);
! 103: if (biowait(bp)) {
! 104: msg = "disk label read error";
! 105: goto done;
! 106: }
! 107:
! 108: slp = (struct sun_disklabel *)bp->b_data;
! 109: if (slp->sl_magic == SUN_DKMAGIC) {
! 110: msg = disklabel_sun_to_bsd(slp, lp);
! 111: goto done;
! 112: }
! 113:
! 114: msg = checkdisklabel(bp->b_data + LABELOFFSET, lp);
! 115: if (msg == NULL)
! 116: goto done;
! 117:
! 118: doslabel:
! 119: msg = readdoslabel(bp, strat, lp, NULL, spoofonly);
! 120: if (msg == NULL)
! 121: goto done;
! 122:
! 123: /* A CD9660/UDF label may be on a non-CD drive, so recheck */
! 124: #if defined(CD9660)
! 125: if (iso_disklabelspoof(dev, strat, lp) == 0) {
! 126: msg = NULL;
! 127: goto done;
! 128: }
! 129: #endif
! 130: #if defined(UDF)
! 131: if (udf_disklabelspoof(dev, strat, lp) == 0) {
! 132: msg = NULL;
! 133: goto done;
! 134: }
! 135: #endif
! 136:
! 137: done:
! 138: if (bp) {
! 139: bp->b_flags |= B_INVAL;
! 140: brelse(bp);
! 141: }
! 142: return (msg);
! 143: }
! 144:
! 145: /*
! 146: * Write disk label back to device after modification.
! 147: */
! 148: int
! 149: writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp)
! 150: {
! 151: struct buf *bp = NULL;
! 152: int error;
! 153:
! 154: /* get buffer and initialize it */
! 155: bp = geteblk((int)lp->d_secsize);
! 156: bp->b_dev = dev;
! 157:
! 158: error = disklabel_bsd_to_sun(lp, (struct sun_disklabel *)bp->b_data);
! 159: if (error)
! 160: goto done;
! 161:
! 162: /* Write out the updated label. */
! 163: bp->b_blkno = LABELSECTOR;
! 164: bp->b_bcount = lp->d_secsize;
! 165: bp->b_flags = B_BUSY | B_WRITE;
! 166: (*strat)(bp);
! 167: error = biowait(bp);
! 168:
! 169: done:
! 170: if (bp) {
! 171: bp->b_flags |= B_INVAL;
! 172: brelse(bp);
! 173: }
! 174: return (error);
! 175: }
! 176:
! 177: /************************************************************************
! 178: *
! 179: * The rest of this was taken from arch/sparc/scsi/sun_disklabel.c
! 180: * and then substantially rewritten by Gordon W. Ross
! 181: *
! 182: ************************************************************************/
! 183:
! 184: /* What partition types to assume for Sun disklabels: */
! 185: static u_char
! 186: sun_fstypes[16] = {
! 187: FS_BSDFFS, /* a */
! 188: FS_SWAP, /* b */
! 189: FS_UNUSED, /* c - whole disk */
! 190: FS_BSDFFS, /* d */
! 191: FS_BSDFFS, /* e */
! 192: FS_BSDFFS, /* f */
! 193: FS_BSDFFS, /* g */
! 194: FS_BSDFFS, /* h */
! 195: FS_BSDFFS, /* i */
! 196: FS_BSDFFS, /* j */
! 197: FS_BSDFFS, /* k */
! 198: FS_BSDFFS, /* l */
! 199: FS_BSDFFS, /* m */
! 200: FS_BSDFFS, /* n */
! 201: FS_BSDFFS, /* o */
! 202: FS_BSDFFS /* p */
! 203: };
! 204:
! 205: /*
! 206: * Given a struct sun_disklabel, assume it has an extended partition
! 207: * table and compute the correct value for sl_xpsum.
! 208: */
! 209: static __inline u_int
! 210: sun_extended_sum(struct sun_disklabel *sl, void *end)
! 211: {
! 212: u_int sum, *xp, *ep;
! 213:
! 214: xp = (u_int *)&sl->sl_xpmag;
! 215: ep = (u_int *)end;
! 216:
! 217: sum = 0;
! 218: for (; xp < ep; xp++)
! 219: sum += *xp;
! 220: return (sum);
! 221: }
! 222:
! 223: /*
! 224: * Given a SunOS disk label, set lp to a BSD disk label.
! 225: * Returns NULL on success, else an error string.
! 226: *
! 227: * The BSD label is cleared out before this is called.
! 228: */
! 229: static char *
! 230: disklabel_sun_to_bsd(struct sun_disklabel *sl, struct disklabel *lp)
! 231: {
! 232: struct partition *npp;
! 233: struct sun_dkpart *spp;
! 234: int i, secpercyl;
! 235: u_short cksum = 0, *sp1, *sp2;
! 236:
! 237: /* Verify the XOR check. */
! 238: sp1 = (u_short *)sl;
! 239: sp2 = (u_short *)(sl + 1);
! 240: while (sp1 < sp2)
! 241: cksum ^= *sp1++;
! 242: if (cksum != 0)
! 243: return ("SunOS disk label, bad checksum");
! 244:
! 245: /* Format conversion. */
! 246: lp->d_magic = DISKMAGIC;
! 247: lp->d_magic2 = DISKMAGIC;
! 248: lp->d_flags = D_VENDOR;
! 249: memcpy(lp->d_packname, sl->sl_text, sizeof(lp->d_packname));
! 250:
! 251: lp->d_secsize = 512;
! 252: lp->d_nsectors = sl->sl_nsectors;
! 253: lp->d_ntracks = sl->sl_ntracks;
! 254: lp->d_ncylinders = sl->sl_ncylinders;
! 255:
! 256: secpercyl = sl->sl_nsectors * sl->sl_ntracks;
! 257: lp->d_secpercyl = secpercyl;
! 258: if (DL_GETDSIZE(lp) == 0)
! 259: DL_SETDSIZE(lp, (daddr64_t)secpercyl * sl->sl_ncylinders);
! 260: lp->d_version = 1;
! 261:
! 262: lp->d_sparespercyl = sl->sl_sparespercyl;
! 263: lp->d_acylinders = sl->sl_acylinders;
! 264: lp->d_rpm = sl->sl_rpm;
! 265: lp->d_interleave = sl->sl_interleave;
! 266:
! 267: lp->d_npartitions = MAXPARTITIONS;
! 268: /* These are as defined in <ufs/ffs/fs.h> */
! 269: lp->d_bbsize = 8192; /* XXX */
! 270: lp->d_sbsize = 8192; /* XXX */
! 271:
! 272: for (i = 0; i < 8; i++) {
! 273: spp = &sl->sl_part[i];
! 274: npp = &lp->d_partitions[i];
! 275: DL_SETPOFFSET(npp, spp->sdkp_cyloffset * secpercyl);
! 276: DL_SETPSIZE(npp, spp->sdkp_nsectors);
! 277: if (DL_GETPSIZE(npp) == 0) {
! 278: npp->p_fstype = FS_UNUSED;
! 279: } else {
! 280: npp->p_fstype = sun_fstypes[i];
! 281: if (npp->p_fstype == FS_BSDFFS) {
! 282: /*
! 283: * The sun label does not store the FFS fields,
! 284: * so just set them with default values here.
! 285: */
! 286: npp->p_fragblock =
! 287: DISKLABELV1_FFS_FRAGBLOCK(2048, 8);
! 288: npp->p_cpg = 16;
! 289: }
! 290: }
! 291: }
! 292:
! 293: /* Clear "extended" partition info, tentatively */
! 294: for (i = 0; i < SUNXPART; i++) {
! 295: npp = &lp->d_partitions[i+8];
! 296: DL_SETPOFFSET(npp, 0);
! 297: DL_SETPSIZE(npp, 0);
! 298: npp->p_fstype = FS_UNUSED;
! 299: }
! 300:
! 301: /* Check to see if there's an "extended" partition table
! 302: * SL_XPMAG partitions had checksums up to just before the
! 303: * (new) sl_types variable, while SL_XPMAGTYP partitions have
! 304: * checksums up to the just before the (new) sl_xxx1 variable.
! 305: */
! 306: if ((sl->sl_xpmag == SL_XPMAG &&
! 307: sun_extended_sum(sl, &sl->sl_types) == sl->sl_xpsum) ||
! 308: (sl->sl_xpmag == SL_XPMAGTYP &&
! 309: sun_extended_sum(sl, &sl->sl_xxx1) == sl->sl_xpsum)) {
! 310: /*
! 311: * There is. Copy over the "extended" partitions.
! 312: * This code parallels the loop for partitions a-h.
! 313: */
! 314: for (i = 0; i < SUNXPART; i++) {
! 315: spp = &sl->sl_xpart[i];
! 316: npp = &lp->d_partitions[i+8];
! 317: DL_SETPOFFSET(npp, spp->sdkp_cyloffset * secpercyl);
! 318: DL_SETPSIZE(npp, spp->sdkp_nsectors);
! 319: if (DL_GETPSIZE(npp) == 0) {
! 320: npp->p_fstype = FS_UNUSED;
! 321: continue;
! 322: }
! 323: npp->p_fstype = sun_fstypes[i+8];
! 324: if (npp->p_fstype == FS_BSDFFS) {
! 325: npp->p_fragblock =
! 326: DISKLABELV1_FFS_FRAGBLOCK(2048, 8);
! 327: npp->p_cpg = 16;
! 328: }
! 329: }
! 330: if (sl->sl_xpmag == SL_XPMAGTYP)
! 331: for (i = 0; i < MAXPARTITIONS; i++) {
! 332: npp = &lp->d_partitions[i];
! 333: npp->p_fstype = sl->sl_types[i];
! 334: npp->p_fragblock = sl->sl_fragblock[i];
! 335: npp->p_cpg = sl->sl_cpg[i];
! 336: }
! 337: }
! 338:
! 339: lp->d_checksum = 0;
! 340: lp->d_checksum = dkcksum(lp);
! 341: return (NULL);
! 342: }
! 343:
! 344: /*
! 345: * Given a BSD disk label, update the Sun disklabel
! 346: * pointed to by cp with the new info. Note that the
! 347: * Sun disklabel may have other info we need to keep.
! 348: * Returns zero or error code.
! 349: */
! 350: static int
! 351: disklabel_bsd_to_sun(struct disklabel *lp, struct sun_disklabel *sl)
! 352: {
! 353: struct partition *npp;
! 354: struct sun_dkpart *spp;
! 355: int i, secpercyl;
! 356: u_short cksum, *sp1, *sp2;
! 357:
! 358: /* Enforce preconditions */
! 359: if (lp->d_secsize != 512 || lp->d_nsectors == 0 || lp->d_ntracks == 0)
! 360: return (EINVAL);
! 361:
! 362: /* Format conversion. */
! 363: memcpy(sl->sl_text, lp->d_packname, sizeof(lp->d_packname));
! 364: sl->sl_rpm = lp->d_rpm;
! 365: sl->sl_pcylinders = lp->d_ncylinders + lp->d_acylinders; /* XXX */
! 366: sl->sl_sparespercyl = lp->d_sparespercyl;
! 367: sl->sl_interleave = lp->d_interleave;
! 368: sl->sl_ncylinders = lp->d_ncylinders;
! 369: sl->sl_acylinders = lp->d_acylinders;
! 370: sl->sl_ntracks = lp->d_ntracks;
! 371: sl->sl_nsectors = lp->d_nsectors;
! 372:
! 373: secpercyl = sl->sl_nsectors * sl->sl_ntracks;
! 374: for (i = 0; i < 8; i++) {
! 375: spp = &sl->sl_part[i];
! 376: npp = &lp->d_partitions[i];
! 377:
! 378: if (DL_GETPOFFSET(npp) % secpercyl)
! 379: return (EINVAL);
! 380: spp->sdkp_cyloffset = DL_GETPOFFSET(npp) / secpercyl;
! 381: spp->sdkp_nsectors = DL_GETPSIZE(npp);
! 382: }
! 383: sl->sl_magic = SUN_DKMAGIC;
! 384:
! 385: for (i = 0; i < SUNXPART; i++) {
! 386: if (DL_GETPOFFSET(&lp->d_partitions[i+8]) ||
! 387: DL_GETPSIZE(&lp->d_partitions[i+8]))
! 388: break;
! 389: }
! 390: for (i = 0; i < SUNXPART; i++) {
! 391: spp = &sl->sl_xpart[i];
! 392: npp = &lp->d_partitions[i+8];
! 393: if (DL_GETPOFFSET(npp) % secpercyl)
! 394: return (EINVAL);
! 395: sl->sl_xpart[i].sdkp_cyloffset =
! 396: DL_GETPOFFSET(npp) / secpercyl;
! 397: sl->sl_xpart[i].sdkp_nsectors = DL_GETPSIZE(npp);
! 398: }
! 399: for (i = 0; i < MAXPARTITIONS; i++) {
! 400: npp = &lp->d_partitions[i];
! 401: sl->sl_types[i] = npp->p_fstype;
! 402: sl->sl_fragblock[i] = npp->p_fragblock;
! 403: sl->sl_cpg[i] = npp->p_cpg;
! 404: }
! 405: sl->sl_xpmag = SL_XPMAGTYP;
! 406: sl->sl_xpsum = sun_extended_sum(sl, &sl->sl_xxx1);
! 407:
! 408: /* Correct the XOR check. */
! 409: sp1 = (u_short *)sl;
! 410: sp2 = (u_short *)(sl + 1);
! 411: sl->sl_cksum = cksum = 0;
! 412: while (sp1 < sp2)
! 413: cksum ^= *sp1++;
! 414: sl->sl_cksum = cksum;
! 415:
! 416: return (0);
! 417: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to disksubr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / sparc64