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