/* $NetBSD: disksubr.c,v 1.4 2019/04/17 20:46:38 skrll Exp $ */ /* $OpenBSD: disksubr.c,v 1.6 2000/10/18 21:00:34 mickey Exp $ */ /* * Copyright (c) 1999 Michael Shalayeff * Copyright (c) 1997 Niklas Hallqvist * 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. * * @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91 */ /* * Copyright (c) 1996 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. */ /* * This disksubr.c module started to take its present form on OpenBSD/alpha * but it was always thought it should be made completely MI and not need to * be in that alpha-specific tree at all. * * XXX HPUX disklabel is not understood yet. */ #include <sys/cdefs.h> __KERNEL_RCSID(0, "$NetBSD: disksubr.c,v 1.4 2019/04/17 20:46:38 skrll Exp $"); #include <sys/param.h> #include <sys/systm.h> #include <sys/buf.h> #include <sys/device.h> #include <sys/disklabel.h> #include <sys/syslog.h> #include <sys/disk.h> const char *readliflabel(struct buf *, void (*)(struct buf *), struct disklabel *, struct cpu_disklabel *, int *, int *, int); const char *readbsdlabel(struct buf *, void (*)(struct buf *), int, int, int, struct disklabel *, int); /* * Try to read a standard BSD disklabel at a certain sector. */ const char * readbsdlabel(struct buf *bp, void (*strat)(struct buf *), int cyl, int sec, int off, struct disklabel *lp, int spoofonly) { struct disklabel *dlp; const char *msg = NULL; uint16_t cksum; /* don't read the on-disk label if we are in spoofed-only mode */ if (spoofonly) return (NULL); bp->b_blkno = sec; bp->b_cylinder = cyl; bp->b_bcount = lp->d_secsize; bp->b_cflags = BC_BUSY; bp->b_flags = B_READ; bp->b_oflags = 0; (*strat)(bp); /* if successful, locate disk label within block and validate */ if (biowait(bp)) { /* XXX we return the faked label built so far */ msg = "disk label I/O error"; return (msg); } /* * If off is negative, search until the end of the sector for * the label, otherwise, just look at the specific location * we're given. */ dlp = (struct disklabel *)((char *)bp->b_data + (off >= 0 ? off : 0)); do { if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) { if (msg == NULL) msg = "no disk label"; } else { cksum = dkcksum(dlp); if (dlp->d_npartitions > MAXPARTITIONS || cksum != 0) { msg = "disk label corrupted"; } else { *lp = *dlp; msg = NULL; break; } } if (off >= 0) break; dlp = (struct disklabel *)((char *)dlp + sizeof(int32_t)); } while (dlp <= (struct disklabel *)((char *)bp->b_data + lp->d_secsize - sizeof(*dlp))); return (msg); } /* * 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. * * 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 *osdep) { int spoofonly = 0; struct buf *bp = NULL; const char *msg = "no disk label"; int i; struct disklabel fallbacklabel; /* minimal requirements for archetypal disk label */ if (lp->d_secsize == 0) lp->d_secsize = DEV_BSIZE; if (lp->d_secperunit == 0) lp->d_secperunit = 0x1fffffff; if (lp->d_secpercyl == 0) return "invalid geometry"; lp->d_npartitions = RAW_PART + 1; for (i = 0; i < RAW_PART; i++) { lp->d_partitions[i].p_size = 0; lp->d_partitions[i].p_offset = 0; } if (lp->d_partitions[i].p_size == 0) lp->d_partitions[i].p_size = 0x1fffffff; lp->d_partitions[i].p_offset = 0; fallbacklabel = *lp; /* get a buffer and initialize it */ bp = geteblk((int)lp->d_secsize); bp->b_dev = dev; msg = readliflabel(bp, strat, lp, osdep, 0, 0, spoofonly); #if defined(CD9660) if (msg && iso_disklabelspoof(dev, strat, lp) == 0) msg = NULL; #endif /* If there was an error, still provide a decent fake one. */ if (msg) *lp = fallbacklabel; if (bp) { brelse(bp, BC_INVAL); } return (msg); } const char * readliflabel(struct buf *bp, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *osdep, int *partoffp, int *cylp, int spoofonly) { int fsoff; /* read LIF volume header */ bp->b_blkno = btodb(HPPA_LIF_VOLSTART); bp->b_bcount = lp->d_secsize; bp->b_cflags = BC_BUSY; bp->b_flags = B_READ; bp->b_cylinder = btodb(HPPA_LIF_VOLSTART) / lp->d_secpercyl; (*strat)(bp); if (biowait(bp)) { if (partoffp) *partoffp = -1; return "LIF volume header I/O error"; } memcpy(&osdep->lifvol, bp->b_data, sizeof(struct hppa_lifvol)); if (osdep->lifvol.vol_id != HPPA_LIF_VOL_ID) { fsoff = 0; } else { struct buf *dbp; struct hppa_lifdir *p; dbp = geteblk(lp->d_secsize); dbp->b_dev = bp->b_dev; /* read LIF directory */ dbp->b_blkno = btodb(HPPA_LIF_DIRSTART); dbp->b_bcount = lp->d_secsize; dbp->b_cflags = BC_BUSY; dbp->b_flags = B_READ; dbp->b_cylinder = (HPPA_LIF_DIRSTART) / lp->d_secpercyl; (*strat)(dbp); if (biowait(dbp)) { if (partoffp) *partoffp = -1; brelse(dbp, BC_INVAL); return "LIF directory I/O error"; } memcpy(osdep->lifdir, dbp->b_data, HPPA_LIF_DIRSIZE); brelse(dbp, BC_INVAL); /* scan for LIF_DIR_FS dir entry */ for (fsoff = -1, p = &osdep->lifdir[0]; fsoff < 0 && p < &osdep->lifdir[HPPA_LIF_NUMDIR]; p++) if (p->dir_type == HPPA_LIF_DIR_FS) fsoff = hppa_lifstodb(p->dir_addr); /* if no suitable lifdir entry found assume 0 */ if (fsoff < 0) fsoff = 0; } if (partoffp) *partoffp = fsoff; return readbsdlabel(bp, strat, 0, fsoff + LABELSECTOR, LABELOFFSET, lp, spoofonly); } /* * Write disk label back to device after modification. */ int writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *osdep) { const char *msg = "no disk label"; struct buf *bp; struct disklabel dl; struct cpu_disklabel cdl; int labeloffset, error, partoff = 0, cyl = 0; /* get a buffer and initialize it */ bp = geteblk((int)lp->d_secsize); bp->b_dev = dev; /* * I once played with the thought of using osdep->label{tag,sector} * as a cache for knowing where (and what) to write. However, now I * think it might be useful to reprobe if someone has written * a newer disklabel of another type with disklabel(8) and -r. */ dl = *lp; msg = readliflabel(bp, strat, &dl, &cdl, &partoff, &cyl, 0); labeloffset = LABELOFFSET; if (msg) { if (partoff == -1) return EIO; /* Write it in the regular place with native byte order. */ labeloffset = LABELOFFSET; bp->b_blkno = partoff + LABELSECTOR; bp->b_cylinder = cyl; bp->b_bcount = lp->d_secsize; } *(struct disklabel *)((char *)bp->b_data + labeloffset) = *lp; bp->b_cflags = BC_BUSY; bp->b_flags = B_WRITE; (*strat)(bp); error = biowait(bp); brelse(bp, BC_INVAL); return (error); }
