1
2
3
4
5
6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/slab.h>
10#include <linux/stat.h>
11#include <linux/ctype.h>
12#include <linux/pci.h>
13#include <linux/pci-p2pdma.h>
14
15#include "nvmet.h"
16
17static const struct config_item_type nvmet_host_type;
18static const struct config_item_type nvmet_subsys_type;
19
20static LIST_HEAD(nvmet_ports_list);
21struct list_head *nvmet_ports = &nvmet_ports_list;
22
23struct nvmet_type_name_map {
24 u8 type;
25 const char *name;
26};
27
28static struct nvmet_type_name_map nvmet_transport[] = {
29 { NVMF_TRTYPE_RDMA, "rdma" },
30 { NVMF_TRTYPE_FC, "fc" },
31 { NVMF_TRTYPE_TCP, "tcp" },
32 { NVMF_TRTYPE_LOOP, "loop" },
33};
34
35static const struct nvmet_type_name_map nvmet_addr_family[] = {
36 { NVMF_ADDR_FAMILY_PCI, "pcie" },
37 { NVMF_ADDR_FAMILY_IP4, "ipv4" },
38 { NVMF_ADDR_FAMILY_IP6, "ipv6" },
39 { NVMF_ADDR_FAMILY_IB, "ib" },
40 { NVMF_ADDR_FAMILY_FC, "fc" },
41 { NVMF_ADDR_FAMILY_LOOP, "loop" },
42};
43
44static bool nvmet_is_port_enabled(struct nvmet_port *p, const char *caller)
45{
46 if (p->enabled)
47 pr_err("Disable port '%u' before changing attribute in %s\n",
48 le16_to_cpu(p->disc_addr.portid), caller);
49 return p->enabled;
50}
51
52
53
54
55
56static ssize_t nvmet_addr_adrfam_show(struct config_item *item, char *page)
57{
58 u8 adrfam = to_nvmet_port(item)->disc_addr.adrfam;
59 int i;
60
61 for (i = 1; i < ARRAY_SIZE(nvmet_addr_family); i++) {
62 if (nvmet_addr_family[i].type == adrfam)
63 return sprintf(page, "%s\n", nvmet_addr_family[i].name);
64 }
65
66 return sprintf(page, "\n");
67}
68
69static ssize_t nvmet_addr_adrfam_store(struct config_item *item,
70 const char *page, size_t count)
71{
72 struct nvmet_port *port = to_nvmet_port(item);
73 int i;
74
75 if (nvmet_is_port_enabled(port, __func__))
76 return -EACCES;
77
78 for (i = 1; i < ARRAY_SIZE(nvmet_addr_family); i++) {
79 if (sysfs_streq(page, nvmet_addr_family[i].name))
80 goto found;
81 }
82
83 pr_err("Invalid value '%s' for adrfam\n", page);
84 return -EINVAL;
85
86found:
87 port->disc_addr.adrfam = nvmet_addr_family[i].type;
88 return count;
89}
90
91CONFIGFS_ATTR(nvmet_, addr_adrfam);
92
93static ssize_t nvmet_addr_portid_show(struct config_item *item,
94 char *page)
95{
96 struct nvmet_port *port = to_nvmet_port(item);
97
98 return snprintf(page, PAGE_SIZE, "%d\n",
99 le16_to_cpu(port->disc_addr.portid));
100}
101
102static ssize_t nvmet_addr_portid_store(struct config_item *item,
103 const char *page, size_t count)
104{
105 struct nvmet_port *port = to_nvmet_port(item);
106 u16 portid = 0;
107
108 if (kstrtou16(page, 0, &portid)) {
109 pr_err("Invalid value '%s' for portid\n", page);
110 return -EINVAL;
111 }
112
113 if (nvmet_is_port_enabled(port, __func__))
114 return -EACCES;
115
116 port->disc_addr.portid = cpu_to_le16(portid);
117 return count;
118}
119
120CONFIGFS_ATTR(nvmet_, addr_portid);
121
122static ssize_t nvmet_addr_traddr_show(struct config_item *item,
123 char *page)
124{
125 struct nvmet_port *port = to_nvmet_port(item);
126
127 return snprintf(page, PAGE_SIZE, "%s\n",
128 port->disc_addr.traddr);
129}
130
131static ssize_t nvmet_addr_traddr_store(struct config_item *item,
132 const char *page, size_t count)
133{
134 struct nvmet_port *port = to_nvmet_port(item);
135
136 if (count > NVMF_TRADDR_SIZE) {
137 pr_err("Invalid value '%s' for traddr\n", page);
138 return -EINVAL;
139 }
140
141 if (nvmet_is_port_enabled(port, __func__))
142 return -EACCES;
143
144 if (sscanf(page, "%s\n", port->disc_addr.traddr) != 1)
145 return -EINVAL;
146 return count;
147}
148
149CONFIGFS_ATTR(nvmet_, addr_traddr);
150
151static const struct nvmet_type_name_map nvmet_addr_treq[] = {
152 { NVMF_TREQ_NOT_SPECIFIED, "not specified" },
153 { NVMF_TREQ_REQUIRED, "required" },
154 { NVMF_TREQ_NOT_REQUIRED, "not required" },
155};
156
157static ssize_t nvmet_addr_treq_show(struct config_item *item, char *page)
158{
159 u8 treq = to_nvmet_port(item)->disc_addr.treq &
160 NVME_TREQ_SECURE_CHANNEL_MASK;
161 int i;
162
163 for (i = 0; i < ARRAY_SIZE(nvmet_addr_treq); i++) {
164 if (treq == nvmet_addr_treq[i].type)
165 return sprintf(page, "%s\n", nvmet_addr_treq[i].name);
166 }
167
168 return sprintf(page, "\n");
169}
170
171static ssize_t nvmet_addr_treq_store(struct config_item *item,
172 const char *page, size_t count)
173{
174 struct nvmet_port *port = to_nvmet_port(item);
175 u8 treq = port->disc_addr.treq & ~NVME_TREQ_SECURE_CHANNEL_MASK;
176 int i;
177
178 if (nvmet_is_port_enabled(port, __func__))
179 return -EACCES;
180
181 for (i = 0; i < ARRAY_SIZE(nvmet_addr_treq); i++) {
182 if (sysfs_streq(page, nvmet_addr_treq[i].name))
183 goto found;
184 }
185
186 pr_err("Invalid value '%s' for treq\n", page);
187 return -EINVAL;
188
189found:
190 treq |= nvmet_addr_treq[i].type;
191 port->disc_addr.treq = treq;
192 return count;
193}
194
195CONFIGFS_ATTR(nvmet_, addr_treq);
196
197static ssize_t nvmet_addr_trsvcid_show(struct config_item *item,
198 char *page)
199{
200 struct nvmet_port *port = to_nvmet_port(item);
201
202 return snprintf(page, PAGE_SIZE, "%s\n",
203 port->disc_addr.trsvcid);
204}
205
206static ssize_t nvmet_addr_trsvcid_store(struct config_item *item,
207 const char *page, size_t count)
208{
209 struct nvmet_port *port = to_nvmet_port(item);
210
211 if (count > NVMF_TRSVCID_SIZE) {
212 pr_err("Invalid value '%s' for trsvcid\n", page);
213 return -EINVAL;
214 }
215 if (nvmet_is_port_enabled(port, __func__))
216 return -EACCES;
217
218 if (sscanf(page, "%s\n", port->disc_addr.trsvcid) != 1)
219 return -EINVAL;
220 return count;
221}
222
223CONFIGFS_ATTR(nvmet_, addr_trsvcid);
224
225static ssize_t nvmet_param_inline_data_size_show(struct config_item *item,
226 char *page)
227{
228 struct nvmet_port *port = to_nvmet_port(item);
229
230 return snprintf(page, PAGE_SIZE, "%d\n", port->inline_data_size);
231}
232
233static ssize_t nvmet_param_inline_data_size_store(struct config_item *item,
234 const char *page, size_t count)
235{
236 struct nvmet_port *port = to_nvmet_port(item);
237 int ret;
238
239 if (nvmet_is_port_enabled(port, __func__))
240 return -EACCES;
241 ret = kstrtoint(page, 0, &port->inline_data_size);
242 if (ret) {
243 pr_err("Invalid value '%s' for inline_data_size\n", page);
244 return -EINVAL;
245 }
246 return count;
247}
248
249CONFIGFS_ATTR(nvmet_, param_inline_data_size);
250
251#ifdef CONFIG_BLK_DEV_INTEGRITY
252static ssize_t nvmet_param_pi_enable_show(struct config_item *item,
253 char *page)
254{
255 struct nvmet_port *port = to_nvmet_port(item);
256
257 return snprintf(page, PAGE_SIZE, "%d\n", port->pi_enable);
258}
259
260static ssize_t nvmet_param_pi_enable_store(struct config_item *item,
261 const char *page, size_t count)
262{
263 struct nvmet_port *port = to_nvmet_port(item);
264 bool val;
265
266 if (strtobool(page, &val))
267 return -EINVAL;
268
269 if (nvmet_is_port_enabled(port, __func__))
270 return -EACCES;
271
272 port->pi_enable = val;
273 return count;
274}
275
276CONFIGFS_ATTR(nvmet_, param_pi_enable);
277#endif
278
279static ssize_t nvmet_addr_trtype_show(struct config_item *item,
280 char *page)
281{
282 struct nvmet_port *port = to_nvmet_port(item);
283 int i;
284
285 for (i = 0; i < ARRAY_SIZE(nvmet_transport); i++) {
286 if (port->disc_addr.trtype == nvmet_transport[i].type)
287 return sprintf(page, "%s\n", nvmet_transport[i].name);
288 }
289
290 return sprintf(page, "\n");
291}
292
293static void nvmet_port_init_tsas_rdma(struct nvmet_port *port)
294{
295 port->disc_addr.tsas.rdma.qptype = NVMF_RDMA_QPTYPE_CONNECTED;
296 port->disc_addr.tsas.rdma.prtype = NVMF_RDMA_PRTYPE_NOT_SPECIFIED;
297 port->disc_addr.tsas.rdma.cms = NVMF_RDMA_CMS_RDMA_CM;
298}
299
300static ssize_t nvmet_addr_trtype_store(struct config_item *item,
301 const char *page, size_t count)
302{
303 struct nvmet_port *port = to_nvmet_port(item);
304 int i;
305
306 if (nvmet_is_port_enabled(port, __func__))
307 return -EACCES;
308
309 for (i = 0; i < ARRAY_SIZE(nvmet_transport); i++) {
310 if (sysfs_streq(page, nvmet_transport[i].name))
311 goto found;
312 }
313
314 pr_err("Invalid value '%s' for trtype\n", page);
315 return -EINVAL;
316
317found:
318 memset(&port->disc_addr.tsas, 0, NVMF_TSAS_SIZE);
319 port->disc_addr.trtype = nvmet_transport[i].type;
320 if (port->disc_addr.trtype == NVMF_TRTYPE_RDMA)
321 nvmet_port_init_tsas_rdma(port);
322 return count;
323}
324
325CONFIGFS_ATTR(nvmet_, addr_trtype);
326
327
328
329
330static ssize_t nvmet_ns_device_path_show(struct config_item *item, char *page)
331{
332 return sprintf(page, "%s\n", to_nvmet_ns(item)->device_path);
333}
334
335static ssize_t nvmet_ns_device_path_store(struct config_item *item,
336 const char *page, size_t count)
337{
338 struct nvmet_ns *ns = to_nvmet_ns(item);
339 struct nvmet_subsys *subsys = ns->subsys;
340 size_t len;
341 int ret;
342
343 mutex_lock(&subsys->lock);
344 ret = -EBUSY;
345 if (ns->enabled)
346 goto out_unlock;
347
348 ret = -EINVAL;
349 len = strcspn(page, "\n");
350 if (!len)
351 goto out_unlock;
352
353 kfree(ns->device_path);
354 ret = -ENOMEM;
355 ns->device_path = kmemdup_nul(page, len, GFP_KERNEL);
356 if (!ns->device_path)
357 goto out_unlock;
358
359 mutex_unlock(&subsys->lock);
360 return count;
361
362out_unlock:
363 mutex_unlock(&subsys->lock);
364 return ret;
365}
366
367CONFIGFS_ATTR(nvmet_ns_, device_path);
368
369#ifdef CONFIG_PCI_P2PDMA
370static ssize_t nvmet_ns_p2pmem_show(struct config_item *item, char *page)
371{
372 struct nvmet_ns *ns = to_nvmet_ns(item);
373
374 return pci_p2pdma_enable_show(page, ns->p2p_dev, ns->use_p2pmem);
375}
376
377static ssize_t nvmet_ns_p2pmem_store(struct config_item *item,
378 const char *page, size_t count)
379{
380 struct nvmet_ns *ns = to_nvmet_ns(item);
381 struct pci_dev *p2p_dev = NULL;
382 bool use_p2pmem;
383 int ret = count;
384 int error;
385
386 mutex_lock(&ns->subsys->lock);
387 if (ns->enabled) {
388 ret = -EBUSY;
389 goto out_unlock;
390 }
391
392 error = pci_p2pdma_enable_store(page, &p2p_dev, &use_p2pmem);
393 if (error) {
394 ret = error;
395 goto out_unlock;
396 }
397
398 ns->use_p2pmem = use_p2pmem;
399 pci_dev_put(ns->p2p_dev);
400 ns->p2p_dev = p2p_dev;
401
402out_unlock:
403 mutex_unlock(&ns->subsys->lock);
404
405 return ret;
406}
407
408CONFIGFS_ATTR(nvmet_ns_, p2pmem);
409#endif
410
411static ssize_t nvmet_ns_device_uuid_show(struct config_item *item, char *page)
412{
413 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->uuid);
414}
415
416static ssize_t nvmet_ns_device_uuid_store(struct config_item *item,
417 const char *page, size_t count)
418{
419 struct nvmet_ns *ns = to_nvmet_ns(item);
420 struct nvmet_subsys *subsys = ns->subsys;
421 int ret = 0;
422
423 mutex_lock(&subsys->lock);
424 if (ns->enabled) {
425 ret = -EBUSY;
426 goto out_unlock;
427 }
428
429 if (uuid_parse(page, &ns->uuid))
430 ret = -EINVAL;
431
432out_unlock:
433 mutex_unlock(&subsys->lock);
434 return ret ? ret : count;
435}
436
437CONFIGFS_ATTR(nvmet_ns_, device_uuid);
438
439static ssize_t nvmet_ns_device_nguid_show(struct config_item *item, char *page)
440{
441 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->nguid);
442}
443
444static ssize_t nvmet_ns_device_nguid_store(struct config_item *item,
445 const char *page, size_t count)
446{
447 struct nvmet_ns *ns = to_nvmet_ns(item);
448 struct nvmet_subsys *subsys = ns->subsys;
449 u8 nguid[16];
450 const char *p = page;
451 int i;
452 int ret = 0;
453
454 mutex_lock(&subsys->lock);
455 if (ns->enabled) {
456 ret = -EBUSY;
457 goto out_unlock;
458 }
459
460 for (i = 0; i < 16; i++) {
461 if (p + 2 > page + count) {
462 ret = -EINVAL;
463 goto out_unlock;
464 }
465 if (!isxdigit(p[0]) || !isxdigit(p[1])) {
466 ret = -EINVAL;
467 goto out_unlock;
468 }
469
470 nguid[i] = (hex_to_bin(p[0]) << 4) | hex_to_bin(p[1]);
471 p += 2;
472
473 if (*p == '-' || *p == ':')
474 p++;
475 }
476
477 memcpy(&ns->nguid, nguid, sizeof(nguid));
478out_unlock:
479 mutex_unlock(&subsys->lock);
480 return ret ? ret : count;
481}
482
483CONFIGFS_ATTR(nvmet_ns_, device_nguid);
484
485static ssize_t nvmet_ns_ana_grpid_show(struct config_item *item, char *page)
486{
487 return sprintf(page, "%u\n", to_nvmet_ns(item)->anagrpid);
488}
489
490static ssize_t nvmet_ns_ana_grpid_store(struct config_item *item,
491 const char *page, size_t count)
492{
493 struct nvmet_ns *ns = to_nvmet_ns(item);
494 u32 oldgrpid, newgrpid;
495 int ret;
496
497 ret = kstrtou32(page, 0, &newgrpid);
498 if (ret)
499 return ret;
500
501 if (newgrpid < 1 || newgrpid > NVMET_MAX_ANAGRPS)
502 return -EINVAL;
503
504 down_write(&nvmet_ana_sem);
505 oldgrpid = ns->anagrpid;
506 nvmet_ana_group_enabled[newgrpid]++;
507 ns->anagrpid = newgrpid;
508 nvmet_ana_group_enabled[oldgrpid]--;
509 nvmet_ana_chgcnt++;
510 up_write(&nvmet_ana_sem);
511
512 nvmet_send_ana_event(ns->subsys, NULL);
513 return count;
514}
515
516CONFIGFS_ATTR(nvmet_ns_, ana_grpid);
517
518static ssize_t nvmet_ns_enable_show(struct config_item *item, char *page)
519{
520 return sprintf(page, "%d\n", to_nvmet_ns(item)->enabled);
521}
522
523static ssize_t nvmet_ns_enable_store(struct config_item *item,
524 const char *page, size_t count)
525{
526 struct nvmet_ns *ns = to_nvmet_ns(item);
527 bool enable;
528 int ret = 0;
529
530 if (strtobool(page, &enable))
531 return -EINVAL;
532
533 if (enable)
534 ret = nvmet_ns_enable(ns);
535 else
536 nvmet_ns_disable(ns);
537
538 return ret ? ret : count;
539}
540
541CONFIGFS_ATTR(nvmet_ns_, enable);
542
543static ssize_t nvmet_ns_buffered_io_show(struct config_item *item, char *page)
544{
545 return sprintf(page, "%d\n", to_nvmet_ns(item)->buffered_io);
546}
547
548static ssize_t nvmet_ns_buffered_io_store(struct config_item *item,
549 const char *page, size_t count)
550{
551 struct nvmet_ns *ns = to_nvmet_ns(item);
552 bool val;
553
554 if (strtobool(page, &val))
555 return -EINVAL;
556
557 mutex_lock(&ns->subsys->lock);
558 if (ns->enabled) {
559 pr_err("disable ns before setting buffered_io value.\n");
560 mutex_unlock(&ns->subsys->lock);
561 return -EINVAL;
562 }
563
564 ns->buffered_io = val;
565 mutex_unlock(&ns->subsys->lock);
566 return count;
567}
568
569CONFIGFS_ATTR(nvmet_ns_, buffered_io);
570
571static ssize_t nvmet_ns_revalidate_size_store(struct config_item *item,
572 const char *page, size_t count)
573{
574 struct nvmet_ns *ns = to_nvmet_ns(item);
575 bool val;
576
577 if (strtobool(page, &val))
578 return -EINVAL;
579
580 if (!val)
581 return -EINVAL;
582
583 mutex_lock(&ns->subsys->lock);
584 if (!ns->enabled) {
585 pr_err("enable ns before revalidate.\n");
586 mutex_unlock(&ns->subsys->lock);
587 return -EINVAL;
588 }
589 nvmet_ns_revalidate(ns);
590 mutex_unlock(&ns->subsys->lock);
591 return count;
592}
593
594CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
595
596static struct configfs_attribute *nvmet_ns_attrs[] = {
597 &nvmet_ns_attr_device_path,
598 &nvmet_ns_attr_device_nguid,
599 &nvmet_ns_attr_device_uuid,
600 &nvmet_ns_attr_ana_grpid,
601 &nvmet_ns_attr_enable,
602 &nvmet_ns_attr_buffered_io,
603 &nvmet_ns_attr_revalidate_size,
604#ifdef CONFIG_PCI_P2PDMA
605 &nvmet_ns_attr_p2pmem,
606#endif
607 NULL,
608};
609
610static void nvmet_ns_release(struct config_item *item)
611{
612 struct nvmet_ns *ns = to_nvmet_ns(item);
613
614 nvmet_ns_free(ns);
615}
616
617static struct configfs_item_operations nvmet_ns_item_ops = {
618 .release = nvmet_ns_release,
619};
620
621static const struct config_item_type nvmet_ns_type = {
622 .ct_item_ops = &nvmet_ns_item_ops,
623 .ct_attrs = nvmet_ns_attrs,
624 .ct_owner = THIS_MODULE,
625};
626
627static struct config_group *nvmet_ns_make(struct config_group *group,
628 const char *name)
629{
630 struct nvmet_subsys *subsys = namespaces_to_subsys(&group->cg_item);
631 struct nvmet_ns *ns;
632 int ret;
633 u32 nsid;
634
635 ret = kstrtou32(name, 0, &nsid);
636 if (ret)
637 goto out;
638
639 ret = -EINVAL;
640 if (nsid == 0 || nsid == NVME_NSID_ALL) {
641 pr_err("invalid nsid %#x", nsid);
642 goto out;
643 }
644
645 ret = -ENOMEM;
646 ns = nvmet_ns_alloc(subsys, nsid);
647 if (!ns)
648 goto out;
649 config_group_init_type_name(&ns->group, name, &nvmet_ns_type);
650
651 pr_info("adding nsid %d to subsystem %s\n", nsid, subsys->subsysnqn);
652
653 return &ns->group;
654out:
655 return ERR_PTR(ret);
656}
657
658static struct configfs_group_operations nvmet_namespaces_group_ops = {
659 .make_group = nvmet_ns_make,
660};
661
662static const struct config_item_type nvmet_namespaces_type = {
663 .ct_group_ops = &nvmet_namespaces_group_ops,
664 .ct_owner = THIS_MODULE,
665};
666
667#ifdef CONFIG_NVME_TARGET_PASSTHRU
668
669static ssize_t nvmet_passthru_device_path_show(struct config_item *item,
670 char *page)
671{
672 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
673
674 return snprintf(page, PAGE_SIZE, "%s\n", subsys->passthru_ctrl_path);
675}
676
677static ssize_t nvmet_passthru_device_path_store(struct config_item *item,
678 const char *page, size_t count)
679{
680 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
681 size_t len;
682 int ret;
683
684 mutex_lock(&subsys->lock);
685
686 ret = -EBUSY;
687 if (subsys->passthru_ctrl)
688 goto out_unlock;
689
690 ret = -EINVAL;
691 len = strcspn(page, "\n");
692 if (!len)
693 goto out_unlock;
694
695 kfree(subsys->passthru_ctrl_path);
696 ret = -ENOMEM;
697 subsys->passthru_ctrl_path = kstrndup(page, len, GFP_KERNEL);
698 if (!subsys->passthru_ctrl_path)
699 goto out_unlock;
700
701 mutex_unlock(&subsys->lock);
702
703 return count;
704out_unlock:
705 mutex_unlock(&subsys->lock);
706 return ret;
707}
708CONFIGFS_ATTR(nvmet_passthru_, device_path);
709
710static ssize_t nvmet_passthru_enable_show(struct config_item *item,
711 char *page)
712{
713 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
714
715 return sprintf(page, "%d\n", subsys->passthru_ctrl ? 1 : 0);
716}
717
718static ssize_t nvmet_passthru_enable_store(struct config_item *item,
719 const char *page, size_t count)
720{
721 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
722 bool enable;
723 int ret = 0;
724
725 if (strtobool(page, &enable))
726 return -EINVAL;
727
728 if (enable)
729 ret = nvmet_passthru_ctrl_enable(subsys);
730 else
731 nvmet_passthru_ctrl_disable(subsys);
732
733 return ret ? ret : count;
734}
735CONFIGFS_ATTR(nvmet_passthru_, enable);
736
737static ssize_t nvmet_passthru_admin_timeout_show(struct config_item *item,
738 char *page)
739{
740 return sprintf(page, "%u\n", to_subsys(item->ci_parent)->admin_timeout);
741}
742
743static ssize_t nvmet_passthru_admin_timeout_store(struct config_item *item,
744 const char *page, size_t count)
745{
746 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
747 unsigned int timeout;
748
749 if (kstrtouint(page, 0, &timeout))
750 return -EINVAL;
751 subsys->admin_timeout = timeout;
752 return count;
753}
754CONFIGFS_ATTR(nvmet_passthru_, admin_timeout);
755
756static ssize_t nvmet_passthru_io_timeout_show(struct config_item *item,
757 char *page)
758{
759 return sprintf(page, "%u\n", to_subsys(item->ci_parent)->io_timeout);
760}
761
762static ssize_t nvmet_passthru_io_timeout_store(struct config_item *item,
763 const char *page, size_t count)
764{
765 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
766 unsigned int timeout;
767
768 if (kstrtouint(page, 0, &timeout))
769 return -EINVAL;
770 subsys->io_timeout = timeout;
771 return count;
772}
773CONFIGFS_ATTR(nvmet_passthru_, io_timeout);
774
775static struct configfs_attribute *nvmet_passthru_attrs[] = {
776 &nvmet_passthru_attr_device_path,
777 &nvmet_passthru_attr_enable,
778 &nvmet_passthru_attr_admin_timeout,
779 &nvmet_passthru_attr_io_timeout,
780 NULL,
781};
782
783static const struct config_item_type nvmet_passthru_type = {
784 .ct_attrs = nvmet_passthru_attrs,
785 .ct_owner = THIS_MODULE,
786};
787
788static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
789{
790 config_group_init_type_name(&subsys->passthru_group,
791 "passthru", &nvmet_passthru_type);
792 configfs_add_default_group(&subsys->passthru_group,
793 &subsys->group);
794}
795
796#else
797
798static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
799{
800}
801
802#endif
803
804static int nvmet_port_subsys_allow_link(struct config_item *parent,
805 struct config_item *target)
806{
807 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
808 struct nvmet_subsys *subsys;
809 struct nvmet_subsys_link *link, *p;
810 int ret;
811
812 if (target->ci_type != &nvmet_subsys_type) {
813 pr_err("can only link subsystems into the subsystems dir.!\n");
814 return -EINVAL;
815 }
816 subsys = to_subsys(target);
817 link = kmalloc(sizeof(*link), GFP_KERNEL);
818 if (!link)
819 return -ENOMEM;
820 link->subsys = subsys;
821
822 down_write(&nvmet_config_sem);
823 ret = -EEXIST;
824 list_for_each_entry(p, &port->subsystems, entry) {
825 if (p->subsys == subsys)
826 goto out_free_link;
827 }
828
829 if (list_empty(&port->subsystems)) {
830 ret = nvmet_enable_port(port);
831 if (ret)
832 goto out_free_link;
833 }
834
835 list_add_tail(&link->entry, &port->subsystems);
836 nvmet_port_disc_changed(port, subsys);
837
838 up_write(&nvmet_config_sem);
839 return 0;
840
841out_free_link:
842 up_write(&nvmet_config_sem);
843 kfree(link);
844 return ret;
845}
846
847static void nvmet_port_subsys_drop_link(struct config_item *parent,
848 struct config_item *target)
849{
850 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
851 struct nvmet_subsys *subsys = to_subsys(target);
852 struct nvmet_subsys_link *p;
853
854 down_write(&nvmet_config_sem);
855 list_for_each_entry(p, &port->subsystems, entry) {
856 if (p->subsys == subsys)
857 goto found;
858 }
859 up_write(&nvmet_config_sem);
860 return;
861
862found:
863 list_del(&p->entry);
864 nvmet_port_del_ctrls(port, subsys);
865 nvmet_port_disc_changed(port, subsys);
866
867 if (list_empty(&port->subsystems))
868 nvmet_disable_port(port);
869 up_write(&nvmet_config_sem);
870 kfree(p);
871}
872
873static struct configfs_item_operations nvmet_port_subsys_item_ops = {
874 .allow_link = nvmet_port_subsys_allow_link,
875 .drop_link = nvmet_port_subsys_drop_link,
876};
877
878static const struct config_item_type nvmet_port_subsys_type = {
879 .ct_item_ops = &nvmet_port_subsys_item_ops,
880 .ct_owner = THIS_MODULE,
881};
882
883static int nvmet_allowed_hosts_allow_link(struct config_item *parent,
884 struct config_item *target)
885{
886 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
887 struct nvmet_host *host;
888 struct nvmet_host_link *link, *p;
889 int ret;
890
891 if (target->ci_type != &nvmet_host_type) {
892 pr_err("can only link hosts into the allowed_hosts directory!\n");
893 return -EINVAL;
894 }
895
896 host = to_host(target);
897 link = kmalloc(sizeof(*link), GFP_KERNEL);
898 if (!link)
899 return -ENOMEM;
900 link->host = host;
901
902 down_write(&nvmet_config_sem);
903 ret = -EINVAL;
904 if (subsys->allow_any_host) {
905 pr_err("can't add hosts when allow_any_host is set!\n");
906 goto out_free_link;
907 }
908
909 ret = -EEXIST;
910 list_for_each_entry(p, &subsys->hosts, entry) {
911 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
912 goto out_free_link;
913 }
914 list_add_tail(&link->entry, &subsys->hosts);
915 nvmet_subsys_disc_changed(subsys, host);
916
917 up_write(&nvmet_config_sem);
918 return 0;
919out_free_link:
920 up_write(&nvmet_config_sem);
921 kfree(link);
922 return ret;
923}
924
925static void nvmet_allowed_hosts_drop_link(struct config_item *parent,
926 struct config_item *target)
927{
928 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
929 struct nvmet_host *host = to_host(target);
930 struct nvmet_host_link *p;
931
932 down_write(&nvmet_config_sem);
933 list_for_each_entry(p, &subsys->hosts, entry) {
934 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
935 goto found;
936 }
937 up_write(&nvmet_config_sem);
938 return;
939
940found:
941 list_del(&p->entry);
942 nvmet_subsys_disc_changed(subsys, host);
943
944 up_write(&nvmet_config_sem);
945 kfree(p);
946}
947
948static struct configfs_item_operations nvmet_allowed_hosts_item_ops = {
949 .allow_link = nvmet_allowed_hosts_allow_link,
950 .drop_link = nvmet_allowed_hosts_drop_link,
951};
952
953static const struct config_item_type nvmet_allowed_hosts_type = {
954 .ct_item_ops = &nvmet_allowed_hosts_item_ops,
955 .ct_owner = THIS_MODULE,
956};
957
958static ssize_t nvmet_subsys_attr_allow_any_host_show(struct config_item *item,
959 char *page)
960{
961 return snprintf(page, PAGE_SIZE, "%d\n",
962 to_subsys(item)->allow_any_host);
963}
964
965static ssize_t nvmet_subsys_attr_allow_any_host_store(struct config_item *item,
966 const char *page, size_t count)
967{
968 struct nvmet_subsys *subsys = to_subsys(item);
969 bool allow_any_host;
970 int ret = 0;
971
972 if (strtobool(page, &allow_any_host))
973 return -EINVAL;
974
975 down_write(&nvmet_config_sem);
976 if (allow_any_host && !list_empty(&subsys->hosts)) {
977 pr_err("Can't set allow_any_host when explicit hosts are set!\n");
978 ret = -EINVAL;
979 goto out_unlock;
980 }
981
982 if (subsys->allow_any_host != allow_any_host) {
983 subsys->allow_any_host = allow_any_host;
984 nvmet_subsys_disc_changed(subsys, NULL);
985 }
986
987out_unlock:
988 up_write(&nvmet_config_sem);
989 return ret ? ret : count;
990}
991
992CONFIGFS_ATTR(nvmet_subsys_, attr_allow_any_host);
993
994static ssize_t nvmet_subsys_attr_version_show(struct config_item *item,
995 char *page)
996{
997 struct nvmet_subsys *subsys = to_subsys(item);
998
999 if (NVME_TERTIARY(subsys->ver))
1000 return snprintf(page, PAGE_SIZE, "%llu.%llu.%llu\n",
1001 NVME_MAJOR(subsys->ver),
1002 NVME_MINOR(subsys->ver),
1003 NVME_TERTIARY(subsys->ver));
1004
1005 return snprintf(page, PAGE_SIZE, "%llu.%llu\n",
1006 NVME_MAJOR(subsys->ver),
1007 NVME_MINOR(subsys->ver));
1008}
1009
1010static ssize_t
1011nvmet_subsys_attr_version_store_locked(struct nvmet_subsys *subsys,
1012 const char *page, size_t count)
1013{
1014 int major, minor, tertiary = 0;
1015 int ret;
1016
1017 if (subsys->subsys_discovered) {
1018 if (NVME_TERTIARY(subsys->ver))
1019 pr_err("Can't set version number. %llu.%llu.%llu is already assigned\n",
1020 NVME_MAJOR(subsys->ver),
1021 NVME_MINOR(subsys->ver),
1022 NVME_TERTIARY(subsys->ver));
1023 else
1024 pr_err("Can't set version number. %llu.%llu is already assigned\n",
1025 NVME_MAJOR(subsys->ver),
1026 NVME_MINOR(subsys->ver));
1027 return -EINVAL;
1028 }
1029
1030
1031 if (nvmet_passthru_ctrl(subsys))
1032 return -EINVAL;
1033
1034 ret = sscanf(page, "%d.%d.%d\n", &major, &minor, &tertiary);
1035 if (ret != 2 && ret != 3)
1036 return -EINVAL;
1037
1038 subsys->ver = NVME_VS(major, minor, tertiary);
1039
1040 return count;
1041}
1042
1043static ssize_t nvmet_subsys_attr_version_store(struct config_item *item,
1044 const char *page, size_t count)
1045{
1046 struct nvmet_subsys *subsys = to_subsys(item);
1047 ssize_t ret;
1048
1049 down_write(&nvmet_config_sem);
1050 mutex_lock(&subsys->lock);
1051 ret = nvmet_subsys_attr_version_store_locked(subsys, page, count);
1052 mutex_unlock(&subsys->lock);
1053 up_write(&nvmet_config_sem);
1054
1055 return ret;
1056}
1057CONFIGFS_ATTR(nvmet_subsys_, attr_version);
1058
1059
1060static bool nvmet_is_ascii(const char c)
1061{
1062 return c >= 0x20 && c <= 0x7e;
1063}
1064
1065static ssize_t nvmet_subsys_attr_serial_show(struct config_item *item,
1066 char *page)
1067{
1068 struct nvmet_subsys *subsys = to_subsys(item);
1069
1070 return snprintf(page, PAGE_SIZE, "%s\n", subsys->serial);
1071}
1072
1073static ssize_t
1074nvmet_subsys_attr_serial_store_locked(struct nvmet_subsys *subsys,
1075 const char *page, size_t count)
1076{
1077 int pos, len = strcspn(page, "\n");
1078
1079 if (subsys->subsys_discovered) {
1080 pr_err("Can't set serial number. %s is already assigned\n",
1081 subsys->serial);
1082 return -EINVAL;
1083 }
1084
1085 if (!len || len > NVMET_SN_MAX_SIZE) {
1086 pr_err("Serial Number can not be empty or exceed %d Bytes\n",
1087 NVMET_SN_MAX_SIZE);
1088 return -EINVAL;
1089 }
1090
1091 for (pos = 0; pos < len; pos++) {
1092 if (!nvmet_is_ascii(page[pos])) {
1093 pr_err("Serial Number must contain only ASCII strings\n");
1094 return -EINVAL;
1095 }
1096 }
1097
1098 memcpy_and_pad(subsys->serial, NVMET_SN_MAX_SIZE, page, len, ' ');
1099
1100 return count;
1101}
1102
1103static ssize_t nvmet_subsys_attr_serial_store(struct config_item *item,
1104 const char *page, size_t count)
1105{
1106 struct nvmet_subsys *subsys = to_subsys(item);
1107 ssize_t ret;
1108
1109 down_write(&nvmet_config_sem);
1110 mutex_lock(&subsys->lock);
1111 ret = nvmet_subsys_attr_serial_store_locked(subsys, page, count);
1112 mutex_unlock(&subsys->lock);
1113 up_write(&nvmet_config_sem);
1114
1115 return ret;
1116}
1117CONFIGFS_ATTR(nvmet_subsys_, attr_serial);
1118
1119static ssize_t nvmet_subsys_attr_cntlid_min_show(struct config_item *item,
1120 char *page)
1121{
1122 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_min);
1123}
1124
1125static ssize_t nvmet_subsys_attr_cntlid_min_store(struct config_item *item,
1126 const char *page, size_t cnt)
1127{
1128 u16 cntlid_min;
1129
1130 if (sscanf(page, "%hu\n", &cntlid_min) != 1)
1131 return -EINVAL;
1132
1133 if (cntlid_min == 0)
1134 return -EINVAL;
1135
1136 down_write(&nvmet_config_sem);
1137 if (cntlid_min >= to_subsys(item)->cntlid_max)
1138 goto out_unlock;
1139 to_subsys(item)->cntlid_min = cntlid_min;
1140 up_write(&nvmet_config_sem);
1141 return cnt;
1142
1143out_unlock:
1144 up_write(&nvmet_config_sem);
1145 return -EINVAL;
1146}
1147CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_min);
1148
1149static ssize_t nvmet_subsys_attr_cntlid_max_show(struct config_item *item,
1150 char *page)
1151{
1152 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_max);
1153}
1154
1155static ssize_t nvmet_subsys_attr_cntlid_max_store(struct config_item *item,
1156 const char *page, size_t cnt)
1157{
1158 u16 cntlid_max;
1159
1160 if (sscanf(page, "%hu\n", &cntlid_max) != 1)
1161 return -EINVAL;
1162
1163 if (cntlid_max == 0)
1164 return -EINVAL;
1165
1166 down_write(&nvmet_config_sem);
1167 if (cntlid_max <= to_subsys(item)->cntlid_min)
1168 goto out_unlock;
1169 to_subsys(item)->cntlid_max = cntlid_max;
1170 up_write(&nvmet_config_sem);
1171 return cnt;
1172
1173out_unlock:
1174 up_write(&nvmet_config_sem);
1175 return -EINVAL;
1176}
1177CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_max);
1178
1179static ssize_t nvmet_subsys_attr_model_show(struct config_item *item,
1180 char *page)
1181{
1182 struct nvmet_subsys *subsys = to_subsys(item);
1183
1184 return snprintf(page, PAGE_SIZE, "%s\n", subsys->model_number);
1185}
1186
1187static ssize_t nvmet_subsys_attr_model_store_locked(struct nvmet_subsys *subsys,
1188 const char *page, size_t count)
1189{
1190 int pos = 0, len;
1191
1192 if (subsys->subsys_discovered) {
1193 pr_err("Can't set model number. %s is already assigned\n",
1194 subsys->model_number);
1195 return -EINVAL;
1196 }
1197
1198 len = strcspn(page, "\n");
1199 if (!len)
1200 return -EINVAL;
1201
1202 if (len > NVMET_MN_MAX_SIZE) {
1203 pr_err("Model number size can not exceed %d Bytes\n",
1204 NVMET_MN_MAX_SIZE);
1205 return -EINVAL;
1206 }
1207
1208 for (pos = 0; pos < len; pos++) {
1209 if (!nvmet_is_ascii(page[pos]))
1210 return -EINVAL;
1211 }
1212
1213 subsys->model_number = kmemdup_nul(page, len, GFP_KERNEL);
1214 if (!subsys->model_number)
1215 return -ENOMEM;
1216 return count;
1217}
1218
1219static ssize_t nvmet_subsys_attr_model_store(struct config_item *item,
1220 const char *page, size_t count)
1221{
1222 struct nvmet_subsys *subsys = to_subsys(item);
1223 ssize_t ret;
1224
1225 down_write(&nvmet_config_sem);
1226 mutex_lock(&subsys->lock);
1227 ret = nvmet_subsys_attr_model_store_locked(subsys, page, count);
1228 mutex_unlock(&subsys->lock);
1229 up_write(&nvmet_config_sem);
1230
1231 return ret;
1232}
1233CONFIGFS_ATTR(nvmet_subsys_, attr_model);
1234
1235#ifdef CONFIG_BLK_DEV_INTEGRITY
1236static ssize_t nvmet_subsys_attr_pi_enable_show(struct config_item *item,
1237 char *page)
1238{
1239 return snprintf(page, PAGE_SIZE, "%d\n", to_subsys(item)->pi_support);
1240}
1241
1242static ssize_t nvmet_subsys_attr_pi_enable_store(struct config_item *item,
1243 const char *page, size_t count)
1244{
1245 struct nvmet_subsys *subsys = to_subsys(item);
1246 bool pi_enable;
1247
1248 if (strtobool(page, &pi_enable))
1249 return -EINVAL;
1250
1251 subsys->pi_support = pi_enable;
1252 return count;
1253}
1254CONFIGFS_ATTR(nvmet_subsys_, attr_pi_enable);
1255#endif
1256
1257static struct configfs_attribute *nvmet_subsys_attrs[] = {
1258 &nvmet_subsys_attr_attr_allow_any_host,
1259 &nvmet_subsys_attr_attr_version,
1260 &nvmet_subsys_attr_attr_serial,
1261 &nvmet_subsys_attr_attr_cntlid_min,
1262 &nvmet_subsys_attr_attr_cntlid_max,
1263 &nvmet_subsys_attr_attr_model,
1264#ifdef CONFIG_BLK_DEV_INTEGRITY
1265 &nvmet_subsys_attr_attr_pi_enable,
1266#endif
1267 NULL,
1268};
1269
1270
1271
1272
1273static void nvmet_subsys_release(struct config_item *item)
1274{
1275 struct nvmet_subsys *subsys = to_subsys(item);
1276
1277 nvmet_subsys_del_ctrls(subsys);
1278 nvmet_subsys_put(subsys);
1279}
1280
1281static struct configfs_item_operations nvmet_subsys_item_ops = {
1282 .release = nvmet_subsys_release,
1283};
1284
1285static const struct config_item_type nvmet_subsys_type = {
1286 .ct_item_ops = &nvmet_subsys_item_ops,
1287 .ct_attrs = nvmet_subsys_attrs,
1288 .ct_owner = THIS_MODULE,
1289};
1290
1291static struct config_group *nvmet_subsys_make(struct config_group *group,
1292 const char *name)
1293{
1294 struct nvmet_subsys *subsys;
1295
1296 if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
1297 pr_err("can't create discovery subsystem through configfs\n");
1298 return ERR_PTR(-EINVAL);
1299 }
1300
1301 subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
1302 if (IS_ERR(subsys))
1303 return ERR_CAST(subsys);
1304
1305 config_group_init_type_name(&subsys->group, name, &nvmet_subsys_type);
1306
1307 config_group_init_type_name(&subsys->namespaces_group,
1308 "namespaces", &nvmet_namespaces_type);
1309 configfs_add_default_group(&subsys->namespaces_group, &subsys->group);
1310
1311 config_group_init_type_name(&subsys->allowed_hosts_group,
1312 "allowed_hosts", &nvmet_allowed_hosts_type);
1313 configfs_add_default_group(&subsys->allowed_hosts_group,
1314 &subsys->group);
1315
1316 nvmet_add_passthru_group(subsys);
1317
1318 return &subsys->group;
1319}
1320
1321static struct configfs_group_operations nvmet_subsystems_group_ops = {
1322 .make_group = nvmet_subsys_make,
1323};
1324
1325static const struct config_item_type nvmet_subsystems_type = {
1326 .ct_group_ops = &nvmet_subsystems_group_ops,
1327 .ct_owner = THIS_MODULE,
1328};
1329
1330static ssize_t nvmet_referral_enable_show(struct config_item *item,
1331 char *page)
1332{
1333 return snprintf(page, PAGE_SIZE, "%d\n", to_nvmet_port(item)->enabled);
1334}
1335
1336static ssize_t nvmet_referral_enable_store(struct config_item *item,
1337 const char *page, size_t count)
1338{
1339 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1340 struct nvmet_port *port = to_nvmet_port(item);
1341 bool enable;
1342
1343 if (strtobool(page, &enable))
1344 goto inval;
1345
1346 if (enable)
1347 nvmet_referral_enable(parent, port);
1348 else
1349 nvmet_referral_disable(parent, port);
1350
1351 return count;
1352inval:
1353 pr_err("Invalid value '%s' for enable\n", page);
1354 return -EINVAL;
1355}
1356
1357CONFIGFS_ATTR(nvmet_referral_, enable);
1358
1359
1360
1361
1362static struct configfs_attribute *nvmet_referral_attrs[] = {
1363 &nvmet_attr_addr_adrfam,
1364 &nvmet_attr_addr_portid,
1365 &nvmet_attr_addr_treq,
1366 &nvmet_attr_addr_traddr,
1367 &nvmet_attr_addr_trsvcid,
1368 &nvmet_attr_addr_trtype,
1369 &nvmet_referral_attr_enable,
1370 NULL,
1371};
1372
1373static void nvmet_referral_notify(struct config_group *group,
1374 struct config_item *item)
1375{
1376 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1377 struct nvmet_port *port = to_nvmet_port(item);
1378
1379 nvmet_referral_disable(parent, port);
1380}
1381
1382static void nvmet_referral_release(struct config_item *item)
1383{
1384 struct nvmet_port *port = to_nvmet_port(item);
1385
1386 kfree(port);
1387}
1388
1389static struct configfs_item_operations nvmet_referral_item_ops = {
1390 .release = nvmet_referral_release,
1391};
1392
1393static const struct config_item_type nvmet_referral_type = {
1394 .ct_owner = THIS_MODULE,
1395 .ct_attrs = nvmet_referral_attrs,
1396 .ct_item_ops = &nvmet_referral_item_ops,
1397};
1398
1399static struct config_group *nvmet_referral_make(
1400 struct config_group *group, const char *name)
1401{
1402 struct nvmet_port *port;
1403
1404 port = kzalloc(sizeof(*port), GFP_KERNEL);
1405 if (!port)
1406 return ERR_PTR(-ENOMEM);
1407
1408 INIT_LIST_HEAD(&port->entry);
1409 config_group_init_type_name(&port->group, name, &nvmet_referral_type);
1410
1411 return &port->group;
1412}
1413
1414static struct configfs_group_operations nvmet_referral_group_ops = {
1415 .make_group = nvmet_referral_make,
1416 .disconnect_notify = nvmet_referral_notify,
1417};
1418
1419static const struct config_item_type nvmet_referrals_type = {
1420 .ct_owner = THIS_MODULE,
1421 .ct_group_ops = &nvmet_referral_group_ops,
1422};
1423
1424static struct nvmet_type_name_map nvmet_ana_state[] = {
1425 { NVME_ANA_OPTIMIZED, "optimized" },
1426 { NVME_ANA_NONOPTIMIZED, "non-optimized" },
1427 { NVME_ANA_INACCESSIBLE, "inaccessible" },
1428 { NVME_ANA_PERSISTENT_LOSS, "persistent-loss" },
1429 { NVME_ANA_CHANGE, "change" },
1430};
1431
1432static ssize_t nvmet_ana_group_ana_state_show(struct config_item *item,
1433 char *page)
1434{
1435 struct nvmet_ana_group *grp = to_ana_group(item);
1436 enum nvme_ana_state state = grp->port->ana_state[grp->grpid];
1437 int i;
1438
1439 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1440 if (state == nvmet_ana_state[i].type)
1441 return sprintf(page, "%s\n", nvmet_ana_state[i].name);
1442 }
1443
1444 return sprintf(page, "\n");
1445}
1446
1447static ssize_t nvmet_ana_group_ana_state_store(struct config_item *item,
1448 const char *page, size_t count)
1449{
1450 struct nvmet_ana_group *grp = to_ana_group(item);
1451 enum nvme_ana_state *ana_state = grp->port->ana_state;
1452 int i;
1453
1454 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1455 if (sysfs_streq(page, nvmet_ana_state[i].name))
1456 goto found;
1457 }
1458
1459 pr_err("Invalid value '%s' for ana_state\n", page);
1460 return -EINVAL;
1461
1462found:
1463 down_write(&nvmet_ana_sem);
1464 ana_state[grp->grpid] = (enum nvme_ana_state) nvmet_ana_state[i].type;
1465 nvmet_ana_chgcnt++;
1466 up_write(&nvmet_ana_sem);
1467 nvmet_port_send_ana_event(grp->port);
1468 return count;
1469}
1470
1471CONFIGFS_ATTR(nvmet_ana_group_, ana_state);
1472
1473static struct configfs_attribute *nvmet_ana_group_attrs[] = {
1474 &nvmet_ana_group_attr_ana_state,
1475 NULL,
1476};
1477
1478static void nvmet_ana_group_release(struct config_item *item)
1479{
1480 struct nvmet_ana_group *grp = to_ana_group(item);
1481
1482 if (grp == &grp->port->ana_default_group)
1483 return;
1484
1485 down_write(&nvmet_ana_sem);
1486 grp->port->ana_state[grp->grpid] = NVME_ANA_INACCESSIBLE;
1487 nvmet_ana_group_enabled[grp->grpid]--;
1488 up_write(&nvmet_ana_sem);
1489
1490 nvmet_port_send_ana_event(grp->port);
1491 kfree(grp);
1492}
1493
1494static struct configfs_item_operations nvmet_ana_group_item_ops = {
1495 .release = nvmet_ana_group_release,
1496};
1497
1498static const struct config_item_type nvmet_ana_group_type = {
1499 .ct_item_ops = &nvmet_ana_group_item_ops,
1500 .ct_attrs = nvmet_ana_group_attrs,
1501 .ct_owner = THIS_MODULE,
1502};
1503
1504static struct config_group *nvmet_ana_groups_make_group(
1505 struct config_group *group, const char *name)
1506{
1507 struct nvmet_port *port = ana_groups_to_port(&group->cg_item);
1508 struct nvmet_ana_group *grp;
1509 u32 grpid;
1510 int ret;
1511
1512 ret = kstrtou32(name, 0, &grpid);
1513 if (ret)
1514 goto out;
1515
1516 ret = -EINVAL;
1517 if (grpid <= 1 || grpid > NVMET_MAX_ANAGRPS)
1518 goto out;
1519
1520 ret = -ENOMEM;
1521 grp = kzalloc(sizeof(*grp), GFP_KERNEL);
1522 if (!grp)
1523 goto out;
1524 grp->port = port;
1525 grp->grpid = grpid;
1526
1527 down_write(&nvmet_ana_sem);
1528 nvmet_ana_group_enabled[grpid]++;
1529 up_write(&nvmet_ana_sem);
1530
1531 nvmet_port_send_ana_event(grp->port);
1532
1533 config_group_init_type_name(&grp->group, name, &nvmet_ana_group_type);
1534 return &grp->group;
1535out:
1536 return ERR_PTR(ret);
1537}
1538
1539static struct configfs_group_operations nvmet_ana_groups_group_ops = {
1540 .make_group = nvmet_ana_groups_make_group,
1541};
1542
1543static const struct config_item_type nvmet_ana_groups_type = {
1544 .ct_group_ops = &nvmet_ana_groups_group_ops,
1545 .ct_owner = THIS_MODULE,
1546};
1547
1548
1549
1550
1551static void nvmet_port_release(struct config_item *item)
1552{
1553 struct nvmet_port *port = to_nvmet_port(item);
1554
1555 list_del(&port->global_entry);
1556
1557 kfree(port->ana_state);
1558 kfree(port);
1559}
1560
1561static struct configfs_attribute *nvmet_port_attrs[] = {
1562 &nvmet_attr_addr_adrfam,
1563 &nvmet_attr_addr_treq,
1564 &nvmet_attr_addr_traddr,
1565 &nvmet_attr_addr_trsvcid,
1566 &nvmet_attr_addr_trtype,
1567 &nvmet_attr_param_inline_data_size,
1568#ifdef CONFIG_BLK_DEV_INTEGRITY
1569 &nvmet_attr_param_pi_enable,
1570#endif
1571 NULL,
1572};
1573
1574static struct configfs_item_operations nvmet_port_item_ops = {
1575 .release = nvmet_port_release,
1576};
1577
1578static const struct config_item_type nvmet_port_type = {
1579 .ct_attrs = nvmet_port_attrs,
1580 .ct_item_ops = &nvmet_port_item_ops,
1581 .ct_owner = THIS_MODULE,
1582};
1583
1584static struct config_group *nvmet_ports_make(struct config_group *group,
1585 const char *name)
1586{
1587 struct nvmet_port *port;
1588 u16 portid;
1589 u32 i;
1590
1591 if (kstrtou16(name, 0, &portid))
1592 return ERR_PTR(-EINVAL);
1593
1594 port = kzalloc(sizeof(*port), GFP_KERNEL);
1595 if (!port)
1596 return ERR_PTR(-ENOMEM);
1597
1598 port->ana_state = kcalloc(NVMET_MAX_ANAGRPS + 1,
1599 sizeof(*port->ana_state), GFP_KERNEL);
1600 if (!port->ana_state) {
1601 kfree(port);
1602 return ERR_PTR(-ENOMEM);
1603 }
1604
1605 for (i = 1; i <= NVMET_MAX_ANAGRPS; i++) {
1606 if (i == NVMET_DEFAULT_ANA_GRPID)
1607 port->ana_state[1] = NVME_ANA_OPTIMIZED;
1608 else
1609 port->ana_state[i] = NVME_ANA_INACCESSIBLE;
1610 }
1611
1612 list_add(&port->global_entry, &nvmet_ports_list);
1613
1614 INIT_LIST_HEAD(&port->entry);
1615 INIT_LIST_HEAD(&port->subsystems);
1616 INIT_LIST_HEAD(&port->referrals);
1617 port->inline_data_size = -1;
1618
1619 port->disc_addr.portid = cpu_to_le16(portid);
1620 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_MAX;
1621 port->disc_addr.treq = NVMF_TREQ_DISABLE_SQFLOW;
1622 config_group_init_type_name(&port->group, name, &nvmet_port_type);
1623
1624 config_group_init_type_name(&port->subsys_group,
1625 "subsystems", &nvmet_port_subsys_type);
1626 configfs_add_default_group(&port->subsys_group, &port->group);
1627
1628 config_group_init_type_name(&port->referrals_group,
1629 "referrals", &nvmet_referrals_type);
1630 configfs_add_default_group(&port->referrals_group, &port->group);
1631
1632 config_group_init_type_name(&port->ana_groups_group,
1633 "ana_groups", &nvmet_ana_groups_type);
1634 configfs_add_default_group(&port->ana_groups_group, &port->group);
1635
1636 port->ana_default_group.port = port;
1637 port->ana_default_group.grpid = NVMET_DEFAULT_ANA_GRPID;
1638 config_group_init_type_name(&port->ana_default_group.group,
1639 __stringify(NVMET_DEFAULT_ANA_GRPID),
1640 &nvmet_ana_group_type);
1641 configfs_add_default_group(&port->ana_default_group.group,
1642 &port->ana_groups_group);
1643
1644 return &port->group;
1645}
1646
1647static struct configfs_group_operations nvmet_ports_group_ops = {
1648 .make_group = nvmet_ports_make,
1649};
1650
1651static const struct config_item_type nvmet_ports_type = {
1652 .ct_group_ops = &nvmet_ports_group_ops,
1653 .ct_owner = THIS_MODULE,
1654};
1655
1656static struct config_group nvmet_subsystems_group;
1657static struct config_group nvmet_ports_group;
1658
1659static void nvmet_host_release(struct config_item *item)
1660{
1661 struct nvmet_host *host = to_host(item);
1662
1663 kfree(host);
1664}
1665
1666static struct configfs_item_operations nvmet_host_item_ops = {
1667 .release = nvmet_host_release,
1668};
1669
1670static const struct config_item_type nvmet_host_type = {
1671 .ct_item_ops = &nvmet_host_item_ops,
1672 .ct_owner = THIS_MODULE,
1673};
1674
1675static struct config_group *nvmet_hosts_make_group(struct config_group *group,
1676 const char *name)
1677{
1678 struct nvmet_host *host;
1679
1680 host = kzalloc(sizeof(*host), GFP_KERNEL);
1681 if (!host)
1682 return ERR_PTR(-ENOMEM);
1683
1684 config_group_init_type_name(&host->group, name, &nvmet_host_type);
1685
1686 return &host->group;
1687}
1688
1689static struct configfs_group_operations nvmet_hosts_group_ops = {
1690 .make_group = nvmet_hosts_make_group,
1691};
1692
1693static const struct config_item_type nvmet_hosts_type = {
1694 .ct_group_ops = &nvmet_hosts_group_ops,
1695 .ct_owner = THIS_MODULE,
1696};
1697
1698static struct config_group nvmet_hosts_group;
1699
1700static const struct config_item_type nvmet_root_type = {
1701 .ct_owner = THIS_MODULE,
1702};
1703
1704static struct configfs_subsystem nvmet_configfs_subsystem = {
1705 .su_group = {
1706 .cg_item = {
1707 .ci_namebuf = "nvmet",
1708 .ci_type = &nvmet_root_type,
1709 },
1710 },
1711};
1712
1713int __init nvmet_init_configfs(void)
1714{
1715 int ret;
1716
1717 config_group_init(&nvmet_configfs_subsystem.su_group);
1718 mutex_init(&nvmet_configfs_subsystem.su_mutex);
1719
1720 config_group_init_type_name(&nvmet_subsystems_group,
1721 "subsystems", &nvmet_subsystems_type);
1722 configfs_add_default_group(&nvmet_subsystems_group,
1723 &nvmet_configfs_subsystem.su_group);
1724
1725 config_group_init_type_name(&nvmet_ports_group,
1726 "ports", &nvmet_ports_type);
1727 configfs_add_default_group(&nvmet_ports_group,
1728 &nvmet_configfs_subsystem.su_group);
1729
1730 config_group_init_type_name(&nvmet_hosts_group,
1731 "hosts", &nvmet_hosts_type);
1732 configfs_add_default_group(&nvmet_hosts_group,
1733 &nvmet_configfs_subsystem.su_group);
1734
1735 ret = configfs_register_subsystem(&nvmet_configfs_subsystem);
1736 if (ret) {
1737 pr_err("configfs_register_subsystem: %d\n", ret);
1738 return ret;
1739 }
1740
1741 return 0;
1742}
1743
1744void __exit nvmet_exit_configfs(void)
1745{
1746 configfs_unregister_subsystem(&nvmet_configfs_subsystem);
1747}
1748