blob: af5e2dc4a3d503bb8bca93951bcfa3be58685ca5 [file] [log] [blame]
Christoph Hellwiga07b4972016-06-21 18:04:20 +02001/*
2 * Configfs interface for the NVMe target.
3 * Copyright (c) 2015-2016 HGST, a Western Digital Company.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/stat.h>
19#include <linux/ctype.h>
20
21#include "nvmet.h"
22
23static struct config_item_type nvmet_host_type;
24static struct config_item_type nvmet_subsys_type;
25
26/*
27 * nvmet_port Generic ConfigFS definitions.
28 * Used in any place in the ConfigFS tree that refers to an address.
29 */
30static ssize_t nvmet_addr_adrfam_show(struct config_item *item,
31 char *page)
32{
33 switch (to_nvmet_port(item)->disc_addr.adrfam) {
34 case NVMF_ADDR_FAMILY_IP4:
35 return sprintf(page, "ipv4\n");
36 case NVMF_ADDR_FAMILY_IP6:
37 return sprintf(page, "ipv6\n");
38 case NVMF_ADDR_FAMILY_IB:
39 return sprintf(page, "ib\n");
40 default:
41 return sprintf(page, "\n");
42 }
43}
44
45static ssize_t nvmet_addr_adrfam_store(struct config_item *item,
46 const char *page, size_t count)
47{
48 struct nvmet_port *port = to_nvmet_port(item);
49
50 if (port->enabled) {
51 pr_err("Cannot modify address while enabled\n");
52 pr_err("Disable the address before modifying\n");
53 return -EACCES;
54 }
55
56 if (sysfs_streq(page, "ipv4")) {
57 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_IP4;
58 } else if (sysfs_streq(page, "ipv6")) {
59 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_IP6;
60 } else if (sysfs_streq(page, "ib")) {
61 port->disc_addr.adrfam = NVMF_ADDR_FAMILY_IB;
62 } else {
63 pr_err("Invalid value '%s' for adrfam\n", page);
64 return -EINVAL;
65 }
66
67 return count;
68}
69
70CONFIGFS_ATTR(nvmet_, addr_adrfam);
71
72static ssize_t nvmet_addr_portid_show(struct config_item *item,
73 char *page)
74{
75 struct nvmet_port *port = to_nvmet_port(item);
76
77 return snprintf(page, PAGE_SIZE, "%d\n",
78 le16_to_cpu(port->disc_addr.portid));
79}
80
81static ssize_t nvmet_addr_portid_store(struct config_item *item,
82 const char *page, size_t count)
83{
84 struct nvmet_port *port = to_nvmet_port(item);
85 u16 portid = 0;
86
87 if (kstrtou16(page, 0, &portid)) {
88 pr_err("Invalid value '%s' for portid\n", page);
89 return -EINVAL;
90 }
91
92 if (port->enabled) {
93 pr_err("Cannot modify address while enabled\n");
94 pr_err("Disable the address before modifying\n");
95 return -EACCES;
96 }
97 port->disc_addr.portid = cpu_to_le16(portid);
98 return count;
99}
100
101CONFIGFS_ATTR(nvmet_, addr_portid);
102
103static ssize_t nvmet_addr_traddr_show(struct config_item *item,
104 char *page)
105{
106 struct nvmet_port *port = to_nvmet_port(item);
107
108 return snprintf(page, PAGE_SIZE, "%s\n",
109 port->disc_addr.traddr);
110}
111
112static ssize_t nvmet_addr_traddr_store(struct config_item *item,
113 const char *page, size_t count)
114{
115 struct nvmet_port *port = to_nvmet_port(item);
116
117 if (count > NVMF_TRADDR_SIZE) {
118 pr_err("Invalid value '%s' for traddr\n", page);
119 return -EINVAL;
120 }
121
122 if (port->enabled) {
123 pr_err("Cannot modify address while enabled\n");
124 pr_err("Disable the address before modifying\n");
125 return -EACCES;
126 }
127 return snprintf(port->disc_addr.traddr,
128 sizeof(port->disc_addr.traddr), "%s", page);
129}
130
131CONFIGFS_ATTR(nvmet_, addr_traddr);
132
133static ssize_t nvmet_addr_treq_show(struct config_item *item,
134 char *page)
135{
136 switch (to_nvmet_port(item)->disc_addr.treq) {
137 case NVMF_TREQ_NOT_SPECIFIED:
138 return sprintf(page, "not specified\n");
139 case NVMF_TREQ_REQUIRED:
140 return sprintf(page, "required\n");
141 case NVMF_TREQ_NOT_REQUIRED:
142 return sprintf(page, "not required\n");
143 default:
144 return sprintf(page, "\n");
145 }
146}
147
148static ssize_t nvmet_addr_treq_store(struct config_item *item,
149 const char *page, size_t count)
150{
151 struct nvmet_port *port = to_nvmet_port(item);
152
153 if (port->enabled) {
154 pr_err("Cannot modify address while enabled\n");
155 pr_err("Disable the address before modifying\n");
156 return -EACCES;
157 }
158
159 if (sysfs_streq(page, "not specified")) {
160 port->disc_addr.treq = NVMF_TREQ_NOT_SPECIFIED;
161 } else if (sysfs_streq(page, "required")) {
162 port->disc_addr.treq = NVMF_TREQ_REQUIRED;
163 } else if (sysfs_streq(page, "not required")) {
164 port->disc_addr.treq = NVMF_TREQ_NOT_REQUIRED;
165 } else {
166 pr_err("Invalid value '%s' for treq\n", page);
167 return -EINVAL;
168 }
169
170 return count;
171}
172
173CONFIGFS_ATTR(nvmet_, addr_treq);
174
175static ssize_t nvmet_addr_trsvcid_show(struct config_item *item,
176 char *page)
177{
178 struct nvmet_port *port = to_nvmet_port(item);
179
180 return snprintf(page, PAGE_SIZE, "%s\n",
181 port->disc_addr.trsvcid);
182}
183
184static ssize_t nvmet_addr_trsvcid_store(struct config_item *item,
185 const char *page, size_t count)
186{
187 struct nvmet_port *port = to_nvmet_port(item);
188
189 if (count > NVMF_TRSVCID_SIZE) {
190 pr_err("Invalid value '%s' for trsvcid\n", page);
191 return -EINVAL;
192 }
193 if (port->enabled) {
194 pr_err("Cannot modify address while enabled\n");
195 pr_err("Disable the address before modifying\n");
196 return -EACCES;
197 }
198 return snprintf(port->disc_addr.trsvcid,
199 sizeof(port->disc_addr.trsvcid), "%s", page);
200}
201
202CONFIGFS_ATTR(nvmet_, addr_trsvcid);
203
204static ssize_t nvmet_addr_trtype_show(struct config_item *item,
205 char *page)
206{
207 switch (to_nvmet_port(item)->disc_addr.trtype) {
208 case NVMF_TRTYPE_RDMA:
209 return sprintf(page, "rdma\n");
210 case NVMF_TRTYPE_LOOP:
211 return sprintf(page, "loop\n");
212 default:
213 return sprintf(page, "\n");
214 }
215}
216
217static void nvmet_port_init_tsas_rdma(struct nvmet_port *port)
218{
219 port->disc_addr.trtype = NVMF_TRTYPE_RDMA;
220 memset(&port->disc_addr.tsas.rdma, 0, NVMF_TSAS_SIZE);
221 port->disc_addr.tsas.rdma.qptype = NVMF_RDMA_QPTYPE_CONNECTED;
222 port->disc_addr.tsas.rdma.prtype = NVMF_RDMA_PRTYPE_NOT_SPECIFIED;
223 port->disc_addr.tsas.rdma.cms = NVMF_RDMA_CMS_RDMA_CM;
224}
225
226static void nvmet_port_init_tsas_loop(struct nvmet_port *port)
227{
228 port->disc_addr.trtype = NVMF_TRTYPE_LOOP;
229 memset(&port->disc_addr.tsas, 0, NVMF_TSAS_SIZE);
230}
231
232static ssize_t nvmet_addr_trtype_store(struct config_item *item,
233 const char *page, size_t count)
234{
235 struct nvmet_port *port = to_nvmet_port(item);
236
237 if (port->enabled) {
238 pr_err("Cannot modify address while enabled\n");
239 pr_err("Disable the address before modifying\n");
240 return -EACCES;
241 }
242
243 if (sysfs_streq(page, "rdma")) {
244 nvmet_port_init_tsas_rdma(port);
245 } else if (sysfs_streq(page, "loop")) {
246 nvmet_port_init_tsas_loop(port);
247 } else {
248 pr_err("Invalid value '%s' for trtype\n", page);
249 return -EINVAL;
250 }
251
252 return count;
253}
254
255CONFIGFS_ATTR(nvmet_, addr_trtype);
256
257/*
258 * Namespace structures & file operation functions below
259 */
260static ssize_t nvmet_ns_device_path_show(struct config_item *item, char *page)
261{
262 return sprintf(page, "%s\n", to_nvmet_ns(item)->device_path);
263}
264
265static ssize_t nvmet_ns_device_path_store(struct config_item *item,
266 const char *page, size_t count)
267{
268 struct nvmet_ns *ns = to_nvmet_ns(item);
269 struct nvmet_subsys *subsys = ns->subsys;
270 int ret;
271
272 mutex_lock(&subsys->lock);
273 ret = -EBUSY;
274 if (nvmet_ns_enabled(ns))
275 goto out_unlock;
276
277 kfree(ns->device_path);
278
279 ret = -ENOMEM;
280 ns->device_path = kstrdup(page, GFP_KERNEL);
281 if (!ns->device_path)
282 goto out_unlock;
283
284 mutex_unlock(&subsys->lock);
285 return count;
286
287out_unlock:
288 mutex_unlock(&subsys->lock);
289 return ret;
290}
291
292CONFIGFS_ATTR(nvmet_ns_, device_path);
293
294static ssize_t nvmet_ns_device_nguid_show(struct config_item *item, char *page)
295{
296 return sprintf(page, "%pUb\n", &to_nvmet_ns(item)->nguid);
297}
298
299static ssize_t nvmet_ns_device_nguid_store(struct config_item *item,
300 const char *page, size_t count)
301{
302 struct nvmet_ns *ns = to_nvmet_ns(item);
303 struct nvmet_subsys *subsys = ns->subsys;
304 u8 nguid[16];
305 const char *p = page;
306 int i;
307 int ret = 0;
308
309 mutex_lock(&subsys->lock);
310 if (nvmet_ns_enabled(ns)) {
311 ret = -EBUSY;
312 goto out_unlock;
313 }
314
315 for (i = 0; i < 16; i++) {
316 if (p + 2 > page + count) {
317 ret = -EINVAL;
318 goto out_unlock;
319 }
320 if (!isxdigit(p[0]) || !isxdigit(p[1])) {
321 ret = -EINVAL;
322 goto out_unlock;
323 }
324
325 nguid[i] = (hex_to_bin(p[0]) << 4) | hex_to_bin(p[1]);
326 p += 2;
327
328 if (*p == '-' || *p == ':')
329 p++;
330 }
331
332 memcpy(&ns->nguid, nguid, sizeof(nguid));
333out_unlock:
334 mutex_unlock(&subsys->lock);
335 return ret ? ret : count;
336}
337
338CONFIGFS_ATTR(nvmet_ns_, device_nguid);
339
340static ssize_t nvmet_ns_enable_show(struct config_item *item, char *page)
341{
342 return sprintf(page, "%d\n", nvmet_ns_enabled(to_nvmet_ns(item)));
343}
344
345static ssize_t nvmet_ns_enable_store(struct config_item *item,
346 const char *page, size_t count)
347{
348 struct nvmet_ns *ns = to_nvmet_ns(item);
349 bool enable;
350 int ret = 0;
351
352 if (strtobool(page, &enable))
353 return -EINVAL;
354
355 if (enable)
356 ret = nvmet_ns_enable(ns);
357 else
358 nvmet_ns_disable(ns);
359
360 return ret ? ret : count;
361}
362
363CONFIGFS_ATTR(nvmet_ns_, enable);
364
365static struct configfs_attribute *nvmet_ns_attrs[] = {
366 &nvmet_ns_attr_device_path,
367 &nvmet_ns_attr_device_nguid,
368 &nvmet_ns_attr_enable,
369 NULL,
370};
371
372static void nvmet_ns_release(struct config_item *item)
373{
374 struct nvmet_ns *ns = to_nvmet_ns(item);
375
376 nvmet_ns_free(ns);
377}
378
379static struct configfs_item_operations nvmet_ns_item_ops = {
380 .release = nvmet_ns_release,
381};
382
383static struct config_item_type nvmet_ns_type = {
384 .ct_item_ops = &nvmet_ns_item_ops,
385 .ct_attrs = nvmet_ns_attrs,
386 .ct_owner = THIS_MODULE,
387};
388
389static struct config_group *nvmet_ns_make(struct config_group *group,
390 const char *name)
391{
392 struct nvmet_subsys *subsys = namespaces_to_subsys(&group->cg_item);
393 struct nvmet_ns *ns;
394 int ret;
395 u32 nsid;
396
397 ret = kstrtou32(name, 0, &nsid);
398 if (ret)
399 goto out;
400
401 ret = -EINVAL;
402 if (nsid == 0 || nsid == 0xffffffff)
403 goto out;
404
405 ret = -ENOMEM;
406 ns = nvmet_ns_alloc(subsys, nsid);
407 if (!ns)
408 goto out;
409 config_group_init_type_name(&ns->group, name, &nvmet_ns_type);
410
411 pr_info("adding nsid %d to subsystem %s\n", nsid, subsys->subsysnqn);
412
413 return &ns->group;
414out:
415 return ERR_PTR(ret);
416}
417
418static struct configfs_group_operations nvmet_namespaces_group_ops = {
419 .make_group = nvmet_ns_make,
420};
421
422static struct config_item_type nvmet_namespaces_type = {
423 .ct_group_ops = &nvmet_namespaces_group_ops,
424 .ct_owner = THIS_MODULE,
425};
426
427static int nvmet_port_subsys_allow_link(struct config_item *parent,
428 struct config_item *target)
429{
430 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
431 struct nvmet_subsys *subsys;
432 struct nvmet_subsys_link *link, *p;
433 int ret;
434
435 if (target->ci_type != &nvmet_subsys_type) {
436 pr_err("can only link subsystems into the subsystems dir.!\n");
437 return -EINVAL;
438 }
439 subsys = to_subsys(target);
440 link = kmalloc(sizeof(*link), GFP_KERNEL);
441 if (!link)
442 return -ENOMEM;
443 link->subsys = subsys;
444
445 down_write(&nvmet_config_sem);
446 ret = -EEXIST;
447 list_for_each_entry(p, &port->subsystems, entry) {
448 if (p->subsys == subsys)
449 goto out_free_link;
450 }
451
452 if (list_empty(&port->subsystems)) {
453 ret = nvmet_enable_port(port);
454 if (ret)
455 goto out_free_link;
456 }
457
458 list_add_tail(&link->entry, &port->subsystems);
459 nvmet_genctr++;
460 up_write(&nvmet_config_sem);
461 return 0;
462
463out_free_link:
464 up_write(&nvmet_config_sem);
465 kfree(link);
466 return ret;
467}
468
469static int nvmet_port_subsys_drop_link(struct config_item *parent,
470 struct config_item *target)
471{
472 struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
473 struct nvmet_subsys *subsys = to_subsys(target);
474 struct nvmet_subsys_link *p;
475
476 down_write(&nvmet_config_sem);
477 list_for_each_entry(p, &port->subsystems, entry) {
478 if (p->subsys == subsys)
479 goto found;
480 }
481 up_write(&nvmet_config_sem);
482 return -EINVAL;
483
484found:
485 list_del(&p->entry);
486 nvmet_genctr++;
487 if (list_empty(&port->subsystems))
488 nvmet_disable_port(port);
489 up_write(&nvmet_config_sem);
490 kfree(p);
491 return 0;
492}
493
494static struct configfs_item_operations nvmet_port_subsys_item_ops = {
495 .allow_link = nvmet_port_subsys_allow_link,
496 .drop_link = nvmet_port_subsys_drop_link,
497};
498
499static struct config_item_type nvmet_port_subsys_type = {
500 .ct_item_ops = &nvmet_port_subsys_item_ops,
501 .ct_owner = THIS_MODULE,
502};
503
504static int nvmet_allowed_hosts_allow_link(struct config_item *parent,
505 struct config_item *target)
506{
507 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
508 struct nvmet_host *host;
509 struct nvmet_host_link *link, *p;
510 int ret;
511
512 if (target->ci_type != &nvmet_host_type) {
513 pr_err("can only link hosts into the allowed_hosts directory!\n");
514 return -EINVAL;
515 }
516
517 host = to_host(target);
518 link = kmalloc(sizeof(*link), GFP_KERNEL);
519 if (!link)
520 return -ENOMEM;
521 link->host = host;
522
523 down_write(&nvmet_config_sem);
524 ret = -EINVAL;
525 if (subsys->allow_any_host) {
526 pr_err("can't add hosts when allow_any_host is set!\n");
527 goto out_free_link;
528 }
529
530 ret = -EEXIST;
531 list_for_each_entry(p, &subsys->hosts, entry) {
532 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
533 goto out_free_link;
534 }
535 list_add_tail(&link->entry, &subsys->hosts);
536 nvmet_genctr++;
537 up_write(&nvmet_config_sem);
538 return 0;
539out_free_link:
540 up_write(&nvmet_config_sem);
541 kfree(link);
542 return ret;
543}
544
545static int nvmet_allowed_hosts_drop_link(struct config_item *parent,
546 struct config_item *target)
547{
548 struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
549 struct nvmet_host *host = to_host(target);
550 struct nvmet_host_link *p;
551
552 down_write(&nvmet_config_sem);
553 list_for_each_entry(p, &subsys->hosts, entry) {
554 if (!strcmp(nvmet_host_name(p->host), nvmet_host_name(host)))
555 goto found;
556 }
557 up_write(&nvmet_config_sem);
558 return -EINVAL;
559
560found:
561 list_del(&p->entry);
562 nvmet_genctr++;
563 up_write(&nvmet_config_sem);
564 kfree(p);
565 return 0;
566}
567
568static struct configfs_item_operations nvmet_allowed_hosts_item_ops = {
569 .allow_link = nvmet_allowed_hosts_allow_link,
570 .drop_link = nvmet_allowed_hosts_drop_link,
571};
572
573static struct config_item_type nvmet_allowed_hosts_type = {
574 .ct_item_ops = &nvmet_allowed_hosts_item_ops,
575 .ct_owner = THIS_MODULE,
576};
577
578static ssize_t nvmet_subsys_attr_allow_any_host_show(struct config_item *item,
579 char *page)
580{
581 return snprintf(page, PAGE_SIZE, "%d\n",
582 to_subsys(item)->allow_any_host);
583}
584
585static ssize_t nvmet_subsys_attr_allow_any_host_store(struct config_item *item,
586 const char *page, size_t count)
587{
588 struct nvmet_subsys *subsys = to_subsys(item);
589 bool allow_any_host;
590 int ret = 0;
591
592 if (strtobool(page, &allow_any_host))
593 return -EINVAL;
594
595 down_write(&nvmet_config_sem);
596 if (allow_any_host && !list_empty(&subsys->hosts)) {
597 pr_err("Can't set allow_any_host when explicit hosts are set!\n");
598 ret = -EINVAL;
599 goto out_unlock;
600 }
601
602 subsys->allow_any_host = allow_any_host;
603out_unlock:
604 up_write(&nvmet_config_sem);
605 return ret ? ret : count;
606}
607
608CONFIGFS_ATTR(nvmet_subsys_, attr_allow_any_host);
609
610static struct configfs_attribute *nvmet_subsys_attrs[] = {
611 &nvmet_subsys_attr_attr_allow_any_host,
612 NULL,
613};
614
615/*
616 * Subsystem structures & folder operation functions below
617 */
618static void nvmet_subsys_release(struct config_item *item)
619{
620 struct nvmet_subsys *subsys = to_subsys(item);
621
622 nvmet_subsys_put(subsys);
623}
624
625static struct configfs_item_operations nvmet_subsys_item_ops = {
626 .release = nvmet_subsys_release,
627};
628
629static struct config_item_type nvmet_subsys_type = {
630 .ct_item_ops = &nvmet_subsys_item_ops,
631 .ct_attrs = nvmet_subsys_attrs,
632 .ct_owner = THIS_MODULE,
633};
634
635static struct config_group *nvmet_subsys_make(struct config_group *group,
636 const char *name)
637{
638 struct nvmet_subsys *subsys;
639
640 if (sysfs_streq(name, NVME_DISC_SUBSYS_NAME)) {
641 pr_err("can't create discovery subsystem through configfs\n");
642 return ERR_PTR(-EINVAL);
643 }
644
645 subsys = nvmet_subsys_alloc(name, NVME_NQN_NVME);
646 if (!subsys)
647 return ERR_PTR(-ENOMEM);
648
649 config_group_init_type_name(&subsys->group, name, &nvmet_subsys_type);
650
651 config_group_init_type_name(&subsys->namespaces_group,
652 "namespaces", &nvmet_namespaces_type);
653 configfs_add_default_group(&subsys->namespaces_group, &subsys->group);
654
655 config_group_init_type_name(&subsys->allowed_hosts_group,
656 "allowed_hosts", &nvmet_allowed_hosts_type);
657 configfs_add_default_group(&subsys->allowed_hosts_group,
658 &subsys->group);
659
660 return &subsys->group;
661}
662
663static struct configfs_group_operations nvmet_subsystems_group_ops = {
664 .make_group = nvmet_subsys_make,
665};
666
667static struct config_item_type nvmet_subsystems_type = {
668 .ct_group_ops = &nvmet_subsystems_group_ops,
669 .ct_owner = THIS_MODULE,
670};
671
672static ssize_t nvmet_referral_enable_show(struct config_item *item,
673 char *page)
674{
675 return snprintf(page, PAGE_SIZE, "%d\n", to_nvmet_port(item)->enabled);
676}
677
678static ssize_t nvmet_referral_enable_store(struct config_item *item,
679 const char *page, size_t count)
680{
681 struct nvmet_port *parent = to_nvmet_port(item->ci_parent->ci_parent);
682 struct nvmet_port *port = to_nvmet_port(item);
683 bool enable;
684
685 if (strtobool(page, &enable))
686 goto inval;
687
688 if (enable)
689 nvmet_referral_enable(parent, port);
690 else
691 nvmet_referral_disable(port);
692
693 return count;
694inval:
695 pr_err("Invalid value '%s' for enable\n", page);
696 return -EINVAL;
697}
698
699CONFIGFS_ATTR(nvmet_referral_, enable);
700
701/*
702 * Discovery Service subsystem definitions
703 */
704static struct configfs_attribute *nvmet_referral_attrs[] = {
705 &nvmet_attr_addr_adrfam,
706 &nvmet_attr_addr_portid,
707 &nvmet_attr_addr_treq,
708 &nvmet_attr_addr_traddr,
709 &nvmet_attr_addr_trsvcid,
710 &nvmet_attr_addr_trtype,
711 &nvmet_referral_attr_enable,
712 NULL,
713};
714
715static void nvmet_referral_release(struct config_item *item)
716{
717 struct nvmet_port *port = to_nvmet_port(item);
718
719 nvmet_referral_disable(port);
720 kfree(port);
721}
722
723static struct configfs_item_operations nvmet_referral_item_ops = {
724 .release = nvmet_referral_release,
725};
726
727static struct config_item_type nvmet_referral_type = {
728 .ct_owner = THIS_MODULE,
729 .ct_attrs = nvmet_referral_attrs,
730 .ct_item_ops = &nvmet_referral_item_ops,
731};
732
733static struct config_group *nvmet_referral_make(
734 struct config_group *group, const char *name)
735{
736 struct nvmet_port *port;
737
738 port = kzalloc(sizeof(*port), GFP_KERNEL);
739 if (!port)
Dan Carpenterf98d9ca2016-07-07 11:15:26 +0300740 return ERR_PTR(-ENOMEM);
Christoph Hellwiga07b4972016-06-21 18:04:20 +0200741
742 INIT_LIST_HEAD(&port->entry);
743 config_group_init_type_name(&port->group, name, &nvmet_referral_type);
744
745 return &port->group;
746}
747
748static struct configfs_group_operations nvmet_referral_group_ops = {
749 .make_group = nvmet_referral_make,
750};
751
752static struct config_item_type nvmet_referrals_type = {
753 .ct_owner = THIS_MODULE,
754 .ct_group_ops = &nvmet_referral_group_ops,
755};
756
757/*
758 * Ports definitions.
759 */
760static void nvmet_port_release(struct config_item *item)
761{
762 struct nvmet_port *port = to_nvmet_port(item);
763
764 kfree(port);
765}
766
767static struct configfs_attribute *nvmet_port_attrs[] = {
768 &nvmet_attr_addr_adrfam,
769 &nvmet_attr_addr_treq,
770 &nvmet_attr_addr_traddr,
771 &nvmet_attr_addr_trsvcid,
772 &nvmet_attr_addr_trtype,
773 NULL,
774};
775
776static struct configfs_item_operations nvmet_port_item_ops = {
777 .release = nvmet_port_release,
778};
779
780static struct config_item_type nvmet_port_type = {
781 .ct_attrs = nvmet_port_attrs,
782 .ct_item_ops = &nvmet_port_item_ops,
783 .ct_owner = THIS_MODULE,
784};
785
786static struct config_group *nvmet_ports_make(struct config_group *group,
787 const char *name)
788{
789 struct nvmet_port *port;
790 u16 portid;
791
792 if (kstrtou16(name, 0, &portid))
793 return ERR_PTR(-EINVAL);
794
795 port = kzalloc(sizeof(*port), GFP_KERNEL);
796 if (!port)
Dan Carpenterf98d9ca2016-07-07 11:15:26 +0300797 return ERR_PTR(-ENOMEM);
Christoph Hellwiga07b4972016-06-21 18:04:20 +0200798
799 INIT_LIST_HEAD(&port->entry);
800 INIT_LIST_HEAD(&port->subsystems);
801 INIT_LIST_HEAD(&port->referrals);
802
803 port->disc_addr.portid = cpu_to_le16(portid);
804 config_group_init_type_name(&port->group, name, &nvmet_port_type);
805
806 config_group_init_type_name(&port->subsys_group,
807 "subsystems", &nvmet_port_subsys_type);
808 configfs_add_default_group(&port->subsys_group, &port->group);
809
810 config_group_init_type_name(&port->referrals_group,
811 "referrals", &nvmet_referrals_type);
812 configfs_add_default_group(&port->referrals_group, &port->group);
813
814 return &port->group;
815}
816
817static struct configfs_group_operations nvmet_ports_group_ops = {
818 .make_group = nvmet_ports_make,
819};
820
821static struct config_item_type nvmet_ports_type = {
822 .ct_group_ops = &nvmet_ports_group_ops,
823 .ct_owner = THIS_MODULE,
824};
825
826static struct config_group nvmet_subsystems_group;
827static struct config_group nvmet_ports_group;
828
829static void nvmet_host_release(struct config_item *item)
830{
831 struct nvmet_host *host = to_host(item);
832
833 kfree(host);
834}
835
836static struct configfs_item_operations nvmet_host_item_ops = {
837 .release = nvmet_host_release,
838};
839
840static struct config_item_type nvmet_host_type = {
841 .ct_item_ops = &nvmet_host_item_ops,
842 .ct_owner = THIS_MODULE,
843};
844
845static struct config_group *nvmet_hosts_make_group(struct config_group *group,
846 const char *name)
847{
848 struct nvmet_host *host;
849
850 host = kzalloc(sizeof(*host), GFP_KERNEL);
851 if (!host)
852 return ERR_PTR(-ENOMEM);
853
854 config_group_init_type_name(&host->group, name, &nvmet_host_type);
855
856 return &host->group;
857}
858
859static struct configfs_group_operations nvmet_hosts_group_ops = {
860 .make_group = nvmet_hosts_make_group,
861};
862
863static struct config_item_type nvmet_hosts_type = {
864 .ct_group_ops = &nvmet_hosts_group_ops,
865 .ct_owner = THIS_MODULE,
866};
867
868static struct config_group nvmet_hosts_group;
869
870static struct config_item_type nvmet_root_type = {
871 .ct_owner = THIS_MODULE,
872};
873
874static struct configfs_subsystem nvmet_configfs_subsystem = {
875 .su_group = {
876 .cg_item = {
877 .ci_namebuf = "nvmet",
878 .ci_type = &nvmet_root_type,
879 },
880 },
881};
882
883int __init nvmet_init_configfs(void)
884{
885 int ret;
886
887 config_group_init(&nvmet_configfs_subsystem.su_group);
888 mutex_init(&nvmet_configfs_subsystem.su_mutex);
889
890 config_group_init_type_name(&nvmet_subsystems_group,
891 "subsystems", &nvmet_subsystems_type);
892 configfs_add_default_group(&nvmet_subsystems_group,
893 &nvmet_configfs_subsystem.su_group);
894
895 config_group_init_type_name(&nvmet_ports_group,
896 "ports", &nvmet_ports_type);
897 configfs_add_default_group(&nvmet_ports_group,
898 &nvmet_configfs_subsystem.su_group);
899
900 config_group_init_type_name(&nvmet_hosts_group,
901 "hosts", &nvmet_hosts_type);
902 configfs_add_default_group(&nvmet_hosts_group,
903 &nvmet_configfs_subsystem.su_group);
904
905 ret = configfs_register_subsystem(&nvmet_configfs_subsystem);
906 if (ret) {
907 pr_err("configfs_register_subsystem: %d\n", ret);
908 return ret;
909 }
910
911 return 0;
912}
913
914void __exit nvmet_exit_configfs(void)
915{
916 configfs_unregister_subsystem(&nvmet_configfs_subsystem);
917}