/* $NetBSD: disksubr.c,v 1.17 2020/05/03 06:31:02 jdc Exp $ */ /* * Copyright (c) 1982, 1986, 1988 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Copyright (c) 1994, 1995 Gordon W. Ross * Copyright (c) 1994 Theo de Raadt * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: disksubr.c,v 1.17 2020/05/03 06:31:02 jdc Exp $"); #include #include #include #include #include #include #include #include #include #if LABELSECTOR != 0 #error "Default value of LABELSECTOR no longer zero?" #endif static const char *disklabel_sun_to_bsd(char *, struct disklabel *); static int disklabel_bsd_to_sun(struct disklabel *, char *); /* * Attempt to read a disk label from a device * using the indicated strategy routine. * The label must be partly set up before this: * secpercyl, secsize and anything required for a block i/o read * operation in the driver's strategy/start routines * must be filled in before calling us. * * Return buffer for use in signalling errors if requested. * * Returns null on success and an error string on failure. */ const char * readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *clp) { struct buf *bp; struct disklabel *dlp; struct sun_disklabel *slp; int error; /* minimal requirements for archtypal disk label */ if (lp->d_secperunit == 0) lp->d_secperunit = 0x1fffffff; if (lp->d_npartitions == 0) { lp->d_npartitions = RAW_PART + 1; if (lp->d_partitions[RAW_PART].p_size == 0) lp->d_partitions[RAW_PART].p_size = 0x1fffffff; lp->d_partitions[RAW_PART].p_offset = 0; } if (lp->d_secsize == 0) return ("sector size 0"); /* obtain buffer to probe drive with */ bp = geteblk((int)lp->d_secsize); /* next, dig out disk label */ bp->b_dev = dev; bp->b_blkno = LABELSECTOR; bp->b_cylinder = 0; bp->b_bcount = lp->d_secsize; bp->b_flags |= B_READ; (*strat)(bp); /* if successful, locate disk label within block and validate */ error = biowait(bp); if (error == 0) { /* Save the whole block in case it has info we need. */ memcpy(clp->cd_block, bp->b_data, sizeof(clp->cd_block)); } brelse(bp, 0); if (error) return ("disk label read error"); /* Check for a NetBSD disk label at LABELOFFSET */ dlp = (struct disklabel *) (clp->cd_block + LABELOFFSET); if (dlp->d_magic == DISKMAGIC) { if (dkcksum(dlp)) return ("NetBSD disk label corrupted"); *lp = *dlp; return (NULL); } /* Check for a Sun disk label (for PROM compatibility). */ slp = (struct sun_disklabel *) clp->cd_block; if (slp->sl_magic == SUN_DKMAGIC) return (disklabel_sun_to_bsd(clp->cd_block, lp)); /* * Check for a NetBSD disk label somewhere in LABELSECTOR * (compat with others big-endian boxes) */ for (dlp = (struct disklabel *)clp->cd_block; dlp <= (struct disklabel *)((char *)clp->cd_block + DEV_BSIZE - sizeof(*dlp)); dlp = (struct disklabel *)((char *)dlp + sizeof(long))) { if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) { continue; } if (dlp->d_npartitions > MAXPARTITIONS || dkcksum(dlp) != 0) return("NetBSD disk label corrupted"); else { *lp = *dlp; return(NULL); } } memset(clp->cd_block, 0, sizeof(clp->cd_block)); return NULL; } /* * Write disk label back to device after modification. * Current label is already in clp->cd_block[] */ int writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *clp) { struct buf *bp; int error; struct disklabel *dlp; struct sun_disklabel *slp; /* * Embed native label in a piece of wasteland. */ if (sizeof(struct disklabel) > sizeof slp->sl_bsdlabel) return EFBIG; slp = (struct sun_disklabel *)clp->cd_block; memset(slp->sl_bsdlabel, 0, sizeof(slp->sl_bsdlabel)); dlp = (struct disklabel *)slp->sl_bsdlabel; *dlp = *lp; /* Build a SunOS compatible label around the native label */ error = disklabel_bsd_to_sun(lp, clp->cd_block); if (error) return (error); /* Get a buffer and copy the new label into it. */ bp = geteblk((int)lp->d_secsize); memcpy(bp->b_data, clp->cd_block, sizeof(clp->cd_block)); /* Write out the updated label. */ bp->b_dev = dev; bp->b_blkno = LABELSECTOR; bp->b_cylinder = 0; bp->b_bcount = lp->d_secsize; bp->b_flags |= B_WRITE; (*strat)(bp); error = biowait(bp); brelse(bp, 0); return (error); } /************************************************************************ * * The rest of this was taken from arch/sparc/scsi/sun_disklabel.c * and then substantially rewritten by Gordon W. Ross * ************************************************************************/ /* What partition types to assume for Sun disklabels: */ static u_char sun_fstypes[8] = { FS_BSDFFS, /* a */ FS_SWAP, /* b */ FS_OTHER, /* c - whole disk */ FS_BSDFFS, /* d */ FS_BSDFFS, /* e */ FS_BSDFFS, /* f */ FS_BSDFFS, /* g */ FS_BSDFFS, /* h */ }; /* * Given a SunOS disk label, set lp to a BSD disk label. * Returns NULL on success, else an error string. * * The BSD label is cleared out before this is called. */ static const char * disklabel_sun_to_bsd(char *cp, struct disklabel *lp) { struct sun_disklabel *sl; struct partition *npp; struct sun_dkpart *spp; int i, secpercyl; unsigned int secpblck; u_short cksum, *sp1, *sp2; sl = (struct sun_disklabel *)cp; /* Verify the XOR check. */ sp1 = (u_short *)sl; sp2 = (u_short *)(sl + 1); cksum = 0; while (sp1 < sp2) cksum ^= *sp1++; if (cksum != 0) return("SunOS disk label, bad checksum"); /* Format conversion. */ lp->d_magic = DISKMAGIC; lp->d_magic2 = DISKMAGIC; memcpy(lp->d_packname, sl->sl_text, sizeof(lp->d_packname)); secpblck = lp->d_secsize / 512; if (secpblck == 0) secpblck = 1; /* can't happen */ lp->d_secsize = 512; lp->d_nsectors = sl->sl_nsectors; lp->d_ntracks = sl->sl_ntracks; lp->d_ncylinders = sl->sl_ncylinders; secpercyl = sl->sl_nsectors * sl->sl_ntracks; lp->d_secpercyl = secpercyl; lp->d_secperunit = secpercyl * sl->sl_ncylinders; lp->d_sparespercyl = sl->sl_sparespercyl; lp->d_acylinders = sl->sl_acylinders; lp->d_rpm = sl->sl_rpm; lp->d_interleave = sl->sl_interleave; lp->d_npartitions = 8; /* These are as defined in */ lp->d_bbsize = 8192; /* XXX */ lp->d_sbsize = 8192; /* XXX */ for (i = 0; i < 8; i++) { spp = &sl->sl_part[i]; npp = &lp->d_partitions[i]; if (npp->p_fstype == FS_ISO9660 && spp->sdkp_cyloffset * secpercyl == npp->p_offset*secpblck && spp->sdkp_nsectors <= npp->p_size*secpblck && npp->p_size > 0 && spp->sdkp_nsectors > 0) { /* * This happens for example on sunlabel'd hybrid * (ffs + ISO9660) CDs, like our install CDs. * The cd driver has initialized a valid ISO9660 * partition (including session parameters), so * we better not overwrite it. */ npp->p_offset *= secpblck; npp->p_size = spp->sdkp_nsectors; npp->p_cdsession *= secpblck; continue; } npp->p_offset = spp->sdkp_cyloffset * secpercyl; npp->p_size = spp->sdkp_nsectors; if (npp->p_size == 0) { npp->p_fstype = FS_UNUSED; } else { npp->p_fstype = sun_fstypes[i]; if (npp->p_fstype == FS_BSDFFS) { /* * The sun label does not store the FFS fields, * so just set them with default values here. */ npp->p_fsize = 1024; npp->p_frag = 8; npp->p_cpg = 16; } } } lp->d_checksum = 0; lp->d_checksum = dkcksum(lp); return (NULL); } /* * Given a BSD disk label, update the Sun disklabel * pointed to by cp with the new info. Note that the * Sun disklabel may have other info we need to keep. * Returns zero or error code. */ static int disklabel_bsd_to_sun(struct disklabel *lp, char *cp) { struct sun_disklabel *sl; struct partition *npp; struct sun_dkpart *spp; int i, secpercyl; u_short cksum, *sp1, *sp2; if (lp->d_secsize != 512) return (EINVAL); sl = (struct sun_disklabel *)cp; /* * Format conversion. */ memcpy(sl->sl_text, lp->d_packname, sizeof(lp->d_packname)); sl->sl_rpm = lp->d_rpm; sl->sl_pcylinders = lp->d_ncylinders + lp->d_acylinders; /* XXX */ sl->sl_sparespercyl = lp->d_sparespercyl; sl->sl_interleave = lp->d_interleave; sl->sl_ncylinders = lp->d_ncylinders; sl->sl_acylinders = lp->d_acylinders; sl->sl_ntracks = lp->d_ntracks; sl->sl_nsectors = lp->d_nsectors; secpercyl = sl->sl_nsectors * sl->sl_ntracks; for (i = 0; i < 8; i++) { spp = &sl->sl_part[i]; npp = &lp->d_partitions[i]; /* * SunOS partitions must start on a cylinder boundary. * Note this restriction is forced upon NetBSD/sparc * labels too, since we want to keep both labels * synchronised. */ if (npp->p_offset % secpercyl) return (EINVAL); spp->sdkp_cyloffset = npp->p_offset / secpercyl; spp->sdkp_nsectors = npp->p_size; } sl->sl_magic = SUN_DKMAGIC; /* Compute the XOR check. */ sp1 = (u_short *)sl; sp2 = (u_short *)(sl + 1); sl->sl_cksum = cksum = 0; while (sp1 < sp2) cksum ^= *sp1++; sl->sl_cksum = cksum; return (0); } /* * Search the bad sector table looking for the specified sector. * Return index if found. * Return -1 if not found. */ int isbad(struct dkbad *bt, int cyl, int trk, int sec) { int i; long blk, bblk; blk = ((long)cyl << 16) + (trk << 8) + sec; for (i = 0; i < 126; i++) { bblk = ((long)bt->bt_bad[i].bt_cyl << 16) + bt->bt_bad[i].bt_trksec; if (blk == bblk) return (i); if (blk < bblk || bblk < 0) break; } return (-1); }