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 struct block_device *bdev = disk->part0; 237 int ret; 238 239 if (IS_ENABLED(CONFIG_NVME_MULTIPATH) && 240 bdev->bd_disk->fops == &nvme_ns_head_ops) 241 ret = ns_head_update_nuse(head); 242 else 243 ret = ns_update_nuse(bdev->bd_disk->private_data); 244 if (ret) 245 return ret; 246 247 return sysfs_emit(buf, "%llu\n", head->nuse); 248 } 249 static DEVICE_ATTR_RO(nuse); 250 251 static struct attribute *nvme_ns_attrs[] = { 252 &dev_attr_wwid.attr, 253 &dev_attr_uuid.attr, 254 &dev_attr_nguid.attr, 255 &dev_attr_eui.attr, 256 &dev_attr_csi.attr, 257 &dev_attr_nsid.attr, 258 &dev_attr_metadata_bytes.attr, 259 &dev_attr_nuse.attr, 260 #ifdef CONFIG_NVME_MULTIPATH 261 &dev_attr_ana_grpid.attr, 262 &dev_attr_ana_state.attr, 263 #endif 264 &dev_attr_io_passthru_err_log_enabled.attr, 265 NULL, 266 }; 267 268 static umode_t nvme_ns_attrs_are_visible(struct kobject *kobj, 269 struct attribute *a, int n) 270 { 271 struct device *dev = container_of(kobj, struct device, kobj); 272 struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids; 273 274 if (a == &dev_attr_uuid.attr) { 275 if (uuid_is_null(&ids->uuid) && 276 !memchr_inv(ids->nguid, 0, sizeof(ids->nguid))) 277 return 0; 278 } 279 if (a == &dev_attr_nguid.attr) { 280 if (!memchr_inv(ids->nguid, 0, sizeof(ids->nguid))) 281 return 0; 282 } 283 if (a == &dev_attr_eui.attr) { 284 if (!memchr_inv(ids->eui64, 0, sizeof(ids->eui64))) 285 return 0; 286 } 287 #ifdef CONFIG_NVME_MULTIPATH 288 if (a == &dev_attr_ana_grpid.attr || a == &dev_attr_ana_state.attr) { 289 /* per-path attr */ 290 if (nvme_disk_is_ns_head(dev_to_disk(dev))) 291 return 0; 292 if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl)) 293 return 0; 294 } 295 #endif 296 return a->mode; 297 } 298 299 static const struct attribute_group nvme_ns_attr_group = { 300 .attrs = nvme_ns_attrs, 301 .is_visible = nvme_ns_attrs_are_visible, 302 }; 303 304 const struct attribute_group *nvme_ns_attr_groups[] = { 305 &nvme_ns_attr_group, 306 NULL, 307 }; 308 309 #define nvme_show_str_function(field) \ 310 static ssize_t field##_show(struct device *dev, \ 311 struct device_attribute *attr, char *buf) \ 312 { \ 313 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \ 314 return sysfs_emit(buf, "%.*s\n", \ 315 (int)sizeof(ctrl->subsys->field), ctrl->subsys->field); \ 316 } \ 317 static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL); 318 319 nvme_show_str_function(model); 320 nvme_show_str_function(serial); 321 nvme_show_str_function(firmware_rev); 322 323 #define nvme_show_int_function(field) \ 324 static ssize_t field##_show(struct device *dev, \ 325 struct device_attribute *attr, char *buf) \ 326 { \ 327 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \ 328 return sysfs_emit(buf, "%d\n", ctrl->field); \ 329 } \ 330 static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL); 331 332 nvme_show_int_function(cntlid); 333 nvme_show_int_function(numa_node); 334 nvme_show_int_function(queue_count); 335 nvme_show_int_function(sqsize); 336 nvme_show_int_function(kato); 337 338 static ssize_t nvme_sysfs_delete(struct device *dev, 339 struct device_attribute *attr, const char *buf, 340 size_t count) 341 { 342 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 343 344 if (!test_bit(NVME_CTRL_STARTED_ONCE, &ctrl->flags)) 345 return -EBUSY; 346 347 if (device_remove_file_self(dev, attr)) 348 nvme_delete_ctrl_sync(ctrl); 349 return count; 350 } 351 static DEVICE_ATTR(delete_controller, S_IWUSR, NULL, nvme_sysfs_delete); 352 353 static ssize_t nvme_sysfs_show_transport(struct device *dev, 354 struct device_attribute *attr, 355 char *buf) 356 { 357 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 358 359 return sysfs_emit(buf, "%s\n", ctrl->ops->name); 360 } 361 static DEVICE_ATTR(transport, S_IRUGO, nvme_sysfs_show_transport, NULL); 362 363 static ssize_t nvme_sysfs_show_state(struct device *dev, 364 struct device_attribute *attr, 365 char *buf) 366 { 367 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 368 unsigned state = (unsigned)nvme_ctrl_state(ctrl); 369 static const char *const state_name[] = { 370 [NVME_CTRL_NEW] = "new", 371 [NVME_CTRL_LIVE] = "live", 372 [NVME_CTRL_RESETTING] = "resetting", 373 [NVME_CTRL_CONNECTING] = "connecting", 374 [NVME_CTRL_DELETING] = "deleting", 375 [NVME_CTRL_DELETING_NOIO]= "deleting (no IO)", 376 [NVME_CTRL_DEAD] = "dead", 377 }; 378 379 if (state < ARRAY_SIZE(state_name) && state_name[state]) 380 return sysfs_emit(buf, "%s\n", state_name[state]); 381 382 return sysfs_emit(buf, "unknown state\n"); 383 } 384 385 static DEVICE_ATTR(state, S_IRUGO, nvme_sysfs_show_state, NULL); 386 387 static ssize_t nvme_sysfs_show_subsysnqn(struct device *dev, 388 struct device_attribute *attr, 389 char *buf) 390 { 391 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 392 393 return sysfs_emit(buf, "%s\n", ctrl->subsys->subnqn); 394 } 395 static DEVICE_ATTR(subsysnqn, S_IRUGO, nvme_sysfs_show_subsysnqn, NULL); 396 397 static ssize_t nvme_sysfs_show_hostnqn(struct device *dev, 398 struct device_attribute *attr, 399 char *buf) 400 { 401 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 402 403 return sysfs_emit(buf, "%s\n", ctrl->opts->host->nqn); 404 } 405 static DEVICE_ATTR(hostnqn, S_IRUGO, nvme_sysfs_show_hostnqn, NULL); 406 407 static ssize_t nvme_sysfs_show_hostid(struct device *dev, 408 struct device_attribute *attr, 409 char *buf) 410 { 411 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 412 413 return sysfs_emit(buf, "%pU\n", &ctrl->opts->host->id); 414 } 415 static DEVICE_ATTR(hostid, S_IRUGO, nvme_sysfs_show_hostid, NULL); 416 417 static ssize_t nvme_sysfs_show_address(struct device *dev, 418 struct device_attribute *attr, 419 char *buf) 420 { 421 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 422 423 return ctrl->ops->get_address(ctrl, buf, PAGE_SIZE); 424 } 425 static DEVICE_ATTR(address, S_IRUGO, nvme_sysfs_show_address, NULL); 426 427 static ssize_t nvme_ctrl_loss_tmo_show(struct device *dev, 428 struct device_attribute *attr, char *buf) 429 { 430 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 431 struct nvmf_ctrl_options *opts = ctrl->opts; 432 433 if (ctrl->opts->max_reconnects == -1) 434 return sysfs_emit(buf, "off\n"); 435 return sysfs_emit(buf, "%d\n", 436 opts->max_reconnects * opts->reconnect_delay); 437 } 438 439 static ssize_t nvme_ctrl_loss_tmo_store(struct device *dev, 440 struct device_attribute *attr, const char *buf, size_t count) 441 { 442 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 443 struct nvmf_ctrl_options *opts = ctrl->opts; 444 int ctrl_loss_tmo, err; 445 446 err = kstrtoint(buf, 10, &ctrl_loss_tmo); 447 if (err) 448 return -EINVAL; 449 450 if (ctrl_loss_tmo < 0) 451 opts->max_reconnects = -1; 452 else 453 opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo, 454 opts->reconnect_delay); 455 return count; 456 } 457 static DEVICE_ATTR(ctrl_loss_tmo, S_IRUGO | S_IWUSR, 458 nvme_ctrl_loss_tmo_show, nvme_ctrl_loss_tmo_store); 459 460 static ssize_t nvme_ctrl_reconnect_delay_show(struct device *dev, 461 struct device_attribute *attr, char *buf) 462 { 463 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 464 465 if (ctrl->opts->reconnect_delay == -1) 466 return sysfs_emit(buf, "off\n"); 467 return sysfs_emit(buf, "%d\n", ctrl->opts->reconnect_delay); 468 } 469 470 static ssize_t nvme_ctrl_reconnect_delay_store(struct device *dev, 471 struct device_attribute *attr, const char *buf, size_t count) 472 { 473 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 474 unsigned int v; 475 int err; 476 477 err = kstrtou32(buf, 10, &v); 478 if (err) 479 return err; 480 481 ctrl->opts->reconnect_delay = v; 482 return count; 483 } 484 static DEVICE_ATTR(reconnect_delay, S_IRUGO | S_IWUSR, 485 nvme_ctrl_reconnect_delay_show, nvme_ctrl_reconnect_delay_store); 486 487 static ssize_t nvme_ctrl_fast_io_fail_tmo_show(struct device *dev, 488 struct device_attribute *attr, char *buf) 489 { 490 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 491 492 if (ctrl->opts->fast_io_fail_tmo == -1) 493 return sysfs_emit(buf, "off\n"); 494 return sysfs_emit(buf, "%d\n", ctrl->opts->fast_io_fail_tmo); 495 } 496 497 static ssize_t nvme_ctrl_fast_io_fail_tmo_store(struct device *dev, 498 struct device_attribute *attr, const char *buf, size_t count) 499 { 500 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 501 struct nvmf_ctrl_options *opts = ctrl->opts; 502 int fast_io_fail_tmo, err; 503 504 err = kstrtoint(buf, 10, &fast_io_fail_tmo); 505 if (err) 506 return -EINVAL; 507 508 if (fast_io_fail_tmo < 0) 509 opts->fast_io_fail_tmo = -1; 510 else 511 opts->fast_io_fail_tmo = fast_io_fail_tmo; 512 return count; 513 } 514 static DEVICE_ATTR(fast_io_fail_tmo, S_IRUGO | S_IWUSR, 515 nvme_ctrl_fast_io_fail_tmo_show, nvme_ctrl_fast_io_fail_tmo_store); 516 517 static ssize_t cntrltype_show(struct device *dev, 518 struct device_attribute *attr, char *buf) 519 { 520 static const char * const type[] = { 521 [NVME_CTRL_IO] = "io\n", 522 [NVME_CTRL_DISC] = "discovery\n", 523 [NVME_CTRL_ADMIN] = "admin\n", 524 }; 525 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 526 527 if (ctrl->cntrltype > NVME_CTRL_ADMIN || !type[ctrl->cntrltype]) 528 return sysfs_emit(buf, "reserved\n"); 529 530 return sysfs_emit(buf, type[ctrl->cntrltype]); 531 } 532 static DEVICE_ATTR_RO(cntrltype); 533 534 static ssize_t dctype_show(struct device *dev, 535 struct device_attribute *attr, char *buf) 536 { 537 static const char * const type[] = { 538 [NVME_DCTYPE_NOT_REPORTED] = "none\n", 539 [NVME_DCTYPE_DDC] = "ddc\n", 540 [NVME_DCTYPE_CDC] = "cdc\n", 541 }; 542 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 543 544 if (ctrl->dctype > NVME_DCTYPE_CDC || !type[ctrl->dctype]) 545 return sysfs_emit(buf, "reserved\n"); 546 547 return sysfs_emit(buf, type[ctrl->dctype]); 548 } 549 static DEVICE_ATTR_RO(dctype); 550 551 #ifdef CONFIG_NVME_HOST_AUTH 552 static ssize_t nvme_ctrl_dhchap_secret_show(struct device *dev, 553 struct device_attribute *attr, char *buf) 554 { 555 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 556 struct nvmf_ctrl_options *opts = ctrl->opts; 557 558 if (!opts->dhchap_secret) 559 return sysfs_emit(buf, "none\n"); 560 return sysfs_emit(buf, "%s\n", opts->dhchap_secret); 561 } 562 563 static ssize_t nvme_ctrl_dhchap_secret_store(struct device *dev, 564 struct device_attribute *attr, const char *buf, size_t count) 565 { 566 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 567 struct nvmf_ctrl_options *opts = ctrl->opts; 568 char *dhchap_secret; 569 570 if (!ctrl->opts->dhchap_secret) 571 return -EINVAL; 572 if (count < 7) 573 return -EINVAL; 574 if (memcmp(buf, "DHHC-1:", 7)) 575 return -EINVAL; 576 577 dhchap_secret = kzalloc(count + 1, GFP_KERNEL); 578 if (!dhchap_secret) 579 return -ENOMEM; 580 memcpy(dhchap_secret, buf, count); 581 nvme_auth_stop(ctrl); 582 if (strcmp(dhchap_secret, opts->dhchap_secret)) { 583 struct nvme_dhchap_key *key, *host_key; 584 int ret; 585 586 ret = nvme_auth_generate_key(dhchap_secret, &key); 587 if (ret) { 588 kfree(dhchap_secret); 589 return ret; 590 } 591 kfree(opts->dhchap_secret); 592 opts->dhchap_secret = dhchap_secret; 593 host_key = ctrl->host_key; 594 mutex_lock(&ctrl->dhchap_auth_mutex); 595 ctrl->host_key = key; 596 mutex_unlock(&ctrl->dhchap_auth_mutex); 597 nvme_auth_free_key(host_key); 598 } else 599 kfree(dhchap_secret); 600 /* Start re-authentication */ 601 dev_info(ctrl->device, "re-authenticating controller\n"); 602 queue_work(nvme_wq, &ctrl->dhchap_auth_work); 603 604 return count; 605 } 606 607 static DEVICE_ATTR(dhchap_secret, S_IRUGO | S_IWUSR, 608 nvme_ctrl_dhchap_secret_show, nvme_ctrl_dhchap_secret_store); 609 610 static ssize_t nvme_ctrl_dhchap_ctrl_secret_show(struct device *dev, 611 struct device_attribute *attr, char *buf) 612 { 613 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 614 struct nvmf_ctrl_options *opts = ctrl->opts; 615 616 if (!opts->dhchap_ctrl_secret) 617 return sysfs_emit(buf, "none\n"); 618 return sysfs_emit(buf, "%s\n", opts->dhchap_ctrl_secret); 619 } 620 621 static ssize_t nvme_ctrl_dhchap_ctrl_secret_store(struct device *dev, 622 struct device_attribute *attr, const char *buf, size_t count) 623 { 624 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 625 struct nvmf_ctrl_options *opts = ctrl->opts; 626 char *dhchap_secret; 627 628 if (!ctrl->opts->dhchap_ctrl_secret) 629 return -EINVAL; 630 if (count < 7) 631 return -EINVAL; 632 if (memcmp(buf, "DHHC-1:", 7)) 633 return -EINVAL; 634 635 dhchap_secret = kzalloc(count + 1, GFP_KERNEL); 636 if (!dhchap_secret) 637 return -ENOMEM; 638 memcpy(dhchap_secret, buf, count); 639 nvme_auth_stop(ctrl); 640 if (strcmp(dhchap_secret, opts->dhchap_ctrl_secret)) { 641 struct nvme_dhchap_key *key, *ctrl_key; 642 int ret; 643 644 ret = nvme_auth_generate_key(dhchap_secret, &key); 645 if (ret) { 646 kfree(dhchap_secret); 647 return ret; 648 } 649 kfree(opts->dhchap_ctrl_secret); 650 opts->dhchap_ctrl_secret = dhchap_secret; 651 ctrl_key = ctrl->ctrl_key; 652 mutex_lock(&ctrl->dhchap_auth_mutex); 653 ctrl->ctrl_key = key; 654 mutex_unlock(&ctrl->dhchap_auth_mutex); 655 nvme_auth_free_key(ctrl_key); 656 } else 657 kfree(dhchap_secret); 658 /* Start re-authentication */ 659 dev_info(ctrl->device, "re-authenticating controller\n"); 660 queue_work(nvme_wq, &ctrl->dhchap_auth_work); 661 662 return count; 663 } 664 665 static DEVICE_ATTR(dhchap_ctrl_secret, S_IRUGO | S_IWUSR, 666 nvme_ctrl_dhchap_ctrl_secret_show, nvme_ctrl_dhchap_ctrl_secret_store); 667 #endif 668 669 #ifdef CONFIG_NVME_TCP_TLS 670 static ssize_t tls_key_show(struct device *dev, 671 struct device_attribute *attr, char *buf) 672 { 673 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 674 675 if (!ctrl->tls_key) 676 return 0; 677 return sysfs_emit(buf, "%08x", key_serial(ctrl->tls_key)); 678 } 679 static DEVICE_ATTR_RO(tls_key); 680 #endif 681 682 static struct attribute *nvme_dev_attrs[] = { 683 &dev_attr_reset_controller.attr, 684 &dev_attr_rescan_controller.attr, 685 &dev_attr_model.attr, 686 &dev_attr_serial.attr, 687 &dev_attr_firmware_rev.attr, 688 &dev_attr_cntlid.attr, 689 &dev_attr_delete_controller.attr, 690 &dev_attr_transport.attr, 691 &dev_attr_subsysnqn.attr, 692 &dev_attr_address.attr, 693 &dev_attr_state.attr, 694 &dev_attr_numa_node.attr, 695 &dev_attr_queue_count.attr, 696 &dev_attr_sqsize.attr, 697 &dev_attr_hostnqn.attr, 698 &dev_attr_hostid.attr, 699 &dev_attr_ctrl_loss_tmo.attr, 700 &dev_attr_reconnect_delay.attr, 701 &dev_attr_fast_io_fail_tmo.attr, 702 &dev_attr_kato.attr, 703 &dev_attr_cntrltype.attr, 704 &dev_attr_dctype.attr, 705 #ifdef CONFIG_NVME_HOST_AUTH 706 &dev_attr_dhchap_secret.attr, 707 &dev_attr_dhchap_ctrl_secret.attr, 708 #endif 709 #ifdef CONFIG_NVME_TCP_TLS 710 &dev_attr_tls_key.attr, 711 #endif 712 &dev_attr_adm_passthru_err_log_enabled.attr, 713 NULL 714 }; 715 716 static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj, 717 struct attribute *a, int n) 718 { 719 struct device *dev = container_of(kobj, struct device, kobj); 720 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); 721 722 if (a == &dev_attr_delete_controller.attr && !ctrl->ops->delete_ctrl) 723 return 0; 724 if (a == &dev_attr_address.attr && !ctrl->ops->get_address) 725 return 0; 726 if (a == &dev_attr_hostnqn.attr && !ctrl->opts) 727 return 0; 728 if (a == &dev_attr_hostid.attr && !ctrl->opts) 729 return 0; 730 if (a == &dev_attr_ctrl_loss_tmo.attr && !ctrl->opts) 731 return 0; 732 if (a == &dev_attr_reconnect_delay.attr && !ctrl->opts) 733 return 0; 734 if (a == &dev_attr_fast_io_fail_tmo.attr && !ctrl->opts) 735 return 0; 736 #ifdef CONFIG_NVME_HOST_AUTH 737 if (a == &dev_attr_dhchap_secret.attr && !ctrl->opts) 738 return 0; 739 if (a == &dev_attr_dhchap_ctrl_secret.attr && !ctrl->opts) 740 return 0; 741 #endif 742 #ifdef CONFIG_NVME_TCP_TLS 743 if (a == &dev_attr_tls_key.attr && 744 (!ctrl->opts || strcmp(ctrl->opts->transport, "tcp"))) 745 return 0; 746 #endif 747 748 return a->mode; 749 } 750 751 const struct attribute_group nvme_dev_attrs_group = { 752 .attrs = nvme_dev_attrs, 753 .is_visible = nvme_dev_attrs_are_visible, 754 }; 755 EXPORT_SYMBOL_GPL(nvme_dev_attrs_group); 756 757 const struct attribute_group *nvme_dev_attr_groups[] = { 758 &nvme_dev_attrs_group, 759 NULL, 760 }; 761 762 #define SUBSYS_ATTR_RO(_name, _mode, _show) \ 763 struct device_attribute subsys_attr_##_name = \ 764 __ATTR(_name, _mode, _show, NULL) 765 766 static ssize_t nvme_subsys_show_nqn(struct device *dev, 767 struct device_attribute *attr, 768 char *buf) 769 { 770 struct nvme_subsystem *subsys = 771 container_of(dev, struct nvme_subsystem, dev); 772 773 return sysfs_emit(buf, "%s\n", subsys->subnqn); 774 } 775 static SUBSYS_ATTR_RO(subsysnqn, S_IRUGO, nvme_subsys_show_nqn); 776 777 static ssize_t nvme_subsys_show_type(struct device *dev, 778 struct device_attribute *attr, 779 char *buf) 780 { 781 struct nvme_subsystem *subsys = 782 container_of(dev, struct nvme_subsystem, dev); 783 784 switch (subsys->subtype) { 785 case NVME_NQN_DISC: 786 return sysfs_emit(buf, "discovery\n"); 787 case NVME_NQN_NVME: 788 return sysfs_emit(buf, "nvm\n"); 789 default: 790 return sysfs_emit(buf, "reserved\n"); 791 } 792 } 793 static SUBSYS_ATTR_RO(subsystype, S_IRUGO, nvme_subsys_show_type); 794 795 #define nvme_subsys_show_str_function(field) \ 796 static ssize_t subsys_##field##_show(struct device *dev, \ 797 struct device_attribute *attr, char *buf) \ 798 { \ 799 struct nvme_subsystem *subsys = \ 800 container_of(dev, struct nvme_subsystem, dev); \ 801 return sysfs_emit(buf, "%.*s\n", \ 802 (int)sizeof(subsys->field), subsys->field); \ 803 } \ 804 static SUBSYS_ATTR_RO(field, S_IRUGO, subsys_##field##_show); 805 806 nvme_subsys_show_str_function(model); 807 nvme_subsys_show_str_function(serial); 808 nvme_subsys_show_str_function(firmware_rev); 809 810 static struct attribute *nvme_subsys_attrs[] = { 811 &subsys_attr_model.attr, 812 &subsys_attr_serial.attr, 813 &subsys_attr_firmware_rev.attr, 814 &subsys_attr_subsysnqn.attr, 815 &subsys_attr_subsystype.attr, 816 #ifdef CONFIG_NVME_MULTIPATH 817 &subsys_attr_iopolicy.attr, 818 #endif 819 NULL, 820 }; 821 822 static const struct attribute_group nvme_subsys_attrs_group = { 823 .attrs = nvme_subsys_attrs, 824 }; 825 826 const struct attribute_group *nvme_subsys_attrs_groups[] = { 827 &nvme_subsys_attrs_group, 828 NULL, 829 }; 830