1 /*******************************************************************************
2  * This file contains the configfs implementation for iSCSI Target mode
3  * from the LIO-Target Project.
4  *
5  * (c) Copyright 2007-2013 Datera, Inc.
6  *
7  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  ****************************************************************************/
19 
20 #include <linux/configfs.h>
21 #include <linux/ctype.h>
22 #include <linux/export.h>
23 #include <linux/inet.h>
24 #include <target/target_core_base.h>
25 #include <target/target_core_fabric.h>
26 #include <target/target_core_fabric_configfs.h>
27 #include <target/target_core_configfs.h>
28 #include <target/configfs_macros.h>
29 #include <target/iscsi/iscsi_transport.h>
30 
31 #include "iscsi_target_core.h"
32 #include "iscsi_target_parameters.h"
33 #include "iscsi_target_device.h"
34 #include "iscsi_target_erl0.h"
35 #include "iscsi_target_nodeattrib.h"
36 #include "iscsi_target_tpg.h"
37 #include "iscsi_target_util.h"
38 #include "iscsi_target.h"
39 #include "iscsi_target_stat.h"
40 #include "iscsi_target_configfs.h"
41 
42 struct target_fabric_configfs *lio_target_fabric_configfs;
43 
44 struct lio_target_configfs_attribute {
45 	struct configfs_attribute attr;
46 	ssize_t (*show)(void *, char *);
47 	ssize_t (*store)(void *, const char *, size_t);
48 };
49 
50 /* Start items for lio_target_portal_cit */
51 
52 static ssize_t lio_target_np_show_sctp(
53 	struct se_tpg_np *se_tpg_np,
54 	char *page)
55 {
56 	struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
57 				struct iscsi_tpg_np, se_tpg_np);
58 	struct iscsi_tpg_np *tpg_np_sctp;
59 	ssize_t rb;
60 
61 	tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP);
62 	if (tpg_np_sctp)
63 		rb = sprintf(page, "1\n");
64 	else
65 		rb = sprintf(page, "0\n");
66 
67 	return rb;
68 }
69 
70 static ssize_t lio_target_np_store_sctp(
71 	struct se_tpg_np *se_tpg_np,
72 	const char *page,
73 	size_t count)
74 {
75 	struct iscsi_np *np;
76 	struct iscsi_portal_group *tpg;
77 	struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
78 				struct iscsi_tpg_np, se_tpg_np);
79 	struct iscsi_tpg_np *tpg_np_sctp = NULL;
80 	u32 op;
81 	int ret;
82 
83 	ret = kstrtou32(page, 0, &op);
84 	if (ret)
85 		return ret;
86 	if ((op != 1) && (op != 0)) {
87 		pr_err("Illegal value for tpg_enable: %u\n", op);
88 		return -EINVAL;
89 	}
90 	np = tpg_np->tpg_np;
91 	if (!np) {
92 		pr_err("Unable to locate struct iscsi_np from"
93 				" struct iscsi_tpg_np\n");
94 		return -EINVAL;
95 	}
96 
97 	tpg = tpg_np->tpg;
98 	if (iscsit_get_tpg(tpg) < 0)
99 		return -EINVAL;
100 
101 	if (op) {
102 		/*
103 		 * Use existing np->np_sockaddr for SCTP network portal reference
104 		 */
105 		tpg_np_sctp = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr,
106 					np->np_ip, tpg_np, ISCSI_SCTP_TCP);
107 		if (!tpg_np_sctp || IS_ERR(tpg_np_sctp))
108 			goto out;
109 	} else {
110 		tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP);
111 		if (!tpg_np_sctp)
112 			goto out;
113 
114 		ret = iscsit_tpg_del_network_portal(tpg, tpg_np_sctp);
115 		if (ret < 0)
116 			goto out;
117 	}
118 
119 	iscsit_put_tpg(tpg);
120 	return count;
121 out:
122 	iscsit_put_tpg(tpg);
123 	return -EINVAL;
124 }
125 
126 TF_NP_BASE_ATTR(lio_target, sctp, S_IRUGO | S_IWUSR);
127 
128 static ssize_t lio_target_np_show_iser(
129 	struct se_tpg_np *se_tpg_np,
130 	char *page)
131 {
132 	struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
133 				struct iscsi_tpg_np, se_tpg_np);
134 	struct iscsi_tpg_np *tpg_np_iser;
135 	ssize_t rb;
136 
137 	tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND);
138 	if (tpg_np_iser)
139 		rb = sprintf(page, "1\n");
140 	else
141 		rb = sprintf(page, "0\n");
142 
143 	return rb;
144 }
145 
146 static ssize_t lio_target_np_store_iser(
147 	struct se_tpg_np *se_tpg_np,
148 	const char *page,
149 	size_t count)
150 {
151 	struct iscsi_np *np;
152 	struct iscsi_portal_group *tpg;
153 	struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
154 				struct iscsi_tpg_np, se_tpg_np);
155 	struct iscsi_tpg_np *tpg_np_iser = NULL;
156 	char *endptr;
157 	u32 op;
158 	int rc = 0;
159 
160 	op = simple_strtoul(page, &endptr, 0);
161 	if ((op != 1) && (op != 0)) {
162 		pr_err("Illegal value for tpg_enable: %u\n", op);
163 		return -EINVAL;
164 	}
165 	np = tpg_np->tpg_np;
166 	if (!np) {
167 		pr_err("Unable to locate struct iscsi_np from"
168 				" struct iscsi_tpg_np\n");
169 		return -EINVAL;
170 	}
171 
172 	tpg = tpg_np->tpg;
173 	if (iscsit_get_tpg(tpg) < 0)
174 		return -EINVAL;
175 
176 	if (op) {
177 		rc = request_module("ib_isert");
178 		if (rc != 0) {
179 			pr_warn("Unable to request_module for ib_isert\n");
180 			rc = 0;
181 		}
182 
183 		tpg_np_iser = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr,
184 				np->np_ip, tpg_np, ISCSI_INFINIBAND);
185 		if (IS_ERR(tpg_np_iser)) {
186 			rc = PTR_ERR(tpg_np_iser);
187 			goto out;
188 		}
189 	} else {
190 		tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND);
191 		if (tpg_np_iser) {
192 			rc = iscsit_tpg_del_network_portal(tpg, tpg_np_iser);
193 			if (rc < 0)
194 				goto out;
195 		}
196 	}
197 
198 	iscsit_put_tpg(tpg);
199 	return count;
200 out:
201 	iscsit_put_tpg(tpg);
202 	return rc;
203 }
204 
205 TF_NP_BASE_ATTR(lio_target, iser, S_IRUGO | S_IWUSR);
206 
207 static struct configfs_attribute *lio_target_portal_attrs[] = {
208 	&lio_target_np_sctp.attr,
209 	&lio_target_np_iser.attr,
210 	NULL,
211 };
212 
213 /* Stop items for lio_target_portal_cit */
214 
215 /* Start items for lio_target_np_cit */
216 
217 #define MAX_PORTAL_LEN		256
218 
219 static struct se_tpg_np *lio_target_call_addnptotpg(
220 	struct se_portal_group *se_tpg,
221 	struct config_group *group,
222 	const char *name)
223 {
224 	struct iscsi_portal_group *tpg;
225 	struct iscsi_tpg_np *tpg_np;
226 	char *str, *str2, *ip_str, *port_str;
227 	struct __kernel_sockaddr_storage sockaddr;
228 	struct sockaddr_in *sock_in;
229 	struct sockaddr_in6 *sock_in6;
230 	unsigned long port;
231 	int ret;
232 	char buf[MAX_PORTAL_LEN + 1];
233 
234 	if (strlen(name) > MAX_PORTAL_LEN) {
235 		pr_err("strlen(name): %d exceeds MAX_PORTAL_LEN: %d\n",
236 			(int)strlen(name), MAX_PORTAL_LEN);
237 		return ERR_PTR(-EOVERFLOW);
238 	}
239 	memset(buf, 0, MAX_PORTAL_LEN + 1);
240 	snprintf(buf, MAX_PORTAL_LEN + 1, "%s", name);
241 
242 	memset(&sockaddr, 0, sizeof(struct __kernel_sockaddr_storage));
243 
244 	str = strstr(buf, "[");
245 	if (str) {
246 		const char *end;
247 
248 		str2 = strstr(str, "]");
249 		if (!str2) {
250 			pr_err("Unable to locate trailing \"]\""
251 				" in IPv6 iSCSI network portal address\n");
252 			return ERR_PTR(-EINVAL);
253 		}
254 		str++; /* Skip over leading "[" */
255 		*str2 = '\0'; /* Terminate the IPv6 address */
256 		str2++; /* Skip over the "]" */
257 		port_str = strstr(str2, ":");
258 		if (!port_str) {
259 			pr_err("Unable to locate \":port\""
260 				" in IPv6 iSCSI network portal address\n");
261 			return ERR_PTR(-EINVAL);
262 		}
263 		*port_str = '\0'; /* Terminate string for IP */
264 		port_str++; /* Skip over ":" */
265 
266 		ret = kstrtoul(port_str, 0, &port);
267 		if (ret < 0) {
268 			pr_err("kstrtoul() failed for port_str: %d\n", ret);
269 			return ERR_PTR(ret);
270 		}
271 		sock_in6 = (struct sockaddr_in6 *)&sockaddr;
272 		sock_in6->sin6_family = AF_INET6;
273 		sock_in6->sin6_port = htons((unsigned short)port);
274 		ret = in6_pton(str, IPV6_ADDRESS_SPACE,
275 				(void *)&sock_in6->sin6_addr.in6_u, -1, &end);
276 		if (ret <= 0) {
277 			pr_err("in6_pton returned: %d\n", ret);
278 			return ERR_PTR(-EINVAL);
279 		}
280 	} else {
281 		str = ip_str = &buf[0];
282 		port_str = strstr(ip_str, ":");
283 		if (!port_str) {
284 			pr_err("Unable to locate \":port\""
285 				" in IPv4 iSCSI network portal address\n");
286 			return ERR_PTR(-EINVAL);
287 		}
288 		*port_str = '\0'; /* Terminate string for IP */
289 		port_str++; /* Skip over ":" */
290 
291 		ret = kstrtoul(port_str, 0, &port);
292 		if (ret < 0) {
293 			pr_err("kstrtoul() failed for port_str: %d\n", ret);
294 			return ERR_PTR(ret);
295 		}
296 		sock_in = (struct sockaddr_in *)&sockaddr;
297 		sock_in->sin_family = AF_INET;
298 		sock_in->sin_port = htons((unsigned short)port);
299 		sock_in->sin_addr.s_addr = in_aton(ip_str);
300 	}
301 	tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
302 	ret = iscsit_get_tpg(tpg);
303 	if (ret < 0)
304 		return ERR_PTR(-EINVAL);
305 
306 	pr_debug("LIO_Target_ConfigFS: REGISTER -> %s TPGT: %hu"
307 		" PORTAL: %s\n",
308 		config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item),
309 		tpg->tpgt, name);
310 	/*
311 	 * Assume ISCSI_TCP by default.  Other network portals for other
312 	 * iSCSI fabrics:
313 	 *
314 	 * Traditional iSCSI over SCTP (initial support)
315 	 * iSER/TCP (TODO, hardware available)
316 	 * iSER/SCTP (TODO, software emulation with osc-iwarp)
317 	 * iSER/IB (TODO, hardware available)
318 	 *
319 	 * can be enabled with attributes under
320 	 * sys/kernel/config/iscsi/$IQN/$TPG/np/$IP:$PORT/
321 	 *
322 	 */
323 	tpg_np = iscsit_tpg_add_network_portal(tpg, &sockaddr, str, NULL,
324 				ISCSI_TCP);
325 	if (IS_ERR(tpg_np)) {
326 		iscsit_put_tpg(tpg);
327 		return ERR_CAST(tpg_np);
328 	}
329 	pr_debug("LIO_Target_ConfigFS: addnptotpg done!\n");
330 
331 	iscsit_put_tpg(tpg);
332 	return &tpg_np->se_tpg_np;
333 }
334 
335 static void lio_target_call_delnpfromtpg(
336 	struct se_tpg_np *se_tpg_np)
337 {
338 	struct iscsi_portal_group *tpg;
339 	struct iscsi_tpg_np *tpg_np;
340 	struct se_portal_group *se_tpg;
341 	int ret;
342 
343 	tpg_np = container_of(se_tpg_np, struct iscsi_tpg_np, se_tpg_np);
344 	tpg = tpg_np->tpg;
345 	ret = iscsit_get_tpg(tpg);
346 	if (ret < 0)
347 		return;
348 
349 	se_tpg = &tpg->tpg_se_tpg;
350 	pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s TPGT: %hu"
351 		" PORTAL: %s:%hu\n", config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item),
352 		tpg->tpgt, tpg_np->tpg_np->np_ip, tpg_np->tpg_np->np_port);
353 
354 	ret = iscsit_tpg_del_network_portal(tpg, tpg_np);
355 	if (ret < 0)
356 		goto out;
357 
358 	pr_debug("LIO_Target_ConfigFS: delnpfromtpg done!\n");
359 out:
360 	iscsit_put_tpg(tpg);
361 }
362 
363 /* End items for lio_target_np_cit */
364 
365 /* Start items for lio_target_nacl_attrib_cit */
366 
367 #define DEF_NACL_ATTRIB(name)						\
368 static ssize_t iscsi_nacl_attrib_show_##name(				\
369 	struct se_node_acl *se_nacl,					\
370 	char *page)							\
371 {									\
372 	struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \
373 					se_node_acl);			\
374 									\
375 	return sprintf(page, "%u\n", nacl->node_attrib.name);		\
376 }									\
377 									\
378 static ssize_t iscsi_nacl_attrib_store_##name(				\
379 	struct se_node_acl *se_nacl,					\
380 	const char *page,						\
381 	size_t count)							\
382 {									\
383 	struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \
384 					se_node_acl);			\
385 	u32 val;							\
386 	int ret;							\
387 									\
388 	ret = kstrtou32(page, 0, &val);					\
389 	if (ret)							\
390 		return ret;						\
391 	ret = iscsit_na_##name(nacl, val);				\
392 	if (ret < 0)							\
393 		return ret;						\
394 									\
395 	return count;							\
396 }
397 
398 #define NACL_ATTR(_name, _mode) TF_NACL_ATTRIB_ATTR(iscsi, _name, _mode);
399 /*
400  * Define iscsi_node_attrib_s_dataout_timeout
401  */
402 DEF_NACL_ATTRIB(dataout_timeout);
403 NACL_ATTR(dataout_timeout, S_IRUGO | S_IWUSR);
404 /*
405  * Define iscsi_node_attrib_s_dataout_timeout_retries
406  */
407 DEF_NACL_ATTRIB(dataout_timeout_retries);
408 NACL_ATTR(dataout_timeout_retries, S_IRUGO | S_IWUSR);
409 /*
410  * Define iscsi_node_attrib_s_default_erl
411  */
412 DEF_NACL_ATTRIB(default_erl);
413 NACL_ATTR(default_erl, S_IRUGO | S_IWUSR);
414 /*
415  * Define iscsi_node_attrib_s_nopin_timeout
416  */
417 DEF_NACL_ATTRIB(nopin_timeout);
418 NACL_ATTR(nopin_timeout, S_IRUGO | S_IWUSR);
419 /*
420  * Define iscsi_node_attrib_s_nopin_response_timeout
421  */
422 DEF_NACL_ATTRIB(nopin_response_timeout);
423 NACL_ATTR(nopin_response_timeout, S_IRUGO | S_IWUSR);
424 /*
425  * Define iscsi_node_attrib_s_random_datain_pdu_offsets
426  */
427 DEF_NACL_ATTRIB(random_datain_pdu_offsets);
428 NACL_ATTR(random_datain_pdu_offsets, S_IRUGO | S_IWUSR);
429 /*
430  * Define iscsi_node_attrib_s_random_datain_seq_offsets
431  */
432 DEF_NACL_ATTRIB(random_datain_seq_offsets);
433 NACL_ATTR(random_datain_seq_offsets, S_IRUGO | S_IWUSR);
434 /*
435  * Define iscsi_node_attrib_s_random_r2t_offsets
436  */
437 DEF_NACL_ATTRIB(random_r2t_offsets);
438 NACL_ATTR(random_r2t_offsets, S_IRUGO | S_IWUSR);
439 
440 static struct configfs_attribute *lio_target_nacl_attrib_attrs[] = {
441 	&iscsi_nacl_attrib_dataout_timeout.attr,
442 	&iscsi_nacl_attrib_dataout_timeout_retries.attr,
443 	&iscsi_nacl_attrib_default_erl.attr,
444 	&iscsi_nacl_attrib_nopin_timeout.attr,
445 	&iscsi_nacl_attrib_nopin_response_timeout.attr,
446 	&iscsi_nacl_attrib_random_datain_pdu_offsets.attr,
447 	&iscsi_nacl_attrib_random_datain_seq_offsets.attr,
448 	&iscsi_nacl_attrib_random_r2t_offsets.attr,
449 	NULL,
450 };
451 
452 /* End items for lio_target_nacl_attrib_cit */
453 
454 /* Start items for lio_target_nacl_auth_cit */
455 
456 #define __DEF_NACL_AUTH_STR(prefix, name, flags)			\
457 static ssize_t __iscsi_##prefix##_show_##name(				\
458 	struct iscsi_node_acl *nacl,					\
459 	char *page)							\
460 {									\
461 	struct iscsi_node_auth *auth = &nacl->node_auth;		\
462 									\
463 	if (!capable(CAP_SYS_ADMIN))					\
464 		return -EPERM;						\
465 	return snprintf(page, PAGE_SIZE, "%s\n", auth->name);		\
466 }									\
467 									\
468 static ssize_t __iscsi_##prefix##_store_##name(				\
469 	struct iscsi_node_acl *nacl,					\
470 	const char *page,						\
471 	size_t count)							\
472 {									\
473 	struct iscsi_node_auth *auth = &nacl->node_auth;		\
474 									\
475 	if (!capable(CAP_SYS_ADMIN))					\
476 		return -EPERM;						\
477 	if (count >= sizeof(auth->name))				\
478 		return -EINVAL;						\
479 	snprintf(auth->name, sizeof(auth->name), "%s", page);		\
480 	if (!strncmp("NULL", auth->name, 4))				\
481 		auth->naf_flags &= ~flags;				\
482 	else								\
483 		auth->naf_flags |= flags;				\
484 									\
485 	if ((auth->naf_flags & NAF_USERID_IN_SET) &&			\
486 	    (auth->naf_flags & NAF_PASSWORD_IN_SET))			\
487 		auth->authenticate_target = 1;				\
488 	else								\
489 		auth->authenticate_target = 0;				\
490 									\
491 	return count;							\
492 }
493 
494 #define __DEF_NACL_AUTH_INT(prefix, name)				\
495 static ssize_t __iscsi_##prefix##_show_##name(				\
496 	struct iscsi_node_acl *nacl,					\
497 	char *page)							\
498 {									\
499 	struct iscsi_node_auth *auth = &nacl->node_auth;		\
500 									\
501 	if (!capable(CAP_SYS_ADMIN))					\
502 		return -EPERM;						\
503 									\
504 	return snprintf(page, PAGE_SIZE, "%d\n", auth->name);		\
505 }
506 
507 #define DEF_NACL_AUTH_STR(name, flags)					\
508 	__DEF_NACL_AUTH_STR(nacl_auth, name, flags)			\
509 static ssize_t iscsi_nacl_auth_show_##name(				\
510 	struct se_node_acl *nacl,					\
511 	char *page)							\
512 {									\
513 	return __iscsi_nacl_auth_show_##name(container_of(nacl,		\
514 			struct iscsi_node_acl, se_node_acl), page);		\
515 }									\
516 static ssize_t iscsi_nacl_auth_store_##name(				\
517 	struct se_node_acl *nacl,					\
518 	const char *page,						\
519 	size_t count)							\
520 {									\
521 	return __iscsi_nacl_auth_store_##name(container_of(nacl,	\
522 			struct iscsi_node_acl, se_node_acl), page, count);	\
523 }
524 
525 #define DEF_NACL_AUTH_INT(name)						\
526 	__DEF_NACL_AUTH_INT(nacl_auth, name)				\
527 static ssize_t iscsi_nacl_auth_show_##name(				\
528 	struct se_node_acl *nacl,					\
529 	char *page)							\
530 {									\
531 	return __iscsi_nacl_auth_show_##name(container_of(nacl,		\
532 			struct iscsi_node_acl, se_node_acl), page);		\
533 }
534 
535 #define AUTH_ATTR(_name, _mode)	TF_NACL_AUTH_ATTR(iscsi, _name, _mode);
536 #define AUTH_ATTR_RO(_name) TF_NACL_AUTH_ATTR_RO(iscsi, _name);
537 
538 /*
539  * One-way authentication userid
540  */
541 DEF_NACL_AUTH_STR(userid, NAF_USERID_SET);
542 AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
543 /*
544  * One-way authentication password
545  */
546 DEF_NACL_AUTH_STR(password, NAF_PASSWORD_SET);
547 AUTH_ATTR(password, S_IRUGO | S_IWUSR);
548 /*
549  * Enforce mutual authentication
550  */
551 DEF_NACL_AUTH_INT(authenticate_target);
552 AUTH_ATTR_RO(authenticate_target);
553 /*
554  * Mutual authentication userid
555  */
556 DEF_NACL_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
557 AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
558 /*
559  * Mutual authentication password
560  */
561 DEF_NACL_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
562 AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
563 
564 static struct configfs_attribute *lio_target_nacl_auth_attrs[] = {
565 	&iscsi_nacl_auth_userid.attr,
566 	&iscsi_nacl_auth_password.attr,
567 	&iscsi_nacl_auth_authenticate_target.attr,
568 	&iscsi_nacl_auth_userid_mutual.attr,
569 	&iscsi_nacl_auth_password_mutual.attr,
570 	NULL,
571 };
572 
573 /* End items for lio_target_nacl_auth_cit */
574 
575 /* Start items for lio_target_nacl_param_cit */
576 
577 #define DEF_NACL_PARAM(name)						\
578 static ssize_t iscsi_nacl_param_show_##name(				\
579 	struct se_node_acl *se_nacl,					\
580 	char *page)							\
581 {									\
582 	struct iscsi_session *sess;					\
583 	struct se_session *se_sess;					\
584 	ssize_t rb;							\
585 									\
586 	spin_lock_bh(&se_nacl->nacl_sess_lock);				\
587 	se_sess = se_nacl->nacl_sess;					\
588 	if (!se_sess) {							\
589 		rb = snprintf(page, PAGE_SIZE,				\
590 			"No Active iSCSI Session\n");			\
591 	} else {							\
592 		sess = se_sess->fabric_sess_ptr;			\
593 		rb = snprintf(page, PAGE_SIZE, "%u\n",			\
594 			(u32)sess->sess_ops->name);			\
595 	}								\
596 	spin_unlock_bh(&se_nacl->nacl_sess_lock);			\
597 									\
598 	return rb;							\
599 }
600 
601 #define NACL_PARAM_ATTR(_name) TF_NACL_PARAM_ATTR_RO(iscsi, _name);
602 
603 DEF_NACL_PARAM(MaxConnections);
604 NACL_PARAM_ATTR(MaxConnections);
605 
606 DEF_NACL_PARAM(InitialR2T);
607 NACL_PARAM_ATTR(InitialR2T);
608 
609 DEF_NACL_PARAM(ImmediateData);
610 NACL_PARAM_ATTR(ImmediateData);
611 
612 DEF_NACL_PARAM(MaxBurstLength);
613 NACL_PARAM_ATTR(MaxBurstLength);
614 
615 DEF_NACL_PARAM(FirstBurstLength);
616 NACL_PARAM_ATTR(FirstBurstLength);
617 
618 DEF_NACL_PARAM(DefaultTime2Wait);
619 NACL_PARAM_ATTR(DefaultTime2Wait);
620 
621 DEF_NACL_PARAM(DefaultTime2Retain);
622 NACL_PARAM_ATTR(DefaultTime2Retain);
623 
624 DEF_NACL_PARAM(MaxOutstandingR2T);
625 NACL_PARAM_ATTR(MaxOutstandingR2T);
626 
627 DEF_NACL_PARAM(DataPDUInOrder);
628 NACL_PARAM_ATTR(DataPDUInOrder);
629 
630 DEF_NACL_PARAM(DataSequenceInOrder);
631 NACL_PARAM_ATTR(DataSequenceInOrder);
632 
633 DEF_NACL_PARAM(ErrorRecoveryLevel);
634 NACL_PARAM_ATTR(ErrorRecoveryLevel);
635 
636 static struct configfs_attribute *lio_target_nacl_param_attrs[] = {
637 	&iscsi_nacl_param_MaxConnections.attr,
638 	&iscsi_nacl_param_InitialR2T.attr,
639 	&iscsi_nacl_param_ImmediateData.attr,
640 	&iscsi_nacl_param_MaxBurstLength.attr,
641 	&iscsi_nacl_param_FirstBurstLength.attr,
642 	&iscsi_nacl_param_DefaultTime2Wait.attr,
643 	&iscsi_nacl_param_DefaultTime2Retain.attr,
644 	&iscsi_nacl_param_MaxOutstandingR2T.attr,
645 	&iscsi_nacl_param_DataPDUInOrder.attr,
646 	&iscsi_nacl_param_DataSequenceInOrder.attr,
647 	&iscsi_nacl_param_ErrorRecoveryLevel.attr,
648 	NULL,
649 };
650 
651 /* End items for lio_target_nacl_param_cit */
652 
653 /* Start items for lio_target_acl_cit */
654 
655 static ssize_t lio_target_nacl_show_info(
656 	struct se_node_acl *se_nacl,
657 	char *page)
658 {
659 	struct iscsi_session *sess;
660 	struct iscsi_conn *conn;
661 	struct se_session *se_sess;
662 	ssize_t rb = 0;
663 
664 	spin_lock_bh(&se_nacl->nacl_sess_lock);
665 	se_sess = se_nacl->nacl_sess;
666 	if (!se_sess) {
667 		rb += sprintf(page+rb, "No active iSCSI Session for Initiator"
668 			" Endpoint: %s\n", se_nacl->initiatorname);
669 	} else {
670 		sess = se_sess->fabric_sess_ptr;
671 
672 		rb += sprintf(page+rb, "InitiatorName: %s\n",
673 			sess->sess_ops->InitiatorName);
674 		rb += sprintf(page+rb, "InitiatorAlias: %s\n",
675 			sess->sess_ops->InitiatorAlias);
676 
677 		rb += sprintf(page+rb, "LIO Session ID: %u   "
678 			"ISID: 0x%02x %02x %02x %02x %02x %02x  "
679 			"TSIH: %hu  ", sess->sid,
680 			sess->isid[0], sess->isid[1], sess->isid[2],
681 			sess->isid[3], sess->isid[4], sess->isid[5],
682 			sess->tsih);
683 		rb += sprintf(page+rb, "SessionType: %s\n",
684 				(sess->sess_ops->SessionType) ?
685 				"Discovery" : "Normal");
686 		rb += sprintf(page+rb, "Session State: ");
687 		switch (sess->session_state) {
688 		case TARG_SESS_STATE_FREE:
689 			rb += sprintf(page+rb, "TARG_SESS_FREE\n");
690 			break;
691 		case TARG_SESS_STATE_ACTIVE:
692 			rb += sprintf(page+rb, "TARG_SESS_STATE_ACTIVE\n");
693 			break;
694 		case TARG_SESS_STATE_LOGGED_IN:
695 			rb += sprintf(page+rb, "TARG_SESS_STATE_LOGGED_IN\n");
696 			break;
697 		case TARG_SESS_STATE_FAILED:
698 			rb += sprintf(page+rb, "TARG_SESS_STATE_FAILED\n");
699 			break;
700 		case TARG_SESS_STATE_IN_CONTINUE:
701 			rb += sprintf(page+rb, "TARG_SESS_STATE_IN_CONTINUE\n");
702 			break;
703 		default:
704 			rb += sprintf(page+rb, "ERROR: Unknown Session"
705 					" State!\n");
706 			break;
707 		}
708 
709 		rb += sprintf(page+rb, "---------------------[iSCSI Session"
710 				" Values]-----------------------\n");
711 		rb += sprintf(page+rb, "  CmdSN/WR  :  CmdSN/WC  :  ExpCmdSN"
712 				"  :  MaxCmdSN  :     ITT    :     TTT\n");
713 		rb += sprintf(page+rb, " 0x%08x   0x%08x   0x%08x   0x%08x"
714 				"   0x%08x   0x%08x\n",
715 			sess->cmdsn_window,
716 			(sess->max_cmd_sn - sess->exp_cmd_sn) + 1,
717 			sess->exp_cmd_sn, sess->max_cmd_sn,
718 			sess->init_task_tag, sess->targ_xfer_tag);
719 		rb += sprintf(page+rb, "----------------------[iSCSI"
720 				" Connections]-------------------------\n");
721 
722 		spin_lock(&sess->conn_lock);
723 		list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
724 			rb += sprintf(page+rb, "CID: %hu  Connection"
725 					" State: ", conn->cid);
726 			switch (conn->conn_state) {
727 			case TARG_CONN_STATE_FREE:
728 				rb += sprintf(page+rb,
729 					"TARG_CONN_STATE_FREE\n");
730 				break;
731 			case TARG_CONN_STATE_XPT_UP:
732 				rb += sprintf(page+rb,
733 					"TARG_CONN_STATE_XPT_UP\n");
734 				break;
735 			case TARG_CONN_STATE_IN_LOGIN:
736 				rb += sprintf(page+rb,
737 					"TARG_CONN_STATE_IN_LOGIN\n");
738 				break;
739 			case TARG_CONN_STATE_LOGGED_IN:
740 				rb += sprintf(page+rb,
741 					"TARG_CONN_STATE_LOGGED_IN\n");
742 				break;
743 			case TARG_CONN_STATE_IN_LOGOUT:
744 				rb += sprintf(page+rb,
745 					"TARG_CONN_STATE_IN_LOGOUT\n");
746 				break;
747 			case TARG_CONN_STATE_LOGOUT_REQUESTED:
748 				rb += sprintf(page+rb,
749 					"TARG_CONN_STATE_LOGOUT_REQUESTED\n");
750 				break;
751 			case TARG_CONN_STATE_CLEANUP_WAIT:
752 				rb += sprintf(page+rb,
753 					"TARG_CONN_STATE_CLEANUP_WAIT\n");
754 				break;
755 			default:
756 				rb += sprintf(page+rb,
757 					"ERROR: Unknown Connection State!\n");
758 				break;
759 			}
760 
761 			rb += sprintf(page+rb, "   Address %s %s", conn->login_ip,
762 				(conn->network_transport == ISCSI_TCP) ?
763 				"TCP" : "SCTP");
764 			rb += sprintf(page+rb, "  StatSN: 0x%08x\n",
765 				conn->stat_sn);
766 		}
767 		spin_unlock(&sess->conn_lock);
768 	}
769 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
770 
771 	return rb;
772 }
773 
774 TF_NACL_BASE_ATTR_RO(lio_target, info);
775 
776 static ssize_t lio_target_nacl_show_cmdsn_depth(
777 	struct se_node_acl *se_nacl,
778 	char *page)
779 {
780 	return sprintf(page, "%u\n", se_nacl->queue_depth);
781 }
782 
783 static ssize_t lio_target_nacl_store_cmdsn_depth(
784 	struct se_node_acl *se_nacl,
785 	const char *page,
786 	size_t count)
787 {
788 	struct se_portal_group *se_tpg = se_nacl->se_tpg;
789 	struct iscsi_portal_group *tpg = container_of(se_tpg,
790 			struct iscsi_portal_group, tpg_se_tpg);
791 	struct config_item *acl_ci, *tpg_ci, *wwn_ci;
792 	u32 cmdsn_depth = 0;
793 	int ret;
794 
795 	ret = kstrtou32(page, 0, &cmdsn_depth);
796 	if (ret)
797 		return ret;
798 	if (cmdsn_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) {
799 		pr_err("Passed cmdsn_depth: %u exceeds"
800 			" TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n", cmdsn_depth,
801 			TA_DEFAULT_CMDSN_DEPTH_MAX);
802 		return -EINVAL;
803 	}
804 	acl_ci = &se_nacl->acl_group.cg_item;
805 	if (!acl_ci) {
806 		pr_err("Unable to locatel acl_ci\n");
807 		return -EINVAL;
808 	}
809 	tpg_ci = &acl_ci->ci_parent->ci_group->cg_item;
810 	if (!tpg_ci) {
811 		pr_err("Unable to locate tpg_ci\n");
812 		return -EINVAL;
813 	}
814 	wwn_ci = &tpg_ci->ci_group->cg_item;
815 	if (!wwn_ci) {
816 		pr_err("Unable to locate config_item wwn_ci\n");
817 		return -EINVAL;
818 	}
819 
820 	if (iscsit_get_tpg(tpg) < 0)
821 		return -EINVAL;
822 	/*
823 	 * iscsit_tpg_set_initiator_node_queue_depth() assumes force=1
824 	 */
825 	ret = iscsit_tpg_set_initiator_node_queue_depth(tpg,
826 				config_item_name(acl_ci), cmdsn_depth, 1);
827 
828 	pr_debug("LIO_Target_ConfigFS: %s/%s Set CmdSN Window: %u for"
829 		"InitiatorName: %s\n", config_item_name(wwn_ci),
830 		config_item_name(tpg_ci), cmdsn_depth,
831 		config_item_name(acl_ci));
832 
833 	iscsit_put_tpg(tpg);
834 	return (!ret) ? count : (ssize_t)ret;
835 }
836 
837 TF_NACL_BASE_ATTR(lio_target, cmdsn_depth, S_IRUGO | S_IWUSR);
838 
839 static ssize_t lio_target_nacl_show_tag(
840 	struct se_node_acl *se_nacl,
841 	char *page)
842 {
843 	return snprintf(page, PAGE_SIZE, "%s", se_nacl->acl_tag);
844 }
845 
846 static ssize_t lio_target_nacl_store_tag(
847 	struct se_node_acl *se_nacl,
848 	const char *page,
849 	size_t count)
850 {
851 	int ret;
852 
853 	ret = core_tpg_set_initiator_node_tag(se_nacl->se_tpg, se_nacl, page);
854 
855 	if (ret < 0)
856 		return ret;
857 	return count;
858 }
859 
860 TF_NACL_BASE_ATTR(lio_target, tag, S_IRUGO | S_IWUSR);
861 
862 static struct configfs_attribute *lio_target_initiator_attrs[] = {
863 	&lio_target_nacl_info.attr,
864 	&lio_target_nacl_cmdsn_depth.attr,
865 	&lio_target_nacl_tag.attr,
866 	NULL,
867 };
868 
869 static struct se_node_acl *lio_tpg_alloc_fabric_acl(
870 	struct se_portal_group *se_tpg)
871 {
872 	struct iscsi_node_acl *acl;
873 
874 	acl = kzalloc(sizeof(struct iscsi_node_acl), GFP_KERNEL);
875 	if (!acl) {
876 		pr_err("Unable to allocate memory for struct iscsi_node_acl\n");
877 		return NULL;
878 	}
879 
880 	return &acl->se_node_acl;
881 }
882 
883 static struct se_node_acl *lio_target_make_nodeacl(
884 	struct se_portal_group *se_tpg,
885 	struct config_group *group,
886 	const char *name)
887 {
888 	struct config_group *stats_cg;
889 	struct iscsi_node_acl *acl;
890 	struct se_node_acl *se_nacl_new, *se_nacl;
891 	struct iscsi_portal_group *tpg = container_of(se_tpg,
892 			struct iscsi_portal_group, tpg_se_tpg);
893 	u32 cmdsn_depth;
894 
895 	se_nacl_new = lio_tpg_alloc_fabric_acl(se_tpg);
896 	if (!se_nacl_new)
897 		return ERR_PTR(-ENOMEM);
898 
899 	cmdsn_depth = tpg->tpg_attrib.default_cmdsn_depth;
900 	/*
901 	 * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
902 	 * when converting a NdoeACL from demo mode -> explict
903 	 */
904 	se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
905 				name, cmdsn_depth);
906 	if (IS_ERR(se_nacl))
907 		return se_nacl;
908 
909 	acl = container_of(se_nacl, struct iscsi_node_acl, se_node_acl);
910 	stats_cg = &se_nacl->acl_fabric_stat_group;
911 
912 	stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,
913 				GFP_KERNEL);
914 	if (!stats_cg->default_groups) {
915 		pr_err("Unable to allocate memory for"
916 				" stats_cg->default_groups\n");
917 		core_tpg_del_initiator_node_acl(se_tpg, se_nacl, 1);
918 		kfree(acl);
919 		return ERR_PTR(-ENOMEM);
920 	}
921 
922 	stats_cg->default_groups[0] = &acl->node_stat_grps.iscsi_sess_stats_group;
923 	stats_cg->default_groups[1] = NULL;
924 	config_group_init_type_name(&acl->node_stat_grps.iscsi_sess_stats_group,
925 			"iscsi_sess_stats", &iscsi_stat_sess_cit);
926 
927 	return se_nacl;
928 }
929 
930 static void lio_target_drop_nodeacl(
931 	struct se_node_acl *se_nacl)
932 {
933 	struct se_portal_group *se_tpg = se_nacl->se_tpg;
934 	struct iscsi_node_acl *acl = container_of(se_nacl,
935 			struct iscsi_node_acl, se_node_acl);
936 	struct config_item *df_item;
937 	struct config_group *stats_cg;
938 	int i;
939 
940 	stats_cg = &acl->se_node_acl.acl_fabric_stat_group;
941 	for (i = 0; stats_cg->default_groups[i]; i++) {
942 		df_item = &stats_cg->default_groups[i]->cg_item;
943 		stats_cg->default_groups[i] = NULL;
944 		config_item_put(df_item);
945 	}
946 	kfree(stats_cg->default_groups);
947 
948 	core_tpg_del_initiator_node_acl(se_tpg, se_nacl, 1);
949 	kfree(acl);
950 }
951 
952 /* End items for lio_target_acl_cit */
953 
954 /* Start items for lio_target_tpg_attrib_cit */
955 
956 #define DEF_TPG_ATTRIB(name)						\
957 									\
958 static ssize_t iscsi_tpg_attrib_show_##name(				\
959 	struct se_portal_group *se_tpg,				\
960 	char *page)							\
961 {									\
962 	struct iscsi_portal_group *tpg = container_of(se_tpg,		\
963 			struct iscsi_portal_group, tpg_se_tpg);	\
964 	ssize_t rb;							\
965 									\
966 	if (iscsit_get_tpg(tpg) < 0)					\
967 		return -EINVAL;						\
968 									\
969 	rb = sprintf(page, "%u\n", tpg->tpg_attrib.name);		\
970 	iscsit_put_tpg(tpg);						\
971 	return rb;							\
972 }									\
973 									\
974 static ssize_t iscsi_tpg_attrib_store_##name(				\
975 	struct se_portal_group *se_tpg,				\
976 	const char *page,						\
977 	size_t count)							\
978 {									\
979 	struct iscsi_portal_group *tpg = container_of(se_tpg,		\
980 			struct iscsi_portal_group, tpg_se_tpg);	\
981 	u32 val;							\
982 	int ret;							\
983 									\
984 	if (iscsit_get_tpg(tpg) < 0)					\
985 		return -EINVAL;						\
986 									\
987 	ret = kstrtou32(page, 0, &val);					\
988 	if (ret)							\
989 		goto out;						\
990 	ret = iscsit_ta_##name(tpg, val);				\
991 	if (ret < 0)							\
992 		goto out;						\
993 									\
994 	iscsit_put_tpg(tpg);						\
995 	return count;							\
996 out:									\
997 	iscsit_put_tpg(tpg);						\
998 	return ret;							\
999 }
1000 
1001 #define TPG_ATTR(_name, _mode) TF_TPG_ATTRIB_ATTR(iscsi, _name, _mode);
1002 
1003 /*
1004  * Define iscsi_tpg_attrib_s_authentication
1005  */
1006 DEF_TPG_ATTRIB(authentication);
1007 TPG_ATTR(authentication, S_IRUGO | S_IWUSR);
1008 /*
1009  * Define iscsi_tpg_attrib_s_login_timeout
1010  */
1011 DEF_TPG_ATTRIB(login_timeout);
1012 TPG_ATTR(login_timeout, S_IRUGO | S_IWUSR);
1013 /*
1014  * Define iscsi_tpg_attrib_s_netif_timeout
1015  */
1016 DEF_TPG_ATTRIB(netif_timeout);
1017 TPG_ATTR(netif_timeout, S_IRUGO | S_IWUSR);
1018 /*
1019  * Define iscsi_tpg_attrib_s_generate_node_acls
1020  */
1021 DEF_TPG_ATTRIB(generate_node_acls);
1022 TPG_ATTR(generate_node_acls, S_IRUGO | S_IWUSR);
1023 /*
1024  * Define iscsi_tpg_attrib_s_default_cmdsn_depth
1025  */
1026 DEF_TPG_ATTRIB(default_cmdsn_depth);
1027 TPG_ATTR(default_cmdsn_depth, S_IRUGO | S_IWUSR);
1028 /*
1029  Define iscsi_tpg_attrib_s_cache_dynamic_acls
1030  */
1031 DEF_TPG_ATTRIB(cache_dynamic_acls);
1032 TPG_ATTR(cache_dynamic_acls, S_IRUGO | S_IWUSR);
1033 /*
1034  * Define iscsi_tpg_attrib_s_demo_mode_write_protect
1035  */
1036 DEF_TPG_ATTRIB(demo_mode_write_protect);
1037 TPG_ATTR(demo_mode_write_protect, S_IRUGO | S_IWUSR);
1038 /*
1039  * Define iscsi_tpg_attrib_s_prod_mode_write_protect
1040  */
1041 DEF_TPG_ATTRIB(prod_mode_write_protect);
1042 TPG_ATTR(prod_mode_write_protect, S_IRUGO | S_IWUSR);
1043 /*
1044  * Define iscsi_tpg_attrib_s_demo_mode_discovery,
1045  */
1046 DEF_TPG_ATTRIB(demo_mode_discovery);
1047 TPG_ATTR(demo_mode_discovery, S_IRUGO | S_IWUSR);
1048 /*
1049  * Define iscsi_tpg_attrib_s_default_erl
1050  */
1051 DEF_TPG_ATTRIB(default_erl);
1052 TPG_ATTR(default_erl, S_IRUGO | S_IWUSR);
1053 /*
1054  * Define iscsi_tpg_attrib_s_t10_pi
1055  */
1056 DEF_TPG_ATTRIB(t10_pi);
1057 TPG_ATTR(t10_pi, S_IRUGO | S_IWUSR);
1058 
1059 static struct configfs_attribute *lio_target_tpg_attrib_attrs[] = {
1060 	&iscsi_tpg_attrib_authentication.attr,
1061 	&iscsi_tpg_attrib_login_timeout.attr,
1062 	&iscsi_tpg_attrib_netif_timeout.attr,
1063 	&iscsi_tpg_attrib_generate_node_acls.attr,
1064 	&iscsi_tpg_attrib_default_cmdsn_depth.attr,
1065 	&iscsi_tpg_attrib_cache_dynamic_acls.attr,
1066 	&iscsi_tpg_attrib_demo_mode_write_protect.attr,
1067 	&iscsi_tpg_attrib_prod_mode_write_protect.attr,
1068 	&iscsi_tpg_attrib_demo_mode_discovery.attr,
1069 	&iscsi_tpg_attrib_default_erl.attr,
1070 	&iscsi_tpg_attrib_t10_pi.attr,
1071 	NULL,
1072 };
1073 
1074 /* End items for lio_target_tpg_attrib_cit */
1075 
1076 /* Start items for lio_target_tpg_auth_cit */
1077 
1078 #define __DEF_TPG_AUTH_STR(prefix, name, flags)					\
1079 static ssize_t __iscsi_##prefix##_show_##name(					\
1080 	struct se_portal_group *se_tpg,						\
1081 	char *page)								\
1082 {										\
1083 	struct iscsi_portal_group *tpg = container_of(se_tpg,			\
1084 				struct iscsi_portal_group, tpg_se_tpg);		\
1085 	struct iscsi_node_auth *auth = &tpg->tpg_demo_auth;			\
1086 										\
1087 	if (!capable(CAP_SYS_ADMIN))						\
1088 		return -EPERM;							\
1089 										\
1090 	return snprintf(page, PAGE_SIZE, "%s\n", auth->name);			\
1091 }										\
1092 										\
1093 static ssize_t __iscsi_##prefix##_store_##name(					\
1094 	struct se_portal_group *se_tpg,						\
1095 	const char *page,							\
1096 	size_t count)								\
1097 {										\
1098 	struct iscsi_portal_group *tpg = container_of(se_tpg,			\
1099 				struct iscsi_portal_group, tpg_se_tpg);		\
1100 	struct iscsi_node_auth *auth = &tpg->tpg_demo_auth;			\
1101 										\
1102 	if (!capable(CAP_SYS_ADMIN))						\
1103 		return -EPERM;							\
1104 										\
1105 	snprintf(auth->name, sizeof(auth->name), "%s", page);			\
1106 	if (!(strncmp("NULL", auth->name, 4)))					\
1107 		auth->naf_flags &= ~flags;					\
1108 	else									\
1109 		auth->naf_flags |= flags;					\
1110 										\
1111 	if ((auth->naf_flags & NAF_USERID_IN_SET) &&				\
1112 	    (auth->naf_flags & NAF_PASSWORD_IN_SET))				\
1113 		auth->authenticate_target = 1;					\
1114 	else									\
1115 		auth->authenticate_target = 0;					\
1116 										\
1117 	return count;								\
1118 }
1119 
1120 #define __DEF_TPG_AUTH_INT(prefix, name)					\
1121 static ssize_t __iscsi_##prefix##_show_##name(					\
1122 	struct se_portal_group *se_tpg,						\
1123 	char *page)								\
1124 {										\
1125 	struct iscsi_portal_group *tpg = container_of(se_tpg,			\
1126 				struct iscsi_portal_group, tpg_se_tpg);		\
1127 	struct iscsi_node_auth *auth = &tpg->tpg_demo_auth;			\
1128 										\
1129 	if (!capable(CAP_SYS_ADMIN))						\
1130 		return -EPERM;							\
1131 										\
1132 	return snprintf(page, PAGE_SIZE, "%d\n", auth->name);			\
1133 }
1134 
1135 #define DEF_TPG_AUTH_STR(name, flags)						\
1136 	__DEF_TPG_AUTH_STR(tpg_auth, name, flags)				\
1137 static ssize_t iscsi_tpg_auth_show_##name(					\
1138 	struct se_portal_group *se_tpg,						\
1139 	char *page)								\
1140 {										\
1141 	return __iscsi_tpg_auth_show_##name(se_tpg, page);			\
1142 }										\
1143 										\
1144 static ssize_t iscsi_tpg_auth_store_##name(					\
1145 	struct se_portal_group *se_tpg,						\
1146 	const char *page,							\
1147 	size_t count)								\
1148 {										\
1149 	return __iscsi_tpg_auth_store_##name(se_tpg, page, count);		\
1150 }
1151 
1152 #define DEF_TPG_AUTH_INT(name)							\
1153 	__DEF_TPG_AUTH_INT(tpg_auth, name)					\
1154 static ssize_t iscsi_tpg_auth_show_##name(					\
1155 	struct se_portal_group *se_tpg,						\
1156 	char *page)								\
1157 {										\
1158 	return __iscsi_tpg_auth_show_##name(se_tpg, page);			\
1159 }
1160 
1161 #define TPG_AUTH_ATTR(_name, _mode) TF_TPG_AUTH_ATTR(iscsi, _name, _mode);
1162 #define TPG_AUTH_ATTR_RO(_name) TF_TPG_AUTH_ATTR_RO(iscsi, _name);
1163 
1164 /*
1165  *  * One-way authentication userid
1166  *   */
1167 DEF_TPG_AUTH_STR(userid, NAF_USERID_SET);
1168 TPG_AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
1169 /*
1170  *  * One-way authentication password
1171  *   */
1172 DEF_TPG_AUTH_STR(password, NAF_PASSWORD_SET);
1173 TPG_AUTH_ATTR(password, S_IRUGO | S_IWUSR);
1174 /*
1175  *  * Enforce mutual authentication
1176  *   */
1177 DEF_TPG_AUTH_INT(authenticate_target);
1178 TPG_AUTH_ATTR_RO(authenticate_target);
1179 /*
1180  *  * Mutual authentication userid
1181  *   */
1182 DEF_TPG_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
1183 TPG_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
1184 /*
1185  *  * Mutual authentication password
1186  *   */
1187 DEF_TPG_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
1188 TPG_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
1189 
1190 static struct configfs_attribute *lio_target_tpg_auth_attrs[] = {
1191 	&iscsi_tpg_auth_userid.attr,
1192 	&iscsi_tpg_auth_password.attr,
1193 	&iscsi_tpg_auth_authenticate_target.attr,
1194 	&iscsi_tpg_auth_userid_mutual.attr,
1195 	&iscsi_tpg_auth_password_mutual.attr,
1196 	NULL,
1197 };
1198 
1199 /* End items for lio_target_tpg_auth_cit */
1200 
1201 /* Start items for lio_target_tpg_param_cit */
1202 
1203 #define DEF_TPG_PARAM(name)						\
1204 static ssize_t iscsi_tpg_param_show_##name(				\
1205 	struct se_portal_group *se_tpg,					\
1206 	char *page)							\
1207 {									\
1208 	struct iscsi_portal_group *tpg = container_of(se_tpg,		\
1209 			struct iscsi_portal_group, tpg_se_tpg);		\
1210 	struct iscsi_param *param;					\
1211 	ssize_t rb;							\
1212 									\
1213 	if (iscsit_get_tpg(tpg) < 0)					\
1214 		return -EINVAL;						\
1215 									\
1216 	param = iscsi_find_param_from_key(__stringify(name),		\
1217 				tpg->param_list);			\
1218 	if (!param) {							\
1219 		iscsit_put_tpg(tpg);					\
1220 		return -EINVAL;						\
1221 	}								\
1222 	rb = snprintf(page, PAGE_SIZE, "%s\n", param->value);		\
1223 									\
1224 	iscsit_put_tpg(tpg);						\
1225 	return rb;							\
1226 }									\
1227 static ssize_t iscsi_tpg_param_store_##name(				\
1228 	struct se_portal_group *se_tpg,				\
1229 	const char *page,						\
1230 	size_t count)							\
1231 {									\
1232 	struct iscsi_portal_group *tpg = container_of(se_tpg,		\
1233 			struct iscsi_portal_group, tpg_se_tpg);		\
1234 	char *buf;							\
1235 	int ret, len;							\
1236 									\
1237 	buf = kzalloc(PAGE_SIZE, GFP_KERNEL);				\
1238 	if (!buf)							\
1239 		return -ENOMEM;						\
1240 	len = snprintf(buf, PAGE_SIZE, "%s=%s", __stringify(name), page);	\
1241 	if (isspace(buf[len-1]))					\
1242 		buf[len-1] = '\0'; /* Kill newline */			\
1243 									\
1244 	if (iscsit_get_tpg(tpg) < 0) {					\
1245 		kfree(buf);						\
1246 		return -EINVAL;						\
1247 	}								\
1248 									\
1249 	ret = iscsi_change_param_value(buf, tpg->param_list, 1);	\
1250 	if (ret < 0)							\
1251 		goto out;						\
1252 									\
1253 	kfree(buf);							\
1254 	iscsit_put_tpg(tpg);						\
1255 	return count;							\
1256 out:									\
1257 	kfree(buf);							\
1258 	iscsit_put_tpg(tpg);						\
1259 	return -EINVAL;						\
1260 }
1261 
1262 #define TPG_PARAM_ATTR(_name, _mode) TF_TPG_PARAM_ATTR(iscsi, _name, _mode);
1263 
1264 DEF_TPG_PARAM(AuthMethod);
1265 TPG_PARAM_ATTR(AuthMethod, S_IRUGO | S_IWUSR);
1266 
1267 DEF_TPG_PARAM(HeaderDigest);
1268 TPG_PARAM_ATTR(HeaderDigest, S_IRUGO | S_IWUSR);
1269 
1270 DEF_TPG_PARAM(DataDigest);
1271 TPG_PARAM_ATTR(DataDigest, S_IRUGO | S_IWUSR);
1272 
1273 DEF_TPG_PARAM(MaxConnections);
1274 TPG_PARAM_ATTR(MaxConnections, S_IRUGO | S_IWUSR);
1275 
1276 DEF_TPG_PARAM(TargetAlias);
1277 TPG_PARAM_ATTR(TargetAlias, S_IRUGO | S_IWUSR);
1278 
1279 DEF_TPG_PARAM(InitialR2T);
1280 TPG_PARAM_ATTR(InitialR2T, S_IRUGO | S_IWUSR);
1281 
1282 DEF_TPG_PARAM(ImmediateData);
1283 TPG_PARAM_ATTR(ImmediateData, S_IRUGO | S_IWUSR);
1284 
1285 DEF_TPG_PARAM(MaxRecvDataSegmentLength);
1286 TPG_PARAM_ATTR(MaxRecvDataSegmentLength, S_IRUGO | S_IWUSR);
1287 
1288 DEF_TPG_PARAM(MaxXmitDataSegmentLength);
1289 TPG_PARAM_ATTR(MaxXmitDataSegmentLength, S_IRUGO | S_IWUSR);
1290 
1291 DEF_TPG_PARAM(MaxBurstLength);
1292 TPG_PARAM_ATTR(MaxBurstLength, S_IRUGO | S_IWUSR);
1293 
1294 DEF_TPG_PARAM(FirstBurstLength);
1295 TPG_PARAM_ATTR(FirstBurstLength, S_IRUGO | S_IWUSR);
1296 
1297 DEF_TPG_PARAM(DefaultTime2Wait);
1298 TPG_PARAM_ATTR(DefaultTime2Wait, S_IRUGO | S_IWUSR);
1299 
1300 DEF_TPG_PARAM(DefaultTime2Retain);
1301 TPG_PARAM_ATTR(DefaultTime2Retain, S_IRUGO | S_IWUSR);
1302 
1303 DEF_TPG_PARAM(MaxOutstandingR2T);
1304 TPG_PARAM_ATTR(MaxOutstandingR2T, S_IRUGO | S_IWUSR);
1305 
1306 DEF_TPG_PARAM(DataPDUInOrder);
1307 TPG_PARAM_ATTR(DataPDUInOrder, S_IRUGO | S_IWUSR);
1308 
1309 DEF_TPG_PARAM(DataSequenceInOrder);
1310 TPG_PARAM_ATTR(DataSequenceInOrder, S_IRUGO | S_IWUSR);
1311 
1312 DEF_TPG_PARAM(ErrorRecoveryLevel);
1313 TPG_PARAM_ATTR(ErrorRecoveryLevel, S_IRUGO | S_IWUSR);
1314 
1315 DEF_TPG_PARAM(IFMarker);
1316 TPG_PARAM_ATTR(IFMarker, S_IRUGO | S_IWUSR);
1317 
1318 DEF_TPG_PARAM(OFMarker);
1319 TPG_PARAM_ATTR(OFMarker, S_IRUGO | S_IWUSR);
1320 
1321 DEF_TPG_PARAM(IFMarkInt);
1322 TPG_PARAM_ATTR(IFMarkInt, S_IRUGO | S_IWUSR);
1323 
1324 DEF_TPG_PARAM(OFMarkInt);
1325 TPG_PARAM_ATTR(OFMarkInt, S_IRUGO | S_IWUSR);
1326 
1327 static struct configfs_attribute *lio_target_tpg_param_attrs[] = {
1328 	&iscsi_tpg_param_AuthMethod.attr,
1329 	&iscsi_tpg_param_HeaderDigest.attr,
1330 	&iscsi_tpg_param_DataDigest.attr,
1331 	&iscsi_tpg_param_MaxConnections.attr,
1332 	&iscsi_tpg_param_TargetAlias.attr,
1333 	&iscsi_tpg_param_InitialR2T.attr,
1334 	&iscsi_tpg_param_ImmediateData.attr,
1335 	&iscsi_tpg_param_MaxRecvDataSegmentLength.attr,
1336 	&iscsi_tpg_param_MaxXmitDataSegmentLength.attr,
1337 	&iscsi_tpg_param_MaxBurstLength.attr,
1338 	&iscsi_tpg_param_FirstBurstLength.attr,
1339 	&iscsi_tpg_param_DefaultTime2Wait.attr,
1340 	&iscsi_tpg_param_DefaultTime2Retain.attr,
1341 	&iscsi_tpg_param_MaxOutstandingR2T.attr,
1342 	&iscsi_tpg_param_DataPDUInOrder.attr,
1343 	&iscsi_tpg_param_DataSequenceInOrder.attr,
1344 	&iscsi_tpg_param_ErrorRecoveryLevel.attr,
1345 	&iscsi_tpg_param_IFMarker.attr,
1346 	&iscsi_tpg_param_OFMarker.attr,
1347 	&iscsi_tpg_param_IFMarkInt.attr,
1348 	&iscsi_tpg_param_OFMarkInt.attr,
1349 	NULL,
1350 };
1351 
1352 /* End items for lio_target_tpg_param_cit */
1353 
1354 /* Start items for lio_target_tpg_cit */
1355 
1356 static ssize_t lio_target_tpg_show_enable(
1357 	struct se_portal_group *se_tpg,
1358 	char *page)
1359 {
1360 	struct iscsi_portal_group *tpg = container_of(se_tpg,
1361 			struct iscsi_portal_group, tpg_se_tpg);
1362 	ssize_t len;
1363 
1364 	spin_lock(&tpg->tpg_state_lock);
1365 	len = sprintf(page, "%d\n",
1366 			(tpg->tpg_state == TPG_STATE_ACTIVE) ? 1 : 0);
1367 	spin_unlock(&tpg->tpg_state_lock);
1368 
1369 	return len;
1370 }
1371 
1372 static ssize_t lio_target_tpg_store_enable(
1373 	struct se_portal_group *se_tpg,
1374 	const char *page,
1375 	size_t count)
1376 {
1377 	struct iscsi_portal_group *tpg = container_of(se_tpg,
1378 			struct iscsi_portal_group, tpg_se_tpg);
1379 	u32 op;
1380 	int ret;
1381 
1382 	ret = kstrtou32(page, 0, &op);
1383 	if (ret)
1384 		return ret;
1385 	if ((op != 1) && (op != 0)) {
1386 		pr_err("Illegal value for tpg_enable: %u\n", op);
1387 		return -EINVAL;
1388 	}
1389 
1390 	ret = iscsit_get_tpg(tpg);
1391 	if (ret < 0)
1392 		return -EINVAL;
1393 
1394 	if (op) {
1395 		ret = iscsit_tpg_enable_portal_group(tpg);
1396 		if (ret < 0)
1397 			goto out;
1398 	} else {
1399 		/*
1400 		 * iscsit_tpg_disable_portal_group() assumes force=1
1401 		 */
1402 		ret = iscsit_tpg_disable_portal_group(tpg, 1);
1403 		if (ret < 0)
1404 			goto out;
1405 	}
1406 
1407 	iscsit_put_tpg(tpg);
1408 	return count;
1409 out:
1410 	iscsit_put_tpg(tpg);
1411 	return -EINVAL;
1412 }
1413 
1414 TF_TPG_BASE_ATTR(lio_target, enable, S_IRUGO | S_IWUSR);
1415 
1416 static struct configfs_attribute *lio_target_tpg_attrs[] = {
1417 	&lio_target_tpg_enable.attr,
1418 	NULL,
1419 };
1420 
1421 /* End items for lio_target_tpg_cit */
1422 
1423 /* Start items for lio_target_tiqn_cit */
1424 
1425 static struct se_portal_group *lio_target_tiqn_addtpg(
1426 	struct se_wwn *wwn,
1427 	struct config_group *group,
1428 	const char *name)
1429 {
1430 	struct iscsi_portal_group *tpg;
1431 	struct iscsi_tiqn *tiqn;
1432 	char *tpgt_str;
1433 	int ret;
1434 	u16 tpgt;
1435 
1436 	tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
1437 	/*
1438 	 * Only tpgt_# directory groups can be created below
1439 	 * target/iscsi/iqn.superturodiskarry/
1440 	 */
1441 	tpgt_str = strstr(name, "tpgt_");
1442 	if (!tpgt_str) {
1443 		pr_err("Unable to locate \"tpgt_#\" directory"
1444 				" group\n");
1445 		return NULL;
1446 	}
1447 	tpgt_str += 5; /* Skip ahead of "tpgt_" */
1448 	ret = kstrtou16(tpgt_str, 0, &tpgt);
1449 	if (ret)
1450 		return NULL;
1451 
1452 	tpg = iscsit_alloc_portal_group(tiqn, tpgt);
1453 	if (!tpg)
1454 		return NULL;
1455 
1456 	ret = core_tpg_register(
1457 			&lio_target_fabric_configfs->tf_ops,
1458 			wwn, &tpg->tpg_se_tpg, tpg,
1459 			TRANSPORT_TPG_TYPE_NORMAL);
1460 	if (ret < 0)
1461 		return NULL;
1462 
1463 	ret = iscsit_tpg_add_portal_group(tiqn, tpg);
1464 	if (ret != 0)
1465 		goto out;
1466 
1467 	pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
1468 	pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated TPG: %s\n",
1469 			name);
1470 	return &tpg->tpg_se_tpg;
1471 out:
1472 	core_tpg_deregister(&tpg->tpg_se_tpg);
1473 	kfree(tpg);
1474 	return NULL;
1475 }
1476 
1477 static void lio_target_tiqn_deltpg(struct se_portal_group *se_tpg)
1478 {
1479 	struct iscsi_portal_group *tpg;
1480 	struct iscsi_tiqn *tiqn;
1481 
1482 	tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
1483 	tiqn = tpg->tpg_tiqn;
1484 	/*
1485 	 * iscsit_tpg_del_portal_group() assumes force=1
1486 	 */
1487 	pr_debug("LIO_Target_ConfigFS: DEREGISTER -> Releasing TPG\n");
1488 	iscsit_tpg_del_portal_group(tiqn, tpg, 1);
1489 }
1490 
1491 /* End items for lio_target_tiqn_cit */
1492 
1493 /* Start LIO-Target TIQN struct contig_item lio_target_cit */
1494 
1495 static ssize_t lio_target_wwn_show_attr_lio_version(
1496 	struct target_fabric_configfs *tf,
1497 	char *page)
1498 {
1499 	return sprintf(page, "Datera Inc. iSCSI Target "ISCSIT_VERSION"\n");
1500 }
1501 
1502 TF_WWN_ATTR_RO(lio_target, lio_version);
1503 
1504 static struct configfs_attribute *lio_target_wwn_attrs[] = {
1505 	&lio_target_wwn_lio_version.attr,
1506 	NULL,
1507 };
1508 
1509 static struct se_wwn *lio_target_call_coreaddtiqn(
1510 	struct target_fabric_configfs *tf,
1511 	struct config_group *group,
1512 	const char *name)
1513 {
1514 	struct config_group *stats_cg;
1515 	struct iscsi_tiqn *tiqn;
1516 
1517 	tiqn = iscsit_add_tiqn((unsigned char *)name);
1518 	if (IS_ERR(tiqn))
1519 		return ERR_CAST(tiqn);
1520 	/*
1521 	 * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group.
1522 	 */
1523 	stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;
1524 
1525 	stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 6,
1526 				GFP_KERNEL);
1527 	if (!stats_cg->default_groups) {
1528 		pr_err("Unable to allocate memory for"
1529 				" stats_cg->default_groups\n");
1530 		iscsit_del_tiqn(tiqn);
1531 		return ERR_PTR(-ENOMEM);
1532 	}
1533 
1534 	stats_cg->default_groups[0] = &tiqn->tiqn_stat_grps.iscsi_instance_group;
1535 	stats_cg->default_groups[1] = &tiqn->tiqn_stat_grps.iscsi_sess_err_group;
1536 	stats_cg->default_groups[2] = &tiqn->tiqn_stat_grps.iscsi_tgt_attr_group;
1537 	stats_cg->default_groups[3] = &tiqn->tiqn_stat_grps.iscsi_login_stats_group;
1538 	stats_cg->default_groups[4] = &tiqn->tiqn_stat_grps.iscsi_logout_stats_group;
1539 	stats_cg->default_groups[5] = NULL;
1540 	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_instance_group,
1541 			"iscsi_instance", &iscsi_stat_instance_cit);
1542 	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_sess_err_group,
1543 			"iscsi_sess_err", &iscsi_stat_sess_err_cit);
1544 	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_tgt_attr_group,
1545 			"iscsi_tgt_attr", &iscsi_stat_tgt_attr_cit);
1546 	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_login_stats_group,
1547 			"iscsi_login_stats", &iscsi_stat_login_cit);
1548 	config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_logout_stats_group,
1549 			"iscsi_logout_stats", &iscsi_stat_logout_cit);
1550 
1551 	pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
1552 	pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
1553 			" %s\n", name);
1554 	return &tiqn->tiqn_wwn;
1555 }
1556 
1557 static void lio_target_call_coredeltiqn(
1558 	struct se_wwn *wwn)
1559 {
1560 	struct iscsi_tiqn *tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
1561 	struct config_item *df_item;
1562 	struct config_group *stats_cg;
1563 	int i;
1564 
1565 	stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;
1566 	for (i = 0; stats_cg->default_groups[i]; i++) {
1567 		df_item = &stats_cg->default_groups[i]->cg_item;
1568 		stats_cg->default_groups[i] = NULL;
1569 		config_item_put(df_item);
1570 	}
1571 	kfree(stats_cg->default_groups);
1572 
1573 	pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s\n",
1574 			tiqn->tiqn);
1575 	iscsit_del_tiqn(tiqn);
1576 }
1577 
1578 /* End LIO-Target TIQN struct contig_lio_target_cit */
1579 
1580 /* Start lio_target_discovery_auth_cit */
1581 
1582 #define DEF_DISC_AUTH_STR(name, flags)					\
1583 	__DEF_NACL_AUTH_STR(disc, name, flags)				\
1584 static ssize_t iscsi_disc_show_##name(					\
1585 	struct target_fabric_configfs *tf,				\
1586 	char *page)							\
1587 {									\
1588 	return __iscsi_disc_show_##name(&iscsit_global->discovery_acl,	\
1589 		page);							\
1590 }									\
1591 static ssize_t iscsi_disc_store_##name(					\
1592 	struct target_fabric_configfs *tf,				\
1593 	const char *page,						\
1594 	size_t count)							\
1595 {									\
1596 	return __iscsi_disc_store_##name(&iscsit_global->discovery_acl,	\
1597 		page, count);						\
1598 }
1599 
1600 #define DEF_DISC_AUTH_INT(name)						\
1601 	__DEF_NACL_AUTH_INT(disc, name)					\
1602 static ssize_t iscsi_disc_show_##name(					\
1603 	struct target_fabric_configfs *tf,				\
1604 	char *page)							\
1605 {									\
1606 	return __iscsi_disc_show_##name(&iscsit_global->discovery_acl,	\
1607 			page);						\
1608 }
1609 
1610 #define DISC_AUTH_ATTR(_name, _mode) TF_DISC_ATTR(iscsi, _name, _mode)
1611 #define DISC_AUTH_ATTR_RO(_name) TF_DISC_ATTR_RO(iscsi, _name)
1612 
1613 /*
1614  * One-way authentication userid
1615  */
1616 DEF_DISC_AUTH_STR(userid, NAF_USERID_SET);
1617 DISC_AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
1618 /*
1619  * One-way authentication password
1620  */
1621 DEF_DISC_AUTH_STR(password, NAF_PASSWORD_SET);
1622 DISC_AUTH_ATTR(password, S_IRUGO | S_IWUSR);
1623 /*
1624  * Enforce mutual authentication
1625  */
1626 DEF_DISC_AUTH_INT(authenticate_target);
1627 DISC_AUTH_ATTR_RO(authenticate_target);
1628 /*
1629  * Mutual authentication userid
1630  */
1631 DEF_DISC_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
1632 DISC_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
1633 /*
1634  * Mutual authentication password
1635  */
1636 DEF_DISC_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
1637 DISC_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
1638 
1639 /*
1640  * enforce_discovery_auth
1641  */
1642 static ssize_t iscsi_disc_show_enforce_discovery_auth(
1643 	struct target_fabric_configfs *tf,
1644 	char *page)
1645 {
1646 	struct iscsi_node_auth *discovery_auth = &iscsit_global->discovery_acl.node_auth;
1647 
1648 	return sprintf(page, "%d\n", discovery_auth->enforce_discovery_auth);
1649 }
1650 
1651 static ssize_t iscsi_disc_store_enforce_discovery_auth(
1652 	struct target_fabric_configfs *tf,
1653 	const char *page,
1654 	size_t count)
1655 {
1656 	struct iscsi_param *param;
1657 	struct iscsi_portal_group *discovery_tpg = iscsit_global->discovery_tpg;
1658 	u32 op;
1659 	int err;
1660 
1661 	err = kstrtou32(page, 0, &op);
1662 	if (err)
1663 		return -EINVAL;
1664 	if ((op != 1) && (op != 0)) {
1665 		pr_err("Illegal value for enforce_discovery_auth:"
1666 				" %u\n", op);
1667 		return -EINVAL;
1668 	}
1669 
1670 	if (!discovery_tpg) {
1671 		pr_err("iscsit_global->discovery_tpg is NULL\n");
1672 		return -EINVAL;
1673 	}
1674 
1675 	param = iscsi_find_param_from_key(AUTHMETHOD,
1676 				discovery_tpg->param_list);
1677 	if (!param)
1678 		return -EINVAL;
1679 
1680 	if (op) {
1681 		/*
1682 		 * Reset the AuthMethod key to CHAP.
1683 		 */
1684 		if (iscsi_update_param_value(param, CHAP) < 0)
1685 			return -EINVAL;
1686 
1687 		discovery_tpg->tpg_attrib.authentication = 1;
1688 		iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 1;
1689 		pr_debug("LIO-CORE[0] Successfully enabled"
1690 			" authentication enforcement for iSCSI"
1691 			" Discovery TPG\n");
1692 	} else {
1693 		/*
1694 		 * Reset the AuthMethod key to CHAP,None
1695 		 */
1696 		if (iscsi_update_param_value(param, "CHAP,None") < 0)
1697 			return -EINVAL;
1698 
1699 		discovery_tpg->tpg_attrib.authentication = 0;
1700 		iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 0;
1701 		pr_debug("LIO-CORE[0] Successfully disabled"
1702 			" authentication enforcement for iSCSI"
1703 			" Discovery TPG\n");
1704 	}
1705 
1706 	return count;
1707 }
1708 
1709 DISC_AUTH_ATTR(enforce_discovery_auth, S_IRUGO | S_IWUSR);
1710 
1711 static struct configfs_attribute *lio_target_discovery_auth_attrs[] = {
1712 	&iscsi_disc_userid.attr,
1713 	&iscsi_disc_password.attr,
1714 	&iscsi_disc_authenticate_target.attr,
1715 	&iscsi_disc_userid_mutual.attr,
1716 	&iscsi_disc_password_mutual.attr,
1717 	&iscsi_disc_enforce_discovery_auth.attr,
1718 	NULL,
1719 };
1720 
1721 /* End lio_target_discovery_auth_cit */
1722 
1723 /* Start functions for target_core_fabric_ops */
1724 
1725 static char *iscsi_get_fabric_name(void)
1726 {
1727 	return "iSCSI";
1728 }
1729 
1730 static u32 iscsi_get_task_tag(struct se_cmd *se_cmd)
1731 {
1732 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1733 
1734 	/* only used for printks or comparism with ->ref_task_tag */
1735 	return (__force u32)cmd->init_task_tag;
1736 }
1737 
1738 static int iscsi_get_cmd_state(struct se_cmd *se_cmd)
1739 {
1740 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1741 
1742 	return cmd->i_state;
1743 }
1744 
1745 static u32 lio_sess_get_index(struct se_session *se_sess)
1746 {
1747 	struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1748 
1749 	return sess->session_index;
1750 }
1751 
1752 static u32 lio_sess_get_initiator_sid(
1753 	struct se_session *se_sess,
1754 	unsigned char *buf,
1755 	u32 size)
1756 {
1757 	struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1758 	/*
1759 	 * iSCSI Initiator Session Identifier from RFC-3720.
1760 	 */
1761 	return snprintf(buf, size, "%02x%02x%02x%02x%02x%02x",
1762 		sess->isid[0], sess->isid[1], sess->isid[2],
1763 		sess->isid[3], sess->isid[4], sess->isid[5]);
1764 }
1765 
1766 static int lio_queue_data_in(struct se_cmd *se_cmd)
1767 {
1768 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1769 
1770 	cmd->i_state = ISTATE_SEND_DATAIN;
1771 	cmd->conn->conn_transport->iscsit_queue_data_in(cmd->conn, cmd);
1772 
1773 	return 0;
1774 }
1775 
1776 static int lio_write_pending(struct se_cmd *se_cmd)
1777 {
1778 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1779 	struct iscsi_conn *conn = cmd->conn;
1780 
1781 	if (!cmd->immediate_data && !cmd->unsolicited_data)
1782 		return conn->conn_transport->iscsit_get_dataout(conn, cmd, false);
1783 
1784 	return 0;
1785 }
1786 
1787 static int lio_write_pending_status(struct se_cmd *se_cmd)
1788 {
1789 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1790 	int ret;
1791 
1792 	spin_lock_bh(&cmd->istate_lock);
1793 	ret = !(cmd->cmd_flags & ICF_GOT_LAST_DATAOUT);
1794 	spin_unlock_bh(&cmd->istate_lock);
1795 
1796 	return ret;
1797 }
1798 
1799 static int lio_queue_status(struct se_cmd *se_cmd)
1800 {
1801 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1802 
1803 	cmd->i_state = ISTATE_SEND_STATUS;
1804 
1805 	if (cmd->se_cmd.scsi_status || cmd->sense_reason) {
1806 		iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
1807 		return 0;
1808 	}
1809 	cmd->conn->conn_transport->iscsit_queue_status(cmd->conn, cmd);
1810 
1811 	return 0;
1812 }
1813 
1814 static void lio_queue_tm_rsp(struct se_cmd *se_cmd)
1815 {
1816 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1817 
1818 	cmd->i_state = ISTATE_SEND_TASKMGTRSP;
1819 	iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
1820 }
1821 
1822 static void lio_aborted_task(struct se_cmd *se_cmd)
1823 {
1824 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1825 
1826 	cmd->conn->conn_transport->iscsit_aborted_task(cmd->conn, cmd);
1827 }
1828 
1829 static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg)
1830 {
1831 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1832 
1833 	return &tpg->tpg_tiqn->tiqn[0];
1834 }
1835 
1836 static u16 lio_tpg_get_tag(struct se_portal_group *se_tpg)
1837 {
1838 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1839 
1840 	return tpg->tpgt;
1841 }
1842 
1843 static u32 lio_tpg_get_default_depth(struct se_portal_group *se_tpg)
1844 {
1845 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1846 
1847 	return tpg->tpg_attrib.default_cmdsn_depth;
1848 }
1849 
1850 static int lio_tpg_check_demo_mode(struct se_portal_group *se_tpg)
1851 {
1852 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1853 
1854 	return tpg->tpg_attrib.generate_node_acls;
1855 }
1856 
1857 static int lio_tpg_check_demo_mode_cache(struct se_portal_group *se_tpg)
1858 {
1859 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1860 
1861 	return tpg->tpg_attrib.cache_dynamic_acls;
1862 }
1863 
1864 static int lio_tpg_check_demo_mode_write_protect(
1865 	struct se_portal_group *se_tpg)
1866 {
1867 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1868 
1869 	return tpg->tpg_attrib.demo_mode_write_protect;
1870 }
1871 
1872 static int lio_tpg_check_prod_mode_write_protect(
1873 	struct se_portal_group *se_tpg)
1874 {
1875 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1876 
1877 	return tpg->tpg_attrib.prod_mode_write_protect;
1878 }
1879 
1880 static void lio_tpg_release_fabric_acl(
1881 	struct se_portal_group *se_tpg,
1882 	struct se_node_acl *se_acl)
1883 {
1884 	struct iscsi_node_acl *acl = container_of(se_acl,
1885 				struct iscsi_node_acl, se_node_acl);
1886 	kfree(acl);
1887 }
1888 
1889 /*
1890  * Called with spin_lock_bh(struct se_portal_group->session_lock) held..
1891  *
1892  * Also, this function calls iscsit_inc_session_usage_count() on the
1893  * struct iscsi_session in question.
1894  */
1895 static int lio_tpg_shutdown_session(struct se_session *se_sess)
1896 {
1897 	struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1898 
1899 	spin_lock(&sess->conn_lock);
1900 	if (atomic_read(&sess->session_fall_back_to_erl0) ||
1901 	    atomic_read(&sess->session_logout) ||
1902 	    (sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)) {
1903 		spin_unlock(&sess->conn_lock);
1904 		return 0;
1905 	}
1906 	atomic_set(&sess->session_reinstatement, 1);
1907 	spin_unlock(&sess->conn_lock);
1908 
1909 	iscsit_stop_time2retain_timer(sess);
1910 	iscsit_stop_session(sess, 1, 1);
1911 
1912 	return 1;
1913 }
1914 
1915 /*
1916  * Calls iscsit_dec_session_usage_count() as inverse of
1917  * lio_tpg_shutdown_session()
1918  */
1919 static void lio_tpg_close_session(struct se_session *se_sess)
1920 {
1921 	struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1922 	/*
1923 	 * If the iSCSI Session for the iSCSI Initiator Node exists,
1924 	 * forcefully shutdown the iSCSI NEXUS.
1925 	 */
1926 	iscsit_close_session(sess);
1927 }
1928 
1929 static u32 lio_tpg_get_inst_index(struct se_portal_group *se_tpg)
1930 {
1931 	struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
1932 
1933 	return tpg->tpg_tiqn->tiqn_index;
1934 }
1935 
1936 static void lio_set_default_node_attributes(struct se_node_acl *se_acl)
1937 {
1938 	struct iscsi_node_acl *acl = container_of(se_acl, struct iscsi_node_acl,
1939 				se_node_acl);
1940 	struct se_portal_group *se_tpg = se_acl->se_tpg;
1941 	struct iscsi_portal_group *tpg = container_of(se_tpg,
1942 				struct iscsi_portal_group, tpg_se_tpg);
1943 
1944 	acl->node_attrib.nacl = acl;
1945 	iscsit_set_default_node_attribues(acl, tpg);
1946 }
1947 
1948 static int lio_check_stop_free(struct se_cmd *se_cmd)
1949 {
1950 	return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
1951 }
1952 
1953 static void lio_release_cmd(struct se_cmd *se_cmd)
1954 {
1955 	struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1956 
1957 	pr_debug("Entering lio_release_cmd for se_cmd: %p\n", se_cmd);
1958 	iscsit_release_cmd(cmd);
1959 }
1960 
1961 /* End functions for target_core_fabric_ops */
1962 
1963 int iscsi_target_register_configfs(void)
1964 {
1965 	struct target_fabric_configfs *fabric;
1966 	int ret;
1967 
1968 	lio_target_fabric_configfs = NULL;
1969 	fabric = target_fabric_configfs_init(THIS_MODULE, "iscsi");
1970 	if (IS_ERR(fabric)) {
1971 		pr_err("target_fabric_configfs_init() for"
1972 				" LIO-Target failed!\n");
1973 		return PTR_ERR(fabric);
1974 	}
1975 	/*
1976 	 * Setup the fabric API of function pointers used by target_core_mod..
1977 	 */
1978 	fabric->tf_ops.get_fabric_name = &iscsi_get_fabric_name;
1979 	fabric->tf_ops.get_fabric_proto_ident = &iscsi_get_fabric_proto_ident;
1980 	fabric->tf_ops.tpg_get_wwn = &lio_tpg_get_endpoint_wwn;
1981 	fabric->tf_ops.tpg_get_tag = &lio_tpg_get_tag;
1982 	fabric->tf_ops.tpg_get_default_depth = &lio_tpg_get_default_depth;
1983 	fabric->tf_ops.tpg_get_pr_transport_id = &iscsi_get_pr_transport_id;
1984 	fabric->tf_ops.tpg_get_pr_transport_id_len =
1985 				&iscsi_get_pr_transport_id_len;
1986 	fabric->tf_ops.tpg_parse_pr_out_transport_id =
1987 				&iscsi_parse_pr_out_transport_id;
1988 	fabric->tf_ops.tpg_check_demo_mode = &lio_tpg_check_demo_mode;
1989 	fabric->tf_ops.tpg_check_demo_mode_cache =
1990 				&lio_tpg_check_demo_mode_cache;
1991 	fabric->tf_ops.tpg_check_demo_mode_write_protect =
1992 				&lio_tpg_check_demo_mode_write_protect;
1993 	fabric->tf_ops.tpg_check_prod_mode_write_protect =
1994 				&lio_tpg_check_prod_mode_write_protect;
1995 	fabric->tf_ops.tpg_alloc_fabric_acl = &lio_tpg_alloc_fabric_acl;
1996 	fabric->tf_ops.tpg_release_fabric_acl = &lio_tpg_release_fabric_acl;
1997 	fabric->tf_ops.tpg_get_inst_index = &lio_tpg_get_inst_index;
1998 	fabric->tf_ops.check_stop_free = &lio_check_stop_free,
1999 	fabric->tf_ops.release_cmd = &lio_release_cmd;
2000 	fabric->tf_ops.shutdown_session = &lio_tpg_shutdown_session;
2001 	fabric->tf_ops.close_session = &lio_tpg_close_session;
2002 	fabric->tf_ops.sess_get_index = &lio_sess_get_index;
2003 	fabric->tf_ops.sess_get_initiator_sid = &lio_sess_get_initiator_sid;
2004 	fabric->tf_ops.write_pending = &lio_write_pending;
2005 	fabric->tf_ops.write_pending_status = &lio_write_pending_status;
2006 	fabric->tf_ops.set_default_node_attributes =
2007 				&lio_set_default_node_attributes;
2008 	fabric->tf_ops.get_task_tag = &iscsi_get_task_tag;
2009 	fabric->tf_ops.get_cmd_state = &iscsi_get_cmd_state;
2010 	fabric->tf_ops.queue_data_in = &lio_queue_data_in;
2011 	fabric->tf_ops.queue_status = &lio_queue_status;
2012 	fabric->tf_ops.queue_tm_rsp = &lio_queue_tm_rsp;
2013 	fabric->tf_ops.aborted_task = &lio_aborted_task;
2014 	/*
2015 	 * Setup function pointers for generic logic in target_core_fabric_configfs.c
2016 	 */
2017 	fabric->tf_ops.fabric_make_wwn = &lio_target_call_coreaddtiqn;
2018 	fabric->tf_ops.fabric_drop_wwn = &lio_target_call_coredeltiqn;
2019 	fabric->tf_ops.fabric_make_tpg = &lio_target_tiqn_addtpg;
2020 	fabric->tf_ops.fabric_drop_tpg = &lio_target_tiqn_deltpg;
2021 	fabric->tf_ops.fabric_post_link	= NULL;
2022 	fabric->tf_ops.fabric_pre_unlink = NULL;
2023 	fabric->tf_ops.fabric_make_np = &lio_target_call_addnptotpg;
2024 	fabric->tf_ops.fabric_drop_np = &lio_target_call_delnpfromtpg;
2025 	fabric->tf_ops.fabric_make_nodeacl = &lio_target_make_nodeacl;
2026 	fabric->tf_ops.fabric_drop_nodeacl = &lio_target_drop_nodeacl;
2027 	/*
2028 	 * Setup default attribute lists for various fabric->tf_cit_tmpl
2029 	 * sturct config_item_type's
2030 	 */
2031 	fabric->tf_cit_tmpl.tfc_discovery_cit.ct_attrs = lio_target_discovery_auth_attrs;
2032 	fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = lio_target_wwn_attrs;
2033 	fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = lio_target_tpg_attrs;
2034 	fabric->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = lio_target_tpg_attrib_attrs;
2035 	fabric->tf_cit_tmpl.tfc_tpg_auth_cit.ct_attrs = lio_target_tpg_auth_attrs;
2036 	fabric->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = lio_target_tpg_param_attrs;
2037 	fabric->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = lio_target_portal_attrs;
2038 	fabric->tf_cit_tmpl.tfc_tpg_nacl_base_cit.ct_attrs = lio_target_initiator_attrs;
2039 	fabric->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit.ct_attrs = lio_target_nacl_attrib_attrs;
2040 	fabric->tf_cit_tmpl.tfc_tpg_nacl_auth_cit.ct_attrs = lio_target_nacl_auth_attrs;
2041 	fabric->tf_cit_tmpl.tfc_tpg_nacl_param_cit.ct_attrs = lio_target_nacl_param_attrs;
2042 
2043 	ret = target_fabric_configfs_register(fabric);
2044 	if (ret < 0) {
2045 		pr_err("target_fabric_configfs_register() for"
2046 				" LIO-Target failed!\n");
2047 		target_fabric_configfs_free(fabric);
2048 		return ret;
2049 	}
2050 
2051 	lio_target_fabric_configfs = fabric;
2052 	pr_debug("LIO_TARGET[0] - Set fabric ->"
2053 			" lio_target_fabric_configfs\n");
2054 	return 0;
2055 }
2056 
2057 
2058 void iscsi_target_deregister_configfs(void)
2059 {
2060 	if (!lio_target_fabric_configfs)
2061 		return;
2062 	/*
2063 	 * Shutdown discovery sessions and disable discovery TPG
2064 	 */
2065 	if (iscsit_global->discovery_tpg)
2066 		iscsit_tpg_disable_portal_group(iscsit_global->discovery_tpg, 1);
2067 
2068 	target_fabric_configfs_deregister(lio_target_fabric_configfs);
2069 	lio_target_fabric_configfs = NULL;
2070 	pr_debug("LIO_TARGET[0] - Cleared"
2071 				" lio_target_fabric_configfs\n");
2072 }
2073