1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * NVMe admin command implementation. 4 * Copyright (c) 2015-2016 HGST, a Western Digital Company. 5 */ 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 #include <linux/module.h> 8 #include <linux/rculist.h> 9 10 #include <generated/utsrelease.h> 11 #include <asm/unaligned.h> 12 #include "nvmet.h" 13 14 u32 nvmet_get_log_page_len(struct nvme_command *cmd) 15 { 16 u32 len = le16_to_cpu(cmd->get_log_page.numdu); 17 18 len <<= 16; 19 len += le16_to_cpu(cmd->get_log_page.numdl); 20 /* NUMD is a 0's based value */ 21 len += 1; 22 len *= sizeof(u32); 23 24 return len; 25 } 26 27 u64 nvmet_get_log_page_offset(struct nvme_command *cmd) 28 { 29 return le64_to_cpu(cmd->get_log_page.lpo); 30 } 31 32 static void nvmet_execute_get_log_page_noop(struct nvmet_req *req) 33 { 34 nvmet_req_complete(req, nvmet_zero_sgl(req, 0, req->data_len)); 35 } 36 37 static void nvmet_execute_get_log_page_error(struct nvmet_req *req) 38 { 39 struct nvmet_ctrl *ctrl = req->sq->ctrl; 40 u16 status = NVME_SC_SUCCESS; 41 unsigned long flags; 42 off_t offset = 0; 43 u64 slot; 44 u64 i; 45 46 spin_lock_irqsave(&ctrl->error_lock, flags); 47 slot = ctrl->err_counter % NVMET_ERROR_LOG_SLOTS; 48 49 for (i = 0; i < NVMET_ERROR_LOG_SLOTS; i++) { 50 status = nvmet_copy_to_sgl(req, offset, &ctrl->slots[slot], 51 sizeof(struct nvme_error_slot)); 52 if (status) 53 break; 54 55 if (slot == 0) 56 slot = NVMET_ERROR_LOG_SLOTS - 1; 57 else 58 slot--; 59 offset += sizeof(struct nvme_error_slot); 60 } 61 spin_unlock_irqrestore(&ctrl->error_lock, flags); 62 nvmet_req_complete(req, status); 63 } 64 65 static u16 nvmet_get_smart_log_nsid(struct nvmet_req *req, 66 struct nvme_smart_log *slog) 67 { 68 struct nvmet_ns *ns; 69 u64 host_reads, host_writes, data_units_read, data_units_written; 70 71 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->get_log_page.nsid); 72 if (!ns) { 73 pr_err("Could not find namespace id : %d\n", 74 le32_to_cpu(req->cmd->get_log_page.nsid)); 75 req->error_loc = offsetof(struct nvme_rw_command, nsid); 76 return NVME_SC_INVALID_NS; 77 } 78 79 /* we don't have the right data for file backed ns */ 80 if (!ns->bdev) 81 goto out; 82 83 host_reads = part_stat_read(ns->bdev->bd_part, ios[READ]); 84 data_units_read = part_stat_read(ns->bdev->bd_part, sectors[READ]); 85 host_writes = part_stat_read(ns->bdev->bd_part, ios[WRITE]); 86 data_units_written = part_stat_read(ns->bdev->bd_part, sectors[WRITE]); 87 88 put_unaligned_le64(host_reads, &slog->host_reads[0]); 89 put_unaligned_le64(data_units_read, &slog->data_units_read[0]); 90 put_unaligned_le64(host_writes, &slog->host_writes[0]); 91 put_unaligned_le64(data_units_written, &slog->data_units_written[0]); 92 out: 93 nvmet_put_namespace(ns); 94 95 return NVME_SC_SUCCESS; 96 } 97 98 static u16 nvmet_get_smart_log_all(struct nvmet_req *req, 99 struct nvme_smart_log *slog) 100 { 101 u64 host_reads = 0, host_writes = 0; 102 u64 data_units_read = 0, data_units_written = 0; 103 struct nvmet_ns *ns; 104 struct nvmet_ctrl *ctrl; 105 106 ctrl = req->sq->ctrl; 107 108 rcu_read_lock(); 109 list_for_each_entry_rcu(ns, &ctrl->subsys->namespaces, dev_link) { 110 /* we don't have the right data for file backed ns */ 111 if (!ns->bdev) 112 continue; 113 host_reads += part_stat_read(ns->bdev->bd_part, ios[READ]); 114 data_units_read += 115 part_stat_read(ns->bdev->bd_part, sectors[READ]); 116 host_writes += part_stat_read(ns->bdev->bd_part, ios[WRITE]); 117 data_units_written += 118 part_stat_read(ns->bdev->bd_part, sectors[WRITE]); 119 120 } 121 rcu_read_unlock(); 122 123 put_unaligned_le64(host_reads, &slog->host_reads[0]); 124 put_unaligned_le64(data_units_read, &slog->data_units_read[0]); 125 put_unaligned_le64(host_writes, &slog->host_writes[0]); 126 put_unaligned_le64(data_units_written, &slog->data_units_written[0]); 127 128 return NVME_SC_SUCCESS; 129 } 130 131 static void nvmet_execute_get_log_page_smart(struct nvmet_req *req) 132 { 133 struct nvme_smart_log *log; 134 u16 status = NVME_SC_INTERNAL; 135 unsigned long flags; 136 137 if (req->data_len != sizeof(*log)) 138 goto out; 139 140 log = kzalloc(sizeof(*log), GFP_KERNEL); 141 if (!log) 142 goto out; 143 144 if (req->cmd->get_log_page.nsid == cpu_to_le32(NVME_NSID_ALL)) 145 status = nvmet_get_smart_log_all(req, log); 146 else 147 status = nvmet_get_smart_log_nsid(req, log); 148 if (status) 149 goto out_free_log; 150 151 spin_lock_irqsave(&req->sq->ctrl->error_lock, flags); 152 put_unaligned_le64(req->sq->ctrl->err_counter, 153 &log->num_err_log_entries); 154 spin_unlock_irqrestore(&req->sq->ctrl->error_lock, flags); 155 156 status = nvmet_copy_to_sgl(req, 0, log, sizeof(*log)); 157 out_free_log: 158 kfree(log); 159 out: 160 nvmet_req_complete(req, status); 161 } 162 163 static void nvmet_execute_get_log_cmd_effects_ns(struct nvmet_req *req) 164 { 165 u16 status = NVME_SC_INTERNAL; 166 struct nvme_effects_log *log; 167 168 log = kzalloc(sizeof(*log), GFP_KERNEL); 169 if (!log) 170 goto out; 171 172 log->acs[nvme_admin_get_log_page] = cpu_to_le32(1 << 0); 173 log->acs[nvme_admin_identify] = cpu_to_le32(1 << 0); 174 log->acs[nvme_admin_abort_cmd] = cpu_to_le32(1 << 0); 175 log->acs[nvme_admin_set_features] = cpu_to_le32(1 << 0); 176 log->acs[nvme_admin_get_features] = cpu_to_le32(1 << 0); 177 log->acs[nvme_admin_async_event] = cpu_to_le32(1 << 0); 178 log->acs[nvme_admin_keep_alive] = cpu_to_le32(1 << 0); 179 180 log->iocs[nvme_cmd_read] = cpu_to_le32(1 << 0); 181 log->iocs[nvme_cmd_write] = cpu_to_le32(1 << 0); 182 log->iocs[nvme_cmd_flush] = cpu_to_le32(1 << 0); 183 log->iocs[nvme_cmd_dsm] = cpu_to_le32(1 << 0); 184 log->iocs[nvme_cmd_write_zeroes] = cpu_to_le32(1 << 0); 185 186 status = nvmet_copy_to_sgl(req, 0, log, sizeof(*log)); 187 188 kfree(log); 189 out: 190 nvmet_req_complete(req, status); 191 } 192 193 static void nvmet_execute_get_log_changed_ns(struct nvmet_req *req) 194 { 195 struct nvmet_ctrl *ctrl = req->sq->ctrl; 196 u16 status = NVME_SC_INTERNAL; 197 size_t len; 198 199 if (req->data_len != NVME_MAX_CHANGED_NAMESPACES * sizeof(__le32)) 200 goto out; 201 202 mutex_lock(&ctrl->lock); 203 if (ctrl->nr_changed_ns == U32_MAX) 204 len = sizeof(__le32); 205 else 206 len = ctrl->nr_changed_ns * sizeof(__le32); 207 status = nvmet_copy_to_sgl(req, 0, ctrl->changed_ns_list, len); 208 if (!status) 209 status = nvmet_zero_sgl(req, len, req->data_len - len); 210 ctrl->nr_changed_ns = 0; 211 nvmet_clear_aen_bit(req, NVME_AEN_BIT_NS_ATTR); 212 mutex_unlock(&ctrl->lock); 213 out: 214 nvmet_req_complete(req, status); 215 } 216 217 static u32 nvmet_format_ana_group(struct nvmet_req *req, u32 grpid, 218 struct nvme_ana_group_desc *desc) 219 { 220 struct nvmet_ctrl *ctrl = req->sq->ctrl; 221 struct nvmet_ns *ns; 222 u32 count = 0; 223 224 if (!(req->cmd->get_log_page.lsp & NVME_ANA_LOG_RGO)) { 225 rcu_read_lock(); 226 list_for_each_entry_rcu(ns, &ctrl->subsys->namespaces, dev_link) 227 if (ns->anagrpid == grpid) 228 desc->nsids[count++] = cpu_to_le32(ns->nsid); 229 rcu_read_unlock(); 230 } 231 232 desc->grpid = cpu_to_le32(grpid); 233 desc->nnsids = cpu_to_le32(count); 234 desc->chgcnt = cpu_to_le64(nvmet_ana_chgcnt); 235 desc->state = req->port->ana_state[grpid]; 236 memset(desc->rsvd17, 0, sizeof(desc->rsvd17)); 237 return sizeof(struct nvme_ana_group_desc) + count * sizeof(__le32); 238 } 239 240 static void nvmet_execute_get_log_page_ana(struct nvmet_req *req) 241 { 242 struct nvme_ana_rsp_hdr hdr = { 0, }; 243 struct nvme_ana_group_desc *desc; 244 size_t offset = sizeof(struct nvme_ana_rsp_hdr); /* start beyond hdr */ 245 size_t len; 246 u32 grpid; 247 u16 ngrps = 0; 248 u16 status; 249 250 status = NVME_SC_INTERNAL; 251 desc = kmalloc(sizeof(struct nvme_ana_group_desc) + 252 NVMET_MAX_NAMESPACES * sizeof(__le32), GFP_KERNEL); 253 if (!desc) 254 goto out; 255 256 down_read(&nvmet_ana_sem); 257 for (grpid = 1; grpid <= NVMET_MAX_ANAGRPS; grpid++) { 258 if (!nvmet_ana_group_enabled[grpid]) 259 continue; 260 len = nvmet_format_ana_group(req, grpid, desc); 261 status = nvmet_copy_to_sgl(req, offset, desc, len); 262 if (status) 263 break; 264 offset += len; 265 ngrps++; 266 } 267 for ( ; grpid <= NVMET_MAX_ANAGRPS; grpid++) { 268 if (nvmet_ana_group_enabled[grpid]) 269 ngrps++; 270 } 271 272 hdr.chgcnt = cpu_to_le64(nvmet_ana_chgcnt); 273 hdr.ngrps = cpu_to_le16(ngrps); 274 nvmet_clear_aen_bit(req, NVME_AEN_BIT_ANA_CHANGE); 275 up_read(&nvmet_ana_sem); 276 277 kfree(desc); 278 279 /* copy the header last once we know the number of groups */ 280 status = nvmet_copy_to_sgl(req, 0, &hdr, sizeof(hdr)); 281 out: 282 nvmet_req_complete(req, status); 283 } 284 285 static void nvmet_execute_identify_ctrl(struct nvmet_req *req) 286 { 287 struct nvmet_ctrl *ctrl = req->sq->ctrl; 288 struct nvme_id_ctrl *id; 289 u16 status = 0; 290 const char model[] = "Linux"; 291 292 id = kzalloc(sizeof(*id), GFP_KERNEL); 293 if (!id) { 294 status = NVME_SC_INTERNAL; 295 goto out; 296 } 297 298 /* XXX: figure out how to assign real vendors IDs. */ 299 id->vid = 0; 300 id->ssvid = 0; 301 302 memset(id->sn, ' ', sizeof(id->sn)); 303 bin2hex(id->sn, &ctrl->subsys->serial, 304 min(sizeof(ctrl->subsys->serial), sizeof(id->sn) / 2)); 305 memcpy_and_pad(id->mn, sizeof(id->mn), model, sizeof(model) - 1, ' '); 306 memcpy_and_pad(id->fr, sizeof(id->fr), 307 UTS_RELEASE, strlen(UTS_RELEASE), ' '); 308 309 id->rab = 6; 310 311 /* 312 * XXX: figure out how we can assign a IEEE OUI, but until then 313 * the safest is to leave it as zeroes. 314 */ 315 316 /* we support multiple ports, multiples hosts and ANA: */ 317 id->cmic = (1 << 0) | (1 << 1) | (1 << 3); 318 319 /* no limit on data transfer sizes for now */ 320 id->mdts = 0; 321 id->cntlid = cpu_to_le16(ctrl->cntlid); 322 id->ver = cpu_to_le32(ctrl->subsys->ver); 323 324 /* XXX: figure out what to do about RTD3R/RTD3 */ 325 id->oaes = cpu_to_le32(NVMET_AEN_CFG_OPTIONAL); 326 id->ctratt = cpu_to_le32(NVME_CTRL_ATTR_HID_128_BIT | 327 NVME_CTRL_ATTR_TBKAS); 328 329 id->oacs = 0; 330 331 /* 332 * We don't really have a practical limit on the number of abort 333 * comands. But we don't do anything useful for abort either, so 334 * no point in allowing more abort commands than the spec requires. 335 */ 336 id->acl = 3; 337 338 id->aerl = NVMET_ASYNC_EVENTS - 1; 339 340 /* first slot is read-only, only one slot supported */ 341 id->frmw = (1 << 0) | (1 << 1); 342 id->lpa = (1 << 0) | (1 << 1) | (1 << 2); 343 id->elpe = NVMET_ERROR_LOG_SLOTS - 1; 344 id->npss = 0; 345 346 /* We support keep-alive timeout in granularity of seconds */ 347 id->kas = cpu_to_le16(NVMET_KAS); 348 349 id->sqes = (0x6 << 4) | 0x6; 350 id->cqes = (0x4 << 4) | 0x4; 351 352 /* no enforcement soft-limit for maxcmd - pick arbitrary high value */ 353 id->maxcmd = cpu_to_le16(NVMET_MAX_CMD); 354 355 id->nn = cpu_to_le32(ctrl->subsys->max_nsid); 356 id->mnan = cpu_to_le32(NVMET_MAX_NAMESPACES); 357 id->oncs = cpu_to_le16(NVME_CTRL_ONCS_DSM | 358 NVME_CTRL_ONCS_WRITE_ZEROES); 359 360 /* XXX: don't report vwc if the underlying device is write through */ 361 id->vwc = NVME_CTRL_VWC_PRESENT; 362 363 /* 364 * We can't support atomic writes bigger than a LBA without support 365 * from the backend device. 366 */ 367 id->awun = 0; 368 id->awupf = 0; 369 370 id->sgls = cpu_to_le32(1 << 0); /* we always support SGLs */ 371 if (ctrl->ops->has_keyed_sgls) 372 id->sgls |= cpu_to_le32(1 << 2); 373 if (req->port->inline_data_size) 374 id->sgls |= cpu_to_le32(1 << 20); 375 376 strlcpy(id->subnqn, ctrl->subsys->subsysnqn, sizeof(id->subnqn)); 377 378 /* Max command capsule size is sqe + single page of in-capsule data */ 379 id->ioccsz = cpu_to_le32((sizeof(struct nvme_command) + 380 req->port->inline_data_size) / 16); 381 /* Max response capsule size is cqe */ 382 id->iorcsz = cpu_to_le32(sizeof(struct nvme_completion) / 16); 383 384 id->msdbd = ctrl->ops->msdbd; 385 386 id->anacap = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4); 387 id->anatt = 10; /* random value */ 388 id->anagrpmax = cpu_to_le32(NVMET_MAX_ANAGRPS); 389 id->nanagrpid = cpu_to_le32(NVMET_MAX_ANAGRPS); 390 391 /* 392 * Meh, we don't really support any power state. Fake up the same 393 * values that qemu does. 394 */ 395 id->psd[0].max_power = cpu_to_le16(0x9c4); 396 id->psd[0].entry_lat = cpu_to_le32(0x10); 397 id->psd[0].exit_lat = cpu_to_le32(0x4); 398 399 id->nwpc = 1 << 0; /* write protect and no write protect */ 400 401 status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id)); 402 403 kfree(id); 404 out: 405 nvmet_req_complete(req, status); 406 } 407 408 static void nvmet_execute_identify_ns(struct nvmet_req *req) 409 { 410 struct nvmet_ns *ns; 411 struct nvme_id_ns *id; 412 u16 status = 0; 413 414 if (le32_to_cpu(req->cmd->identify.nsid) == NVME_NSID_ALL) { 415 req->error_loc = offsetof(struct nvme_identify, nsid); 416 status = NVME_SC_INVALID_NS | NVME_SC_DNR; 417 goto out; 418 } 419 420 id = kzalloc(sizeof(*id), GFP_KERNEL); 421 if (!id) { 422 status = NVME_SC_INTERNAL; 423 goto out; 424 } 425 426 /* return an all zeroed buffer if we can't find an active namespace */ 427 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->identify.nsid); 428 if (!ns) 429 goto done; 430 431 /* 432 * nuse = ncap = nsze isn't always true, but we have no way to find 433 * that out from the underlying device. 434 */ 435 id->ncap = id->nsze = cpu_to_le64(ns->size >> ns->blksize_shift); 436 switch (req->port->ana_state[ns->anagrpid]) { 437 case NVME_ANA_INACCESSIBLE: 438 case NVME_ANA_PERSISTENT_LOSS: 439 break; 440 default: 441 id->nuse = id->nsze; 442 break; 443 } 444 445 if (ns->bdev) 446 nvmet_bdev_set_limits(ns->bdev, id); 447 448 /* 449 * We just provide a single LBA format that matches what the 450 * underlying device reports. 451 */ 452 id->nlbaf = 0; 453 id->flbas = 0; 454 455 /* 456 * Our namespace might always be shared. Not just with other 457 * controllers, but also with any other user of the block device. 458 */ 459 id->nmic = (1 << 0); 460 id->anagrpid = cpu_to_le32(ns->anagrpid); 461 462 memcpy(&id->nguid, &ns->nguid, sizeof(id->nguid)); 463 464 id->lbaf[0].ds = ns->blksize_shift; 465 466 if (ns->readonly) 467 id->nsattr |= (1 << 0); 468 nvmet_put_namespace(ns); 469 done: 470 status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id)); 471 kfree(id); 472 out: 473 nvmet_req_complete(req, status); 474 } 475 476 static void nvmet_execute_identify_nslist(struct nvmet_req *req) 477 { 478 static const int buf_size = NVME_IDENTIFY_DATA_SIZE; 479 struct nvmet_ctrl *ctrl = req->sq->ctrl; 480 struct nvmet_ns *ns; 481 u32 min_nsid = le32_to_cpu(req->cmd->identify.nsid); 482 __le32 *list; 483 u16 status = 0; 484 int i = 0; 485 486 list = kzalloc(buf_size, GFP_KERNEL); 487 if (!list) { 488 status = NVME_SC_INTERNAL; 489 goto out; 490 } 491 492 rcu_read_lock(); 493 list_for_each_entry_rcu(ns, &ctrl->subsys->namespaces, dev_link) { 494 if (ns->nsid <= min_nsid) 495 continue; 496 list[i++] = cpu_to_le32(ns->nsid); 497 if (i == buf_size / sizeof(__le32)) 498 break; 499 } 500 rcu_read_unlock(); 501 502 status = nvmet_copy_to_sgl(req, 0, list, buf_size); 503 504 kfree(list); 505 out: 506 nvmet_req_complete(req, status); 507 } 508 509 static u16 nvmet_copy_ns_identifier(struct nvmet_req *req, u8 type, u8 len, 510 void *id, off_t *off) 511 { 512 struct nvme_ns_id_desc desc = { 513 .nidt = type, 514 .nidl = len, 515 }; 516 u16 status; 517 518 status = nvmet_copy_to_sgl(req, *off, &desc, sizeof(desc)); 519 if (status) 520 return status; 521 *off += sizeof(desc); 522 523 status = nvmet_copy_to_sgl(req, *off, id, len); 524 if (status) 525 return status; 526 *off += len; 527 528 return 0; 529 } 530 531 static void nvmet_execute_identify_desclist(struct nvmet_req *req) 532 { 533 struct nvmet_ns *ns; 534 u16 status = 0; 535 off_t off = 0; 536 537 ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->identify.nsid); 538 if (!ns) { 539 req->error_loc = offsetof(struct nvme_identify, nsid); 540 status = NVME_SC_INVALID_NS | NVME_SC_DNR; 541 goto out; 542 } 543 544 if (memchr_inv(&ns->uuid, 0, sizeof(ns->uuid))) { 545 status = nvmet_copy_ns_identifier(req, NVME_NIDT_UUID, 546 NVME_NIDT_UUID_LEN, 547 &ns->uuid, &off); 548 if (status) 549 goto out_put_ns; 550 } 551 if (memchr_inv(ns->nguid, 0, sizeof(ns->nguid))) { 552 status = nvmet_copy_ns_identifier(req, NVME_NIDT_NGUID, 553 NVME_NIDT_NGUID_LEN, 554 &ns->nguid, &off); 555 if (status) 556 goto out_put_ns; 557 } 558 559 if (sg_zero_buffer(req->sg, req->sg_cnt, NVME_IDENTIFY_DATA_SIZE - off, 560 off) != NVME_IDENTIFY_DATA_SIZE - off) 561 status = NVME_SC_INTERNAL | NVME_SC_DNR; 562 out_put_ns: 563 nvmet_put_namespace(ns); 564 out: 565 nvmet_req_complete(req, status); 566 } 567 568 /* 569 * A "minimum viable" abort implementation: the command is mandatory in the 570 * spec, but we are not required to do any useful work. We couldn't really 571 * do a useful abort, so don't bother even with waiting for the command 572 * to be exectuted and return immediately telling the command to abort 573 * wasn't found. 574 */ 575 static void nvmet_execute_abort(struct nvmet_req *req) 576 { 577 nvmet_set_result(req, 1); 578 nvmet_req_complete(req, 0); 579 } 580 581 static u16 nvmet_write_protect_flush_sync(struct nvmet_req *req) 582 { 583 u16 status; 584 585 if (req->ns->file) 586 status = nvmet_file_flush(req); 587 else 588 status = nvmet_bdev_flush(req); 589 590 if (status) 591 pr_err("write protect flush failed nsid: %u\n", req->ns->nsid); 592 return status; 593 } 594 595 static u16 nvmet_set_feat_write_protect(struct nvmet_req *req) 596 { 597 u32 write_protect = le32_to_cpu(req->cmd->common.cdw11); 598 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 599 u16 status = NVME_SC_FEATURE_NOT_CHANGEABLE; 600 601 req->ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->rw.nsid); 602 if (unlikely(!req->ns)) { 603 req->error_loc = offsetof(struct nvme_common_command, nsid); 604 return status; 605 } 606 607 mutex_lock(&subsys->lock); 608 switch (write_protect) { 609 case NVME_NS_WRITE_PROTECT: 610 req->ns->readonly = true; 611 status = nvmet_write_protect_flush_sync(req); 612 if (status) 613 req->ns->readonly = false; 614 break; 615 case NVME_NS_NO_WRITE_PROTECT: 616 req->ns->readonly = false; 617 status = 0; 618 break; 619 default: 620 break; 621 } 622 623 if (!status) 624 nvmet_ns_changed(subsys, req->ns->nsid); 625 mutex_unlock(&subsys->lock); 626 return status; 627 } 628 629 u16 nvmet_set_feat_kato(struct nvmet_req *req) 630 { 631 u32 val32 = le32_to_cpu(req->cmd->common.cdw11); 632 633 req->sq->ctrl->kato = DIV_ROUND_UP(val32, 1000); 634 635 nvmet_set_result(req, req->sq->ctrl->kato); 636 637 return 0; 638 } 639 640 u16 nvmet_set_feat_async_event(struct nvmet_req *req, u32 mask) 641 { 642 u32 val32 = le32_to_cpu(req->cmd->common.cdw11); 643 644 if (val32 & ~mask) { 645 req->error_loc = offsetof(struct nvme_common_command, cdw11); 646 return NVME_SC_INVALID_FIELD | NVME_SC_DNR; 647 } 648 649 WRITE_ONCE(req->sq->ctrl->aen_enabled, val32); 650 nvmet_set_result(req, val32); 651 652 return 0; 653 } 654 655 static void nvmet_execute_set_features(struct nvmet_req *req) 656 { 657 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 658 u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10); 659 u16 status = 0; 660 661 switch (cdw10 & 0xff) { 662 case NVME_FEAT_NUM_QUEUES: 663 nvmet_set_result(req, 664 (subsys->max_qid - 1) | ((subsys->max_qid - 1) << 16)); 665 break; 666 case NVME_FEAT_KATO: 667 status = nvmet_set_feat_kato(req); 668 break; 669 case NVME_FEAT_ASYNC_EVENT: 670 status = nvmet_set_feat_async_event(req, NVMET_AEN_CFG_ALL); 671 break; 672 case NVME_FEAT_HOST_ID: 673 status = NVME_SC_CMD_SEQ_ERROR | NVME_SC_DNR; 674 break; 675 case NVME_FEAT_WRITE_PROTECT: 676 status = nvmet_set_feat_write_protect(req); 677 break; 678 default: 679 req->error_loc = offsetof(struct nvme_common_command, cdw10); 680 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 681 break; 682 } 683 684 nvmet_req_complete(req, status); 685 } 686 687 static u16 nvmet_get_feat_write_protect(struct nvmet_req *req) 688 { 689 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 690 u32 result; 691 692 req->ns = nvmet_find_namespace(req->sq->ctrl, req->cmd->common.nsid); 693 if (!req->ns) { 694 req->error_loc = offsetof(struct nvme_common_command, nsid); 695 return NVME_SC_INVALID_NS | NVME_SC_DNR; 696 } 697 mutex_lock(&subsys->lock); 698 if (req->ns->readonly == true) 699 result = NVME_NS_WRITE_PROTECT; 700 else 701 result = NVME_NS_NO_WRITE_PROTECT; 702 nvmet_set_result(req, result); 703 mutex_unlock(&subsys->lock); 704 705 return 0; 706 } 707 708 void nvmet_get_feat_kato(struct nvmet_req *req) 709 { 710 nvmet_set_result(req, req->sq->ctrl->kato * 1000); 711 } 712 713 void nvmet_get_feat_async_event(struct nvmet_req *req) 714 { 715 nvmet_set_result(req, READ_ONCE(req->sq->ctrl->aen_enabled)); 716 } 717 718 static void nvmet_execute_get_features(struct nvmet_req *req) 719 { 720 struct nvmet_subsys *subsys = req->sq->ctrl->subsys; 721 u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10); 722 u16 status = 0; 723 724 switch (cdw10 & 0xff) { 725 /* 726 * These features are mandatory in the spec, but we don't 727 * have a useful way to implement them. We'll eventually 728 * need to come up with some fake values for these. 729 */ 730 #if 0 731 case NVME_FEAT_ARBITRATION: 732 break; 733 case NVME_FEAT_POWER_MGMT: 734 break; 735 case NVME_FEAT_TEMP_THRESH: 736 break; 737 case NVME_FEAT_ERR_RECOVERY: 738 break; 739 case NVME_FEAT_IRQ_COALESCE: 740 break; 741 case NVME_FEAT_IRQ_CONFIG: 742 break; 743 case NVME_FEAT_WRITE_ATOMIC: 744 break; 745 #endif 746 case NVME_FEAT_ASYNC_EVENT: 747 nvmet_get_feat_async_event(req); 748 break; 749 case NVME_FEAT_VOLATILE_WC: 750 nvmet_set_result(req, 1); 751 break; 752 case NVME_FEAT_NUM_QUEUES: 753 nvmet_set_result(req, 754 (subsys->max_qid-1) | ((subsys->max_qid-1) << 16)); 755 break; 756 case NVME_FEAT_KATO: 757 nvmet_get_feat_kato(req); 758 break; 759 case NVME_FEAT_HOST_ID: 760 /* need 128-bit host identifier flag */ 761 if (!(req->cmd->common.cdw11 & cpu_to_le32(1 << 0))) { 762 req->error_loc = 763 offsetof(struct nvme_common_command, cdw11); 764 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 765 break; 766 } 767 768 status = nvmet_copy_to_sgl(req, 0, &req->sq->ctrl->hostid, 769 sizeof(req->sq->ctrl->hostid)); 770 break; 771 case NVME_FEAT_WRITE_PROTECT: 772 status = nvmet_get_feat_write_protect(req); 773 break; 774 default: 775 req->error_loc = 776 offsetof(struct nvme_common_command, cdw10); 777 status = NVME_SC_INVALID_FIELD | NVME_SC_DNR; 778 break; 779 } 780 781 nvmet_req_complete(req, status); 782 } 783 784 void nvmet_execute_async_event(struct nvmet_req *req) 785 { 786 struct nvmet_ctrl *ctrl = req->sq->ctrl; 787 788 mutex_lock(&ctrl->lock); 789 if (ctrl->nr_async_event_cmds >= NVMET_ASYNC_EVENTS) { 790 mutex_unlock(&ctrl->lock); 791 nvmet_req_complete(req, NVME_SC_ASYNC_LIMIT | NVME_SC_DNR); 792 return; 793 } 794 ctrl->async_event_cmds[ctrl->nr_async_event_cmds++] = req; 795 mutex_unlock(&ctrl->lock); 796 797 schedule_work(&ctrl->async_event_work); 798 } 799 800 void nvmet_execute_keep_alive(struct nvmet_req *req) 801 { 802 struct nvmet_ctrl *ctrl = req->sq->ctrl; 803 804 pr_debug("ctrl %d update keep-alive timer for %d secs\n", 805 ctrl->cntlid, ctrl->kato); 806 807 mod_delayed_work(system_wq, &ctrl->ka_work, ctrl->kato * HZ); 808 nvmet_req_complete(req, 0); 809 } 810 811 u16 nvmet_parse_admin_cmd(struct nvmet_req *req) 812 { 813 struct nvme_command *cmd = req->cmd; 814 u16 ret; 815 816 ret = nvmet_check_ctrl_status(req, cmd); 817 if (unlikely(ret)) 818 return ret; 819 820 switch (cmd->common.opcode) { 821 case nvme_admin_get_log_page: 822 req->data_len = nvmet_get_log_page_len(cmd); 823 824 switch (cmd->get_log_page.lid) { 825 case NVME_LOG_ERROR: 826 req->execute = nvmet_execute_get_log_page_error; 827 return 0; 828 case NVME_LOG_SMART: 829 req->execute = nvmet_execute_get_log_page_smart; 830 return 0; 831 case NVME_LOG_FW_SLOT: 832 /* 833 * We only support a single firmware slot which always 834 * is active, so we can zero out the whole firmware slot 835 * log and still claim to fully implement this mandatory 836 * log page. 837 */ 838 req->execute = nvmet_execute_get_log_page_noop; 839 return 0; 840 case NVME_LOG_CHANGED_NS: 841 req->execute = nvmet_execute_get_log_changed_ns; 842 return 0; 843 case NVME_LOG_CMD_EFFECTS: 844 req->execute = nvmet_execute_get_log_cmd_effects_ns; 845 return 0; 846 case NVME_LOG_ANA: 847 req->execute = nvmet_execute_get_log_page_ana; 848 return 0; 849 } 850 break; 851 case nvme_admin_identify: 852 req->data_len = NVME_IDENTIFY_DATA_SIZE; 853 switch (cmd->identify.cns) { 854 case NVME_ID_CNS_NS: 855 req->execute = nvmet_execute_identify_ns; 856 return 0; 857 case NVME_ID_CNS_CTRL: 858 req->execute = nvmet_execute_identify_ctrl; 859 return 0; 860 case NVME_ID_CNS_NS_ACTIVE_LIST: 861 req->execute = nvmet_execute_identify_nslist; 862 return 0; 863 case NVME_ID_CNS_NS_DESC_LIST: 864 req->execute = nvmet_execute_identify_desclist; 865 return 0; 866 } 867 break; 868 case nvme_admin_abort_cmd: 869 req->execute = nvmet_execute_abort; 870 req->data_len = 0; 871 return 0; 872 case nvme_admin_set_features: 873 req->execute = nvmet_execute_set_features; 874 req->data_len = 0; 875 return 0; 876 case nvme_admin_get_features: 877 req->execute = nvmet_execute_get_features; 878 req->data_len = 0; 879 return 0; 880 case nvme_admin_async_event: 881 req->execute = nvmet_execute_async_event; 882 req->data_len = 0; 883 return 0; 884 case nvme_admin_keep_alive: 885 req->execute = nvmet_execute_keep_alive; 886 req->data_len = 0; 887 return 0; 888 } 889 890 pr_err("unhandled cmd %d on qid %d\n", cmd->common.opcode, 891 req->sq->qid); 892 req->error_loc = offsetof(struct nvme_common_command, opcode); 893 return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; 894 } 895