whitespace changes to reduce diffs from i386.

still broken pc98 boot.

3 files changed, 636 insertions, 615 deletions

diff --git a/stand/pc98/boot2/boot2.c b/stand/pc98/boot2/boot2.c
index b582516..3a9a54b 100644
--- a/stand/pc98/boot2/boot2.c
+++ b/stand/pc98/boot2/boot2.c
@@ -71,20 +71,20 @@ extern uint32_t _end;
 
 static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */
 static const unsigned char flags[NOPT] = {
-    RBX_DUAL,
-    RBX_SERIAL,
-    RBX_ASKNAME,
-    RBX_CDROM,
-    RBX_CONFIG,
-    RBX_KDB,
-    RBX_GDB,
-    RBX_MUTE,
-    RBX_NOINTR,
-    RBX_PAUSE,
-    RBX_QUIET,
-    RBX_DFLTROOT,
-    RBX_SINGLE,
-    RBX_VERBOSE
+	RBX_DUAL,
+	RBX_SERIAL,
+	RBX_ASKNAME,
+	RBX_CDROM,
+	RBX_CONFIG,
+	RBX_KDB,
+	RBX_GDB,
+	RBX_MUTE,
+	RBX_NOINTR,
+	RBX_PAUSE,
+	RBX_QUIET,
+	RBX_DFLTROOT,
+	RBX_SINGLE,
+	RBX_VERBOSE
 };
 
 static const char *const dev_nm[NDEV] = {"ad", "da", "fd"};
@@ -92,15 +92,15 @@ static const unsigned char dev_maj[NDEV] = {30, 4, 2};
 static const unsigned char dev_daua[NDEV] = {0x80, 0xa0, 0x90};
 
 static struct dsk {
-    unsigned daua;
-    unsigned type;
-    unsigned disk;
-    unsigned unit;
-    unsigned head;
-    unsigned sec;
-    uint8_t slice;
-    uint8_t part;
-    unsigned start;
+	unsigned daua;
+	unsigned type;
+	unsigned disk;
+	unsigned unit;
+	unsigned head;
+	unsigned sec;
+	uint8_t slice;
+	uint8_t part;
+	unsigned start;
 } dsk;
 static char cmd[512], cmddup[512], knamebuf[1024];
 static const char *kname;
@@ -128,18 +128,19 @@ static void memcpy(void *, const void *, int);
 static void
 memcpy(void *dst, const void *src, int len)
 {
-    const char *s = src;
-    char *d = dst;
+	const char *s = src;
+	char *d = dst;
 
-    while (len--)
-        *d++ = *s++;
+	while (len--)
+		*d++ = *s++;
 }
 
 static inline int
 strcmp(const char *s1, const char *s2)
 {
-    for (; *s1 == *s2 && *s1; s1++, s2++);
-    return (unsigned char)*s1 - (unsigned char)*s2;
+
+	for (; *s1 == *s2 && *s1; s1++, s2++);
+	return ((unsigned char)*s1 - (unsigned char)*s2);
 }
 
 #define	UFS_SMALL_CGBASE
@@ -148,52 +149,53 @@ strcmp(const char *s1, const char *s2)
 static inline int
 xfsread(ufs_ino_t inode, void *buf, size_t nbyte)
 {
-    if ((size_t)fsread(inode, buf, nbyte) != nbyte) {
-	printf("Invalid %s\n", "format");
-	return -1;
-    }
-    return 0;
+
+	if ((size_t)fsread(inode, buf, nbyte) != nbyte) {
+		printf("Invalid %s\n", "format");
+		return (-1);
+	}
+	return (0);
 }
 
 static inline void
 getstr(void)
 {
-    char *s;
-    int c;
-
-    s = cmd;
-    for (;;) {
-	switch (c = xgetc(0)) {
-	case 0:
-	    break;
-	case '\177':
-	case '\b':
-	    if (s > cmd) {
-		s--;
-		printf("\b \b");
-	    }
-	    break;
-	case '\n':
-	case '\r':
-	    *s = 0;
-	    return;
-	default:
-	    if (s - cmd < sizeof(cmd) - 1)
-		*s++ = c;
-	    putchar(c);
+	char *s;
+	int c;
+
+	s = cmd;
+	for (;;) {
+		switch (c = xgetc(0)) {
+		case 0:
+			break;
+		case '\177':
+		case '\b':
+			if (s > cmd) {
+				s--;
+				printf("\b \b");
+			}
+			break;
+		case '\n':
+		case '\r':
+			*s = 0;
+			return;
+		default:
+			if (s - cmd < sizeof(cmd) - 1)
+				*s++ = c;
+			putchar(c);
+		}
 	}
-    }
 }
 
 static inline void
 putc(int c)
 {
 
-    v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
-    v86.addr = PUTCORG;		/* call to putc in boot1 */
-    v86.eax = c;
-    v86int();
-    v86.ctl = V86_FLAGS;
+	v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
+	v86.addr = PUTCORG;		/* call to putc in boot1 */
+	v86.eax = c;
+	v86int();
+	v86.ctl = V86_FLAGS;
 }
 
 static inline int
@@ -322,482 +324,491 @@ int
 main(void)
 {
 #ifdef GET_BIOSGEOM
-    int i;
+	int i;
 #endif
-    uint8_t autoboot;
-    ufs_ino_t ino;
-    size_t nbyte;
-
-    dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
-    v86.ctl = V86_FLAGS;
-    v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
-    dsk.daua = *(uint8_t *)PTOV(0x584);
-    dsk.disk = dsk.daua & DRV_DISK;
-    dsk.unit = dsk.daua & DRV_UNIT;
-    if (dsk.disk == 0x80)
-        dsk.type = TYPE_AD;
-    else if (dsk.disk == 0xa0)
-        dsk.type = TYPE_DA;
-    else /* if (dsk.disk == 0x30 || dsk.disk == 0x90) */
-        dsk.type = TYPE_FD;
-    dsk.slice = check_slice();
+	uint8_t autoboot;
+	ufs_ino_t ino;
+	size_t nbyte;
+
+	dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
+	v86.ctl = V86_FLAGS;
+	v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
+	dsk.daua = *(uint8_t *)PTOV(0x584);
+	dsk.disk = dsk.daua & DRV_DISK;
+	dsk.unit = dsk.daua & DRV_UNIT;
+	if (dsk.disk == 0x80)
+		dsk.type = TYPE_AD;
+	else if (dsk.disk == 0xa0)
+		dsk.type = TYPE_DA;
+	else /* if (dsk.disk == 0x30 || dsk.disk == 0x90) */
+		dsk.type = TYPE_FD;
+	dsk.slice = check_slice();
 #ifdef GET_BIOSGEOM
-    for (i = 0; i < N_BIOS_GEOM; i++)
-	bootinfo.bi_bios_geom[i] = bd_getbigeom(i);
+	for (i = 0; i < N_BIOS_GEOM; i++)
+		bootinfo.bi_bios_geom[i] = bd_getbigeom(i);
 #endif
-    bootinfo.bi_version = BOOTINFO_VERSION;
-    bootinfo.bi_size = sizeof(bootinfo);
+	bootinfo.bi_version = BOOTINFO_VERSION;
+	bootinfo.bi_size = sizeof(bootinfo);
 
-    /* Process configuration file */
+	/* Process configuration file */
 
-    autoboot = 1;
+	autoboot = 1;
 
-    if ((ino = lookup(PATH_CONFIG)) ||
-        (ino = lookup(PATH_DOTCONFIG))) {
-	nbyte = fsread(ino, cmd, sizeof(cmd) - 1);
-	cmd[nbyte] = '\0';
-    }
+	if ((ino = lookup(PATH_CONFIG)) ||
+	    (ino = lookup(PATH_DOTCONFIG))) {
+		nbyte = fsread(ino, cmd, sizeof(cmd) - 1);
+		cmd[nbyte] = '\0';
+	}
 
-    if (*cmd) {
-	memcpy(cmddup, cmd, sizeof(cmd));
-	if (parse())
-	    autoboot = 0;
-	if (!OPT_CHECK(RBX_QUIET))
-	    printf("%s: %s", PATH_CONFIG, cmddup);
-	/* Do not process this command twice */
-	*cmd = 0;
-    }
+	if (*cmd) {
+		memcpy(cmddup, cmd, sizeof(cmd));
+		if (parse())
+			autoboot = 0;
+		if (!OPT_CHECK(RBX_QUIET))
+			printf("%s: %s", PATH_CONFIG, cmddup);
+		/* Do not process this command twice */
+		*cmd = 0;
+	}
 
-    /*
-     * Try to exec stage 3 boot loader. If interrupted by a keypress,
-     * or in case of failure, try to load a kernel directly instead.
-     */
+	/*
+	 * Try to exec stage 3 boot loader. If interrupted by a keypress,
+	 * or in case of failure, try to load a kernel directly instead.
+	 */
 
-    if (!kname) {
-	kname = PATH_LOADER;
-	if (autoboot && !keyhit(3*SECOND)) {
-	    load();
-	    kname = PATH_KERNEL;
+	if (!kname) {
+		kname = PATH_LOADER;
+		if (autoboot && !keyhit(3*SECOND)) {
+			load();
+			kname = PATH_KERNEL;
+		}
 	}
-    }
-
-    /* Present the user with the boot2 prompt. */
 
-    for (;;) {
-	if (!autoboot || !OPT_CHECK(RBX_QUIET))
-	    printf("\nFreeBSD/pc98 boot\n"
-		   "Default: %u:%s(%u,%c)%s\n"
-		   "boot: ",
-		   dsk.unit, dev_nm[dsk.type], dsk.unit,
-		   'a' + dsk.part, kname);
-	if (DO_SIO)
-	    sio_flush();
-	if (!autoboot || keyhit(3*SECOND))
-	    getstr();
-	else if (!autoboot || !OPT_CHECK(RBX_QUIET))
-	    putchar('\n');
-	autoboot = 0;
-	if (parse())
-	    putchar('\a');
-	else
-	    load();
-    }
+	/* Present the user with the boot2 prompt. */
+
+	for (;;) {
+		if (!autoboot || !OPT_CHECK(RBX_QUIET))
+			printf("\nFreeBSD/pc98 boot\n"
+				 "Default: %u:%s(%u,%c)%s\n"
+				 "boot: ",
+			    dsk.unit, dev_nm[dsk.type], dsk.unit,
+			    'a' + dsk.part, kname);
+		if (DO_SIO)
+			sio_flush();
+		if (!autoboot || keyhit(3*SECOND))
+			getstr();
+		else if (!autoboot || !OPT_CHECK(RBX_QUIET))
+			putchar('\n');
+		autoboot = 0;
+		if (parse())
+			putchar('\a');
+		else
+			load();
+	}
 }
 
 /* XXX - Needed for btxld to link the boot2 binary; do not remove. */
 void
 exit(int x)
 {
+
 }
 
 static void
 load(void)
 {
-    union {
-	struct exec ex;
-	Elf32_Ehdr eh;
-    } hdr;
-    static Elf32_Phdr ep[2];
-    static Elf32_Shdr es[2];
-    caddr_t p;
-    ufs_ino_t ino;
-    uint32_t addr;
-    int k;
-    uint8_t i, j;
-
-    if (!(ino = lookup(kname))) {
-	if (!ls)
-	    printf("No %s\n", kname);
-	return;
-    }
-    if (xfsread(ino, &hdr, sizeof(hdr)))
-	return;
-
-    if (N_GETMAGIC(hdr.ex) == ZMAGIC) {
-	addr = hdr.ex.a_entry & 0xffffff;
-	p = PTOV(addr);
-	fs_off = PAGE_SIZE;
-	if (xfsread(ino, p, hdr.ex.a_text))
-	    return;
-	p += roundup2(hdr.ex.a_text, PAGE_SIZE);
-	if (xfsread(ino, p, hdr.ex.a_data))
-	    return;
-    } else if (IS_ELF(hdr.eh)) {
-	fs_off = hdr.eh.e_phoff;
-	for (j = k = 0; k < hdr.eh.e_phnum && j < 2; k++) {
-	    if (xfsread(ino, ep + j, sizeof(ep[0])))
+	union {
+		struct exec ex;
+		Elf32_Ehdr eh;
+	} hdr;
+	static Elf32_Phdr ep[2];
+	static Elf32_Shdr es[2];
+	caddr_t p;
+	ufs_ino_t ino;
+	uint32_t addr;
+	int k;
+	uint8_t i, j;
+
+	if (!(ino = lookup(kname))) {
+		if (!ls)
+			printf("No %s\n", kname);
 		return;
-	    if (ep[j].p_type == PT_LOAD)
-		j++;
 	}
-	for (i = 0; i < 2; i++) {
-	    p = PTOV(ep[i].p_paddr & 0xffffff);
-	    fs_off = ep[i].p_offset;
-	    if (xfsread(ino, p, ep[i].p_filesz))
+	if (xfsread(ino, &hdr, sizeof(hdr)))
 		return;
-	}
-	p += roundup2(ep[1].p_memsz, PAGE_SIZE);
-	bootinfo.bi_symtab = VTOP(p);
-	if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) {
-	    fs_off = hdr.eh.e_shoff + sizeof(es[0]) *
-		(hdr.eh.e_shstrndx + 1);
-	    if (xfsread(ino, &es, sizeof(es)))
+
+	if (N_GETMAGIC(hdr.ex) == ZMAGIC) {
+		addr = hdr.ex.a_entry & 0xffffff;
+		p = PTOV(addr);
+		fs_off = PAGE_SIZE;
+		if (xfsread(ino, p, hdr.ex.a_text))
+			return;
+		p += roundup2(hdr.ex.a_text, PAGE_SIZE);
+		if (xfsread(ino, p, hdr.ex.a_data))
+			return;
+	} else if (IS_ELF(hdr.eh)) {
+		fs_off = hdr.eh.e_phoff;
+		for (j = k = 0; k < hdr.eh.e_phnum && j < 2; k++) {
+			if (xfsread(ino, ep + j, sizeof(ep[0])))
+				return;
+			if (ep[j].p_type == PT_LOAD)
+				j++;
+		}
+		for (i = 0; i < 2; i++) {
+			p = PTOV(ep[i].p_paddr & 0xffffff);
+			fs_off = ep[i].p_offset;
+			if (xfsread(ino, p, ep[i].p_filesz))
+				return;
+		}
+		p += roundup2(ep[1].p_memsz, PAGE_SIZE);
+		bootinfo.bi_symtab = VTOP(p);
+		if (hdr.eh.e_shnum == hdr.eh.e_shstrndx + 3) {
+			fs_off = hdr.eh.e_shoff + sizeof(es[0]) *
+			    (hdr.eh.e_shstrndx + 1);
+			if (xfsread(ino, &es, sizeof(es)))
+				return;
+			for (i = 0; i < 2; i++) {
+				*(Elf32_Word *)p = es[i].sh_size;
+				p += sizeof(es[i].sh_size);
+				fs_off = es[i].sh_offset;
+				if (xfsread(ino, p, es[i].sh_size))
+					return;
+				p += es[i].sh_size;
+			}
+		}
+		addr = hdr.eh.e_entry & 0xffffff;
+		bootinfo.bi_esymtab = VTOP(p);
+	} else {
+		printf("Invalid %s\n", "format");
 		return;
-	    for (i = 0; i < 2; i++) {
-		*(Elf32_Word *)p = es[i].sh_size;
-		p += sizeof(es[i].sh_size);
-		fs_off = es[i].sh_offset;
-		if (xfsread(ino, p, es[i].sh_size))
-		    return;
-		p += es[i].sh_size;
-	    }
 	}
-	addr = hdr.eh.e_entry & 0xffffff;
-	bootinfo.bi_esymtab = VTOP(p);
-    } else {
-	printf("Invalid %s\n", "format");
-	return;
-    }
 
-    bootinfo.bi_kernelname = VTOP(kname);
-    bootinfo.bi_bios_dev = dsk.daua;
-    __exec((caddr_t)addr, RB_BOOTINFO | (opts & RBX_MASK),
-	   MAKEBOOTDEV(dev_maj[dsk.type], dsk.slice, dsk.unit, dsk.part),
-	   0, 0, 0, VTOP(&bootinfo));
+	bootinfo.bi_kernelname = VTOP(kname);
+	bootinfo.bi_bios_dev = dsk.daua;
+	__exec((caddr_t)addr, RB_BOOTINFO | (opts & RBX_MASK),
+	    MAKEBOOTDEV(dev_maj[dsk.type], dsk.slice, dsk.unit, dsk.part),
+	    0, 0, 0, VTOP(&bootinfo));
 }
 
 static int
 parse()
 {
-    char *arg = cmd;
-    char *ep, *p, *q;
-    const char *cp;
-    unsigned int drv;
-    int c, i, j;
-    size_t k;
-
-    while ((c = *arg++)) {
-	if (c == ' ' || c == '\t' || c == '\n')
-	    continue;
-	for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
-	ep = p;
-	if (*p)
-	    *p++ = 0;
-	if (c == '-') {
-	    while ((c = *arg++)) {
-		if (c == 'P') {
-		    if (*(uint8_t *)PTOV(0x481) & 0x48) {
-			cp = "yes";
-		    } else {
-			opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL);
-			cp = "no";
-		    }
-		    printf("Keyboard: %s\n", cp);
-		    continue;
+	char *arg = cmd;
+	char *ep, *p, *q;
+	const char *cp;
+	unsigned int drv;
+	int c, i, j;
+	size_t k;
+
+	while ((c = *arg++)) {
+		if (c == ' ' || c == '\t' || c == '\n')
+			continue;
+		for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
+		ep = p;
+		if (*p)
+			*p++ = 0;
+		if (c == '-') {
+			while ((c = *arg++)) {
+				if (c == 'P') {
+					if (*(uint8_t *)PTOV(0x481) & 0x48) {
+						cp = "yes";
+					} else {
+						opts |= OPT_SET(RBX_DUAL) |
+						    OPT_SET(RBX_SERIAL);
+						cp = "no";
+					}
+					printf("Keyboard: %s\n", cp);
+					continue;
 #if SERIAL
-		} else if (c == 'S') {
-		    j = 0;
-		    while ((unsigned int)(i = *arg++ - '0') <= 9)
-			j = j * 10 + i;
-		    if (j > 0 && i == -'0') {
-			comspeed = j;
-			break;
-		    }
-		    /* Fall through to error below ('S' not in optstr[]). */
+				} else if (c == 'S') {
+					j = 0;
+					while ((unsigned int)(i = *arg++ - '0') <= 9)
+						j = j * 10 + i;
+					if (j > 0 && i == -'0') {
+						comspeed = j;
+						break;
+					}
+					/*
+					 * Fall through to error below
+					 * ('S' not in optstr[]).
+					 */
 #endif
-		}
-		for (i = 0; c != optstr[i]; i++)
-		    if (i == NOPT - 1)
-			return -1;
-		opts ^= OPT_SET(flags[i]);
-	    }
+				}
+				for (i = 0; c != optstr[i]; i++)
+					if (i == NOPT - 1)
+						return (-1);
+				opts ^= OPT_SET(flags[i]);
+			}
 #if SERIAL
-	    ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
-		     OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
-	    if (DO_SIO) {
-	        if (sio_init(115200 / comspeed) != 0)
-		    ioctrl &= ~IO_SERIAL;
-	    }
+			ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
+			    OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
+			if (DO_SIO) {
+				if (sio_init(115200 / comspeed) != 0)
+					ioctrl &= ~IO_SERIAL;
+			}
 #endif
-	} else {
-	    for (q = arg--; *q && *q != '('; q++);
-	    if (*q) {
-		drv = -1;
-		if (arg[1] == ':') {
-		    drv = *arg - '0';
-		    if (drv > 9)
-			return (-1);
-		    arg += 2;
-		}
-		if (q - arg != 2)
-		    return -1;
-		for (i = 0; arg[0] != dev_nm[i][0] ||
-			    arg[1] != dev_nm[i][1]; i++)
-		    if (i == NDEV - 1)
-			return -1;
-		dsk.type = i;
-		arg += 3;
-		dsk.unit = *arg - '0';
-		if (arg[1] != ',' || dsk.unit > 9)
-		    return -1;
-		arg += 2;
-		dsk.slice = WHOLE_DISK_SLICE;
-		if (arg[1] == ',') {
-		    dsk.slice = *arg - '0' + 1;
-		    if (dsk.slice > PC98_NPARTS + 1)
-			return -1;
-		    arg += 2;
+		} else {
+			for (q = arg--; *q && *q != '('; q++);
+			if (*q) {
+				drv = -1;
+				if (arg[1] == ':') {
+					drv = *arg - '0';
+					if (drv > 9)
+						return (-1);
+					arg += 2;
+				}
+				if (q - arg != 2)
+					return (-1);
+				for (i = 0; arg[0] != dev_nm[i][0] ||
+				    arg[1] != dev_nm[i][1]; i++)
+					if (i == NDEV - 1)
+						return (-1);
+				dsk.type = i;
+				arg += 3;
+				dsk.unit = *arg - '0';
+				if (arg[1] != ',' || dsk.unit > 9)
+					return (-1);
+				arg += 2;
+				dsk.slice = WHOLE_DISK_SLICE;
+				if (arg[1] == ',') {
+					dsk.slice = *arg - '0' + 1;
+					if (dsk.slice > PC98_NPARTS + 1)
+						return (-1);
+					arg += 2;
+				}
+				if (arg[1] != ')')
+					return (-1);
+				dsk.part = *arg - 'a';
+				if (dsk.part > 7)
+					return (-1);
+				arg += 2;
+				if (drv == -1)
+					drv = dsk.unit;
+				dsk.disk = dev_daua[dsk.type];
+				dsk.daua = dsk.disk | dsk.unit;
+				dsk_meta = 0;
+			}
+			k = ep - arg;
+			if (k > 0) {
+				if (k >= sizeof(knamebuf))
+					return (-1);
+				memcpy(knamebuf, arg, k + 1);
+				kname = knamebuf;
+			}
 		}
-		if (arg[1] != ')')
-		    return -1;
-		dsk.part = *arg - 'a';
-		if (dsk.part > 7)
-		    return (-1);
-		arg += 2;
-		if (drv == -1)
-		    drv = dsk.unit;
-		dsk.disk = dev_daua[dsk.type];
-		dsk.daua = dsk.disk | dsk.unit;
-		dsk_meta = 0;
-	    }
-	    k = ep - arg;
-	    if (k > 0) {
-		if (k >= sizeof(knamebuf))
-		    return -1;
-		memcpy(knamebuf, arg, k + 1);
-		kname = knamebuf;
-	    }
+		arg = p;
 	}
-	arg = p;
-    }
-    return 0;
+	return (0);
 }
 
 static int
 dskread(void *buf, unsigned lba, unsigned nblk)
 {
-    struct pc98_partition *dp;
-    struct disklabel *d;
-    char *sec;
-    unsigned i;
-    uint8_t sl;
-    u_char *p;
-    const char *reason;
-
-    if (!dsk_meta) {
-	sec = dmadat->secbuf;
-	set_dsk();
-	if (dsk.type == TYPE_FD)
-	    goto unsliced;
-	if (drvread(sec, PC98_BBSECTOR))
-	    return -1;
-	dp = (void *)(sec + PC98_PARTOFF);
-	sl = dsk.slice;
-	if (sl < BASE_SLICE) {
-	    for (i = 0; i < PC98_NPARTS; i++)
-		if (dp[i].dp_mid == DOSMID_386BSD) {
-		    sl = BASE_SLICE + i;
-		    break;
+	struct pc98_partition *dp;
+	struct disklabel *d;
+	char *sec;
+	unsigned i;
+	uint8_t sl;
+	u_char *p;
+	const char *reason;
+
+	if (!dsk_meta) {
+		sec = dmadat->secbuf;
+		set_dsk();
+		if (dsk.type == TYPE_FD)
+			goto unsliced;
+		if (drvread(sec, PC98_BBSECTOR))
+			return -1;
+		dp = (void *)(sec + PC98_PARTOFF);
+		sl = dsk.slice;
+		if (sl < BASE_SLICE) {
+			for (i = 0; i < PC98_NPARTS; i++)
+				if (dp[i].dp_mid == DOSMID_386BSD) {
+					sl = BASE_SLICE + i;
+					break;
+				}
+			dsk.slice = sl;
 		}
-	    dsk.slice = sl;
-	}
-	if (sl != WHOLE_DISK_SLICE) {
-	    dp += sl - BASE_SLICE;
-	    if (dp->dp_mid != DOSMID_386BSD) {
-		reason = "slice";
-		goto error;
-	    }
-	    dsk.start = dp->dp_scyl * dsk.head * dsk.sec +
-		dp->dp_shd * dsk.sec + dp->dp_ssect;
+		if (sl != WHOLE_DISK_SLICE) {
+			dp += sl - BASE_SLICE;
+			if (dp->dp_mid != DOSMID_386BSD) {
+				reason = "slice";
+				goto error;
+			}
+			dsk.start = dp->dp_scyl * dsk.head * dsk.sec +
+				dp->dp_shd * dsk.sec + dp->dp_ssect;
+		}
+		if (drvread(sec, dsk.start + LABELSECTOR))
+			return -1;
+		d = (void *)(sec + LABELOFFSET);
+		if (d->d_magic != DISKMAGIC || d->d_magic2 != DISKMAGIC) {
+			if (dsk.part != RAW_PART) {
+				reason = "label";
+				goto error;
+			}
+		} else {
+			if (dsk.part >= d->d_npartitions ||
+			    !d->d_partitions[dsk.part].p_size) {
+				reason = "partition";
+				goto error;
+			}
+			dsk.start += d->d_partitions[dsk.part].p_offset;
+			dsk.start -= d->d_partitions[RAW_PART].p_offset;
+		}
+	unsliced: ;
 	}
-	if (drvread(sec, dsk.start + LABELSECTOR))
-		return -1;
-	d = (void *)(sec + LABELOFFSET);
-	if (d->d_magic != DISKMAGIC || d->d_magic2 != DISKMAGIC) {
-	    if (dsk.part != RAW_PART) {
-		reason = "label";
-		goto error;
-	    }
-	} else {
-	    if (dsk.part >= d->d_npartitions ||
-		!d->d_partitions[dsk.part].p_size) {
-		reason = "partition";
-		goto error;
-	    }
-	    dsk.start += d->d_partitions[dsk.part].p_offset;
-	    dsk.start -= d->d_partitions[RAW_PART].p_offset;
+	for (p = buf; nblk; p += 512, lba++, nblk--) {
+		if ((i = drvread(p, dsk.start + lba)))
+			return (i);
 	}
-    unsliced: ;
-    }
-    for (p = buf; nblk; p += 512, lba++, nblk--) {
-	if ((i = drvread(p, dsk.start + lba)))
-	    return i;
-    }
-    return 0;
+	return (0);
 error:
-    printf("Invalid %s\n", reason);
-    return -1;
+	printf("Invalid %s\n", reason);
+	return (-1);
 }
 
 static void
 printf(const char *fmt,...)
 {
-    va_list ap;
-    static char buf[10];
-    char *s;
-    unsigned u;
-    int c;
-
-    va_start(ap, fmt);
-    while ((c = *fmt++)) {
-	if (c == '%') {
-	    c = *fmt++;
-	    switch (c) {
-	    case 'c':
-		putchar(va_arg(ap, int));
-		continue;
-	    case 's':
-		for (s = va_arg(ap, char *); *s; s++)
-		    putchar(*s);
-		continue;
-	    case 'u':
-		u = va_arg(ap, unsigned);
-		s = buf;
-		do
-		    *s++ = '0' + u % 10U;
-		while (u /= 10U);
-		while (--s >= buf)
-		    putchar(*s);
-		continue;
-	    }
+	va_list ap;
+	static char buf[10];
+	char *s;
+	unsigned u;
+	int c;
+
+	va_start(ap, fmt);
+	while ((c = *fmt++)) {
+		if (c == '%') {
+			c = *fmt++;
+			switch (c) {
+			case 'c':
+				putchar(va_arg(ap, int));
+				continue;
+			case 's':
+				for (s = va_arg(ap, char *); *s; s++)
+					putchar(*s);
+				continue;
+			case 'u':
+				u = va_arg(ap, unsigned);
+				s = buf;
+				do
+					*s++ = '0' + u % 10U;
+				while (u /= 10U);
+				while (--s >= buf)
+					putchar(*s);
+				continue;
+			}
+		}
+		putchar(c);
 	}
-	putchar(c);
-    }
-    va_end(ap);
-    return;
+	va_end(ap);
+	return;
 }
 
 static void
 putchar(int c)
 {
-    if (c == '\n')
-	xputc('\r');
-    xputc(c);
+
+	if (c == '\n')
+		xputc('\r');
+	xputc(c);
 }
 
 static int
 drvread(void *buf, unsigned lba)
 {
-    static unsigned c = 0x2d5c7c2f;
-    unsigned bpc, x, cyl, head, sec;
-
-    bpc = dsk.sec * dsk.head;
-    cyl = lba / bpc;
-    x = lba % bpc;
-    head = x / dsk.sec;
-    sec = x % dsk.sec;
-
-    if (!OPT_CHECK(RBX_QUIET)) {
-	xputc(c = c << 8 | c >> 24);
-	xputc('\b');
-    }
-    v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
-    v86.addr = READORG;		/* call to read in boot1 */
-    v86.ecx = cyl;
-    v86.edx = (head << 8) | sec;
-    v86.edi = lba;
-    v86.ebx = 512;
-    v86.es = VTOPSEG(buf);
-    v86.ebp = VTOPOFF(buf);
-    v86int();
-    v86.ctl = V86_FLAGS;
-    if (V86_CY(v86.efl)) {
-	printf("error %u c/h/s %u/%u/%u lba %u\n", v86.eax >> 8 & 0xff,
-	       cyl, head, sec, lba);
-	return -1;
-    }
-    return 0;
+	static unsigned c = 0x2d5c7c2f;
+	unsigned bpc, x, cyl, head, sec;
+
+	bpc = dsk.sec * dsk.head;
+	cyl = lba / bpc;
+	x = lba % bpc;
+	head = x / dsk.sec;
+	sec = x % dsk.sec;
+	
+	if (!OPT_CHECK(RBX_QUIET)) {
+		xputc(c = c << 8 | c >> 24);
+		xputc('\b');
+	}
+	v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
+	v86.addr = READORG;		/* call to read in boot1 */
+	v86.ecx = cyl;
+	v86.edx = (head << 8) | sec;
+	v86.edi = lba;
+	v86.ebx = 512;
+	v86.es = VTOPSEG(buf);
+	v86.ebp = VTOPOFF(buf);
+	v86int();
+	v86.ctl = V86_FLAGS;
+	if (V86_CY(v86.efl)) {
+		printf("error %u c/h/s %u/%u/%u lba %u\n", v86.eax >> 8 & 0xff,
+		    cyl, head, sec, lba);
+		return (-1);
+	}
+	return (0);
 }
 
 static inline void
 delay(void)
 {
-    int i;
+	int i;
 
-    i = 800;
-    do {
-	outb(0x5f, 0);	/* about 600ns */
-    } while (--i >= 0);
+	i = 800;
+	do {
+		outb(0x5f, 0);	/* about 600ns */
+	} while (--i >= 0);
 }
 
 static int
 keyhit(unsigned sec)
 {
-    unsigned i;
-
-    if (OPT_CHECK(RBX_NOINTR))
-	return 0;
-    for (i = 0; i < sec * 1000; i++) {
-	if (xgetc(1))
-	    return 1;
-	delay();
-    }
-    return 0;
+	unsigned i;
+
+	if (OPT_CHECK(RBX_NOINTR))
+		return (0);
+	for (i = 0; i < sec * 1000; i++) {
+		if (xgetc(1))
+			return (1);
+		delay();
+	}
+	return (0);
 }
 
 static int
 xputc(int c)
 {
-    if (DO_KBD)
-	putc(c);
-    if (DO_SIO)
-	sio_putc(c);
-    return c;
+
+	if (DO_KBD)
+		putc(c);
+	if (DO_SIO)
+		sio_putc(c);
+	return (c);
 }
 
 static int
 getc(int fn)
 {
-    v86.addr = 0x18;
-    v86.eax = fn << 8;
-    v86int();
-    if (fn)
-	return (v86.ebx >> 8) & 0x01;
-    else
-	return v86.eax & 0xff;
+
+	v86.addr = 0x18;
+	v86.eax = fn << 8;
+	v86int();
+	if (fn)
+		return ((v86.ebx >> 8) & 0x01);
+	else
+		return (v86.eax & 0xff);
 }
 
 static int
 xgetc(int fn)
 {
-    if (OPT_CHECK(RBX_NOINTR))
-	return 0;
-    for (;;) {
-	if (DO_KBD && getc(1))
-	    return fn ? 1 : getc(0);
-	if (DO_SIO && sio_ischar())
-	    return fn ? 1 : sio_getc();
-	if (fn)
-	    return 0;
-    }
+
+	if (OPT_CHECK(RBX_NOINTR))
+		return (0);
+	for (;;) {
+		if (DO_KBD && getc(1))
+			return (fn ? 1 : getc(0));
+		if (DO_SIO && sio_ischar())
+			return (fn ? 1 : sio_getc());
+		if (fn)
+			return (0);
+	}
 }
diff --git a/stand/pc98/libpc98/bioscd.c b/stand/pc98/libpc98/bioscd.c
index 3b29c21..1ef14f7 100644
--- a/stand/pc98/libpc98/bioscd.c
+++ b/stand/pc98/libpc98/bioscd.c
@@ -94,9 +94,9 @@ static int nbcinfo = 0;
 static int	bc_read(int unit, daddr_t dblk, int blks, caddr_t dest);
 static int	bc_init(void);
 static int	bc_strategy(void *devdata, int flag, daddr_t dblk,
-		    size_t size, char *buf, size_t *rsize);
+    size_t size, char *buf, size_t *rsize);
 static int	bc_realstrategy(void *devdata, int flag, daddr_t dblk,
-		    size_t size, char *buf, size_t *rsize);
+    size_t size, char *buf, size_t *rsize);
 static int	bc_open(struct open_file *f, ...);
 static int	bc_close(struct open_file *f);
 static int	bc_print(int verbose);
diff --git a/stand/pc98/libpc98/biosdisk.c b/stand/pc98/libpc98/biosdisk.c
index b13e96f..0d7ac6f 100644
--- a/stand/pc98/libpc98/biosdisk.c
+++ b/stand/pc98/libpc98/biosdisk.c
@@ -92,49 +92,48 @@ struct open_disk {
  */
 static struct bdinfo
 {
-    int		bd_unit;		/* BIOS unit number */
-    int		bd_flags;
-    int		bd_type;		/* BIOS 'drive type' (floppy only) */
-    int		bd_da_unit;		/* kernel unit number for da */
-    int		bd_open;		/* reference counter */
-    void	*bd_bcache;		/* buffer cache data */
+	int		bd_unit;	/* BIOS unit number */
+	int		bd_flags;
+	int		bd_type;	/* BIOS 'drive type' (floppy only) */
+	int		bd_da_unit;	/* kernel unit number for da */
+	int		bd_open;	/* reference counter */
+	void		*bd_bcache;	/* buffer cache data */
 } bdinfo [MAXBDDEV];
 static int nbdinfo = 0;
 
 #define	BD(dev)	(bdinfo[(dev)->dd.d_unit])
 
-static int	bd_getgeom(struct open_disk *od);
-static int	bd_read(struct open_disk *od, daddr_t dblk, int blks,
-		    caddr_t dest);
-static int	bd_write(struct open_disk *od, daddr_t dblk, int blks,
-		    caddr_t dest);
-
-static int	bd_int13probe(struct bdinfo *bd);
-
-static int	bd_printslice(struct open_disk *od, struct pc98_partition *dp,
-		    char *prefix, int verbose);
-static int	bd_printbsdslice(struct open_disk *od, daddr_t offset,
-		    char *prefix, int verbose);
-
-static int	bd_init(void);
-static int	bd_strategy(void *devdata, int flag, daddr_t dblk,
-		    size_t size, char *buf, size_t *rsize);
-static int	bd_realstrategy(void *devdata, int flag, daddr_t dblk,
-		    size_t size, char *buf, size_t *rsize);
-static int	bd_open(struct open_file *f, ...);
-static int	bd_close(struct open_file *f);
-static int	bd_print(int verbose);
+static int bd_getgeom(struct open_disk *od);
+static int bd_read(struct open_disk *od, daddr_t dblk, int blks,
+    caddr_t dest);
+static int bd_write(struct open_disk *od, daddr_t dblk, int blks,
+    caddr_t dest);
+static int bd_int13probe(struct bdinfo *bd);
+
+static int bd_printslice(struct open_disk *od, struct pc98_partition *dp,
+    char *prefix, int verbose);
+static int bd_printbsdslice(struct open_disk *od, daddr_t offset,
+    char *prefix, int verbose);
+
+static int bd_init(void);
+static int bd_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
+    char *buf, size_t *rsize);
+static int bd_realstrategy(void *devdata, int flag, daddr_t dblk, size_t size,
+    char *buf, size_t *rsize);
+static int bd_open(struct open_file *f, ...);
+static int bd_close(struct open_file *f);
+static int bd_print(int verbose);
 
 struct devsw biosdisk = {
-    "disk", 
-    DEVT_DISK, 
-    bd_init,
-    bd_strategy, 
-    bd_open, 
-    bd_close, 
-    noioctl,
-    bd_print,
-    NULL
+	"disk", 
+	DEVT_DISK, 
+	bd_init,
+	bd_strategy, 
+	bd_open, 
+	bd_close, 
+	noioctl,
+	bd_print,
+	NULL
 };
 
 static int	bd_opendisk(struct open_disk **odp, struct i386_devdesc *dev);
@@ -149,70 +148,78 @@ static void	bd_checkextended(struct open_disk *od, int slicenum);
 int
 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);
-	if (bdinfo[i].bd_unit == biosdev)
-	    return(i);
-    }
-    return(-1);
+	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);
+		if (bdinfo[i].bd_unit == biosdev)
+			return (i);
+	}
+	return (-1);
 }
 
 int
 bd_unit2bios(int unit)
 {
-    if ((unit >= 0) && (unit < nbdinfo))
-	return(bdinfo[unit].bd_unit);
-    return(-1);
+
+	if ((unit >= 0) && (unit < nbdinfo))
+		return (bdinfo[unit].bd_unit);
+	return (-1);
 }
 
-/*    
+/*
  * Quiz the BIOS for disk devices, save a little info about them.
  */
 static int
-bd_init(void) 
+bd_init(void)
 {
-    int		base, unit;
-    int		da_drive=0, n=-0x10;
-
-    /* sequence 0x90, 0x80, 0xa0 */
-    for (base = 0x90; base <= 0xa0; base += n, n += 0x30) {
-	for (unit = base; (nbdinfo < MAXBDDEV) || ((unit & 0x0f) < 4); unit++) {
-	    bdinfo[nbdinfo].bd_open = 0;
-	    bdinfo[nbdinfo].bd_bcache = NULL;
-	    bdinfo[nbdinfo].bd_unit = unit;
-	    bdinfo[nbdinfo].bd_flags = (unit & 0xf0) == 0x90 ? BD_FLOPPY : 0;
-
-	    if (!bd_int13probe(&bdinfo[nbdinfo])){
-		if (((unit & 0xf0) == 0x90 && (unit & 0x0f) < 4) ||
-		    ((unit & 0xf0) == 0xa0 && (unit & 0x0f) < 6))
-		    continue;	/* Target IDs are not contiguous. */
-		else
-		    break;
-	    }
+	int base, unit;
+	int da_drive=0, n=-0x10;
+
+	/* sequence 0x90, 0x80, 0xa0 */
+	for (base = 0x90; base <= 0xa0; base += n, n += 0x30) {
+		for (unit = base; (nbdinfo < MAXBDDEV) || ((unit & 0x0f) < 4);
+		     unit++) {
+			bdinfo[nbdinfo].bd_open = 0;
+			bdinfo[nbdinfo].bd_bcache = NULL;
+			bdinfo[nbdinfo].bd_unit = unit;
+			bdinfo[nbdinfo].bd_flags =
+				(unit & 0xf0) == 0x90 ? BD_FLOPPY : 0;
+			if (!bd_int13probe(&bdinfo[nbdinfo])) {
+				if (((unit & 0xf0) == 0x90 &&
+					(unit & 0x0f) < 4) ||
+				    ((unit & 0xf0) == 0xa0 &&
+					(unit & 0x0f) < 6))
+					/* Target IDs are not contiguous. */
+					continue;
+				else
+					break;
+			}
 
-	    if (bdinfo[nbdinfo].bd_flags & BD_FLOPPY){
-		/* available 1.44MB access? */
-		if (*(u_char *)PTOV(0xA15AE) & (1<<(unit & 0xf))) {
-		    /* boot media 1.2MB FD? */
-		    if ((*(u_char *)PTOV(0xA1584) & 0xf0) != 0x90)
-		        bdinfo[nbdinfo].bd_unit = 0x30 + (unit & 0xf);
+			if (bdinfo[nbdinfo].bd_flags & BD_FLOPPY) {
+				/* available 1.44MB access? */
+				if (*(u_char *)PTOV(0xA15AE) &
+				    (1<<(unit & 0xf))) {
+					/* boot media 1.2MB FD? */
+					if ((*(u_char *)PTOV(0xA1584) &
+						0xf0) != 0x90)
+						bdinfo[nbdinfo].bd_unit =
+							0x30 + (unit & 0xf);
+				}
+			} else {
+				if ((unit & 0xF0) == 0xA0) /* SCSI HD or MO */
+					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++;
 		}
-	    }
-	    else {
-		if ((unit & 0xF0) == 0xA0)	/* SCSI HD or MO */
-		    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++;
 	}
-    }
-    bcache_add_dev(nbdinfo);
-    return(0);
+	bcache_add_dev(nbdinfo);
+	return(0);
 }
 
 /*
@@ -221,29 +228,30 @@ bd_init(void)
 static int
 bd_int13probe(struct bdinfo *bd)
 {
-    int addr;
+	int addr;
 
-    if (bd->bd_flags & BD_FLOPPY) {
-	addr = 0xa155c;
-    } else {
-	if ((bd->bd_unit & 0xf0) == 0x80)
-	    addr = 0xa155d;
-	else
-	    addr = 0xa1482;
-    }
-    if ( *(u_char *)PTOV(addr) & (1<<(bd->bd_unit & 0x0f))) {
-	bd->bd_flags |= BD_MODEINT13;
-	return(1);
-    }
-    if ((bd->bd_unit & 0xF0) == 0xA0) {
-	int media = ((unsigned *)PTOV(0xA1460))[bd->bd_unit & 0x0F] & 0x1F;
+	if (bd->bd_flags & BD_FLOPPY) {
+		addr = 0xa155c;
+	} else {
+		if ((bd->bd_unit & 0xf0) == 0x80)
+			addr = 0xa155d;
+		else
+			addr = 0xa1482;
+	}
+	if ( *(u_char *)PTOV(addr) & (1<<(bd->bd_unit & 0x0f))) {
+		bd->bd_flags |= BD_MODEINT13;
+		return (1);
+	}
+	if ((bd->bd_unit & 0xF0) == 0xA0) {
+		int media =
+			((unsigned *)PTOV(0xA1460))[bd->bd_unit & 0x0F] & 0x1F;
 
-	if (media == 7) { /* MO */
-	    bd->bd_flags |= BD_MODEINT13 | BD_OPTICAL;
-	    return(1);
+		if (media == 7) { /* MO */
+			bd->bd_flags |= BD_MODEINT13 | BD_OPTICAL;
+			return(1);
+		}
 	}
-    }
-    return(0);
+	return (0);
 }
 
 /*
@@ -252,72 +260,74 @@ bd_int13probe(struct bdinfo *bd)
 static int
 bd_print(int verbose)
 {
-    int				i, j, ret = 0;
-    char			line[80];
-    struct i386_devdesc		dev;
-    struct open_disk		*od;
-    struct pc98_partition	*dptr;
+	int i, j, ret = 0;
+	char line[80];
+	struct i386_devdesc dev;
+	struct open_disk *od;
+	struct pc98_partition *dptr;
     
-    if (nbdinfo == 0)
-	return (0);
-
-    printf("%s devices:", biosdisk.dv_name);
-    if ((ret = pager_output("\n")) != 0)
-	return (ret);
-
-    for (i = 0; i < nbdinfo; i++) {
-	snprintf(line, sizeof(line), "    disk%d:   BIOS drive %c:\n",
-	    i, 'A' + i);
-	if ((ret = pager_output(line)) != 0)
-	    break;
-
-	/* try to open the whole disk */
-	dev.dd.d_unit = i;
-	dev.d_kind.biosdisk.slice = -1;
-	dev.d_kind.biosdisk.partition = -1;
-	
-	if (!bd_opendisk(&od, &dev)) {
+	if (nbdinfo == 0)
+		return (0);
 
-	    /* Do we have a partition table? */
-	    if (od->od_flags & BD_PARTTABOK) {
-		dptr = &od->od_slicetab[0];
+	printf("%s devices:", biosdisk.dv_name);
+	if ((ret = pager_output("\n")) != 0)
+		return (ret);
 
-		/* Check for a "dedicated" disk */
-		for (j = 0; j < od->od_nslices; j++) {
-		    snprintf(line, sizeof(line), "      disk%ds%d", i, j + 1);
-		    if ((ret = bd_printslice(od, &dptr[j], line, verbose)) != 0)
+	for (i = 0; i < nbdinfo; i++) {
+		snprintf(line, sizeof(line), "    disk%d:   BIOS drive %c:\n",
+		    i, 'A' + i);
+		if ((ret = pager_output(line)) != 0)
 			break;
+
+		/* try to open the whole disk */
+		dev.dd.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? */
+			if (od->od_flags & BD_PARTTABOK) {
+				dptr = &od->od_slicetab[0];
+
+				/* Check for a "dedicated" disk */
+				for (j = 0; j < od->od_nslices; j++) {
+					snprintf(line, sizeof(line),
+					    "      disk%ds%d", i, j + 1);
+					if ((ret = bd_printslice(od, &dptr[j],
+						    line, verbose)) != 0)
+						break;
+				}
+			}
+			bd_closedisk(od);
+			if (ret != 0)
+				break;
 		}
-	    }
-	    bd_closedisk(od);
-	    if (ret != 0)
-		break;
 	}
-    }
-    return (ret);
+	return (ret);
 }
 
 /* Given a size in 512 byte sectors, convert it to a human-readable number. */
 static char *
 display_size(uint64_t size)
 {
-    static char buf[80];
-    char unit;
-
-    size /= 2;
-    unit = 'K';
-    if (size >= 10485760000LL) {
-	size /= 1073741824;
-	unit = 'T';
-    } else if (size >= 10240000) {
-	size /= 1048576;
-	unit = 'G';
-    } else if (size >= 10000) {
-	size /= 1024;
-	unit = 'M';
-    }
-    sprintf(buf, "%6ld%cB", (long)size, unit);
-    return (buf);
+	static char buf[80];
+	char unit;
+
+	size /= 2;
+	unit = 'K';
+	if (size >= 10485760000LL) {
+		size /= 1073741824;
+		unit = 'T';
+	} else if (size >= 10240000) {
+		size /= 1048576;
+		unit = 'G';
+	} else if (size >= 10000) {
+		size /= 1024;
+		unit = 'M';
+	}
+	sprintf(buf, "%6ld%cB", (long)size, unit);
+	return (buf);
 }
 
 /*
@@ -760,8 +770,8 @@ bd_strategy(void *devdata, int rw, daddr_t dblk, size_t size,
 }
 
 static int 
-bd_realstrategy(void *devdata, int rw, daddr_t dblk,
-    size_t size, char *buf, size_t *rsize)
+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);
     int			blks;