1/*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2013 EMC Corp. 5 * All rights reserved. 6 * 7 * Copyright (C) 2012-2013 Intel Corporation 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32#include <sys/param.h> 33#include <sys/ioccom.h> 34#include <sys/stat.h> 35#include <sys/types.h> 36 37#include <ctype.h> 38#include <err.h> 39#include <fcntl.h> 40#include <inttypes.h> 41#include <stdbool.h> 42#include <stddef.h> 43#include <stdio.h> 44#include <stdlib.h> 45#include <string.h> 46#include <sysexits.h> 47#include <unistd.h> 48 49#include "nvmecontrol.h" 50 51/* Tables for command line parsing */ 52 53static cmd_fn_t firmware; 54 55#define NONE 0xffffffffu 56static struct options { 57 bool activate; 58 uint32_t slot; 59 const char *fw_img; 60 const char *dev; 61} opt = { 62 .activate = false, 63 .slot = NONE, 64 .fw_img = NULL, 65 .dev = NULL, 66}; 67 68static const struct opts firmware_opts[] = { 69#define OPT(l, s, t, opt, addr, desc) { l, s, t, &opt.addr, desc } 70 OPT("activate", 'a', arg_none, opt, activate, 71 "Attempt to activate firmware"), 72 OPT("slot", 's', arg_uint32, opt, slot, 73 "Slot to activate and/or download firmware to"), 74 OPT("firmware", 'f', arg_path, opt, fw_img, 75 "Firmware image to download"), 76 { NULL, 0, arg_none, NULL, NULL } 77}; 78#undef OPT 79 80static const struct args firmware_args[] = { 81 { arg_string, &opt.dev, "controller-id|namespace-id" }, 82 { arg_none, NULL, NULL }, 83}; 84 85static struct cmd firmware_cmd = { 86 .name = "firmware", 87 .fn = firmware, 88 .descr = "Download firmware image to controller", 89 .ctx_size = sizeof(opt), 90 .opts = firmware_opts, 91 .args = firmware_args, 92}; 93 94CMD_COMMAND(firmware_cmd); 95 96/* End of tables for command line parsing */ 97 98static int 99slot_has_valid_firmware(int fd, int slot) 100{ 101 struct nvme_firmware_page fw; 102 int has_fw = false; 103 104 read_logpage(fd, NVME_LOG_FIRMWARE_SLOT, 105 NVME_GLOBAL_NAMESPACE_TAG, 0, 0, 0, 0, 0, 0, 0, 106 &fw, sizeof(fw)); 107 108 if (fw.revision[slot-1][0] != '\0') 109 has_fw = true; 110 111 return (has_fw); 112} 113 114static void 115read_image_file(const char *path, void **buf, int32_t *size) 116{ 117 struct stat sb; 118 int32_t filesize; 119 int fd; 120 121 *size = 0; 122 *buf = NULL; 123 124 if ((fd = open(path, O_RDONLY)) < 0) 125 err(EX_NOINPUT, "unable to open '%s'", path); 126 if (fstat(fd, &sb) < 0) 127 err(EX_NOINPUT, "unable to stat '%s'", path); 128 129 /* 130 * The NVMe spec does not explicitly state a maximum firmware image 131 * size, although one can be inferred from the dword size limitation 132 * for the size and offset fields in the Firmware Image Download 133 * command. 134 * 135 * Technically, the max is UINT32_MAX * sizeof(uint32_t), since the 136 * size and offsets are specified in terms of dwords (not bytes), but 137 * realistically INT32_MAX is sufficient here and simplifies matters 138 * a bit. 139 */ 140 if (sb.st_size > INT32_MAX) 141 errx(EX_USAGE, "size of file '%s' is too large (%jd bytes)", 142 path, (intmax_t)sb.st_size); 143 filesize = (int32_t)sb.st_size; 144 if ((*buf = malloc(filesize)) == NULL) 145 errx(EX_OSERR, "unable to malloc %d bytes", filesize); 146 if ((*size = read(fd, *buf, filesize)) < 0) 147 err(EX_IOERR, "error reading '%s'", path); 148 /* XXX assuming no short reads */ 149 if (*size != filesize) 150 errx(EX_IOERR, 151 "error reading '%s' (read %d bytes, requested %d bytes)", 152 path, *size, filesize); 153 close(fd); 154} 155 156static void 157update_firmware(int fd, uint8_t *payload, int32_t payload_size, uint8_t fwug) 158{ 159 struct nvme_pt_command pt; 160 uint64_t max_xfer_size; 161 int32_t off; 162 uint32_t resid, size; 163 void *chunk; 164 165 off = 0; 166 resid = payload_size; 167 168 if (ioctl(fd, NVME_GET_MAX_XFER_SIZE, &max_xfer_size) < 0) 169 err(EX_IOERR, "query max transfer size failed"); 170 if (fwug != 0 && fwug != 0xFF) 171 max_xfer_size = MIN(max_xfer_size, (uint64_t)fwug << 12); 172 173 if ((chunk = aligned_alloc(PAGE_SIZE, max_xfer_size)) == NULL) 174 errx(EX_OSERR, "unable to malloc %zd bytes", (size_t)max_xfer_size); 175 176 while (resid > 0) { 177 size = (resid >= max_xfer_size) ? max_xfer_size : resid; 178 memcpy(chunk, payload + off, size); 179 180 memset(&pt, 0, sizeof(pt)); 181 pt.cmd.opc = NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD; 182 pt.cmd.cdw10 = htole32((size / sizeof(uint32_t)) - 1); 183 pt.cmd.cdw11 = htole32(off / sizeof(uint32_t)); 184 pt.buf = chunk; 185 pt.len = size; 186 pt.is_read = 0; 187 188 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 189 err(EX_IOERR, "firmware download request failed"); 190 191 if (nvme_completion_is_error(&pt.cpl)) 192 errx(EX_IOERR, "firmware download request returned error"); 193 194 resid -= size; 195 off += size; 196 } 197 free(chunk); 198} 199 200static int 201activate_firmware(int fd, int slot, int activate_action) 202{ 203 struct nvme_pt_command pt; 204 uint16_t sct, sc; 205 206 memset(&pt, 0, sizeof(pt)); 207 pt.cmd.opc = NVME_OPC_FIRMWARE_ACTIVATE; 208 pt.cmd.cdw10 = htole32((activate_action << 3) | slot); 209 pt.is_read = 0; 210 211 if (ioctl(fd, NVME_PASSTHROUGH_CMD, &pt) < 0) 212 err(EX_IOERR, "firmware activate request failed"); 213 214 sct = NVME_STATUS_GET_SCT(pt.cpl.status); 215 sc = NVME_STATUS_GET_SC(pt.cpl.status); 216 217 if (sct == NVME_SCT_COMMAND_SPECIFIC && 218 sc == NVME_SC_FIRMWARE_REQUIRES_RESET) 219 return 1; 220 221 if (nvme_completion_is_error(&pt.cpl)) 222 errx(EX_IOERR, "firmware activate request returned error"); 223 224 return 0; 225} 226 227static void 228firmware(const struct cmd *f, int argc, char *argv[]) 229{ 230 int fd = -1; 231 int activate_action, reboot_required; 232 char prompt[64]; 233 void *buf = NULL; 234 char *path; 235 int32_t size = 0, nsid; 236 uint16_t oacs_fw; 237 uint8_t fw_slot1_ro, fw_num_slots; 238 struct nvme_controller_data cdata; 239 240 if (arg_parse(argc, argv, f)) 241 return; 242 243 if (opt.slot == 0) { 244 fprintf(stderr, 245 "0 is not a valid slot number. " 246 "Slot numbers start at 1.\n"); 247 arg_help(argc, argv, f); 248 } else if (opt.slot > 7 && opt.slot != NONE) { 249 fprintf(stderr, 250 "Slot number %s specified which is " 251 "greater than max allowed slot number of " 252 "7.\n", optarg); 253 arg_help(argc, argv, f); 254 } 255 256 if (!opt.activate && opt.fw_img == NULL) { 257 fprintf(stderr, 258 "Neither a replace ([-f path_to_firmware]) nor " 259 "activate ([-a]) firmware image action\n" 260 "was specified.\n"); 261 arg_help(argc, argv, f); 262 } 263 264 if (opt.activate && opt.fw_img == NULL && opt.slot == 0) { 265 fprintf(stderr, 266 "Slot number to activate not specified.\n"); 267 arg_help(argc, argv, f); 268 } 269 270 open_dev(opt.dev, &fd, 1, 1); 271 get_nsid(fd, &path, &nsid); 272 if (nsid != 0) { 273 close(fd); 274 open_dev(path, &fd, 1, 1); 275 } 276 free(path); 277 278 if (read_controller_data(fd, &cdata)) 279 errx(EX_IOERR, "Identify request failed"); 280 281 oacs_fw = NVMEV(NVME_CTRLR_DATA_OACS_FIRMWARE, cdata.oacs); 282 283 if (oacs_fw == 0) 284 errx(EX_UNAVAILABLE, 285 "controller does not support firmware activate/download"); 286 287 fw_slot1_ro = NVMEV(NVME_CTRLR_DATA_FRMW_SLOT1_RO, cdata.frmw); 288 289 if (opt.fw_img && opt.slot == 1 && fw_slot1_ro) 290 errx(EX_UNAVAILABLE, "slot %d is marked as read only", opt.slot); 291 292 fw_num_slots = NVMEV(NVME_CTRLR_DATA_FRMW_NUM_SLOTS, cdata.frmw); 293 294 if (opt.slot > fw_num_slots) 295 errx(EX_UNAVAILABLE, 296 "slot %d specified but controller only supports %d slots", 297 opt.slot, fw_num_slots); 298 299 if (opt.activate && opt.fw_img == NULL && 300 !slot_has_valid_firmware(fd, opt.slot)) 301 errx(EX_UNAVAILABLE, 302 "slot %d does not contain valid firmware,\n" 303 "try 'nvmecontrol logpage -p 3 %s' to get a list " 304 "of available images\n", 305 opt.slot, opt.dev); 306 307 if (opt.fw_img) 308 read_image_file(opt.fw_img, &buf, &size); 309 310 if (opt.fw_img != NULL&& opt.activate) 311 printf("You are about to download and activate " 312 "firmware image (%s) to controller %s.\n" 313 "This may damage your controller and/or " 314 "overwrite an existing firmware image.\n", 315 opt.fw_img, opt.dev); 316 else if (opt.activate) 317 printf("You are about to activate a new firmware " 318 "image on controller %s.\n" 319 "This may damage your controller.\n", 320 opt.dev); 321 else if (opt.fw_img != NULL) 322 printf("You are about to download firmware image " 323 "(%s) to controller %s.\n" 324 "This may damage your controller and/or " 325 "overwrite an existing firmware image.\n", 326 opt.fw_img, opt.dev); 327 328 printf("Are you sure you want to continue? (yes/no) "); 329 while (1) { 330 fgets(prompt, sizeof(prompt), stdin); 331 if (strncasecmp(prompt, "yes", 3) == 0) 332 break; 333 if (strncasecmp(prompt, "no", 2) == 0) 334 exit(EX_DATAERR); 335 printf("Please answer \"yes\" or \"no\". "); 336 } 337 338 if (opt.fw_img != NULL) { 339 update_firmware(fd, buf, size, cdata.fwug); 340 if (opt.activate) 341 activate_action = NVME_AA_REPLACE_ACTIVATE; 342 else 343 activate_action = NVME_AA_REPLACE_NO_ACTIVATE; 344 } else { 345 activate_action = NVME_AA_ACTIVATE; 346 } 347 348 reboot_required = activate_firmware(fd, opt.slot, activate_action); 349 350 if (opt.activate) { 351 if (reboot_required) { 352 printf("New firmware image activated but requires " 353 "conventional reset (i.e. reboot) to " 354 "complete activation.\n"); 355 } else { 356 printf("New firmware image activated and will take " 357 "effect after next controller reset.\n" 358 "Controller reset can be initiated via " 359 "'nvmecontrol reset %s'\n", 360 opt.dev); 361 } 362 } 363 364 close(fd); 365 exit(0); 366} 367