Attachment #164376 for bug #205424

View | Details | Raw Unified | Return to bug 205424
Collapse All | Expand All




/*
 * BIOS disk device handling.
 *
 * Ideas and algorithms from:
 *
 * - NetBSD libi386/biosdisk.c

{
    u_int	x, sec, result, resid, retry, maxfer;
    caddr_t	p, xp, bbuf, breg;

    /* Just in case some idiot actually tries to read/write -1 blocks... */
    if (blks < 0)
	return (-1);

	(VTOP(dest) >> 16) != (VTOP(dest +
	blks * BD(dev).bd_sectorsize) >> 16))) {
	/*
	 * There is a 64k physical boundary somewhere in the
	 * destination buffer, or the destination buffer is above
	 * first 1MB of physical memory so we have to arrange a

	breg = bbuf = NULL;
	maxfer = 0;
    }

    while (resid > 0) {
	/*
	 * Play it safe and don't cross track boundaries.

	/*
	 * Put your Data In, Put your Data out,
	 * Put your Data In, and shake it all about
	 */
	if (write && bbuf != NULL)
	    bcopy(p, breg, x * BD(dev).bd_sectorsize);




#include <machine/bootinfo.h>
#include <machine/elf.h>
#include <machine/pc/bios.h>
#include <machine/psl.h>
#include <stdarg.h>
#include <stddef.h>

	n = size;
	if (*offp + n > zp->zp_size)
		n = zp->zp_size - *offp;

	rc = dnode_read(spa, dnode, *offp, start, n);
	if (rc)
		return (-1);

	v86.es = VTOPSEG(&smap);
	v86.edi = VTOPOFF(&smap);
	v86int();
	if ((v86.efl & PCL_C) || (v86.eax != SMAP_SIG))
	    break;
	/* look for a low-memory segment that's large enough */
	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&

	v86.ctl = 0;
	v86.addr = 0x12;		/* int 0x12 */
	v86int();

	bios_basemem = (v86.eax & 0xffff) * 1024;
    }

	v86.addr = 0x15;		/* int 0x15 function 0xe801*/
	v86.eax = 0xe801;
	v86int();
	if (!(v86.efl & PSL_C)) {
	    bios_extmem = ((v86.ecx & 0xffff) + ((v86.edx & 0xffff) * 64)) * 1024;
	}
    }

	high_heap_size = HEAP_MIN;
	high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;
    }
}
/*
 * Try to detect a device supported by the legacy int13 BIOS

    v86.eax = 0x800;
    v86.edx = drive;
    v86int();

    if (!(v86.efl & PSL_C) &&				/* carry clear */
	((v86.edx & 0xff) != (drive & DRV_MASK))) {	/* unit # OK */
	if ((v86.ecx & 0x3f) == 0) {			/* absurd sector size */
		return(0);				/* skip device */

Lines 26-31 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/boot/pc98/boot2/boot2.c (-1 / +2 lines)
26	#include <machine/bootinfo.h>	26	#include <machine/bootinfo.h>
27	#include <machine/cpufunc.h>	27	#include <machine/cpufunc.h>
28	#include <machine/elf.h>	28	#include <machine/elf.h>
		29	#include <machine/psl.h>
29	#include <stdarg.h>	30	#include <stdarg.h>
Lines 327-333 bd_getbigeom(int bunit) Link Here
327	v86.addr = 0x1b;	328	v86.addr = 0x1b;
328	v86.eax = 0x8400 \| unit;	329	v86.eax = 0x8400 \| unit;
329	v86int();	330	v86int();
330	if (v86.efl & 0x1)	331	if (v86.efl & PSL_C)
331	return 0x4F020F; /* 1200KB FD C:80 H:2 S:15 */	332	return 0x4F020F; /* 1200KB FD C:80 H:2 S:15 */
332	return ((v86.ecx & 0xffff) << 16) \| (v86.edx & 0xffff);	333	return ((v86.ecx & 0xffff) << 16) \| (v86.edx & 0xffff);
333	}	334	}




/*
 * BIOS disk device handling.
 *
 * Ideas and algorithms from:
 *
 * - NetBSD libi386/biosdisk.c

#include <sys/disklabel.h>
#include <sys/diskpc98.h>
#include <machine/bootinfo.h>
#include <machine/psl.h>
#include <stdarg.h>

static void	bd_print(int verbose);
struct devsw biosdisk = {
    "disk",
    DEVT_DISK,
    bd_init,
    bd_strategy,
    bd_open,
    bd_close,
    noioctl,
    bd_print,
    NULL

bd_bios2unit(int biosdev)
{
    int		i;

    DEBUG("looking for bios device 0x%x", biosdev);
    for (i = 0; i < nbdinfo; i++) {
	DEBUG("bd unit %d is BIOS device 0x%x", i, bdinfo[i].bd_unit);

    return(-1);
}
/*
 * Quiz the BIOS for disk devices, save a little info about them.
 */
static int
bd_init(void)
{
    int		base, unit;
    int		da_drive=0, n=-0x10;

		    bdinfo[nbdinfo].bd_da_unit = da_drive++;
	    }
	    /* XXX we need "disk aliases" to make this simpler */
	    printf("BIOS drive %c: is disk%d\n",
		   'A' + nbdinfo, nbdinfo);
	    nbdinfo++;
	}

    struct i386_devdesc		dev;
    struct open_disk		*od;
    struct pc98_partition	*dptr;

    for (i = 0; i < nbdinfo; i++) {
	sprintf(line, "    disk%d:   BIOS drive %c:\n", i, 'A' + i);
	pager_output(line);

	dev.d_unit = i;
	dev.d_kind.biosdisk.slice = -1;
	dev.d_kind.biosdisk.partition = -1;

	if (!bd_opendisk(&od, &dev)) {
	    /* Do we have a partition table? */

	pager_output(line);
	return;
    }

    /* Print partitions */
    for (i = 0; i < lp->d_npartitions; i++) {
	/*

	if ((lp->d_partitions[i].p_fstype == FS_BSDFFS) ||
            (lp->d_partitions[i].p_fstype == FS_SWAP) ||
            (lp->d_partitions[i].p_fstype == FS_VINUM) ||
	    ((lp->d_partitions[i].p_fstype == FS_UNUSED) &&
	     (od->od_flags & BD_FLOPPY) && (i == 0))) {
	    /* Only print out statistics in verbose mode */
	    if (verbose)
	        sprintf(line, "  %s%c: %s %s (%d - %d)\n", prefix, 'a' + i,
		    (lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap " :
		    (lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
		    "FFS  ",
		    display_size(lp->d_partitions[i].p_size),

		    lp->d_partitions[i].p_offset + lp->d_partitions[i].p_size);
	    else
	        sprintf(line, "  %s%c: %s\n", prefix, 'a' + i,
		    (lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" :
		    (lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
		    "FFS");
	    pager_output(line);

 *  sliced - are they after the first BSD slice, or the DOS
 *  slice before it?)
 */
static int
bd_open(struct open_file *f, ...)
{
    va_list			ap;

    va_end(ap);
    if ((error = bd_opendisk(&od, dev)))
	return(error);

    /*
     * Save our context
     */

	DEBUG("attempt to open nonexistent disk");
	return(ENXIO);
    }

    od = (struct open_disk *)malloc(sizeof(struct open_disk));
    if (!od) {
	DEBUG("no memory");

    od->od_boff = 0;
    error = 0;
    DEBUG("open '%s', unit 0x%x slice %d partition %d",
	     i386_fmtdev(dev), dev->d_unit,
	     dev->d_kind.biosdisk.slice, dev->d_kind.biosdisk.partition);
    /* Get geometry for this open (removable device may have changed) */

    /* Determine disk layout. */
    error = bd_open_pc98(od, dev);

 out:
    if (error) {
	free(od);

	return (EIO);
    }
    /*
     * Check the slice table magic.
     */
    if (((u_char)buf[0x1fe] != 0x55) || ((u_char)buf[0x1ff] != 0xaa)) {

	dev->d_kind.biosdisk.partition = 0;
 unsliced:
    /*
     * Now we have the slice offset, look for the partition in the disklabel if we have
     * a partition to start with.
     *

	od->od_boff = sector;		/* no partition, must be after the slice */
	DEBUG("opening raw slice");
    } else {

	if (bd_read(od, sector + LABELSECTOR, 1, buf)) {
	    DEBUG("error reading disklabel");
	    return (EIO);

	    !(od->od_flags & BD_FLOPPY))
	    DEBUG("warning, partition marked as unused");
#endif

	od->od_boff =
		lp->d_partitions[dev->d_kind.biosdisk.partition].p_offset -
		lp->d_partitions[RAW_PART].p_offset +
		sector;

	struct pc98_partition *dp;
	int pref, preflevel;
	int i, prefslice;

	prefslice = 0;
	preflevel = PREF_NONE;

	}
	return (prefslice);
}

static int
bd_close(struct open_file *f)
{
    struct open_disk	*od = (struct open_disk *)(((struct i386_devdesc *)(f->f_devdata))->d_kind.biosdisk.data);

    free(od);
}
static int
bd_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
{
    struct bcache_devdata	bcd;

    return(bcache_strategy(&bcd, od->od_unit, rw, dblk+od->od_boff, size, buf, rsize));
}
static int
bd_realstrategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
{
    struct open_disk	*od = (struct open_disk *)(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);

    v86.es = VTOPSEG(dest);
    v86.ebp = VTOPOFF(dest);
    v86int();
    return (v86.efl & PSL_C);
}
static int

{
    u_int	x, sec, result, resid, retry, maxfer;
    caddr_t	p, xp, bbuf, breg;

    /* Just in case some idiot actually tries to read/write -1 blocks... */
    if (blks < 0)
	return (-1);

    if (VTOP(dest) >> 20 != 0 ||
	((VTOP(dest) >> 16) != (VTOP(dest + blks * BIOSDISK_SECSIZE) >> 16))) {
	/*
	 * There is a 64k physical boundary somewhere in the
	 * destination buffer, or the destination buffer is above
	 * first 1MB of physical memory so we have to arrange a

	breg = bbuf = NULL;
	maxfer = 0;
    }

    while (resid > 0) {
	/*
	 * Play it safe and don't cross track boundaries.

	/*
	 * Put your Data In, Put your Data out,
	 * Put your Data In, and shake it all about
	 */
	if (write && bbuf != NULL)
	    bcopy(p, breg, x * BIOSDISK_SECSIZE);

	v86.addr = 0x1b;
	v86.eax = 0x8400 | od->od_unit;
	v86int();

	od->od_cyl = v86.ecx;
	od->od_hds = (v86.edx >> 8) & 0xff;
	od->od_sec = v86.edx & 0xff;
	if (v86.efl & PSL_C)
	    return(1);
    }

    v86.addr = 0x1b;
    v86.eax = 0x8400 | unit;
    v86int();
    if (v86.efl & PSL_C)
	return 0x4F020F;	/* 1200KB FD C:80 H:2 S:15 */
    return ((v86.ecx & 0xffff) << 16) | (v86.edx & 0xffff);
}
-

Return to bug 205424

Lines 28-33 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/boot/i386/zfsboot/zfsboot.c (-7 / +8 lines)
28	#include <machine/bootinfo.h>	28	#include <machine/bootinfo.h>
29	#include <machine/elf.h>	29	#include <machine/elf.h>
30	#include <machine/pc/bios.h>	30	#include <machine/pc/bios.h>
		31	#include <machine/psl.h>
31	#include <stdarg.h>	32	#include <stdarg.h>
32	#include <stddef.h>	33	#include <stddef.h>
Lines 163-169 zfs_read(spa_t spa, const dnode_phys_t dnode, off_t offp, void start, size_t Link Here
163	n = size;	164	n = size;
164	if (*offp + n > zp->zp_size)	165	if (*offp + n > zp->zp_size)
165	n = zp->zp_size - *offp;	166	n = zp->zp_size - *offp;
166		167
167	rc = dnode_read(spa, dnode, *offp, start, n);	168	rc = dnode_read(spa, dnode, *offp, start, n);
168	if (rc)	169	if (rc)
169	return (-1);	170	return (-1);
Lines 238-244 bios_getmem(void) Link Here
238	v86.es = VTOPSEG(&smap);	239	v86.es = VTOPSEG(&smap);
239	v86.edi = VTOPOFF(&smap);	240	v86.edi = VTOPOFF(&smap);
240	v86int();	241	v86int();
241	if ((v86.efl & 1) \|\| (v86.eax != SMAP_SIG))	242	if ((v86.efl & PCL_C) \|\| (v86.eax != SMAP_SIG))
242	break;	243	break;
243	/* look for a low-memory segment that's large enough */	244	/* look for a low-memory segment that's large enough */
244	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&	245	if ((smap.type == SMAP_TYPE_MEMORY) && (smap.base == 0) &&
Lines 275-281 bios_getmem(void) Link Here
275	v86.ctl = 0;	276	v86.ctl = 0;
276	v86.addr = 0x12; /* int 0x12 */	277	v86.addr = 0x12; /* int 0x12 */
277	v86int();	278	v86int();
278		279
279	bios_basemem = (v86.eax & 0xffff) * 1024;	280	bios_basemem = (v86.eax & 0xffff) * 1024;
280	}	281	}
Lines 285-291 bios_getmem(void) Link Here
285	v86.addr = 0x15; /* int 0x15 function 0xe801*/	286	v86.addr = 0x15; /* int 0x15 function 0xe801*/
286	v86.eax = 0xe801;	287	v86.eax = 0xe801;
287	v86int();	288	v86int();
288	if (!(v86.efl & 1)) {	289	if (!(v86.efl & PSL_C)) {
289	bios_extmem = ((v86.ecx & 0xffff) + ((v86.edx & 0xffff) * 64)) * 1024;	290	bios_extmem = ((v86.ecx & 0xffff) + ((v86.edx & 0xffff) * 64)) * 1024;
290	}	291	}
291	}	292	}
Lines 306-312 bios_getmem(void) Link Here
306	high_heap_size = HEAP_MIN;	307	high_heap_size = HEAP_MIN;
307	high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;	308	high_heap_base = bios_extmem + 0x100000 - HEAP_MIN;
308	}	309	}
309	}	310	}
310	/*	311	/*
311	* Try to detect a device supported by the legacy int13 BIOS	312	* Try to detect a device supported by the legacy int13 BIOS
Lines 319-326 int13probe(int drive) Link Here
319	v86.eax = 0x800;	320	v86.eax = 0x800;
320	v86.edx = drive;	321	v86.edx = drive;
321	v86int();	322	v86int();
322		323
323	if (!(v86.efl & 0x1) && /* carry clear */	324	if (!(v86.efl & PSL_C) && /* carry clear */
324	((v86.edx & 0xff) != (drive & DRV_MASK))) { /* unit # OK */	325	((v86.edx & 0xff) != (drive & DRV_MASK))) { /* unit # OK */
325	if ((v86.ecx & 0x3f) == 0) { /* absurd sector size */	326	if ((v86.ecx & 0x3f) == 0) { /* absurd sector size */
326	return(0); /* skip device */	327	return(0); /* skip device */

Lines 30-36 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/boot/i386/libi386/biosdisk.c (-5 / +5 lines)
30	/*	30	/*
31	* BIOS disk device handling.	31	* BIOS disk device handling.
32	*	32	*
33	* Ideas and algorithms from:	33	* Ideas and algorithms from:
34	*	34	*
35	* - NetBSD libi386/biosdisk.c	35	* - NetBSD libi386/biosdisk.c
Lines 486-492 bd_io(struct disk_devdesc *dev, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
486	{	486	{
487	u_int x, sec, result, resid, retry, maxfer;	487	u_int x, sec, result, resid, retry, maxfer;
488	caddr_t p, xp, bbuf, breg;	488	caddr_t p, xp, bbuf, breg;
489		489
490	/* Just in case some idiot actually tries to read/write -1 blocks... */	490	/* Just in case some idiot actually tries to read/write -1 blocks... */
491	if (blks < 0)	491	if (blks < 0)
492	return (-1);	492	return (-1);
Lines 499-505 bd_io(struct disk_devdesc *dev, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
499	(VTOP(dest) >> 16) != (VTOP(dest +	499	(VTOP(dest) >> 16) != (VTOP(dest +
500	blks * BD(dev).bd_sectorsize) >> 16))) {	500	blks * BD(dev).bd_sectorsize) >> 16))) {
501	/*	501	/*
502	* There is a 64k physical boundary somewhere in the	502	* There is a 64k physical boundary somewhere in the
503	* destination buffer, or the destination buffer is above	503	* destination buffer, or the destination buffer is above
504	* first 1MB of physical memory so we have to arrange a	504	* first 1MB of physical memory so we have to arrange a
Lines 520-526 bd_io(struct disk_devdesc *dev, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
520	breg = bbuf = NULL;	520	breg = bbuf = NULL;
521	maxfer = 0;	521	maxfer = 0;
522	}	522	}
523		523
524	while (resid > 0) {	524	while (resid > 0) {
525	/*	525	/*
526	* Play it safe and don't cross track boundaries.	526	* Play it safe and don't cross track boundaries.
Lines 536-542 bd_io(struct disk_devdesc *dev, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
536	/*	536	/*
537	* Put your Data In, Put your Data out,	537	* Put your Data In, Put your Data out,
538	* Put your Data In, and shake it all about	538	* Put your Data In, and shake it all about
539	*/	539	*/
540	if (write && bbuf != NULL)	540	if (write && bbuf != NULL)
541	bcopy(p, breg, x * BD(dev).bd_sectorsize);	541	bcopy(p, breg, x * BD(dev).bd_sectorsize);

Lines 29-35 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/boot/pc98/libpc98/biosdisk.c (-40 / +40 lines)
29	/*	29	/*
30	* BIOS disk device handling.	30	* BIOS disk device handling.
31	*	31	*
32	* Ideas and algorithms from:	32	* Ideas and algorithms from:
33	*	33	*
34	* - NetBSD libi386/biosdisk.c	34	* - NetBSD libi386/biosdisk.c
Lines 42-47 __FBSDID("$FreeBSD$"); Link Here
42	#include <sys/disklabel.h>	42	#include <sys/disklabel.h>
43	#include <sys/diskpc98.h>	43	#include <sys/diskpc98.h>
44	#include <machine/bootinfo.h>	44	#include <machine/bootinfo.h>
		45	#include <machine/psl.h>
45	#include <stdarg.h>	46	#include <stdarg.h>
Lines 122-133 static int bd_close(struct open_file *f); Link Here
122	static void bd_print(int verbose);	123	static void bd_print(int verbose);
123	struct devsw biosdisk = {	124	struct devsw biosdisk = {
124	"disk",	125	"disk",
125	DEVT_DISK,	126	DEVT_DISK,
126	bd_init,	127	bd_init,
127	bd_strategy,	128	bd_strategy,
128	bd_open,	129	bd_open,
129	bd_close,	130	bd_close,
130	noioctl,	131	noioctl,
131	bd_print,	132	bd_print,
132	NULL	133	NULL
Lines 146-152 int Link Here
146	bd_bios2unit(int biosdev)	147	bd_bios2unit(int biosdev)
147	{	148	{
148	int i;	149	int i;
149		150
150	DEBUG("looking for bios device 0x%x", biosdev);	151	DEBUG("looking for bios device 0x%x", biosdev);
151	for (i = 0; i < nbdinfo; i++) {	152	for (i = 0; i < nbdinfo; i++) {
152	DEBUG("bd unit %d is BIOS device 0x%x", i, bdinfo[i].bd_unit);	153	DEBUG("bd unit %d is BIOS device 0x%x", i, bdinfo[i].bd_unit);
Lines 164-174 bd_unit2bios(int unit) Link Here
164	return(-1);	165	return(-1);
165	}	166	}
166	/*	167	/*
167	* Quiz the BIOS for disk devices, save a little info about them.	168	* Quiz the BIOS for disk devices, save a little info about them.
168	*/	169	*/
169	static int	170	static int
170	bd_init(void)	171	bd_init(void)
171	{	172	{
172	int base, unit;	173	int base, unit;
173	int da_drive=0, n=-0x10;	174	int da_drive=0, n=-0x10;
Lines 200-206 bd_init(void) Link Here
200	bdinfo[nbdinfo].bd_da_unit = da_drive++;	201	bdinfo[nbdinfo].bd_da_unit = da_drive++;
201	}	202	}
202	/* XXX we need "disk aliases" to make this simpler */	203	/* XXX we need "disk aliases" to make this simpler */
203	printf("BIOS drive %c: is disk%d\n",	204	printf("BIOS drive %c: is disk%d\n",
204	'A' + nbdinfo, nbdinfo);	205	'A' + nbdinfo, nbdinfo);
205	nbdinfo++;	206	nbdinfo++;
206	}	207	}
Lines 250-256 bd_print(int verbose) Link Here
250	struct i386_devdesc dev;	251	struct i386_devdesc dev;
251	struct open_disk *od;	252	struct open_disk *od;
252	struct pc98_partition *dptr;	253	struct pc98_partition *dptr;
253		254
254	for (i = 0; i < nbdinfo; i++) {	255	for (i = 0; i < nbdinfo; i++) {
255	sprintf(line, " disk%d: BIOS drive %c:\n", i, 'A' + i);	256	sprintf(line, " disk%d: BIOS drive %c:\n", i, 'A' + i);
256	pager_output(line);	257	pager_output(line);
Lines 259-265 bd_print(int verbose) Link Here
259	dev.d_unit = i;	260	dev.d_unit = i;
260	dev.d_kind.biosdisk.slice = -1;	261	dev.d_kind.biosdisk.slice = -1;
261	dev.d_kind.biosdisk.partition = -1;	262	dev.d_kind.biosdisk.partition = -1;
262		263
263	if (!bd_opendisk(&od, &dev)) {	264	if (!bd_opendisk(&od, &dev)) {
264	/* Do we have a partition table? */	265	/* Do we have a partition table? */
Lines 368-374 bd_printbsdslice(struct open_disk od, daddr_t offset, char prefix, Link Here
368	pager_output(line);	369	pager_output(line);
369	return;	370	return;
370	}	371	}
371		372
372	/* Print partitions */	373	/* Print partitions */
373	for (i = 0; i < lp->d_npartitions; i++) {	374	for (i = 0; i < lp->d_npartitions; i++) {
374	/*	375	/*
Lines 380-392 bd_printbsdslice(struct open_disk od, daddr_t offset, char prefix, Link Here
380	if ((lp->d_partitions[i].p_fstype == FS_BSDFFS) \|\|	381	if ((lp->d_partitions[i].p_fstype == FS_BSDFFS) \|\|
381	(lp->d_partitions[i].p_fstype == FS_SWAP) \|\|	382	(lp->d_partitions[i].p_fstype == FS_SWAP) \|\|
382	(lp->d_partitions[i].p_fstype == FS_VINUM) \|\|	383	(lp->d_partitions[i].p_fstype == FS_VINUM) \|\|
383	((lp->d_partitions[i].p_fstype == FS_UNUSED) &&	384	((lp->d_partitions[i].p_fstype == FS_UNUSED) &&
384	(od->od_flags & BD_FLOPPY) && (i == 0))) {	385	(od->od_flags & BD_FLOPPY) && (i == 0))) {
385	/* Only print out statistics in verbose mode */	386	/* Only print out statistics in verbose mode */
386	if (verbose)	387	if (verbose)
387	sprintf(line, " %s%c: %s %s (%d - %d)\n", prefix, 'a' + i,	388	sprintf(line, " %s%c: %s %s (%d - %d)\n", prefix, 'a' + i,
388	(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap " :	389	(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap " :
389	(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :	390	(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
390	"FFS ",	391	"FFS ",
391	display_size(lp->d_partitions[i].p_size),	392	display_size(lp->d_partitions[i].p_size),
Lines 394-400 bd_printbsdslice(struct open_disk od, daddr_t offset, char prefix, Link Here
394	lp->d_partitions[i].p_offset + lp->d_partitions[i].p_size);	395	lp->d_partitions[i].p_offset + lp->d_partitions[i].p_size);
395	else	396	else
396	sprintf(line, " %s%c: %s\n", prefix, 'a' + i,	397	sprintf(line, " %s%c: %s\n", prefix, 'a' + i,
397	(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" :	398	(lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" :
398	(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :	399	(lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
399	"FFS");	400	"FFS");
400	pager_output(line);	401	pager_output(line);
Lines 413-419 bd_printbsdslice(struct open_disk od, daddr_t offset, char prefix, Link Here
413	* sliced - are they after the first BSD slice, or the DOS	414	* sliced - are they after the first BSD slice, or the DOS
414	* slice before it?)	415	* slice before it?)
415	*/	416	*/
416	static int	417	static int
417	bd_open(struct open_file *f, ...)	418	bd_open(struct open_file *f, ...)
418	{	419	{
419	va_list ap;	420	va_list ap;
Lines 426-432 bd_open(struct open_file *f, ...) Link Here
426	va_end(ap);	427	va_end(ap);
427	if ((error = bd_opendisk(&od, dev)))	428	if ((error = bd_opendisk(&od, dev)))
428	return(error);	429	return(error);
429		430
430	/*	431	/*
431	* Save our context	432	* Save our context
432	*/	433	*/
Lines 445-451 bd_opendisk(struct open_disk *odp, struct i386_devdesc dev) Link Here
445	DEBUG("attempt to open nonexistent disk");	446	DEBUG("attempt to open nonexistent disk");
446	return(ENXIO);	447	return(ENXIO);
447	}	448	}
448		449
449	od = (struct open_disk *)malloc(sizeof(struct open_disk));	450	od = (struct open_disk *)malloc(sizeof(struct open_disk));
450	if (!od) {	451	if (!od) {
451	DEBUG("no memory");	452	DEBUG("no memory");
Lines 459-465 bd_opendisk(struct open_disk *odp, struct i386_devdesc dev) Link Here
459	od->od_boff = 0;	460	od->od_boff = 0;
460	error = 0;	461	error = 0;
461	DEBUG("open '%s', unit 0x%x slice %d partition %d",	462	DEBUG("open '%s', unit 0x%x slice %d partition %d",
462	i386_fmtdev(dev), dev->d_unit,	463	i386_fmtdev(dev), dev->d_unit,
463	dev->d_kind.biosdisk.slice, dev->d_kind.biosdisk.partition);	464	dev->d_kind.biosdisk.slice, dev->d_kind.biosdisk.partition);
464	/* Get geometry for this open (removable device may have changed) */	465	/* Get geometry for this open (removable device may have changed) */
Lines 471-477 bd_opendisk(struct open_disk *odp, struct i386_devdesc dev) Link Here
471	/* Determine disk layout. */	472	/* Determine disk layout. */
472	error = bd_open_pc98(od, dev);	473	error = bd_open_pc98(od, dev);
473		474
474	out:	475	out:
475	if (error) {	476	if (error) {
476	free(od);	477	free(od);
Lines 508-514 bd_open_pc98(struct open_disk od, struct i386_devdesc dev) Link Here
508	return (EIO);	509	return (EIO);
509	}	510	}
510	/*	511	/*
511	* Check the slice table magic.	512	* Check the slice table magic.
512	*/	513	*/
513	if (((u_char)buf[0x1fe] != 0x55) \|\| ((u_char)buf[0x1ff] != 0xaa)) {	514	if (((u_char)buf[0x1fe] != 0x55) \|\| ((u_char)buf[0x1ff] != 0xaa)) {
Lines 582-588 bd_open_pc98(struct open_disk od, struct i386_devdesc dev) Link Here
582	dev->d_kind.biosdisk.partition = 0;	583	dev->d_kind.biosdisk.partition = 0;
583	unsliced:	584	unsliced:
584	/*	585	/*
585	* Now we have the slice offset, look for the partition in the disklabel if we have	586	* Now we have the slice offset, look for the partition in the disklabel if we have
586	* a partition to start with.	587	* a partition to start with.
587	*	588	*
Lines 592-598 bd_open_pc98(struct open_disk od, struct i386_devdesc dev) Link Here
592	od->od_boff = sector; /* no partition, must be after the slice */	593	od->od_boff = sector; /* no partition, must be after the slice */
593	DEBUG("opening raw slice");	594	DEBUG("opening raw slice");
594	} else {	595	} else {
595		596
596	if (bd_read(od, sector + LABELSECTOR, 1, buf)) {	597	if (bd_read(od, sector + LABELSECTOR, 1, buf)) {
597	DEBUG("error reading disklabel");	598	DEBUG("error reading disklabel");
598	return (EIO);	599	return (EIO);
Lines 618-625 bd_open_pc98(struct open_disk od, struct i386_devdesc dev) Link Here
618	!(od->od_flags & BD_FLOPPY))	619	!(od->od_flags & BD_FLOPPY))
619	DEBUG("warning, partition marked as unused");	620	DEBUG("warning, partition marked as unused");
620	#endif	621	#endif
621		622
622	od->od_boff =	623	od->od_boff =
623	lp->d_partitions[dev->d_kind.biosdisk.partition].p_offset -	624	lp->d_partitions[dev->d_kind.biosdisk.partition].p_offset -
624	lp->d_partitions[RAW_PART].p_offset +	625	lp->d_partitions[RAW_PART].p_offset +
625	sector;	626	sector;
Lines 655-661 bd_bestslice(struct open_disk *od) Link Here
655	struct pc98_partition *dp;	656	struct pc98_partition *dp;
656	int pref, preflevel;	657	int pref, preflevel;
657	int i, prefslice;	658	int i, prefslice;
658		659
659	prefslice = 0;	660	prefslice = 0;
660	preflevel = PREF_NONE;	661	preflevel = PREF_NONE;
Lines 692-699 bd_bestslice(struct open_disk *od) Link Here
692	}	693	}
693	return (prefslice);	694	return (prefslice);
694	}	695	}
695		696
696	static int	697	static int
697	bd_close(struct open_file *f)	698	bd_close(struct open_file *f)
698	{	699	{
699	struct open_disk od = (struct open_disk )(((struct i386_devdesc *)(f->f_devdata))->d_kind.biosdisk.data);	700	struct open_disk od = (struct open_disk )(((struct i386_devdesc *)(f->f_devdata))->d_kind.biosdisk.data);
Lines 714-720 bd_closedisk(struct open_disk *od) Link Here
714	free(od);	715	free(od);
715	}	716	}
716	static int	717	static int
717	bd_strategy(void devdata, int rw, daddr_t dblk, size_t size, char buf, size_t *rsize)	718	bd_strategy(void devdata, int rw, daddr_t dblk, size_t size, char buf, size_t *rsize)
718	{	719	{
719	struct bcache_devdata bcd;	720	struct bcache_devdata bcd;
Lines 725-731 bd_strategy(void devdata, int rw, daddr_t dblk, size_t size, char buf, size_t Link Here
725	return(bcache_strategy(&bcd, od->od_unit, rw, dblk+od->od_boff, size, buf, rsize));	726	return(bcache_strategy(&bcd, od->od_unit, rw, dblk+od->od_boff, size, buf, rsize));
726	}	727	}
727	static int	728	static int
728	bd_realstrategy(void devdata, int rw, daddr_t dblk, size_t size, char buf, size_t *rsize)	729	bd_realstrategy(void devdata, int rw, daddr_t dblk, size_t size, char buf, size_t *rsize)
729	{	730	{
730	struct open_disk od = (struct open_disk )(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);	731	struct open_disk od = (struct open_disk )(((struct i386_devdesc *)devdata)->d_kind.biosdisk.data);
Lines 824-830 bd_chs_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
824	v86.es = VTOPSEG(dest);	825	v86.es = VTOPSEG(dest);
825	v86.ebp = VTOPOFF(dest);	826	v86.ebp = VTOPOFF(dest);
826	v86int();	827	v86int();
827	return (v86.efl & 0x1);	828	return (v86.efl & PSL_C);
828	}	829	}
829	static int	830	static int
Lines 832-838 bd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
832	{	833	{
833	u_int x, sec, result, resid, retry, maxfer;	834	u_int x, sec, result, resid, retry, maxfer;
834	caddr_t p, xp, bbuf, breg;	835	caddr_t p, xp, bbuf, breg;
835		836
836	/* Just in case some idiot actually tries to read/write -1 blocks... */	837	/* Just in case some idiot actually tries to read/write -1 blocks... */
837	if (blks < 0)	838	if (blks < 0)
838	return (-1);	839	return (-1);
Lines 844-850 bd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
844	if (VTOP(dest) >> 20 != 0 \|\|	845	if (VTOP(dest) >> 20 != 0 \|\|
845	((VTOP(dest) >> 16) != (VTOP(dest + blks * BIOSDISK_SECSIZE) >> 16))) {	846	((VTOP(dest) >> 16) != (VTOP(dest + blks * BIOSDISK_SECSIZE) >> 16))) {
846	/*	847	/*
847	* There is a 64k physical boundary somewhere in the	848	* There is a 64k physical boundary somewhere in the
848	* destination buffer, or the destination buffer is above	849	* destination buffer, or the destination buffer is above
849	* first 1MB of physical memory so we have to arrange a	850	* first 1MB of physical memory so we have to arrange a
Lines 865-871 bd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
865	breg = bbuf = NULL;	866	breg = bbuf = NULL;
866	maxfer = 0;	867	maxfer = 0;
867	}	868	}
868		869
869	while (resid > 0) {	870	while (resid > 0) {
870	/*	871	/*
871	* Play it safe and don't cross track boundaries.	872	* Play it safe and don't cross track boundaries.
Lines 881-887 bd_io(struct open_disk *od, daddr_t dblk, int blks, caddr_t dest, int write) Link Here
881	/*	882	/*
882	* Put your Data In, Put your Data out,	883	* Put your Data In, Put your Data out,
883	* Put your Data In, and shake it all about	884	* Put your Data In, and shake it all about
884	*/	885	*/
885	if (write && bbuf != NULL)	886	if (write && bbuf != NULL)
886	bcopy(p, breg, x * BIOSDISK_SECSIZE);	887	bcopy(p, breg, x * BIOSDISK_SECSIZE);
Lines 955-965 bd_getgeom(struct open_disk *od) Link Here
955	v86.addr = 0x1b;	956	v86.addr = 0x1b;
956	v86.eax = 0x8400 \| od->od_unit;	957	v86.eax = 0x8400 \| od->od_unit;
957	v86int();	958	v86int();
958		959
959	od->od_cyl = v86.ecx;	960	od->od_cyl = v86.ecx;
960	od->od_hds = (v86.edx >> 8) & 0xff;	961	od->od_hds = (v86.edx >> 8) & 0xff;
961	od->od_sec = v86.edx & 0xff;	962	od->od_sec = v86.edx & 0xff;
962	if (v86.efl & 0x1)	963	if (v86.efl & PSL_C)
963	return(1);	964	return(1);
964	}	965	}
Lines 1010-1016 bd_getbigeom(int bunit) Link Here
1010	v86.addr = 0x1b;	1011	v86.addr = 0x1b;
1011	v86.eax = 0x8400 \| unit;	1012	v86.eax = 0x8400 \| unit;
1012	v86int();	1013	v86int();
1013	if (v86.efl & 0x1)	1014	if (v86.efl & PSL_C)
1014	return 0x4F020F; /* 1200KB FD C:80 H:2 S:15 */	1015	return 0x4F020F; /* 1200KB FD C:80 H:2 S:15 */
1015	return ((v86.ecx & 0xffff) << 16) \| (v86.edx & 0xffff);	1016	return ((v86.ecx & 0xffff) << 16) \| (v86.edx & 0xffff);
1016	}	1017	}
1017	-