Home | History | Annotate | Line # | Download | only in nvmectl
nvmectl.c revision 1.5 
      1 /*	$NetBSD: nvmectl.c,v 1.5 2018/03/17 11:07:26 jdolecek Exp $	*/
      2 
      3 /*-
      4  * Copyright (C) 2012-2013 Intel Corporation
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 #ifndef lint
     31 __RCSID("$NetBSD: nvmectl.c,v 1.5 2018/03/17 11:07:26 jdolecek Exp $");
     32 #if 0
     33 __FBSDID("$FreeBSD: head/sbin/nvmecontrol/nvmecontrol.c 314229 2017-02-25 00:09:12Z imp $");
     34 #endif
     35 #endif
     36 
     37 #include <sys/param.h>
     38 #include <sys/ioccom.h>
     39 #include <sys/stat.h>
     40 
     41 #include <ctype.h>
     42 #include <err.h>
     43 #include <errno.h>
     44 #include <fcntl.h>
     45 #include <paths.h>
     46 #include <stdbool.h>
     47 #include <stddef.h>
     48 #include <stdio.h>
     49 #include <stdlib.h>
     50 #include <string.h>
     51 #include <unistd.h>
     52 
     53 #include "nvmectl.h"
     54 
     55 static const struct nvme_function funcs[] = {
     56 	{"devlist",	devlist,	DEVLIST_USAGE},
     57 	{"identify",	identify,	IDENTIFY_USAGE},
     58 #ifdef PERFTEST_USAGE
     59 	{"perftest",	perftest,	PERFTEST_USAGE},
     60 #endif
     61 #ifdef RESET_USAGE
     62 	{"reset",	reset,		RESET_USAGE},
     63 #endif
     64 	{"logpage",	logpage,	LOGPAGE_USAGE},
     65 #ifdef FIRMWARE_USAGE
     66 	{"firmware",	firmware,	FIRMWARE_USAGE},
     67 #endif
     68 	{"power",	power,		POWER_USAGE},
     69 	{"wdc",		wdc,		WDC_USAGE},
     70 	{NULL,		NULL,		NULL},
     71 };
     72 
     73 static __dead void
     74 gen_usage(const struct nvme_function *f)
     75 {
     76 
     77 	fprintf(stderr, "usage:\n");
     78 	while (f->name != NULL) {
     79 		fprintf(stderr, "\t%s %s", getprogname(), f->usage);
     80 		f++;
     81 	}
     82 	exit(1);
     83 }
     84 
     85 __dead void
     86 dispatch(int argc, char *argv[], const struct nvme_function *tbl)
     87 {
     88 	const struct nvme_function *f = tbl;
     89 
     90 	if (argv[1] == NULL)
     91 		gen_usage(tbl);
     92 
     93 	while (f->name != NULL) {
     94 		if (strcmp(argv[1], f->name) == 0)
     95 			f->fn(argc-1, &argv[1]);
     96 		f++;
     97 	}
     98 
     99 	fprintf(stderr, "Unknown command: %s\n", argv[1]);
    100 	gen_usage(tbl);
    101 }
    102 
    103 static void
    104 print_bytes(void *data, uint32_t length)
    105 {
    106 	uint32_t	i, j;
    107 	uint8_t		*p, *end;
    108 
    109 	end = (uint8_t *)data + length;
    110 
    111 	for (i = 0; i < length; i++) {
    112 		p = (uint8_t *)data + (i*16);
    113 		printf("%03x: ", i*16);
    114 		for (j = 0; j < 16 && p < end; j++)
    115 			printf("%02x ", *p++);
    116 		if (p >= end)
    117 			break;
    118 		printf("\n");
    119 	}
    120 	printf("\n");
    121 }
    122 
    123 static void
    124 print_dwords(void *data, uint32_t length)
    125 {
    126 	uint32_t	*p;
    127 	uint32_t	i, j;
    128 
    129 	p = (uint32_t *)data;
    130 	length /= sizeof(uint32_t);
    131 
    132 	for (i = 0; i < length; i+=8) {
    133 		printf("%03x: ", i*4);
    134 		for (j = 0; j < 8; j++)
    135 			printf("%08x ", p[i+j]);
    136 		printf("\n");
    137 	}
    138 
    139 	printf("\n");
    140 }
    141 
    142 void
    143 print_hex(void *data, uint32_t length)
    144 {
    145 	if (length >= sizeof(uint32_t) || length % sizeof(uint32_t) == 0)
    146 		print_dwords(data, length);
    147 	else
    148 		print_bytes(data, length);
    149 }
    150 
    151 void
    152 read_controller_data(int fd, struct nvm_identify_controller *cdata)
    153 {
    154 	struct nvme_pt_command	pt;
    155 
    156 	memset(&pt, 0, sizeof(pt));
    157 	pt.cmd.opcode = NVM_ADMIN_IDENTIFY;
    158 	pt.cmd.cdw10 = 1;
    159 	pt.buf = cdata;
    160 	pt.len = sizeof(*cdata);
    161 	pt.is_read = 1;
    162 
    163 	if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
    164 		err(1, "identify request failed");
    165 
    166 	if (nvme_completion_is_error(&pt.cpl))
    167 		errx(1, "identify request returned error");
    168 }
    169 
    170 void
    171 read_namespace_data(int fd, int nsid, struct nvm_identify_namespace *nsdata)
    172 {
    173 	struct nvme_pt_command	pt;
    174 
    175 	memset(&pt, 0, sizeof(pt));
    176 	pt.cmd.opcode = NVM_ADMIN_IDENTIFY;
    177 	pt.cmd.nsid = nsid;
    178 	pt.buf = nsdata;
    179 	pt.len = sizeof(*nsdata);
    180 	pt.is_read = 1;
    181 
    182 	if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0)
    183 		err(1, "identify request failed");
    184 
    185 	if (nvme_completion_is_error(&pt.cpl))
    186 		errx(1, "identify request returned error");
    187 }
    188 
    189 int
    190 open_dev(const char *str, int *fd, int show_error, int exit_on_error)
    191 {
    192 	char		full_path[64];
    193 
    194 	if (!strnstr(str, NVME_CTRLR_PREFIX, strlen(NVME_CTRLR_PREFIX))) {
    195 		if (show_error)
    196 			warnx("controller/namespace ids must begin with '%s'",
    197 			    NVME_CTRLR_PREFIX);
    198 		if (exit_on_error)
    199 			exit(1);
    200 		else
    201 			return (EINVAL);
    202 	}
    203 
    204 	snprintf(full_path, sizeof(full_path), _PATH_DEV"%s", str);
    205 	*fd = open(full_path, O_RDWR);
    206 	if (*fd < 0) {
    207 		if (show_error)
    208 			warn("could not open %s", full_path);
    209 		if (exit_on_error)
    210 			exit(1);
    211 		else
    212 			return (errno);
    213 	}
    214 
    215 	return (0);
    216 }
    217 
    218 void
    219 parse_ns_str(const char *ns_str, char *ctrlr_str, int *nsid)
    220 {
    221 	char	*nsloc;
    222 
    223 	/*
    224 	 * Pull the namespace id from the string. +2 skips past the "ns" part
    225 	 *  of the string.  Don't search past 10 characters into the string,
    226 	 *  otherwise we know it is malformed.
    227 	 */
    228 	nsloc = strnstr(ns_str, NVME_NS_PREFIX, 10);
    229 	if (nsloc != NULL)
    230 		*nsid = strtol(nsloc + 2, NULL, 10);
    231 	if (nsloc == NULL || (*nsid == 0 && errno != 0))
    232 		errx(1, "invalid namespace ID '%s'", ns_str);
    233 
    234 	/*
    235 	 * The controller string will include only the nvmX part of the
    236 	 *  nvmeXnsY string.
    237 	 */
    238 	snprintf(ctrlr_str, nsloc - ns_str + 1, "%s", ns_str);
    239 }
    240 
    241 void
    242 nvme_strvis(u_char *dst, int dlen, const u_char *src, int slen)
    243 {
    244 #define STRVIS_ISWHITE(x) ((x) == ' ' || (x) == '\0' || (x) == (u_char)'\377')
    245 	/* Trim leading and trailing blanks and NULs. */
    246 	while (slen > 0 && STRVIS_ISWHITE(src[0]))
    247 		++src, --slen;
    248 	while (slen > 0 && STRVIS_ISWHITE(src[slen - 1]))
    249 		--slen;
    250 
    251 	while (slen > 0) {
    252 		if (*src < 0x20 || *src >= 0x80) {
    253 			/* non-printable characters */
    254 			dlen -= 4;
    255 			if (dlen < 1)
    256 				break;
    257 			*dst++ = '\\';
    258 			*dst++ = ((*src & 0300) >> 6) + '0';
    259 			*dst++ = ((*src & 0070) >> 3) + '0';
    260 			*dst++ = ((*src & 0007) >> 0) + '0';
    261 		} else if (*src == '\\') {
    262 			/* quote characters */
    263 			dlen -= 2;
    264 			if (dlen < 1)
    265 				break;
    266 			*dst++ = '\\';
    267 			*dst++ = '\\';
    268 		} else {
    269 			/* normal characters */
    270 			if (--dlen < 1)
    271 				break;
    272 			*dst++ = *src;
    273 		}
    274 		++src, --slen;
    275 	}
    276 
    277 	*dst++ = 0;
    278 }
    279 
    280 int
    281 main(int argc, char *argv[])
    282 {
    283 	setprogname(argv[0]);
    284 
    285 	if (argc < 2)
    286 		gen_usage(funcs);
    287 
    288 	dispatch(argc, argv, funcs);
    289 
    290 	return (0);
    291 }
    292