31e40c8ce1
MIPS32 4Kc CPU board, with support for the MIPS64 5Kc and the QED RM5261 CPU boards to follow. The cs4281 audio hasn't been tested, there are some interrupt problems with onboard the pciide, but all other on-board peripherals work. The evbmips port will support more MIPS evaluation boards in the future.
285 lines
8.1 KiB
C
285 lines
8.1 KiB
C
/* $NetBSD: disksubr.c,v 1.1 2002/03/07 14:44:03 simonb 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. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. 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.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/disklabel.h>
|
|
#include <sys/disk.h>
|
|
|
|
/*
|
|
* Attempt to read a disk label from a device
|
|
* using the indicated stategy routine.
|
|
* The label must be partly set up before this:
|
|
* secpercyl and anything required in the strategy routine
|
|
* (e.g., sector size) must be filled in before calling us.
|
|
* Returns null on success and an error string on failure.
|
|
*/
|
|
char *
|
|
readdisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
|
|
struct cpu_disklabel *clp)
|
|
{
|
|
struct buf *bp;
|
|
struct disklabel *dlp;
|
|
struct dkbad *bdp;
|
|
char *msg = NULL;
|
|
int i;
|
|
|
|
/* minimal requirements for archtypal disk label */
|
|
if (lp->d_secsize == 0)
|
|
lp->d_secsize = DEV_BSIZE;
|
|
if (lp->d_secperunit == 0)
|
|
lp->d_secperunit = 0x1fffffff;
|
|
lp->d_npartitions = RAW_PART + 1;
|
|
if (lp->d_partitions[RAW_PART].p_size == 0)
|
|
lp->d_partitions[RAW_PART].p_size =
|
|
lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
|
|
lp->d_partitions[RAW_PART].p_offset = 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 */
|
|
if (biowait(bp)) {
|
|
msg = "disk label read error";
|
|
goto done;
|
|
}
|
|
|
|
for (dlp = (struct disklabel *)bp->b_data;
|
|
dlp <= (struct disklabel *)(bp->b_data + lp->d_secsize - sizeof(*dlp));
|
|
dlp = (struct disklabel *)((char *)dlp + sizeof(long))) {
|
|
if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
|
|
if (msg == NULL)
|
|
msg = "no disk label";
|
|
} else if (dlp->d_npartitions > MAXPARTITIONS ||
|
|
dkcksum(dlp) != 0)
|
|
msg = "disk label corrupted";
|
|
else {
|
|
*lp = *dlp;
|
|
msg = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (msg)
|
|
goto done;
|
|
|
|
/* obtain bad sector table if requested and present */
|
|
if (clp && (bdp = &clp->bad) != NULL && (lp->d_flags & D_BADSECT)) {
|
|
struct dkbad *db;
|
|
|
|
i = 0;
|
|
do {
|
|
/* read a bad sector table */
|
|
bp->b_flags &= ~(B_DONE);
|
|
bp->b_flags |= B_READ;
|
|
bp->b_blkno = lp->d_secperunit - lp->d_nsectors + i;
|
|
if (lp->d_secsize > DEV_BSIZE)
|
|
bp->b_blkno *= lp->d_secsize / DEV_BSIZE;
|
|
else
|
|
bp->b_blkno /= DEV_BSIZE / lp->d_secsize;
|
|
bp->b_bcount = lp->d_secsize;
|
|
bp->b_cylinder = lp->d_ncylinders - 1;
|
|
(*strat)(bp);
|
|
|
|
/* if successful, validate, otherwise try another */
|
|
if (biowait(bp)) {
|
|
msg = "bad sector table I/O error";
|
|
} else {
|
|
db = (struct dkbad *)(bp->b_data);
|
|
#define DKBAD_MAGIC 0x4321
|
|
if (db->bt_mbz == 0
|
|
&& db->bt_flag == DKBAD_MAGIC) {
|
|
msg = NULL;
|
|
*bdp = *db;
|
|
break;
|
|
} else
|
|
msg = "bad sector table corrupted";
|
|
}
|
|
} while ((bp->b_flags & B_ERROR) && (i += 2) < 10 &&
|
|
i < lp->d_nsectors);
|
|
}
|
|
|
|
done:
|
|
brelse(bp);
|
|
return (msg);
|
|
}
|
|
|
|
/*
|
|
* Check new disk label for sensibility before setting it.
|
|
*/
|
|
int
|
|
setdisklabel(struct disklabel *olp, struct disklabel *nlp, u_long openmask,
|
|
struct cpu_disklabel *clp)
|
|
{
|
|
int i;
|
|
struct partition *opp, *npp;
|
|
|
|
/* sanity clause */
|
|
if (nlp->d_secpercyl == 0 || nlp->d_secsize == 0 ||
|
|
(nlp->d_secsize % DEV_BSIZE) != 0)
|
|
return(EINVAL);
|
|
|
|
#ifdef notdef
|
|
/* XXX WHY WAS THIS HERE?! */
|
|
/* special case to allow disklabel to be invalidated */
|
|
if (nlp->d_magic == 0xffffffff) {
|
|
*olp = *nlp;
|
|
return (0);
|
|
}
|
|
#endif
|
|
|
|
if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC ||
|
|
dkcksum(nlp) != 0)
|
|
return (EINVAL);
|
|
|
|
while ((i = ffs(openmask)) != 0) {
|
|
i--;
|
|
openmask &= ~(1 << i);
|
|
if (nlp->d_npartitions <= i)
|
|
return (EBUSY);
|
|
opp = &olp->d_partitions[i];
|
|
npp = &nlp->d_partitions[i];
|
|
if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size)
|
|
return (EBUSY);
|
|
/*
|
|
* Copy internally-set partition information
|
|
* if new label doesn't include it. XXX
|
|
*/
|
|
if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) {
|
|
npp->p_fstype = opp->p_fstype;
|
|
npp->p_fsize = opp->p_fsize;
|
|
npp->p_frag = opp->p_frag;
|
|
npp->p_cpg = opp->p_cpg;
|
|
}
|
|
}
|
|
nlp->d_checksum = 0;
|
|
nlp->d_checksum = dkcksum(nlp);
|
|
*olp = *nlp;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Write disk label back to device after modification.
|
|
* this means write out the Rigid disk blocks to represent the
|
|
* label. Hope the user was carefull.
|
|
*/
|
|
int
|
|
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp,
|
|
struct cpu_disklabel *clp)
|
|
{
|
|
struct buf *bp;
|
|
struct disklabel *dlp;
|
|
int error = 0;
|
|
|
|
bp = geteblk((int)lp->d_secsize);
|
|
bp->b_dev = dev;
|
|
bp->b_blkno = LABELSECTOR;
|
|
bp->b_cylinder = 0;
|
|
bp->b_bcount = lp->d_secsize;
|
|
bp->b_flags |= B_READ; /* get current label */
|
|
(*strat)(bp);
|
|
if ((error = biowait(bp)) != 0)
|
|
goto done;
|
|
|
|
dlp = (struct disklabel *)(bp->b_data + LABELOFFSET);
|
|
*dlp = *lp; /* struct assignment */
|
|
|
|
bp->b_flags &= ~(B_READ|B_DONE);
|
|
bp->b_flags |= B_WRITE;
|
|
(*strat)(bp);
|
|
error = biowait(bp);
|
|
|
|
done:
|
|
brelse(bp);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Determine the size of the transfer, and make sure it is
|
|
* within the boundaries of the partition. Adjust transfer
|
|
* if needed, and signal errors or early completion.
|
|
*/
|
|
int
|
|
bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
|
|
{
|
|
struct partition *p = lp->d_partitions + DISKPART(bp->b_dev);
|
|
int labelsector = lp->d_partitions[RAW_PART].p_offset + LABELSECTOR;
|
|
int maxsz = p->p_size;
|
|
int sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
|
|
|
|
/* Overwriting disk label? */
|
|
/* XXX should also protect bootstrap in first 8K */
|
|
if (bp->b_blkno + p->p_offset <= labelsector &&
|
|
#if LABELSECTOR != 0
|
|
bp->b_blkno + p->p_offset + sz > labelsector &&
|
|
#endif
|
|
(bp->b_flags & B_READ) == 0 && wlabel == 0) {
|
|
bp->b_error = EROFS;
|
|
goto bad;
|
|
}
|
|
|
|
/* beyond partition? */
|
|
if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) {
|
|
/* if exactly at end of disk, return an EOF */
|
|
if (bp->b_blkno == maxsz) {
|
|
bp->b_resid = bp->b_bcount;
|
|
return(0);
|
|
}
|
|
/* or truncate if part of it fits */
|
|
sz = maxsz - bp->b_blkno;
|
|
if (sz <= 0) {
|
|
bp->b_error = EINVAL;
|
|
goto bad;
|
|
}
|
|
bp->b_bcount = sz << DEV_BSHIFT;
|
|
}
|
|
|
|
/* calculate cylinder for disksort to order transfers with */
|
|
bp->b_resid = (bp->b_blkno + p->p_offset) / lp->d_secpercyl;
|
|
return (1);
|
|
bad:
|
|
bp->b_flags |= B_ERROR;
|
|
return (0);
|
|
}
|