1 /*******************************************************************************
2 * This file contains the configfs implementation for iSCSI Target mode
3 * from the LIO-Target Project.
5 * (c) Copyright 2007-2013 Datera, Inc.
7 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
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.
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 ****************************************************************************/
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/configfs_macros.h>
28 #include <target/iscsi/iscsi_transport.h>
30 #include <target/iscsi/iscsi_target_core.h>
31 #include "iscsi_target_parameters.h"
32 #include "iscsi_target_device.h"
33 #include "iscsi_target_erl0.h"
34 #include "iscsi_target_nodeattrib.h"
35 #include "iscsi_target_tpg.h"
36 #include "iscsi_target_util.h"
37 #include "iscsi_target.h"
38 #include <target/iscsi/iscsi_target_stat.h>
40 struct lio_target_configfs_attribute {
41 struct configfs_attribute attr;
42 ssize_t (*show)(void *, char *);
43 ssize_t (*store)(void *, const char *, size_t);
46 /* Start items for lio_target_portal_cit */
48 static ssize_t lio_target_np_show_sctp(
49 struct se_tpg_np *se_tpg_np,
52 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
53 struct iscsi_tpg_np, se_tpg_np);
54 struct iscsi_tpg_np *tpg_np_sctp;
57 tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP);
59 rb = sprintf(page, "1\n");
61 rb = sprintf(page, "0\n");
66 static ssize_t lio_target_np_store_sctp(
67 struct se_tpg_np *se_tpg_np,
72 struct iscsi_portal_group *tpg;
73 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
74 struct iscsi_tpg_np, se_tpg_np);
75 struct iscsi_tpg_np *tpg_np_sctp = NULL;
79 ret = kstrtou32(page, 0, &op);
82 if ((op != 1) && (op != 0)) {
83 pr_err("Illegal value for tpg_enable: %u\n", op);
88 pr_err("Unable to locate struct iscsi_np from"
89 " struct iscsi_tpg_np\n");
94 if (iscsit_get_tpg(tpg) < 0)
99 * Use existing np->np_sockaddr for SCTP network portal reference
101 tpg_np_sctp = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr,
102 np->np_ip, tpg_np, ISCSI_SCTP_TCP);
103 if (!tpg_np_sctp || IS_ERR(tpg_np_sctp))
106 tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP);
110 ret = iscsit_tpg_del_network_portal(tpg, tpg_np_sctp);
122 TF_NP_BASE_ATTR(lio_target, sctp, S_IRUGO | S_IWUSR);
124 static ssize_t lio_target_np_show_iser(
125 struct se_tpg_np *se_tpg_np,
128 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
129 struct iscsi_tpg_np, se_tpg_np);
130 struct iscsi_tpg_np *tpg_np_iser;
133 tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND);
135 rb = sprintf(page, "1\n");
137 rb = sprintf(page, "0\n");
142 static ssize_t lio_target_np_store_iser(
143 struct se_tpg_np *se_tpg_np,
148 struct iscsi_portal_group *tpg;
149 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
150 struct iscsi_tpg_np, se_tpg_np);
151 struct iscsi_tpg_np *tpg_np_iser = NULL;
156 op = simple_strtoul(page, &endptr, 0);
157 if ((op != 1) && (op != 0)) {
158 pr_err("Illegal value for tpg_enable: %u\n", op);
163 pr_err("Unable to locate struct iscsi_np from"
164 " struct iscsi_tpg_np\n");
169 if (iscsit_get_tpg(tpg) < 0)
173 rc = request_module("ib_isert");
175 pr_warn("Unable to request_module for ib_isert\n");
179 tpg_np_iser = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr,
180 np->np_ip, tpg_np, ISCSI_INFINIBAND);
181 if (IS_ERR(tpg_np_iser)) {
182 rc = PTR_ERR(tpg_np_iser);
186 tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND);
188 rc = iscsit_tpg_del_network_portal(tpg, tpg_np_iser);
201 TF_NP_BASE_ATTR(lio_target, iser, S_IRUGO | S_IWUSR);
203 static struct configfs_attribute *lio_target_portal_attrs[] = {
204 &lio_target_np_sctp.attr,
205 &lio_target_np_iser.attr,
209 /* Stop items for lio_target_portal_cit */
211 /* Start items for lio_target_np_cit */
213 #define MAX_PORTAL_LEN 256
215 static struct se_tpg_np *lio_target_call_addnptotpg(
216 struct se_portal_group *se_tpg,
217 struct config_group *group,
220 struct iscsi_portal_group *tpg;
221 struct iscsi_tpg_np *tpg_np;
222 char *str, *str2, *ip_str, *port_str;
223 struct __kernel_sockaddr_storage sockaddr;
224 struct sockaddr_in *sock_in;
225 struct sockaddr_in6 *sock_in6;
228 char buf[MAX_PORTAL_LEN + 1];
230 if (strlen(name) > MAX_PORTAL_LEN) {
231 pr_err("strlen(name): %d exceeds MAX_PORTAL_LEN: %d\n",
232 (int)strlen(name), MAX_PORTAL_LEN);
233 return ERR_PTR(-EOVERFLOW);
235 memset(buf, 0, MAX_PORTAL_LEN + 1);
236 snprintf(buf, MAX_PORTAL_LEN + 1, "%s", name);
238 memset(&sockaddr, 0, sizeof(struct __kernel_sockaddr_storage));
240 str = strstr(buf, "[");
244 str2 = strstr(str, "]");
246 pr_err("Unable to locate trailing \"]\""
247 " in IPv6 iSCSI network portal address\n");
248 return ERR_PTR(-EINVAL);
250 str++; /* Skip over leading "[" */
251 *str2 = '\0'; /* Terminate the IPv6 address */
252 str2++; /* Skip over the "]" */
253 port_str = strstr(str2, ":");
255 pr_err("Unable to locate \":port\""
256 " in IPv6 iSCSI network portal address\n");
257 return ERR_PTR(-EINVAL);
259 *port_str = '\0'; /* Terminate string for IP */
260 port_str++; /* Skip over ":" */
262 ret = kstrtoul(port_str, 0, &port);
264 pr_err("kstrtoul() failed for port_str: %d\n", ret);
267 sock_in6 = (struct sockaddr_in6 *)&sockaddr;
268 sock_in6->sin6_family = AF_INET6;
269 sock_in6->sin6_port = htons((unsigned short)port);
270 ret = in6_pton(str, IPV6_ADDRESS_SPACE,
271 (void *)&sock_in6->sin6_addr.in6_u, -1, &end);
273 pr_err("in6_pton returned: %d\n", ret);
274 return ERR_PTR(-EINVAL);
277 str = ip_str = &buf[0];
278 port_str = strstr(ip_str, ":");
280 pr_err("Unable to locate \":port\""
281 " in IPv4 iSCSI network portal address\n");
282 return ERR_PTR(-EINVAL);
284 *port_str = '\0'; /* Terminate string for IP */
285 port_str++; /* Skip over ":" */
287 ret = kstrtoul(port_str, 0, &port);
289 pr_err("kstrtoul() failed for port_str: %d\n", ret);
292 sock_in = (struct sockaddr_in *)&sockaddr;
293 sock_in->sin_family = AF_INET;
294 sock_in->sin_port = htons((unsigned short)port);
295 sock_in->sin_addr.s_addr = in_aton(ip_str);
297 tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
298 ret = iscsit_get_tpg(tpg);
300 return ERR_PTR(-EINVAL);
302 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s TPGT: %hu"
304 config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item),
307 * Assume ISCSI_TCP by default. Other network portals for other
310 * Traditional iSCSI over SCTP (initial support)
311 * iSER/TCP (TODO, hardware available)
312 * iSER/SCTP (TODO, software emulation with osc-iwarp)
313 * iSER/IB (TODO, hardware available)
315 * can be enabled with attributes under
316 * sys/kernel/config/iscsi/$IQN/$TPG/np/$IP:$PORT/
319 tpg_np = iscsit_tpg_add_network_portal(tpg, &sockaddr, str, NULL,
321 if (IS_ERR(tpg_np)) {
323 return ERR_CAST(tpg_np);
325 pr_debug("LIO_Target_ConfigFS: addnptotpg done!\n");
328 return &tpg_np->se_tpg_np;
331 static void lio_target_call_delnpfromtpg(
332 struct se_tpg_np *se_tpg_np)
334 struct iscsi_portal_group *tpg;
335 struct iscsi_tpg_np *tpg_np;
336 struct se_portal_group *se_tpg;
339 tpg_np = container_of(se_tpg_np, struct iscsi_tpg_np, se_tpg_np);
341 ret = iscsit_get_tpg(tpg);
345 se_tpg = &tpg->tpg_se_tpg;
346 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s TPGT: %hu"
347 " PORTAL: %s:%hu\n", config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item),
348 tpg->tpgt, tpg_np->tpg_np->np_ip, tpg_np->tpg_np->np_port);
350 ret = iscsit_tpg_del_network_portal(tpg, tpg_np);
354 pr_debug("LIO_Target_ConfigFS: delnpfromtpg done!\n");
359 /* End items for lio_target_np_cit */
361 /* Start items for lio_target_nacl_attrib_cit */
363 #define DEF_NACL_ATTRIB(name) \
364 static ssize_t iscsi_nacl_attrib_show_##name( \
365 struct se_node_acl *se_nacl, \
368 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \
371 return sprintf(page, "%u\n", nacl->node_attrib.name); \
374 static ssize_t iscsi_nacl_attrib_store_##name( \
375 struct se_node_acl *se_nacl, \
379 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \
384 ret = kstrtou32(page, 0, &val); \
387 ret = iscsit_na_##name(nacl, val); \
394 #define NACL_ATTR(_name, _mode) TF_NACL_ATTRIB_ATTR(iscsi, _name, _mode);
396 * Define iscsi_node_attrib_s_dataout_timeout
398 DEF_NACL_ATTRIB(dataout_timeout);
399 NACL_ATTR(dataout_timeout, S_IRUGO | S_IWUSR);
401 * Define iscsi_node_attrib_s_dataout_timeout_retries
403 DEF_NACL_ATTRIB(dataout_timeout_retries);
404 NACL_ATTR(dataout_timeout_retries, S_IRUGO | S_IWUSR);
406 * Define iscsi_node_attrib_s_default_erl
408 DEF_NACL_ATTRIB(default_erl);
409 NACL_ATTR(default_erl, S_IRUGO | S_IWUSR);
411 * Define iscsi_node_attrib_s_nopin_timeout
413 DEF_NACL_ATTRIB(nopin_timeout);
414 NACL_ATTR(nopin_timeout, S_IRUGO | S_IWUSR);
416 * Define iscsi_node_attrib_s_nopin_response_timeout
418 DEF_NACL_ATTRIB(nopin_response_timeout);
419 NACL_ATTR(nopin_response_timeout, S_IRUGO | S_IWUSR);
421 * Define iscsi_node_attrib_s_random_datain_pdu_offsets
423 DEF_NACL_ATTRIB(random_datain_pdu_offsets);
424 NACL_ATTR(random_datain_pdu_offsets, S_IRUGO | S_IWUSR);
426 * Define iscsi_node_attrib_s_random_datain_seq_offsets
428 DEF_NACL_ATTRIB(random_datain_seq_offsets);
429 NACL_ATTR(random_datain_seq_offsets, S_IRUGO | S_IWUSR);
431 * Define iscsi_node_attrib_s_random_r2t_offsets
433 DEF_NACL_ATTRIB(random_r2t_offsets);
434 NACL_ATTR(random_r2t_offsets, S_IRUGO | S_IWUSR);
436 static struct configfs_attribute *lio_target_nacl_attrib_attrs[] = {
437 &iscsi_nacl_attrib_dataout_timeout.attr,
438 &iscsi_nacl_attrib_dataout_timeout_retries.attr,
439 &iscsi_nacl_attrib_default_erl.attr,
440 &iscsi_nacl_attrib_nopin_timeout.attr,
441 &iscsi_nacl_attrib_nopin_response_timeout.attr,
442 &iscsi_nacl_attrib_random_datain_pdu_offsets.attr,
443 &iscsi_nacl_attrib_random_datain_seq_offsets.attr,
444 &iscsi_nacl_attrib_random_r2t_offsets.attr,
448 /* End items for lio_target_nacl_attrib_cit */
450 /* Start items for lio_target_nacl_auth_cit */
452 #define __DEF_NACL_AUTH_STR(prefix, name, flags) \
453 static ssize_t __iscsi_##prefix##_show_##name( \
454 struct iscsi_node_acl *nacl, \
457 struct iscsi_node_auth *auth = &nacl->node_auth; \
459 if (!capable(CAP_SYS_ADMIN)) \
461 return snprintf(page, PAGE_SIZE, "%s\n", auth->name); \
464 static ssize_t __iscsi_##prefix##_store_##name( \
465 struct iscsi_node_acl *nacl, \
469 struct iscsi_node_auth *auth = &nacl->node_auth; \
471 if (!capable(CAP_SYS_ADMIN)) \
473 if (count >= sizeof(auth->name)) \
475 snprintf(auth->name, sizeof(auth->name), "%s", page); \
476 if (!strncmp("NULL", auth->name, 4)) \
477 auth->naf_flags &= ~flags; \
479 auth->naf_flags |= flags; \
481 if ((auth->naf_flags & NAF_USERID_IN_SET) && \
482 (auth->naf_flags & NAF_PASSWORD_IN_SET)) \
483 auth->authenticate_target = 1; \
485 auth->authenticate_target = 0; \
490 #define __DEF_NACL_AUTH_INT(prefix, name) \
491 static ssize_t __iscsi_##prefix##_show_##name( \
492 struct iscsi_node_acl *nacl, \
495 struct iscsi_node_auth *auth = &nacl->node_auth; \
497 if (!capable(CAP_SYS_ADMIN)) \
500 return snprintf(page, PAGE_SIZE, "%d\n", auth->name); \
503 #define DEF_NACL_AUTH_STR(name, flags) \
504 __DEF_NACL_AUTH_STR(nacl_auth, name, flags) \
505 static ssize_t iscsi_nacl_auth_show_##name( \
506 struct se_node_acl *nacl, \
509 return __iscsi_nacl_auth_show_##name(container_of(nacl, \
510 struct iscsi_node_acl, se_node_acl), page); \
512 static ssize_t iscsi_nacl_auth_store_##name( \
513 struct se_node_acl *nacl, \
517 return __iscsi_nacl_auth_store_##name(container_of(nacl, \
518 struct iscsi_node_acl, se_node_acl), page, count); \
521 #define DEF_NACL_AUTH_INT(name) \
522 __DEF_NACL_AUTH_INT(nacl_auth, name) \
523 static ssize_t iscsi_nacl_auth_show_##name( \
524 struct se_node_acl *nacl, \
527 return __iscsi_nacl_auth_show_##name(container_of(nacl, \
528 struct iscsi_node_acl, se_node_acl), page); \
531 #define AUTH_ATTR(_name, _mode) TF_NACL_AUTH_ATTR(iscsi, _name, _mode);
532 #define AUTH_ATTR_RO(_name) TF_NACL_AUTH_ATTR_RO(iscsi, _name);
535 * One-way authentication userid
537 DEF_NACL_AUTH_STR(userid, NAF_USERID_SET);
538 AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
540 * One-way authentication password
542 DEF_NACL_AUTH_STR(password, NAF_PASSWORD_SET);
543 AUTH_ATTR(password, S_IRUGO | S_IWUSR);
545 * Enforce mutual authentication
547 DEF_NACL_AUTH_INT(authenticate_target);
548 AUTH_ATTR_RO(authenticate_target);
550 * Mutual authentication userid
552 DEF_NACL_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
553 AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
555 * Mutual authentication password
557 DEF_NACL_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
558 AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
560 static struct configfs_attribute *lio_target_nacl_auth_attrs[] = {
561 &iscsi_nacl_auth_userid.attr,
562 &iscsi_nacl_auth_password.attr,
563 &iscsi_nacl_auth_authenticate_target.attr,
564 &iscsi_nacl_auth_userid_mutual.attr,
565 &iscsi_nacl_auth_password_mutual.attr,
569 /* End items for lio_target_nacl_auth_cit */
571 /* Start items for lio_target_nacl_param_cit */
573 #define DEF_NACL_PARAM(name) \
574 static ssize_t iscsi_nacl_param_show_##name( \
575 struct se_node_acl *se_nacl, \
578 struct iscsi_session *sess; \
579 struct se_session *se_sess; \
582 spin_lock_bh(&se_nacl->nacl_sess_lock); \
583 se_sess = se_nacl->nacl_sess; \
585 rb = snprintf(page, PAGE_SIZE, \
586 "No Active iSCSI Session\n"); \
588 sess = se_sess->fabric_sess_ptr; \
589 rb = snprintf(page, PAGE_SIZE, "%u\n", \
590 (u32)sess->sess_ops->name); \
592 spin_unlock_bh(&se_nacl->nacl_sess_lock); \
597 #define NACL_PARAM_ATTR(_name) TF_NACL_PARAM_ATTR_RO(iscsi, _name);
599 DEF_NACL_PARAM(MaxConnections);
600 NACL_PARAM_ATTR(MaxConnections);
602 DEF_NACL_PARAM(InitialR2T);
603 NACL_PARAM_ATTR(InitialR2T);
605 DEF_NACL_PARAM(ImmediateData);
606 NACL_PARAM_ATTR(ImmediateData);
608 DEF_NACL_PARAM(MaxBurstLength);
609 NACL_PARAM_ATTR(MaxBurstLength);
611 DEF_NACL_PARAM(FirstBurstLength);
612 NACL_PARAM_ATTR(FirstBurstLength);
614 DEF_NACL_PARAM(DefaultTime2Wait);
615 NACL_PARAM_ATTR(DefaultTime2Wait);
617 DEF_NACL_PARAM(DefaultTime2Retain);
618 NACL_PARAM_ATTR(DefaultTime2Retain);
620 DEF_NACL_PARAM(MaxOutstandingR2T);
621 NACL_PARAM_ATTR(MaxOutstandingR2T);
623 DEF_NACL_PARAM(DataPDUInOrder);
624 NACL_PARAM_ATTR(DataPDUInOrder);
626 DEF_NACL_PARAM(DataSequenceInOrder);
627 NACL_PARAM_ATTR(DataSequenceInOrder);
629 DEF_NACL_PARAM(ErrorRecoveryLevel);
630 NACL_PARAM_ATTR(ErrorRecoveryLevel);
632 static struct configfs_attribute *lio_target_nacl_param_attrs[] = {
633 &iscsi_nacl_param_MaxConnections.attr,
634 &iscsi_nacl_param_InitialR2T.attr,
635 &iscsi_nacl_param_ImmediateData.attr,
636 &iscsi_nacl_param_MaxBurstLength.attr,
637 &iscsi_nacl_param_FirstBurstLength.attr,
638 &iscsi_nacl_param_DefaultTime2Wait.attr,
639 &iscsi_nacl_param_DefaultTime2Retain.attr,
640 &iscsi_nacl_param_MaxOutstandingR2T.attr,
641 &iscsi_nacl_param_DataPDUInOrder.attr,
642 &iscsi_nacl_param_DataSequenceInOrder.attr,
643 &iscsi_nacl_param_ErrorRecoveryLevel.attr,
647 /* End items for lio_target_nacl_param_cit */
649 /* Start items for lio_target_acl_cit */
651 static ssize_t lio_target_nacl_show_info(
652 struct se_node_acl *se_nacl,
655 struct iscsi_session *sess;
656 struct iscsi_conn *conn;
657 struct se_session *se_sess;
660 spin_lock_bh(&se_nacl->nacl_sess_lock);
661 se_sess = se_nacl->nacl_sess;
663 rb += sprintf(page+rb, "No active iSCSI Session for Initiator"
664 " Endpoint: %s\n", se_nacl->initiatorname);
666 sess = se_sess->fabric_sess_ptr;
668 rb += sprintf(page+rb, "InitiatorName: %s\n",
669 sess->sess_ops->InitiatorName);
670 rb += sprintf(page+rb, "InitiatorAlias: %s\n",
671 sess->sess_ops->InitiatorAlias);
673 rb += sprintf(page+rb,
674 "LIO Session ID: %u ISID: 0x%6ph TSIH: %hu ",
675 sess->sid, sess->isid, sess->tsih);
676 rb += sprintf(page+rb, "SessionType: %s\n",
677 (sess->sess_ops->SessionType) ?
678 "Discovery" : "Normal");
679 rb += sprintf(page+rb, "Session State: ");
680 switch (sess->session_state) {
681 case TARG_SESS_STATE_FREE:
682 rb += sprintf(page+rb, "TARG_SESS_FREE\n");
684 case TARG_SESS_STATE_ACTIVE:
685 rb += sprintf(page+rb, "TARG_SESS_STATE_ACTIVE\n");
687 case TARG_SESS_STATE_LOGGED_IN:
688 rb += sprintf(page+rb, "TARG_SESS_STATE_LOGGED_IN\n");
690 case TARG_SESS_STATE_FAILED:
691 rb += sprintf(page+rb, "TARG_SESS_STATE_FAILED\n");
693 case TARG_SESS_STATE_IN_CONTINUE:
694 rb += sprintf(page+rb, "TARG_SESS_STATE_IN_CONTINUE\n");
697 rb += sprintf(page+rb, "ERROR: Unknown Session"
702 rb += sprintf(page+rb, "---------------------[iSCSI Session"
703 " Values]-----------------------\n");
704 rb += sprintf(page+rb, " CmdSN/WR : CmdSN/WC : ExpCmdSN"
705 " : MaxCmdSN : ITT : TTT\n");
706 rb += sprintf(page+rb, " 0x%08x 0x%08x 0x%08x 0x%08x"
709 (sess->max_cmd_sn - sess->exp_cmd_sn) + 1,
710 sess->exp_cmd_sn, sess->max_cmd_sn,
711 sess->init_task_tag, sess->targ_xfer_tag);
712 rb += sprintf(page+rb, "----------------------[iSCSI"
713 " Connections]-------------------------\n");
715 spin_lock(&sess->conn_lock);
716 list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
717 rb += sprintf(page+rb, "CID: %hu Connection"
718 " State: ", conn->cid);
719 switch (conn->conn_state) {
720 case TARG_CONN_STATE_FREE:
721 rb += sprintf(page+rb,
722 "TARG_CONN_STATE_FREE\n");
724 case TARG_CONN_STATE_XPT_UP:
725 rb += sprintf(page+rb,
726 "TARG_CONN_STATE_XPT_UP\n");
728 case TARG_CONN_STATE_IN_LOGIN:
729 rb += sprintf(page+rb,
730 "TARG_CONN_STATE_IN_LOGIN\n");
732 case TARG_CONN_STATE_LOGGED_IN:
733 rb += sprintf(page+rb,
734 "TARG_CONN_STATE_LOGGED_IN\n");
736 case TARG_CONN_STATE_IN_LOGOUT:
737 rb += sprintf(page+rb,
738 "TARG_CONN_STATE_IN_LOGOUT\n");
740 case TARG_CONN_STATE_LOGOUT_REQUESTED:
741 rb += sprintf(page+rb,
742 "TARG_CONN_STATE_LOGOUT_REQUESTED\n");
744 case TARG_CONN_STATE_CLEANUP_WAIT:
745 rb += sprintf(page+rb,
746 "TARG_CONN_STATE_CLEANUP_WAIT\n");
749 rb += sprintf(page+rb,
750 "ERROR: Unknown Connection State!\n");
754 rb += sprintf(page+rb, " Address %s %s", conn->login_ip,
755 (conn->network_transport == ISCSI_TCP) ?
757 rb += sprintf(page+rb, " StatSN: 0x%08x\n",
760 spin_unlock(&sess->conn_lock);
762 spin_unlock_bh(&se_nacl->nacl_sess_lock);
767 TF_NACL_BASE_ATTR_RO(lio_target, info);
769 static ssize_t lio_target_nacl_show_cmdsn_depth(
770 struct se_node_acl *se_nacl,
773 return sprintf(page, "%u\n", se_nacl->queue_depth);
776 static ssize_t lio_target_nacl_store_cmdsn_depth(
777 struct se_node_acl *se_nacl,
781 struct se_portal_group *se_tpg = se_nacl->se_tpg;
782 struct iscsi_portal_group *tpg = container_of(se_tpg,
783 struct iscsi_portal_group, tpg_se_tpg);
784 struct config_item *acl_ci, *tpg_ci, *wwn_ci;
788 ret = kstrtou32(page, 0, &cmdsn_depth);
791 if (cmdsn_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) {
792 pr_err("Passed cmdsn_depth: %u exceeds"
793 " TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n", cmdsn_depth,
794 TA_DEFAULT_CMDSN_DEPTH_MAX);
797 acl_ci = &se_nacl->acl_group.cg_item;
799 pr_err("Unable to locatel acl_ci\n");
802 tpg_ci = &acl_ci->ci_parent->ci_group->cg_item;
804 pr_err("Unable to locate tpg_ci\n");
807 wwn_ci = &tpg_ci->ci_group->cg_item;
809 pr_err("Unable to locate config_item wwn_ci\n");
813 if (iscsit_get_tpg(tpg) < 0)
816 * iscsit_tpg_set_initiator_node_queue_depth() assumes force=1
818 ret = iscsit_tpg_set_initiator_node_queue_depth(tpg,
819 config_item_name(acl_ci), cmdsn_depth, 1);
821 pr_debug("LIO_Target_ConfigFS: %s/%s Set CmdSN Window: %u for"
822 "InitiatorName: %s\n", config_item_name(wwn_ci),
823 config_item_name(tpg_ci), cmdsn_depth,
824 config_item_name(acl_ci));
827 return (!ret) ? count : (ssize_t)ret;
830 TF_NACL_BASE_ATTR(lio_target, cmdsn_depth, S_IRUGO | S_IWUSR);
832 static ssize_t lio_target_nacl_show_tag(
833 struct se_node_acl *se_nacl,
836 return snprintf(page, PAGE_SIZE, "%s", se_nacl->acl_tag);
839 static ssize_t lio_target_nacl_store_tag(
840 struct se_node_acl *se_nacl,
846 ret = core_tpg_set_initiator_node_tag(se_nacl->se_tpg, se_nacl, page);
853 TF_NACL_BASE_ATTR(lio_target, tag, S_IRUGO | S_IWUSR);
855 static struct configfs_attribute *lio_target_initiator_attrs[] = {
856 &lio_target_nacl_info.attr,
857 &lio_target_nacl_cmdsn_depth.attr,
858 &lio_target_nacl_tag.attr,
862 static int lio_target_init_nodeacl(struct se_node_acl *se_nacl,
865 struct iscsi_node_acl *acl =
866 container_of(se_nacl, struct iscsi_node_acl, se_node_acl);
867 struct config_group *stats_cg = &se_nacl->acl_fabric_stat_group;
869 stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,
871 if (!stats_cg->default_groups) {
872 pr_err("Unable to allocate memory for"
873 " stats_cg->default_groups\n");
877 stats_cg->default_groups[0] = &acl->node_stat_grps.iscsi_sess_stats_group;
878 stats_cg->default_groups[1] = NULL;
879 config_group_init_type_name(&acl->node_stat_grps.iscsi_sess_stats_group,
880 "iscsi_sess_stats", &iscsi_stat_sess_cit);
885 static void lio_target_cleanup_nodeacl( struct se_node_acl *se_nacl)
887 struct iscsi_node_acl *acl = container_of(se_nacl,
888 struct iscsi_node_acl, se_node_acl);
889 struct config_item *df_item;
890 struct config_group *stats_cg;
893 stats_cg = &acl->se_node_acl.acl_fabric_stat_group;
894 for (i = 0; stats_cg->default_groups[i]; i++) {
895 df_item = &stats_cg->default_groups[i]->cg_item;
896 stats_cg->default_groups[i] = NULL;
897 config_item_put(df_item);
899 kfree(stats_cg->default_groups);
902 /* End items for lio_target_acl_cit */
904 /* Start items for lio_target_tpg_attrib_cit */
906 #define DEF_TPG_ATTRIB(name) \
908 static ssize_t iscsi_tpg_attrib_show_##name( \
909 struct se_portal_group *se_tpg, \
912 struct iscsi_portal_group *tpg = container_of(se_tpg, \
913 struct iscsi_portal_group, tpg_se_tpg); \
916 if (iscsit_get_tpg(tpg) < 0) \
919 rb = sprintf(page, "%u\n", tpg->tpg_attrib.name); \
920 iscsit_put_tpg(tpg); \
924 static ssize_t iscsi_tpg_attrib_store_##name( \
925 struct se_portal_group *se_tpg, \
929 struct iscsi_portal_group *tpg = container_of(se_tpg, \
930 struct iscsi_portal_group, tpg_se_tpg); \
934 if (iscsit_get_tpg(tpg) < 0) \
937 ret = kstrtou32(page, 0, &val); \
940 ret = iscsit_ta_##name(tpg, val); \
944 iscsit_put_tpg(tpg); \
947 iscsit_put_tpg(tpg); \
951 #define TPG_ATTR(_name, _mode) TF_TPG_ATTRIB_ATTR(iscsi, _name, _mode);
954 * Define iscsi_tpg_attrib_s_authentication
956 DEF_TPG_ATTRIB(authentication);
957 TPG_ATTR(authentication, S_IRUGO | S_IWUSR);
959 * Define iscsi_tpg_attrib_s_login_timeout
961 DEF_TPG_ATTRIB(login_timeout);
962 TPG_ATTR(login_timeout, S_IRUGO | S_IWUSR);
964 * Define iscsi_tpg_attrib_s_netif_timeout
966 DEF_TPG_ATTRIB(netif_timeout);
967 TPG_ATTR(netif_timeout, S_IRUGO | S_IWUSR);
969 * Define iscsi_tpg_attrib_s_generate_node_acls
971 DEF_TPG_ATTRIB(generate_node_acls);
972 TPG_ATTR(generate_node_acls, S_IRUGO | S_IWUSR);
974 * Define iscsi_tpg_attrib_s_default_cmdsn_depth
976 DEF_TPG_ATTRIB(default_cmdsn_depth);
977 TPG_ATTR(default_cmdsn_depth, S_IRUGO | S_IWUSR);
979 Define iscsi_tpg_attrib_s_cache_dynamic_acls
981 DEF_TPG_ATTRIB(cache_dynamic_acls);
982 TPG_ATTR(cache_dynamic_acls, S_IRUGO | S_IWUSR);
984 * Define iscsi_tpg_attrib_s_demo_mode_write_protect
986 DEF_TPG_ATTRIB(demo_mode_write_protect);
987 TPG_ATTR(demo_mode_write_protect, S_IRUGO | S_IWUSR);
989 * Define iscsi_tpg_attrib_s_prod_mode_write_protect
991 DEF_TPG_ATTRIB(prod_mode_write_protect);
992 TPG_ATTR(prod_mode_write_protect, S_IRUGO | S_IWUSR);
994 * Define iscsi_tpg_attrib_s_demo_mode_discovery,
996 DEF_TPG_ATTRIB(demo_mode_discovery);
997 TPG_ATTR(demo_mode_discovery, S_IRUGO | S_IWUSR);
999 * Define iscsi_tpg_attrib_s_default_erl
1001 DEF_TPG_ATTRIB(default_erl);
1002 TPG_ATTR(default_erl, S_IRUGO | S_IWUSR);
1004 * Define iscsi_tpg_attrib_s_t10_pi
1006 DEF_TPG_ATTRIB(t10_pi);
1007 TPG_ATTR(t10_pi, S_IRUGO | S_IWUSR);
1009 * Define iscsi_tpg_attrib_s_fabric_prot_type
1011 DEF_TPG_ATTRIB(fabric_prot_type);
1012 TPG_ATTR(fabric_prot_type, S_IRUGO | S_IWUSR);
1014 static struct configfs_attribute *lio_target_tpg_attrib_attrs[] = {
1015 &iscsi_tpg_attrib_authentication.attr,
1016 &iscsi_tpg_attrib_login_timeout.attr,
1017 &iscsi_tpg_attrib_netif_timeout.attr,
1018 &iscsi_tpg_attrib_generate_node_acls.attr,
1019 &iscsi_tpg_attrib_default_cmdsn_depth.attr,
1020 &iscsi_tpg_attrib_cache_dynamic_acls.attr,
1021 &iscsi_tpg_attrib_demo_mode_write_protect.attr,
1022 &iscsi_tpg_attrib_prod_mode_write_protect.attr,
1023 &iscsi_tpg_attrib_demo_mode_discovery.attr,
1024 &iscsi_tpg_attrib_default_erl.attr,
1025 &iscsi_tpg_attrib_t10_pi.attr,
1026 &iscsi_tpg_attrib_fabric_prot_type.attr,
1030 /* End items for lio_target_tpg_attrib_cit */
1032 /* Start items for lio_target_tpg_auth_cit */
1034 #define __DEF_TPG_AUTH_STR(prefix, name, flags) \
1035 static ssize_t __iscsi_##prefix##_show_##name( \
1036 struct se_portal_group *se_tpg, \
1039 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1040 struct iscsi_portal_group, tpg_se_tpg); \
1041 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1043 if (!capable(CAP_SYS_ADMIN)) \
1046 return snprintf(page, PAGE_SIZE, "%s\n", auth->name); \
1049 static ssize_t __iscsi_##prefix##_store_##name( \
1050 struct se_portal_group *se_tpg, \
1054 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1055 struct iscsi_portal_group, tpg_se_tpg); \
1056 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1058 if (!capable(CAP_SYS_ADMIN)) \
1061 snprintf(auth->name, sizeof(auth->name), "%s", page); \
1062 if (!(strncmp("NULL", auth->name, 4))) \
1063 auth->naf_flags &= ~flags; \
1065 auth->naf_flags |= flags; \
1067 if ((auth->naf_flags & NAF_USERID_IN_SET) && \
1068 (auth->naf_flags & NAF_PASSWORD_IN_SET)) \
1069 auth->authenticate_target = 1; \
1071 auth->authenticate_target = 0; \
1076 #define __DEF_TPG_AUTH_INT(prefix, name) \
1077 static ssize_t __iscsi_##prefix##_show_##name( \
1078 struct se_portal_group *se_tpg, \
1081 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1082 struct iscsi_portal_group, tpg_se_tpg); \
1083 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1085 if (!capable(CAP_SYS_ADMIN)) \
1088 return snprintf(page, PAGE_SIZE, "%d\n", auth->name); \
1091 #define DEF_TPG_AUTH_STR(name, flags) \
1092 __DEF_TPG_AUTH_STR(tpg_auth, name, flags) \
1093 static ssize_t iscsi_tpg_auth_show_##name( \
1094 struct se_portal_group *se_tpg, \
1097 return __iscsi_tpg_auth_show_##name(se_tpg, page); \
1100 static ssize_t iscsi_tpg_auth_store_##name( \
1101 struct se_portal_group *se_tpg, \
1105 return __iscsi_tpg_auth_store_##name(se_tpg, page, count); \
1108 #define DEF_TPG_AUTH_INT(name) \
1109 __DEF_TPG_AUTH_INT(tpg_auth, name) \
1110 static ssize_t iscsi_tpg_auth_show_##name( \
1111 struct se_portal_group *se_tpg, \
1114 return __iscsi_tpg_auth_show_##name(se_tpg, page); \
1117 #define TPG_AUTH_ATTR(_name, _mode) TF_TPG_AUTH_ATTR(iscsi, _name, _mode);
1118 #define TPG_AUTH_ATTR_RO(_name) TF_TPG_AUTH_ATTR_RO(iscsi, _name);
1121 * * One-way authentication userid
1123 DEF_TPG_AUTH_STR(userid, NAF_USERID_SET);
1124 TPG_AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
1126 * * One-way authentication password
1128 DEF_TPG_AUTH_STR(password, NAF_PASSWORD_SET);
1129 TPG_AUTH_ATTR(password, S_IRUGO | S_IWUSR);
1131 * * Enforce mutual authentication
1133 DEF_TPG_AUTH_INT(authenticate_target);
1134 TPG_AUTH_ATTR_RO(authenticate_target);
1136 * * Mutual authentication userid
1138 DEF_TPG_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
1139 TPG_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
1141 * * Mutual authentication password
1143 DEF_TPG_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
1144 TPG_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
1146 static struct configfs_attribute *lio_target_tpg_auth_attrs[] = {
1147 &iscsi_tpg_auth_userid.attr,
1148 &iscsi_tpg_auth_password.attr,
1149 &iscsi_tpg_auth_authenticate_target.attr,
1150 &iscsi_tpg_auth_userid_mutual.attr,
1151 &iscsi_tpg_auth_password_mutual.attr,
1155 /* End items for lio_target_tpg_auth_cit */
1157 /* Start items for lio_target_tpg_param_cit */
1159 #define DEF_TPG_PARAM(name) \
1160 static ssize_t iscsi_tpg_param_show_##name( \
1161 struct se_portal_group *se_tpg, \
1164 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1165 struct iscsi_portal_group, tpg_se_tpg); \
1166 struct iscsi_param *param; \
1169 if (iscsit_get_tpg(tpg) < 0) \
1172 param = iscsi_find_param_from_key(__stringify(name), \
1175 iscsit_put_tpg(tpg); \
1178 rb = snprintf(page, PAGE_SIZE, "%s\n", param->value); \
1180 iscsit_put_tpg(tpg); \
1183 static ssize_t iscsi_tpg_param_store_##name( \
1184 struct se_portal_group *se_tpg, \
1188 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1189 struct iscsi_portal_group, tpg_se_tpg); \
1193 buf = kzalloc(PAGE_SIZE, GFP_KERNEL); \
1196 len = snprintf(buf, PAGE_SIZE, "%s=%s", __stringify(name), page); \
1197 if (isspace(buf[len-1])) \
1198 buf[len-1] = '\0'; /* Kill newline */ \
1200 if (iscsit_get_tpg(tpg) < 0) { \
1205 ret = iscsi_change_param_value(buf, tpg->param_list, 1); \
1210 iscsit_put_tpg(tpg); \
1214 iscsit_put_tpg(tpg); \
1218 #define TPG_PARAM_ATTR(_name, _mode) TF_TPG_PARAM_ATTR(iscsi, _name, _mode);
1220 DEF_TPG_PARAM(AuthMethod);
1221 TPG_PARAM_ATTR(AuthMethod, S_IRUGO | S_IWUSR);
1223 DEF_TPG_PARAM(HeaderDigest);
1224 TPG_PARAM_ATTR(HeaderDigest, S_IRUGO | S_IWUSR);
1226 DEF_TPG_PARAM(DataDigest);
1227 TPG_PARAM_ATTR(DataDigest, S_IRUGO | S_IWUSR);
1229 DEF_TPG_PARAM(MaxConnections);
1230 TPG_PARAM_ATTR(MaxConnections, S_IRUGO | S_IWUSR);
1232 DEF_TPG_PARAM(TargetAlias);
1233 TPG_PARAM_ATTR(TargetAlias, S_IRUGO | S_IWUSR);
1235 DEF_TPG_PARAM(InitialR2T);
1236 TPG_PARAM_ATTR(InitialR2T, S_IRUGO | S_IWUSR);
1238 DEF_TPG_PARAM(ImmediateData);
1239 TPG_PARAM_ATTR(ImmediateData, S_IRUGO | S_IWUSR);
1241 DEF_TPG_PARAM(MaxRecvDataSegmentLength);
1242 TPG_PARAM_ATTR(MaxRecvDataSegmentLength, S_IRUGO | S_IWUSR);
1244 DEF_TPG_PARAM(MaxXmitDataSegmentLength);
1245 TPG_PARAM_ATTR(MaxXmitDataSegmentLength, S_IRUGO | S_IWUSR);
1247 DEF_TPG_PARAM(MaxBurstLength);
1248 TPG_PARAM_ATTR(MaxBurstLength, S_IRUGO | S_IWUSR);
1250 DEF_TPG_PARAM(FirstBurstLength);
1251 TPG_PARAM_ATTR(FirstBurstLength, S_IRUGO | S_IWUSR);
1253 DEF_TPG_PARAM(DefaultTime2Wait);
1254 TPG_PARAM_ATTR(DefaultTime2Wait, S_IRUGO | S_IWUSR);
1256 DEF_TPG_PARAM(DefaultTime2Retain);
1257 TPG_PARAM_ATTR(DefaultTime2Retain, S_IRUGO | S_IWUSR);
1259 DEF_TPG_PARAM(MaxOutstandingR2T);
1260 TPG_PARAM_ATTR(MaxOutstandingR2T, S_IRUGO | S_IWUSR);
1262 DEF_TPG_PARAM(DataPDUInOrder);
1263 TPG_PARAM_ATTR(DataPDUInOrder, S_IRUGO | S_IWUSR);
1265 DEF_TPG_PARAM(DataSequenceInOrder);
1266 TPG_PARAM_ATTR(DataSequenceInOrder, S_IRUGO | S_IWUSR);
1268 DEF_TPG_PARAM(ErrorRecoveryLevel);
1269 TPG_PARAM_ATTR(ErrorRecoveryLevel, S_IRUGO | S_IWUSR);
1271 DEF_TPG_PARAM(IFMarker);
1272 TPG_PARAM_ATTR(IFMarker, S_IRUGO | S_IWUSR);
1274 DEF_TPG_PARAM(OFMarker);
1275 TPG_PARAM_ATTR(OFMarker, S_IRUGO | S_IWUSR);
1277 DEF_TPG_PARAM(IFMarkInt);
1278 TPG_PARAM_ATTR(IFMarkInt, S_IRUGO | S_IWUSR);
1280 DEF_TPG_PARAM(OFMarkInt);
1281 TPG_PARAM_ATTR(OFMarkInt, S_IRUGO | S_IWUSR);
1283 static struct configfs_attribute *lio_target_tpg_param_attrs[] = {
1284 &iscsi_tpg_param_AuthMethod.attr,
1285 &iscsi_tpg_param_HeaderDigest.attr,
1286 &iscsi_tpg_param_DataDigest.attr,
1287 &iscsi_tpg_param_MaxConnections.attr,
1288 &iscsi_tpg_param_TargetAlias.attr,
1289 &iscsi_tpg_param_InitialR2T.attr,
1290 &iscsi_tpg_param_ImmediateData.attr,
1291 &iscsi_tpg_param_MaxRecvDataSegmentLength.attr,
1292 &iscsi_tpg_param_MaxXmitDataSegmentLength.attr,
1293 &iscsi_tpg_param_MaxBurstLength.attr,
1294 &iscsi_tpg_param_FirstBurstLength.attr,
1295 &iscsi_tpg_param_DefaultTime2Wait.attr,
1296 &iscsi_tpg_param_DefaultTime2Retain.attr,
1297 &iscsi_tpg_param_MaxOutstandingR2T.attr,
1298 &iscsi_tpg_param_DataPDUInOrder.attr,
1299 &iscsi_tpg_param_DataSequenceInOrder.attr,
1300 &iscsi_tpg_param_ErrorRecoveryLevel.attr,
1301 &iscsi_tpg_param_IFMarker.attr,
1302 &iscsi_tpg_param_OFMarker.attr,
1303 &iscsi_tpg_param_IFMarkInt.attr,
1304 &iscsi_tpg_param_OFMarkInt.attr,
1308 /* End items for lio_target_tpg_param_cit */
1310 /* Start items for lio_target_tpg_cit */
1312 static ssize_t lio_target_tpg_show_enable(
1313 struct se_portal_group *se_tpg,
1316 struct iscsi_portal_group *tpg = container_of(se_tpg,
1317 struct iscsi_portal_group, tpg_se_tpg);
1320 spin_lock(&tpg->tpg_state_lock);
1321 len = sprintf(page, "%d\n",
1322 (tpg->tpg_state == TPG_STATE_ACTIVE) ? 1 : 0);
1323 spin_unlock(&tpg->tpg_state_lock);
1328 static ssize_t lio_target_tpg_store_enable(
1329 struct se_portal_group *se_tpg,
1333 struct iscsi_portal_group *tpg = container_of(se_tpg,
1334 struct iscsi_portal_group, tpg_se_tpg);
1338 ret = kstrtou32(page, 0, &op);
1341 if ((op != 1) && (op != 0)) {
1342 pr_err("Illegal value for tpg_enable: %u\n", op);
1346 ret = iscsit_get_tpg(tpg);
1351 ret = iscsit_tpg_enable_portal_group(tpg);
1356 * iscsit_tpg_disable_portal_group() assumes force=1
1358 ret = iscsit_tpg_disable_portal_group(tpg, 1);
1363 iscsit_put_tpg(tpg);
1366 iscsit_put_tpg(tpg);
1370 TF_TPG_BASE_ATTR(lio_target, enable, S_IRUGO | S_IWUSR);
1372 static ssize_t lio_target_tpg_show_dynamic_sessions(
1373 struct se_portal_group *se_tpg,
1376 return target_show_dynamic_sessions(se_tpg, page);
1379 TF_TPG_BASE_ATTR_RO(lio_target, dynamic_sessions);
1381 static struct configfs_attribute *lio_target_tpg_attrs[] = {
1382 &lio_target_tpg_enable.attr,
1383 &lio_target_tpg_dynamic_sessions.attr,
1387 /* End items for lio_target_tpg_cit */
1389 /* Start items for lio_target_tiqn_cit */
1391 static struct se_portal_group *lio_target_tiqn_addtpg(
1393 struct config_group *group,
1396 struct iscsi_portal_group *tpg;
1397 struct iscsi_tiqn *tiqn;
1402 tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
1404 * Only tpgt_# directory groups can be created below
1405 * target/iscsi/iqn.superturodiskarry/
1407 tpgt_str = strstr(name, "tpgt_");
1409 pr_err("Unable to locate \"tpgt_#\" directory"
1413 tpgt_str += 5; /* Skip ahead of "tpgt_" */
1414 ret = kstrtou16(tpgt_str, 0, &tpgt);
1418 tpg = iscsit_alloc_portal_group(tiqn, tpgt);
1422 ret = core_tpg_register(wwn, &tpg->tpg_se_tpg, SCSI_PROTOCOL_ISCSI);
1426 ret = iscsit_tpg_add_portal_group(tiqn, tpg);
1430 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
1431 pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated TPG: %s\n",
1433 return &tpg->tpg_se_tpg;
1435 core_tpg_deregister(&tpg->tpg_se_tpg);
1440 static void lio_target_tiqn_deltpg(struct se_portal_group *se_tpg)
1442 struct iscsi_portal_group *tpg;
1443 struct iscsi_tiqn *tiqn;
1445 tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
1446 tiqn = tpg->tpg_tiqn;
1448 * iscsit_tpg_del_portal_group() assumes force=1
1450 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> Releasing TPG\n");
1451 iscsit_tpg_del_portal_group(tiqn, tpg, 1);
1454 /* End items for lio_target_tiqn_cit */
1456 /* Start LIO-Target TIQN struct contig_item lio_target_cit */
1458 static ssize_t lio_target_wwn_show_attr_lio_version(
1459 struct target_fabric_configfs *tf,
1462 return sprintf(page, "Datera Inc. iSCSI Target "ISCSIT_VERSION"\n");
1465 TF_WWN_ATTR_RO(lio_target, lio_version);
1467 static struct configfs_attribute *lio_target_wwn_attrs[] = {
1468 &lio_target_wwn_lio_version.attr,
1472 static struct se_wwn *lio_target_call_coreaddtiqn(
1473 struct target_fabric_configfs *tf,
1474 struct config_group *group,
1477 struct config_group *stats_cg;
1478 struct iscsi_tiqn *tiqn;
1480 tiqn = iscsit_add_tiqn((unsigned char *)name);
1482 return ERR_CAST(tiqn);
1484 * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group.
1486 stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;
1488 stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 6,
1490 if (!stats_cg->default_groups) {
1491 pr_err("Unable to allocate memory for"
1492 " stats_cg->default_groups\n");
1493 iscsit_del_tiqn(tiqn);
1494 return ERR_PTR(-ENOMEM);
1497 stats_cg->default_groups[0] = &tiqn->tiqn_stat_grps.iscsi_instance_group;
1498 stats_cg->default_groups[1] = &tiqn->tiqn_stat_grps.iscsi_sess_err_group;
1499 stats_cg->default_groups[2] = &tiqn->tiqn_stat_grps.iscsi_tgt_attr_group;
1500 stats_cg->default_groups[3] = &tiqn->tiqn_stat_grps.iscsi_login_stats_group;
1501 stats_cg->default_groups[4] = &tiqn->tiqn_stat_grps.iscsi_logout_stats_group;
1502 stats_cg->default_groups[5] = NULL;
1503 config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_instance_group,
1504 "iscsi_instance", &iscsi_stat_instance_cit);
1505 config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_sess_err_group,
1506 "iscsi_sess_err", &iscsi_stat_sess_err_cit);
1507 config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_tgt_attr_group,
1508 "iscsi_tgt_attr", &iscsi_stat_tgt_attr_cit);
1509 config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_login_stats_group,
1510 "iscsi_login_stats", &iscsi_stat_login_cit);
1511 config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_logout_stats_group,
1512 "iscsi_logout_stats", &iscsi_stat_logout_cit);
1514 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
1515 pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
1517 return &tiqn->tiqn_wwn;
1520 static void lio_target_call_coredeltiqn(
1523 struct iscsi_tiqn *tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
1524 struct config_item *df_item;
1525 struct config_group *stats_cg;
1528 stats_cg = &tiqn->tiqn_wwn.fabric_stat_group;
1529 for (i = 0; stats_cg->default_groups[i]; i++) {
1530 df_item = &stats_cg->default_groups[i]->cg_item;
1531 stats_cg->default_groups[i] = NULL;
1532 config_item_put(df_item);
1534 kfree(stats_cg->default_groups);
1536 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s\n",
1538 iscsit_del_tiqn(tiqn);
1541 /* End LIO-Target TIQN struct contig_lio_target_cit */
1543 /* Start lio_target_discovery_auth_cit */
1545 #define DEF_DISC_AUTH_STR(name, flags) \
1546 __DEF_NACL_AUTH_STR(disc, name, flags) \
1547 static ssize_t iscsi_disc_show_##name( \
1548 struct target_fabric_configfs *tf, \
1551 return __iscsi_disc_show_##name(&iscsit_global->discovery_acl, \
1554 static ssize_t iscsi_disc_store_##name( \
1555 struct target_fabric_configfs *tf, \
1559 return __iscsi_disc_store_##name(&iscsit_global->discovery_acl, \
1563 #define DEF_DISC_AUTH_INT(name) \
1564 __DEF_NACL_AUTH_INT(disc, name) \
1565 static ssize_t iscsi_disc_show_##name( \
1566 struct target_fabric_configfs *tf, \
1569 return __iscsi_disc_show_##name(&iscsit_global->discovery_acl, \
1573 #define DISC_AUTH_ATTR(_name, _mode) TF_DISC_ATTR(iscsi, _name, _mode)
1574 #define DISC_AUTH_ATTR_RO(_name) TF_DISC_ATTR_RO(iscsi, _name)
1577 * One-way authentication userid
1579 DEF_DISC_AUTH_STR(userid, NAF_USERID_SET);
1580 DISC_AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
1582 * One-way authentication password
1584 DEF_DISC_AUTH_STR(password, NAF_PASSWORD_SET);
1585 DISC_AUTH_ATTR(password, S_IRUGO | S_IWUSR);
1587 * Enforce mutual authentication
1589 DEF_DISC_AUTH_INT(authenticate_target);
1590 DISC_AUTH_ATTR_RO(authenticate_target);
1592 * Mutual authentication userid
1594 DEF_DISC_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
1595 DISC_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
1597 * Mutual authentication password
1599 DEF_DISC_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
1600 DISC_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
1603 * enforce_discovery_auth
1605 static ssize_t iscsi_disc_show_enforce_discovery_auth(
1606 struct target_fabric_configfs *tf,
1609 struct iscsi_node_auth *discovery_auth = &iscsit_global->discovery_acl.node_auth;
1611 return sprintf(page, "%d\n", discovery_auth->enforce_discovery_auth);
1614 static ssize_t iscsi_disc_store_enforce_discovery_auth(
1615 struct target_fabric_configfs *tf,
1619 struct iscsi_param *param;
1620 struct iscsi_portal_group *discovery_tpg = iscsit_global->discovery_tpg;
1624 err = kstrtou32(page, 0, &op);
1627 if ((op != 1) && (op != 0)) {
1628 pr_err("Illegal value for enforce_discovery_auth:"
1633 if (!discovery_tpg) {
1634 pr_err("iscsit_global->discovery_tpg is NULL\n");
1638 param = iscsi_find_param_from_key(AUTHMETHOD,
1639 discovery_tpg->param_list);
1645 * Reset the AuthMethod key to CHAP.
1647 if (iscsi_update_param_value(param, CHAP) < 0)
1650 discovery_tpg->tpg_attrib.authentication = 1;
1651 iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 1;
1652 pr_debug("LIO-CORE[0] Successfully enabled"
1653 " authentication enforcement for iSCSI"
1654 " Discovery TPG\n");
1657 * Reset the AuthMethod key to CHAP,None
1659 if (iscsi_update_param_value(param, "CHAP,None") < 0)
1662 discovery_tpg->tpg_attrib.authentication = 0;
1663 iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 0;
1664 pr_debug("LIO-CORE[0] Successfully disabled"
1665 " authentication enforcement for iSCSI"
1666 " Discovery TPG\n");
1672 DISC_AUTH_ATTR(enforce_discovery_auth, S_IRUGO | S_IWUSR);
1674 static struct configfs_attribute *lio_target_discovery_auth_attrs[] = {
1675 &iscsi_disc_userid.attr,
1676 &iscsi_disc_password.attr,
1677 &iscsi_disc_authenticate_target.attr,
1678 &iscsi_disc_userid_mutual.attr,
1679 &iscsi_disc_password_mutual.attr,
1680 &iscsi_disc_enforce_discovery_auth.attr,
1684 /* End lio_target_discovery_auth_cit */
1686 /* Start functions for target_core_fabric_ops */
1688 static char *iscsi_get_fabric_name(void)
1693 static int iscsi_get_cmd_state(struct se_cmd *se_cmd)
1695 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1697 return cmd->i_state;
1700 static u32 lio_sess_get_index(struct se_session *se_sess)
1702 struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1704 return sess->session_index;
1707 static u32 lio_sess_get_initiator_sid(
1708 struct se_session *se_sess,
1712 struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1714 * iSCSI Initiator Session Identifier from RFC-3720.
1716 return snprintf(buf, size, "%6phN", sess->isid);
1719 static int lio_queue_data_in(struct se_cmd *se_cmd)
1721 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1723 cmd->i_state = ISTATE_SEND_DATAIN;
1724 cmd->conn->conn_transport->iscsit_queue_data_in(cmd->conn, cmd);
1729 static int lio_write_pending(struct se_cmd *se_cmd)
1731 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1732 struct iscsi_conn *conn = cmd->conn;
1734 if (!cmd->immediate_data && !cmd->unsolicited_data)
1735 return conn->conn_transport->iscsit_get_dataout(conn, cmd, false);
1740 static int lio_write_pending_status(struct se_cmd *se_cmd)
1742 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1745 spin_lock_bh(&cmd->istate_lock);
1746 ret = !(cmd->cmd_flags & ICF_GOT_LAST_DATAOUT);
1747 spin_unlock_bh(&cmd->istate_lock);
1752 static int lio_queue_status(struct se_cmd *se_cmd)
1754 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1756 cmd->i_state = ISTATE_SEND_STATUS;
1758 if (cmd->se_cmd.scsi_status || cmd->sense_reason) {
1759 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
1762 cmd->conn->conn_transport->iscsit_queue_status(cmd->conn, cmd);
1767 static void lio_queue_tm_rsp(struct se_cmd *se_cmd)
1769 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1771 cmd->i_state = ISTATE_SEND_TASKMGTRSP;
1772 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
1775 static void lio_aborted_task(struct se_cmd *se_cmd)
1777 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1779 cmd->conn->conn_transport->iscsit_aborted_task(cmd->conn, cmd);
1782 static inline struct iscsi_portal_group *iscsi_tpg(struct se_portal_group *se_tpg)
1784 return container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
1787 static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg)
1789 return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn;
1792 static u16 lio_tpg_get_tag(struct se_portal_group *se_tpg)
1794 return iscsi_tpg(se_tpg)->tpgt;
1797 static u32 lio_tpg_get_default_depth(struct se_portal_group *se_tpg)
1799 return iscsi_tpg(se_tpg)->tpg_attrib.default_cmdsn_depth;
1802 static int lio_tpg_check_demo_mode(struct se_portal_group *se_tpg)
1804 return iscsi_tpg(se_tpg)->tpg_attrib.generate_node_acls;
1807 static int lio_tpg_check_demo_mode_cache(struct se_portal_group *se_tpg)
1809 return iscsi_tpg(se_tpg)->tpg_attrib.cache_dynamic_acls;
1812 static int lio_tpg_check_demo_mode_write_protect(
1813 struct se_portal_group *se_tpg)
1815 return iscsi_tpg(se_tpg)->tpg_attrib.demo_mode_write_protect;
1818 static int lio_tpg_check_prod_mode_write_protect(
1819 struct se_portal_group *se_tpg)
1821 return iscsi_tpg(se_tpg)->tpg_attrib.prod_mode_write_protect;
1824 static int lio_tpg_check_prot_fabric_only(
1825 struct se_portal_group *se_tpg)
1828 * Only report fabric_prot_type if t10_pi has also been enabled
1829 * for incoming ib_isert sessions.
1831 if (!iscsi_tpg(se_tpg)->tpg_attrib.t10_pi)
1833 return iscsi_tpg(se_tpg)->tpg_attrib.fabric_prot_type;
1837 * Called with spin_lock_bh(struct se_portal_group->session_lock) held..
1839 * Also, this function calls iscsit_inc_session_usage_count() on the
1840 * struct iscsi_session in question.
1842 static int lio_tpg_shutdown_session(struct se_session *se_sess)
1844 struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1846 spin_lock(&sess->conn_lock);
1847 if (atomic_read(&sess->session_fall_back_to_erl0) ||
1848 atomic_read(&sess->session_logout) ||
1849 (sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)) {
1850 spin_unlock(&sess->conn_lock);
1853 atomic_set(&sess->session_reinstatement, 1);
1854 spin_unlock(&sess->conn_lock);
1856 iscsit_stop_time2retain_timer(sess);
1857 iscsit_stop_session(sess, 1, 1);
1863 * Calls iscsit_dec_session_usage_count() as inverse of
1864 * lio_tpg_shutdown_session()
1866 static void lio_tpg_close_session(struct se_session *se_sess)
1868 struct iscsi_session *sess = se_sess->fabric_sess_ptr;
1870 * If the iSCSI Session for the iSCSI Initiator Node exists,
1871 * forcefully shutdown the iSCSI NEXUS.
1873 iscsit_close_session(sess);
1876 static u32 lio_tpg_get_inst_index(struct se_portal_group *se_tpg)
1878 return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn_index;
1881 static void lio_set_default_node_attributes(struct se_node_acl *se_acl)
1883 struct iscsi_node_acl *acl = container_of(se_acl, struct iscsi_node_acl,
1885 struct se_portal_group *se_tpg = se_acl->se_tpg;
1886 struct iscsi_portal_group *tpg = container_of(se_tpg,
1887 struct iscsi_portal_group, tpg_se_tpg);
1889 acl->node_attrib.nacl = acl;
1890 iscsit_set_default_node_attribues(acl, tpg);
1893 static int lio_check_stop_free(struct se_cmd *se_cmd)
1895 return target_put_sess_cmd(se_cmd);
1898 static void lio_release_cmd(struct se_cmd *se_cmd)
1900 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1902 pr_debug("Entering lio_release_cmd for se_cmd: %p\n", se_cmd);
1903 iscsit_release_cmd(cmd);
1906 const struct target_core_fabric_ops iscsi_ops = {
1907 .module = THIS_MODULE,
1909 .node_acl_size = sizeof(struct iscsi_node_acl),
1910 .get_fabric_name = iscsi_get_fabric_name,
1911 .tpg_get_wwn = lio_tpg_get_endpoint_wwn,
1912 .tpg_get_tag = lio_tpg_get_tag,
1913 .tpg_get_default_depth = lio_tpg_get_default_depth,
1914 .tpg_check_demo_mode = lio_tpg_check_demo_mode,
1915 .tpg_check_demo_mode_cache = lio_tpg_check_demo_mode_cache,
1916 .tpg_check_demo_mode_write_protect =
1917 lio_tpg_check_demo_mode_write_protect,
1918 .tpg_check_prod_mode_write_protect =
1919 lio_tpg_check_prod_mode_write_protect,
1920 .tpg_check_prot_fabric_only = &lio_tpg_check_prot_fabric_only,
1921 .tpg_get_inst_index = lio_tpg_get_inst_index,
1922 .check_stop_free = lio_check_stop_free,
1923 .release_cmd = lio_release_cmd,
1924 .shutdown_session = lio_tpg_shutdown_session,
1925 .close_session = lio_tpg_close_session,
1926 .sess_get_index = lio_sess_get_index,
1927 .sess_get_initiator_sid = lio_sess_get_initiator_sid,
1928 .write_pending = lio_write_pending,
1929 .write_pending_status = lio_write_pending_status,
1930 .set_default_node_attributes = lio_set_default_node_attributes,
1931 .get_cmd_state = iscsi_get_cmd_state,
1932 .queue_data_in = lio_queue_data_in,
1933 .queue_status = lio_queue_status,
1934 .queue_tm_rsp = lio_queue_tm_rsp,
1935 .aborted_task = lio_aborted_task,
1936 .fabric_make_wwn = lio_target_call_coreaddtiqn,
1937 .fabric_drop_wwn = lio_target_call_coredeltiqn,
1938 .fabric_make_tpg = lio_target_tiqn_addtpg,
1939 .fabric_drop_tpg = lio_target_tiqn_deltpg,
1940 .fabric_make_np = lio_target_call_addnptotpg,
1941 .fabric_drop_np = lio_target_call_delnpfromtpg,
1942 .fabric_init_nodeacl = lio_target_init_nodeacl,
1943 .fabric_cleanup_nodeacl = lio_target_cleanup_nodeacl,
1945 .tfc_discovery_attrs = lio_target_discovery_auth_attrs,
1946 .tfc_wwn_attrs = lio_target_wwn_attrs,
1947 .tfc_tpg_base_attrs = lio_target_tpg_attrs,
1948 .tfc_tpg_attrib_attrs = lio_target_tpg_attrib_attrs,
1949 .tfc_tpg_auth_attrs = lio_target_tpg_auth_attrs,
1950 .tfc_tpg_param_attrs = lio_target_tpg_param_attrs,
1951 .tfc_tpg_np_base_attrs = lio_target_portal_attrs,
1952 .tfc_tpg_nacl_base_attrs = lio_target_initiator_attrs,
1953 .tfc_tpg_nacl_attrib_attrs = lio_target_nacl_attrib_attrs,
1954 .tfc_tpg_nacl_auth_attrs = lio_target_nacl_auth_attrs,
1955 .tfc_tpg_nacl_param_attrs = lio_target_nacl_param_attrs,