363 lines
10 KiB
C
363 lines
10 KiB
C
/* $NetBSD: dkwedge_rdb.c,v 1.8 2021/02/20 09:51:20 rin Exp $ */
|
|
|
|
/*
|
|
* Adapted from arch/amiga/amiga/disksubr.c:
|
|
*
|
|
* 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) 1994 Christian E. Hopps
|
|
*
|
|
* 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.
|
|
*
|
|
* @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: dkwedge_rdb.c,v 1.8 2021/02/20 09:51:20 rin Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/disklabel_rdb.h>
|
|
#include <sys/disk.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/systm.h>
|
|
|
|
/*
|
|
* In /usr/src/sys/dev/scsipi/sd.c, routine sdstart() adjusts the
|
|
* block numbers, it changes from DEV_BSIZE units to physical units:
|
|
* blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
|
|
* As long as media with sector sizes of 512 bytes are used, this
|
|
* doesn't matter (divide by 1), but for successful usage of media with
|
|
* greater sector sizes (e.g. 640MB MO-media with 2048 bytes/sector)
|
|
* we must multiply block numbers with (lp->d_secsize / DEV_BSIZE)
|
|
* to keep "unchanged" physical block numbers.
|
|
*/
|
|
#define SD_C_ADJUSTS_NR
|
|
#ifdef SD_C_ADJUSTS_NR
|
|
#define ADJUST_NR(x) ((x) * (secsize / DEV_BSIZE))
|
|
#else
|
|
#define ADJUST_NR(x) (x)
|
|
#endif
|
|
|
|
static unsigned rdbchksum(void *);
|
|
static unsigned char getarchtype(uint32_t);
|
|
static const char *archtype_to_ptype(uint8_t);
|
|
|
|
static int
|
|
dkwedge_discover_rdb(struct disk *pdk, struct vnode *vp)
|
|
{
|
|
struct dkwedge_info dkw;
|
|
struct partblock *pbp;
|
|
struct rdblock *rbp;
|
|
struct buf *bp;
|
|
int error;
|
|
uint32_t blk_per_cyl, bufsize, newsecsize, nextb, secsize, tabsize;
|
|
const char *ptype;
|
|
uint8_t archtype;
|
|
bool found, root, swap;
|
|
|
|
secsize = DEV_BSIZE << pdk->dk_blkshift;
|
|
bufsize = roundup(MAX(sizeof(struct partblock), sizeof(struct rdblock)),
|
|
secsize);
|
|
bp = geteblk(bufsize);
|
|
|
|
retry:
|
|
/*
|
|
* find the RDB block
|
|
* XXX bsdlabel should be detected by the other method
|
|
*/
|
|
for (nextb = 0; nextb < RDB_MAXBLOCKS; nextb++) {
|
|
error = dkwedge_read(pdk, vp, ADJUST_NR(nextb), bp->b_data,
|
|
bufsize);
|
|
if (error) {
|
|
aprint_error("%s: unable to read RDB @ %u, "
|
|
"error = %d\n", pdk->dk_name, nextb, error);
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
rbp = (struct rdblock *)bp->b_data;
|
|
if (be32toh(rbp->id) == RDBLOCK_ID) {
|
|
if (rdbchksum(rbp) == 0)
|
|
break;
|
|
else
|
|
aprint_error("%s: RDB bad checksum @ %u\n",
|
|
pdk->dk_name, nextb);
|
|
}
|
|
}
|
|
|
|
if (nextb == RDB_MAXBLOCKS) {
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
|
|
newsecsize = be32toh(rbp->nbytes);
|
|
if (secsize != newsecsize) {
|
|
aprint_verbose("secsize changed from %u to %u\n",
|
|
secsize, newsecsize);
|
|
secsize = newsecsize;
|
|
bufsize = roundup(MAX(sizeof(struct partblock),
|
|
sizeof(struct rdblock)), secsize);
|
|
brelse(bp, 0);
|
|
bp = geteblk(bufsize);
|
|
goto retry;
|
|
}
|
|
|
|
memset(&dkw, 0, sizeof(dkw));
|
|
|
|
strlcpy(dkw.dkw_parent, pdk->dk_name, sizeof(dkw.dkw_parent));
|
|
|
|
found = root = swap = false;
|
|
/*
|
|
* scan for partition blocks
|
|
*/
|
|
for (nextb = be32toh(rbp->partbhead); nextb != RDBNULL;
|
|
nextb = be32toh(pbp->next)) {
|
|
error = dkwedge_read(pdk, vp, ADJUST_NR(nextb), bp->b_data,
|
|
bufsize);
|
|
if (error) {
|
|
aprint_error("%s: unable to read RDB partition block @ "
|
|
"%u, error = %d\n", pdk->dk_name, nextb, error);
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
pbp = (struct partblock *)bp->b_data;
|
|
|
|
if (be32toh(pbp->id) != PARTBLOCK_ID) {
|
|
aprint_error(
|
|
"%s: RDB partition block @ %u bad id\n",
|
|
pdk->dk_name, nextb);
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
if (rdbchksum(pbp)) {
|
|
aprint_error(
|
|
"%s: RDB partition block @ %u bad checksum\n",
|
|
pdk->dk_name, nextb);
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
|
|
tabsize = be32toh(pbp->e.tabsize);
|
|
if (tabsize < 11) {
|
|
/*
|
|
* not enough info, too funky for us.
|
|
* I don't want to skip I want it fixed.
|
|
*/
|
|
aprint_error(
|
|
"%s: RDB partition block @ %u bad partition info "
|
|
"(environ < 11)\n",
|
|
pdk->dk_name, nextb);
|
|
error = ESRCH;
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
* XXXX should be ">" however some vendors don't know
|
|
* what a table size is so, we hack for them.
|
|
* the other checks can fail for all I care but this
|
|
* is a very common value. *sigh*.
|
|
*/
|
|
if (tabsize >= 16)
|
|
archtype = getarchtype(be32toh(pbp->e.dostype));
|
|
else
|
|
archtype = ADT_UNKNOWN;
|
|
|
|
switch (archtype) {
|
|
case ADT_NETBSDROOT:
|
|
if (root) {
|
|
aprint_error("%s: more than one root RDB "
|
|
"partition, ignoring\n", pdk->dk_name);
|
|
continue;
|
|
}
|
|
root = true;
|
|
break;
|
|
case ADT_NETBSDSWAP:
|
|
if (swap) {
|
|
aprint_error("%s: more than one swap RDB "
|
|
"partition , ignoring\n", pdk->dk_name);
|
|
continue;
|
|
}
|
|
swap = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (pbp->partname[0] + 1 < sizeof(pbp->partname))
|
|
pbp->partname[pbp->partname[0] + 1] = 0;
|
|
else
|
|
pbp->partname[sizeof(pbp->partname) - 1] = 0;
|
|
strlcpy(dkw.dkw_wname, pbp->partname + 1,
|
|
sizeof(dkw.dkw_wname));
|
|
|
|
ptype = archtype_to_ptype(archtype);
|
|
strlcpy(dkw.dkw_ptype, ptype, sizeof(dkw.dkw_ptype));
|
|
|
|
blk_per_cyl =
|
|
be32toh(pbp->e.secpertrk) * be32toh(pbp->e.numheads)
|
|
* ((be32toh(pbp->e.sizeblock) << 2) / secsize);
|
|
dkw.dkw_size = (uint64_t)(be32toh(pbp->e.highcyl)
|
|
- be32toh(pbp->e.lowcyl) + 1) * blk_per_cyl;
|
|
dkw.dkw_offset = (daddr_t)be32toh(pbp->e.lowcyl) * blk_per_cyl;
|
|
|
|
error = dkwedge_add(&dkw);
|
|
if (error == EEXIST) {
|
|
aprint_error(
|
|
"%s: wedge named '%s' already exists, ignoring\n",
|
|
pdk->dk_name, dkw.dkw_wname);
|
|
} else if (error)
|
|
aprint_error("%s: error %d adding partition %s\n",
|
|
pdk->dk_name, error, dkw.dkw_wname);
|
|
else
|
|
found = true;
|
|
}
|
|
|
|
if (found)
|
|
error = 0;
|
|
else
|
|
error = ESRCH;
|
|
done:
|
|
brelse(bp, 0);
|
|
return error;
|
|
}
|
|
|
|
static uint32_t
|
|
rdbchksum(void *bdata)
|
|
{
|
|
uint32_t *blp, cnt, val;
|
|
|
|
blp = bdata;
|
|
cnt = be32toh(blp[1]);
|
|
val = 0;
|
|
|
|
while (cnt--)
|
|
val += be32toh(*blp++);
|
|
return val;
|
|
}
|
|
|
|
static uint8_t
|
|
getarchtype(uint32_t dostype)
|
|
{
|
|
uint32_t t3, b1;
|
|
|
|
t3 = dostype & 0xffffff00;
|
|
b1 = dostype & 0x000000ff;
|
|
|
|
switch (t3) {
|
|
case DOST_NBR:
|
|
return ADT_NETBSDROOT;
|
|
case DOST_NBS:
|
|
return ADT_NETBSDSWAP;
|
|
case DOST_NBU:
|
|
return ADT_NETBSDUSER;
|
|
case DOST_MUFS: /* check for 'muFS'? */
|
|
case DOST_DOS:
|
|
return ADT_AMIGADOS;
|
|
case DOST_AMIX:
|
|
return ADT_AMIX;
|
|
|
|
case DOST_XXXBSD:
|
|
#ifdef DIAGNOSTIC
|
|
aprint_verbose("deprecated dostype found: 0x%x\n",
|
|
dostype);
|
|
#endif
|
|
switch (b1) {
|
|
case 'R':
|
|
return ADT_NETBSDROOT;
|
|
case 'S':
|
|
return ADT_NETBSDSWAP;
|
|
default:
|
|
return ADT_NETBSDUSER;
|
|
}
|
|
|
|
case DOST_EXT2:
|
|
return ADT_EXT2;
|
|
case DOST_RAID:
|
|
return ADT_RAID;
|
|
default:
|
|
#ifdef DIAGNOSTIC
|
|
aprint_verbose("warning unknown dostype: 0x%x\n",
|
|
dostype);
|
|
#endif
|
|
return ADT_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
static const char *
|
|
archtype_to_ptype(unsigned char archtype)
|
|
{
|
|
|
|
switch (archtype) {
|
|
case ADT_NETBSDROOT:
|
|
case ADT_NETBSDUSER:
|
|
return DKW_PTYPE_FFS;
|
|
case ADT_NETBSDSWAP:
|
|
return DKW_PTYPE_SWAP;
|
|
case ADT_AMIGADOS:
|
|
return DKW_PTYPE_AMIGADOS;
|
|
case ADT_EXT2:
|
|
return DKW_PTYPE_EXT2FS;
|
|
default:
|
|
return DKW_PTYPE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
#ifdef _KERNEL
|
|
DKWEDGE_DISCOVERY_METHOD_DECL(RDB, 15, dkwedge_discover_rdb);
|
|
#endif
|