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