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))
269 if (nvmet_is_port_enabled(port, __func__))
272 port->pi_enable = val;
276 CONFIGFS_ATTR(nvmet_, param_pi_enable);
279 static ssize_t nvmet_addr_trtype_show(struct config_item *item,
282 struct nvmet_port *port = to_nvmet_port(item);
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);
290 return sprintf(page, "\n");
293 static void nvmet_port_init_tsas_rdma(struct nvmet_port *port)
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;
300 static ssize_t nvmet_addr_trtype_store(struct config_item *item,
301 const char *page, size_t count)
303 struct nvmet_port *port = to_nvmet_port(item);
306 if (nvmet_is_port_enabled(port, __func__))
309 for (i = 0; i < ARRAY_SIZE(nvmet_transport); i++) {
310 if (sysfs_streq(page, nvmet_transport[i].name))
314 pr_err("Invalid value '%s' for trtype\n", page);
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);
325 CONFIGFS_ATTR(nvmet_, addr_trtype);
328 * Namespace structures & file operation functions below
330 static ssize_t nvmet_ns_device_path_show(struct config_item *item, char *page)
332 return sprintf(page, "%s\n", to_nvmet_ns(item)->device_path);
335 static ssize_t nvmet_ns_device_path_store(struct config_item *item,
336 const char *page, size_t count)
338 struct nvmet_ns *ns = to_nvmet_ns(item);
339 struct nvmet_subsys *subsys = ns->subsys;
343 mutex_lock(&subsys->lock);
349 len = strcspn(page, "\n");
353 kfree(ns->device_path);
355 ns->device_path = kmemdup_nul(page, len, GFP_KERNEL);
356 if (!ns->device_path)
359 mutex_unlock(&subsys->lock);
363 mutex_unlock(&subsys->lock);
367 CONFIGFS_ATTR(nvmet_ns_, device_path);
369 #ifdef CONFIG_PCI_P2PDMA
370 static ssize_t nvmet_ns_p2pmem_show(struct config_item *item, char *page)
372 struct nvmet_ns *ns = to_nvmet_ns(item);
374 return pci_p2pdma_enable_show(page, ns->p2p_dev, ns->use_p2pmem);
377 static ssize_t nvmet_ns_p2pmem_store(struct config_item *item,
378 const char *page, size_t count)
380 struct nvmet_ns *ns = to_nvmet_ns(item);
381 struct pci_dev *p2p_dev = NULL;
386 mutex_lock(&ns->subsys->lock);
392 error = pci_p2pdma_enable_store(page, &p2p_dev, &use_p2pmem);
398 ns->use_p2pmem = use_p2pmem;
399 pci_dev_put(ns->p2p_dev);
400 ns->p2p_dev = p2p_dev;
403 mutex_unlock(&ns->subsys->lock);
408 CONFIGFS_ATTR(nvmet_ns_, p2pmem);
409 #endif /* CONFIG_PCI_P2PDMA */
411 static ssize_t nvmet_ns_device_uuid_show(struct config_item *item, char *page)
413 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->uuid);
416 static ssize_t nvmet_ns_device_uuid_store(struct config_item *item,
417 const char *page, size_t count)
419 struct nvmet_ns *ns = to_nvmet_ns(item);
420 struct nvmet_subsys *subsys = ns->subsys;
423 mutex_lock(&subsys->lock);
429 if (uuid_parse(page, &ns->uuid))
433 mutex_unlock(&subsys->lock);
434 return ret ? ret : count;
437 CONFIGFS_ATTR(nvmet_ns_, device_uuid);
439 static ssize_t nvmet_ns_device_nguid_show(struct config_item *item, char *page)
441 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->nguid);
444 static ssize_t nvmet_ns_device_nguid_store(struct config_item *item,
445 const char *page, size_t count)
447 struct nvmet_ns *ns = to_nvmet_ns(item);
448 struct nvmet_subsys *subsys = ns->subsys;
450 const char *p = page;
454 mutex_lock(&subsys->lock);
460 for (i = 0; i < 16; i++) {
461 if (p + 2 > page + count) {
465 if (!isxdigit(p[0]) || !isxdigit(p[1])) {
470 nguid[i] = (hex_to_bin(p[0]) << 4) | hex_to_bin(p[1]);
473 if (*p == '-' || *p == ':')
477 memcpy(&ns->nguid, nguid, sizeof(nguid));
479 mutex_unlock(&subsys->lock);
480 return ret ? ret : count;
483 CONFIGFS_ATTR(nvmet_ns_, device_nguid);
485 static ssize_t nvmet_ns_ana_grpid_show(struct config_item *item, char *page)
487 return sprintf(page, "%u\n", to_nvmet_ns(item)->anagrpid);
490 static ssize_t nvmet_ns_ana_grpid_store(struct config_item *item,
491 const char *page, size_t count)
493 struct nvmet_ns *ns = to_nvmet_ns(item);
494 u32 oldgrpid, newgrpid;
497 ret = kstrtou32(page, 0, &newgrpid);
501 if (newgrpid < 1 || newgrpid > NVMET_MAX_ANAGRPS)
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]--;
510 up_write(&nvmet_ana_sem);
512 nvmet_send_ana_event(ns->subsys, NULL);
516 CONFIGFS_ATTR(nvmet_ns_, ana_grpid);
518 static ssize_t nvmet_ns_enable_show(struct config_item *item, char *page)
520 return sprintf(page, "%d\n", to_nvmet_ns(item)->enabled);
523 static ssize_t nvmet_ns_enable_store(struct config_item *item,
524 const char *page, size_t count)
526 struct nvmet_ns *ns = to_nvmet_ns(item);
530 if (strtobool(page, &enable))
534 ret = nvmet_ns_enable(ns);
536 nvmet_ns_disable(ns);
538 return ret ? ret : count;
541 CONFIGFS_ATTR(nvmet_ns_, enable);
543 static ssize_t nvmet_ns_buffered_io_show(struct config_item *item, char *page)
545 return sprintf(page, "%d\n", to_nvmet_ns(item)->buffered_io);
548 static ssize_t nvmet_ns_buffered_io_store(struct config_item *item,
549 const char *page, size_t count)
551 struct nvmet_ns *ns = to_nvmet_ns(item);
554 if (strtobool(page, &val))
557 mutex_lock(&ns->subsys->lock);
559 pr_err("disable ns before setting buffered_io value.\n");
560 mutex_unlock(&ns->subsys->lock);
564 ns->buffered_io = val;
565 mutex_unlock(&ns->subsys->lock);
569 CONFIGFS_ATTR(nvmet_ns_, buffered_io);
571 static ssize_t nvmet_ns_revalidate_size_store(struct config_item *item,
572 const char *page, size_t count)
574 struct nvmet_ns *ns = to_nvmet_ns(item);
577 if (strtobool(page, &val))
583 mutex_lock(&ns->subsys->lock);
585 pr_err("enable ns before revalidate.\n");
586 mutex_unlock(&ns->subsys->lock);
589 nvmet_ns_revalidate(ns);
590 mutex_unlock(&ns->subsys->lock);
594 CONFIGFS_ATTR_WO(nvmet_ns_, revalidate_size);
596 static 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,
610 static void nvmet_ns_release(struct config_item *item)
612 struct nvmet_ns *ns = to_nvmet_ns(item);
617 static struct configfs_item_operations nvmet_ns_item_ops = {
618 .release = nvmet_ns_release,
621 static 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,
627 static struct config_group *nvmet_ns_make(struct config_group *group,
630 struct nvmet_subsys *subsys = namespaces_to_subsys(&group->cg_item);
635 ret = kstrtou32(name, 0, &nsid);
640 if (nsid == 0 || nsid == NVME_NSID_ALL) {
641 pr_err("invalid nsid %#x", nsid);
646 ns = nvmet_ns_alloc(subsys, nsid);
649 config_group_init_type_name(&ns->group, name, &nvmet_ns_type);
651 pr_info("adding nsid %d to subsystem %s\n", nsid, subsys->subsysnqn);
658 static struct configfs_group_operations nvmet_namespaces_group_ops = {
659 .make_group = nvmet_ns_make,
662 static const struct config_item_type nvmet_namespaces_type = {
663 .ct_group_ops = &nvmet_namespaces_group_ops,
664 .ct_owner = THIS_MODULE,
667 #ifdef CONFIG_NVME_TARGET_PASSTHRU
669 static ssize_t nvmet_passthru_device_path_show(struct config_item *item,
672 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
674 return snprintf(page, PAGE_SIZE, "%s\n", subsys->passthru_ctrl_path);
677 static ssize_t nvmet_passthru_device_path_store(struct config_item *item,
678 const char *page, size_t count)
680 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
684 mutex_lock(&subsys->lock);
687 if (subsys->passthru_ctrl)
691 len = strcspn(page, "\n");
695 kfree(subsys->passthru_ctrl_path);
697 subsys->passthru_ctrl_path = kstrndup(page, len, GFP_KERNEL);
698 if (!subsys->passthru_ctrl_path)
701 mutex_unlock(&subsys->lock);
705 mutex_unlock(&subsys->lock);
708 CONFIGFS_ATTR(nvmet_passthru_, device_path);
710 static ssize_t nvmet_passthru_enable_show(struct config_item *item,
713 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
715 return sprintf(page, "%d\n", subsys->passthru_ctrl ? 1 : 0);
718 static ssize_t nvmet_passthru_enable_store(struct config_item *item,
719 const char *page, size_t count)
721 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
725 if (strtobool(page, &enable))
729 ret = nvmet_passthru_ctrl_enable(subsys);
731 nvmet_passthru_ctrl_disable(subsys);
733 return ret ? ret : count;
735 CONFIGFS_ATTR(nvmet_passthru_, enable);
737 static ssize_t nvmet_passthru_admin_timeout_show(struct config_item *item,
740 return sprintf(page, "%u\n", to_subsys(item->ci_parent)->admin_timeout);
743 static ssize_t nvmet_passthru_admin_timeout_store(struct config_item *item,
744 const char *page, size_t count)
746 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
747 unsigned int timeout;
749 if (kstrtouint(page, 0, &timeout))
751 subsys->admin_timeout = timeout;
754 CONFIGFS_ATTR(nvmet_passthru_, admin_timeout);
756 static ssize_t nvmet_passthru_io_timeout_show(struct config_item *item,
759 return sprintf(page, "%u\n", to_subsys(item->ci_parent)->io_timeout);
762 static ssize_t nvmet_passthru_io_timeout_store(struct config_item *item,
763 const char *page, size_t count)
765 struct nvmet_subsys *subsys = to_subsys(item->ci_parent);
766 unsigned int timeout;
768 if (kstrtouint(page, 0, &timeout))
770 subsys->io_timeout = timeout;
773 CONFIGFS_ATTR(nvmet_passthru_, io_timeout);
775 static 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,
783 static const struct config_item_type nvmet_passthru_type = {
784 .ct_attrs = nvmet_passthru_attrs,
785 .ct_owner = THIS_MODULE,
788 static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
790 config_group_init_type_name(&subsys->passthru_group,
791 "passthru", &nvmet_passthru_type);
792 configfs_add_default_group(&subsys->passthru_group,
796 #else /* CONFIG_NVME_TARGET_PASSTHRU */
798 static void nvmet_add_passthru_group(struct nvmet_subsys *subsys)
802 #endif /* CONFIG_NVME_TARGET_PASSTHRU */
804 static int nvmet_port_subsys_allow_link(struct config_item *parent,
805 struct config_item *target)
807 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
808 struct nvmet_subsys *subsys;
809 struct nvmet_subsys_link *link, *p;
812 if (target->ci_type != &nvmet_subsys_type) {
813 pr_err("can only link subsystems into the subsystems dir.!\n");
816 subsys = to_subsys(target);
817 link = kmalloc(sizeof(*link), GFP_KERNEL);
820 link->subsys = subsys;
822 down_write(&nvmet_config_sem);
824 list_for_each_entry(p, &port->subsystems, entry) {
825 if (p->subsys == subsys)
829 if (list_empty(&port->subsystems)) {
830 ret = nvmet_enable_port(port);
835 list_add_tail(&link->entry, &port->subsystems);
836 nvmet_port_disc_changed(port, subsys);
838 up_write(&nvmet_config_sem);
842 up_write(&nvmet_config_sem);
847 static void nvmet_port_subsys_drop_link(struct config_item *parent,
848 struct config_item *target)
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;
854 down_write(&nvmet_config_sem);
855 list_for_each_entry(p, &port->subsystems, entry) {
856 if (p->subsys == subsys)
859 up_write(&nvmet_config_sem);
864 nvmet_port_del_ctrls(port, subsys);
865 nvmet_port_disc_changed(port, subsys);
867 if (list_empty(&port->subsystems))
868 nvmet_disable_port(port);
869 up_write(&nvmet_config_sem);
873 static 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,
878 static const struct config_item_type nvmet_port_subsys_type = {
879 .ct_item_ops = &nvmet_port_subsys_item_ops,
880 .ct_owner = THIS_MODULE,
883 static int nvmet_allowed_hosts_allow_link(struct config_item *parent,
884 struct config_item *target)
886 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
887 struct nvmet_host *host;
888 struct nvmet_host_link *link, *p;
891 if (target->ci_type != &nvmet_host_type) {
892 pr_err("can only link hosts into the allowed_hosts directory!\n");
896 host = to_host(target);
897 link = kmalloc(sizeof(*link), GFP_KERNEL);
902 down_write(&nvmet_config_sem);
904 if (subsys->allow_any_host) {
905 pr_err("can't add hosts when allow_any_host is set!\n");
910 list_for_each_entry(p, &subsys->hosts, entry) {
911 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
914 list_add_tail(&link->entry, &subsys->hosts);
915 nvmet_subsys_disc_changed(subsys, host);
917 up_write(&nvmet_config_sem);
920 up_write(&nvmet_config_sem);
925 static void nvmet_allowed_hosts_drop_link(struct config_item *parent,
926 struct config_item *target)
928 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
929 struct nvmet_host *host = to_host(target);
930 struct nvmet_host_link *p;
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)))
937 up_write(&nvmet_config_sem);
942 nvmet_subsys_disc_changed(subsys, host);
944 up_write(&nvmet_config_sem);
948 static 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,
953 static const struct config_item_type nvmet_allowed_hosts_type = {
954 .ct_item_ops = &nvmet_allowed_hosts_item_ops,
955 .ct_owner = THIS_MODULE,
958 static ssize_t nvmet_subsys_attr_allow_any_host_show(struct config_item *item,
961 return snprintf(page, PAGE_SIZE, "%d\n",
962 to_subsys(item)->allow_any_host);
965 static ssize_t nvmet_subsys_attr_allow_any_host_store(struct config_item *item,
966 const char *page, size_t count)
968 struct nvmet_subsys *subsys = to_subsys(item);
972 if (strtobool(page, &allow_any_host))
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");
982 if (subsys->allow_any_host != allow_any_host) {
983 subsys->allow_any_host = allow_any_host;
984 nvmet_subsys_disc_changed(subsys, NULL);
988 up_write(&nvmet_config_sem);
989 return ret ? ret : count;
992 CONFIGFS_ATTR(nvmet_subsys_, attr_allow_any_host);
994 static ssize_t nvmet_subsys_attr_version_show(struct config_item *item,
997 struct nvmet_subsys *subsys = to_subsys(item);
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));
1005 return snprintf(page, PAGE_SIZE, "%llu.%llu\n",
1006 NVME_MAJOR(subsys->ver),
1007 NVME_MINOR(subsys->ver));
1010 static ssize_t nvmet_subsys_attr_version_store(struct config_item *item,
1011 const char *page, size_t count)
1013 struct nvmet_subsys *subsys = to_subsys(item);
1014 int major, minor, tertiary = 0;
1017 /* passthru subsystems use the underlying controller's version */
1018 if (nvmet_passthru_ctrl(subsys))
1021 ret = sscanf(page, "%d.%d.%d\n", &major, &minor, &tertiary);
1022 if (ret != 2 && ret != 3)
1025 down_write(&nvmet_config_sem);
1026 subsys->ver = NVME_VS(major, minor, tertiary);
1027 up_write(&nvmet_config_sem);
1031 CONFIGFS_ATTR(nvmet_subsys_, attr_version);
1033 /* See Section 1.5 of NVMe 1.4 */
1034 static bool nvmet_is_ascii(const char c)
1036 return c >= 0x20 && c <= 0x7e;
1039 static ssize_t nvmet_subsys_attr_serial_show(struct config_item *item,
1042 struct nvmet_subsys *subsys = to_subsys(item);
1044 return snprintf(page, PAGE_SIZE, "%s\n", subsys->serial);
1048 nvmet_subsys_attr_serial_store_locked(struct nvmet_subsys *subsys,
1049 const char *page, size_t count)
1051 int pos, len = strcspn(page, "\n");
1053 if (subsys->subsys_discovered) {
1054 pr_err("Can't set serial number. %s is already assigned\n",
1059 if (!len || len > NVMET_SN_MAX_SIZE) {
1060 pr_err("Serial Number can not be empty or exceed %d Bytes\n",
1065 for (pos = 0; pos < len; pos++) {
1066 if (!nvmet_is_ascii(page[pos])) {
1067 pr_err("Serial Number must contain only ASCII strings\n");
1072 memcpy_and_pad(subsys->serial, NVMET_SN_MAX_SIZE, page, len, ' ');
1077 static ssize_t nvmet_subsys_attr_serial_store(struct config_item *item,
1078 const char *page, size_t count)
1080 struct nvmet_subsys *subsys = to_subsys(item);
1083 down_write(&nvmet_config_sem);
1084 mutex_lock(&subsys->lock);
1085 ret = nvmet_subsys_attr_serial_store_locked(subsys, page, count);
1086 mutex_unlock(&subsys->lock);
1087 up_write(&nvmet_config_sem);
1091 CONFIGFS_ATTR(nvmet_subsys_, attr_serial);
1093 static ssize_t nvmet_subsys_attr_cntlid_min_show(struct config_item *item,
1096 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_min);
1099 static ssize_t nvmet_subsys_attr_cntlid_min_store(struct config_item *item,
1100 const char *page, size_t cnt)
1104 if (sscanf(page, "%hu\n", &cntlid_min) != 1)
1107 if (cntlid_min == 0)
1110 down_write(&nvmet_config_sem);
1111 if (cntlid_min >= to_subsys(item)->cntlid_max)
1113 to_subsys(item)->cntlid_min = cntlid_min;
1114 up_write(&nvmet_config_sem);
1118 up_write(&nvmet_config_sem);
1121 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_min);
1123 static ssize_t nvmet_subsys_attr_cntlid_max_show(struct config_item *item,
1126 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_max);
1129 static ssize_t nvmet_subsys_attr_cntlid_max_store(struct config_item *item,
1130 const char *page, size_t cnt)
1134 if (sscanf(page, "%hu\n", &cntlid_max) != 1)
1137 if (cntlid_max == 0)
1140 down_write(&nvmet_config_sem);
1141 if (cntlid_max <= to_subsys(item)->cntlid_min)
1143 to_subsys(item)->cntlid_max = cntlid_max;
1144 up_write(&nvmet_config_sem);
1148 up_write(&nvmet_config_sem);
1151 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_max);
1153 static ssize_t nvmet_subsys_attr_model_show(struct config_item *item,
1156 struct nvmet_subsys *subsys = to_subsys(item);
1158 return snprintf(page, PAGE_SIZE, "%s\n", subsys->model_number);
1161 static ssize_t nvmet_subsys_attr_model_store_locked(struct nvmet_subsys *subsys,
1162 const char *page, size_t count)
1166 if (subsys->subsys_discovered) {
1167 pr_err("Can't set model number. %s is already assigned\n",
1168 subsys->model_number);
1172 len = strcspn(page, "\n");
1176 if (len > NVMET_MN_MAX_SIZE) {
1177 pr_err("Model number size can not exceed %d Bytes\n",
1182 for (pos = 0; pos < len; pos++) {
1183 if (!nvmet_is_ascii(page[pos]))
1187 subsys->model_number = kmemdup_nul(page, len, GFP_KERNEL);
1188 if (!subsys->model_number)
1193 static ssize_t nvmet_subsys_attr_model_store(struct config_item *item,
1194 const char *page, size_t count)
1196 struct nvmet_subsys *subsys = to_subsys(item);
1199 down_write(&nvmet_config_sem);
1200 mutex_lock(&subsys->lock);
1201 ret = nvmet_subsys_attr_model_store_locked(subsys, page, count);
1202 mutex_unlock(&subsys->lock);
1203 up_write(&nvmet_config_sem);
1207 CONFIGFS_ATTR(nvmet_subsys_, attr_model);
1209 #ifdef CONFIG_BLK_DEV_INTEGRITY
1210 static ssize_t nvmet_subsys_attr_pi_enable_show(struct config_item *item,
1213 return snprintf(page, PAGE_SIZE, "%d\n", to_subsys(item)->pi_support);
1216 static ssize_t nvmet_subsys_attr_pi_enable_store(struct config_item *item,
1217 const char *page, size_t count)
1219 struct nvmet_subsys *subsys = to_subsys(item);
1222 if (strtobool(page, &pi_enable))
1225 subsys->pi_support = pi_enable;
1228 CONFIGFS_ATTR(nvmet_subsys_, attr_pi_enable);
1231 static struct configfs_attribute *nvmet_subsys_attrs[] = {
1232 &nvmet_subsys_attr_attr_allow_any_host,
1233 &nvmet_subsys_attr_attr_version,
1234 &nvmet_subsys_attr_attr_serial,
1235 &nvmet_subsys_attr_attr_cntlid_min,
1236 &nvmet_subsys_attr_attr_cntlid_max,
1237 &nvmet_subsys_attr_attr_model,
1238 #ifdef CONFIG_BLK_DEV_INTEGRITY
1239 &nvmet_subsys_attr_attr_pi_enable,
1245 * Subsystem structures & folder operation functions below
1247 static void nvmet_subsys_release(struct config_item *item)
1249 struct nvmet_subsys *subsys = to_subsys(item);
1251 nvmet_subsys_del_ctrls(subsys);
1252 nvmet_subsys_put(subsys);
1255 static struct configfs_item_operations nvmet_subsys_item_ops = {
1256 .release = nvmet_subsys_release,
1259 static const struct config_item_type nvmet_subsys_type = {
1260 .ct_item_ops = &nvmet_subsys_item_ops,
1261 .ct_attrs = nvmet_subsys_attrs,
1262 .ct_owner = THIS_MODULE,
1265 static struct config_group *nvmet_subsys_make(struct config_group *group,
1268 struct nvmet_subsys *subsys;
1270 if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
1271 pr_err("can't create discovery subsystem through configfs\n");
1272 return ERR_PTR(-EINVAL);
1275 subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
1277 return ERR_CAST(subsys);
1279 config_group_init_type_name(&subsys->group, name, &nvmet_subsys_type);
1281 config_group_init_type_name(&subsys->namespaces_group,
1282 "namespaces", &nvmet_namespaces_type);
1283 configfs_add_default_group(&subsys->namespaces_group, &subsys->group);
1285 config_group_init_type_name(&subsys->allowed_hosts_group,
1286 "allowed_hosts", &nvmet_allowed_hosts_type);
1287 configfs_add_default_group(&subsys->allowed_hosts_group,
1290 nvmet_add_passthru_group(subsys);
1292 return &subsys->group;
1295 static struct configfs_group_operations nvmet_subsystems_group_ops = {
1296 .make_group = nvmet_subsys_make,
1299 static const struct config_item_type nvmet_subsystems_type = {
1300 .ct_group_ops = &nvmet_subsystems_group_ops,
1301 .ct_owner = THIS_MODULE,
1304 static ssize_t nvmet_referral_enable_show(struct config_item *item,
1307 return snprintf(page, PAGE_SIZE, "%d\n", to_nvmet_port(item)->enabled);
1310 static ssize_t nvmet_referral_enable_store(struct config_item *item,
1311 const char *page, size_t count)
1313 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1314 struct nvmet_port *port = to_nvmet_port(item);
1317 if (strtobool(page, &enable))
1321 nvmet_referral_enable(parent, port);
1323 nvmet_referral_disable(parent, port);
1327 pr_err("Invalid value '%s' for enable\n", page);
1331 CONFIGFS_ATTR(nvmet_referral_, enable);
1334 * Discovery Service subsystem definitions
1336 static struct configfs_attribute *nvmet_referral_attrs[] = {
1337 &nvmet_attr_addr_adrfam,
1338 &nvmet_attr_addr_portid,
1339 &nvmet_attr_addr_treq,
1340 &nvmet_attr_addr_traddr,
1341 &nvmet_attr_addr_trsvcid,
1342 &nvmet_attr_addr_trtype,
1343 &nvmet_referral_attr_enable,
1347 static void nvmet_referral_notify(struct config_group *group,
1348 struct config_item *item)
1350 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1351 struct nvmet_port *port = to_nvmet_port(item);
1353 nvmet_referral_disable(parent, port);
1356 static void nvmet_referral_release(struct config_item *item)
1358 struct nvmet_port *port = to_nvmet_port(item);
1363 static struct configfs_item_operations nvmet_referral_item_ops = {
1364 .release = nvmet_referral_release,
1367 static const struct config_item_type nvmet_referral_type = {
1368 .ct_owner = THIS_MODULE,
1369 .ct_attrs = nvmet_referral_attrs,
1370 .ct_item_ops = &nvmet_referral_item_ops,
1373 static struct config_group *nvmet_referral_make(
1374 struct config_group *group, const char *name)
1376 struct nvmet_port *port;
1378 port = kzalloc(sizeof(*port), GFP_KERNEL);
1380 return ERR_PTR(-ENOMEM);
1382 INIT_LIST_HEAD(&port->entry);
1383 config_group_init_type_name(&port->group, name, &nvmet_referral_type);
1385 return &port->group;
1388 static struct configfs_group_operations nvmet_referral_group_ops = {
1389 .make_group = nvmet_referral_make,
1390 .disconnect_notify = nvmet_referral_notify,
1393 static const struct config_item_type nvmet_referrals_type = {
1394 .ct_owner = THIS_MODULE,
1395 .ct_group_ops = &nvmet_referral_group_ops,
1398 static struct nvmet_type_name_map nvmet_ana_state[] = {
1399 { NVME_ANA_OPTIMIZED, "optimized" },
1400 { NVME_ANA_NONOPTIMIZED, "non-optimized" },
1401 { NVME_ANA_INACCESSIBLE, "inaccessible" },
1402 { NVME_ANA_PERSISTENT_LOSS, "persistent-loss" },
1403 { NVME_ANA_CHANGE, "change" },
1406 static ssize_t nvmet_ana_group_ana_state_show(struct config_item *item,
1409 struct nvmet_ana_group *grp = to_ana_group(item);
1410 enum nvme_ana_state state = grp->port->ana_state[grp->grpid];
1413 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1414 if (state == nvmet_ana_state[i].type)
1415 return sprintf(page, "%s\n", nvmet_ana_state[i].name);
1418 return sprintf(page, "\n");
1421 static ssize_t nvmet_ana_group_ana_state_store(struct config_item *item,
1422 const char *page, size_t count)
1424 struct nvmet_ana_group *grp = to_ana_group(item);
1425 enum nvme_ana_state *ana_state = grp->port->ana_state;
1428 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1429 if (sysfs_streq(page, nvmet_ana_state[i].name))
1433 pr_err("Invalid value '%s' for ana_state\n", page);
1437 down_write(&nvmet_ana_sem);
1438 ana_state[grp->grpid] = (enum nvme_ana_state) nvmet_ana_state[i].type;
1440 up_write(&nvmet_ana_sem);
1441 nvmet_port_send_ana_event(grp->port);
1445 CONFIGFS_ATTR(nvmet_ana_group_, ana_state);
1447 static struct configfs_attribute *nvmet_ana_group_attrs[] = {
1448 &nvmet_ana_group_attr_ana_state,
1452 static void nvmet_ana_group_release(struct config_item *item)
1454 struct nvmet_ana_group *grp = to_ana_group(item);
1456 if (grp == &grp->port->ana_default_group)
1459 down_write(&nvmet_ana_sem);
1460 grp->port->ana_state[grp->grpid] = NVME_ANA_INACCESSIBLE;
1461 nvmet_ana_group_enabled[grp->grpid]--;
1462 up_write(&nvmet_ana_sem);
1464 nvmet_port_send_ana_event(grp->port);
1468 static struct configfs_item_operations nvmet_ana_group_item_ops = {
1469 .release = nvmet_ana_group_release,
1472 static const struct config_item_type nvmet_ana_group_type = {
1473 .ct_item_ops = &nvmet_ana_group_item_ops,
1474 .ct_attrs = nvmet_ana_group_attrs,
1475 .ct_owner = THIS_MODULE,
1478 static struct config_group *nvmet_ana_groups_make_group(
1479 struct config_group *group, const char *name)
1481 struct nvmet_port *port = ana_groups_to_port(&group->cg_item);
1482 struct nvmet_ana_group *grp;
1486 ret = kstrtou32(name, 0, &grpid);
1491 if (grpid <= 1 || grpid > NVMET_MAX_ANAGRPS)
1495 grp = kzalloc(sizeof(*grp), GFP_KERNEL);
1501 down_write(&nvmet_ana_sem);
1502 nvmet_ana_group_enabled[grpid]++;
1503 up_write(&nvmet_ana_sem);
1505 nvmet_port_send_ana_event(grp->port);
1507 config_group_init_type_name(&grp->group, name, &nvmet_ana_group_type);
1510 return ERR_PTR(ret);
1513 static struct configfs_group_operations nvmet_ana_groups_group_ops = {
1514 .make_group = nvmet_ana_groups_make_group,
1517 static const struct config_item_type nvmet_ana_groups_type = {
1518 .ct_group_ops = &nvmet_ana_groups_group_ops,
1519 .ct_owner = THIS_MODULE,
1523 * Ports definitions.
1525 static void nvmet_port_release(struct config_item *item)
1527 struct nvmet_port *port = to_nvmet_port(item);
1529 list_del(&port->global_entry);
1531 kfree(port->ana_state);
1535 static struct configfs_attribute *nvmet_port_attrs[] = {
1536 &nvmet_attr_addr_adrfam,
1537 &nvmet_attr_addr_treq,
1538 &nvmet_attr_addr_traddr,
1539 &nvmet_attr_addr_trsvcid,
1540 &nvmet_attr_addr_trtype,
1541 &nvmet_attr_param_inline_data_size,
1542 #ifdef CONFIG_BLK_DEV_INTEGRITY
1543 &nvmet_attr_param_pi_enable,
1548 static struct configfs_item_operations nvmet_port_item_ops = {
1549 .release = nvmet_port_release,
1552 static const struct config_item_type nvmet_port_type = {
1553 .ct_attrs = nvmet_port_attrs,
1554 .ct_item_ops = &nvmet_port_item_ops,
1555 .ct_owner = THIS_MODULE,
1558 static struct config_group *nvmet_ports_make(struct config_group *group,
1561 struct nvmet_port *port;
1565 if (kstrtou16(name, 0, &portid))
1566 return ERR_PTR(-EINVAL);
1568 port = kzalloc(sizeof(*port), GFP_KERNEL);
1570 return ERR_PTR(-ENOMEM);
1572 port->ana_state = kcalloc(NVMET_MAX_ANAGRPS + 1,
1573 sizeof(*port->ana_state), GFP_KERNEL);
1574 if (!port->ana_state) {
1576 return ERR_PTR(-ENOMEM);
1579 for (i = 1; i <= NVMET_MAX_ANAGRPS; i++) {
1580 if (i == NVMET_DEFAULT_ANA_GRPID)
1581 port->ana_state[1] = NVME_ANA_OPTIMIZED;
1583 port->ana_state[i] = NVME_ANA_INACCESSIBLE;
1586 list_add(&port->global_entry, &nvmet_ports_list);
1588 INIT_LIST_HEAD(&port->entry);
1589 INIT_LIST_HEAD(&port->subsystems);
1590 INIT_LIST_HEAD(&port->referrals);
1591 port->inline_data_size = -1; /* < 0 == let the transport choose */
1593 port->disc_addr.portid = cpu_to_le16(portid);
1594 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_MAX;
1595 port->disc_addr.treq = NVMF_TREQ_DISABLE_SQFLOW;
1596 config_group_init_type_name(&port->group, name, &nvmet_port_type);
1598 config_group_init_type_name(&port->subsys_group,
1599 "subsystems", &nvmet_port_subsys_type);
1600 configfs_add_default_group(&port->subsys_group, &port->group);
1602 config_group_init_type_name(&port->referrals_group,
1603 "referrals", &nvmet_referrals_type);
1604 configfs_add_default_group(&port->referrals_group, &port->group);
1606 config_group_init_type_name(&port->ana_groups_group,
1607 "ana_groups", &nvmet_ana_groups_type);
1608 configfs_add_default_group(&port->ana_groups_group, &port->group);
1610 port->ana_default_group.port = port;
1611 port->ana_default_group.grpid = NVMET_DEFAULT_ANA_GRPID;
1612 config_group_init_type_name(&port->ana_default_group.group,
1613 __stringify(NVMET_DEFAULT_ANA_GRPID),
1614 &nvmet_ana_group_type);
1615 configfs_add_default_group(&port->ana_default_group.group,
1616 &port->ana_groups_group);
1618 return &port->group;
1621 static struct configfs_group_operations nvmet_ports_group_ops = {
1622 .make_group = nvmet_ports_make,
1625 static const struct config_item_type nvmet_ports_type = {
1626 .ct_group_ops = &nvmet_ports_group_ops,
1627 .ct_owner = THIS_MODULE,
1630 static struct config_group nvmet_subsystems_group;
1631 static struct config_group nvmet_ports_group;
1633 static void nvmet_host_release(struct config_item *item)
1635 struct nvmet_host *host = to_host(item);
1640 static struct configfs_item_operations nvmet_host_item_ops = {
1641 .release = nvmet_host_release,
1644 static const struct config_item_type nvmet_host_type = {
1645 .ct_item_ops = &nvmet_host_item_ops,
1646 .ct_owner = THIS_MODULE,
1649 static struct config_group *nvmet_hosts_make_group(struct config_group *group,
1652 struct nvmet_host *host;
1654 host = kzalloc(sizeof(*host), GFP_KERNEL);
1656 return ERR_PTR(-ENOMEM);
1658 config_group_init_type_name(&host->group, name, &nvmet_host_type);
1660 return &host->group;
1663 static struct configfs_group_operations nvmet_hosts_group_ops = {
1664 .make_group = nvmet_hosts_make_group,
1667 static const struct config_item_type nvmet_hosts_type = {
1668 .ct_group_ops = &nvmet_hosts_group_ops,
1669 .ct_owner = THIS_MODULE,
1672 static struct config_group nvmet_hosts_group;
1674 static const struct config_item_type nvmet_root_type = {
1675 .ct_owner = THIS_MODULE,
1678 static struct configfs_subsystem nvmet_configfs_subsystem = {
1681 .ci_namebuf = "nvmet",
1682 .ci_type = &nvmet_root_type,
1687 int __init nvmet_init_configfs(void)
1691 config_group_init(&nvmet_configfs_subsystem.su_group);
1692 mutex_init(&nvmet_configfs_subsystem.su_mutex);
1694 config_group_init_type_name(&nvmet_subsystems_group,
1695 "subsystems", &nvmet_subsystems_type);
1696 configfs_add_default_group(&nvmet_subsystems_group,
1697 &nvmet_configfs_subsystem.su_group);
1699 config_group_init_type_name(&nvmet_ports_group,
1700 "ports", &nvmet_ports_type);
1701 configfs_add_default_group(&nvmet_ports_group,
1702 &nvmet_configfs_subsystem.su_group);
1704 config_group_init_type_name(&nvmet_hosts_group,
1705 "hosts", &nvmet_hosts_type);
1706 configfs_add_default_group(&nvmet_hosts_group,
1707 &nvmet_configfs_subsystem.su_group);
1709 ret = configfs_register_subsystem(&nvmet_configfs_subsystem);
1711 pr_err("configfs_register_subsystem: %d\n", ret);
1718 void __exit nvmet_exit_configfs(void)
1720 configfs_unregister_subsystem(&nvmet_configfs_subsystem);