1 /* 2 * NVMe admin command implementation. 3 * Copyright (c) 2015-2016 HGST, a Western Digital Company. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 */ 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 #include <linux/module.h> 16 #include <linux/rculist.h> 17 18 #include <generated/utsrelease.h> 19 #include <asm/unaligned.h> 20 #include "nvmet.h" 21 22 u32 nvmet_get_log_page_len(struct nvme_command *cmd) 23 { 24 u32 len = le16_to_cpu(cmd->get_log_page.numdu); 25 26 len <<= 16; 27 len += le16_to_cpu(cmd->get_log_page.numdl); 28 /* NUMD is a 0's based value */ 29 len += 1; 30 len *= sizeof(u32); 31 32 return len; 33 } 34 35 static void nvmet_execute_get_log_page_noop(struct nvmet_req *req) 36 { 37 nvmet_req_complete(req, nvmet_zero_sgl(req, 0, req->data_len)); 38 } 39 40 static u16 nvmet_get_smart_log_nsid(struct nvmet_req *req, 41 struct nvme_smart_log *slog) 42 { 43 struct nvmet_ns *ns; 44 u64 host_reads, host_writes, data_units_read, data_units_written; 45 46 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->get_log_page.nsid); 47 if (!ns) { 48 pr_err("nvmet : Could not find namespace id : %d\n", 49 le32_to_cpu(req->cmd->get_log_page.nsid)); 50 return NVME_SC_INVALID_NS; 51 } 52 53 /* we don't have the right data for file backed ns */ 54 if (!ns->bdev) 55 goto out; 56 57 host_reads = part_stat_read(ns->bdev->bd_part, ios[READ]); 58 data_units_read = part_stat_read(ns->bdev->bd_part, sectors[READ]); 59 host_writes = part_stat_read(ns->bdev->bd_part, ios[WRITE]); 60 data_units_written = part_stat_read(ns->bdev->bd_part, sectors[WRITE]); 61 62 put_unaligned_le64(host_reads, &slog->host_reads[0]); 63 put_unaligned_le64(data_units_read, &slog->data_units_read[0]); 64 put_unaligned_le64(host_writes, &slog->host_writes[0]); 65 put_unaligned_le64(data_units_written, &slog->data_units_written[0]); 66 out: 67 nvmet_put_namespace(ns); 68 69 return NVME_SC_SUCCESS; 70 } 71 72 static u16 nvmet_get_smart_log_all(struct nvmet_req *req, 73 struct nvme_smart_log *slog) 74 { 75 u64 host_reads = 0, host_writes = 0; 76 u64 data_units_read = 0, data_units_written = 0; 77 struct nvmet_ns *ns; 78 struct nvmet_ctrl *ctrl; 79 80 ctrl = req->sq->ctrl; 81 82 rcu_read_lock(); 83 list_for_each_entry_rcu(ns, &ctrl->subsys->namespaces, dev_link) { 84 /* we don't have the right data for file backed ns */ 85 if (!ns->bdev) 86 continue; 87 host_reads += part_stat_read(ns->bdev->bd_part, ios[READ]); 88 data_units_read += 89 part_stat_read(ns->bdev->bd_part, sectors[READ]); 90 host_writes += part_stat_read(ns->bdev->bd_part, ios[WRITE]); 91 data_units_written += 92 part_stat_read(ns->bdev->bd_part, sectors[WRITE]); 93 94 } 95 rcu_read_unlock(); 96 97 put_unaligned_le64(host_reads, &slog->host_reads[0]); 98 put_unaligned_le64(data_units_read, &slog->data_units_read[0]); 99 put_unaligned_le64(host_writes, &slog->host_writes[0]); 100 put_unaligned_le64(data_units_written, &slog->data_units_written[0]); 101 102 return NVME_SC_SUCCESS; 103 } 104 105 static void nvmet_execute_get_log_page_smart(struct nvmet_req *req) 106 { 107 struct nvme_smart_log *log; 108 u16 status = NVME_SC_INTERNAL; 109 110 if (req->data_len != sizeof(*log)) 111 goto out; 112 113 log = kzalloc(sizeof(*log), GFP_KERNEL); 114 if (!log) 115 goto out; 116 117 if (req->cmd->get_log_page.nsid == cpu_to_le32(NVME_NSID_ALL)) 118 status = nvmet_get_smart_log_all(req, log); 119 else 120 status = nvmet_get_smart_log_nsid(req, log); 121 if (status) 122 goto out; 123 124 status = nvmet_copy_to_sgl(req, 0, log, sizeof(*log)); 125 out: 126 nvmet_req_complete(req, status); 127 } 128 129 static void nvmet_execute_get_log_changed_ns(struct nvmet_req *req) 130 { 131 struct nvmet_ctrl *ctrl = req->sq->ctrl; 132 u16 status = NVME_SC_INTERNAL; 133 size_t len; 134 135 if (req->data_len != NVME_MAX_CHANGED_NAMESPACES * sizeof(__le32)) 136 goto out; 137 138 mutex_lock(&ctrl->lock); 139 if (ctrl->nr_changed_ns == U32_MAX) 140 len = sizeof(__le32); 141 else 142 len = ctrl->nr_changed_ns * sizeof(__le32); 143 status = nvmet_copy_to_sgl(req, 0, ctrl->changed_ns_list, len); 144 if (!status) 145 status = nvmet_zero_sgl(req, len, req->data_len - len); 146 ctrl->nr_changed_ns = 0; 147 clear_bit(NVME_AEN_CFG_NS_ATTR, &ctrl->aen_masked); 148 mutex_unlock(&ctrl->lock); 149 out: 150 nvmet_req_complete(req, status); 151 } 152 153 static void nvmet_execute_identify_ctrl(struct nvmet_req *req) 154 { 155 struct nvmet_ctrl *ctrl = req->sq->ctrl; 156 struct nvme_id_ctrl *id; 157 u16 status = 0; 158 const char model[] = "Linux"; 159 160 id = kzalloc(sizeof(*id), GFP_KERNEL); 161 if (!id) { 162 status = NVME_SC_INTERNAL; 163 goto out; 164 } 165 166 /* XXX: figure out how to assign real vendors IDs. */ 167 id->vid = 0; 168 id->ssvid = 0; 169 170 memset(id->sn, ' ', sizeof(id->sn)); 171 bin2hex(id->sn, &ctrl->subsys->serial, 172 min(sizeof(ctrl->subsys->serial), sizeof(id->sn) / 2)); 173 memcpy_and_pad(id->mn, sizeof(id->mn), model, sizeof(model) - 1, ' '); 174 memcpy_and_pad(id->fr, sizeof(id->fr), 175 UTS_RELEASE, strlen(UTS_RELEASE), ' '); 176 177 id->rab = 6; 178 179 /* 180 * XXX: figure out how we can assign a IEEE OUI, but until then 181 * the safest is to leave it as zeroes. 182 */ 183 184 /* we support multiple ports and multiples hosts: */ 185 id->cmic = (1 << 0) | (1 << 1); 186 187 /* no limit on data transfer sizes for now */ 188 id->mdts = 0; 189 id->cntlid = cpu_to_le16(ctrl->cntlid); 190 id->ver = cpu_to_le32(ctrl->subsys->ver); 191 192 /* XXX: figure out what to do about RTD3R/RTD3 */ 193 id->oaes = cpu_to_le32(NVMET_AEN_CFG_OPTIONAL); 194 id->ctratt = cpu_to_le32(1 << 0); 195 196 id->oacs = 0; 197 198 /* 199 * We don't really have a practical limit on the number of abort 200 * comands. But we don't do anything useful for abort either, so 201 * no point in allowing more abort commands than the spec requires. 202 */ 203 id->acl = 3; 204 205 id->aerl = NVMET_ASYNC_EVENTS - 1; 206 207 /* first slot is read-only, only one slot supported */ 208 id->frmw = (1 << 0) | (1 << 1); 209 id->lpa = (1 << 0) | (1 << 2); 210 id->elpe = NVMET_ERROR_LOG_SLOTS - 1; 211 id->npss = 0; 212 213 /* We support keep-alive timeout in granularity of seconds */ 214 id->kas = cpu_to_le16(NVMET_KAS); 215 216 id->sqes = (0x6 << 4) | 0x6; 217 id->cqes = (0x4 << 4) | 0x4; 218 219 /* no enforcement soft-limit for maxcmd - pick arbitrary high value */ 220 id->maxcmd = cpu_to_le16(NVMET_MAX_CMD); 221 222 id->nn = cpu_to_le32(ctrl->subsys->max_nsid); 223 id->oncs = cpu_to_le16(NVME_CTRL_ONCS_DSM | 224 NVME_CTRL_ONCS_WRITE_ZEROES); 225 226 /* XXX: don't report vwc if the underlying device is write through */ 227 id->vwc = NVME_CTRL_VWC_PRESENT; 228 229 /* 230 * We can't support atomic writes bigger than a LBA without support 231 * from the backend device. 232 */ 233 id->awun = 0; 234 id->awupf = 0; 235 236 id->sgls = cpu_to_le32(1 << 0); /* we always support SGLs */ 237 if (ctrl->ops->has_keyed_sgls) 238 id->sgls |= cpu_to_le32(1 << 2); 239 if (ctrl->ops->sqe_inline_size) 240 id->sgls |= cpu_to_le32(1 << 20); 241 242 strcpy(id->subnqn, ctrl->subsys->subsysnqn); 243 244 /* Max command capsule size is sqe + single page of in-capsule data */ 245 id->ioccsz = cpu_to_le32((sizeof(struct nvme_command) + 246 ctrl->ops->sqe_inline_size) / 16); 247 /* Max response capsule size is cqe */ 248 id->iorcsz = cpu_to_le32(sizeof(struct nvme_completion) / 16); 249 250 id->msdbd = ctrl->ops->msdbd; 251 252 /* 253 * Meh, we don't really support any power state. Fake up the same 254 * values that qemu does. 255 */ 256 id->psd[0].max_power = cpu_to_le16(0x9c4); 257 id->psd[0].entry_lat = cpu_to_le32(0x10); 258 id->psd[0].exit_lat = cpu_to_le32(0x4); 259 260 status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id)); 261 262 kfree(id); 263 out: 264 nvmet_req_complete(req, status); 265 } 266 267 static void nvmet_execute_identify_ns(struct nvmet_req *req) 268 { 269 struct nvmet_ns *ns; 270 struct nvme_id_ns *id; 271 u16 status = 0; 272 273 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->identify.nsid); 274 if (!ns) { 275 status = NVME_SC_INVALID_NS | NVME_SC_DNR; 276 goto out; 277 } 278 279 id = kzalloc(sizeof(*id), GFP_KERNEL); 280 if (!id) { 281 status = NVME_SC_INTERNAL; 282 goto out_put_ns; 283 } 284 285 /* 286 * nuse = ncap = nsze isn't always true, but we have no way to find 287 * that out from the underlying device. 288 */ 289 id->ncap = id->nuse = id->nsze = 290 cpu_to_le64(ns->size >> ns->blksize_shift); 291 292 /* 293 * We just provide a single LBA format that matches what the 294 * underlying device reports. 295 */ 296 id->nlbaf = 0; 297 id->flbas = 0; 298 299 /* 300 * Our namespace might always be shared. Not just with other 301 * controllers, but also with any other user of the block device. 302 */ 303 id->nmic = (1 << 0); 304 305 memcpy(&id->nguid, &ns->nguid, sizeof(uuid_le)); 306 307 id->lbaf[0].ds = ns->blksize_shift; 308 309 status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id)); 310 311 kfree(id); 312 out_put_ns: 313 nvmet_put_namespace(ns); 314 out: 315 nvmet_req_complete(req, status); 316 } 317 318 static void nvmet_execute_identify_nslist(struct nvmet_req *req) 319 { 320 static const int buf_size = NVME_IDENTIFY_DATA_SIZE; 321 struct nvmet_ctrl *ctrl = req->sq->ctrl; 322 struct nvmet_ns *ns; 323 u32 min_nsid = le32_to_cpu(req->cmd->identify.nsid); 324 __le32 *list; 325 u16 status = 0; 326 int i = 0; 327 328 list = kzalloc(buf_size, GFP_KERNEL); 329 if (!list) { 330 status = NVME_SC_INTERNAL; 331 goto out; 332 } 333 334 rcu_read_lock(); 335 list_for_each_entry_rcu(ns, &ctrl->subsys->namespaces, dev_link) { 336 if (ns->nsid <= min_nsid) 337 continue; 338 list[i++] = cpu_to_le32(ns->nsid); 339 if (i == buf_size / sizeof(__le32)) 340 break; 341 } 342 rcu_read_unlock(); 343 344 status = nvmet_copy_to_sgl(req, 0, list, buf_size); 345 346 kfree(list); 347 out: 348 nvmet_req_complete(req, status); 349 } 350 351 static u16 nvmet_copy_ns_identifier(struct nvmet_req *req, u8 type, u8 len, 352 void *id, off_t *off) 353 { 354 struct nvme_ns_id_desc desc = { 355 .nidt = type, 356 .nidl = len, 357 }; 358 u16 status; 359 360 status = nvmet_copy_to_sgl(req, *off, &desc, sizeof(desc)); 361 if (status) 362 return status; 363 *off += sizeof(desc); 364 365 status = nvmet_copy_to_sgl(req, *off, id, len); 366 if (status) 367 return status; 368 *off += len; 369 370 return 0; 371 } 372 373 static void nvmet_execute_identify_desclist(struct nvmet_req *req) 374 { 375 struct nvmet_ns *ns; 376 u16 status = 0; 377 off_t off = 0; 378 379 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->identify.nsid); 380 if (!ns) { 381 status = NVME_SC_INVALID_NS | NVME_SC_DNR; 382 goto out; 383 } 384 385 if (memchr_inv(&ns->uuid, 0, sizeof(ns->uuid))) { 386 status = nvmet_copy_ns_identifier(req, NVME_NIDT_UUID, 387 NVME_NIDT_UUID_LEN, 388 &ns->uuid, &off); 389 if (status) 390 goto out_put_ns; 391 } 392 if (memchr_inv(ns->nguid, 0, sizeof(ns->nguid))) { 393 status = nvmet_copy_ns_identifier(req, NVME_NIDT_NGUID, 394 NVME_NIDT_NGUID_LEN, 395 &ns->nguid, &off); 396 if (status) 397 goto out_put_ns; 398 } 399 400 if (sg_zero_buffer(req->sg, req->sg_cnt, NVME_IDENTIFY_DATA_SIZE - off, 401 off) != NVME_IDENTIFY_DATA_SIZE - off) 402 status = NVME_SC_INTERNAL | NVME_SC_DNR; 403 out_put_ns: 404 nvmet_put_namespace(ns); 405 out: 406 nvmet_req_complete(req, status); 407 } 408 409 /* 410 * A "minimum viable" abort implementation: the command is mandatory in the 411 * spec, but we are not required to do any useful work. We couldn't really 412 * do a useful abort, so don't bother even with waiting for the command 413 * to be exectuted and return immediately telling the command to abort 414 * wasn't found. 415 */ 416 static void nvmet_execute_abort(struct nvmet_req *req) 417 { 418 nvmet_set_result(req, 1); 419 nvmet_req_complete(req, 0); 420 } 421 422 static void nvmet_execute_set_features(struct nvmet_req *req) 423 { 424 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 425 u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10[0]); 426 u32 val32; 427 u16 status = 0; 428 429 switch (cdw10 & 0xff) { 430 case NVME_FEAT_NUM_QUEUES: 431 nvmet_set_result(req, 432 (subsys->max_qid - 1) | ((subsys->max_qid - 1) << 16)); 433 break; 434 case NVME_FEAT_KATO: 435 val32 = le32_to_cpu(req->cmd->common.cdw10[1]); 436 req->sq->ctrl->kato = DIV_ROUND_UP(val32, 1000); 437 nvmet_set_result(req, req->sq->ctrl->kato); 438 break; 439 case NVME_FEAT_ASYNC_EVENT: 440 val32 = le32_to_cpu(req->cmd->common.cdw10[1]); 441 if (val32 & ~NVMET_AEN_CFG_ALL) { 442 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 443 break; 444 } 445 446 WRITE_ONCE(req->sq->ctrl->aen_enabled, val32); 447 nvmet_set_result(req, val32); 448 break; 449 case NVME_FEAT_HOST_ID: 450 status = NVME_SC_CMD_SEQ_ERROR | NVME_SC_DNR; 451 break; 452 default: 453 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 454 break; 455 } 456 457 nvmet_req_complete(req, status); 458 } 459 460 static void nvmet_execute_get_features(struct nvmet_req *req) 461 { 462 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 463 u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10[0]); 464 u16 status = 0; 465 466 switch (cdw10 & 0xff) { 467 /* 468 * These features are mandatory in the spec, but we don't 469 * have a useful way to implement them. We'll eventually 470 * need to come up with some fake values for these. 471 */ 472 #if 0 473 case NVME_FEAT_ARBITRATION: 474 break; 475 case NVME_FEAT_POWER_MGMT: 476 break; 477 case NVME_FEAT_TEMP_THRESH: 478 break; 479 case NVME_FEAT_ERR_RECOVERY: 480 break; 481 case NVME_FEAT_IRQ_COALESCE: 482 break; 483 case NVME_FEAT_IRQ_CONFIG: 484 break; 485 case NVME_FEAT_WRITE_ATOMIC: 486 break; 487 #endif 488 case NVME_FEAT_ASYNC_EVENT: 489 nvmet_set_result(req, READ_ONCE(req->sq->ctrl->aen_enabled)); 490 break; 491 case NVME_FEAT_VOLATILE_WC: 492 nvmet_set_result(req, 1); 493 break; 494 case NVME_FEAT_NUM_QUEUES: 495 nvmet_set_result(req, 496 (subsys->max_qid-1) | ((subsys->max_qid-1) << 16)); 497 break; 498 case NVME_FEAT_KATO: 499 nvmet_set_result(req, req->sq->ctrl->kato * 1000); 500 break; 501 case NVME_FEAT_HOST_ID: 502 /* need 128-bit host identifier flag */ 503 if (!(req->cmd->common.cdw10[1] & cpu_to_le32(1 << 0))) { 504 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 505 break; 506 } 507 508 status = nvmet_copy_to_sgl(req, 0, &req->sq->ctrl->hostid, 509 sizeof(req->sq->ctrl->hostid)); 510 break; 511 default: 512 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 513 break; 514 } 515 516 nvmet_req_complete(req, status); 517 } 518 519 static void nvmet_execute_async_event(struct nvmet_req *req) 520 { 521 struct nvmet_ctrl *ctrl = req->sq->ctrl; 522 523 mutex_lock(&ctrl->lock); 524 if (ctrl->nr_async_event_cmds >= NVMET_ASYNC_EVENTS) { 525 mutex_unlock(&ctrl->lock); 526 nvmet_req_complete(req, NVME_SC_ASYNC_LIMIT | NVME_SC_DNR); 527 return; 528 } 529 ctrl->async_event_cmds[ctrl->nr_async_event_cmds++] = req; 530 mutex_unlock(&ctrl->lock); 531 532 schedule_work(&ctrl->async_event_work); 533 } 534 535 static void nvmet_execute_keep_alive(struct nvmet_req *req) 536 { 537 struct nvmet_ctrl *ctrl = req->sq->ctrl; 538 539 pr_debug("ctrl %d update keep-alive timer for %d secs\n", 540 ctrl->cntlid, ctrl->kato); 541 542 mod_delayed_work(system_wq, &ctrl->ka_work, ctrl->kato * HZ); 543 nvmet_req_complete(req, 0); 544 } 545 546 u16 nvmet_parse_admin_cmd(struct nvmet_req *req) 547 { 548 struct nvme_command *cmd = req->cmd; 549 u16 ret; 550 551 ret = nvmet_check_ctrl_status(req, cmd); 552 if (unlikely(ret)) 553 return ret; 554 555 switch (cmd->common.opcode) { 556 case nvme_admin_get_log_page: 557 req->data_len = nvmet_get_log_page_len(cmd); 558 559 switch (cmd->get_log_page.lid) { 560 case NVME_LOG_ERROR: 561 /* 562 * We currently never set the More bit in the status 563 * field, so all error log entries are invalid and can 564 * be zeroed out. This is called a minum viable 565 * implementation (TM) of this mandatory log page. 566 */ 567 req->execute = nvmet_execute_get_log_page_noop; 568 return 0; 569 case NVME_LOG_SMART: 570 req->execute = nvmet_execute_get_log_page_smart; 571 return 0; 572 case NVME_LOG_FW_SLOT: 573 /* 574 * We only support a single firmware slot which always 575 * is active, so we can zero out the whole firmware slot 576 * log and still claim to fully implement this mandatory 577 * log page. 578 */ 579 req->execute = nvmet_execute_get_log_page_noop; 580 return 0; 581 case NVME_LOG_CHANGED_NS: 582 req->execute = nvmet_execute_get_log_changed_ns; 583 return 0; 584 } 585 break; 586 case nvme_admin_identify: 587 req->data_len = NVME_IDENTIFY_DATA_SIZE; 588 switch (cmd->identify.cns) { 589 case NVME_ID_CNS_NS: 590 req->execute = nvmet_execute_identify_ns; 591 return 0; 592 case NVME_ID_CNS_CTRL: 593 req->execute = nvmet_execute_identify_ctrl; 594 return 0; 595 case NVME_ID_CNS_NS_ACTIVE_LIST: 596 req->execute = nvmet_execute_identify_nslist; 597 return 0; 598 case NVME_ID_CNS_NS_DESC_LIST: 599 req->execute = nvmet_execute_identify_desclist; 600 return 0; 601 } 602 break; 603 case nvme_admin_abort_cmd: 604 req->execute = nvmet_execute_abort; 605 req->data_len = 0; 606 return 0; 607 case nvme_admin_set_features: 608 req->execute = nvmet_execute_set_features; 609 req->data_len = 0; 610 return 0; 611 case nvme_admin_get_features: 612 req->execute = nvmet_execute_get_features; 613 req->data_len = 0; 614 return 0; 615 case nvme_admin_async_event: 616 req->execute = nvmet_execute_async_event; 617 req->data_len = 0; 618 return 0; 619 case nvme_admin_keep_alive: 620 req->execute = nvmet_execute_keep_alive; 621 req->data_len = 0; 622 return 0; 623 } 624 625 pr_err("unhandled cmd %d on qid %d\n", cmd->common.opcode, 626 req->sq->qid); 627 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; 628 } 629