Index: lib/libstand/stand.h
===================================================================
--- lib/libstand/stand.h
+++ lib/libstand/stand.h
@@ -143,7 +143,7 @@
     int		(*dv_open)(struct open_file *f, ...);
     int		(*dv_close)(struct open_file *f);
     int		(*dv_ioctl)(struct open_file *f, u_long cmd, void *data);
-    void	(*dv_print)(int verbose);	/* print device information */
+    int		(*dv_print)(int verbose);	/* print device information */
     void	(*dv_cleanup)(void);
 };
 
Index: sys/boot/common/dev_net.c
===================================================================
--- sys/boot/common/dev_net.c
+++ sys/boot/common/dev_net.c
@@ -80,7 +80,7 @@
 static int	net_close(struct open_file *);
 static void	net_cleanup(void);
 static int	net_strategy();
-static void	net_print(int);
+static int	net_print(int);
 
 static int net_getparams(int sock);
 
@@ -332,23 +332,32 @@
 	return (0);
 }
 
-static void
+static int
 net_print(int verbose)
 {
 	struct netif_driver *drv;
+	char line[80];
 	int i, d, cnt;
+	int ret = 0;
 
 	cnt = 0;
 	for (d = 0; netif_drivers[d]; d++) {
 		drv = netif_drivers[d];
 		for (i = 0; i < drv->netif_nifs; i++) {
-			printf("\t%s%d:", "net", cnt++);
-			if (verbose)
-				printf(" (%s%d)", drv->netif_bname,
+			snprintf(line, 80, "\t%s%d:", "net", cnt++);
+			ret = pager_output(line);
+			if (ret != 0)
+				break;
+			if (verbose) {
+				snprintf(line, 80, " (%s%d)", drv->netif_bname,
 				    drv->netif_ifs[i].dif_unit);
+				ret = pager_output(line);
+				if (ret != 0)
+					break;
+			}
 		}
 	}
-	printf("\n");
+	return (ret |= pager_output("\n"));
 }
 
 /*
Index: sys/boot/common/disk.h
===================================================================
--- sys/boot/common/disk.h
+++ sys/boot/common/disk.h
@@ -111,7 +111,7 @@
 /*
  * Print information about slices on a disk.
  */
-extern void disk_print(struct disk_devdesc *dev, char *prefix, int verbose);
+extern int disk_print(struct disk_devdesc *dev, char *prefix, int verbose);
 extern char* disk_fmtdev(struct disk_devdesc *dev);
 extern int disk_parsedev(struct disk_devdesc *dev, const char *devspec,
     const char **path);
Index: sys/boot/common/disk.c
===================================================================
--- sys/boot/common/disk.c
+++ sys/boot/common/disk.c
@@ -183,13 +183,14 @@
 }
 
 #define	PWIDTH	35
-static void
+static int
 ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
 {
 	struct print_args *pa, bsd;
 	struct open_disk *od;
 	struct ptable *table;
 	char line[80];
+	int ret = 0;
 
 	pa = (struct print_args *)arg;
 	od = (struct open_disk *)pa->dev->d_opendata;
@@ -200,25 +201,28 @@
 		    display_size(part->end - part->start + 1,
 		    od->sectorsize));
 	strcat(line, "\n");
-	pager_output(line);
+	ret = pager_output(line);
+	if (ret != 0)
+		return (ret);
 	if (part->type == PART_FREEBSD) {
 		/* Open slice with BSD label */
 		pa->dev->d_offset = part->start;
 		table = ptable_open(pa->dev, part->end - part->start + 1,
 		    od->sectorsize, ptblread);
 		if (table == NULL)
-			return;
+			return (ret);
 		sprintf(line, "  %s%s", pa->prefix, pname);
 		bsd.dev = pa->dev;
 		bsd.prefix = line;
 		bsd.verbose = pa->verbose;
-		ptable_iterate(table, &bsd, ptable_print);
+		ret = ptable_iterate(table, &bsd, ptable_print);
 		ptable_close(table);
 	}
+	return (ret);
 }
 #undef PWIDTH
 
-void
+int
 disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
 {
 	struct open_disk *od;
@@ -229,7 +233,7 @@
 	pa.dev = dev;
 	pa.prefix = prefix;
 	pa.verbose = verbose;
-	ptable_iterate(od->table, &pa, ptable_print);
+	return (ptable_iterate(od->table, &pa, ptable_print));
 }
 
 int
Index: sys/boot/common/module.c
===================================================================
--- sys/boot/common/module.c
+++ sys/boot/common/module.c
@@ -250,7 +250,7 @@
     struct kernel_module	*mp;
     struct file_metadata	*md;
     char			lbuf[80];
-    int				ch, verbose;
+    int				ch, verbose, ret = 0;
 
     verbose = 0;
     optind = 1;
@@ -273,11 +273,13 @@
 	pager_output(lbuf);
 	pager_output(fp->f_name);
 	sprintf(lbuf, " (%s, 0x%lx)\n", fp->f_type, (long)fp->f_size);
-	pager_output(lbuf);
+	if (pager_output(lbuf))
+	    break;
 	if (fp->f_args != NULL) {
 	    pager_output("    args: ");
 	    pager_output(fp->f_args);
-	    pager_output("\n");
+	    if (pager_output("\n"))
+		break;
 	}
 	if (fp->f_modules) {
 	    pager_output("  modules: ");
@@ -285,15 +287,19 @@
 		sprintf(lbuf, "%s.%d ", mp->m_name, mp->m_version);
 		pager_output(lbuf);
 	    }
-	    pager_output("\n");
+	    if (pager_output("\n"))
+		break;
 	}
 	if (verbose) {
 	    /* XXX could add some formatting smarts here to display some better */
 	    for (md = fp->f_metadata; md != NULL; md = md->md_next) {
 		sprintf(lbuf, "      0x%04x, 0x%lx\n", md->md_type, (long) md->md_size);
-		pager_output(lbuf);
+		if ((ret = pager_output(lbuf)))
+		    break;
 	    }
 	}
+	if (ret)
+	    break;
     }
     pager_close();
     return(CMD_OK);
Index: sys/boot/common/part.h
===================================================================
--- sys/boot/common/part.h
+++ sys/boot/common/part.h
@@ -63,7 +63,7 @@
 
 /* The offset and size are in sectors */
 typedef int (diskread_t)(void *arg, void *buf, size_t blocks, off_t offset);
-typedef void (ptable_iterate_t)(void *arg, const char *partname,
+typedef int (ptable_iterate_t)(void *arg, const char *partname,
     const struct ptable_entry *part);
 
 struct ptable *ptable_open(void *dev, off_t sectors, uint16_t sectorsize,
@@ -75,7 +75,7 @@
     int index);
 int ptable_getbestpart(const struct ptable *table, struct ptable_entry *part);
 
-void ptable_iterate(const struct ptable *table, void *arg,
+int ptable_iterate(const struct ptable *table, void *arg,
     ptable_iterate_t *iter);
 const char *parttype2str(enum partition_type type);
 
Index: sys/boot/common/part.c
===================================================================
--- sys/boot/common/part.c
+++ sys/boot/common/part.c
@@ -828,11 +828,12 @@
 	return (ENOENT);
 }
 
-void
+int
 ptable_iterate(const struct ptable *table, void *arg, ptable_iterate_t *iter)
 {
 	struct pentry *entry;
 	char name[32];
+	int ret = 0;
 
 	name[0] = '\0';
 	STAILQ_FOREACH(entry, &table->entries, entry) {
@@ -855,7 +856,10 @@
 		if (table->type == PTABLE_BSD)
 			sprintf(name, "%c", (u_char) 'a' +
 			    entry->part.index);
-		iter(arg, name, &entry->part);
+		ret = iter(arg, name, &entry->part);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
Index: sys/boot/common/util.h
===================================================================
--- sys/boot/common/util.h
+++ sys/boot/common/util.h
@@ -48,6 +48,6 @@
 char *strchr(const char *s, char ch);
 size_t strlen(const char *s);
 
-void printf(const char *fmt, ...);
+int printf(const char *fmt, ...);
 
 #endif	/* !_UTIL_H_ */
Index: sys/boot/common/util.c
===================================================================
--- sys/boot/common/util.c
+++ sys/boot/common/util.c
@@ -114,7 +114,7 @@
 	return (len);
 }
 
-void
+int
 printf(const char *fmt, ...)
 {
 	va_list ap;
@@ -173,4 +173,5 @@
 		}
 	}
 	va_end(ap);
+	return (0);
 }
Index: sys/boot/efi/include/efiapi.h
===================================================================
--- sys/boot/efi/include/efiapi.h
+++ sys/boot/efi/include/efiapi.h
@@ -218,9 +218,13 @@
     { 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} }
 
 // Variable attributes
-#define EFI_VARIABLE_NON_VOLATILE           0x00000001
-#define EFI_VARIABLE_BOOTSERVICE_ACCESS     0x00000002
-#define EFI_VARIABLE_RUNTIME_ACCESS         0x00000004
+#define EFI_VARIABLE_NON_VOLATILE		0x00000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS		0x00000002
+#define EFI_VARIABLE_RUNTIME_ACCESS		0x00000004
+#define	EFI_VARIABLE_HARDWARE_ERROR_RECORD	0x00000008
+#define	EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS	0x00000010
+#define	EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS	0x00000020
+#define	EFI_VARIABLE_APPEND_WRITE		0x00000040
 
 // Variable size limitation
 #define EFI_MAXIMUM_VARIABLE_SIZE           1024
Index: sys/boot/efi/libefi/efinet.c
===================================================================
--- sys/boot/efi/libefi/efinet.c
+++ sys/boot/efi/libefi/efinet.c
@@ -245,7 +245,7 @@
 }
 
 static int efinet_dev_init(void);
-static void efinet_dev_print(int);
+static int efinet_dev_print(int);
 
 struct devsw efinet_dev = {
 	.dv_name = "net",
@@ -322,16 +322,19 @@
 	return (0);
 }
 
-static void
+static int
 efinet_dev_print(int verbose)
 {
 	char line[80];
 	EFI_HANDLE h;
-	int unit;
+	int unit, ret;
 
 	for (unit = 0, h = efi_find_handle(&efinet_dev, 0);
 	    h != NULL; h = efi_find_handle(&efinet_dev, ++unit)) {
 		sprintf(line, "    %s%d:\n", efinet_dev.dv_name, unit);
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret)
+		    break;
 	}
+	return (ret);
 }
Index: sys/boot/efi/libefi/efipart.c
===================================================================
--- sys/boot/efi/libefi/efipart.c
+++ sys/boot/efi/libefi/efipart.c
@@ -45,7 +45,7 @@
 static int efipart_strategy(void *, int, daddr_t, size_t, char *, size_t *);
 static int efipart_open(struct open_file *, ...);
 static int efipart_close(struct open_file *);
-static void efipart_print(int);
+static int efipart_print(int);
 
 struct devsw efipart_dev = {
 	.dv_name = "part",
@@ -147,7 +147,7 @@
 	return (err);
 }
 
-static void
+static int
 efipart_print(int verbose)
 {
 	char line[80];
@@ -155,22 +155,26 @@
 	EFI_HANDLE h;
 	EFI_STATUS status;
 	u_int unit;
+	int ret = 0;
 
 	for (unit = 0, h = efi_find_handle(&efipart_dev, 0);
 	    h != NULL; h = efi_find_handle(&efipart_dev, ++unit)) {
 		sprintf(line, "    %s%d:", efipart_dev.dv_name, unit);
-		pager_output(line);
+		ret = pager_output(line);
 
 		status = BS->HandleProtocol(h, &blkio_guid, (void **)&blkio);
 		if (!EFI_ERROR(status)) {
 			sprintf(line, "    %llu blocks",
 			    (unsigned long long)(blkio->Media->LastBlock + 1));
-			pager_output(line);
+			ret = pager_output(line);
 			if (blkio->Media->RemovableMedia)
-				pager_output(" (removable)");
+				ret = pager_output(" (removable)");
 		}
-		pager_output("\n");
+		ret = pager_output("\n");
+		if (ret != 0)
+			break;
 	}
+	return (ret);
 }
 
 static int 
Index: sys/boot/efi/loader/main.c
===================================================================
--- sys/boot/efi/loader/main.c
+++ sys/boot/efi/loader/main.c
@@ -442,6 +442,8 @@
 	UINT32 dver;
 	EFI_STATUS status;
 	int i, ndesc;
+	int rv = 0;
+	char line[80];
 	static char *types[] = {
 	    "Reserved",
 	    "LoaderCode",
@@ -473,14 +475,24 @@
 	}
 
 	ndesc = sz / dsz;
-	printf("%23s %12s %12s %8s %4s\n",
+	snprintf(line, 80, "%23s %12s %12s %8s %4s\n",
 	    "Type", "Physical", "Virtual", "#Pages", "Attr");
+	pager_open();
+	rv = pager_output(line);
+	if (rv) {
+		pager_close();
+		return (CMD_OK);
+	}
 
 	for (i = 0, p = map; i < ndesc;
 	     i++, p = NextMemoryDescriptor(p, dsz)) {
-		printf("%23s %012jx %012jx %08jx ", types[p->Type],
+		snprintf(line, 80, "%23s %012jx %012jx %08jx ", types[p->Type],
 		   (uintmax_t)p->PhysicalStart, (uintmax_t)p->VirtualStart,
 		   (uintmax_t)p->NumberOfPages);
+		rv = pager_output(line);
+		if (rv)
+			break;
+
 		if (p->Attribute & EFI_MEMORY_UC)
 			printf("UC ");
 		if (p->Attribute & EFI_MEMORY_WC)
@@ -497,9 +509,12 @@
 			printf("RP ");
 		if (p->Attribute & EFI_MEMORY_XP)
 			printf("XP ");
-		printf("\n");
+		rv = pager_output("\n");
+		if (rv)
+			break;
 	}
 
+	pager_close();
 	return (CMD_OK);
 }
 
@@ -617,44 +632,70 @@
 command_nvram(int argc, char *argv[])
 {
 	CHAR16 var[128];
-	CHAR16 *data;
+	UINT8 *data;		/* value is in bytes */
 	EFI_STATUS status;
 	EFI_GUID varguid = { 0,0,0,{0,0,0,0,0,0,0,0} };
 	UINTN varsz, datasz, i;
+	UINT32 attr;
 	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
 
 	conout = ST->ConOut;
 
-	/* Initiate the search */
-	status = RS->GetNextVariableName(&varsz, NULL, NULL);
+	pager_open();
+	var[0] = 0;
+	varsz = 128;
+
+	for (status = RS->GetNextVariableName(&varsz, var, &varguid);
+		status != EFI_NOT_FOUND;
+		status = RS->GetNextVariableName(&varsz, var, &varguid)) {
+
+		/*
+		 * as term emu is keeping track on cursor, use putchar().
+		 */
+		for (i = 0; var[i] != 0; i++)
+			putchar(var[i]);
+		varsz = 128;	/* GetNextVariableName() did change it. */
 
-	for (; status != EFI_NOT_FOUND; ) {
-		status = RS->GetNextVariableName(&varsz, var, &varguid);
-		//if (EFI_ERROR(status))
-			//break;
-
-		conout->OutputString(conout, var);
-		printf("=");
+		printf(": Attributes:");
 		datasz = 0;
-		status = RS->GetVariable(var, &varguid, NULL, &datasz, NULL);
-		/* XXX: check status */
-		data = malloc(datasz);
-		status = RS->GetVariable(var, &varguid, NULL, &datasz, data);
+		data = NULL;
+		status = RS->GetVariable(var, &varguid, &attr, &datasz, NULL);
+		if ((data = malloc(datasz)) == NULL)
+			break;
+		status = RS->GetVariable(var, &varguid, &attr, &datasz, data);
 		if (EFI_ERROR(status))
 			printf("<error retrieving variable>");
 		else {
+			if (attr & EFI_VARIABLE_NON_VOLATILE)
+				printf(" NV");
+			if (attr & EFI_VARIABLE_BOOTSERVICE_ACCESS)
+				printf(" BS");
+			if (attr & EFI_VARIABLE_RUNTIME_ACCESS)
+				printf(" RS");
+			if (attr & EFI_VARIABLE_HARDWARE_ERROR_RECORD)
+				printf(" HR");
+			if (attr & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)
+				printf(" AW");
+			if (attr &
+			    EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)
+				printf(" TW");
+			printf(": DataLength: %lld", (long long)datasz);
+#if 0
+/* this needs further investigation */
 			for (i = 0; i < datasz; i++) {
 				if (isalnum(data[i]) || isspace(data[i]))
 					printf("%c", data[i]);
 				else
 					printf("\\x%02x", data[i]);
 			}
+#endif
 		}
-		/* XXX */
-		pager_output("\n");
 		free(data);
+		if (pager_output("\n"))
+			break;
 	}
 
+	pager_close();
 	return (CMD_OK);
 }
 
Index: sys/boot/i386/libfirewire/firewire.c
===================================================================
--- sys/boot/i386/libfirewire/firewire.c
+++ sys/boot/i386/libfirewire/firewire.c
@@ -69,7 +69,7 @@
 		    size_t size, char *buf, size_t *rsize);
 static int	fw_open(struct open_file *f, ...);
 static int	fw_close(struct open_file *f);
-static void	fw_print(int verbose);
+static int	fw_print(int verbose);
 static void	fw_cleanup(void);
 
 void		fw_enable(void);
@@ -148,21 +148,26 @@
 /*
  * Print information about OHCI chips
  */
-static void
+static int
 fw_print(int verbose)
 {
-	int i;
+	char line[80];
+	int i, ret = 0;
 	struct fwohci_softc *sc;
 
 	for (i = 0; i < MAX_OHCI; i ++) {
 		sc = &fwinfo[i];
 		if (sc->state == FWOHCI_STATE_DEAD)
 			break;
-		printf("%d: locator=0x%04x devid=0x%08x"
+		snprintf(line, 80, "%d: locator=0x%04x devid=0x%08x"
 			" base_addr=0x%08x handle=0x%08x bus_id=0x%08x\n",
 			i, sc->locator, sc->devid,
 			sc->base_addr, sc->handle, sc->bus_id);
+		ret = pager_output(line);
+		if (ret != 0)
+			break;
 	}
+	return (ret);
 }
 
 static int 
Index: sys/boot/i386/libi386/bioscd.c
===================================================================
--- sys/boot/i386/libi386/bioscd.c
+++ sys/boot/i386/libi386/bioscd.c
@@ -94,7 +94,7 @@
 		    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 void	bc_print(int verbose);
+static int	bc_print(int verbose);
 
 struct devsw bioscd = {
 	"cd", 
@@ -170,17 +170,20 @@
 /*
  * Print information about disks
  */
-static void
+static int
 bc_print(int verbose)
 {
 	char line[80];
-	int i;
+	int i, ret = 0;
 
 	for (i = 0; i < nbcinfo; i++) {
 		sprintf(line, "    cd%d: Device 0x%x\n", i,
 		    bcinfo[i].bc_sp.sp_devicespec);
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
 /*
Index: sys/boot/i386/libi386/biosdisk.c
===================================================================
--- sys/boot/i386/libi386/biosdisk.c
+++ sys/boot/i386/libi386/biosdisk.c
@@ -105,7 +105,7 @@
 static int bd_open(struct open_file *f, ...);
 static int bd_close(struct open_file *f);
 static int bd_ioctl(struct open_file *f, u_long cmd, void *data);
-static void bd_print(int verbose);
+static int bd_print(int verbose);
 static void bd_cleanup(void);
 
 struct devsw biosdisk = {
@@ -258,18 +258,21 @@
 /*
  * Print information about disks
  */
-static void
+static int
 bd_print(int verbose)
 {
 	static char line[80];
 	struct disk_devdesc dev;
-	int i;
+	int i, ret = 0;
 
 	for (i = 0; i < nbdinfo; i++) {
 		sprintf(line, "    disk%d:   BIOS drive %c:\n", i,
 		    (bdinfo[i].bd_unit < 0x80) ? ('A' + bdinfo[i].bd_unit):
 		    ('C' + bdinfo[i].bd_unit - 0x80));
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+		    return (ret);
+
 		dev.d_dev = &biosdisk;
 		dev.d_unit = i;
 		dev.d_slice = -1;
@@ -280,10 +283,13 @@
 		    (bdinfo[i].bd_flags & BD_FLOPPY) ?
 		    DISK_F_NOCACHE: 0) == 0) {
 			sprintf(line, "    disk%d", i);
-			disk_print(&dev, line, verbose);
+			ret = disk_print(&dev, line, verbose);
 			disk_close(&dev);
+			if (ret != 0)
+			    return (ret);
 		}
 	}
+	return (ret);
 }
 
 /*
Index: sys/boot/i386/libi386/pxe.c
===================================================================
--- sys/boot/i386/libi386/pxe.c
+++ sys/boot/i386/libi386/pxe.c
@@ -75,7 +75,7 @@
 			     size_t size, char *buf, size_t *rsize);
 static int	pxe_open(struct open_file *f, ...);
 static int	pxe_close(struct open_file *f);
-static void	pxe_print(int verbose);
+static int	pxe_print(int verbose);
 static void	pxe_cleanup(void);
 static void	pxe_setnfshandle(char *rootpath);
 
@@ -371,14 +371,16 @@
     return (0);
 }
 
-static void
+static int
 pxe_print(int verbose)
 {
-
+	char line[255];
 	if (pxe_call == NULL)
-		return;
+		return (0);
 
-	printf("    pxe0:    %s:%s\n", inet_ntoa(rootip), rootpath);
+	snprintf(line, 255, "    pxe0:    %s:%s\n", inet_ntoa(rootip),
+		rootpath);
+	return (pager_output(line));
 }
 
 static void
Index: sys/boot/mips/beri/loader/beri_disk_cfi.c
===================================================================
--- sys/boot/mips/beri/loader/beri_disk_cfi.c
+++ sys/boot/mips/beri/loader/beri_disk_cfi.c
@@ -47,7 +47,7 @@
 static void	beri_cfi_disk_cleanup(void);
 static int	beri_cfi_disk_strategy(void *, int, daddr_t, size_t, char *,
 		    size_t *);
-static void	beri_cfi_disk_print(int);
+static int	beri_cfi_disk_print(int);
 
 struct devsw beri_cfi_disk = {
 	.dv_name = "cfi",
@@ -112,14 +112,17 @@
 	return (disk_close(dev));
 }
 
-static void
+static int
 beri_cfi_disk_print(int verbose)
 {
 	struct disk_devdesc dev;
 	char line[80];
+	int ret;
 
 	sprintf(line, "    cfi%d   CFI flash device\n", 0);
-	pager_output(line);
+	ret = pager_output(line);
+	if (ret != 0)
+		return (ret);
 	dev.d_dev = &beri_cfi_disk;
 	dev.d_unit = 0;
 	dev.d_slice = -1;
@@ -127,10 +130,13 @@
 	if (disk_open(&dev, cfi_get_mediasize(),
 	    cfi_get_sectorsize(), 0) == 0) {
 		sprintf(line, "    cfi%d", 0);
-		disk_print(&dev, line, verbose);
+		ret = disk_print(&dev, line, verbose);
 		disk_close(&dev);
+		if (ret != 0)
+		    return (ret);
 	}
 
+	return (ret);
 }
 
 static void
Index: sys/boot/mips/beri/loader/beri_disk_sdcard.c
===================================================================
--- sys/boot/mips/beri/loader/beri_disk_sdcard.c
+++ sys/boot/mips/beri/loader/beri_disk_sdcard.c
@@ -47,7 +47,7 @@
 static void	beri_sdcard_disk_cleanup(void);
 static int	beri_sdcard_disk_strategy(void *, int, daddr_t, size_t, char *,
 		    size_t *);
-static void	beri_sdcard_disk_print(int);
+static int	beri_sdcard_disk_print(int);
 
 struct devsw beri_sdcard_disk = {
 	.dv_name = "sdcard",
@@ -123,9 +123,12 @@
 {
 	struct disk_devdesc dev;
 	char line[80];
+	int ret;
 
 	sprintf(line, "    sdcard%d   Altera SD card drive\n", 0);
-	pager_output(line);
+	ret = pager_output(line);
+	if (ret != 0)
+	    return (ret);
 	dev.d_dev = &beri_sdcard_disk;
 	dev.d_unit = 0;
 	dev.d_slice = -1;
@@ -133,9 +136,12 @@
 	if (disk_open(&dev, altera_sdcard_get_mediasize(),
 	    altera_sdcard_get_sectorsize(), 0) == 0) {
 		sprintf(line, "    sdcard%d", 0);
-		disk_print(&dev, line, verbose);
+		ret = disk_print(&dev, line, verbose);
 		disk_close(&dev);
+		if (ret != 0)
+		    return (ret);
 	}
+	return (ret);
 }
 
 static void
Index: sys/boot/ofw/libofw/ofw_disk.c
===================================================================
--- sys/boot/ofw/libofw/ofw_disk.c
+++ sys/boot/ofw/libofw/ofw_disk.c
@@ -47,7 +47,7 @@
 static int	ofwd_open(struct open_file *f, ...);
 static int	ofwd_close(struct open_file *f);
 static int	ofwd_ioctl(struct open_file *f, u_long cmd, void *data);
-static void	ofwd_print(int verbose);
+static int	ofwd_print(int verbose);
 
 struct devsw ofwdisk = {
 	"block",
@@ -161,8 +161,8 @@
 	return (EINVAL);
 }
 
-static void
+static int
 ofwd_print(int verbose __unused)
 {
-
+	return (0);
 }
Index: sys/boot/pc98/libpc98/bioscd.c
===================================================================
--- sys/boot/pc98/libpc98/bioscd.c
+++ sys/boot/pc98/libpc98/bioscd.c
@@ -93,7 +93,7 @@
 		    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 void	bc_print(int verbose);
+static int	bc_print(int verbose);
 
 struct devsw bioscd = {
 	"cd", 
@@ -166,17 +166,20 @@
 /*
  * Print information about disks
  */
-static void
+static int
 bc_print(int verbose)
 {
 	char line[80];
-	int i;
+	int i, ret = 0;
 
 	for (i = 0; i < nbcinfo; i++) {
 		sprintf(line, "    cd%d: Device 0x%x\n", i,
 		    bcinfo[i].bc_sp.sp_devicespec);
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+		    return (ret);
 	}
+	return (ret);
 }
 
 /*
Index: sys/boot/pc98/libpc98/biosdisk.c
===================================================================
--- sys/boot/pc98/libpc98/biosdisk.c
+++ sys/boot/pc98/libpc98/biosdisk.c
@@ -107,9 +107,9 @@
 
 static int	bd_int13probe(struct bdinfo *bd);
 
-static void	bd_printslice(struct open_disk *od, struct pc98_partition *dp,
+static int	bd_printslice(struct open_disk *od, struct pc98_partition *dp,
 		    char *prefix, int verbose);
-static void	bd_printbsdslice(struct open_disk *od, daddr_t offset,
+static int	bd_printbsdslice(struct open_disk *od, daddr_t offset,
 		    char *prefix, int verbose);
 
 static int	bd_init(void);
@@ -119,7 +119,7 @@
 		    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 void	bd_print(int verbose);
+static int	bd_print(int verbose);
 
 struct devsw biosdisk = {
     "disk", 
@@ -242,10 +242,10 @@
 /*
  * Print information about disks
  */
-static void
+static int
 bd_print(int verbose)
 {
-    int				i, j;
+    int				i, j, ret = 0;
     char			line[80];
     struct i386_devdesc		dev;
     struct open_disk		*od;
@@ -253,7 +253,9 @@
     
     for (i = 0; i < nbdinfo; i++) {
 	sprintf(line, "    disk%d:   BIOS drive %c:\n", i, 'A' + i);
-	pager_output(line);
+	ret = pager_output(line);
+	if (ret != 0)
+	    return (ret);
 
 	/* try to open the whole disk */
 	dev.d_unit = i;
@@ -269,12 +271,17 @@
 		/* Check for a "dedicated" disk */
 		for (j = 0; j < od->od_nslices; j++) {
 		    sprintf(line, "      disk%ds%d", i, j + 1);
-		    bd_printslice(od, &dptr[j], line, verbose);
+		    ret = bd_printslice(od, &dptr[j], line, verbose);
+		    if (ret != 0)
+			break;
 		}
 	    }
 	    bd_closedisk(od);
+	    if (ret != 0)
+		return (ret);
 	}
     }
+    return (ret);
 }
 
 /* Given a size in 512 byte sectors, convert it to a human-readable number. */
@@ -304,11 +311,11 @@
  * Print information about slices on a disk.  For the size calculations we
  * assume a 512 byte sector.
  */
-static void
+static int
 bd_printslice(struct open_disk *od, struct pc98_partition *dp, char *prefix,
 	int verbose)
 {
-	int cylsecs, start, size;
+	int cylsecs, start, size, ret = 0;
 	char stats[80];
 	char line[80];
 
@@ -324,10 +331,9 @@
 
 	switch(dp->dp_mid & PC98_MID_MASK) {
 	case PC98_MID_386BSD:
-		bd_printbsdslice(od, start, prefix, verbose);
-		return;
+		return (bd_printbsdslice(od, start, prefix, verbose));
 	case 0x00:				/* unused partition */
-		return;
+		return (ret);
 	case 0x01:
 		sprintf(line, "%s: FAT-12%s\n", prefix, stats);
 		break;
@@ -343,30 +349,29 @@
 		sprintf(line, "%s: Unknown fs: 0x%x %s\n", prefix, dp->dp_mid,
 		    stats);
 	}
-	pager_output(line);
+	return (pager_output(line));
 }
 
 /*
  * Print out each valid partition in the disklabel of a FreeBSD slice.
  * For size calculations, we assume a 512 byte sector size.
  */
-static void
+static int
 bd_printbsdslice(struct open_disk *od, daddr_t offset, char *prefix,
     int verbose)
 {
     char		line[80];
     char		buf[BIOSDISK_SECSIZE];
     struct disklabel	*lp;
-    int			i;
+    int			i, ret = 0;
 
     /* read disklabel */
     if (bd_read(od, offset + LABELSECTOR, 1, buf))
-	return;
+	return (ret);
     lp =(struct disklabel *)(&buf[0]);
     if (lp->d_magic != DISKMAGIC) {
 	sprintf(line, "%s: FFS  bad disklabel\n", prefix);
-	pager_output(line);
-	return;
+	return (pager_output(line));
     }
     
     /* Print partitions */
@@ -397,9 +402,12 @@
 		    (lp->d_partitions[i].p_fstype == FS_SWAP) ? "swap" : 
 		    (lp->d_partitions[i].p_fstype == FS_VINUM) ? "vinum" :
 		    "FFS");
-	    pager_output(line);
+	    ret = pager_output(line);
+	    if (ret != 0)
+		break;
 	}
     }
+    return (ret);
 }
 
 
Index: sys/boot/powerpc/kboot/hostdisk.c
===================================================================
--- sys/boot/powerpc/kboot/hostdisk.c
+++ sys/boot/powerpc/kboot/hostdisk.c
@@ -37,7 +37,7 @@
 static int hostdisk_open(struct open_file *f, ...);
 static int hostdisk_close(struct open_file *f);
 static int hostdisk_ioctl(struct open_file *f, u_long cmd, void *data);
-static void hostdisk_print(int verbose);
+static int hostdisk_print(int verbose);
 
 struct devsw hostdisk = {
 	"/dev",
@@ -117,9 +117,9 @@
 	return (EINVAL);
 }
 
-static void
+static int
 hostdisk_print(int verbose)
 {
-
+	return (0);
 }
 
Index: sys/boot/powerpc/ps3/ps3cdrom.c
===================================================================
--- sys/boot/powerpc/ps3/ps3cdrom.c
+++ sys/boot/powerpc/ps3/ps3cdrom.c
@@ -49,7 +49,7 @@
 	size_t size, char *buf, size_t *rsize);
 static int ps3cdrom_open(struct open_file *f, ...);
 static int ps3cdrom_close(struct open_file *f);
-static void ps3cdrom_print(int verbose);
+static int ps3cdrom_print(int verbose);
 
 struct devsw ps3cdrom = {
 	"cd",
@@ -149,6 +149,7 @@
 	return 0;
 }
 
-static void ps3cdrom_print(int verbose)
+static int ps3cdrom_print(int verbose)
 {
+	return (0);
 }
Index: sys/boot/powerpc/ps3/ps3disk.c
===================================================================
--- sys/boot/powerpc/ps3/ps3disk.c
+++ sys/boot/powerpc/ps3/ps3disk.c
@@ -61,7 +61,7 @@
 	size_t size, char *buf, size_t *rsize);
 static int ps3disk_open(struct open_file *f, ...);
 static int ps3disk_close(struct open_file *f);
-static void ps3disk_print(int verbose);
+static int ps3disk_print(int verbose);
 
 struct devsw ps3disk = {
 	"disk",
@@ -186,8 +186,9 @@
 	return 0;
 }
 
-static void ps3disk_print(int verbose)
+static int ps3disk_print(int verbose)
 {
+	return (0);
 }
 
 static int ps3disk_open_gpt(struct ps3_devdesc *dev, struct open_dev *od)
Index: sys/boot/uboot/lib/disk.c
===================================================================
--- sys/boot/uboot/lib/disk.c
+++ sys/boot/uboot/lib/disk.c
@@ -77,7 +77,7 @@
 static int stor_open(struct open_file *, ...);
 static int stor_close(struct open_file *);
 static int stor_ioctl(struct open_file *f, u_long cmd, void *data);
-static void stor_print(int);
+static int stor_print(int);
 static void stor_cleanup(void);
 
 struct devsw uboot_storage = {
@@ -236,12 +236,12 @@
 	return (err);
 }
 
-static void
+static int
 stor_print(int verbose)
 {
 	struct disk_devdesc dev;
 	static char line[80];
-	int i;
+	int i, ret = 0;
 
 	for (i = 0; i < stor_info_no; i++) {
 		dev.d_dev = &uboot_storage;
@@ -250,13 +250,18 @@
 		dev.d_partition = -1;
 		sprintf(line, "\tdisk%d (%s)\n", i,
 		    ub_stor_type(SI(&dev).type));
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+			return (ret);
 		if (stor_opendev(&dev) == 0) {
 			sprintf(line, "\tdisk%d", i);
-			disk_print(&dev, line, verbose);
+			ret = disk_print(&dev, line, verbose);
 			disk_close(&dev);
+			if (ret != 0)
+				return (ret);
 		}
 	}
+	return (ret);
 }
 
 static int
Index: sys/boot/usb/storage/umass_loader.c
===================================================================
--- sys/boot/usb/storage/umass_loader.c
+++ sys/boot/usb/storage/umass_loader.c
@@ -49,7 +49,7 @@
 static void umass_disk_cleanup(void);
 static int umass_disk_ioctl(struct open_file *, u_long, void *);
 static int umass_disk_strategy(void *, int, daddr_t, size_t, char *, size_t *);
-static void umass_disk_print(int);
+static int umass_disk_print(int);
 
 struct devsw umass_disk = {
 	.dv_name = "umass",
@@ -169,23 +169,28 @@
 	return (disk_close(dev));
 }
 
-static void
+static int
 umass_disk_print(int verbose)
 {
 	struct disk_devdesc dev;
 
 	memset(&dev, 0, sizeof(dev));
 
-	pager_output("    umass0   UMASS device\n");
+	ret = pager_output("    umass0   UMASS device\n");
+	if (ret != 0)
+		return (ret);
 	dev.d_dev = &umass_disk;
 	dev.d_unit = 0;
 	dev.d_slice = -1;
 	dev.d_partition = -1;
 
 	if (umass_disk_open_sub(&dev) == 0) {
-		disk_print(&dev, "    umass0", verbose);
+		ret = disk_print(&dev, "    umass0", verbose);
 		disk_close(&dev);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
 static void
Index: sys/boot/userboot/userboot/host.c
===================================================================
--- sys/boot/userboot/userboot/host.c
+++ sys/boot/userboot/userboot/host.c
@@ -134,13 +134,13 @@
 	return (0);
 }
 
-static void
+static int
 host_dev_print(int verbose)
 {
 	char line[80];
 
 	sprintf(line, "    host%d:   Host filesystem\n", 0);
-	pager_output(line);
+	return (pager_output(line));
 }
 
 /*
Index: sys/boot/userboot/userboot/userboot_disk.c
===================================================================
--- sys/boot/userboot/userboot/userboot_disk.c
+++ sys/boot/userboot/userboot/userboot_disk.c
@@ -56,7 +56,7 @@
 static int	userdisk_open(struct open_file *f, ...);
 static int	userdisk_close(struct open_file *f);
 static int	userdisk_ioctl(struct open_file *f, u_long cmd, void *data);
-static void	userdisk_print(int verbose);
+static int	userdisk_print(int verbose);
 
 struct devsw userboot_disk = {
 	"disk",
@@ -110,16 +110,18 @@
 /*
  * Print information about disks
  */
-static void
+static int
 userdisk_print(int verbose)
 {
 	struct disk_devdesc dev;
 	char line[80];
-	int i;
+	int i, ret;
 
 	for (i = 0; i < userdisk_maxunit; i++) {
 		sprintf(line, "    disk%d:   Guest drive image\n", i);
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+			return (ret);
 		dev.d_dev = &userboot_disk;
 		dev.d_unit = i;
 		dev.d_slice = -1;
@@ -127,10 +129,13 @@
 		if (disk_open(&dev, ud_info[i].mediasize,
 		    ud_info[i].sectorsize, 0) == 0) {
 			sprintf(line, "    disk%d", i);
-			disk_print(&dev, line, verbose);
+			ret = disk_print(&dev, line, verbose);
 			disk_close(&dev);
+			if (ret != 0)
+				return (ret);
 		}
 	}
+	return (ret);
 }
 
 /*
Index: sys/boot/zfs/zfs.c
===================================================================
--- sys/boot/zfs/zfs.c
+++ sys/boot/zfs/zfs.c
@@ -438,19 +438,19 @@
 	return (ret);
 }
 
-static void
+static int
 zfs_probe_partition(void *arg, const char *partname,
     const struct ptable_entry *part)
 {
 	struct zfs_probe_args *ppa, pa;
 	struct ptable *table;
 	char devname[32];
-	int ret;
+	int ret = 0;
 
 	/* Probe only freebsd-zfs and freebsd partitions */
 	if (part->type != PART_FREEBSD &&
 	    part->type != PART_FREEBSD_ZFS)
-		return;
+		return (ret);
 
 	ppa = (struct zfs_probe_args *)arg;
 	strncpy(devname, ppa->devname, strlen(ppa->devname) - 1);
@@ -458,10 +458,10 @@
 	sprintf(devname, "%s%s:", devname, partname);
 	pa.fd = open(devname, O_RDONLY);
 	if (pa.fd == -1)
-		return;
+		return (ret);
 	ret = zfs_probe(pa.fd, ppa->pool_guid);
 	if (ret == 0)
-		return;
+		return (ret);
 	/* Do we have BSD label here? */
 	if (part->type == PART_FREEBSD) {
 		pa.devname = devname;
@@ -475,6 +475,7 @@
 		}
 	}
 	close(pa.fd);
+	return (0);
 }
 
 int
@@ -513,20 +514,23 @@
 /*
  * Print information about ZFS pools
  */
-static void
+static int
 zfs_dev_print(int verbose)
 {
 	spa_t *spa;
 	char line[80];
+	int ret = 0;
 
 	if (verbose) {
-		spa_all_status();
-		return;
+		return (spa_all_status());
 	}
 	STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
 		sprintf(line, "    zfs:%s\n", spa->spa_name);
-		pager_output(line);
+		ret = pager_output(line);
+		if (ret != 0)
+			break;
 	}
+	return (ret);
 }
 
 /*
@@ -893,4 +897,4 @@
 	}
 
 	return (rv);
-}
\ No newline at end of file
+}
Index: sys/boot/zfs/zfsimpl.c
===================================================================
--- sys/boot/zfs/zfsimpl.c
+++ sys/boot/zfs/zfsimpl.c
@@ -775,7 +775,7 @@
 
 #else
 
-static void
+static int
 pager_printf(const char *fmt, ...)
 {
 	char line[80];
@@ -784,14 +784,14 @@
 	va_start(args, fmt);
 	vsprintf(line, fmt, args);
 	va_end(args);
-	pager_output(line);
+	return (pager_output(line));
 }
 
 #endif
 
 #define STATUS_FORMAT	"        %s %s\n"
 
-static void
+static int
 print_state(int indent, const char *name, vdev_state_t state)
 {
 	int i;
@@ -801,40 +801,56 @@
 	for (i = 0; i < indent; i++)
 		strcat(buf, "  ");
 	strcat(buf, name);
-	pager_printf(STATUS_FORMAT, buf, state_name(state));
+	return (pager_printf(STATUS_FORMAT, buf, state_name(state)));
 	
 }
 
-static void
+static int
 vdev_status(vdev_t *vdev, int indent)
 {
 	vdev_t *kid;
-	print_state(indent, vdev->v_name, vdev->v_state);
+	int ret;
+	ret = print_state(indent, vdev->v_name, vdev->v_state);
+	if (ret != 0)
+		return (ret);
 
 	STAILQ_FOREACH(kid, &vdev->v_children, v_childlink) {
-		vdev_status(kid, indent + 1);
+		ret = vdev_status(kid, indent + 1);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
-static void
+static int
 spa_status(spa_t *spa)
 {
 	static char bootfs[ZFS_MAXNAMELEN];
 	uint64_t rootid;
 	vdev_t *vdev;
-	int good_kids, bad_kids, degraded_kids;
+	int good_kids, bad_kids, degraded_kids, ret;
 	vdev_state_t state;
 
-	pager_printf("  pool: %s\n", spa->spa_name);
+	ret = pager_printf("  pool: %s\n", spa->spa_name);
+	if (ret != 0)
+		return (ret);
+
 	if (zfs_get_root(spa, &rootid) == 0 &&
 	    zfs_rlookup(spa, rootid, bootfs) == 0) {
 		if (bootfs[0] == '\0')
-			pager_printf("bootfs: %s\n", spa->spa_name);
+			ret = pager_printf("bootfs: %s\n", spa->spa_name);
 		else
-			pager_printf("bootfs: %s/%s\n", spa->spa_name, bootfs);
-	}
-	pager_printf("config:\n\n");
-	pager_printf(STATUS_FORMAT, "NAME", "STATE");
+			ret = pager_printf("bootfs: %s/%s\n", spa->spa_name,
+			    bootfs);
+		if (ret != 0)
+			return (ret);
+	}
+	ret = pager_printf("config:\n\n");
+	if (ret != 0)
+		return (ret);
+	ret = pager_printf(STATUS_FORMAT, "NAME", "STATE");
+	if (ret != 0)
+		return (ret);
 
 	good_kids = 0;
 	degraded_kids = 0;
@@ -854,24 +870,35 @@
 	else if ((good_kids + degraded_kids) > 0)
 		state = VDEV_STATE_DEGRADED;
 
-	print_state(0, spa->spa_name, state);
+	ret = print_state(0, spa->spa_name, state);
+	if (ret != 0)
+		return (ret);
 	STAILQ_FOREACH(vdev, &spa->spa_vdevs, v_childlink) {
-		vdev_status(vdev, 1);
+		ret = vdev_status(vdev, 1);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
-static void
+static int
 spa_all_status(void)
 {
 	spa_t *spa;
-	int first = 1;
+	int first = 1, ret = 0;
 
 	STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
-		if (!first)
-			pager_printf("\n");
+		if (!first) {
+			ret = pager_printf("\n");
+			if (ret != 0)
+				return (ret);
+		}
 		first = 0;
-		spa_status(spa);
+		ret = spa_status(spa);
+		if (ret != 0)
+			return (ret);
 	}
+	return (ret);
 }
 
 static int