1 // SPDX-License-Identifier: GPL-2.0
3 * Configfs interface for the NVMe target.
4 * Copyright (c) 2015-2016 HGST, a Western Digital Company.
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>
17 static const struct config_item_type nvmet_host_type;
18 static const struct config_item_type nvmet_subsys_type;
20 static LIST_HEAD(nvmet_ports_list);
21 struct list_head *nvmet_ports = &nvmet_ports_list;
23 struct nvmet_type_name_map {
28 static 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" },
35 static 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" },
44 static bool nvmet_is_port_enabled(struct nvmet_port *p, const char *caller)
47 pr_err("Disable port '%u' before changing attribute in %s\n",
48 le16_to_cpu(p->disc_addr.portid), caller);
53 * nvmet_port Generic ConfigFS definitions.
54 * Used in any place in the ConfigFS tree that refers to an address.
56 static ssize_t nvmet_addr_adrfam_show(struct config_item *item, char *page)
58 u8 adrfam = to_nvmet_port(item)->disc_addr.adrfam;
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);
66 return sprintf(page, "\n");
69 static ssize_t nvmet_addr_adrfam_store(struct config_item *item,
70 const char *page, size_t count)
72 struct nvmet_port *port = to_nvmet_port(item);
75 if (nvmet_is_port_enabled(port, __func__))
78 for (i = 1; i < ARRAY_SIZE(nvmet_addr_family); i++) {
79 if (sysfs_streq(page, nvmet_addr_family[i].name))
83 pr_err("Invalid value '%s' for adrfam\n", page);
87 port->disc_addr.adrfam = nvmet_addr_family[i].type;
91 CONFIGFS_ATTR(nvmet_, addr_adrfam);
93 static ssize_t nvmet_addr_portid_show(struct config_item *item,
96 struct nvmet_port *port = to_nvmet_port(item);
98 return snprintf(page, PAGE_SIZE, "%d\n",
99 le16_to_cpu(port->disc_addr.portid));
102 static ssize_t nvmet_addr_portid_store(struct config_item *item,
103 const char *page, size_t count)
105 struct nvmet_port *port = to_nvmet_port(item);
108 if (kstrtou16(page, 0, &portid)) {
109 pr_err("Invalid value '%s' for portid\n", page);
113 if (nvmet_is_port_enabled(port, __func__))
116 port->disc_addr.portid = cpu_to_le16(portid);
120 CONFIGFS_ATTR(nvmet_, addr_portid);
122 static ssize_t nvmet_addr_traddr_show(struct config_item *item,
125 struct nvmet_port *port = to_nvmet_port(item);
127 return snprintf(page, PAGE_SIZE, "%s\n",
128 port->disc_addr.traddr);
131 static ssize_t nvmet_addr_traddr_store(struct config_item *item,
132 const char *page, size_t count)
134 struct nvmet_port *port = to_nvmet_port(item);
136 if (count > NVMF_TRADDR_SIZE) {
137 pr_err("Invalid value '%s' for traddr\n", page);
141 if (nvmet_is_port_enabled(port, __func__))
144 if (sscanf(page, "%s\n", port->disc_addr.traddr) != 1)
149 CONFIGFS_ATTR(nvmet_, addr_traddr);
151 static 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" },
157 static ssize_t nvmet_addr_treq_show(struct config_item *item, char *page)
159 u8 treq = to_nvmet_port(item)->disc_addr.treq &
160 NVME_TREQ_SECURE_CHANNEL_MASK;
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);
168 return sprintf(page, "\n");
171 static ssize_t nvmet_addr_treq_store(struct config_item *item,
172 const char *page, size_t count)
174 struct nvmet_port *port = to_nvmet_port(item);
175 u8 treq = port->disc_addr.treq & ~NVME_TREQ_SECURE_CHANNEL_MASK;
178 if (nvmet_is_port_enabled(port, __func__))
181 for (i = 0; i < ARRAY_SIZE(nvmet_addr_treq); i++) {
182 if (sysfs_streq(page, nvmet_addr_treq[i].name))
186 pr_err("Invalid value '%s' for treq\n", page);
190 treq |= nvmet_addr_treq[i].type;
191 port->disc_addr.treq = treq;
195 CONFIGFS_ATTR(nvmet_, addr_treq);
197 static ssize_t nvmet_addr_trsvcid_show(struct config_item *item,
200 struct nvmet_port *port = to_nvmet_port(item);
202 return snprintf(page, PAGE_SIZE, "%s\n",
203 port->disc_addr.trsvcid);
206 static ssize_t nvmet_addr_trsvcid_store(struct config_item *item,
207 const char *page, size_t count)
209 struct nvmet_port *port = to_nvmet_port(item);
211 if (count > NVMF_TRSVCID_SIZE) {
212 pr_err("Invalid value '%s' for trsvcid\n", page);
215 if (nvmet_is_port_enabled(port, __func__))
218 if (sscanf(page, "%s\n", port->disc_addr.trsvcid) != 1)
223 CONFIGFS_ATTR(nvmet_, addr_trsvcid);
225 static ssize_t nvmet_param_inline_data_size_show(struct config_item *item,
228 struct nvmet_port *port = to_nvmet_port(item);
230 return snprintf(page, PAGE_SIZE, "%d\n", port->inline_data_size);
233 static ssize_t nvmet_param_inline_data_size_store(struct config_item *item,
234 const char *page, size_t count)
236 struct nvmet_port *port = to_nvmet_port(item);
239 if (nvmet_is_port_enabled(port, __func__))
241 ret = kstrtoint(page, 0, &port->inline_data_size);
243 pr_err("Invalid value '%s' for inline_data_size\n", page);
249 CONFIGFS_ATTR(nvmet_, param_inline_data_size);
251 #ifdef CONFIG_BLK_DEV_INTEGRITY
252 static ssize_t nvmet_param_pi_enable_show(struct config_item *item,
255 struct nvmet_port *port = to_nvmet_port(item);
257 return snprintf(page, PAGE_SIZE, "%d\n", port->pi_enable);
260 static ssize_t nvmet_param_pi_enable_store(struct config_item *item,
261 const char *page, size_t count)
263 struct nvmet_port *port = to_nvmet_port(item);
266 if (strtobool(page, &val))
270 pr_err("Disable port before setting pi_enable value.\n");
274 port->pi_enable = val;
278 CONFIGFS_ATTR(nvmet_, param_pi_enable);
281 static ssize_t nvmet_addr_trtype_show(struct config_item *item,
284 struct nvmet_port *port = to_nvmet_port(item);
287 for (i = 0; i < ARRAY_SIZE(nvmet_transport); i++) {
288 if (port->disc_addr.trtype == nvmet_transport[i].type)
289 return sprintf(page, "%s\n", nvmet_transport[i].name);
292 return sprintf(page, "\n");
295 static void nvmet_port_init_tsas_rdma(struct nvmet_port *port)
297 port->disc_addr.tsas.rdma.qptype = NVMF_RDMA_QPTYPE_CONNECTED;
298 port->disc_addr.tsas.rdma.prtype = NVMF_RDMA_PRTYPE_NOT_SPECIFIED;
299 port->disc_addr.tsas.rdma.cms = NVMF_RDMA_CMS_RDMA_CM;
302 static ssize_t nvmet_addr_trtype_store(struct config_item *item,
303 const char *page, size_t count)
305 struct nvmet_port *port = to_nvmet_port(item);
308 if (nvmet_is_port_enabled(port, __func__))
311 for (i = 0; i < ARRAY_SIZE(nvmet_transport); i++) {
312 if (sysfs_streq(page, nvmet_transport[i].name))
316 pr_err("Invalid value '%s' for trtype\n", page);
320 memset(&port->disc_addr.tsas, 0, NVMF_TSAS_SIZE);
321 port->disc_addr.trtype = nvmet_transport[i].type;
322 if (port->disc_addr.trtype == NVMF_TRTYPE_RDMA)
323 nvmet_port_init_tsas_rdma(port);
327 CONFIGFS_ATTR(nvmet_, addr_trtype);
330 * Namespace structures & file operation functions below
332 static ssize_t nvmet_ns_device_path_show(struct config_item *item, char *page)
334 return sprintf(page, "%s\n", to_nvmet_ns(item)->device_path);
337 static ssize_t nvmet_ns_device_path_store(struct config_item *item,
338 const char *page, size_t count)
340 struct nvmet_ns *ns = to_nvmet_ns(item);
341 struct nvmet_subsys *subsys = ns->subsys;
345 mutex_lock(&subsys->lock);
351 len = strcspn(page, "\n");
355 kfree(ns->device_path);
357 ns->device_path = kmemdup_nul(page, len, GFP_KERNEL);
358 if (!ns->device_path)
361 mutex_unlock(&subsys->lock);
365 mutex_unlock(&subsys->lock);
369 CONFIGFS_ATTR(nvmet_ns_, device_path);
371 #ifdef CONFIG_PCI_P2PDMA
372 static ssize_t nvmet_ns_p2pmem_show(struct config_item *item, char *page)
374 struct nvmet_ns *ns = to_nvmet_ns(item);
376 return pci_p2pdma_enable_show(page, ns->p2p_dev, ns->use_p2pmem);
379 static ssize_t nvmet_ns_p2pmem_store(struct config_item *item,
380 const char *page, size_t count)
382 struct nvmet_ns *ns = to_nvmet_ns(item);
383 struct pci_dev *p2p_dev = NULL;
388 mutex_lock(&ns->subsys->lock);
394 error = pci_p2pdma_enable_store(page, &p2p_dev, &use_p2pmem);
400 ns->use_p2pmem = use_p2pmem;
401 pci_dev_put(ns->p2p_dev);
402 ns->p2p_dev = p2p_dev;
405 mutex_unlock(&ns->subsys->lock);
410 CONFIGFS_ATTR(nvmet_ns_, p2pmem);
411 #endif /* CONFIG_PCI_P2PDMA */
413 static ssize_t nvmet_ns_device_uuid_show(struct config_item *item, char *page)
415 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->uuid);
418 static ssize_t nvmet_ns_device_uuid_store(struct config_item *item,
419 const char *page, size_t count)
421 struct nvmet_ns *ns = to_nvmet_ns(item);
422 struct nvmet_subsys *subsys = ns->subsys;
425 mutex_lock(&subsys->lock);
431 if (uuid_parse(page, &ns->uuid))
435 mutex_unlock(&subsys->lock);
436 return ret ? ret : count;
439 CONFIGFS_ATTR(nvmet_ns_, device_uuid);
441 static ssize_t nvmet_ns_device_nguid_show(struct config_item *item, char *page)
443 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->nguid);
446 static ssize_t nvmet_ns_device_nguid_store(struct config_item *item,
447 const char *page, size_t count)
449 struct nvmet_ns *ns = to_nvmet_ns(item);
450 struct nvmet_subsys *subsys = ns->subsys;
452 const char *p = page;
456 mutex_lock(&subsys->lock);
462 for (i = 0; i < 16; i++) {
463 if (p + 2 > page + count) {
467 if (!isxdigit(p[0]) || !isxdigit(p[1])) {
472 nguid[i] = (hex_to_bin(p[0]) << 4) | hex_to_bin(p[1]);
475 if (*p == '-' || *p == ':')
479 memcpy(&ns->nguid, nguid, sizeof(nguid));
481 mutex_unlock(&subsys->lock);
482 return ret ? ret : count;
485 CONFIGFS_ATTR(nvmet_ns_, device_nguid);
487 static ssize_t nvmet_ns_ana_grpid_show(struct config_item *item, char *page)
489 return sprintf(page, "%u\n", to_nvmet_ns(item)->anagrpid);
492 static ssize_t nvmet_ns_ana_grpid_store(struct config_item *item,
493 const char *page, size_t count)
495 struct nvmet_ns *ns = to_nvmet_ns(item);
496 u32 oldgrpid, newgrpid;
499 ret = kstrtou32(page, 0, &newgrpid);
503 if (newgrpid < 1 || newgrpid > NVMET_MAX_ANAGRPS)
506 down_write(&nvmet_ana_sem);
507 oldgrpid = ns->anagrpid;
508 nvmet_ana_group_enabled[newgrpid]++;
509 ns->anagrpid = newgrpid;
510 nvmet_ana_group_enabled[oldgrpid]--;
512 up_write(&nvmet_ana_sem);
514 nvmet_send_ana_event(ns->subsys, NULL);
518 CONFIGFS_ATTR(nvmet_ns_, ana_grpid);
520 static ssize_t nvmet_ns_enable_show(struct config_item *item, char *page)
522 return sprintf(page, "%d\n", to_nvmet_ns(item)->enabled);
525 static ssize_t nvmet_ns_enable_store(struct config_item *item,
526 const char *page, size_t count)
528 struct nvmet_ns *ns = to_nvmet_ns(item);
532 if (strtobool(page, &enable))
536 ret = nvmet_ns_enable(ns);
538 nvmet_ns_disable(ns);
540 return ret ? ret : count;
543 CONFIGFS_ATTR(nvmet_ns_, enable);
545 static ssize_t nvmet_ns_buffered_io_show(struct config_item *item, char *page)
547 return sprintf(page, "%d\n", to_nvmet_ns(item)->buffered_io);
550 static ssize_t nvmet_ns_buffered_io_store(struct config_item *item,
551 const char *page, size_t count)
553 struct nvmet_ns *ns = to_nvmet_ns(item);
556 if (strtobool(page, &val))
559 mutex_lock(&ns->subsys->lock);
561 pr_err("disable ns before setting buffered_io value.\n");
562 mutex_unlock(&ns->subsys->lock);
566 ns->buffered_io = val;
567 mutex_unlock(&ns->subsys->lock);
571 CONFIGFS_ATTR(nvmet_ns_, buffered_io);
573 static ssize_t nvmet_ns_revalidate_size_store(struct config_item *item,
574 const char *page, size_t count)
576 struct nvmet_ns *ns = to_nvmet_ns(item);
579 if (strtobool(page, &val))
585 mutex_lock(&ns->subsys->lock);
587 pr_err("enable ns before revalidate.\n");
588 mutex_unlock(&ns->subsys->lock);
591 nvmet_ns_revalidate(ns);
592 mutex_unlock(&ns->subsys->lock);
596 CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
598 static struct configfs_attribute *nvmet_ns_attrs[] = {
599 &nvmet_ns_attr_device_path,
600 &nvmet_ns_attr_device_nguid,
601 &nvmet_ns_attr_device_uuid,
602 &nvmet_ns_attr_ana_grpid,
603 &nvmet_ns_attr_enable,
604 &nvmet_ns_attr_buffered_io,
605 &nvmet_ns_attr_revalidate_size,
606 #ifdef CONFIG_PCI_P2PDMA
607 &nvmet_ns_attr_p2pmem,
612 static void nvmet_ns_release(struct config_item *item)
614 struct nvmet_ns *ns = to_nvmet_ns(item);
619 static struct configfs_item_operations nvmet_ns_item_ops = {
620 .release = nvmet_ns_release,
623 static const struct config_item_type nvmet_ns_type = {
624 .ct_item_ops = &nvmet_ns_item_ops,
625 .ct_attrs = nvmet_ns_attrs,
626 .ct_owner = THIS_MODULE,
629 static struct config_group *nvmet_ns_make(struct config_group *group,
632 struct nvmet_subsys *subsys = namespaces_to_subsys(&group->cg_item);
637 ret = kstrtou32(name, 0, &nsid);
642 if (nsid == 0 || nsid == NVME_NSID_ALL) {
643 pr_err("invalid nsid %#x", nsid);
648 ns = nvmet_ns_alloc(subsys, nsid);
651 config_group_init_type_name(&ns->group, name, &nvmet_ns_type);
653 pr_info("adding nsid %d to subsystem %s\n", nsid, subsys->subsysnqn);
660 static struct configfs_group_operations nvmet_namespaces_group_ops = {
661 .make_group = nvmet_ns_make,
664 static const struct config_item_type nvmet_namespaces_type = {
665 .ct_group_ops = &nvmet_namespaces_group_ops,
666 .ct_owner = THIS_MODULE,
669 #ifdef CONFIG_NVME_TARGET_PASSTHRU
671 static ssize_t nvmet_passthru_device_path_show(struct config_item *item,
674 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
676 return snprintf(page, PAGE_SIZE, "%s\n", subsys->passthru_ctrl_path);
679 static ssize_t nvmet_passthru_device_path_store(struct config_item *item,
680 const char *page, size_t count)
682 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
686 mutex_lock(&subsys->lock);
689 if (subsys->passthru_ctrl)
693 len = strcspn(page, "\n");
697 kfree(subsys->passthru_ctrl_path);
699 subsys->passthru_ctrl_path = kstrndup(page, len, GFP_KERNEL);
700 if (!subsys->passthru_ctrl_path)
703 mutex_unlock(&subsys->lock);
707 mutex_unlock(&subsys->lock);
710 CONFIGFS_ATTR(nvmet_passthru_, device_path);
712 static ssize_t nvmet_passthru_enable_show(struct config_item *item,
715 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
717 return sprintf(page, "%d\n", subsys->passthru_ctrl ? 1 : 0);
720 static ssize_t nvmet_passthru_enable_store(struct config_item *item,
721 const char *page, size_t count)
723 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
727 if (strtobool(page, &enable))
731 ret = nvmet_passthru_ctrl_enable(subsys);
733 nvmet_passthru_ctrl_disable(subsys);
735 return ret ? ret : count;
737 CONFIGFS_ATTR(nvmet_passthru_, enable);
739 static struct configfs_attribute *nvmet_passthru_attrs[] = {
740 &nvmet_passthru_attr_device_path,
741 &nvmet_passthru_attr_enable,
745 static const struct config_item_type nvmet_passthru_type = {
746 .ct_attrs = nvmet_passthru_attrs,
747 .ct_owner = THIS_MODULE,
750 static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
752 config_group_init_type_name(&subsys->passthru_group,
753 "passthru", &nvmet_passthru_type);
754 configfs_add_default_group(&subsys->passthru_group,
758 #else /* CONFIG_NVME_TARGET_PASSTHRU */
760 static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
764 #endif /* CONFIG_NVME_TARGET_PASSTHRU */
766 static int nvmet_port_subsys_allow_link(struct config_item *parent,
767 struct config_item *target)
769 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
770 struct nvmet_subsys *subsys;
771 struct nvmet_subsys_link *link, *p;
774 if (target->ci_type != &nvmet_subsys_type) {
775 pr_err("can only link subsystems into the subsystems dir.!\n");
778 subsys = to_subsys(target);
779 link = kmalloc(sizeof(*link), GFP_KERNEL);
782 link->subsys = subsys;
784 down_write(&nvmet_config_sem);
786 list_for_each_entry(p, &port->subsystems, entry) {
787 if (p->subsys == subsys)
791 if (list_empty(&port->subsystems)) {
792 ret = nvmet_enable_port(port);
797 list_add_tail(&link->entry, &port->subsystems);
798 nvmet_port_disc_changed(port, subsys);
800 up_write(&nvmet_config_sem);
804 up_write(&nvmet_config_sem);
809 static void nvmet_port_subsys_drop_link(struct config_item *parent,
810 struct config_item *target)
812 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
813 struct nvmet_subsys *subsys = to_subsys(target);
814 struct nvmet_subsys_link *p;
816 down_write(&nvmet_config_sem);
817 list_for_each_entry(p, &port->subsystems, entry) {
818 if (p->subsys == subsys)
821 up_write(&nvmet_config_sem);
826 nvmet_port_del_ctrls(port, subsys);
827 nvmet_port_disc_changed(port, subsys);
829 if (list_empty(&port->subsystems))
830 nvmet_disable_port(port);
831 up_write(&nvmet_config_sem);
835 static struct configfs_item_operations nvmet_port_subsys_item_ops = {
836 .allow_link = nvmet_port_subsys_allow_link,
837 .drop_link = nvmet_port_subsys_drop_link,
840 static const struct config_item_type nvmet_port_subsys_type = {
841 .ct_item_ops = &nvmet_port_subsys_item_ops,
842 .ct_owner = THIS_MODULE,
845 static int nvmet_allowed_hosts_allow_link(struct config_item *parent,
846 struct config_item *target)
848 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
849 struct nvmet_host *host;
850 struct nvmet_host_link *link, *p;
853 if (target->ci_type != &nvmet_host_type) {
854 pr_err("can only link hosts into the allowed_hosts directory!\n");
858 host = to_host(target);
859 link = kmalloc(sizeof(*link), GFP_KERNEL);
864 down_write(&nvmet_config_sem);
866 if (subsys->allow_any_host) {
867 pr_err("can't add hosts when allow_any_host is set!\n");
872 list_for_each_entry(p, &subsys->hosts, entry) {
873 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
876 list_add_tail(&link->entry, &subsys->hosts);
877 nvmet_subsys_disc_changed(subsys, host);
879 up_write(&nvmet_config_sem);
882 up_write(&nvmet_config_sem);
887 static void nvmet_allowed_hosts_drop_link(struct config_item *parent,
888 struct config_item *target)
890 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
891 struct nvmet_host *host = to_host(target);
892 struct nvmet_host_link *p;
894 down_write(&nvmet_config_sem);
895 list_for_each_entry(p, &subsys->hosts, entry) {
896 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
899 up_write(&nvmet_config_sem);
904 nvmet_subsys_disc_changed(subsys, host);
906 up_write(&nvmet_config_sem);
910 static struct configfs_item_operations nvmet_allowed_hosts_item_ops = {
911 .allow_link = nvmet_allowed_hosts_allow_link,
912 .drop_link = nvmet_allowed_hosts_drop_link,
915 static const struct config_item_type nvmet_allowed_hosts_type = {
916 .ct_item_ops = &nvmet_allowed_hosts_item_ops,
917 .ct_owner = THIS_MODULE,
920 static ssize_t nvmet_subsys_attr_allow_any_host_show(struct config_item *item,
923 return snprintf(page, PAGE_SIZE, "%d\n",
924 to_subsys(item)->allow_any_host);
927 static ssize_t nvmet_subsys_attr_allow_any_host_store(struct config_item *item,
928 const char *page, size_t count)
930 struct nvmet_subsys *subsys = to_subsys(item);
934 if (strtobool(page, &allow_any_host))
937 down_write(&nvmet_config_sem);
938 if (allow_any_host && !list_empty(&subsys->hosts)) {
939 pr_err("Can't set allow_any_host when explicit hosts are set!\n");
944 if (subsys->allow_any_host != allow_any_host) {
945 subsys->allow_any_host = allow_any_host;
946 nvmet_subsys_disc_changed(subsys, NULL);
950 up_write(&nvmet_config_sem);
951 return ret ? ret : count;
954 CONFIGFS_ATTR(nvmet_subsys_, attr_allow_any_host);
956 static ssize_t nvmet_subsys_attr_version_show(struct config_item *item,
959 struct nvmet_subsys *subsys = to_subsys(item);
961 if (NVME_TERTIARY(subsys->ver))
962 return snprintf(page, PAGE_SIZE, "%llu.%llu.%llu\n",
963 NVME_MAJOR(subsys->ver),
964 NVME_MINOR(subsys->ver),
965 NVME_TERTIARY(subsys->ver));
967 return snprintf(page, PAGE_SIZE, "%llu.%llu\n",
968 NVME_MAJOR(subsys->ver),
969 NVME_MINOR(subsys->ver));
972 static ssize_t nvmet_subsys_attr_version_store(struct config_item *item,
973 const char *page, size_t count)
975 struct nvmet_subsys *subsys = to_subsys(item);
976 int major, minor, tertiary = 0;
979 /* passthru subsystems use the underlying controller's version */
980 if (nvmet_passthru_ctrl(subsys))
983 ret = sscanf(page, "%d.%d.%d\n", &major, &minor, &tertiary);
984 if (ret != 2 && ret != 3)
987 down_write(&nvmet_config_sem);
988 subsys->ver = NVME_VS(major, minor, tertiary);
989 up_write(&nvmet_config_sem);
993 CONFIGFS_ATTR(nvmet_subsys_, attr_version);
995 static ssize_t nvmet_subsys_attr_serial_show(struct config_item *item,
998 struct nvmet_subsys *subsys = to_subsys(item);
1000 return snprintf(page, PAGE_SIZE, "%llx\n", subsys->serial);
1003 static ssize_t nvmet_subsys_attr_serial_store(struct config_item *item,
1004 const char *page, size_t count)
1008 if (sscanf(page, "%llx\n", &serial) != 1)
1011 down_write(&nvmet_config_sem);
1012 to_subsys(item)->serial = serial;
1013 up_write(&nvmet_config_sem);
1017 CONFIGFS_ATTR(nvmet_subsys_, attr_serial);
1019 static ssize_t nvmet_subsys_attr_cntlid_min_show(struct config_item *item,
1022 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_min);
1025 static ssize_t nvmet_subsys_attr_cntlid_min_store(struct config_item *item,
1026 const char *page, size_t cnt)
1030 if (sscanf(page, "%hu\n", &cntlid_min) != 1)
1033 if (cntlid_min == 0)
1036 down_write(&nvmet_config_sem);
1037 if (cntlid_min >= to_subsys(item)->cntlid_max)
1039 to_subsys(item)->cntlid_min = cntlid_min;
1040 up_write(&nvmet_config_sem);
1044 up_write(&nvmet_config_sem);
1047 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_min);
1049 static ssize_t nvmet_subsys_attr_cntlid_max_show(struct config_item *item,
1052 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_max);
1055 static ssize_t nvmet_subsys_attr_cntlid_max_store(struct config_item *item,
1056 const char *page, size_t cnt)
1060 if (sscanf(page, "%hu\n", &cntlid_max) != 1)
1063 if (cntlid_max == 0)
1066 down_write(&nvmet_config_sem);
1067 if (cntlid_max <= to_subsys(item)->cntlid_min)
1069 to_subsys(item)->cntlid_max = cntlid_max;
1070 up_write(&nvmet_config_sem);
1074 up_write(&nvmet_config_sem);
1077 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_max);
1079 static ssize_t nvmet_subsys_attr_model_show(struct config_item *item,
1082 struct nvmet_subsys *subsys = to_subsys(item);
1083 struct nvmet_subsys_model *subsys_model;
1084 char *model = NVMET_DEFAULT_CTRL_MODEL;
1088 subsys_model = rcu_dereference(subsys->model);
1090 model = subsys_model->number;
1091 ret = snprintf(page, PAGE_SIZE, "%s\n", model);
1097 /* See Section 1.5 of NVMe 1.4 */
1098 static bool nvmet_is_ascii(const char c)
1100 return c >= 0x20 && c <= 0x7e;
1103 static ssize_t nvmet_subsys_attr_model_store(struct config_item *item,
1104 const char *page, size_t count)
1106 struct nvmet_subsys *subsys = to_subsys(item);
1107 struct nvmet_subsys_model *new_model;
1108 char *new_model_number;
1111 len = strcspn(page, "\n");
1115 for (pos = 0; pos < len; pos++) {
1116 if (!nvmet_is_ascii(page[pos]))
1120 new_model_number = kmemdup_nul(page, len, GFP_KERNEL);
1121 if (!new_model_number)
1124 new_model = kzalloc(sizeof(*new_model) + len + 1, GFP_KERNEL);
1126 kfree(new_model_number);
1129 memcpy(new_model->number, new_model_number, len);
1131 down_write(&nvmet_config_sem);
1132 mutex_lock(&subsys->lock);
1133 new_model = rcu_replace_pointer(subsys->model, new_model,
1134 mutex_is_locked(&subsys->lock));
1135 mutex_unlock(&subsys->lock);
1136 up_write(&nvmet_config_sem);
1138 kfree_rcu(new_model, rcuhead);
1139 kfree(new_model_number);
1143 CONFIGFS_ATTR(nvmet_subsys_, attr_model);
1145 #ifdef CONFIG_BLK_DEV_INTEGRITY
1146 static ssize_t nvmet_subsys_attr_pi_enable_show(struct config_item *item,
1149 return snprintf(page, PAGE_SIZE, "%d\n", to_subsys(item)->pi_support);
1152 static ssize_t nvmet_subsys_attr_pi_enable_store(struct config_item *item,
1153 const char *page, size_t count)
1155 struct nvmet_subsys *subsys = to_subsys(item);
1158 if (strtobool(page, &pi_enable))
1161 subsys->pi_support = pi_enable;
1164 CONFIGFS_ATTR(nvmet_subsys_, attr_pi_enable);
1167 static struct configfs_attribute *nvmet_subsys_attrs[] = {
1168 &nvmet_subsys_attr_attr_allow_any_host,
1169 &nvmet_subsys_attr_attr_version,
1170 &nvmet_subsys_attr_attr_serial,
1171 &nvmet_subsys_attr_attr_cntlid_min,
1172 &nvmet_subsys_attr_attr_cntlid_max,
1173 &nvmet_subsys_attr_attr_model,
1174 #ifdef CONFIG_BLK_DEV_INTEGRITY
1175 &nvmet_subsys_attr_attr_pi_enable,
1181 * Subsystem structures & folder operation functions below
1183 static void nvmet_subsys_release(struct config_item *item)
1185 struct nvmet_subsys *subsys = to_subsys(item);
1187 nvmet_subsys_del_ctrls(subsys);
1188 nvmet_subsys_put(subsys);
1191 static struct configfs_item_operations nvmet_subsys_item_ops = {
1192 .release = nvmet_subsys_release,
1195 static const struct config_item_type nvmet_subsys_type = {
1196 .ct_item_ops = &nvmet_subsys_item_ops,
1197 .ct_attrs = nvmet_subsys_attrs,
1198 .ct_owner = THIS_MODULE,
1201 static struct config_group *nvmet_subsys_make(struct config_group *group,
1204 struct nvmet_subsys *subsys;
1206 if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
1207 pr_err("can't create discovery subsystem through configfs\n");
1208 return ERR_PTR(-EINVAL);
1211 subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
1213 return ERR_CAST(subsys);
1215 config_group_init_type_name(&subsys->group, name, &nvmet_subsys_type);
1217 config_group_init_type_name(&subsys->namespaces_group,
1218 "namespaces", &nvmet_namespaces_type);
1219 configfs_add_default_group(&subsys->namespaces_group, &subsys->group);
1221 config_group_init_type_name(&subsys->allowed_hosts_group,
1222 "allowed_hosts", &nvmet_allowed_hosts_type);
1223 configfs_add_default_group(&subsys->allowed_hosts_group,
1226 nvmet_add_passthru_group(subsys);
1228 return &subsys->group;
1231 static struct configfs_group_operations nvmet_subsystems_group_ops = {
1232 .make_group = nvmet_subsys_make,
1235 static const struct config_item_type nvmet_subsystems_type = {
1236 .ct_group_ops = &nvmet_subsystems_group_ops,
1237 .ct_owner = THIS_MODULE,
1240 static ssize_t nvmet_referral_enable_show(struct config_item *item,
1243 return snprintf(page, PAGE_SIZE, "%d\n", to_nvmet_port(item)->enabled);
1246 static ssize_t nvmet_referral_enable_store(struct config_item *item,
1247 const char *page, size_t count)
1249 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1250 struct nvmet_port *port = to_nvmet_port(item);
1253 if (strtobool(page, &enable))
1257 nvmet_referral_enable(parent, port);
1259 nvmet_referral_disable(parent, port);
1263 pr_err("Invalid value '%s' for enable\n", page);
1267 CONFIGFS_ATTR(nvmet_referral_, enable);
1270 * Discovery Service subsystem definitions
1272 static struct configfs_attribute *nvmet_referral_attrs[] = {
1273 &nvmet_attr_addr_adrfam,
1274 &nvmet_attr_addr_portid,
1275 &nvmet_attr_addr_treq,
1276 &nvmet_attr_addr_traddr,
1277 &nvmet_attr_addr_trsvcid,
1278 &nvmet_attr_addr_trtype,
1279 &nvmet_referral_attr_enable,
1283 static void nvmet_referral_notify(struct config_group *group,
1284 struct config_item *item)
1286 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1287 struct nvmet_port *port = to_nvmet_port(item);
1289 nvmet_referral_disable(parent, port);
1292 static void nvmet_referral_release(struct config_item *item)
1294 struct nvmet_port *port = to_nvmet_port(item);
1299 static struct configfs_item_operations nvmet_referral_item_ops = {
1300 .release = nvmet_referral_release,
1303 static const struct config_item_type nvmet_referral_type = {
1304 .ct_owner = THIS_MODULE,
1305 .ct_attrs = nvmet_referral_attrs,
1306 .ct_item_ops = &nvmet_referral_item_ops,
1309 static struct config_group *nvmet_referral_make(
1310 struct config_group *group, const char *name)
1312 struct nvmet_port *port;
1314 port = kzalloc(sizeof(*port), GFP_KERNEL);
1316 return ERR_PTR(-ENOMEM);
1318 INIT_LIST_HEAD(&port->entry);
1319 config_group_init_type_name(&port->group, name, &nvmet_referral_type);
1321 return &port->group;
1324 static struct configfs_group_operations nvmet_referral_group_ops = {
1325 .make_group = nvmet_referral_make,
1326 .disconnect_notify = nvmet_referral_notify,
1329 static const struct config_item_type nvmet_referrals_type = {
1330 .ct_owner = THIS_MODULE,
1331 .ct_group_ops = &nvmet_referral_group_ops,
1334 static struct nvmet_type_name_map nvmet_ana_state[] = {
1335 { NVME_ANA_OPTIMIZED, "optimized" },
1336 { NVME_ANA_NONOPTIMIZED, "non-optimized" },
1337 { NVME_ANA_INACCESSIBLE, "inaccessible" },
1338 { NVME_ANA_PERSISTENT_LOSS, "persistent-loss" },
1339 { NVME_ANA_CHANGE, "change" },
1342 static ssize_t nvmet_ana_group_ana_state_show(struct config_item *item,
1345 struct nvmet_ana_group *grp = to_ana_group(item);
1346 enum nvme_ana_state state = grp->port->ana_state[grp->grpid];
1349 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1350 if (state == nvmet_ana_state[i].type)
1351 return sprintf(page, "%s\n", nvmet_ana_state[i].name);
1354 return sprintf(page, "\n");
1357 static ssize_t nvmet_ana_group_ana_state_store(struct config_item *item,
1358 const char *page, size_t count)
1360 struct nvmet_ana_group *grp = to_ana_group(item);
1361 enum nvme_ana_state *ana_state = grp->port->ana_state;
1364 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1365 if (sysfs_streq(page, nvmet_ana_state[i].name))
1369 pr_err("Invalid value '%s' for ana_state\n", page);
1373 down_write(&nvmet_ana_sem);
1374 ana_state[grp->grpid] = (enum nvme_ana_state) nvmet_ana_state[i].type;
1376 up_write(&nvmet_ana_sem);
1377 nvmet_port_send_ana_event(grp->port);
1381 CONFIGFS_ATTR(nvmet_ana_group_, ana_state);
1383 static struct configfs_attribute *nvmet_ana_group_attrs[] = {
1384 &nvmet_ana_group_attr_ana_state,
1388 static void nvmet_ana_group_release(struct config_item *item)
1390 struct nvmet_ana_group *grp = to_ana_group(item);
1392 if (grp == &grp->port->ana_default_group)
1395 down_write(&nvmet_ana_sem);
1396 grp->port->ana_state[grp->grpid] = NVME_ANA_INACCESSIBLE;
1397 nvmet_ana_group_enabled[grp->grpid]--;
1398 up_write(&nvmet_ana_sem);
1400 nvmet_port_send_ana_event(grp->port);
1404 static struct configfs_item_operations nvmet_ana_group_item_ops = {
1405 .release = nvmet_ana_group_release,
1408 static const struct config_item_type nvmet_ana_group_type = {
1409 .ct_item_ops = &nvmet_ana_group_item_ops,
1410 .ct_attrs = nvmet_ana_group_attrs,
1411 .ct_owner = THIS_MODULE,
1414 static struct config_group *nvmet_ana_groups_make_group(
1415 struct config_group *group, const char *name)
1417 struct nvmet_port *port = ana_groups_to_port(&group->cg_item);
1418 struct nvmet_ana_group *grp;
1422 ret = kstrtou32(name, 0, &grpid);
1427 if (grpid <= 1 || grpid > NVMET_MAX_ANAGRPS)
1431 grp = kzalloc(sizeof(*grp), GFP_KERNEL);
1437 down_write(&nvmet_ana_sem);
1438 nvmet_ana_group_enabled[grpid]++;
1439 up_write(&nvmet_ana_sem);
1441 nvmet_port_send_ana_event(grp->port);
1443 config_group_init_type_name(&grp->group, name, &nvmet_ana_group_type);
1446 return ERR_PTR(ret);
1449 static struct configfs_group_operations nvmet_ana_groups_group_ops = {
1450 .make_group = nvmet_ana_groups_make_group,
1453 static const struct config_item_type nvmet_ana_groups_type = {
1454 .ct_group_ops = &nvmet_ana_groups_group_ops,
1455 .ct_owner = THIS_MODULE,
1459 * Ports definitions.
1461 static void nvmet_port_release(struct config_item *item)
1463 struct nvmet_port *port = to_nvmet_port(item);
1465 /* Let inflight controllers teardown complete */
1466 flush_scheduled_work();
1467 list_del(&port->global_entry);
1469 kfree(port->ana_state);
1473 static struct configfs_attribute *nvmet_port_attrs[] = {
1474 &nvmet_attr_addr_adrfam,
1475 &nvmet_attr_addr_treq,
1476 &nvmet_attr_addr_traddr,
1477 &nvmet_attr_addr_trsvcid,
1478 &nvmet_attr_addr_trtype,
1479 &nvmet_attr_param_inline_data_size,
1480 #ifdef CONFIG_BLK_DEV_INTEGRITY
1481 &nvmet_attr_param_pi_enable,
1486 static struct configfs_item_operations nvmet_port_item_ops = {
1487 .release = nvmet_port_release,
1490 static const struct config_item_type nvmet_port_type = {
1491 .ct_attrs = nvmet_port_attrs,
1492 .ct_item_ops = &nvmet_port_item_ops,
1493 .ct_owner = THIS_MODULE,
1496 static struct config_group *nvmet_ports_make(struct config_group *group,
1499 struct nvmet_port *port;
1503 if (kstrtou16(name, 0, &portid))
1504 return ERR_PTR(-EINVAL);
1506 port = kzalloc(sizeof(*port), GFP_KERNEL);
1508 return ERR_PTR(-ENOMEM);
1510 port->ana_state = kcalloc(NVMET_MAX_ANAGRPS + 1,
1511 sizeof(*port->ana_state), GFP_KERNEL);
1512 if (!port->ana_state) {
1514 return ERR_PTR(-ENOMEM);
1517 for (i = 1; i <= NVMET_MAX_ANAGRPS; i++) {
1518 if (i == NVMET_DEFAULT_ANA_GRPID)
1519 port->ana_state[1] = NVME_ANA_OPTIMIZED;
1521 port->ana_state[i] = NVME_ANA_INACCESSIBLE;
1524 list_add(&port->global_entry, &nvmet_ports_list);
1526 INIT_LIST_HEAD(&port->entry);
1527 INIT_LIST_HEAD(&port->subsystems);
1528 INIT_LIST_HEAD(&port->referrals);
1529 port->inline_data_size = -1; /* < 0 == let the transport choose */
1531 port->disc_addr.portid = cpu_to_le16(portid);
1532 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_MAX;
1533 port->disc_addr.treq = NVMF_TREQ_DISABLE_SQFLOW;
1534 config_group_init_type_name(&port->group, name, &nvmet_port_type);
1536 config_group_init_type_name(&port->subsys_group,
1537 "subsystems", &nvmet_port_subsys_type);
1538 configfs_add_default_group(&port->subsys_group, &port->group);
1540 config_group_init_type_name(&port->referrals_group,
1541 "referrals", &nvmet_referrals_type);
1542 configfs_add_default_group(&port->referrals_group, &port->group);
1544 config_group_init_type_name(&port->ana_groups_group,
1545 "ana_groups", &nvmet_ana_groups_type);
1546 configfs_add_default_group(&port->ana_groups_group, &port->group);
1548 port->ana_default_group.port = port;
1549 port->ana_default_group.grpid = NVMET_DEFAULT_ANA_GRPID;
1550 config_group_init_type_name(&port->ana_default_group.group,
1551 __stringify(NVMET_DEFAULT_ANA_GRPID),
1552 &nvmet_ana_group_type);
1553 configfs_add_default_group(&port->ana_default_group.group,
1554 &port->ana_groups_group);
1556 return &port->group;
1559 static struct configfs_group_operations nvmet_ports_group_ops = {
1560 .make_group = nvmet_ports_make,
1563 static const struct config_item_type nvmet_ports_type = {
1564 .ct_group_ops = &nvmet_ports_group_ops,
1565 .ct_owner = THIS_MODULE,
1568 static struct config_group nvmet_subsystems_group;
1569 static struct config_group nvmet_ports_group;
1571 static void nvmet_host_release(struct config_item *item)
1573 struct nvmet_host *host = to_host(item);
1578 static struct configfs_item_operations nvmet_host_item_ops = {
1579 .release = nvmet_host_release,
1582 static const struct config_item_type nvmet_host_type = {
1583 .ct_item_ops = &nvmet_host_item_ops,
1584 .ct_owner = THIS_MODULE,
1587 static struct config_group *nvmet_hosts_make_group(struct config_group *group,
1590 struct nvmet_host *host;
1592 host = kzalloc(sizeof(*host), GFP_KERNEL);
1594 return ERR_PTR(-ENOMEM);
1596 config_group_init_type_name(&host->group, name, &nvmet_host_type);
1598 return &host->group;
1601 static struct configfs_group_operations nvmet_hosts_group_ops = {
1602 .make_group = nvmet_hosts_make_group,
1605 static const struct config_item_type nvmet_hosts_type = {
1606 .ct_group_ops = &nvmet_hosts_group_ops,
1607 .ct_owner = THIS_MODULE,
1610 static struct config_group nvmet_hosts_group;
1612 static const struct config_item_type nvmet_root_type = {
1613 .ct_owner = THIS_MODULE,
1616 static struct configfs_subsystem nvmet_configfs_subsystem = {
1619 .ci_namebuf = "nvmet",
1620 .ci_type = &nvmet_root_type,
1625 int __init nvmet_init_configfs(void)
1629 config_group_init(&nvmet_configfs_subsystem.su_group);
1630 mutex_init(&nvmet_configfs_subsystem.su_mutex);
1632 config_group_init_type_name(&nvmet_subsystems_group,
1633 "subsystems", &nvmet_subsystems_type);
1634 configfs_add_default_group(&nvmet_subsystems_group,
1635 &nvmet_configfs_subsystem.su_group);
1637 config_group_init_type_name(&nvmet_ports_group,
1638 "ports", &nvmet_ports_type);
1639 configfs_add_default_group(&nvmet_ports_group,
1640 &nvmet_configfs_subsystem.su_group);
1642 config_group_init_type_name(&nvmet_hosts_group,
1643 "hosts", &nvmet_hosts_type);
1644 configfs_add_default_group(&nvmet_hosts_group,
1645 &nvmet_configfs_subsystem.su_group);
1647 ret = configfs_register_subsystem(&nvmet_configfs_subsystem);
1649 pr_err("configfs_register_subsystem: %d\n", ret);
1656 void __exit nvmet_exit_configfs(void)
1658 configfs_unregister_subsystem(&nvmet_configfs_subsystem);