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 static ssize_t nvmet_subsys_attr_serial_show(struct config_item *item,
1036 struct nvmet_subsys *subsys = to_subsys(item);
1038 return snprintf(page, PAGE_SIZE, "%llx\n", subsys->serial);
1041 static ssize_t nvmet_subsys_attr_serial_store(struct config_item *item,
1042 const char *page, size_t count)
1046 if (sscanf(page, "%llx\n", &serial) != 1)
1049 down_write(&nvmet_config_sem);
1050 to_subsys(item)->serial = serial;
1051 up_write(&nvmet_config_sem);
1055 CONFIGFS_ATTR(nvmet_subsys_, attr_serial);
1057 static ssize_t nvmet_subsys_attr_cntlid_min_show(struct config_item *item,
1060 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_min);
1063 static ssize_t nvmet_subsys_attr_cntlid_min_store(struct config_item *item,
1064 const char *page, size_t cnt)
1068 if (sscanf(page, "%hu\n", &cntlid_min) != 1)
1071 if (cntlid_min == 0)
1074 down_write(&nvmet_config_sem);
1075 if (cntlid_min >= to_subsys(item)->cntlid_max)
1077 to_subsys(item)->cntlid_min = cntlid_min;
1078 up_write(&nvmet_config_sem);
1082 up_write(&nvmet_config_sem);
1085 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_min);
1087 static ssize_t nvmet_subsys_attr_cntlid_max_show(struct config_item *item,
1090 return snprintf(page, PAGE_SIZE, "%u\n", to_subsys(item)->cntlid_max);
1093 static ssize_t nvmet_subsys_attr_cntlid_max_store(struct config_item *item,
1094 const char *page, size_t cnt)
1098 if (sscanf(page, "%hu\n", &cntlid_max) != 1)
1101 if (cntlid_max == 0)
1104 down_write(&nvmet_config_sem);
1105 if (cntlid_max <= to_subsys(item)->cntlid_min)
1107 to_subsys(item)->cntlid_max = cntlid_max;
1108 up_write(&nvmet_config_sem);
1112 up_write(&nvmet_config_sem);
1115 CONFIGFS_ATTR(nvmet_subsys_, attr_cntlid_max);
1117 static ssize_t nvmet_subsys_attr_model_show(struct config_item *item,
1120 struct nvmet_subsys *subsys = to_subsys(item);
1121 struct nvmet_subsys_model *subsys_model;
1122 char *model = NVMET_DEFAULT_CTRL_MODEL;
1126 subsys_model = rcu_dereference(subsys->model);
1128 model = subsys_model->number;
1129 ret = snprintf(page, PAGE_SIZE, "%s\n", model);
1135 /* See Section 1.5 of NVMe 1.4 */
1136 static bool nvmet_is_ascii(const char c)
1138 return c >= 0x20 && c <= 0x7e;
1141 static ssize_t nvmet_subsys_attr_model_store(struct config_item *item,
1142 const char *page, size_t count)
1144 struct nvmet_subsys *subsys = to_subsys(item);
1145 struct nvmet_subsys_model *new_model;
1146 char *new_model_number;
1149 len = strcspn(page, "\n");
1153 for (pos = 0; pos < len; pos++) {
1154 if (!nvmet_is_ascii(page[pos]))
1158 new_model_number = kmemdup_nul(page, len, GFP_KERNEL);
1159 if (!new_model_number)
1162 new_model = kzalloc(sizeof(*new_model) + len + 1, GFP_KERNEL);
1164 kfree(new_model_number);
1167 memcpy(new_model->number, new_model_number, len);
1169 down_write(&nvmet_config_sem);
1170 mutex_lock(&subsys->lock);
1171 new_model = rcu_replace_pointer(subsys->model, new_model,
1172 mutex_is_locked(&subsys->lock));
1173 mutex_unlock(&subsys->lock);
1174 up_write(&nvmet_config_sem);
1176 kfree_rcu(new_model, rcuhead);
1177 kfree(new_model_number);
1181 CONFIGFS_ATTR(nvmet_subsys_, attr_model);
1183 #ifdef CONFIG_BLK_DEV_INTEGRITY
1184 static ssize_t nvmet_subsys_attr_pi_enable_show(struct config_item *item,
1187 return snprintf(page, PAGE_SIZE, "%d\n", to_subsys(item)->pi_support);
1190 static ssize_t nvmet_subsys_attr_pi_enable_store(struct config_item *item,
1191 const char *page, size_t count)
1193 struct nvmet_subsys *subsys = to_subsys(item);
1196 if (strtobool(page, &pi_enable))
1199 subsys->pi_support = pi_enable;
1202 CONFIGFS_ATTR(nvmet_subsys_, attr_pi_enable);
1205 static struct configfs_attribute *nvmet_subsys_attrs[] = {
1206 &nvmet_subsys_attr_attr_allow_any_host,
1207 &nvmet_subsys_attr_attr_version,
1208 &nvmet_subsys_attr_attr_serial,
1209 &nvmet_subsys_attr_attr_cntlid_min,
1210 &nvmet_subsys_attr_attr_cntlid_max,
1211 &nvmet_subsys_attr_attr_model,
1212 #ifdef CONFIG_BLK_DEV_INTEGRITY
1213 &nvmet_subsys_attr_attr_pi_enable,
1219 * Subsystem structures & folder operation functions below
1221 static void nvmet_subsys_release(struct config_item *item)
1223 struct nvmet_subsys *subsys = to_subsys(item);
1225 nvmet_subsys_del_ctrls(subsys);
1226 nvmet_subsys_put(subsys);
1229 static struct configfs_item_operations nvmet_subsys_item_ops = {
1230 .release = nvmet_subsys_release,
1233 static const struct config_item_type nvmet_subsys_type = {
1234 .ct_item_ops = &nvmet_subsys_item_ops,
1235 .ct_attrs = nvmet_subsys_attrs,
1236 .ct_owner = THIS_MODULE,
1239 static struct config_group *nvmet_subsys_make(struct config_group *group,
1242 struct nvmet_subsys *subsys;
1244 if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
1245 pr_err("can't create discovery subsystem through configfs\n");
1246 return ERR_PTR(-EINVAL);
1249 subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
1251 return ERR_CAST(subsys);
1253 config_group_init_type_name(&subsys->group, name, &nvmet_subsys_type);
1255 config_group_init_type_name(&subsys->namespaces_group,
1256 "namespaces", &nvmet_namespaces_type);
1257 configfs_add_default_group(&subsys->namespaces_group, &subsys->group);
1259 config_group_init_type_name(&subsys->allowed_hosts_group,
1260 "allowed_hosts", &nvmet_allowed_hosts_type);
1261 configfs_add_default_group(&subsys->allowed_hosts_group,
1264 nvmet_add_passthru_group(subsys);
1266 return &subsys->group;
1269 static struct configfs_group_operations nvmet_subsystems_group_ops = {
1270 .make_group = nvmet_subsys_make,
1273 static const struct config_item_type nvmet_subsystems_type = {
1274 .ct_group_ops = &nvmet_subsystems_group_ops,
1275 .ct_owner = THIS_MODULE,
1278 static ssize_t nvmet_referral_enable_show(struct config_item *item,
1281 return snprintf(page, PAGE_SIZE, "%d\n", to_nvmet_port(item)->enabled);
1284 static ssize_t nvmet_referral_enable_store(struct config_item *item,
1285 const char *page, size_t count)
1287 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1288 struct nvmet_port *port = to_nvmet_port(item);
1291 if (strtobool(page, &enable))
1295 nvmet_referral_enable(parent, port);
1297 nvmet_referral_disable(parent, port);
1301 pr_err("Invalid value '%s' for enable\n", page);
1305 CONFIGFS_ATTR(nvmet_referral_, enable);
1308 * Discovery Service subsystem definitions
1310 static struct configfs_attribute *nvmet_referral_attrs[] = {
1311 &nvmet_attr_addr_adrfam,
1312 &nvmet_attr_addr_portid,
1313 &nvmet_attr_addr_treq,
1314 &nvmet_attr_addr_traddr,
1315 &nvmet_attr_addr_trsvcid,
1316 &nvmet_attr_addr_trtype,
1317 &nvmet_referral_attr_enable,
1321 static void nvmet_referral_notify(struct config_group *group,
1322 struct config_item *item)
1324 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
1325 struct nvmet_port *port = to_nvmet_port(item);
1327 nvmet_referral_disable(parent, port);
1330 static void nvmet_referral_release(struct config_item *item)
1332 struct nvmet_port *port = to_nvmet_port(item);
1337 static struct configfs_item_operations nvmet_referral_item_ops = {
1338 .release = nvmet_referral_release,
1341 static const struct config_item_type nvmet_referral_type = {
1342 .ct_owner = THIS_MODULE,
1343 .ct_attrs = nvmet_referral_attrs,
1344 .ct_item_ops = &nvmet_referral_item_ops,
1347 static struct config_group *nvmet_referral_make(
1348 struct config_group *group, const char *name)
1350 struct nvmet_port *port;
1352 port = kzalloc(sizeof(*port), GFP_KERNEL);
1354 return ERR_PTR(-ENOMEM);
1356 INIT_LIST_HEAD(&port->entry);
1357 config_group_init_type_name(&port->group, name, &nvmet_referral_type);
1359 return &port->group;
1362 static struct configfs_group_operations nvmet_referral_group_ops = {
1363 .make_group = nvmet_referral_make,
1364 .disconnect_notify = nvmet_referral_notify,
1367 static const struct config_item_type nvmet_referrals_type = {
1368 .ct_owner = THIS_MODULE,
1369 .ct_group_ops = &nvmet_referral_group_ops,
1372 static struct nvmet_type_name_map nvmet_ana_state[] = {
1373 { NVME_ANA_OPTIMIZED, "optimized" },
1374 { NVME_ANA_NONOPTIMIZED, "non-optimized" },
1375 { NVME_ANA_INACCESSIBLE, "inaccessible" },
1376 { NVME_ANA_PERSISTENT_LOSS, "persistent-loss" },
1377 { NVME_ANA_CHANGE, "change" },
1380 static ssize_t nvmet_ana_group_ana_state_show(struct config_item *item,
1383 struct nvmet_ana_group *grp = to_ana_group(item);
1384 enum nvme_ana_state state = grp->port->ana_state[grp->grpid];
1387 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1388 if (state == nvmet_ana_state[i].type)
1389 return sprintf(page, "%s\n", nvmet_ana_state[i].name);
1392 return sprintf(page, "\n");
1395 static ssize_t nvmet_ana_group_ana_state_store(struct config_item *item,
1396 const char *page, size_t count)
1398 struct nvmet_ana_group *grp = to_ana_group(item);
1399 enum nvme_ana_state *ana_state = grp->port->ana_state;
1402 for (i = 0; i < ARRAY_SIZE(nvmet_ana_state); i++) {
1403 if (sysfs_streq(page, nvmet_ana_state[i].name))
1407 pr_err("Invalid value '%s' for ana_state\n", page);
1411 down_write(&nvmet_ana_sem);
1412 ana_state[grp->grpid] = (enum nvme_ana_state) nvmet_ana_state[i].type;
1414 up_write(&nvmet_ana_sem);
1415 nvmet_port_send_ana_event(grp->port);
1419 CONFIGFS_ATTR(nvmet_ana_group_, ana_state);
1421 static struct configfs_attribute *nvmet_ana_group_attrs[] = {
1422 &nvmet_ana_group_attr_ana_state,
1426 static void nvmet_ana_group_release(struct config_item *item)
1428 struct nvmet_ana_group *grp = to_ana_group(item);
1430 if (grp == &grp->port->ana_default_group)
1433 down_write(&nvmet_ana_sem);
1434 grp->port->ana_state[grp->grpid] = NVME_ANA_INACCESSIBLE;
1435 nvmet_ana_group_enabled[grp->grpid]--;
1436 up_write(&nvmet_ana_sem);
1438 nvmet_port_send_ana_event(grp->port);
1442 static struct configfs_item_operations nvmet_ana_group_item_ops = {
1443 .release = nvmet_ana_group_release,
1446 static const struct config_item_type nvmet_ana_group_type = {
1447 .ct_item_ops = &nvmet_ana_group_item_ops,
1448 .ct_attrs = nvmet_ana_group_attrs,
1449 .ct_owner = THIS_MODULE,
1452 static struct config_group *nvmet_ana_groups_make_group(
1453 struct config_group *group, const char *name)
1455 struct nvmet_port *port = ana_groups_to_port(&group->cg_item);
1456 struct nvmet_ana_group *grp;
1460 ret = kstrtou32(name, 0, &grpid);
1465 if (grpid <= 1 || grpid > NVMET_MAX_ANAGRPS)
1469 grp = kzalloc(sizeof(*grp), GFP_KERNEL);
1475 down_write(&nvmet_ana_sem);
1476 nvmet_ana_group_enabled[grpid]++;
1477 up_write(&nvmet_ana_sem);
1479 nvmet_port_send_ana_event(grp->port);
1481 config_group_init_type_name(&grp->group, name, &nvmet_ana_group_type);
1484 return ERR_PTR(ret);
1487 static struct configfs_group_operations nvmet_ana_groups_group_ops = {
1488 .make_group = nvmet_ana_groups_make_group,
1491 static const struct config_item_type nvmet_ana_groups_type = {
1492 .ct_group_ops = &nvmet_ana_groups_group_ops,
1493 .ct_owner = THIS_MODULE,
1497 * Ports definitions.
1499 static void nvmet_port_release(struct config_item *item)
1501 struct nvmet_port *port = to_nvmet_port(item);
1503 list_del(&port->global_entry);
1505 kfree(port->ana_state);
1509 static struct configfs_attribute *nvmet_port_attrs[] = {
1510 &nvmet_attr_addr_adrfam,
1511 &nvmet_attr_addr_treq,
1512 &nvmet_attr_addr_traddr,
1513 &nvmet_attr_addr_trsvcid,
1514 &nvmet_attr_addr_trtype,
1515 &nvmet_attr_param_inline_data_size,
1516 #ifdef CONFIG_BLK_DEV_INTEGRITY
1517 &nvmet_attr_param_pi_enable,
1522 static struct configfs_item_operations nvmet_port_item_ops = {
1523 .release = nvmet_port_release,
1526 static const struct config_item_type nvmet_port_type = {
1527 .ct_attrs = nvmet_port_attrs,
1528 .ct_item_ops = &nvmet_port_item_ops,
1529 .ct_owner = THIS_MODULE,
1532 static struct config_group *nvmet_ports_make(struct config_group *group,
1535 struct nvmet_port *port;
1539 if (kstrtou16(name, 0, &portid))
1540 return ERR_PTR(-EINVAL);
1542 port = kzalloc(sizeof(*port), GFP_KERNEL);
1544 return ERR_PTR(-ENOMEM);
1546 port->ana_state = kcalloc(NVMET_MAX_ANAGRPS + 1,
1547 sizeof(*port->ana_state), GFP_KERNEL);
1548 if (!port->ana_state) {
1550 return ERR_PTR(-ENOMEM);
1553 for (i = 1; i <= NVMET_MAX_ANAGRPS; i++) {
1554 if (i == NVMET_DEFAULT_ANA_GRPID)
1555 port->ana_state[1] = NVME_ANA_OPTIMIZED;
1557 port->ana_state[i] = NVME_ANA_INACCESSIBLE;
1560 list_add(&port->global_entry, &nvmet_ports_list);
1562 INIT_LIST_HEAD(&port->entry);
1563 INIT_LIST_HEAD(&port->subsystems);
1564 INIT_LIST_HEAD(&port->referrals);
1565 port->inline_data_size = -1; /* < 0 == let the transport choose */
1567 port->disc_addr.portid = cpu_to_le16(portid);
1568 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_MAX;
1569 port->disc_addr.treq = NVMF_TREQ_DISABLE_SQFLOW;
1570 config_group_init_type_name(&port->group, name, &nvmet_port_type);
1572 config_group_init_type_name(&port->subsys_group,
1573 "subsystems", &nvmet_port_subsys_type);
1574 configfs_add_default_group(&port->subsys_group, &port->group);
1576 config_group_init_type_name(&port->referrals_group,
1577 "referrals", &nvmet_referrals_type);
1578 configfs_add_default_group(&port->referrals_group, &port->group);
1580 config_group_init_type_name(&port->ana_groups_group,
1581 "ana_groups", &nvmet_ana_groups_type);
1582 configfs_add_default_group(&port->ana_groups_group, &port->group);
1584 port->ana_default_group.port = port;
1585 port->ana_default_group.grpid = NVMET_DEFAULT_ANA_GRPID;
1586 config_group_init_type_name(&port->ana_default_group.group,
1587 __stringify(NVMET_DEFAULT_ANA_GRPID),
1588 &nvmet_ana_group_type);
1589 configfs_add_default_group(&port->ana_default_group.group,
1590 &port->ana_groups_group);
1592 return &port->group;
1595 static struct configfs_group_operations nvmet_ports_group_ops = {
1596 .make_group = nvmet_ports_make,
1599 static const struct config_item_type nvmet_ports_type = {
1600 .ct_group_ops = &nvmet_ports_group_ops,
1601 .ct_owner = THIS_MODULE,
1604 static struct config_group nvmet_subsystems_group;
1605 static struct config_group nvmet_ports_group;
1607 static void nvmet_host_release(struct config_item *item)
1609 struct nvmet_host *host = to_host(item);
1614 static struct configfs_item_operations nvmet_host_item_ops = {
1615 .release = nvmet_host_release,
1618 static const struct config_item_type nvmet_host_type = {
1619 .ct_item_ops = &nvmet_host_item_ops,
1620 .ct_owner = THIS_MODULE,
1623 static struct config_group *nvmet_hosts_make_group(struct config_group *group,
1626 struct nvmet_host *host;
1628 host = kzalloc(sizeof(*host), GFP_KERNEL);
1630 return ERR_PTR(-ENOMEM);
1632 config_group_init_type_name(&host->group, name, &nvmet_host_type);
1634 return &host->group;
1637 static struct configfs_group_operations nvmet_hosts_group_ops = {
1638 .make_group = nvmet_hosts_make_group,
1641 static const struct config_item_type nvmet_hosts_type = {
1642 .ct_group_ops = &nvmet_hosts_group_ops,
1643 .ct_owner = THIS_MODULE,
1646 static struct config_group nvmet_hosts_group;
1648 static const struct config_item_type nvmet_root_type = {
1649 .ct_owner = THIS_MODULE,
1652 static struct configfs_subsystem nvmet_configfs_subsystem = {
1655 .ci_namebuf = "nvmet",
1656 .ci_type = &nvmet_root_type,
1661 int __init nvmet_init_configfs(void)
1665 config_group_init(&nvmet_configfs_subsystem.su_group);
1666 mutex_init(&nvmet_configfs_subsystem.su_mutex);
1668 config_group_init_type_name(&nvmet_subsystems_group,
1669 "subsystems", &nvmet_subsystems_type);
1670 configfs_add_default_group(&nvmet_subsystems_group,
1671 &nvmet_configfs_subsystem.su_group);
1673 config_group_init_type_name(&nvmet_ports_group,
1674 "ports", &nvmet_ports_type);
1675 configfs_add_default_group(&nvmet_ports_group,
1676 &nvmet_configfs_subsystem.su_group);
1678 config_group_init_type_name(&nvmet_hosts_group,
1679 "hosts", &nvmet_hosts_type);
1680 configfs_add_default_group(&nvmet_hosts_group,
1681 &nvmet_configfs_subsystem.su_group);
1683 ret = configfs_register_subsystem(&nvmet_configfs_subsystem);
1685 pr_err("configfs_register_subsystem: %d\n", ret);
1692 void __exit nvmet_exit_configfs(void)
1694 configfs_unregister_subsystem(&nvmet_configfs_subsystem);