1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*******************************************************************************
3 * Filename: target_core_fabric_configfs.c
4  *
5  * This file contains generic fabric module configfs infrastructure for
6  * TCM v4.x code
7  *
8  * (c) Copyright 2010-2013 Datera, Inc.
9  *
10  * Nicholas A. Bellinger <nab@linux-iscsi.org>
11 *
12  ****************************************************************************/
13 
14 #include <linux/kstrtox.h>
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/utsname.h>
18 #include <linux/init.h>
19 #include <linux/fs.h>
20 #include <linux/namei.h>
21 #include <linux/slab.h>
22 #include <linux/types.h>
23 #include <linux/delay.h>
24 #include <linux/unistd.h>
25 #include <linux/string.h>
26 #include <linux/syscalls.h>
27 #include <linux/configfs.h>
28 
29 #include <target/target_core_base.h>
30 #include <target/target_core_backend.h>
31 #include <target/target_core_fabric.h>
32 
33 #include "target_core_internal.h"
34 #include "target_core_alua.h"
35 #include "target_core_pr.h"
36 
37 #define TF_CIT_SETUP(_name, _item_ops, _group_ops, _attrs)		\
38 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
39 {									\
40 	struct config_item_type *cit = &tf->tf_##_name##_cit;		\
41 									\
42 	cit->ct_item_ops = _item_ops;					\
43 	cit->ct_group_ops = _group_ops;					\
44 	cit->ct_attrs = _attrs;						\
45 	cit->ct_owner = tf->tf_ops->module;				\
46 	pr_debug("Setup generic %s\n", __stringify(_name));		\
47 }
48 
49 #define TF_CIT_SETUP_DRV(_name, _item_ops, _group_ops)		\
50 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
51 {									\
52 	struct config_item_type *cit = &tf->tf_##_name##_cit;		\
53 	struct configfs_attribute **attrs = tf->tf_ops->tfc_##_name##_attrs; \
54 									\
55 	cit->ct_item_ops = _item_ops;					\
56 	cit->ct_group_ops = _group_ops;					\
57 	cit->ct_attrs = attrs;						\
58 	cit->ct_owner = tf->tf_ops->module;				\
59 	pr_debug("Setup generic %s\n", __stringify(_name));		\
60 }
61 
62 static struct configfs_item_operations target_fabric_port_item_ops;
63 
64 /* Start of tfc_tpg_mappedlun_cit */
65 
66 static int target_fabric_mappedlun_link(
67 	struct config_item *lun_acl_ci,
68 	struct config_item *lun_ci)
69 {
70 	struct se_dev_entry *deve;
71 	struct se_lun *lun;
72 	struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),
73 			struct se_lun_acl, se_lun_group);
74 	struct se_portal_group *se_tpg;
75 	struct config_item *nacl_ci, *tpg_ci, *tpg_ci_s, *wwn_ci, *wwn_ci_s;
76 	bool lun_access_ro;
77 
78 	if (!lun_ci->ci_type ||
79 	    lun_ci->ci_type->ct_item_ops != &target_fabric_port_item_ops) {
80 		pr_err("Bad lun_ci, not a valid lun_ci pointer: %p\n", lun_ci);
81 		return -EFAULT;
82 	}
83 	lun = container_of(to_config_group(lun_ci), struct se_lun, lun_group);
84 
85 	/*
86 	 * Ensure that the source port exists
87 	 */
88 	if (!lun->lun_se_dev) {
89 		pr_err("Source se_lun->lun_se_dev does not exist\n");
90 		return -EINVAL;
91 	}
92 	if (lun->lun_shutdown) {
93 		pr_err("Unable to create mappedlun symlink because"
94 			" lun->lun_shutdown=true\n");
95 		return -EINVAL;
96 	}
97 	se_tpg = lun->lun_tpg;
98 
99 	nacl_ci = &lun_acl_ci->ci_parent->ci_group->cg_item;
100 	tpg_ci = &nacl_ci->ci_group->cg_item;
101 	wwn_ci = &tpg_ci->ci_group->cg_item;
102 	tpg_ci_s = &lun_ci->ci_parent->ci_group->cg_item;
103 	wwn_ci_s = &tpg_ci_s->ci_group->cg_item;
104 	/*
105 	 * Make sure the SymLink is going to the same $FABRIC/$WWN/tpgt_$TPGT
106 	 */
107 	if (strcmp(config_item_name(wwn_ci), config_item_name(wwn_ci_s))) {
108 		pr_err("Illegal Initiator ACL SymLink outside of %s\n",
109 			config_item_name(wwn_ci));
110 		return -EINVAL;
111 	}
112 	if (strcmp(config_item_name(tpg_ci), config_item_name(tpg_ci_s))) {
113 		pr_err("Illegal Initiator ACL Symlink outside of %s"
114 			" TPGT: %s\n", config_item_name(wwn_ci),
115 			config_item_name(tpg_ci));
116 		return -EINVAL;
117 	}
118 	/*
119 	 * If this struct se_node_acl was dynamically generated with
120 	 * tpg_1/attrib/generate_node_acls=1, use the existing
121 	 * deve->lun_access_ro value, which will be true when
122 	 * tpg_1/attrib/demo_mode_write_protect=1
123 	 */
124 	rcu_read_lock();
125 	deve = target_nacl_find_deve(lacl->se_lun_nacl, lacl->mapped_lun);
126 	if (deve)
127 		lun_access_ro = deve->lun_access_ro;
128 	else
129 		lun_access_ro =
130 			(se_tpg->se_tpg_tfo->tpg_check_prod_mode_write_protect(
131 				se_tpg)) ? true : false;
132 	rcu_read_unlock();
133 	/*
134 	 * Determine the actual mapped LUN value user wants..
135 	 *
136 	 * This value is what the SCSI Initiator actually sees the
137 	 * $FABRIC/$WWPN/$TPGT/lun/lun_* as on their SCSI Initiator Ports.
138 	 */
139 	return core_dev_add_initiator_node_lun_acl(se_tpg, lacl, lun, lun_access_ro);
140 }
141 
142 static void target_fabric_mappedlun_unlink(
143 	struct config_item *lun_acl_ci,
144 	struct config_item *lun_ci)
145 {
146 	struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),
147 			struct se_lun_acl, se_lun_group);
148 	struct se_lun *lun = container_of(to_config_group(lun_ci),
149 			struct se_lun, lun_group);
150 
151 	core_dev_del_initiator_node_lun_acl(lun, lacl);
152 }
153 
154 static struct se_lun_acl *item_to_lun_acl(struct config_item *item)
155 {
156 	return container_of(to_config_group(item), struct se_lun_acl,
157 			se_lun_group);
158 }
159 
160 static ssize_t target_fabric_mappedlun_write_protect_show(
161 		struct config_item *item, char *page)
162 {
163 	struct se_lun_acl *lacl = item_to_lun_acl(item);
164 	struct se_node_acl *se_nacl = lacl->se_lun_nacl;
165 	struct se_dev_entry *deve;
166 	ssize_t len = 0;
167 
168 	rcu_read_lock();
169 	deve = target_nacl_find_deve(se_nacl, lacl->mapped_lun);
170 	if (deve) {
171 		len = sprintf(page, "%d\n", deve->lun_access_ro);
172 	}
173 	rcu_read_unlock();
174 
175 	return len;
176 }
177 
178 static ssize_t target_fabric_mappedlun_write_protect_store(
179 		struct config_item *item, const char *page, size_t count)
180 {
181 	struct se_lun_acl *lacl = item_to_lun_acl(item);
182 	struct se_node_acl *se_nacl = lacl->se_lun_nacl;
183 	struct se_portal_group *se_tpg = se_nacl->se_tpg;
184 	unsigned long wp;
185 	int ret;
186 
187 	ret = kstrtoul(page, 0, &wp);
188 	if (ret)
189 		return ret;
190 
191 	if ((wp != 1) && (wp != 0))
192 		return -EINVAL;
193 
194 	/* wp=1 means lun_access_ro=true */
195 	core_update_device_list_access(lacl->mapped_lun, wp, lacl->se_lun_nacl);
196 
197 	pr_debug("%s_ConfigFS: Changed Initiator ACL: %s"
198 		" Mapped LUN: %llu Write Protect bit to %s\n",
199 		se_tpg->se_tpg_tfo->fabric_name,
200 		se_nacl->initiatorname, lacl->mapped_lun, (wp) ? "ON" : "OFF");
201 
202 	return count;
203 
204 }
205 
206 CONFIGFS_ATTR(target_fabric_mappedlun_, write_protect);
207 
208 static struct configfs_attribute *target_fabric_mappedlun_attrs[] = {
209 	&target_fabric_mappedlun_attr_write_protect,
210 	NULL,
211 };
212 
213 static void target_fabric_mappedlun_release(struct config_item *item)
214 {
215 	struct se_lun_acl *lacl = container_of(to_config_group(item),
216 				struct se_lun_acl, se_lun_group);
217 	struct se_portal_group *se_tpg = lacl->se_lun_nacl->se_tpg;
218 
219 	core_dev_free_initiator_node_lun_acl(se_tpg, lacl);
220 }
221 
222 static struct configfs_item_operations target_fabric_mappedlun_item_ops = {
223 	.release		= target_fabric_mappedlun_release,
224 	.allow_link		= target_fabric_mappedlun_link,
225 	.drop_link		= target_fabric_mappedlun_unlink,
226 };
227 
228 TF_CIT_SETUP(tpg_mappedlun, &target_fabric_mappedlun_item_ops, NULL,
229 		target_fabric_mappedlun_attrs);
230 
231 /* End of tfc_tpg_mappedlun_cit */
232 
233 /* Start of tfc_tpg_mappedlun_port_cit */
234 
235 static struct config_group *target_core_mappedlun_stat_mkdir(
236 	struct config_group *group,
237 	const char *name)
238 {
239 	return ERR_PTR(-ENOSYS);
240 }
241 
242 static void target_core_mappedlun_stat_rmdir(
243 	struct config_group *group,
244 	struct config_item *item)
245 {
246 	return;
247 }
248 
249 static struct configfs_group_operations target_fabric_mappedlun_stat_group_ops = {
250 	.make_group		= target_core_mappedlun_stat_mkdir,
251 	.drop_item		= target_core_mappedlun_stat_rmdir,
252 };
253 
254 TF_CIT_SETUP(tpg_mappedlun_stat, NULL, &target_fabric_mappedlun_stat_group_ops,
255 		NULL);
256 
257 /* End of tfc_tpg_mappedlun_port_cit */
258 
259 TF_CIT_SETUP_DRV(tpg_nacl_attrib, NULL, NULL);
260 TF_CIT_SETUP_DRV(tpg_nacl_auth, NULL, NULL);
261 TF_CIT_SETUP_DRV(tpg_nacl_param, NULL, NULL);
262 
263 /* Start of tfc_tpg_nacl_base_cit */
264 
265 static struct config_group *target_fabric_make_mappedlun(
266 	struct config_group *group,
267 	const char *name)
268 {
269 	struct se_node_acl *se_nacl = container_of(group,
270 			struct se_node_acl, acl_group);
271 	struct se_portal_group *se_tpg = se_nacl->se_tpg;
272 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
273 	struct se_lun_acl *lacl = NULL;
274 	char *buf;
275 	unsigned long long mapped_lun;
276 	int ret = 0;
277 
278 	buf = kzalloc(strlen(name) + 1, GFP_KERNEL);
279 	if (!buf) {
280 		pr_err("Unable to allocate memory for name buf\n");
281 		return ERR_PTR(-ENOMEM);
282 	}
283 	snprintf(buf, strlen(name) + 1, "%s", name);
284 	/*
285 	 * Make sure user is creating iscsi/$IQN/$TPGT/acls/$INITIATOR/lun_$ID.
286 	 */
287 	if (strstr(buf, "lun_") != buf) {
288 		pr_err("Unable to locate \"lun_\" from buf: %s"
289 			" name: %s\n", buf, name);
290 		ret = -EINVAL;
291 		goto out;
292 	}
293 	/*
294 	 * Determine the Mapped LUN value.  This is what the SCSI Initiator
295 	 * Port will actually see.
296 	 */
297 	ret = kstrtoull(buf + 4, 0, &mapped_lun);
298 	if (ret)
299 		goto out;
300 
301 	lacl = core_dev_init_initiator_node_lun_acl(se_tpg, se_nacl,
302 			mapped_lun, &ret);
303 	if (!lacl) {
304 		ret = -EINVAL;
305 		goto out;
306 	}
307 
308 	config_group_init_type_name(&lacl->se_lun_group, name,
309 			&tf->tf_tpg_mappedlun_cit);
310 
311 	config_group_init_type_name(&lacl->ml_stat_grps.stat_group,
312 			"statistics", &tf->tf_tpg_mappedlun_stat_cit);
313 	configfs_add_default_group(&lacl->ml_stat_grps.stat_group,
314 			&lacl->se_lun_group);
315 
316 	target_stat_setup_mappedlun_default_groups(lacl);
317 
318 	kfree(buf);
319 	return &lacl->se_lun_group;
320 out:
321 	kfree(lacl);
322 	kfree(buf);
323 	return ERR_PTR(ret);
324 }
325 
326 static void target_fabric_drop_mappedlun(
327 	struct config_group *group,
328 	struct config_item *item)
329 {
330 	struct se_lun_acl *lacl = container_of(to_config_group(item),
331 			struct se_lun_acl, se_lun_group);
332 
333 	configfs_remove_default_groups(&lacl->ml_stat_grps.stat_group);
334 	configfs_remove_default_groups(&lacl->se_lun_group);
335 
336 	config_item_put(item);
337 }
338 
339 static void target_fabric_nacl_base_release(struct config_item *item)
340 {
341 	struct se_node_acl *se_nacl = container_of(to_config_group(item),
342 			struct se_node_acl, acl_group);
343 
344 	configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
345 	core_tpg_del_initiator_node_acl(se_nacl);
346 }
347 
348 static struct configfs_item_operations target_fabric_nacl_base_item_ops = {
349 	.release		= target_fabric_nacl_base_release,
350 };
351 
352 static struct configfs_group_operations target_fabric_nacl_base_group_ops = {
353 	.make_group		= target_fabric_make_mappedlun,
354 	.drop_item		= target_fabric_drop_mappedlun,
355 };
356 
357 TF_CIT_SETUP_DRV(tpg_nacl_base, &target_fabric_nacl_base_item_ops,
358 		&target_fabric_nacl_base_group_ops);
359 
360 /* End of tfc_tpg_nacl_base_cit */
361 
362 /* Start of tfc_node_fabric_stats_cit */
363 /*
364  * This is used as a placeholder for struct se_node_acl->acl_fabric_stat_group
365  * to allow fabrics access to ->acl_fabric_stat_group->default_groups[]
366  */
367 TF_CIT_SETUP(tpg_nacl_stat, NULL, NULL, NULL);
368 
369 /* End of tfc_wwn_fabric_stats_cit */
370 
371 /* Start of tfc_tpg_nacl_cit */
372 
373 static struct config_group *target_fabric_make_nodeacl(
374 	struct config_group *group,
375 	const char *name)
376 {
377 	struct se_portal_group *se_tpg = container_of(group,
378 			struct se_portal_group, tpg_acl_group);
379 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
380 	struct se_node_acl *se_nacl;
381 
382 	se_nacl = core_tpg_add_initiator_node_acl(se_tpg, name);
383 	if (IS_ERR(se_nacl))
384 		return ERR_CAST(se_nacl);
385 
386 	config_group_init_type_name(&se_nacl->acl_group, name,
387 			&tf->tf_tpg_nacl_base_cit);
388 
389 	config_group_init_type_name(&se_nacl->acl_attrib_group, "attrib",
390 			&tf->tf_tpg_nacl_attrib_cit);
391 	configfs_add_default_group(&se_nacl->acl_attrib_group,
392 			&se_nacl->acl_group);
393 
394 	config_group_init_type_name(&se_nacl->acl_auth_group, "auth",
395 			&tf->tf_tpg_nacl_auth_cit);
396 	configfs_add_default_group(&se_nacl->acl_auth_group,
397 			&se_nacl->acl_group);
398 
399 	config_group_init_type_name(&se_nacl->acl_param_group, "param",
400 			&tf->tf_tpg_nacl_param_cit);
401 	configfs_add_default_group(&se_nacl->acl_param_group,
402 			&se_nacl->acl_group);
403 
404 	config_group_init_type_name(&se_nacl->acl_fabric_stat_group,
405 			"fabric_statistics", &tf->tf_tpg_nacl_stat_cit);
406 	configfs_add_default_group(&se_nacl->acl_fabric_stat_group,
407 			&se_nacl->acl_group);
408 
409 	if (tf->tf_ops->fabric_init_nodeacl) {
410 		int ret = tf->tf_ops->fabric_init_nodeacl(se_nacl, name);
411 		if (ret) {
412 			configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
413 			core_tpg_del_initiator_node_acl(se_nacl);
414 			return ERR_PTR(ret);
415 		}
416 	}
417 
418 	return &se_nacl->acl_group;
419 }
420 
421 static void target_fabric_drop_nodeacl(
422 	struct config_group *group,
423 	struct config_item *item)
424 {
425 	struct se_node_acl *se_nacl = container_of(to_config_group(item),
426 			struct se_node_acl, acl_group);
427 
428 	configfs_remove_default_groups(&se_nacl->acl_group);
429 
430 	/*
431 	 * struct se_node_acl free is done in target_fabric_nacl_base_release()
432 	 */
433 	config_item_put(item);
434 }
435 
436 static struct configfs_group_operations target_fabric_nacl_group_ops = {
437 	.make_group	= target_fabric_make_nodeacl,
438 	.drop_item	= target_fabric_drop_nodeacl,
439 };
440 
441 TF_CIT_SETUP(tpg_nacl, NULL, &target_fabric_nacl_group_ops, NULL);
442 
443 /* End of tfc_tpg_nacl_cit */
444 
445 /* Start of tfc_tpg_np_base_cit */
446 
447 static void target_fabric_np_base_release(struct config_item *item)
448 {
449 	struct se_tpg_np *se_tpg_np = container_of(to_config_group(item),
450 				struct se_tpg_np, tpg_np_group);
451 	struct se_portal_group *se_tpg = se_tpg_np->tpg_np_parent;
452 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
453 
454 	tf->tf_ops->fabric_drop_np(se_tpg_np);
455 }
456 
457 static struct configfs_item_operations target_fabric_np_base_item_ops = {
458 	.release		= target_fabric_np_base_release,
459 };
460 
461 TF_CIT_SETUP_DRV(tpg_np_base, &target_fabric_np_base_item_ops, NULL);
462 
463 /* End of tfc_tpg_np_base_cit */
464 
465 /* Start of tfc_tpg_np_cit */
466 
467 static struct config_group *target_fabric_make_np(
468 	struct config_group *group,
469 	const char *name)
470 {
471 	struct se_portal_group *se_tpg = container_of(group,
472 				struct se_portal_group, tpg_np_group);
473 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
474 	struct se_tpg_np *se_tpg_np;
475 
476 	if (!tf->tf_ops->fabric_make_np) {
477 		pr_err("tf->tf_ops.fabric_make_np is NULL\n");
478 		return ERR_PTR(-ENOSYS);
479 	}
480 
481 	se_tpg_np = tf->tf_ops->fabric_make_np(se_tpg, group, name);
482 	if (!se_tpg_np || IS_ERR(se_tpg_np))
483 		return ERR_PTR(-EINVAL);
484 
485 	se_tpg_np->tpg_np_parent = se_tpg;
486 	config_group_init_type_name(&se_tpg_np->tpg_np_group, name,
487 			&tf->tf_tpg_np_base_cit);
488 
489 	return &se_tpg_np->tpg_np_group;
490 }
491 
492 static void target_fabric_drop_np(
493 	struct config_group *group,
494 	struct config_item *item)
495 {
496 	/*
497 	 * struct se_tpg_np is released via target_fabric_np_base_release()
498 	 */
499 	config_item_put(item);
500 }
501 
502 static struct configfs_group_operations target_fabric_np_group_ops = {
503 	.make_group	= &target_fabric_make_np,
504 	.drop_item	= &target_fabric_drop_np,
505 };
506 
507 TF_CIT_SETUP(tpg_np, NULL, &target_fabric_np_group_ops, NULL);
508 
509 /* End of tfc_tpg_np_cit */
510 
511 /* Start of tfc_tpg_port_cit */
512 
513 static struct se_lun *item_to_lun(struct config_item *item)
514 {
515 	return container_of(to_config_group(item), struct se_lun,
516 			lun_group);
517 }
518 
519 static ssize_t target_fabric_port_alua_tg_pt_gp_show(struct config_item *item,
520 		char *page)
521 {
522 	struct se_lun *lun = item_to_lun(item);
523 
524 	if (!lun->lun_se_dev)
525 		return -ENODEV;
526 
527 	return core_alua_show_tg_pt_gp_info(lun, page);
528 }
529 
530 static ssize_t target_fabric_port_alua_tg_pt_gp_store(struct config_item *item,
531 		const char *page, size_t count)
532 {
533 	struct se_lun *lun = item_to_lun(item);
534 
535 	if (!lun->lun_se_dev)
536 		return -ENODEV;
537 
538 	return core_alua_store_tg_pt_gp_info(lun, page, count);
539 }
540 
541 static ssize_t target_fabric_port_alua_tg_pt_offline_show(
542 		struct config_item *item, char *page)
543 {
544 	struct se_lun *lun = item_to_lun(item);
545 
546 	if (!lun->lun_se_dev)
547 		return -ENODEV;
548 
549 	return core_alua_show_offline_bit(lun, page);
550 }
551 
552 static ssize_t target_fabric_port_alua_tg_pt_offline_store(
553 		struct config_item *item, const char *page, size_t count)
554 {
555 	struct se_lun *lun = item_to_lun(item);
556 
557 	if (!lun->lun_se_dev)
558 		return -ENODEV;
559 
560 	return core_alua_store_offline_bit(lun, page, count);
561 }
562 
563 static ssize_t target_fabric_port_alua_tg_pt_status_show(
564 		struct config_item *item, char *page)
565 {
566 	struct se_lun *lun = item_to_lun(item);
567 
568 	if (!lun->lun_se_dev)
569 		return -ENODEV;
570 
571 	return core_alua_show_secondary_status(lun, page);
572 }
573 
574 static ssize_t target_fabric_port_alua_tg_pt_status_store(
575 		struct config_item *item, const char *page, size_t count)
576 {
577 	struct se_lun *lun = item_to_lun(item);
578 
579 	if (!lun->lun_se_dev)
580 		return -ENODEV;
581 
582 	return core_alua_store_secondary_status(lun, page, count);
583 }
584 
585 static ssize_t target_fabric_port_alua_tg_pt_write_md_show(
586 		struct config_item *item, char *page)
587 {
588 	struct se_lun *lun = item_to_lun(item);
589 
590 	if (!lun->lun_se_dev)
591 		return -ENODEV;
592 
593 	return core_alua_show_secondary_write_metadata(lun, page);
594 }
595 
596 static ssize_t target_fabric_port_alua_tg_pt_write_md_store(
597 		struct config_item *item, const char *page, size_t count)
598 {
599 	struct se_lun *lun = item_to_lun(item);
600 
601 	if (!lun->lun_se_dev)
602 		return -ENODEV;
603 
604 	return core_alua_store_secondary_write_metadata(lun, page, count);
605 }
606 
607 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_gp);
608 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_offline);
609 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_status);
610 CONFIGFS_ATTR(target_fabric_port_, alua_tg_pt_write_md);
611 
612 static struct configfs_attribute *target_fabric_port_attrs[] = {
613 	&target_fabric_port_attr_alua_tg_pt_gp,
614 	&target_fabric_port_attr_alua_tg_pt_offline,
615 	&target_fabric_port_attr_alua_tg_pt_status,
616 	&target_fabric_port_attr_alua_tg_pt_write_md,
617 	NULL,
618 };
619 
620 static int target_fabric_port_link(
621 	struct config_item *lun_ci,
622 	struct config_item *se_dev_ci)
623 {
624 	struct config_item *tpg_ci;
625 	struct se_lun *lun = container_of(to_config_group(lun_ci),
626 				struct se_lun, lun_group);
627 	struct se_portal_group *se_tpg;
628 	struct se_device *dev;
629 	struct target_fabric_configfs *tf;
630 	int ret;
631 
632 	if (!se_dev_ci->ci_type ||
633 	    se_dev_ci->ci_type->ct_item_ops != &target_core_dev_item_ops) {
634 		pr_err("Bad se_dev_ci, not a valid se_dev_ci pointer: %p\n", se_dev_ci);
635 		return -EFAULT;
636 	}
637 	dev = container_of(to_config_group(se_dev_ci), struct se_device, dev_group);
638 
639 	if (!target_dev_configured(dev)) {
640 		pr_err("se_device not configured yet, cannot port link\n");
641 		return -ENODEV;
642 	}
643 
644 	tpg_ci = &lun_ci->ci_parent->ci_group->cg_item;
645 	se_tpg = container_of(to_config_group(tpg_ci),
646 				struct se_portal_group, tpg_group);
647 	tf = se_tpg->se_tpg_wwn->wwn_tf;
648 
649 	if (lun->lun_se_dev !=  NULL) {
650 		pr_err("Port Symlink already exists\n");
651 		return -EEXIST;
652 	}
653 
654 	ret = core_dev_add_lun(se_tpg, dev, lun);
655 	if (ret) {
656 		pr_err("core_dev_add_lun() failed: %d\n", ret);
657 		goto out;
658 	}
659 
660 	if (tf->tf_ops->fabric_post_link) {
661 		/*
662 		 * Call the optional fabric_post_link() to allow a
663 		 * fabric module to setup any additional state once
664 		 * core_dev_add_lun() has been called..
665 		 */
666 		tf->tf_ops->fabric_post_link(se_tpg, lun);
667 	}
668 
669 	return 0;
670 out:
671 	return ret;
672 }
673 
674 static void target_fabric_port_unlink(
675 	struct config_item *lun_ci,
676 	struct config_item *se_dev_ci)
677 {
678 	struct se_lun *lun = container_of(to_config_group(lun_ci),
679 				struct se_lun, lun_group);
680 	struct se_portal_group *se_tpg = lun->lun_tpg;
681 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
682 
683 	if (tf->tf_ops->fabric_pre_unlink) {
684 		/*
685 		 * Call the optional fabric_pre_unlink() to allow a
686 		 * fabric module to release any additional stat before
687 		 * core_dev_del_lun() is called.
688 		*/
689 		tf->tf_ops->fabric_pre_unlink(se_tpg, lun);
690 	}
691 
692 	core_dev_del_lun(se_tpg, lun);
693 }
694 
695 static void target_fabric_port_release(struct config_item *item)
696 {
697 	struct se_lun *lun = container_of(to_config_group(item),
698 					  struct se_lun, lun_group);
699 
700 	kfree_rcu(lun, rcu_head);
701 }
702 
703 static struct configfs_item_operations target_fabric_port_item_ops = {
704 	.release		= target_fabric_port_release,
705 	.allow_link		= target_fabric_port_link,
706 	.drop_link		= target_fabric_port_unlink,
707 };
708 
709 TF_CIT_SETUP(tpg_port, &target_fabric_port_item_ops, NULL, target_fabric_port_attrs);
710 
711 /* End of tfc_tpg_port_cit */
712 
713 /* Start of tfc_tpg_port_stat_cit */
714 
715 static struct config_group *target_core_port_stat_mkdir(
716 	struct config_group *group,
717 	const char *name)
718 {
719 	return ERR_PTR(-ENOSYS);
720 }
721 
722 static void target_core_port_stat_rmdir(
723 	struct config_group *group,
724 	struct config_item *item)
725 {
726 	return;
727 }
728 
729 static struct configfs_group_operations target_fabric_port_stat_group_ops = {
730 	.make_group		= target_core_port_stat_mkdir,
731 	.drop_item		= target_core_port_stat_rmdir,
732 };
733 
734 TF_CIT_SETUP(tpg_port_stat, NULL, &target_fabric_port_stat_group_ops, NULL);
735 
736 /* End of tfc_tpg_port_stat_cit */
737 
738 /* Start of tfc_tpg_lun_cit */
739 
740 static struct config_group *target_fabric_make_lun(
741 	struct config_group *group,
742 	const char *name)
743 {
744 	struct se_lun *lun;
745 	struct se_portal_group *se_tpg = container_of(group,
746 			struct se_portal_group, tpg_lun_group);
747 	struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
748 	unsigned long long unpacked_lun;
749 	int errno;
750 
751 	if (strstr(name, "lun_") != name) {
752 		pr_err("Unable to locate \'_\" in"
753 				" \"lun_$LUN_NUMBER\"\n");
754 		return ERR_PTR(-EINVAL);
755 	}
756 	errno = kstrtoull(name + 4, 0, &unpacked_lun);
757 	if (errno)
758 		return ERR_PTR(errno);
759 
760 	lun = core_tpg_alloc_lun(se_tpg, unpacked_lun);
761 	if (IS_ERR(lun))
762 		return ERR_CAST(lun);
763 
764 	config_group_init_type_name(&lun->lun_group, name,
765 			&tf->tf_tpg_port_cit);
766 
767 	config_group_init_type_name(&lun->port_stat_grps.stat_group,
768 			"statistics", &tf->tf_tpg_port_stat_cit);
769 	configfs_add_default_group(&lun->port_stat_grps.stat_group,
770 			&lun->lun_group);
771 
772 	target_stat_setup_port_default_groups(lun);
773 
774 	return &lun->lun_group;
775 }
776 
777 static void target_fabric_drop_lun(
778 	struct config_group *group,
779 	struct config_item *item)
780 {
781 	struct se_lun *lun = container_of(to_config_group(item),
782 				struct se_lun, lun_group);
783 
784 	configfs_remove_default_groups(&lun->port_stat_grps.stat_group);
785 	configfs_remove_default_groups(&lun->lun_group);
786 
787 	config_item_put(item);
788 }
789 
790 static struct configfs_group_operations target_fabric_lun_group_ops = {
791 	.make_group	= &target_fabric_make_lun,
792 	.drop_item	= &target_fabric_drop_lun,
793 };
794 
795 TF_CIT_SETUP(tpg_lun, NULL, &target_fabric_lun_group_ops, NULL);
796 
797 /* End of tfc_tpg_lun_cit */
798 
799 TF_CIT_SETUP_DRV(tpg_attrib, NULL, NULL);
800 TF_CIT_SETUP_DRV(tpg_auth, NULL, NULL);
801 TF_CIT_SETUP_DRV(tpg_param, NULL, NULL);
802 
803 /* Start of tfc_tpg_base_cit */
804 
805 static void target_fabric_tpg_release(struct config_item *item)
806 {
807 	struct se_portal_group *se_tpg = container_of(to_config_group(item),
808 			struct se_portal_group, tpg_group);
809 	struct se_wwn *wwn = se_tpg->se_tpg_wwn;
810 	struct target_fabric_configfs *tf = wwn->wwn_tf;
811 
812 	tf->tf_ops->fabric_drop_tpg(se_tpg);
813 }
814 
815 static struct configfs_item_operations target_fabric_tpg_base_item_ops = {
816 	.release		= target_fabric_tpg_release,
817 };
818 
819 static ssize_t target_fabric_tpg_base_enable_show(struct config_item *item,
820 						  char *page)
821 {
822 	return sysfs_emit(page, "%d\n", to_tpg(item)->enabled);
823 }
824 
825 static ssize_t target_fabric_tpg_base_enable_store(struct config_item *item,
826 						   const char *page,
827 						   size_t count)
828 {
829 	struct se_portal_group *se_tpg = to_tpg(item);
830 	int ret;
831 	bool op;
832 
833 	ret = kstrtobool(page, &op);
834 	if (ret)
835 		return ret;
836 
837 	if (se_tpg->enabled == op)
838 		return count;
839 
840 	ret = se_tpg->se_tpg_tfo->fabric_enable_tpg(se_tpg, op);
841 	if (ret)
842 		return ret;
843 
844 	se_tpg->enabled = op;
845 
846 	return count;
847 }
848 
849 CONFIGFS_ATTR(target_fabric_tpg_base_, enable);
850 
851 static int
852 target_fabric_setup_tpg_base_cit(struct target_fabric_configfs *tf)
853 {
854 	struct config_item_type *cit = &tf->tf_tpg_base_cit;
855 	struct configfs_attribute **attrs = NULL;
856 	size_t nr_attrs = 0;
857 	int i = 0;
858 
859 	if (tf->tf_ops->tfc_tpg_base_attrs)
860 		while (tf->tf_ops->tfc_tpg_base_attrs[nr_attrs] != NULL)
861 			nr_attrs++;
862 
863 	if (tf->tf_ops->fabric_enable_tpg)
864 		nr_attrs++;
865 
866 	if (nr_attrs == 0)
867 		goto done;
868 
869 	/* + 1 for final NULL in the array */
870 	attrs = kcalloc(nr_attrs + 1, sizeof(*attrs), GFP_KERNEL);
871 	if (!attrs)
872 		return -ENOMEM;
873 
874 	if (tf->tf_ops->tfc_tpg_base_attrs)
875 		for (; tf->tf_ops->tfc_tpg_base_attrs[i] != NULL; i++)
876 			attrs[i] = tf->tf_ops->tfc_tpg_base_attrs[i];
877 
878 	if (tf->tf_ops->fabric_enable_tpg)
879 		attrs[i] = &target_fabric_tpg_base_attr_enable;
880 
881 done:
882 	cit->ct_item_ops = &target_fabric_tpg_base_item_ops;
883 	cit->ct_attrs = attrs;
884 	cit->ct_owner = tf->tf_ops->module;
885 	pr_debug("Setup generic tpg_base\n");
886 
887 	return 0;
888 }
889 /* End of tfc_tpg_base_cit */
890 
891 /* Start of tfc_tpg_cit */
892 
893 static struct config_group *target_fabric_make_tpg(
894 	struct config_group *group,
895 	const char *name)
896 {
897 	struct se_wwn *wwn = container_of(group, struct se_wwn, wwn_group);
898 	struct target_fabric_configfs *tf = wwn->wwn_tf;
899 	struct se_portal_group *se_tpg;
900 
901 	if (!tf->tf_ops->fabric_make_tpg) {
902 		pr_err("tf->tf_ops->fabric_make_tpg is NULL\n");
903 		return ERR_PTR(-ENOSYS);
904 	}
905 
906 	se_tpg = tf->tf_ops->fabric_make_tpg(wwn, name);
907 	if (!se_tpg || IS_ERR(se_tpg))
908 		return ERR_PTR(-EINVAL);
909 
910 	config_group_init_type_name(&se_tpg->tpg_group, name,
911 			&tf->tf_tpg_base_cit);
912 
913 	config_group_init_type_name(&se_tpg->tpg_lun_group, "lun",
914 			&tf->tf_tpg_lun_cit);
915 	configfs_add_default_group(&se_tpg->tpg_lun_group,
916 			&se_tpg->tpg_group);
917 
918 	config_group_init_type_name(&se_tpg->tpg_np_group, "np",
919 			&tf->tf_tpg_np_cit);
920 	configfs_add_default_group(&se_tpg->tpg_np_group,
921 			&se_tpg->tpg_group);
922 
923 	config_group_init_type_name(&se_tpg->tpg_acl_group, "acls",
924 			&tf->tf_tpg_nacl_cit);
925 	configfs_add_default_group(&se_tpg->tpg_acl_group,
926 			&se_tpg->tpg_group);
927 
928 	config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib",
929 			&tf->tf_tpg_attrib_cit);
930 	configfs_add_default_group(&se_tpg->tpg_attrib_group,
931 			&se_tpg->tpg_group);
932 
933 	config_group_init_type_name(&se_tpg->tpg_auth_group, "auth",
934 			&tf->tf_tpg_auth_cit);
935 	configfs_add_default_group(&se_tpg->tpg_auth_group,
936 			&se_tpg->tpg_group);
937 
938 	config_group_init_type_name(&se_tpg->tpg_param_group, "param",
939 			&tf->tf_tpg_param_cit);
940 	configfs_add_default_group(&se_tpg->tpg_param_group,
941 			&se_tpg->tpg_group);
942 
943 	return &se_tpg->tpg_group;
944 }
945 
946 static void target_fabric_drop_tpg(
947 	struct config_group *group,
948 	struct config_item *item)
949 {
950 	struct se_portal_group *se_tpg = container_of(to_config_group(item),
951 				struct se_portal_group, tpg_group);
952 
953 	configfs_remove_default_groups(&se_tpg->tpg_group);
954 	config_item_put(item);
955 }
956 
957 static void target_fabric_release_wwn(struct config_item *item)
958 {
959 	struct se_wwn *wwn = container_of(to_config_group(item),
960 				struct se_wwn, wwn_group);
961 	struct target_fabric_configfs *tf = wwn->wwn_tf;
962 
963 	configfs_remove_default_groups(&wwn->fabric_stat_group);
964 	configfs_remove_default_groups(&wwn->param_group);
965 	tf->tf_ops->fabric_drop_wwn(wwn);
966 }
967 
968 static struct configfs_item_operations target_fabric_tpg_item_ops = {
969 	.release	= target_fabric_release_wwn,
970 };
971 
972 static struct configfs_group_operations target_fabric_tpg_group_ops = {
973 	.make_group	= target_fabric_make_tpg,
974 	.drop_item	= target_fabric_drop_tpg,
975 };
976 
977 TF_CIT_SETUP(tpg, &target_fabric_tpg_item_ops, &target_fabric_tpg_group_ops,
978 		NULL);
979 
980 /* End of tfc_tpg_cit */
981 
982 /* Start of tfc_wwn_fabric_stats_cit */
983 /*
984  * This is used as a placeholder for struct se_wwn->fabric_stat_group
985  * to allow fabrics access to ->fabric_stat_group->default_groups[]
986  */
987 TF_CIT_SETUP(wwn_fabric_stats, NULL, NULL, NULL);
988 
989 /* End of tfc_wwn_fabric_stats_cit */
990 
991 static ssize_t
992 target_fabric_wwn_cmd_completion_affinity_show(struct config_item *item,
993 					       char *page)
994 {
995 	struct se_wwn *wwn = container_of(to_config_group(item), struct se_wwn,
996 					  param_group);
997 	return sprintf(page, "%d\n",
998 		       wwn->cmd_compl_affinity == WORK_CPU_UNBOUND ?
999 		       SE_COMPL_AFFINITY_CURR_CPU : wwn->cmd_compl_affinity);
1000 }
1001 
1002 static ssize_t
1003 target_fabric_wwn_cmd_completion_affinity_store(struct config_item *item,
1004 						const char *page, size_t count)
1005 {
1006 	struct se_wwn *wwn = container_of(to_config_group(item), struct se_wwn,
1007 					  param_group);
1008 	int compl_val;
1009 
1010 	if (kstrtoint(page, 0, &compl_val))
1011 		return -EINVAL;
1012 
1013 	switch (compl_val) {
1014 	case SE_COMPL_AFFINITY_CPUID:
1015 		wwn->cmd_compl_affinity = compl_val;
1016 		break;
1017 	case SE_COMPL_AFFINITY_CURR_CPU:
1018 		wwn->cmd_compl_affinity = WORK_CPU_UNBOUND;
1019 		break;
1020 	default:
1021 		if (compl_val < 0 || compl_val >= nr_cpu_ids ||
1022 		    !cpu_online(compl_val)) {
1023 			pr_err("Command completion value must be between %d and %d or an online CPU.\n",
1024 			       SE_COMPL_AFFINITY_CPUID,
1025 			       SE_COMPL_AFFINITY_CURR_CPU);
1026 			return -EINVAL;
1027 		}
1028 		wwn->cmd_compl_affinity = compl_val;
1029 	}
1030 
1031 	return count;
1032 }
1033 CONFIGFS_ATTR(target_fabric_wwn_, cmd_completion_affinity);
1034 
1035 static struct configfs_attribute *target_fabric_wwn_param_attrs[] = {
1036 	&target_fabric_wwn_attr_cmd_completion_affinity,
1037 	NULL,
1038 };
1039 
1040 TF_CIT_SETUP(wwn_param, NULL, NULL, target_fabric_wwn_param_attrs);
1041 
1042 /* Start of tfc_wwn_cit */
1043 
1044 static struct config_group *target_fabric_make_wwn(
1045 	struct config_group *group,
1046 	const char *name)
1047 {
1048 	struct target_fabric_configfs *tf = container_of(group,
1049 				struct target_fabric_configfs, tf_group);
1050 	struct se_wwn *wwn;
1051 
1052 	if (!tf->tf_ops->fabric_make_wwn) {
1053 		pr_err("tf->tf_ops.fabric_make_wwn is NULL\n");
1054 		return ERR_PTR(-ENOSYS);
1055 	}
1056 
1057 	wwn = tf->tf_ops->fabric_make_wwn(tf, group, name);
1058 	if (!wwn || IS_ERR(wwn))
1059 		return ERR_PTR(-EINVAL);
1060 
1061 	wwn->cmd_compl_affinity = SE_COMPL_AFFINITY_CPUID;
1062 	wwn->wwn_tf = tf;
1063 
1064 	config_group_init_type_name(&wwn->wwn_group, name, &tf->tf_tpg_cit);
1065 
1066 	config_group_init_type_name(&wwn->fabric_stat_group, "fabric_statistics",
1067 			&tf->tf_wwn_fabric_stats_cit);
1068 	configfs_add_default_group(&wwn->fabric_stat_group, &wwn->wwn_group);
1069 
1070 	config_group_init_type_name(&wwn->param_group, "param",
1071 			&tf->tf_wwn_param_cit);
1072 	configfs_add_default_group(&wwn->param_group, &wwn->wwn_group);
1073 
1074 	if (tf->tf_ops->add_wwn_groups)
1075 		tf->tf_ops->add_wwn_groups(wwn);
1076 	return &wwn->wwn_group;
1077 }
1078 
1079 static void target_fabric_drop_wwn(
1080 	struct config_group *group,
1081 	struct config_item *item)
1082 {
1083 	struct se_wwn *wwn = container_of(to_config_group(item),
1084 				struct se_wwn, wwn_group);
1085 
1086 	configfs_remove_default_groups(&wwn->wwn_group);
1087 	config_item_put(item);
1088 }
1089 
1090 static struct configfs_group_operations target_fabric_wwn_group_ops = {
1091 	.make_group	= target_fabric_make_wwn,
1092 	.drop_item	= target_fabric_drop_wwn,
1093 };
1094 
1095 TF_CIT_SETUP_DRV(wwn, NULL, &target_fabric_wwn_group_ops);
1096 TF_CIT_SETUP_DRV(discovery, NULL, NULL);
1097 
1098 int target_fabric_setup_cits(struct target_fabric_configfs *tf)
1099 {
1100 	int ret;
1101 
1102 	target_fabric_setup_discovery_cit(tf);
1103 	target_fabric_setup_wwn_cit(tf);
1104 	target_fabric_setup_wwn_fabric_stats_cit(tf);
1105 	target_fabric_setup_wwn_param_cit(tf);
1106 	target_fabric_setup_tpg_cit(tf);
1107 
1108 	ret = target_fabric_setup_tpg_base_cit(tf);
1109 	if (ret)
1110 		return ret;
1111 
1112 	target_fabric_setup_tpg_port_cit(tf);
1113 	target_fabric_setup_tpg_port_stat_cit(tf);
1114 	target_fabric_setup_tpg_lun_cit(tf);
1115 	target_fabric_setup_tpg_np_cit(tf);
1116 	target_fabric_setup_tpg_np_base_cit(tf);
1117 	target_fabric_setup_tpg_attrib_cit(tf);
1118 	target_fabric_setup_tpg_auth_cit(tf);
1119 	target_fabric_setup_tpg_param_cit(tf);
1120 	target_fabric_setup_tpg_nacl_cit(tf);
1121 	target_fabric_setup_tpg_nacl_base_cit(tf);
1122 	target_fabric_setup_tpg_nacl_attrib_cit(tf);
1123 	target_fabric_setup_tpg_nacl_auth_cit(tf);
1124 	target_fabric_setup_tpg_nacl_param_cit(tf);
1125 	target_fabric_setup_tpg_nacl_stat_cit(tf);
1126 	target_fabric_setup_tpg_mappedlun_cit(tf);
1127 	target_fabric_setup_tpg_mappedlun_stat_cit(tf);
1128 
1129 	return 0;
1130 }
1131