1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Sysfs interface for the NVMe core driver. 4 * 5 * Copyright (c) 2011-2014, Intel Corporation. 6 */ 7 8 #include <linux/nvme-auth.h> 9 10 #include "nvme.h" 11 #include "fabrics.h" 12 13 static ssize_t nvme_sysfs_reset(struct device *dev, 14 struct device_attribute *attr, const char *buf, 15 size_t count) 16 { 17 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 18 int ret; 19 20 ret = nvme_reset_ctrl_sync(ctrl); 21 if (ret < 0) 22 return ret; 23 return count; 24 } 25 static DEVICE_ATTR(reset_controller, S_IWUSR, NULL, nvme_sysfs_reset); 26 27 static ssize_t nvme_sysfs_rescan(struct device *dev, 28 struct device_attribute *attr, const char *buf, 29 size_t count) 30 { 31 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 32 33 nvme_queue_scan(ctrl); 34 return count; 35 } 36 static DEVICE_ATTR(rescan_controller, S_IWUSR, NULL, nvme_sysfs_rescan); 37 38 static ssize_t nvme_adm_passthru_err_log_enabled_show(struct device *dev, 39 struct device_attribute *attr, char *buf) 40 { 41 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 42 43 return sysfs_emit(buf, 44 ctrl->passthru_err_log_enabled ? "on\n" : "off\n"); 45 } 46 47 static ssize_t nvme_adm_passthru_err_log_enabled_store(struct device *dev, 48 struct device_attribute *attr, const char *buf, size_t count) 49 { 50 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 51 bool passthru_err_log_enabled; 52 int err; 53 54 err = kstrtobool(buf, &passthru_err_log_enabled); 55 if (err) 56 return -EINVAL; 57 58 ctrl->passthru_err_log_enabled = passthru_err_log_enabled; 59 60 return count; 61 } 62 63 static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev) 64 { 65 struct gendisk *disk = dev_to_disk(dev); 66 67 if (nvme_disk_is_ns_head(disk)) 68 return disk->private_data; 69 return nvme_get_ns_from_dev(dev)->head; 70 } 71 72 static ssize_t nvme_io_passthru_err_log_enabled_show(struct device *dev, 73 struct device_attribute *attr, char *buf) 74 { 75 struct nvme_ns_head *head = dev_to_ns_head(dev); 76 77 return sysfs_emit(buf, head->passthru_err_log_enabled ? "on\n" : "off\n"); 78 } 79 80 static ssize_t nvme_io_passthru_err_log_enabled_store(struct device *dev, 81 struct device_attribute *attr, const char *buf, size_t count) 82 { 83 struct nvme_ns_head *head = dev_to_ns_head(dev); 84 bool passthru_err_log_enabled; 85 int err; 86 87 err = kstrtobool(buf, &passthru_err_log_enabled); 88 if (err) 89 return -EINVAL; 90 head->passthru_err_log_enabled = passthru_err_log_enabled; 91 92 return count; 93 } 94 95 static struct device_attribute dev_attr_adm_passthru_err_log_enabled = \ 96 __ATTR(passthru_err_log_enabled, S_IRUGO | S_IWUSR, \ 97 nvme_adm_passthru_err_log_enabled_show, nvme_adm_passthru_err_log_enabled_store); 98 99 static struct device_attribute dev_attr_io_passthru_err_log_enabled = \ 100 __ATTR(passthru_err_log_enabled, S_IRUGO | S_IWUSR, \ 101 nvme_io_passthru_err_log_enabled_show, nvme_io_passthru_err_log_enabled_store); 102 103 static ssize_t wwid_show(struct device *dev, struct device_attribute *attr, 104 char *buf) 105 { 106 struct nvme_ns_head *head = dev_to_ns_head(dev); 107 struct nvme_ns_ids *ids = &head->ids; 108 struct nvme_subsystem *subsys = head->subsys; 109 int serial_len = sizeof(subsys->serial); 110 int model_len = sizeof(subsys->model); 111 112 if (!uuid_is_null(&ids->uuid)) 113 return sysfs_emit(buf, "uuid.%pU\n", &ids->uuid); 114 115 if (memchr_inv(ids->nguid, 0, sizeof(ids->nguid))) 116 return sysfs_emit(buf, "eui.%16phN\n", ids->nguid); 117 118 if (memchr_inv(ids->eui64, 0, sizeof(ids->eui64))) 119 return sysfs_emit(buf, "eui.%8phN\n", ids->eui64); 120 121 while (serial_len > 0 && (subsys->serial[serial_len - 1] == ' ' || 122 subsys->serial[serial_len - 1] == '\0')) 123 serial_len--; 124 while (model_len > 0 && (subsys->model[model_len - 1] == ' ' || 125 subsys->model[model_len - 1] == '\0')) 126 model_len--; 127 128 return sysfs_emit(buf, "nvme.%04x-%*phN-%*phN-%08x\n", subsys->vendor_id, 129 serial_len, subsys->serial, model_len, subsys->model, 130 head->ns_id); 131 } 132 static DEVICE_ATTR_RO(wwid); 133 134 static ssize_t nguid_show(struct device *dev, struct device_attribute *attr, 135 char *buf) 136 { 137 return sysfs_emit(buf, "%pU\n", dev_to_ns_head(dev)->ids.nguid); 138 } 139 static DEVICE_ATTR_RO(nguid); 140 141 static ssize_t uuid_show(struct device *dev, struct device_attribute *attr, 142 char *buf) 143 { 144 struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids; 145 146 /* For backward compatibility expose the NGUID to userspace if 147 * we have no UUID set 148 */ 149 if (uuid_is_null(&ids->uuid)) { 150 dev_warn_once(dev, 151 "No UUID available providing old NGUID\n"); 152 return sysfs_emit(buf, "%pU\n", ids->nguid); 153 } 154 return sysfs_emit(buf, "%pU\n", &ids->uuid); 155 } 156 static DEVICE_ATTR_RO(uuid); 157 158 static ssize_t eui_show(struct device *dev, struct device_attribute *attr, 159 char *buf) 160 { 161 return sysfs_emit(buf, "%8ph\n", dev_to_ns_head(dev)->ids.eui64); 162 } 163 static DEVICE_ATTR_RO(eui); 164 165 static ssize_t nsid_show(struct device *dev, struct device_attribute *attr, 166 char *buf) 167 { 168 return sysfs_emit(buf, "%d\n", dev_to_ns_head(dev)->ns_id); 169 } 170 static DEVICE_ATTR_RO(nsid); 171 172 static ssize_t csi_show(struct device *dev, struct device_attribute *attr, 173 char *buf) 174 { 175 return sysfs_emit(buf, "%u\n", dev_to_ns_head(dev)->ids.csi); 176 } 177 static DEVICE_ATTR_RO(csi); 178 179 static ssize_t metadata_bytes_show(struct device *dev, 180 struct device_attribute *attr, char *buf) 181 { 182 return sysfs_emit(buf, "%u\n", dev_to_ns_head(dev)->ms); 183 } 184 static DEVICE_ATTR_RO(metadata_bytes); 185 186 static int ns_head_update_nuse(struct nvme_ns_head *head) 187 { 188 struct nvme_id_ns *id; 189 struct nvme_ns *ns; 190 int srcu_idx, ret = -EWOULDBLOCK; 191 192 /* Avoid issuing commands too often by rate limiting the update */ 193 if (!__ratelimit(&head->rs_nuse)) 194 return 0; 195 196 srcu_idx = srcu_read_lock(&head->srcu); 197 ns = nvme_find_path(head); 198 if (!ns) 199 goto out_unlock; 200 201 ret = nvme_identify_ns(ns->ctrl, head->ns_id, &id); 202 if (ret) 203 goto out_unlock; 204 205 head->nuse = le64_to_cpu(id->nuse); 206 kfree(id); 207 208 out_unlock: 209 srcu_read_unlock(&head->srcu, srcu_idx); 210 return ret; 211 } 212 213 static int ns_update_nuse(struct nvme_ns *ns) 214 { 215 struct nvme_id_ns *id; 216 int ret; 217 218 /* Avoid issuing commands too often by rate limiting the update. */ 219 if (!__ratelimit(&ns->head->rs_nuse)) 220 return 0; 221 222 ret = nvme_identify_ns(ns->ctrl, ns->head->ns_id, &id); 223 if (ret) 224 return ret; 225 226 ns->head->nuse = le64_to_cpu(id->nuse); 227 kfree(id); 228 return 0; 229 } 230 231 static ssize_t nuse_show(struct device *dev, struct device_attribute *attr, 232 char *buf) 233 { 234 struct nvme_ns_head *head = dev_to_ns_head(dev); 235 struct gendisk *disk = dev_to_disk(dev); 236 int ret; 237 238 if (nvme_disk_is_ns_head(disk)) 239 ret = ns_head_update_nuse(head); 240 else 241 ret = ns_update_nuse(disk->private_data); 242 if (ret) 243 return ret; 244 245 return sysfs_emit(buf, "%llu\n", head->nuse); 246 } 247 static DEVICE_ATTR_RO(nuse); 248 249 static struct attribute *nvme_ns_attrs[] = { 250 &dev_attr_wwid.attr, 251 &dev_attr_uuid.attr, 252 &dev_attr_nguid.attr, 253 &dev_attr_eui.attr, 254 &dev_attr_csi.attr, 255 &dev_attr_nsid.attr, 256 &dev_attr_metadata_bytes.attr, 257 &dev_attr_nuse.attr, 258 #ifdef CONFIG_NVME_MULTIPATH 259 &dev_attr_ana_grpid.attr, 260 &dev_attr_ana_state.attr, 261 #endif 262 &dev_attr_io_passthru_err_log_enabled.attr, 263 NULL, 264 }; 265 266 static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj, 267 struct attribute *a, int n) 268 { 269 struct device *dev = container_of(kobj, struct device, kobj); 270 struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids; 271 272 if (a == &dev_attr_uuid.attr) { 273 if (uuid_is_null(&ids->uuid) && 274 !memchr_inv(ids->nguid, 0, sizeof(ids->nguid))) 275 return 0; 276 } 277 if (a == &dev_attr_nguid.attr) { 278 if (!memchr_inv(ids->nguid, 0, sizeof(ids->nguid))) 279 return 0; 280 } 281 if (a == &dev_attr_eui.attr) { 282 if (!memchr_inv(ids->eui64, 0, sizeof(ids->eui64))) 283 return 0; 284 } 285 #ifdef CONFIG_NVME_MULTIPATH 286 if (a == &dev_attr_ana_grpid.attr || a == &dev_attr_ana_state.attr) { 287 /* per-path attr */ 288 if (nvme_disk_is_ns_head(dev_to_disk(dev))) 289 return 0; 290 if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl)) 291 return 0; 292 } 293 #endif 294 return a->mode; 295 } 296 297 static const struct attribute_group nvme_ns_attr_group = { 298 .attrs = nvme_ns_attrs, 299 .is_visible = nvme_ns_attrs_are_visible, 300 }; 301 302 const struct attribute_group *nvme_ns_attr_groups[] = { 303 &nvme_ns_attr_group, 304 NULL, 305 }; 306 307 #define nvme_show_str_function(field) \ 308 static ssize_t field##_show(struct device *dev, \ 309 struct device_attribute *attr, char *buf) \ 310 { \ 311 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \ 312 return sysfs_emit(buf, "%.*s\n", \ 313 (int)sizeof(ctrl->subsys->field), ctrl->subsys->field); \ 314 } \ 315 static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL); 316 317 nvme_show_str_function(model); 318 nvme_show_str_function(serial); 319 nvme_show_str_function(firmware_rev); 320 321 #define nvme_show_int_function(field) \ 322 static ssize_t field##_show(struct device *dev, \ 323 struct device_attribute *attr, char *buf) \ 324 { \ 325 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \ 326 return sysfs_emit(buf, "%d\n", ctrl->field); \ 327 } \ 328 static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL); 329 330 nvme_show_int_function(cntlid); 331 nvme_show_int_function(numa_node); 332 nvme_show_int_function(queue_count); 333 nvme_show_int_function(sqsize); 334 nvme_show_int_function(kato); 335 336 static ssize_t nvme_sysfs_delete(struct device *dev, 337 struct device_attribute *attr, const char *buf, 338 size_t count) 339 { 340 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 341 342 if (!test_bit(NVME_CTRL_STARTED_ONCE, &ctrl->flags)) 343 return -EBUSY; 344 345 if (device_remove_file_self(dev, attr)) 346 nvme_delete_ctrl_sync(ctrl); 347 return count; 348 } 349 static DEVICE_ATTR(delete_controller, S_IWUSR, NULL, nvme_sysfs_delete); 350 351 static ssize_t nvme_sysfs_show_transport(struct device *dev, 352 struct device_attribute *attr, 353 char *buf) 354 { 355 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 356 357 return sysfs_emit(buf, "%s\n", ctrl->ops->name); 358 } 359 static DEVICE_ATTR(transport, S_IRUGO, nvme_sysfs_show_transport, NULL); 360 361 static ssize_t nvme_sysfs_show_state(struct device *dev, 362 struct device_attribute *attr, 363 char *buf) 364 { 365 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 366 unsigned state = (unsigned)nvme_ctrl_state(ctrl); 367 static const char *const state_name[] = { 368 [NVME_CTRL_NEW] = "new", 369 [NVME_CTRL_LIVE] = "live", 370 [NVME_CTRL_RESETTING] = "resetting", 371 [NVME_CTRL_CONNECTING] = "connecting", 372 [NVME_CTRL_DELETING] = "deleting", 373 [NVME_CTRL_DELETING_NOIO]= "deleting (no IO)", 374 [NVME_CTRL_DEAD] = "dead", 375 }; 376 377 if (state < ARRAY_SIZE(state_name) && state_name[state]) 378 return sysfs_emit(buf, "%s\n", state_name[state]); 379 380 return sysfs_emit(buf, "unknown state\n"); 381 } 382 383 static DEVICE_ATTR(state, S_IRUGO, nvme_sysfs_show_state, NULL); 384 385 static ssize_t nvme_sysfs_show_subsysnqn(struct device *dev, 386 struct device_attribute *attr, 387 char *buf) 388 { 389 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 390 391 return sysfs_emit(buf, "%s\n", ctrl->subsys->subnqn); 392 } 393 static DEVICE_ATTR(subsysnqn, S_IRUGO, nvme_sysfs_show_subsysnqn, NULL); 394 395 static ssize_t nvme_sysfs_show_hostnqn(struct device *dev, 396 struct device_attribute *attr, 397 char *buf) 398 { 399 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 400 401 return sysfs_emit(buf, "%s\n", ctrl->opts->host->nqn); 402 } 403 static DEVICE_ATTR(hostnqn, S_IRUGO, nvme_sysfs_show_hostnqn, NULL); 404 405 static ssize_t nvme_sysfs_show_hostid(struct device *dev, 406 struct device_attribute *attr, 407 char *buf) 408 { 409 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 410 411 return sysfs_emit(buf, "%pU\n", &ctrl->opts->host->id); 412 } 413 static DEVICE_ATTR(hostid, S_IRUGO, nvme_sysfs_show_hostid, NULL); 414 415 static ssize_t nvme_sysfs_show_address(struct device *dev, 416 struct device_attribute *attr, 417 char *buf) 418 { 419 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 420 421 return ctrl->ops->get_address(ctrl, buf, PAGE_SIZE); 422 } 423 static DEVICE_ATTR(address, S_IRUGO, nvme_sysfs_show_address, NULL); 424 425 static ssize_t nvme_ctrl_loss_tmo_show(struct device *dev, 426 struct device_attribute *attr, char *buf) 427 { 428 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 429 struct nvmf_ctrl_options *opts = ctrl->opts; 430 431 if (ctrl->opts->max_reconnects == -1) 432 return sysfs_emit(buf, "off\n"); 433 return sysfs_emit(buf, "%d\n", 434 opts->max_reconnects * opts->reconnect_delay); 435 } 436 437 static ssize_t nvme_ctrl_loss_tmo_store(struct device *dev, 438 struct device_attribute *attr, const char *buf, size_t count) 439 { 440 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 441 struct nvmf_ctrl_options *opts = ctrl->opts; 442 int ctrl_loss_tmo, err; 443 444 err = kstrtoint(buf, 10, &ctrl_loss_tmo); 445 if (err) 446 return -EINVAL; 447 448 if (ctrl_loss_tmo < 0) 449 opts->max_reconnects = -1; 450 else 451 opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo, 452 opts->reconnect_delay); 453 return count; 454 } 455 static DEVICE_ATTR(ctrl_loss_tmo, S_IRUGO | S_IWUSR, 456 nvme_ctrl_loss_tmo_show, nvme_ctrl_loss_tmo_store); 457 458 static ssize_t nvme_ctrl_reconnect_delay_show(struct device *dev, 459 struct device_attribute *attr, char *buf) 460 { 461 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 462 463 if (ctrl->opts->reconnect_delay == -1) 464 return sysfs_emit(buf, "off\n"); 465 return sysfs_emit(buf, "%d\n", ctrl->opts->reconnect_delay); 466 } 467 468 static ssize_t nvme_ctrl_reconnect_delay_store(struct device *dev, 469 struct device_attribute *attr, const char *buf, size_t count) 470 { 471 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 472 unsigned int v; 473 int err; 474 475 err = kstrtou32(buf, 10, &v); 476 if (err) 477 return err; 478 479 ctrl->opts->reconnect_delay = v; 480 return count; 481 } 482 static DEVICE_ATTR(reconnect_delay, S_IRUGO | S_IWUSR, 483 nvme_ctrl_reconnect_delay_show, nvme_ctrl_reconnect_delay_store); 484 485 static ssize_t nvme_ctrl_fast_io_fail_tmo_show(struct device *dev, 486 struct device_attribute *attr, char *buf) 487 { 488 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 489 490 if (ctrl->opts->fast_io_fail_tmo == -1) 491 return sysfs_emit(buf, "off\n"); 492 return sysfs_emit(buf, "%d\n", ctrl->opts->fast_io_fail_tmo); 493 } 494 495 static ssize_t nvme_ctrl_fast_io_fail_tmo_store(struct device *dev, 496 struct device_attribute *attr, const char *buf, size_t count) 497 { 498 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 499 struct nvmf_ctrl_options *opts = ctrl->opts; 500 int fast_io_fail_tmo, err; 501 502 err = kstrtoint(buf, 10, &fast_io_fail_tmo); 503 if (err) 504 return -EINVAL; 505 506 if (fast_io_fail_tmo < 0) 507 opts->fast_io_fail_tmo = -1; 508 else 509 opts->fast_io_fail_tmo = fast_io_fail_tmo; 510 return count; 511 } 512 static DEVICE_ATTR(fast_io_fail_tmo, S_IRUGO | S_IWUSR, 513 nvme_ctrl_fast_io_fail_tmo_show, nvme_ctrl_fast_io_fail_tmo_store); 514 515 static ssize_t cntrltype_show(struct device *dev, 516 struct device_attribute *attr, char *buf) 517 { 518 static const char * const type[] = { 519 [NVME_CTRL_IO] = "io\n", 520 [NVME_CTRL_DISC] = "discovery\n", 521 [NVME_CTRL_ADMIN] = "admin\n", 522 }; 523 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 524 525 if (ctrl->cntrltype > NVME_CTRL_ADMIN || !type[ctrl->cntrltype]) 526 return sysfs_emit(buf, "reserved\n"); 527 528 return sysfs_emit(buf, type[ctrl->cntrltype]); 529 } 530 static DEVICE_ATTR_RO(cntrltype); 531 532 static ssize_t dctype_show(struct device *dev, 533 struct device_attribute *attr, char *buf) 534 { 535 static const char * const type[] = { 536 [NVME_DCTYPE_NOT_REPORTED] = "none\n", 537 [NVME_DCTYPE_DDC] = "ddc\n", 538 [NVME_DCTYPE_CDC] = "cdc\n", 539 }; 540 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 541 542 if (ctrl->dctype > NVME_DCTYPE_CDC || !type[ctrl->dctype]) 543 return sysfs_emit(buf, "reserved\n"); 544 545 return sysfs_emit(buf, type[ctrl->dctype]); 546 } 547 static DEVICE_ATTR_RO(dctype); 548 549 #ifdef CONFIG_NVME_HOST_AUTH 550 static ssize_t nvme_ctrl_dhchap_secret_show(struct device *dev, 551 struct device_attribute *attr, char *buf) 552 { 553 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 554 struct nvmf_ctrl_options *opts = ctrl->opts; 555 556 if (!opts->dhchap_secret) 557 return sysfs_emit(buf, "none\n"); 558 return sysfs_emit(buf, "%s\n", opts->dhchap_secret); 559 } 560 561 static ssize_t nvme_ctrl_dhchap_secret_store(struct device *dev, 562 struct device_attribute *attr, const char *buf, size_t count) 563 { 564 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 565 struct nvmf_ctrl_options *opts = ctrl->opts; 566 char *dhchap_secret; 567 568 if (!ctrl->opts->dhchap_secret) 569 return -EINVAL; 570 if (count < 7) 571 return -EINVAL; 572 if (memcmp(buf, "DHHC-1:", 7)) 573 return -EINVAL; 574 575 dhchap_secret = kzalloc(count + 1, GFP_KERNEL); 576 if (!dhchap_secret) 577 return -ENOMEM; 578 memcpy(dhchap_secret, buf, count); 579 nvme_auth_stop(ctrl); 580 if (strcmp(dhchap_secret, opts->dhchap_secret)) { 581 struct nvme_dhchap_key *key, *host_key; 582 int ret; 583 584 ret = nvme_auth_generate_key(dhchap_secret, &key); 585 if (ret) { 586 kfree(dhchap_secret); 587 return ret; 588 } 589 kfree(opts->dhchap_secret); 590 opts->dhchap_secret = dhchap_secret; 591 host_key = ctrl->host_key; 592 mutex_lock(&ctrl->dhchap_auth_mutex); 593 ctrl->host_key = key; 594 mutex_unlock(&ctrl->dhchap_auth_mutex); 595 nvme_auth_free_key(host_key); 596 } else 597 kfree(dhchap_secret); 598 /* Start re-authentication */ 599 dev_info(ctrl->device, "re-authenticating controller\n"); 600 queue_work(nvme_wq, &ctrl->dhchap_auth_work); 601 602 return count; 603 } 604 605 static DEVICE_ATTR(dhchap_secret, S_IRUGO | S_IWUSR, 606 nvme_ctrl_dhchap_secret_show, nvme_ctrl_dhchap_secret_store); 607 608 static ssize_t nvme_ctrl_dhchap_ctrl_secret_show(struct device *dev, 609 struct device_attribute *attr, char *buf) 610 { 611 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 612 struct nvmf_ctrl_options *opts = ctrl->opts; 613 614 if (!opts->dhchap_ctrl_secret) 615 return sysfs_emit(buf, "none\n"); 616 return sysfs_emit(buf, "%s\n", opts->dhchap_ctrl_secret); 617 } 618 619 static ssize_t nvme_ctrl_dhchap_ctrl_secret_store(struct device *dev, 620 struct device_attribute *attr, const char *buf, size_t count) 621 { 622 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 623 struct nvmf_ctrl_options *opts = ctrl->opts; 624 char *dhchap_secret; 625 626 if (!ctrl->opts->dhchap_ctrl_secret) 627 return -EINVAL; 628 if (count < 7) 629 return -EINVAL; 630 if (memcmp(buf, "DHHC-1:", 7)) 631 return -EINVAL; 632 633 dhchap_secret = kzalloc(count + 1, GFP_KERNEL); 634 if (!dhchap_secret) 635 return -ENOMEM; 636 memcpy(dhchap_secret, buf, count); 637 nvme_auth_stop(ctrl); 638 if (strcmp(dhchap_secret, opts->dhchap_ctrl_secret)) { 639 struct nvme_dhchap_key *key, *ctrl_key; 640 int ret; 641 642 ret = nvme_auth_generate_key(dhchap_secret, &key); 643 if (ret) { 644 kfree(dhchap_secret); 645 return ret; 646 } 647 kfree(opts->dhchap_ctrl_secret); 648 opts->dhchap_ctrl_secret = dhchap_secret; 649 ctrl_key = ctrl->ctrl_key; 650 mutex_lock(&ctrl->dhchap_auth_mutex); 651 ctrl->ctrl_key = key; 652 mutex_unlock(&ctrl->dhchap_auth_mutex); 653 nvme_auth_free_key(ctrl_key); 654 } else 655 kfree(dhchap_secret); 656 /* Start re-authentication */ 657 dev_info(ctrl->device, "re-authenticating controller\n"); 658 queue_work(nvme_wq, &ctrl->dhchap_auth_work); 659 660 return count; 661 } 662 663 static DEVICE_ATTR(dhchap_ctrl_secret, S_IRUGO | S_IWUSR, 664 nvme_ctrl_dhchap_ctrl_secret_show, nvme_ctrl_dhchap_ctrl_secret_store); 665 #endif 666 667 static struct attribute *nvme_dev_attrs[] = { 668 &dev_attr_reset_controller.attr, 669 &dev_attr_rescan_controller.attr, 670 &dev_attr_model.attr, 671 &dev_attr_serial.attr, 672 &dev_attr_firmware_rev.attr, 673 &dev_attr_cntlid.attr, 674 &dev_attr_delete_controller.attr, 675 &dev_attr_transport.attr, 676 &dev_attr_subsysnqn.attr, 677 &dev_attr_address.attr, 678 &dev_attr_state.attr, 679 &dev_attr_numa_node.attr, 680 &dev_attr_queue_count.attr, 681 &dev_attr_sqsize.attr, 682 &dev_attr_hostnqn.attr, 683 &dev_attr_hostid.attr, 684 &dev_attr_ctrl_loss_tmo.attr, 685 &dev_attr_reconnect_delay.attr, 686 &dev_attr_fast_io_fail_tmo.attr, 687 &dev_attr_kato.attr, 688 &dev_attr_cntrltype.attr, 689 &dev_attr_dctype.attr, 690 #ifdef CONFIG_NVME_HOST_AUTH 691 &dev_attr_dhchap_secret.attr, 692 &dev_attr_dhchap_ctrl_secret.attr, 693 #endif 694 &dev_attr_adm_passthru_err_log_enabled.attr, 695 NULL 696 }; 697 698 static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj, 699 struct attribute *a, int n) 700 { 701 struct device *dev = container_of(kobj, struct device, kobj); 702 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 703 704 if (a == &dev_attr_delete_controller.attr && !ctrl->ops->delete_ctrl) 705 return 0; 706 if (a == &dev_attr_address.attr && !ctrl->ops->get_address) 707 return 0; 708 if (a == &dev_attr_hostnqn.attr && !ctrl->opts) 709 return 0; 710 if (a == &dev_attr_hostid.attr && !ctrl->opts) 711 return 0; 712 if (a == &dev_attr_ctrl_loss_tmo.attr && !ctrl->opts) 713 return 0; 714 if (a == &dev_attr_reconnect_delay.attr && !ctrl->opts) 715 return 0; 716 if (a == &dev_attr_fast_io_fail_tmo.attr && !ctrl->opts) 717 return 0; 718 #ifdef CONFIG_NVME_HOST_AUTH 719 if (a == &dev_attr_dhchap_secret.attr && !ctrl->opts) 720 return 0; 721 if (a == &dev_attr_dhchap_ctrl_secret.attr && !ctrl->opts) 722 return 0; 723 #endif 724 725 return a->mode; 726 } 727 728 const struct attribute_group nvme_dev_attrs_group = { 729 .attrs = nvme_dev_attrs, 730 .is_visible = nvme_dev_attrs_are_visible, 731 }; 732 EXPORT_SYMBOL_GPL(nvme_dev_attrs_group); 733 734 #ifdef CONFIG_NVME_TCP_TLS 735 static ssize_t tls_key_show(struct device *dev, 736 struct device_attribute *attr, char *buf) 737 { 738 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 739 740 if (!ctrl->tls_pskid) 741 return 0; 742 return sysfs_emit(buf, "%08x\n", ctrl->tls_pskid); 743 } 744 static DEVICE_ATTR_RO(tls_key); 745 746 static ssize_t tls_configured_key_show(struct device *dev, 747 struct device_attribute *attr, char *buf) 748 { 749 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 750 struct key *key = ctrl->opts->tls_key; 751 752 return sysfs_emit(buf, "%08x\n", key_serial(key)); 753 } 754 static DEVICE_ATTR_RO(tls_configured_key); 755 756 static ssize_t tls_keyring_show(struct device *dev, 757 struct device_attribute *attr, char *buf) 758 { 759 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 760 struct key *keyring = ctrl->opts->keyring; 761 762 return sysfs_emit(buf, "%s\n", keyring->description); 763 } 764 static DEVICE_ATTR_RO(tls_keyring); 765 766 static struct attribute *nvme_tls_attrs[] = { 767 &dev_attr_tls_key.attr, 768 &dev_attr_tls_configured_key.attr, 769 &dev_attr_tls_keyring.attr, 770 NULL, 771 }; 772 773 static umode_t nvme_tls_attrs_are_visible(struct kobject *kobj, 774 struct attribute *a, int n) 775 { 776 struct device *dev = container_of(kobj, struct device, kobj); 777 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 778 779 if (!ctrl->opts || strcmp(ctrl->opts->transport, "tcp")) 780 return 0; 781 782 if (a == &dev_attr_tls_key.attr && 783 !ctrl->opts->tls) 784 return 0; 785 if (a == &dev_attr_tls_configured_key.attr && 786 !ctrl->opts->tls_key) 787 return 0; 788 if (a == &dev_attr_tls_keyring.attr && 789 !ctrl->opts->keyring) 790 return 0; 791 792 return a->mode; 793 } 794 795 const struct attribute_group nvme_tls_attrs_group = { 796 .attrs = nvme_tls_attrs, 797 .is_visible = nvme_tls_attrs_are_visible, 798 }; 799 #endif 800 801 const struct attribute_group *nvme_dev_attr_groups[] = { 802 &nvme_dev_attrs_group, 803 #ifdef CONFIG_NVME_TCP_TLS 804 &nvme_tls_attrs_group, 805 #endif 806 NULL, 807 }; 808 809 #define SUBSYS_ATTR_RO(_name, _mode, _show) \ 810 struct device_attribute subsys_attr_##_name = \ 811 __ATTR(_name, _mode, _show, NULL) 812 813 static ssize_t nvme_subsys_show_nqn(struct device *dev, 814 struct device_attribute *attr, 815 char *buf) 816 { 817 struct nvme_subsystem *subsys = 818 container_of(dev, struct nvme_subsystem, dev); 819 820 return sysfs_emit(buf, "%s\n", subsys->subnqn); 821 } 822 static SUBSYS_ATTR_RO(subsysnqn, S_IRUGO, nvme_subsys_show_nqn); 823 824 static ssize_t nvme_subsys_show_type(struct device *dev, 825 struct device_attribute *attr, 826 char *buf) 827 { 828 struct nvme_subsystem *subsys = 829 container_of(dev, struct nvme_subsystem, dev); 830 831 switch (subsys->subtype) { 832 case NVME_NQN_DISC: 833 return sysfs_emit(buf, "discovery\n"); 834 case NVME_NQN_NVME: 835 return sysfs_emit(buf, "nvm\n"); 836 default: 837 return sysfs_emit(buf, "reserved\n"); 838 } 839 } 840 static SUBSYS_ATTR_RO(subsystype, S_IRUGO, nvme_subsys_show_type); 841 842 #define nvme_subsys_show_str_function(field) \ 843 static ssize_t subsys_##field##_show(struct device *dev, \ 844 struct device_attribute *attr, char *buf) \ 845 { \ 846 struct nvme_subsystem *subsys = \ 847 container_of(dev, struct nvme_subsystem, dev); \ 848 return sysfs_emit(buf, "%.*s\n", \ 849 (int)sizeof(subsys->field), subsys->field); \ 850 } \ 851 static SUBSYS_ATTR_RO(field, S_IRUGO, subsys_##field##_show); 852 853 nvme_subsys_show_str_function(model); 854 nvme_subsys_show_str_function(serial); 855 nvme_subsys_show_str_function(firmware_rev); 856 857 static struct attribute *nvme_subsys_attrs[] = { 858 &subsys_attr_model.attr, 859 &subsys_attr_serial.attr, 860 &subsys_attr_firmware_rev.attr, 861 &subsys_attr_subsysnqn.attr, 862 &subsys_attr_subsystype.attr, 863 #ifdef CONFIG_NVME_MULTIPATH 864 &subsys_attr_iopolicy.attr, 865 #endif 866 NULL, 867 }; 868 869 static const struct attribute_group nvme_subsys_attrs_group = { 870 .attrs = nvme_subsys_attrs, 871 }; 872 873 const struct attribute_group *nvme_subsys_attrs_groups[] = { 874 &nvme_subsys_attrs_group, 875 NULL, 876 }; 877