Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
13static 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}
25static DEVICE_ATTR(reset_controller, S_IWUSR, NULL, nvme_sysfs_reset);
26
27static 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}
36static DEVICE_ATTR(rescan_controller, S_IWUSR, NULL, nvme_sysfs_rescan);
37
38static inline struct nvme_ns_head *dev_to_ns_head(struct device *dev)
39{
40 struct gendisk *disk = dev_to_disk(dev);
41
42 if (disk->fops == &nvme_bdev_ops)
43 return nvme_get_ns_from_dev(dev)->head;
44 else
45 return disk->private_data;
46}
47
48static ssize_t wwid_show(struct device *dev, struct device_attribute *attr,
49 char *buf)
50{
51 struct nvme_ns_head *head = dev_to_ns_head(dev);
52 struct nvme_ns_ids *ids = &head->ids;
53 struct nvme_subsystem *subsys = head->subsys;
54 int serial_len = sizeof(subsys->serial);
55 int model_len = sizeof(subsys->model);
56
57 if (!uuid_is_null(&ids->uuid))
58 return sysfs_emit(buf, "uuid.%pU\n", &ids->uuid);
59
60 if (memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))
61 return sysfs_emit(buf, "eui.%16phN\n", ids->nguid);
62
63 if (memchr_inv(ids->eui64, 0, sizeof(ids->eui64)))
64 return sysfs_emit(buf, "eui.%8phN\n", ids->eui64);
65
66 while (serial_len > 0 && (subsys->serial[serial_len - 1] == ' ' ||
67 subsys->serial[serial_len - 1] == '\0'))
68 serial_len--;
69 while (model_len > 0 && (subsys->model[model_len - 1] == ' ' ||
70 subsys->model[model_len - 1] == '\0'))
71 model_len--;
72
73 return sysfs_emit(buf, "nvme.%04x-%*phN-%*phN-%08x\n", subsys->vendor_id,
74 serial_len, subsys->serial, model_len, subsys->model,
75 head->ns_id);
76}
77static DEVICE_ATTR_RO(wwid);
78
79static ssize_t nguid_show(struct device *dev, struct device_attribute *attr,
80 char *buf)
81{
82 return sysfs_emit(buf, "%pU\n", dev_to_ns_head(dev)->ids.nguid);
83}
84static DEVICE_ATTR_RO(nguid);
85
86static ssize_t uuid_show(struct device *dev, struct device_attribute *attr,
87 char *buf)
88{
89 struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids;
90
91 /* For backward compatibility expose the NGUID to userspace if
92 * we have no UUID set
93 */
94 if (uuid_is_null(&ids->uuid)) {
95 dev_warn_once(dev,
96 "No UUID available providing old NGUID\n");
97 return sysfs_emit(buf, "%pU\n", ids->nguid);
98 }
99 return sysfs_emit(buf, "%pU\n", &ids->uuid);
100}
101static DEVICE_ATTR_RO(uuid);
102
103static ssize_t eui_show(struct device *dev, struct device_attribute *attr,
104 char *buf)
105{
106 return sysfs_emit(buf, "%8ph\n", dev_to_ns_head(dev)->ids.eui64);
107}
108static DEVICE_ATTR_RO(eui);
109
110static ssize_t nsid_show(struct device *dev, struct device_attribute *attr,
111 char *buf)
112{
113 return sysfs_emit(buf, "%d\n", dev_to_ns_head(dev)->ns_id);
114}
115static DEVICE_ATTR_RO(nsid);
116
117static struct attribute *nvme_ns_id_attrs[] = {
118 &dev_attr_wwid.attr,
119 &dev_attr_uuid.attr,
120 &dev_attr_nguid.attr,
121 &dev_attr_eui.attr,
122 &dev_attr_nsid.attr,
123#ifdef CONFIG_NVME_MULTIPATH
124 &dev_attr_ana_grpid.attr,
125 &dev_attr_ana_state.attr,
126#endif
127 NULL,
128};
129
130static umode_t nvme_ns_id_attrs_are_visible(struct kobject *kobj,
131 struct attribute *a, int n)
132{
133 struct device *dev = container_of(kobj, struct device, kobj);
134 struct nvme_ns_ids *ids = &dev_to_ns_head(dev)->ids;
135
136 if (a == &dev_attr_uuid.attr) {
137 if (uuid_is_null(&ids->uuid) &&
138 !memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))
139 return 0;
140 }
141 if (a == &dev_attr_nguid.attr) {
142 if (!memchr_inv(ids->nguid, 0, sizeof(ids->nguid)))
143 return 0;
144 }
145 if (a == &dev_attr_eui.attr) {
146 if (!memchr_inv(ids->eui64, 0, sizeof(ids->eui64)))
147 return 0;
148 }
149#ifdef CONFIG_NVME_MULTIPATH
150 if (a == &dev_attr_ana_grpid.attr || a == &dev_attr_ana_state.attr) {
151 if (dev_to_disk(dev)->fops != &nvme_bdev_ops) /* per-path attr */
152 return 0;
153 if (!nvme_ctrl_use_ana(nvme_get_ns_from_dev(dev)->ctrl))
154 return 0;
155 }
156#endif
157 return a->mode;
158}
159
160static const struct attribute_group nvme_ns_id_attr_group = {
161 .attrs = nvme_ns_id_attrs,
162 .is_visible = nvme_ns_id_attrs_are_visible,
163};
164
165const struct attribute_group *nvme_ns_id_attr_groups[] = {
166 &nvme_ns_id_attr_group,
167 NULL,
168};
169
170#define nvme_show_str_function(field) \
171static ssize_t field##_show(struct device *dev, \
172 struct device_attribute *attr, char *buf) \
173{ \
174 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \
175 return sysfs_emit(buf, "%.*s\n", \
176 (int)sizeof(ctrl->subsys->field), ctrl->subsys->field); \
177} \
178static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);
179
180nvme_show_str_function(model);
181nvme_show_str_function(serial);
182nvme_show_str_function(firmware_rev);
183
184#define nvme_show_int_function(field) \
185static ssize_t field##_show(struct device *dev, \
186 struct device_attribute *attr, char *buf) \
187{ \
188 struct nvme_ctrl *ctrl = dev_get_drvdata(dev); \
189 return sysfs_emit(buf, "%d\n", ctrl->field); \
190} \
191static DEVICE_ATTR(field, S_IRUGO, field##_show, NULL);
192
193nvme_show_int_function(cntlid);
194nvme_show_int_function(numa_node);
195nvme_show_int_function(queue_count);
196nvme_show_int_function(sqsize);
197nvme_show_int_function(kato);
198
199static ssize_t nvme_sysfs_delete(struct device *dev,
200 struct device_attribute *attr, const char *buf,
201 size_t count)
202{
203 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
204
205 if (!test_bit(NVME_CTRL_STARTED_ONCE, &ctrl->flags))
206 return -EBUSY;
207
208 if (device_remove_file_self(dev, attr))
209 nvme_delete_ctrl_sync(ctrl);
210 return count;
211}
212static DEVICE_ATTR(delete_controller, S_IWUSR, NULL, nvme_sysfs_delete);
213
214static ssize_t nvme_sysfs_show_transport(struct device *dev,
215 struct device_attribute *attr,
216 char *buf)
217{
218 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
219
220 return sysfs_emit(buf, "%s\n", ctrl->ops->name);
221}
222static DEVICE_ATTR(transport, S_IRUGO, nvme_sysfs_show_transport, NULL);
223
224static ssize_t nvme_sysfs_show_state(struct device *dev,
225 struct device_attribute *attr,
226 char *buf)
227{
228 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
229 static const char *const state_name[] = {
230 [NVME_CTRL_NEW] = "new",
231 [NVME_CTRL_LIVE] = "live",
232 [NVME_CTRL_RESETTING] = "resetting",
233 [NVME_CTRL_CONNECTING] = "connecting",
234 [NVME_CTRL_DELETING] = "deleting",
235 [NVME_CTRL_DELETING_NOIO]= "deleting (no IO)",
236 [NVME_CTRL_DEAD] = "dead",
237 };
238
239 if ((unsigned)ctrl->state < ARRAY_SIZE(state_name) &&
240 state_name[ctrl->state])
241 return sysfs_emit(buf, "%s\n", state_name[ctrl->state]);
242
243 return sysfs_emit(buf, "unknown state\n");
244}
245
246static DEVICE_ATTR(state, S_IRUGO, nvme_sysfs_show_state, NULL);
247
248static ssize_t nvme_sysfs_show_subsysnqn(struct device *dev,
249 struct device_attribute *attr,
250 char *buf)
251{
252 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
253
254 return sysfs_emit(buf, "%s\n", ctrl->subsys->subnqn);
255}
256static DEVICE_ATTR(subsysnqn, S_IRUGO, nvme_sysfs_show_subsysnqn, NULL);
257
258static ssize_t nvme_sysfs_show_hostnqn(struct device *dev,
259 struct device_attribute *attr,
260 char *buf)
261{
262 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
263
264 return sysfs_emit(buf, "%s\n", ctrl->opts->host->nqn);
265}
266static DEVICE_ATTR(hostnqn, S_IRUGO, nvme_sysfs_show_hostnqn, NULL);
267
268static ssize_t nvme_sysfs_show_hostid(struct device *dev,
269 struct device_attribute *attr,
270 char *buf)
271{
272 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
273
274 return sysfs_emit(buf, "%pU\n", &ctrl->opts->host->id);
275}
276static DEVICE_ATTR(hostid, S_IRUGO, nvme_sysfs_show_hostid, NULL);
277
278static ssize_t nvme_sysfs_show_address(struct device *dev,
279 struct device_attribute *attr,
280 char *buf)
281{
282 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
283
284 return ctrl->ops->get_address(ctrl, buf, PAGE_SIZE);
285}
286static DEVICE_ATTR(address, S_IRUGO, nvme_sysfs_show_address, NULL);
287
288static ssize_t nvme_ctrl_loss_tmo_show(struct device *dev,
289 struct device_attribute *attr, char *buf)
290{
291 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
292 struct nvmf_ctrl_options *opts = ctrl->opts;
293
294 if (ctrl->opts->max_reconnects == -1)
295 return sysfs_emit(buf, "off\n");
296 return sysfs_emit(buf, "%d\n",
297 opts->max_reconnects * opts->reconnect_delay);
298}
299
300static ssize_t nvme_ctrl_loss_tmo_store(struct device *dev,
301 struct device_attribute *attr, const char *buf, size_t count)
302{
303 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
304 struct nvmf_ctrl_options *opts = ctrl->opts;
305 int ctrl_loss_tmo, err;
306
307 err = kstrtoint(buf, 10, &ctrl_loss_tmo);
308 if (err)
309 return -EINVAL;
310
311 if (ctrl_loss_tmo < 0)
312 opts->max_reconnects = -1;
313 else
314 opts->max_reconnects = DIV_ROUND_UP(ctrl_loss_tmo,
315 opts->reconnect_delay);
316 return count;
317}
318static DEVICE_ATTR(ctrl_loss_tmo, S_IRUGO | S_IWUSR,
319 nvme_ctrl_loss_tmo_show, nvme_ctrl_loss_tmo_store);
320
321static ssize_t nvme_ctrl_reconnect_delay_show(struct device *dev,
322 struct device_attribute *attr, char *buf)
323{
324 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
325
326 if (ctrl->opts->reconnect_delay == -1)
327 return sysfs_emit(buf, "off\n");
328 return sysfs_emit(buf, "%d\n", ctrl->opts->reconnect_delay);
329}
330
331static ssize_t nvme_ctrl_reconnect_delay_store(struct device *dev,
332 struct device_attribute *attr, const char *buf, size_t count)
333{
334 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
335 unsigned int v;
336 int err;
337
338 err = kstrtou32(buf, 10, &v);
339 if (err)
340 return err;
341
342 ctrl->opts->reconnect_delay = v;
343 return count;
344}
345static DEVICE_ATTR(reconnect_delay, S_IRUGO | S_IWUSR,
346 nvme_ctrl_reconnect_delay_show, nvme_ctrl_reconnect_delay_store);
347
348static ssize_t nvme_ctrl_fast_io_fail_tmo_show(struct device *dev,
349 struct device_attribute *attr, char *buf)
350{
351 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
352
353 if (ctrl->opts->fast_io_fail_tmo == -1)
354 return sysfs_emit(buf, "off\n");
355 return sysfs_emit(buf, "%d\n", ctrl->opts->fast_io_fail_tmo);
356}
357
358static ssize_t nvme_ctrl_fast_io_fail_tmo_store(struct device *dev,
359 struct device_attribute *attr, const char *buf, size_t count)
360{
361 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
362 struct nvmf_ctrl_options *opts = ctrl->opts;
363 int fast_io_fail_tmo, err;
364
365 err = kstrtoint(buf, 10, &fast_io_fail_tmo);
366 if (err)
367 return -EINVAL;
368
369 if (fast_io_fail_tmo < 0)
370 opts->fast_io_fail_tmo = -1;
371 else
372 opts->fast_io_fail_tmo = fast_io_fail_tmo;
373 return count;
374}
375static DEVICE_ATTR(fast_io_fail_tmo, S_IRUGO | S_IWUSR,
376 nvme_ctrl_fast_io_fail_tmo_show, nvme_ctrl_fast_io_fail_tmo_store);
377
378static ssize_t cntrltype_show(struct device *dev,
379 struct device_attribute *attr, char *buf)
380{
381 static const char * const type[] = {
382 [NVME_CTRL_IO] = "io\n",
383 [NVME_CTRL_DISC] = "discovery\n",
384 [NVME_CTRL_ADMIN] = "admin\n",
385 };
386 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
387
388 if (ctrl->cntrltype > NVME_CTRL_ADMIN || !type[ctrl->cntrltype])
389 return sysfs_emit(buf, "reserved\n");
390
391 return sysfs_emit(buf, type[ctrl->cntrltype]);
392}
393static DEVICE_ATTR_RO(cntrltype);
394
395static ssize_t dctype_show(struct device *dev,
396 struct device_attribute *attr, char *buf)
397{
398 static const char * const type[] = {
399 [NVME_DCTYPE_NOT_REPORTED] = "none\n",
400 [NVME_DCTYPE_DDC] = "ddc\n",
401 [NVME_DCTYPE_CDC] = "cdc\n",
402 };
403 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
404
405 if (ctrl->dctype > NVME_DCTYPE_CDC || !type[ctrl->dctype])
406 return sysfs_emit(buf, "reserved\n");
407
408 return sysfs_emit(buf, type[ctrl->dctype]);
409}
410static DEVICE_ATTR_RO(dctype);
411
412#ifdef CONFIG_NVME_AUTH
413static ssize_t nvme_ctrl_dhchap_secret_show(struct device *dev,
414 struct device_attribute *attr, char *buf)
415{
416 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
417 struct nvmf_ctrl_options *opts = ctrl->opts;
418
419 if (!opts->dhchap_secret)
420 return sysfs_emit(buf, "none\n");
421 return sysfs_emit(buf, "%s\n", opts->dhchap_secret);
422}
423
424static ssize_t nvme_ctrl_dhchap_secret_store(struct device *dev,
425 struct device_attribute *attr, const char *buf, size_t count)
426{
427 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
428 struct nvmf_ctrl_options *opts = ctrl->opts;
429 char *dhchap_secret;
430
431 if (!ctrl->opts->dhchap_secret)
432 return -EINVAL;
433 if (count < 7)
434 return -EINVAL;
435 if (memcmp(buf, "DHHC-1:", 7))
436 return -EINVAL;
437
438 dhchap_secret = kzalloc(count + 1, GFP_KERNEL);
439 if (!dhchap_secret)
440 return -ENOMEM;
441 memcpy(dhchap_secret, buf, count);
442 nvme_auth_stop(ctrl);
443 if (strcmp(dhchap_secret, opts->dhchap_secret)) {
444 struct nvme_dhchap_key *key, *host_key;
445 int ret;
446
447 ret = nvme_auth_generate_key(dhchap_secret, &key);
448 if (ret) {
449 kfree(dhchap_secret);
450 return ret;
451 }
452 kfree(opts->dhchap_secret);
453 opts->dhchap_secret = dhchap_secret;
454 host_key = ctrl->host_key;
455 mutex_lock(&ctrl->dhchap_auth_mutex);
456 ctrl->host_key = key;
457 mutex_unlock(&ctrl->dhchap_auth_mutex);
458 nvme_auth_free_key(host_key);
459 } else
460 kfree(dhchap_secret);
461 /* Start re-authentication */
462 dev_info(ctrl->device, "re-authenticating controller\n");
463 queue_work(nvme_wq, &ctrl->dhchap_auth_work);
464
465 return count;
466}
467
468static DEVICE_ATTR(dhchap_secret, S_IRUGO | S_IWUSR,
469 nvme_ctrl_dhchap_secret_show, nvme_ctrl_dhchap_secret_store);
470
471static ssize_t nvme_ctrl_dhchap_ctrl_secret_show(struct device *dev,
472 struct device_attribute *attr, char *buf)
473{
474 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
475 struct nvmf_ctrl_options *opts = ctrl->opts;
476
477 if (!opts->dhchap_ctrl_secret)
478 return sysfs_emit(buf, "none\n");
479 return sysfs_emit(buf, "%s\n", opts->dhchap_ctrl_secret);
480}
481
482static ssize_t nvme_ctrl_dhchap_ctrl_secret_store(struct device *dev,
483 struct device_attribute *attr, const char *buf, size_t count)
484{
485 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
486 struct nvmf_ctrl_options *opts = ctrl->opts;
487 char *dhchap_secret;
488
489 if (!ctrl->opts->dhchap_ctrl_secret)
490 return -EINVAL;
491 if (count < 7)
492 return -EINVAL;
493 if (memcmp(buf, "DHHC-1:", 7))
494 return -EINVAL;
495
496 dhchap_secret = kzalloc(count + 1, GFP_KERNEL);
497 if (!dhchap_secret)
498 return -ENOMEM;
499 memcpy(dhchap_secret, buf, count);
500 nvme_auth_stop(ctrl);
501 if (strcmp(dhchap_secret, opts->dhchap_ctrl_secret)) {
502 struct nvme_dhchap_key *key, *ctrl_key;
503 int ret;
504
505 ret = nvme_auth_generate_key(dhchap_secret, &key);
506 if (ret) {
507 kfree(dhchap_secret);
508 return ret;
509 }
510 kfree(opts->dhchap_ctrl_secret);
511 opts->dhchap_ctrl_secret = dhchap_secret;
512 ctrl_key = ctrl->ctrl_key;
513 mutex_lock(&ctrl->dhchap_auth_mutex);
514 ctrl->ctrl_key = key;
515 mutex_unlock(&ctrl->dhchap_auth_mutex);
516 nvme_auth_free_key(ctrl_key);
517 } else
518 kfree(dhchap_secret);
519 /* Start re-authentication */
520 dev_info(ctrl->device, "re-authenticating controller\n");
521 queue_work(nvme_wq, &ctrl->dhchap_auth_work);
522
523 return count;
524}
525
526static DEVICE_ATTR(dhchap_ctrl_secret, S_IRUGO | S_IWUSR,
527 nvme_ctrl_dhchap_ctrl_secret_show, nvme_ctrl_dhchap_ctrl_secret_store);
528#endif
529
530static struct attribute *nvme_dev_attrs[] = {
531 &dev_attr_reset_controller.attr,
532 &dev_attr_rescan_controller.attr,
533 &dev_attr_model.attr,
534 &dev_attr_serial.attr,
535 &dev_attr_firmware_rev.attr,
536 &dev_attr_cntlid.attr,
537 &dev_attr_delete_controller.attr,
538 &dev_attr_transport.attr,
539 &dev_attr_subsysnqn.attr,
540 &dev_attr_address.attr,
541 &dev_attr_state.attr,
542 &dev_attr_numa_node.attr,
543 &dev_attr_queue_count.attr,
544 &dev_attr_sqsize.attr,
545 &dev_attr_hostnqn.attr,
546 &dev_attr_hostid.attr,
547 &dev_attr_ctrl_loss_tmo.attr,
548 &dev_attr_reconnect_delay.attr,
549 &dev_attr_fast_io_fail_tmo.attr,
550 &dev_attr_kato.attr,
551 &dev_attr_cntrltype.attr,
552 &dev_attr_dctype.attr,
553#ifdef CONFIG_NVME_AUTH
554 &dev_attr_dhchap_secret.attr,
555 &dev_attr_dhchap_ctrl_secret.attr,
556#endif
557 NULL
558};
559
560static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj,
561 struct attribute *a, int n)
562{
563 struct device *dev = container_of(kobj, struct device, kobj);
564 struct nvme_ctrl *ctrl = dev_get_drvdata(dev);
565
566 if (a == &dev_attr_delete_controller.attr && !ctrl->ops->delete_ctrl)
567 return 0;
568 if (a == &dev_attr_address.attr && !ctrl->ops->get_address)
569 return 0;
570 if (a == &dev_attr_hostnqn.attr && !ctrl->opts)
571 return 0;
572 if (a == &dev_attr_hostid.attr && !ctrl->opts)
573 return 0;
574 if (a == &dev_attr_ctrl_loss_tmo.attr && !ctrl->opts)
575 return 0;
576 if (a == &dev_attr_reconnect_delay.attr && !ctrl->opts)
577 return 0;
578 if (a == &dev_attr_fast_io_fail_tmo.attr && !ctrl->opts)
579 return 0;
580#ifdef CONFIG_NVME_AUTH
581 if (a == &dev_attr_dhchap_secret.attr && !ctrl->opts)
582 return 0;
583 if (a == &dev_attr_dhchap_ctrl_secret.attr && !ctrl->opts)
584 return 0;
585#endif
586
587 return a->mode;
588}
589
590const struct attribute_group nvme_dev_attrs_group = {
591 .attrs = nvme_dev_attrs,
592 .is_visible = nvme_dev_attrs_are_visible,
593};
594EXPORT_SYMBOL_GPL(nvme_dev_attrs_group);
595
596const struct attribute_group *nvme_dev_attr_groups[] = {
597 &nvme_dev_attrs_group,
598 NULL,
599};
600
601#define SUBSYS_ATTR_RO(_name, _mode, _show) \
602 struct device_attribute subsys_attr_##_name = \
603 __ATTR(_name, _mode, _show, NULL)
604
605static ssize_t nvme_subsys_show_nqn(struct device *dev,
606 struct device_attribute *attr,
607 char *buf)
608{
609 struct nvme_subsystem *subsys =
610 container_of(dev, struct nvme_subsystem, dev);
611
612 return sysfs_emit(buf, "%s\n", subsys->subnqn);
613}
614static SUBSYS_ATTR_RO(subsysnqn, S_IRUGO, nvme_subsys_show_nqn);
615
616static ssize_t nvme_subsys_show_type(struct device *dev,
617 struct device_attribute *attr,
618 char *buf)
619{
620 struct nvme_subsystem *subsys =
621 container_of(dev, struct nvme_subsystem, dev);
622
623 switch (subsys->subtype) {
624 case NVME_NQN_DISC:
625 return sysfs_emit(buf, "discovery\n");
626 case NVME_NQN_NVME:
627 return sysfs_emit(buf, "nvm\n");
628 default:
629 return sysfs_emit(buf, "reserved\n");
630 }
631}
632static SUBSYS_ATTR_RO(subsystype, S_IRUGO, nvme_subsys_show_type);
633
634#define nvme_subsys_show_str_function(field) \
635static ssize_t subsys_##field##_show(struct device *dev, \
636 struct device_attribute *attr, char *buf) \
637{ \
638 struct nvme_subsystem *subsys = \
639 container_of(dev, struct nvme_subsystem, dev); \
640 return sysfs_emit(buf, "%.*s\n", \
641 (int)sizeof(subsys->field), subsys->field); \
642} \
643static SUBSYS_ATTR_RO(field, S_IRUGO, subsys_##field##_show);
644
645nvme_subsys_show_str_function(model);
646nvme_subsys_show_str_function(serial);
647nvme_subsys_show_str_function(firmware_rev);
648
649static struct attribute *nvme_subsys_attrs[] = {
650 &subsys_attr_model.attr,
651 &subsys_attr_serial.attr,
652 &subsys_attr_firmware_rev.attr,
653 &subsys_attr_subsysnqn.attr,
654 &subsys_attr_subsystype.attr,
655#ifdef CONFIG_NVME_MULTIPATH
656 &subsys_attr_iopolicy.attr,
657#endif
658 NULL,
659};
660
661static const struct attribute_group nvme_subsys_attrs_group = {
662 .attrs = nvme_subsys_attrs,
663};
664
665const struct attribute_group *nvme_subsys_attrs_groups[] = {
666 &nvme_subsys_attrs_group,
667 NULL,
668};