drivers/nvme/host/sysfs.c

   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 };