1 /* $NetBSD: nvmectl.c,v 1.4 2017/05/03 01:37:16 christos 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.4 2017/05/03 01:37:16 christos 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 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(struct nvme_function *f) 75 { 76 77 fprintf(stderr, "usage:\n"); 78 while (f->name != NULL) { 79 fprintf(stderr, "%s", f->usage); 80 f++; 81 } 82 exit(1); 83 } 84 85 __dead void 86 dispatch(int argc, char *argv[], struct nvme_function *tbl) 87 { 88 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 284 if (argc < 2) 285 gen_usage(funcs); 286 287 dispatch(argc, argv, funcs); 288 289 return (0); 290 } 291