NetBSD-5.0.2/sys/arch/sgimips/sgimips/disksubr.c
/* $NetBSD: disksubr.c,v 1.23 2008/01/02 11:48:28 ad Exp $ */
/*
* Copyright (c) 2001 Christopher Sekiya
* Copyright (c) 2001 Wayne Knowles
* Copyright (c) 2000 Soren S. Jorvang
* 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 for the
* NetBSD Project. See http://www.NetBSD.org/ for
* information about NetBSD.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: disksubr.c,v 1.23 2008/01/02 11:48:28 ad Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <ufs/ufs/dinode.h>
#include <ufs/ffs/fs.h>
#include <machine/disklabel.h>
static int disklabel_bsd_to_sgimips(struct disklabel *lp,
struct sgi_boot_block *vh);
static const char *disklabel_sgimips_to_bsd(struct sgi_boot_block *vh,
struct disklabel *lp);
int mipsvh_cksum(struct sgi_boot_block *vhp);
#define LABELSIZE(lp) ((char *)&lp->d_partitions[lp->d_npartitions] - \
(char *)lp)
/*
* 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 sgi_boot_block *slp;
int err;
/* 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;
/* Obtain buffer to probe drive with. */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
(*strat)(bp);
err = biowait(bp);
brelse(bp, 0);
if (err)
return "error reading disklabel";
/* Check for NetBSD label in second sector */
dlp = (struct disklabel *)((char *)bp->b_data + LABELOFFSET);
if (dlp->d_magic == DISKMAGIC)
if (!dkcksum(dlp)) {
memcpy(lp, dlp, LABELSIZE(dlp));
return NULL; /* NetBSD label found */
}
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = 0;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
(*strat)(bp);
err = biowait(bp);
brelse(bp, 0);
if (err)
return "error reading volume header";
/* Check for a SGI label. */
slp = (struct sgi_boot_block *)bp->b_data;
if (be32toh(slp->magic) != SGI_BOOT_BLOCK_MAGIC)
return "no disk label";
return disklabel_sgimips_to_bsd(slp, lp);
}
int
setdisklabel(struct disklabel *olp, struct disklabel *nlp, unsigned long openmask, struct cpu_disklabel *clp)
{
register int i;
register struct partition *opp, *npp;
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);
}
#define dkpart(dev) (minor(dev) & 07)
#define dkminor(unit, part) (((unit) << 3) | (part))
int
writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp, struct cpu_disklabel *clp)
{
struct buf *bp;
int labelpart;
int error;
labelpart = dkpart(dev);
if (lp->d_partitions[labelpart].p_offset != 0) {
if (lp->d_partitions[0].p_offset != 0)
return (EXDEV); /* not quite right */
labelpart = 0;
}
/* Read sgimips volume header before merging NetBSD partition info */
bp = geteblk((int)lp->d_secsize);
bp->b_dev = dev;
bp->b_blkno = 0;
bp->b_bcount = lp->d_secsize;
bp->b_flags |= B_READ;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
(*strat)(bp);
if((error = biowait(bp)) != 0)
goto ioerror;
if ((error = disklabel_bsd_to_sgimips(lp, (void *)bp->b_data)) != 0)
goto ioerror;
/* Write sgimips label to first sector */
bp->b_oflags &= ~(BO_DONE);
bp->b_flags &= ~(B_READ);
bp->b_flags |= B_WRITE;
(*strat)(bp);
if ((error = biowait(bp)) != 0)
goto ioerror;
/* Write NetBSD disk label to second sector */
memset(bp->b_data, 0, lp->d_secsize);
memcpy(bp->b_data, lp, sizeof(*lp));
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
bp->b_oflags &= ~(BO_DONE);
bp->b_flags &= ~(B_READ);
bp->b_flags |= B_WRITE;
(*strat)(bp);
error = biowait(bp);
ioerror:
brelse(bp, 0);
return error;
}
struct partitionmap {
int mips_part; /* sgimips partition number */
int mips_type; /* sgimips partition type */
int bsd_part; /* BSD partition number */
int bsd_type; /* BSD partition type */
};
struct partitionmap partition_map[] = {
/* slice sgimips type BSD BSD Type */
{0, SGI_PTYPE_BSD, 0, FS_BSDFFS},
{1, SGI_PTYPE_RAW, 1, FS_SWAP},
{2, SGI_PTYPE_BSD, 10, FS_BSDFFS},
{3, SGI_PTYPE_BSD, 3, FS_BSDFFS},
{4, SGI_PTYPE_BSD, 4, FS_BSDFFS},
{5, SGI_PTYPE_BSD, 5, FS_BSDFFS},
{6, SGI_PTYPE_BSD, 6, FS_BSDFFS},
{7, SGI_PTYPE_BSD, 7, FS_BSDFFS},
{8, SGI_PTYPE_VOLHDR, 8, FS_OTHER},
{9, SGI_PTYPE_BSD, 9, FS_BSDFFS},
{10, SGI_PTYPE_VOLUME, 2, FS_OTHER},
{11, SGI_PTYPE_BSD, 11, FS_BSDFFS},
{12, SGI_PTYPE_BSD, 12, FS_BSDFFS},
{13, SGI_PTYPE_BSD, 13, FS_BSDFFS},
{14, SGI_PTYPE_BSD, 14, FS_BSDFFS},
{15, SGI_PTYPE_BSD, 15, FS_BSDFFS}
};
#define NPARTMAP (sizeof(partition_map)/sizeof(struct partitionmap))
/*
* Convert a sgimips disk label into a NetBSD disk label.
*
* Returns NULL on success, otherwise an error string
*/
static const char *
disklabel_sgimips_to_bsd(struct sgi_boot_block *vh, struct disklabel *lp)
{
int i, bp, mp;
struct partition *lpp;
if (mipsvh_cksum(vh))
return ("sgimips disk label corrupted");
#if 0 /* ARCS ignores dp_secbytes and it may be wrong; use default instead */
lp->d_secsize = vh->dp.dp_secbytes;
#endif
lp->d_nsectors = vh->dp.dp_secs;
lp->d_ntracks = vh->dp.dp_trks0;
lp->d_ncylinders = vh->dp.dp_cyls;
lp->d_interleave = vh->dp.dp_interleave;
lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
lp->d_bbsize = BBSIZE;
lp->d_sbsize = SBLOCKSIZE;
lp->d_npartitions = MAXPARTITIONS;
for (i = 0; i < 16; i++) {
mp = partition_map[i].mips_part;
bp = partition_map[i].bsd_part;
lpp = &lp->d_partitions[bp];
lpp->p_offset = vh->partitions[mp].first;
/* XXX ARCS ignores dp_secbytes on calculating offsets */
if (lp->d_secsize > DEV_BSIZE)
lpp->p_offset /= lp->d_secsize / DEV_BSIZE;
lpp->p_size = vh->partitions[mp].blocks;
lpp->p_fstype = partition_map[i].bsd_type;
if (lpp->p_fstype == FS_BSDFFS) {
lpp->p_fsize = 1024;
lpp->p_frag = 8;
lpp->p_cpg = 16;
}
}
return NULL;
}
/*
* Convert a NetBSD disk label into a sgimips disk label.
*
* Returns NULL on success, otherwise an error string
*/
static int
disklabel_bsd_to_sgimips(struct disklabel *lp, struct sgi_boot_block *vh)
{
int i, bp, mp;
struct partition *lpp;
if (vh->magic != SGI_BOOT_BLOCK_MAGIC || mipsvh_cksum(vh) != 0) {
memset((void *)vh, 0, sizeof *vh);
vh->magic = SGI_BOOT_BLOCK_MAGIC;
vh->root = 0; /* a*/
vh->swap = 1; /* b*/
}
strcpy(vh->bootfile, "/netbsd");
vh->dp.dp_skew = lp->d_trackskew;
vh->dp.dp_gap1 = 1; /* XXX */
vh->dp.dp_gap2 = 1; /* XXX */
vh->dp.dp_cyls = lp->d_ncylinders;
vh->dp.dp_shd0 = 0;
vh->dp.dp_trks0 = lp->d_ntracks;
vh->dp.dp_secs = lp->d_nsectors;
#if 0 /* ARCS ignores dp_secbytes; leave it default */
vh->dp.dp_secbytes = lp->d_secsize;
#else
vh->dp.dp_secbytes = SGI_BOOT_BLOCK_BLOCKSIZE;
#endif
vh->dp.dp_interleave = lp->d_interleave;
vh->dp.dp_nretries = 22;
for (i = 0; i < 16; i++) {
mp = partition_map[i].mips_part;
bp = partition_map[i].bsd_part;
lpp = &lp->d_partitions[bp];
vh->partitions[mp].first = lpp->p_offset;
/* XXX ARCS ignores dp_secbytes on calculating offsets */
if (lp->d_secsize > SGI_BOOT_BLOCK_BLOCKSIZE)
vh->partitions[mp].first *=
lp->d_secsize / SGI_BOOT_BLOCK_BLOCKSIZE;
vh->partitions[mp].blocks = lpp->p_size;
vh->partitions[mp].type = partition_map[i].mips_type;
}
/*
* Create a fake partition for bootstrap code (or SASH)
*/
vh->partitions[8].first = 0;
vh->partitions[8].blocks = vh->partitions[vh->root].first +
BBSIZE / vh->dp.dp_secbytes;
vh->partitions[8].type = SGI_PTYPE_VOLHDR;
vh->checksum = 0;
vh->checksum = -mipsvh_cksum(vh);
return 0;
}
/*
* Compute checksum for MIPS disk volume header
*
* Mips volume header checksum is the 32bit 2's complement sum
* of the entire volume header structure
*/
int
mipsvh_cksum(struct sgi_boot_block *vhp)
{
int i, *ptr;
int cksum = 0;
ptr = (int *)vhp;
i = sizeof(*vhp) / sizeof(*ptr);
while (i--)
cksum += *ptr++;
return cksum;
}