 @@ -1,14 +1,14 @@
-.\" $NetBSD: nvmectl.8,v 1.2 2016/06/05 09:13:08 wiz Exp $
+.\" $NetBSD: nvmectl.8,v 1.3 2017/04/29 00:06:40 nonaka Exp $
 .\"
 .\" Copyright (c) 2012 Intel Corporation
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions, and the following disclaimer,
 .\"    without modification.
 .\" 2. Redistributions in binary form must reproduce at minimum a disclaimer
 .\"    substantially similar to the "NO WARRANTY" disclaimer below
 .\"    ("Disclaimer") and any redistribution must be conditioned upon
 @@ -22,27 +22,27 @@
 .\" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 .\" HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 .\" STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 .\" IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 .\" POSSIBILITY OF SUCH DAMAGES.
 .\"
 .\" nvmecontrol man page.
 .\"
 .\" Author: Jim Harris <jimharris@FreeBSD.org>
 .\"
-.\" $FreeBSD: head/sbin/nvmecontrol/nvmecontrol.8 299151 2016-05-06 03:11:34Z pfg $
+.\" $FreeBSD: head/sbin/nvmecontrol/nvmecontrol.8 314230 2017-02-25 00:09:16Z imp $
 .\"
 .Dd May 19, 2016
 .Dt NVMECTL 8
 .Os
 .Sh NAME
 .Nm nvmectl
 .Nd NVM Express control utility
 .Sh SYNOPSIS
 .Nm
 .Ic devlist
 .Nm
 .Ic identify
 .Op Fl x Op Fl v
 @@ -52,96 +52,159 @@
 .\".Op Fl p
 .\".Aq Fl n Ar num_threads
 .\".Aq Fl o Ar read|write
 .\".Aq Fl s Ar size_in_bytes
 .\".Aq Fl t Ar time_in_sec
 .\".Aq namespace id
 .\".Nm
 .\".Ic reset
 .\".Aq controller id
 .Nm
 .Ic logpage
 .Op Fl x
 .Op Fl p Ar page_id
 .Op Fl v Ar vendor-string
 .Op Fl b
 .Ar device_id Ns | Ns Ar namespace_id
 .\".Nm
 .\".Ic firmware
 .\".Op Fl a
 .\".Op Fl s Ar slot
 .\".Op Fl f Ar path_to_firmware
 .\".Aq device id
 .Nm
 .Ic power
 .Op Fl l
 .Op Fl p Ar power_state
 .Op Fl w Ar workload_hint
 .Ar device_id
 .Nm
 .Ic wdc cap-diag
 .Op Fl o path_template
 .Ar device id
 .Nm
 .Ic wdc drive-log
 .Op Fl o path_template
 .Ar device id
 .Nm
 .Ic wdc get-crash-dump
 .Op Fl o path_template
 .Ar device id
 .\" .Nm
 .\" .Ic wdc purge
 .\" .Aq device id
 .\" .Nm
 .\" .Ic wdc purge-monitor
 .\" .Aq device id
 .Sh DESCRIPTION
 NVM Express (NVMe) is a storage protocol standard, for SSDs and other
 high-speed storage devices over PCI Express.
 .Pp
 .Ss logpage
 The logpage command knows how to print log pages of various types.
 It also knows about vendor specific log pages from hgst/wdc and intel.
 Page 0xc1 for hgst/wdc contains the advanced smart information about
 the drive.
 Page 0xc1 is read latency stats for intel.
 Page 0xc2 is write latency stats for intel.
 Page 0xc5 is temperature stats for intel.
 Page 0xca is advanced smart information for intel.
 .Pp
 Specifying
 .Fl p
 .Ic help
 will list all valid vendors and pages.
 .Fl x
 will print the page as hex.
 .Fl b
 will print the binary data for the page.
 .Ss wdc
 The various wdc command retrieve log data from the wdc/hgst drives.
 The
 .Fl o
 flag specifies a path template to use to output the files.
 Each file takes the path template (which defaults to nothing), appends
 the drive's serial number and the type of dump it is followed
 by .bin.
 These logs must be sent to the vendor for analysis.
 This tool only provides a way to extract them.
 .Sh EXAMPLES
 .Dl nvmectl devlist
 .Pp
 Display a list of NVMe controllers and namespaces along with their device nodes.
 .Pp
 .Dl nvmectl identify nvme0
 .Pp
 Display a human-readable summary of the nvme0 IDENTIFY_CONTROLLER data.
 .Pp
 .Dl nvmectl identify -x -v nvme0ns1
 .Pp
 Display an hexadecimal dump of the nvme0
 .Dv IDENTIFY_NAMESPACE
 data for namespace 1.
 .\".Pp
 .\".Dl nvmectl perftest -n 32 -o read -s 512 -t 30 nvme0ns1
 .\".Pp
-.\"Run a performance test on nvme0ns1 using 32 kernel threads for 30 seconds.  Each
+.\"Run a performance test on nvme0ns1 using 32 kernel threads for 30 seconds.
-.\"thread will issue a single 512 byte read command.  Results are printed to
+.\"Each thread will issue a single 512 byte read command.
-.\"stdout when 30 seconds expires.
+.\"Results are printed to stdout when 30 seconds expires.
 .\".Pp
 .\".Dl nvmectl reset nvme0
 .\".Pp
 .\"Perform a controller-level reset of the nvme0 controller.
 .Pp
 .Dl nvmectl logpage -p 1 nvme0
 .Pp
 Display a human-readable summary of the nvme0 controller's Error Information Log.
 Log pages defined by the NVMe specification include Error Information Log (ID=1),
 SMART/Health Information Log (ID=2), and Firmware Slot Log (ID=3).
 .Pp
 .Dl nvmectl logpage -p 0xc1 -v wdc nvme0
 .Pp
 Display a human-readable summary of the nvme0's wdc-specific advanced
 SMART data.
 .Pp
 .Dl nvmectl logpage -p 1 -x nvme0
 .Pp
 Display a hexadecimal dump of the nvme0 controller's Error Information Log.
 .Pp
 .Dl nvmectl logpage -p 0xcb -b nvme0 > /tmp/page-cb.bin
 .Pp
 Print the contents of vendor specific page 0xcb as binary data on
 standard out.
 Redirect it to a temporary file.
 .\".Pp
 .\".Dl nvmectl firmware -s 2 -f /tmp/nvme_firmware nvme0
 .\".Pp
 .\"Download the firmware image contained in "/tmp/nvme_firmware" to slot 2 of the
 .\"nvme0 controller, but do not activate the image.
 .\".Pp
 .\".Dl nvmectl firmware -s 4 -a nvme0
 .\".Pp
 .\"Activate the firmware in slot 4 of the nvme0 controller on the next reset.
 .\".Pp
 .\".Dl nvmectl firmware -s 7 -f /tmp/nvme_firmware -a nvme0
 .\".Pp
 .\"Download the firmware image contained in "/tmp/nvme_firmware" to slot 7 of the
 .\"nvme0 controller and activate it on the next reset.
 .Pp
 .Dl nvmectl power -l nvme0
 .Pp
 List all the current power modes.
 .Pp
 .Dl nvmectl power -p 3 nvme0
 .Pp
 Set the current power mode.
 .Pp
 .Dl nvmectl power nvme0
 .Pp
 Get the current power mode.
 .Sh HISTORY
 The nvmecontrol utility appeared in
 .Fx 9.2 .
 .Sh AUTHORS
 .An -nosplit
 nvmecontrol was developed by Intel and originally written by
 .An Jim Harris Aq Mt jimharris@FreeBSD.org .
 .Pp
 This man page was written by
 .An Jim Harris Aq Mt jimharris@FreeBSD.org .

 @@ -1,47 +1,48 @@
-/*	$NetBSD: nvme.h,v 1.1 2016/06/04 16:29:35 nonaka Exp $	*/
+/*	$NetBSD: nvme.h,v 1.2 2017/04/29 00:06:40 nonaka Exp $	*/
 /*-
  * Copyright (C) 2012-2013 Intel Corporation
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
- * $FreeBSD: head/sys/dev/nvme/nvme.h 296617 2016-03-10 17:13:10Z mav $
+ * $FreeBSD: head/sys/dev/nvme/nvme.h 314888 2017-03-07 23:02:59Z imp $
  */
 #ifndef __NVME_H__
 #define __NVME_H__
-#define	NVME_MAX_XFER_SIZE	MAXPHYS
+/* Cap nvme to 1MB transfers driver explodes with larger sizes */
 #define NVME_MAX_XFER_SIZE		(MAXPHYS < (1<<20) ? MAXPHYS : (1<<20))
 /* Get/Set Features */
 #define	NVME_FEAT_ARBITRATION				0x01
 #define	NVME_FEAT_POWER_MANAGEMENT			0x02
 #define	NVME_FEAT_LBA_RANGE_TYPE			0x03
 #define	NVME_FEAT_TEMPERATURE_THRESHOLD			0x04
 #define	NVME_FEAT_ERROR_RECOVERY			0x05
 #define	NVME_FEAT_VOLATILE_WRITE_CACHE			0x06
 #define	NVME_FEAT_NUMBER_OF_QUEUES			0x07
 #define	NVME_FEAT_INTERRUPT_COALESCING			0x08
 #define	NVME_FEAT_INTERRUPT_VECTOR_CONFIGURATION	0x09
 #define	NVME_FEAT_WRITE_ATOMICITY_NORMAL		0x0a
 #define	NVME_FEAT_ASYNC_EVENT_CONFIGURATION		0x0b
 @@ -50,26 +51,39 @@
 /* NVM Command Set specific */
 #define	NVME_FEAT_SOFTWARE_PROGRESS_MARKER		0x80
 #define	NVME_FEAT_HOST_IDENTIFIER			0x81
 #define	NVME_FEAT_RESERVATION_NOTIFICATION_MASK		0x82
 #define	NVME_FEAT_RESERVATION_PERSISTANCE		0x83
 /* Get Log Page */
 #define	NVME_LOG_ERROR					0x01
 #define	NVME_LOG_HEALTH_INFORMATION			0x02
 #define	NVME_LOG_FIRMWARE_SLOT				0x03
 #define	NVME_LOG_CHANGED_NAMESPACE_LIST			0x04
 #define	NVME_LOG_COMMAND_EFFECTS_LOG			0x05
 #define	NVME_LOG_RESERVATION_NOTIFICATION		0x80
 /*
  * The following are Intel Specific log pages, but they seem
  * to be widely implemented.
  */
 #define	INTEL_LOG_READ_LAT_LOG				0xc1
 #define	INTEL_LOG_WRITE_LAT_LOG				0xc2
 #define	INTEL_LOG_TEMP_STATS				0xc5
 #define	INTEL_LOG_ADD_SMART				0xca
 #define	INTEL_LOG_DRIVE_MKT_NAME			0xdd
 /*
  * HGST log page, with lots ofs sub pages.
  */
 #define	HGST_INFO_LOG					0xc1
 /* Error Information Log (Log Identifier 01h) */
 struct nvme_error_information_entry {
 	uint64_t		error_count;
 	uint16_t		sqid;
 	uint16_t		cid;
 	uint16_t		status;
 	uint16_t		error_location;
 	uint64_t		lba;
 	uint32_t		nsid;
 	uint8_t			vendor_specific;
 	uint8_t			_reserved1[3];
 	uint64_t		command_specific;
 @@ -91,51 +105,63 @@ struct nvme_health_information_page {
 	uint8_t			_reserved1[26];
 	uint64_t		data_units_read[2];
 	uint64_t		data_units_written[2];
 	uint64_t		host_read_commands[2];
 	uint64_t		host_write_commands[2];
 	uint64_t		controller_busy_time[2];
 	uint64_t		power_cycles[2];
 	uint64_t		power_on_hours[2];
 	uint64_t		unsafe_shutdowns[2];
 	uint64_t		media_errors[2];
 	uint64_t		num_error_info_log_entries[2];
-	uint32_t		warning_composite_temperature_time;
+	uint32_t		warning_temp_time;
-	uint32_t		critical_composite_temperature_time;
+	uint32_t		error_temp_time;
-	uint16_t		temperature_sensor[8];
+	uint16_t		temp_sensor[8];
 	uint8_t			reserved[296];
 } __packed __aligned(4);
 /* Firmware Commit */
 #define	NVME_COMMIT_ACTION_REPLACE_NO_ACTIVATE	0
 #define	NVME_COMMIT_ACTION_REPLACE_ACTIVATE	1
 #define	NVME_COMMIT_ACTION_ACTIVATE_RESET	2
 #define	NVME_COMMIT_ACTION_ACTIVATE_NO_RESET	3
 /* Firmware Slot Information (Log Identifier 03h) */
 struct nvme_firmware_page {
 	uint8_t			afi;
 #define	NVME_FW_PAGE_AFI_SLOT_RST	__BITS(4, 6)
 #define	NVME_FW_PAGE_AFI_SLOT		__BITS(0, 2)
 	uint8_t			_reserved1[7];
 	uint64_t		revision[7];	/* revisions for 7 slots */
 	uint8_t			reserved[448];
 } __packed __aligned(4);
 struct intel_log_temp_stats {
 	uint64_t	current;
 	uint64_t	overtemp_flag_last;
 	uint64_t	overtemp_flag_life;
 	uint64_t	max_temp;
 	uint64_t	min_temp;
 	uint64_t	_rsvd[5];
 	uint64_t	max_oper_temp;
 	uint64_t	min_oper_temp;
 	uint64_t	est_offset;
 } __packed __aligned(4);
 /* Commands Supported and Effects (Log Identifier 05h) */
 struct nvme_command_effeects_page {
 	uint32_t		acs[256];
 #define	NVME_CE_PAGE_CS_CSE		__BITS(16, 18)
 #define	NVME_CE_PAGE_CS_CCC		__BIT(4)
 #define	NVME_CE_PAGE_CS_NIC		__BIT(3)
 #define	NVME_CE_PAGE_CS_NCC		__BIT(2)
 #define	NVME_CE_PAGE_CS_LBCC		__BIT(1)
 #define	NVME_CE_PAGE_CS_CSUPP		__BIT(0)
 	uint32_t		iocs[256];
 	uint8_t			reserved[2048];
 } __packed __aligned(4);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: logpage.c,v 1.3 2017/02/13 11:16:46 nonaka Exp $	*/
+/*	$NetBSD: logpage.c,v 1.4 2017/04/29 00:06:40 nonaka Exp $	*/
 /*-
  * Copyright (c) 2013 EMC Corp.
  * All rights reserved.
+ *
  * Copyright (C) 2012-2013 Intel Corporation
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -21,53 +21,87 @@
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: logpage.c,v 1.3 2017/02/13 11:16:46 nonaka Exp $");
+__RCSID("$NetBSD: logpage.c,v 1.4 2017/04/29 00:06:40 nonaka Exp $");
 #if 0
-__FBSDID("$FreeBSD: head/sbin/nvmecontrol/logpage.c 285796 2015-07-22 16:10:29Z jimharris $");
+__FBSDID("$FreeBSD: head/sbin/nvmecontrol/logpage.c 314230 2017-02-25 00:09:16Z imp $");
 #endif
 #endif
 #include <sys/param.h>
 #include <sys/ioccom.h>
 #include <sys/endian.h>
 #include <ctype.h>
 #include <err.h>
 #include <fcntl.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "nvmectl.h"
 #include "bn.h"
 #define DEFAULT_SIZE	(4096)
 #define MAX_FW_SLOTS	(7)
 typedef void (*print_fn_t)(void *buf, uint32_t size);
 struct kv_name {
 	uint32_t key;
 	const char *name;
 };
 static const char *
 kv_lookup(const struct kv_name *kv, size_t kv_count, uint32_t key)
+{
 	static char bad[32];
 	size_t i;
 	for (i = 0; i < kv_count; i++, kv++)
 		if (kv->key == key)
 			return kv->name;
 	snprintf(bad, sizeof(bad), "Attribute %#x", key);
 	return bad;
+}
 static void
 print_bin(void *data, uint32_t length)
+{
 	write(STDOUT_FILENO, data, length);
+}
 /* "Missing" from endian.h */
 static __inline uint64_t
 le48dec(const void *pp)
+{
 	uint8_t const *p = (uint8_t const *)pp;
 	return (((uint64_t)le16dec(p + 4) << 32) | le32dec(p));
+}
 static void *
 get_log_buffer(uint32_t size)
+{
 	void	*buf;
 	if ((buf = malloc(size)) == NULL)
 		errx(1, "unable to malloc %u bytes", size);
 	memset(buf, 0, size);
 	return (buf);
+}
 void
 @@ -168,82 +202,89 @@ print_bignum(const char *title, uint64_t
 	buf[0] = '\0';
 	BIGNUM *bn = BN_bin2bn(tmp, __arraycount(tmp), NULL);
 	if (bn != NULL) {
 		humanize_bignum(buf, METRIX_PREFIX_BUFSIZ + strlen(suffix),
 		    bn, suffix, HN_AUTOSCALE, HN_DECIMAL);
 		BN_free(bn);
+	}
 	if (buf[0] == '\0')
 		snprintf(buf, sizeof(buf), "0x%016jx%016jx", h, l);
 	printf("%-31s %s\n", title, buf);
+}
 static void
 print_temp(uint16_t t)
+{
 	printf("%u K, %2.2f C, %3.2f F\n", t, (float)t - 273.15,
 	    (float)t * 9 / 5 - 459.67);
+}
 static void
 print_log_health(void *buf, uint32_t size __unused)
+{
 	struct nvme_health_information_page *health = buf;
-	float composite_temperature = health->composite_temperature;
+	int i;
 	printf("SMART/Health Information Log\n");
 	printf("============================\n");
 	printf("Critical Warning State:         0x%02x\n",
 	    health->critical_warning);
 	printf(" Available spare:               %d\n",
 	    (uint8_t)__SHIFTOUT(health->critical_warning,
 	      NVME_HEALTH_PAGE_CW_AVAIL_SPARE));
 	printf(" Temperature:                   %d\n",
 	    (uint8_t)__SHIFTOUT(health->critical_warning,
 	      NVME_HEALTH_PAGE_CW_TEMPERTURE));
 	printf(" Device reliability:            %d\n",
 	    (uint8_t)__SHIFTOUT(health->critical_warning,
 	      NVME_HEALTH_PAGE_CW_DEVICE_RELIABLITY));
 	printf(" Read only:                     %d\n",
 	    (uint8_t)__SHIFTOUT(health->critical_warning,
 	      NVME_HEALTH_PAGE_CW_READ_ONLY));
 	printf(" Volatile memory backup:        %d\n",
 	    (uint8_t)__SHIFTOUT(health->critical_warning,
 	      NVME_HEALTH_PAGE_CW_VOLATILE_MEMORY_BACKUP));
-	printf("Temperature:                    %u K, %2.2f C, %3.2f F\n",
+	printf("Temperature:                    ");
-	    health->composite_temperature,
+	print_temp(health->composite_temperature);
 	    composite_temperature - (float)273.15,
 	    (composite_temperature * (float)9/5) - (float)459.67);
 	printf("Available spare:                %u\n",
 	    health->available_spare);
 	printf("Available spare threshold:      %u\n",
 	    health->available_spare_threshold);
 	printf("Percentage used:                %u\n",
 	    health->percentage_used);
-	print_bignum("Data units (512 byte) read:",
+	print_bignum("Data units (512 byte) read:", health->data_units_read, "");
-	    health->data_units_read, "");
+	print_bignum("Data units (512 byte) written:", health->data_units_written,
-	print_bignum("Data units (512 byte) written:",
+	    "");
-	    health->data_units_written, "");
+	print_bignum("Host read commands:", health->host_read_commands, "");
-	print_bignum("Host read commands:",
+	print_bignum("Host write commands:", health->host_write_commands, "");
-	    health->host_read_commands, "");
+	print_bignum("Controller busy time (minutes):", health->controller_busy_time,
-	print_bignum("Host write commands:",
+	    "");
-	    health->host_write_commands, "");
+	print_bignum("Power cycles:", health->power_cycles, "");
-	print_bignum("Controller busy time (minutes):",
+	print_bignum("Power on hours:", health->power_on_hours, "");
-	    health->controller_busy_time, "");
+	print_bignum("Unsafe shutdowns:", health->unsafe_shutdowns, "");
-	print_bignum("Power cycles:",
+	print_bignum("Media errors:", health->media_errors, "");
 	    health->power_cycles, "");
 	print_bignum("Power on hours:",
 	    health->power_on_hours, "");
 	print_bignum("Unsafe shutdowns:",
 	    health->unsafe_shutdowns, "");
 	print_bignum("Media errors:",
 	    health->media_errors, "");
 	print_bignum("No. error info log entries:",
 	    health->num_error_info_log_entries, "");
 	printf("Warning Temp Composite Time:    %d\n", health->warning_temp_time);
 	printf("Error Temp Composite Time:      %d\n", health->error_temp_time);
 	for (i = 0; i < 7; i++) {
 		if (health->temp_sensor[i] == 0)
 			continue;
 		printf("Temperature Sensor %d:           ", i + 1);
 		print_temp(health->temp_sensor[i]);
+	}
+}
 static void
 print_log_firmware(void *buf, uint32_t size __unused)
+{
 	u_int				i;
 	const char			*status;
 	struct nvme_firmware_page	*fw = buf;
 	printf("Firmware Slot Log\n");
 	printf("=================\n");
 	for (i = 0; i < MAX_FW_SLOTS; i++) {
 @@ -255,83 +296,683 @@ print_log_firmware(void *buf, uint32_t s
 		if (fw->revision[i] == 0LLU)
 			printf("Empty\n");
 		else
 			if (isprint(*(uint8_t *)&fw->revision[i]))
 				printf("[%s] %.8s\n", status,
 				    (char *)&fw->revision[i]);
 			else
 				printf("[%s] %016jx\n", status,
 				    fw->revision[i]);
+	}
+}
 /*
  * Intel specific log pages from
  * http://www.intel.com/content/dam/www/public/us/en/documents/product-specifications/ssd-dc-p3700-spec.pdf
+ *
  * Though the version as of this date has a typo for the size of log page 0xca,
  * offset 147: it is only 1 byte, not 6.
  */
 static void
 print_intel_temp_stats(void *buf, uint32_t size __unused)
+{
 	struct intel_log_temp_stats	*temp = buf;
 	printf("Intel Temperature Log\n");
 	printf("=====================\n");
 	printf("Current:                        ");
 	print_temp(temp->current);
 	printf("Overtemp Last Flags             %#jx\n",
 	    (uintmax_t)temp->overtemp_flag_last);
 	printf("Overtemp Lifetime Flags         %#jx\n",
 	    (uintmax_t)temp->overtemp_flag_life);
 	printf("Max Temperature                 ");
 	print_temp(temp->max_temp);
 	printf("Min Temperature                 ");
 	print_temp(temp->min_temp);
 	printf("Max Operating Temperature       ");
 	print_temp(temp->max_oper_temp);
 	printf("Min Operating Temperature       ");
 	print_temp(temp->min_oper_temp);
 	printf("Estimated Temperature Offset:   %ju C/K\n",
 	    (uintmax_t)temp->est_offset);
+}
 /*
  * Format from Table 22, section 5.7 IO Command Latency Statistics.
  * Read and write stats pages have identical encoding.
  */
 static void
 print_intel_read_write_lat_log(void *buf, uint32_t size __unused)
+{
 	const char *walker = buf;
 	int i;
 	printf("Major:                         %d\n", le16dec(walker + 0));
 	printf("Minor:                         %d\n", le16dec(walker + 2));
 	for (i = 0; i < 32; i++)
 		printf("%4dus-%4dus:                 %ju\n", i * 32, (i + 1) * 32,
 		    (uintmax_t)le32dec(walker + 4 + i * 4));
 	for (i = 1; i < 32; i++)
 		printf("%4dms-%4dms:                 %ju\n", i, i + 1,
 		    (uintmax_t)le32dec(walker + 132 + i * 4));
 	for (i = 1; i < 32; i++)
 		printf("%4dms-%4dms:                 %ju\n", i * 32, (i + 1) * 32,
 		    (uintmax_t)le32dec(walker + 256 + i * 4));
+}
 static void
 print_intel_read_lat_log(void *buf, uint32_t size)
+{
 	printf("Intel Read Latency Log\n");
 	printf("======================\n");
 	print_intel_read_write_lat_log(buf, size);
+}
 static void
 print_intel_write_lat_log(void *buf, uint32_t size)
+{
 	printf("Intel Write Latency Log\n");
 	printf("=======================\n");
 	print_intel_read_write_lat_log(buf, size);
+}
 /*
  * Table 19. 5.4 SMART Attributes.
  * Samsung also implements this and some extra data not documented.
  */
 static void
 print_intel_add_smart(void *buf, uint32_t size __unused)
+{
 	uint8_t *walker = buf;
 	uint8_t *end = walker + 150;
 	const char *name;
 	uint64_t raw;
 	uint8_t normalized;
 	static struct kv_name kv[] = {
 		{ 0xab, "Program Fail Count" },
 		{ 0xac, "Erase Fail Count" },
 		{ 0xad, "Wear Leveling Count" },
 		{ 0xb8, "End to End Error Count" },
 		{ 0xc7, "CRC Error Count" },
 		{ 0xe2, "Timed: Media Wear" },
 		{ 0xe3, "Timed: Host Read %" },
 		{ 0xe4, "Timed: Elapsed Time" },
 		{ 0xea, "Thermal Throttle Status" },
 		{ 0xf0, "Retry Buffer Overflows" },
 		{ 0xf3, "PLL Lock Loss Count" },
 		{ 0xf4, "NAND Bytes Written" },
 		{ 0xf5, "Host Bytes Written" },
 	};
 	printf("Additional SMART Data Log\n");
 	printf("=========================\n");
 	/*
 	 * walker[0] = Key
 	 * walker[1,2] = reserved
 	 * walker[3] = Normalized Value
 	 * walker[4] = reserved
 	 * walker[5..10] = Little Endian Raw value
 	 *	(or other represenations)
 	 * walker[11] = reserved
 	 */
 	while (walker < end) {
 		name = kv_lookup(kv, __arraycount(kv), *walker);
 		normalized = walker[3];
 		raw = le48dec(walker + 5);
 		switch (*walker){
 		case 0:
 			break;
 		case 0xad:
 			printf("%-32s: %3d min: %u max: %u ave: %u\n", name,
 			    normalized, le16dec(walker + 5), le16dec(walker + 7),
 			    le16dec(walker + 9));
 			break;
 		case 0xe2:
 			printf("%-32s: %3d %.3f%%\n", name, normalized, raw / 1024.0);
 			break;
 		case 0xea:
 			printf("%-32s: %3d %d%% %d times\n", name, normalized,
 			    walker[5], le32dec(walker+6));
 			break;
 		default:
 			printf("%-32s: %3d %ju\n", name, normalized, (uintmax_t)raw);
 			break;
+		}
 		walker += 12;
+	}
+}
 /*
  * HGST's 0xc1 page. This is a grab bag of additional data. Please see
  * https://www.hgst.com/sites/default/files/resources/US_SN150_ProdManual.pdf
  * https://www.hgst.com/sites/default/files/resources/US_SN100_ProdManual.pdf
  * Appendix A for details
  */
 typedef void (*subprint_fn_t)(void *buf, uint16_t subtype, uint8_t res, uint32_t size);
 struct subpage_print {
 	uint16_t key;
 	subprint_fn_t fn;
 };
 static void print_hgst_info_write_errors(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_read_errors(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_verify_errors(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_self_test(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_background_scan(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_erase_errors(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_erase_counts(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_temp_history(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_ssd_perf(void *, uint16_t, uint8_t, uint32_t);
 static void print_hgst_info_firmware_load(void *, uint16_t, uint8_t, uint32_t);
 static struct subpage_print hgst_subpage[] = {
 	{ 0x02, print_hgst_info_write_errors },
 	{ 0x03, print_hgst_info_read_errors },
 	{ 0x05, print_hgst_info_verify_errors },
 	{ 0x10, print_hgst_info_self_test },
 	{ 0x15, print_hgst_info_background_scan },
 	{ 0x30, print_hgst_info_erase_errors },
 	{ 0x31, print_hgst_info_erase_counts },
 	{ 0x32, print_hgst_info_temp_history },
 	{ 0x37, print_hgst_info_ssd_perf },
 	{ 0x38, print_hgst_info_firmware_load },
 };
 /* Print a subpage that is basically just key value pairs */
 static void
 print_hgst_info_subpage_gen(void *buf, uint16_t subtype __unused, uint32_t size,
     const struct kv_name *kv, size_t kv_count)
+{
 	uint8_t *wsp, *esp;
 	uint16_t ptype;
 	uint8_t plen;
 	uint64_t param;
 	int i;
 	wsp = buf;
 	esp = wsp + size;
 	while (wsp < esp) {
 		ptype = le16dec(wsp);
 		wsp += 2;
 		wsp++;			/* Flags, just ignore */
 		plen = *wsp++;
 		param = 0;
 		for (i = 0; i < plen; i++)
 			param |= (uint64_t)*wsp++ << (i * 8);
 		printf("  %-30s: %jd\n", kv_lookup(kv, kv_count, ptype),
 		    (uintmax_t)param);
+	}
+}
 static void
 print_hgst_info_write_errors(void *buf, uint16_t subtype, uint8_t res __unused,
     uint32_t size)
+{
 	static const struct kv_name kv[] = {
 		{ 0x0000, "Corrected Without Delay" },
 		{ 0x0001, "Corrected Maybe Delayed" },
 		{ 0x0002, "Re-Writes" },
 		{ 0x0003, "Errors Corrected" },
 		{ 0x0004, "Correct Algorithm Used" },
 		{ 0x0005, "Bytes Processed" },
 		{ 0x0006, "Uncorrected Errors" },
 		{ 0x8000, "Flash Write Commands" },
 		{ 0x8001, "HGST Special" },
 	};
 	printf("Write Errors Subpage:\n");
 	print_hgst_info_subpage_gen(buf, subtype, size, kv, __arraycount(kv));
+}
 static void
 print_hgst_info_read_errors(void *buf, uint16_t subtype, uint8_t res __unused,
     uint32_t size)
+{
 	static const struct kv_name kv[] = {
 		{ 0x0000, "Corrected Without Delay" },
 		{ 0x0001, "Corrected Maybe Delayed" },
 		{ 0x0002, "Re-Reads" },
 		{ 0x0003, "Errors Corrected" },
 		{ 0x0004, "Correct Algorithm Used" },
 		{ 0x0005, "Bytes Processed" },
 		{ 0x0006, "Uncorrected Errors" },
 		{ 0x8000, "Flash Read Commands" },
 		{ 0x8001, "XOR Recovered" },
 		{ 0x8002, "Total Corrected Bits" },
 	};
 	printf("Read Errors Subpage:\n");
 	print_hgst_info_subpage_gen(buf, subtype, size, kv, __arraycount(kv));
+}
 static void
 print_hgst_info_verify_errors(void *buf, uint16_t subtype, uint8_t res __unused,
     uint32_t size)
+{
 	static const struct kv_name kv[] = {
 		{ 0x0000, "Corrected Without Delay" },
 		{ 0x0001, "Corrected Maybe Delayed" },
 		{ 0x0002, "Re-Reads" },
 		{ 0x0003, "Errors Corrected" },
 		{ 0x0004, "Correct Algorithm Used" },
 		{ 0x0005, "Bytes Processed" },
 		{ 0x0006, "Uncorrected Errors" },
 		{ 0x8000, "Commands Processed" },
 	};
 	printf("Verify Errors Subpage:\n");
 	print_hgst_info_subpage_gen(buf, subtype, size, kv, __arraycount(kv));
+}
 static void
 print_hgst_info_self_test(void *buf, uint16_t subtype __unused, uint8_t res __unused,
     uint32_t size)
+{
 	size_t i;
 	uint8_t *walker = buf;
 	uint16_t code, hrs;
 	uint32_t lba;
 	printf("Self Test Subpage:\n");
 	for (i = 0; i < size / 20; i++) {	/* Each entry is 20 bytes */
 		code = le16dec(walker);
 		walker += 2;
 		walker++;			/* Ignore fixed flags */
 		if (*walker == 0)		/* Last entry is zero length */
 			break;
 		if (*walker++ != 0x10) {
 			printf("Bad length for self test report\n");
 			return;
+		}
 		printf("  %-30s: %d\n", "Recent Test", code);
 		printf("    %-28s: %#x\n", "Self-Test Results", *walker & 0xf);
 		printf("    %-28s: %#x\n", "Self-Test Code", (*walker >> 5) & 0x7);
 		walker++;
 		printf("    %-28s: %#x\n", "Self-Test Number", *walker++);
 		hrs = le16dec(walker);
 		walker += 2;
 		lba = le32dec(walker);
 		walker += 4;
 		printf("    %-28s: %u\n", "Total Power On Hrs", hrs);
 		printf("    %-28s: %#jx (%jd)\n", "LBA", (uintmax_t)lba,
 		    (uintmax_t)lba);
 		printf("    %-28s: %#x\n", "Sense Key", *walker++ & 0xf);
 		printf("    %-28s: %#x\n", "Additional Sense Code", *walker++);
 		printf("    %-28s: %#x\n", "Additional Sense Qualifier", *walker++);
 		printf("    %-28s: %#x\n", "Vendor Specific Detail", *walker++);
+	}
+}
 static void
 print_hgst_info_background_scan(void *buf, uint16_t subtype __unused,
     uint8_t res __unused, uint32_t size)
+{
 	uint8_t *walker = buf;
 	uint8_t status;
 	uint16_t code, nscan, progress;
 	uint32_t pom, nand;
 	printf("Background Media Scan Subpage:\n");
 	/* Decode the header */
 	code = le16dec(walker);
 	walker += 2;
 	walker++;			/* Ignore fixed flags */
 	if (*walker++ != 0x10) {
 		printf("Bad length for background scan header\n");
 		return;
+	}
 	if (code != 0) {
 		printf("Expceted code 0, found code %#x\n", code);
 		return;
+	}
 	pom = le32dec(walker);
 	walker += 4;
 	walker++;			/* Reserved */
 	status = *walker++;
 	nscan = le16dec(walker);
 	walker += 2;
 	progress = le16dec(walker);
 	walker += 2;
 	walker += 6;			/* Reserved */
 	printf("  %-30s: %d\n", "Power On Minutes", pom);
 	printf("  %-30s: %x (%s)\n", "BMS Status", status,
 	    status == 0 ? "idle" : (status == 1 ? "active" :
 	      (status == 8 ? "suspended" : "unknown")));
 	printf("  %-30s: %d\n", "Number of BMS", nscan);
 	printf("  %-30s: %d\n", "Progress Current BMS", progress);
 	/* Report retirements */
 	if (walker - (uint8_t *)buf != 20) {
 		printf("Coding error, offset not 20\n");
 		return;
+	}
 	size -= 20;
 	printf("  %-30s: %d\n", "BMS retirements", size / 0x18);
 	while (size > 0) {
 		code = le16dec(walker);
 		walker += 2;
 		walker++;
 		if (*walker++ != 0x14) {
 			printf("Bad length parameter\n");
 			return;
+		}
 		pom = le32dec(walker);
 		walker += 4;
 		/*
 		 * Spec sheet says the following are hard coded, if true, just
 		 * print the NAND retirement.
 		 */
 		if (walker[0] == 0x41 &&
 		    walker[1] == 0x0b &&
 		    walker[2] == 0x01 &&
 		    walker[3] == 0x00 &&
 		    walker[4] == 0x00 &&
 		    walker[5] == 0x00 &&
 		    walker[6] == 0x00 &&
 		    walker[7] == 0x00) {
 			walker += 8;
 			walker += 4;	/* Skip reserved */
 			nand = le32dec(walker);
 			walker += 4;
 			printf("  %-30s: %d\n", "Retirement number", code);
 			printf("    %-28s: %#x\n", "NAND (C/T)BBBPPP", nand);
 		} else {
 			printf("Parameter %#x entry corrupt\n", code);
 			walker += 16;
+		}
+	}
+}
 static void
 print_hgst_info_erase_errors(void *buf, uint16_t subtype __unused,
     uint8_t res __unused, uint32_t size)
+{
 	static const struct kv_name kv[] = {
 		{ 0x0000, "Corrected Without Delay" },
 		{ 0x0001, "Corrected Maybe Delayed" },
 		{ 0x0002, "Re-Erase" },
 		{ 0x0003, "Errors Corrected" },
 		{ 0x0004, "Correct Algorithm Used" },
 		{ 0x0005, "Bytes Processed" },
 		{ 0x0006, "Uncorrected Errors" },
 		{ 0x8000, "Flash Erase Commands" },
 		{ 0x8001, "Mfg Defect Count" },
 		{ 0x8002, "Grown Defect Count" },
 		{ 0x8003, "Erase Count -- User" },
 		{ 0x8004, "Erase Count -- System" },
 	};
 	printf("Erase Errors Subpage:\n");
 	print_hgst_info_subpage_gen(buf, subtype, size, kv, __arraycount(kv));
+}
 static void
 print_hgst_info_erase_counts(void *buf, uint16_t subtype, uint8_t res __unused,
     uint32_t size)
+{
 	/* My drive doesn't export this -- so not coding up */
 	printf("XXX: Erase counts subpage: %p, %#x %d\n", buf, subtype, size);
+}
 static void
 print_hgst_info_temp_history(void *buf, uint16_t subtype __unused,
     uint8_t res __unused, uint32_t size __unused)
+{
 	uint8_t *walker = buf;
 	uint32_t min;
 	printf("Temperature History:\n");
 	printf("  %-30s: %d C\n", "Current Temperature", *walker++);
 	printf("  %-30s: %d C\n", "Reference Temperature", *walker++);
 	printf("  %-30s: %d C\n", "Maximum Temperature", *walker++);
 	printf("  %-30s: %d C\n", "Minimum Temperature", *walker++);
 	min = le32dec(walker);
 	walker += 4;
 	printf("  %-30s: %d:%02d:00\n", "Max Temperature Time", min / 60, min % 60);
 	min = le32dec(walker);
 	walker += 4;
 	printf("  %-30s: %d:%02d:00\n", "Over Temperature Duration", min / 60,
 	    min % 60);
 	min = le32dec(walker);
 	walker += 4;
 	printf("  %-30s: %d:%02d:00\n", "Min Temperature Time", min / 60, min % 60);
+}
 static void
 print_hgst_info_ssd_perf(void *buf, uint16_t subtype __unused, uint8_t res,
     uint32_t size __unused)
+{
 	uint8_t *walker = buf;
 	uint64_t val;
 	printf("SSD Performance Subpage Type %d:\n", res);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Read Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Read Blocks", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Cache Read Hits Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Cache Read Hits Blocks", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Read Commands Stalled", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Write Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Write Blocks", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Write Odd Start Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Write Odd End Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "Host Write Commands Stalled", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "NAND Read Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "NAND Read Blocks", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "NAND Write Commands", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "NAND Write Blocks", val);
 	val = le64dec(walker);
 	walker += 8;
 	printf("  %-30s: %ju\n", "NAND Read Before Writes", val);
+}
 static void
 print_hgst_info_firmware_load(void *buf, uint16_t subtype __unused,
     uint8_t res __unused, uint32_t size __unused)
+{
 	uint8_t *walker = buf;
 	printf("Firmware Load Subpage:\n");
 	printf("  %-30s: %d\n", "Firmware Downloads", le32dec(walker));
+}
 static void
 kv_indirect(void *buf, uint32_t subtype, uint8_t res, uint32_t size,
     struct subpage_print *sp, size_t nsp)
+{
 	size_t i;
 	for (i = 0; i < nsp; i++, sp++) {
 		if (sp->key == subtype) {
 			sp->fn(buf, subtype, res, size);
 			return;
+		}
+	}
 	printf("No handler for page type %x\n", subtype);
+}
 static void
 print_hgst_info_log(void *buf, uint32_t size __unused)
+{
 	uint8_t	*walker, *end, *subpage;
 	int pages __unused;
 	uint16_t len;
 	uint8_t subtype, res;
 	printf("HGST Extra Info Log\n");
 	printf("===================\n");
 	walker = buf;
 	pages = *walker++;
 	walker++;
 	len = le16dec(walker);
 	walker += 2;
 	end = walker + len;		/* Length is exclusive of this header */
 	while (walker < end) {
 		subpage = walker + 4;
 		subtype = *walker++ & 0x3f;	/* subtype */
 		res = *walker++;		/* Reserved */
 		len = le16dec(walker);
 		walker += len + 2;		/* Length, not incl header */
 		if (walker > end) {
 			printf("Ooops! Off the end of the list\n");
 			break;
+		}
 		kv_indirect(subpage, subtype, res, len, hgst_subpage,
 		    __arraycount(hgst_subpage));
+	}
+}
 /*
  * Table of log page printer / sizing.
+ *
  * This includes Intel specific pages that are widely implemented.
  * Make sure you keep all the pages of one vendor together so -v help
  * lists all the vendors pages.
  */
 static struct logpage_function {
 	uint8_t		log_page;
-	print_fn_t	fn;
+	const char     *vendor;
 	const char     *name;
 	print_fn_t	print_fn;
 	size_t		size;
 } logfuncs[] = {
-	{NVME_LOG_ERROR,		print_log_error		},
+	{NVME_LOG_ERROR,		NULL,	"Drive Error Log",
-	{NVME_LOG_HEALTH_INFORMATION,	print_log_health	},
+	 print_log_error,		0},
-	{NVME_LOG_FIRMWARE_SLOT,	print_log_firmware	},
+	{NVME_LOG_HEALTH_INFORMATION,	NULL,	"Health/SMART Data",
-	{0,				NULL			},
+	 print_log_health,		sizeof(struct nvme_health_information_page)},
 	{NVME_LOG_FIRMWARE_SLOT,	NULL,	"Firmware Information",
 	 print_log_firmware,		sizeof(struct nvme_firmware_page)},
 	{HGST_INFO_LOG,			"hgst",	"Detailed Health/SMART",
 	 print_hgst_info_log,		DEFAULT_SIZE},
 	{HGST_INFO_LOG,			"wds",	"Detailed Health/SMART",
 	 print_hgst_info_log,		DEFAULT_SIZE},
 	{INTEL_LOG_TEMP_STATS,		"intel", "Temperature Stats",
 	 print_intel_temp_stats,	sizeof(struct intel_log_temp_stats)},
 	{INTEL_LOG_READ_LAT_LOG,	"intel", "Read Latencies",
 	 print_intel_read_lat_log,	DEFAULT_SIZE},
 	{INTEL_LOG_WRITE_LAT_LOG,	"intel", "Write Latencies",
 	 print_intel_write_lat_log,	DEFAULT_SIZE},
 	{INTEL_LOG_ADD_SMART,		"intel", "Extra Health/SMART Data",
 	 print_intel_add_smart,		DEFAULT_SIZE},
 	{INTEL_LOG_ADD_SMART,		"samsung", "Extra Health/SMART Data",
 	 print_intel_add_smart,		DEFAULT_SIZE},
 	{0, NULL, NULL, NULL, 0},
 };
 __dead static void
 logpage_usage(void)
+{
 	fprintf(stderr, "usage:\n");
 	fprintf(stderr, LOGPAGE_USAGE);
 	exit(1);
+}
 __dead static void
 logpage_help(void)
+{
 	struct logpage_function		*f;
 	const char 			*v;
 	fprintf(stderr, "\n");
 	fprintf(stderr, "%-8s %-10s %s\n", "Page", "Vendor","Page Name");
 	fprintf(stderr, "-------- ---------- ----------\n");
 	for (f = logfuncs; f->log_page > 0; f++) {
 		v = f->vendor == NULL ? "-" : f->vendor;
 		fprintf(stderr, "0x%02x     %-10s %s\n", f->log_page, v, f->name);
+	}
 	exit(1);
+}
 void
 logpage(int argc, char *argv[])
+{
 	int				fd, nsid;
 	int				log_page = 0, pageflag = false;
-	int				hexflag = false, ns_specified;
+	int				binflag = false, hexflag = false, ns_specified;
 	int				ch;
 	char				*p;
 	char				cname[64];
 	uint32_t			size;
 	void				*buf;
 	const char 			*vendor = NULL;
 	struct logpage_function		*f;
 	struct nvm_identify_controller	cdata;
 	print_fn_t			print_fn;
-	while ((ch = getopt(argc, argv, "p:x")) != -1) {
+	while ((ch = getopt(argc, argv, "bp:xv:")) != -1) {
 		switch (ch) {
 		case 'b':
 			binflag = true;
 			break;
 		case 'p':
 			if (strcmp(optarg, "help") == 0)
 				logpage_help();
 			/* TODO: Add human-readable ASCII page IDs */
 			log_page = strtol(optarg, &p, 0);
 			if (p != NULL && *p != '\0') {
 				fprintf(stderr,
 				    "\"%s\" not valid log page id.\n",
 				    optarg);
 				logpage_usage();
 			/* TODO: Define valid log page id ranges in nvme.h? */
 			} else if (log_page == 0 ||
 				   (log_page >= 0x04 && log_page <= 0x7F) ||
 				   (log_page >= 0x80 && log_page <= 0xBF)) {
 				fprintf(stderr,
 				    "\"%s\" not valid log page id.\n",
 				    optarg);
 				logpage_usage();
+			}
 			pageflag = true;
 			break;
 		case 'x':
 			hexflag = true;
 			break;
 		case 'v':
 			if (strcmp(optarg, "help") == 0)
 				logpage_help();
 			vendor = optarg;
 			break;
+		}
+	}
 	if (!pageflag) {
 		printf("Missing page_id (-p).\n");
 		logpage_usage();
+	}
 	/* Check that a controller and/or namespace was specified. */
 	if (optind >= argc)
 		logpage_usage();
 	if (strstr(argv[optind], NVME_NS_PREFIX) != NULL) {
 @@ -352,53 +993,49 @@ logpage(int argc, char *argv[])
 	 * namespace basis.
 	 */
 	if (ns_specified) {
 		if (log_page != NVME_LOG_HEALTH_INFORMATION)
 			errx(1, "log page %d valid only at controller level",
 			    log_page);
 		if (!(cdata.lpa & NVME_ID_CTRLR_LPA_NS_SMART))
 			errx(1,
 			    "controller does not support per namespace "
 			    "smart/health information");
+	}
 	print_fn = print_hex;
-	if (!hexflag) {
+	size = DEFAULT_SIZE;
 	if (binflag)
 		print_fn = print_bin;
 	if (!binflag && !hexflag) {
 		/*
-		 * See if there is a pretty print function for the
+		 * See if there is a pretty print function for the specified log
-		 *  specified log page.  If one isn't found, we
+		 * page.  If one isn't found, we just revert to the default
-		 *  just revert to the default (print_hex).
+		 * (print_hex). If there was a vendor specified bt the user, and
 		 * the page is vendor specific, don't match the print function
 		 * unless the vendors match.
 		 */
-		f = logfuncs;
+		for (f = logfuncs; f->log_page > 0; f++) {
-		while (f->log_page > 0) {
+			if (f->vendor != NULL && vendor != NULL &&
-			if (log_page == f->log_page) {
+			    strcmp(f->vendor, vendor) != 0)
-				print_fn = f->fn;
+				continue;
-				break;
+			if (log_page != f->log_page)
 				continue;
-			f++;
+			print_fn = f->print_fn;
 			size = f->size;
 			break;
+		}
+	}
-	/* Read the log page */
+	if (log_page == NVME_LOG_ERROR) {
 	switch (log_page) {
 	case NVME_LOG_ERROR:
 		size = sizeof(struct nvme_error_information_entry);
 		size *= (cdata.elpe + 1);
 		break;
 	case NVME_LOG_HEALTH_INFORMATION:
 		size = sizeof(struct nvme_health_information_page);
 		break;
 	case NVME_LOG_FIRMWARE_SLOT:
 		size = sizeof(struct nvme_firmware_page);
 		break;
 	default:
 		size = DEFAULT_SIZE;
 		break;
+	}
 	/* Read the log page */
 	buf = get_log_buffer(size);
 	read_logpage(fd, log_page, nsid, buf, size);
 	print_fn(buf, size);
 	close(fd);
 	exit(0);
+}

 @@ -1,21 +1,22 @@
-#	$NetBSD: Makefile,v 1.2 2017/02/13 11:16:46 nonaka Exp $
+#	$NetBSD: Makefile,v 1.3 2017/04/29 00:06:40 nonaka Exp $
 .include <bsd.own.mk>
 PROG=	nvmectl
 SRCS=	nvmectl.c
 SRCS+=	devlist.c
 SRCS+=	firmware.c
 SRCS+=	identify.c
 SRCS+=	logpage.c
 SRCS+=	perftest.c
 SRCS+=	power.c
 SRCS+=	reset.c
 SRCS+=	wdc.c
 SRCS+=	bignum.c
 SRCS+=	humanize_bignum.c
 MAN=	nvmectl.8
 DPADD+= ${LIBUTIL}
 LDADD+= -lutil
 .include <bsd.prog.mk>