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/configfs_macros.h> 28 #include <target/iscsi/iscsi_transport.h> 29 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> 39 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); 44 }; 45 46 /* Start items for lio_target_portal_cit */ 47 48 static ssize_t lio_target_np_show_sctp( 49 struct se_tpg_np *se_tpg_np, 50 char *page) 51 { 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; 55 ssize_t rb; 56 57 tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP); 58 if (tpg_np_sctp) 59 rb = sprintf(page, "1\n"); 60 else 61 rb = sprintf(page, "0\n"); 62 63 return rb; 64 } 65 66 static ssize_t lio_target_np_store_sctp( 67 struct se_tpg_np *se_tpg_np, 68 const char *page, 69 size_t count) 70 { 71 struct iscsi_np *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; 76 u32 op; 77 int ret; 78 79 ret = kstrtou32(page, 0, &op); 80 if (ret) 81 return ret; 82 if ((op != 1) && (op != 0)) { 83 pr_err("Illegal value for tpg_enable: %u\n", op); 84 return -EINVAL; 85 } 86 np = tpg_np->tpg_np; 87 if (!np) { 88 pr_err("Unable to locate struct iscsi_np from" 89 " struct iscsi_tpg_np\n"); 90 return -EINVAL; 91 } 92 93 tpg = tpg_np->tpg; 94 if (iscsit_get_tpg(tpg) < 0) 95 return -EINVAL; 96 97 if (op) { 98 /* 99 * Use existing np->np_sockaddr for SCTP network portal reference 100 */ 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)) 104 goto out; 105 } else { 106 tpg_np_sctp = iscsit_tpg_locate_child_np(tpg_np, ISCSI_SCTP_TCP); 107 if (!tpg_np_sctp) 108 goto out; 109 110 ret = iscsit_tpg_del_network_portal(tpg, tpg_np_sctp); 111 if (ret < 0) 112 goto out; 113 } 114 115 iscsit_put_tpg(tpg); 116 return count; 117 out: 118 iscsit_put_tpg(tpg); 119 return -EINVAL; 120 } 121 122 TF_NP_BASE_ATTR(lio_target, sctp, S_IRUGO | S_IWUSR); 123 124 static ssize_t lio_target_np_show_iser( 125 struct se_tpg_np *se_tpg_np, 126 char *page) 127 { 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; 131 ssize_t rb; 132 133 tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND); 134 if (tpg_np_iser) 135 rb = sprintf(page, "1\n"); 136 else 137 rb = sprintf(page, "0\n"); 138 139 return rb; 140 } 141 142 static ssize_t lio_target_np_store_iser( 143 struct se_tpg_np *se_tpg_np, 144 const char *page, 145 size_t count) 146 { 147 struct iscsi_np *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; 152 char *endptr; 153 u32 op; 154 int rc = 0; 155 156 op = simple_strtoul(page, &endptr, 0); 157 if ((op != 1) && (op != 0)) { 158 pr_err("Illegal value for tpg_enable: %u\n", op); 159 return -EINVAL; 160 } 161 np = tpg_np->tpg_np; 162 if (!np) { 163 pr_err("Unable to locate struct iscsi_np from" 164 " struct iscsi_tpg_np\n"); 165 return -EINVAL; 166 } 167 168 tpg = tpg_np->tpg; 169 if (iscsit_get_tpg(tpg) < 0) 170 return -EINVAL; 171 172 if (op) { 173 rc = request_module("ib_isert"); 174 if (rc != 0) { 175 pr_warn("Unable to request_module for ib_isert\n"); 176 rc = 0; 177 } 178 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); 183 goto out; 184 } 185 } else { 186 tpg_np_iser = iscsit_tpg_locate_child_np(tpg_np, ISCSI_INFINIBAND); 187 if (tpg_np_iser) { 188 rc = iscsit_tpg_del_network_portal(tpg, tpg_np_iser); 189 if (rc < 0) 190 goto out; 191 } 192 } 193 194 iscsit_put_tpg(tpg); 195 return count; 196 out: 197 iscsit_put_tpg(tpg); 198 return rc; 199 } 200 201 TF_NP_BASE_ATTR(lio_target, iser, S_IRUGO | S_IWUSR); 202 203 static struct configfs_attribute *lio_target_portal_attrs[] = { 204 &lio_target_np_sctp.attr, 205 &lio_target_np_iser.attr, 206 NULL, 207 }; 208 209 /* Stop items for lio_target_portal_cit */ 210 211 /* Start items for lio_target_np_cit */ 212 213 #define MAX_PORTAL_LEN 256 214 215 static struct se_tpg_np *lio_target_call_addnptotpg( 216 struct se_portal_group *se_tpg, 217 struct config_group *group, 218 const char *name) 219 { 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; 226 unsigned long port; 227 int ret; 228 char buf[MAX_PORTAL_LEN + 1]; 229 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); 234 } 235 memset(buf, 0, MAX_PORTAL_LEN + 1); 236 snprintf(buf, MAX_PORTAL_LEN + 1, "%s", name); 237 238 memset(&sockaddr, 0, sizeof(struct __kernel_sockaddr_storage)); 239 240 str = strstr(buf, "["); 241 if (str) { 242 const char *end; 243 244 str2 = strstr(str, "]"); 245 if (!str2) { 246 pr_err("Unable to locate trailing \"]\"" 247 " in IPv6 iSCSI network portal address\n"); 248 return ERR_PTR(-EINVAL); 249 } 250 str++; /* Skip over leading "[" */ 251 *str2 = '\0'; /* Terminate the IPv6 address */ 252 str2++; /* Skip over the "]" */ 253 port_str = strstr(str2, ":"); 254 if (!port_str) { 255 pr_err("Unable to locate \":port\"" 256 " in IPv6 iSCSI network portal address\n"); 257 return ERR_PTR(-EINVAL); 258 } 259 *port_str = '\0'; /* Terminate string for IP */ 260 port_str++; /* Skip over ":" */ 261 262 ret = kstrtoul(port_str, 0, &port); 263 if (ret < 0) { 264 pr_err("kstrtoul() failed for port_str: %d\n", ret); 265 return ERR_PTR(ret); 266 } 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); 272 if (ret <= 0) { 273 pr_err("in6_pton returned: %d\n", ret); 274 return ERR_PTR(-EINVAL); 275 } 276 } else { 277 str = ip_str = &buf[0]; 278 port_str = strstr(ip_str, ":"); 279 if (!port_str) { 280 pr_err("Unable to locate \":port\"" 281 " in IPv4 iSCSI network portal address\n"); 282 return ERR_PTR(-EINVAL); 283 } 284 *port_str = '\0'; /* Terminate string for IP */ 285 port_str++; /* Skip over ":" */ 286 287 ret = kstrtoul(port_str, 0, &port); 288 if (ret < 0) { 289 pr_err("kstrtoul() failed for port_str: %d\n", ret); 290 return ERR_PTR(ret); 291 } 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); 296 } 297 tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg); 298 ret = iscsit_get_tpg(tpg); 299 if (ret < 0) 300 return ERR_PTR(-EINVAL); 301 302 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s TPGT: %hu" 303 " PORTAL: %s\n", 304 config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item), 305 tpg->tpgt, name); 306 /* 307 * Assume ISCSI_TCP by default. Other network portals for other 308 * iSCSI fabrics: 309 * 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) 314 * 315 * can be enabled with attributes under 316 * sys/kernel/config/iscsi/$IQN/$TPG/np/$IP:$PORT/ 317 * 318 */ 319 tpg_np = iscsit_tpg_add_network_portal(tpg, &sockaddr, str, NULL, 320 ISCSI_TCP); 321 if (IS_ERR(tpg_np)) { 322 iscsit_put_tpg(tpg); 323 return ERR_CAST(tpg_np); 324 } 325 pr_debug("LIO_Target_ConfigFS: addnptotpg done!\n"); 326 327 iscsit_put_tpg(tpg); 328 return &tpg_np->se_tpg_np; 329 } 330 331 static void lio_target_call_delnpfromtpg( 332 struct se_tpg_np *se_tpg_np) 333 { 334 struct iscsi_portal_group *tpg; 335 struct iscsi_tpg_np *tpg_np; 336 struct se_portal_group *se_tpg; 337 int ret; 338 339 tpg_np = container_of(se_tpg_np, struct iscsi_tpg_np, se_tpg_np); 340 tpg = tpg_np->tpg; 341 ret = iscsit_get_tpg(tpg); 342 if (ret < 0) 343 return; 344 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); 349 350 ret = iscsit_tpg_del_network_portal(tpg, tpg_np); 351 if (ret < 0) 352 goto out; 353 354 pr_debug("LIO_Target_ConfigFS: delnpfromtpg done!\n"); 355 out: 356 iscsit_put_tpg(tpg); 357 } 358 359 /* End items for lio_target_np_cit */ 360 361 /* Start items for lio_target_nacl_attrib_cit */ 362 363 #define DEF_NACL_ATTRIB(name) \ 364 static ssize_t iscsi_nacl_attrib_show_##name( \ 365 struct se_node_acl *se_nacl, \ 366 char *page) \ 367 { \ 368 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \ 369 se_node_acl); \ 370 \ 371 return sprintf(page, "%u\n", nacl->node_attrib.name); \ 372 } \ 373 \ 374 static ssize_t iscsi_nacl_attrib_store_##name( \ 375 struct se_node_acl *se_nacl, \ 376 const char *page, \ 377 size_t count) \ 378 { \ 379 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \ 380 se_node_acl); \ 381 u32 val; \ 382 int ret; \ 383 \ 384 ret = kstrtou32(page, 0, &val); \ 385 if (ret) \ 386 return ret; \ 387 ret = iscsit_na_##name(nacl, val); \ 388 if (ret < 0) \ 389 return ret; \ 390 \ 391 return count; \ 392 } 393 394 #define NACL_ATTR(_name, _mode) TF_NACL_ATTRIB_ATTR(iscsi, _name, _mode); 395 /* 396 * Define iscsi_node_attrib_s_dataout_timeout 397 */ 398 DEF_NACL_ATTRIB(dataout_timeout); 399 NACL_ATTR(dataout_timeout, S_IRUGO | S_IWUSR); 400 /* 401 * Define iscsi_node_attrib_s_dataout_timeout_retries 402 */ 403 DEF_NACL_ATTRIB(dataout_timeout_retries); 404 NACL_ATTR(dataout_timeout_retries, S_IRUGO | S_IWUSR); 405 /* 406 * Define iscsi_node_attrib_s_default_erl 407 */ 408 DEF_NACL_ATTRIB(default_erl); 409 NACL_ATTR(default_erl, S_IRUGO | S_IWUSR); 410 /* 411 * Define iscsi_node_attrib_s_nopin_timeout 412 */ 413 DEF_NACL_ATTRIB(nopin_timeout); 414 NACL_ATTR(nopin_timeout, S_IRUGO | S_IWUSR); 415 /* 416 * Define iscsi_node_attrib_s_nopin_response_timeout 417 */ 418 DEF_NACL_ATTRIB(nopin_response_timeout); 419 NACL_ATTR(nopin_response_timeout, S_IRUGO | S_IWUSR); 420 /* 421 * Define iscsi_node_attrib_s_random_datain_pdu_offsets 422 */ 423 DEF_NACL_ATTRIB(random_datain_pdu_offsets); 424 NACL_ATTR(random_datain_pdu_offsets, S_IRUGO | S_IWUSR); 425 /* 426 * Define iscsi_node_attrib_s_random_datain_seq_offsets 427 */ 428 DEF_NACL_ATTRIB(random_datain_seq_offsets); 429 NACL_ATTR(random_datain_seq_offsets, S_IRUGO | S_IWUSR); 430 /* 431 * Define iscsi_node_attrib_s_random_r2t_offsets 432 */ 433 DEF_NACL_ATTRIB(random_r2t_offsets); 434 NACL_ATTR(random_r2t_offsets, S_IRUGO | S_IWUSR); 435 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, 445 NULL, 446 }; 447 448 /* End items for lio_target_nacl_attrib_cit */ 449 450 /* Start items for lio_target_nacl_auth_cit */ 451 452 #define __DEF_NACL_AUTH_STR(prefix, name, flags) \ 453 static ssize_t __iscsi_##prefix##_show_##name( \ 454 struct iscsi_node_acl *nacl, \ 455 char *page) \ 456 { \ 457 struct iscsi_node_auth *auth = &nacl->node_auth; \ 458 \ 459 if (!capable(CAP_SYS_ADMIN)) \ 460 return -EPERM; \ 461 return snprintf(page, PAGE_SIZE, "%s\n", auth->name); \ 462 } \ 463 \ 464 static ssize_t __iscsi_##prefix##_store_##name( \ 465 struct iscsi_node_acl *nacl, \ 466 const char *page, \ 467 size_t count) \ 468 { \ 469 struct iscsi_node_auth *auth = &nacl->node_auth; \ 470 \ 471 if (!capable(CAP_SYS_ADMIN)) \ 472 return -EPERM; \ 473 if (count >= sizeof(auth->name)) \ 474 return -EINVAL; \ 475 snprintf(auth->name, sizeof(auth->name), "%s", page); \ 476 if (!strncmp("NULL", auth->name, 4)) \ 477 auth->naf_flags &= ~flags; \ 478 else \ 479 auth->naf_flags |= flags; \ 480 \ 481 if ((auth->naf_flags & NAF_USERID_IN_SET) && \ 482 (auth->naf_flags & NAF_PASSWORD_IN_SET)) \ 483 auth->authenticate_target = 1; \ 484 else \ 485 auth->authenticate_target = 0; \ 486 \ 487 return count; \ 488 } 489 490 #define __DEF_NACL_AUTH_INT(prefix, name) \ 491 static ssize_t __iscsi_##prefix##_show_##name( \ 492 struct iscsi_node_acl *nacl, \ 493 char *page) \ 494 { \ 495 struct iscsi_node_auth *auth = &nacl->node_auth; \ 496 \ 497 if (!capable(CAP_SYS_ADMIN)) \ 498 return -EPERM; \ 499 \ 500 return snprintf(page, PAGE_SIZE, "%d\n", auth->name); \ 501 } 502 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, \ 507 char *page) \ 508 { \ 509 return __iscsi_nacl_auth_show_##name(container_of(nacl, \ 510 struct iscsi_node_acl, se_node_acl), page); \ 511 } \ 512 static ssize_t iscsi_nacl_auth_store_##name( \ 513 struct se_node_acl *nacl, \ 514 const char *page, \ 515 size_t count) \ 516 { \ 517 return __iscsi_nacl_auth_store_##name(container_of(nacl, \ 518 struct iscsi_node_acl, se_node_acl), page, count); \ 519 } 520 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, \ 525 char *page) \ 526 { \ 527 return __iscsi_nacl_auth_show_##name(container_of(nacl, \ 528 struct iscsi_node_acl, se_node_acl), page); \ 529 } 530 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); 533 534 /* 535 * One-way authentication userid 536 */ 537 DEF_NACL_AUTH_STR(userid, NAF_USERID_SET); 538 AUTH_ATTR(userid, S_IRUGO | S_IWUSR); 539 /* 540 * One-way authentication password 541 */ 542 DEF_NACL_AUTH_STR(password, NAF_PASSWORD_SET); 543 AUTH_ATTR(password, S_IRUGO | S_IWUSR); 544 /* 545 * Enforce mutual authentication 546 */ 547 DEF_NACL_AUTH_INT(authenticate_target); 548 AUTH_ATTR_RO(authenticate_target); 549 /* 550 * Mutual authentication userid 551 */ 552 DEF_NACL_AUTH_STR(userid_mutual, NAF_USERID_IN_SET); 553 AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR); 554 /* 555 * Mutual authentication password 556 */ 557 DEF_NACL_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET); 558 AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR); 559 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, 566 NULL, 567 }; 568 569 /* End items for lio_target_nacl_auth_cit */ 570 571 /* Start items for lio_target_nacl_param_cit */ 572 573 #define DEF_NACL_PARAM(name) \ 574 static ssize_t iscsi_nacl_param_show_##name( \ 575 struct se_node_acl *se_nacl, \ 576 char *page) \ 577 { \ 578 struct iscsi_session *sess; \ 579 struct se_session *se_sess; \ 580 ssize_t rb; \ 581 \ 582 spin_lock_bh(&se_nacl->nacl_sess_lock); \ 583 se_sess = se_nacl->nacl_sess; \ 584 if (!se_sess) { \ 585 rb = snprintf(page, PAGE_SIZE, \ 586 "No Active iSCSI Session\n"); \ 587 } else { \ 588 sess = se_sess->fabric_sess_ptr; \ 589 rb = snprintf(page, PAGE_SIZE, "%u\n", \ 590 (u32)sess->sess_ops->name); \ 591 } \ 592 spin_unlock_bh(&se_nacl->nacl_sess_lock); \ 593 \ 594 return rb; \ 595 } 596 597 #define NACL_PARAM_ATTR(_name) TF_NACL_PARAM_ATTR_RO(iscsi, _name); 598 599 DEF_NACL_PARAM(MaxConnections); 600 NACL_PARAM_ATTR(MaxConnections); 601 602 DEF_NACL_PARAM(InitialR2T); 603 NACL_PARAM_ATTR(InitialR2T); 604 605 DEF_NACL_PARAM(ImmediateData); 606 NACL_PARAM_ATTR(ImmediateData); 607 608 DEF_NACL_PARAM(MaxBurstLength); 609 NACL_PARAM_ATTR(MaxBurstLength); 610 611 DEF_NACL_PARAM(FirstBurstLength); 612 NACL_PARAM_ATTR(FirstBurstLength); 613 614 DEF_NACL_PARAM(DefaultTime2Wait); 615 NACL_PARAM_ATTR(DefaultTime2Wait); 616 617 DEF_NACL_PARAM(DefaultTime2Retain); 618 NACL_PARAM_ATTR(DefaultTime2Retain); 619 620 DEF_NACL_PARAM(MaxOutstandingR2T); 621 NACL_PARAM_ATTR(MaxOutstandingR2T); 622 623 DEF_NACL_PARAM(DataPDUInOrder); 624 NACL_PARAM_ATTR(DataPDUInOrder); 625 626 DEF_NACL_PARAM(DataSequenceInOrder); 627 NACL_PARAM_ATTR(DataSequenceInOrder); 628 629 DEF_NACL_PARAM(ErrorRecoveryLevel); 630 NACL_PARAM_ATTR(ErrorRecoveryLevel); 631 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, 644 NULL, 645 }; 646 647 /* End items for lio_target_nacl_param_cit */ 648 649 /* Start items for lio_target_acl_cit */ 650 651 static ssize_t lio_target_nacl_show_info( 652 struct se_node_acl *se_nacl, 653 char *page) 654 { 655 struct iscsi_session *sess; 656 struct iscsi_conn *conn; 657 struct se_session *se_sess; 658 ssize_t rb = 0; 659 660 spin_lock_bh(&se_nacl->nacl_sess_lock); 661 se_sess = se_nacl->nacl_sess; 662 if (!se_sess) { 663 rb += sprintf(page+rb, "No active iSCSI Session for Initiator" 664 " Endpoint: %s\n", se_nacl->initiatorname); 665 } else { 666 sess = se_sess->fabric_sess_ptr; 667 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); 672 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"); 683 break; 684 case TARG_SESS_STATE_ACTIVE: 685 rb += sprintf(page+rb, "TARG_SESS_STATE_ACTIVE\n"); 686 break; 687 case TARG_SESS_STATE_LOGGED_IN: 688 rb += sprintf(page+rb, "TARG_SESS_STATE_LOGGED_IN\n"); 689 break; 690 case TARG_SESS_STATE_FAILED: 691 rb += sprintf(page+rb, "TARG_SESS_STATE_FAILED\n"); 692 break; 693 case TARG_SESS_STATE_IN_CONTINUE: 694 rb += sprintf(page+rb, "TARG_SESS_STATE_IN_CONTINUE\n"); 695 break; 696 default: 697 rb += sprintf(page+rb, "ERROR: Unknown Session" 698 " State!\n"); 699 break; 700 } 701 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" 707 " 0x%08x 0x%08x\n", 708 sess->cmdsn_window, 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"); 714 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"); 723 break; 724 case TARG_CONN_STATE_XPT_UP: 725 rb += sprintf(page+rb, 726 "TARG_CONN_STATE_XPT_UP\n"); 727 break; 728 case TARG_CONN_STATE_IN_LOGIN: 729 rb += sprintf(page+rb, 730 "TARG_CONN_STATE_IN_LOGIN\n"); 731 break; 732 case TARG_CONN_STATE_LOGGED_IN: 733 rb += sprintf(page+rb, 734 "TARG_CONN_STATE_LOGGED_IN\n"); 735 break; 736 case TARG_CONN_STATE_IN_LOGOUT: 737 rb += sprintf(page+rb, 738 "TARG_CONN_STATE_IN_LOGOUT\n"); 739 break; 740 case TARG_CONN_STATE_LOGOUT_REQUESTED: 741 rb += sprintf(page+rb, 742 "TARG_CONN_STATE_LOGOUT_REQUESTED\n"); 743 break; 744 case TARG_CONN_STATE_CLEANUP_WAIT: 745 rb += sprintf(page+rb, 746 "TARG_CONN_STATE_CLEANUP_WAIT\n"); 747 break; 748 default: 749 rb += sprintf(page+rb, 750 "ERROR: Unknown Connection State!\n"); 751 break; 752 } 753 754 rb += sprintf(page+rb, " Address %s %s", conn->login_ip, 755 (conn->network_transport == ISCSI_TCP) ? 756 "TCP" : "SCTP"); 757 rb += sprintf(page+rb, " StatSN: 0x%08x\n", 758 conn->stat_sn); 759 } 760 spin_unlock(&sess->conn_lock); 761 } 762 spin_unlock_bh(&se_nacl->nacl_sess_lock); 763 764 return rb; 765 } 766 767 TF_NACL_BASE_ATTR_RO(lio_target, info); 768 769 static ssize_t lio_target_nacl_show_cmdsn_depth( 770 struct se_node_acl *se_nacl, 771 char *page) 772 { 773 return sprintf(page, "%u\n", se_nacl->queue_depth); 774 } 775 776 static ssize_t lio_target_nacl_store_cmdsn_depth( 777 struct se_node_acl *se_nacl, 778 const char *page, 779 size_t count) 780 { 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; 785 u32 cmdsn_depth = 0; 786 int ret; 787 788 ret = kstrtou32(page, 0, &cmdsn_depth); 789 if (ret) 790 return ret; 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); 795 return -EINVAL; 796 } 797 acl_ci = &se_nacl->acl_group.cg_item; 798 if (!acl_ci) { 799 pr_err("Unable to locatel acl_ci\n"); 800 return -EINVAL; 801 } 802 tpg_ci = &acl_ci->ci_parent->ci_group->cg_item; 803 if (!tpg_ci) { 804 pr_err("Unable to locate tpg_ci\n"); 805 return -EINVAL; 806 } 807 wwn_ci = &tpg_ci->ci_group->cg_item; 808 if (!wwn_ci) { 809 pr_err("Unable to locate config_item wwn_ci\n"); 810 return -EINVAL; 811 } 812 813 if (iscsit_get_tpg(tpg) < 0) 814 return -EINVAL; 815 /* 816 * iscsit_tpg_set_initiator_node_queue_depth() assumes force=1 817 */ 818 ret = iscsit_tpg_set_initiator_node_queue_depth(tpg, 819 config_item_name(acl_ci), cmdsn_depth, 1); 820 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)); 825 826 iscsit_put_tpg(tpg); 827 return (!ret) ? count : (ssize_t)ret; 828 } 829 830 TF_NACL_BASE_ATTR(lio_target, cmdsn_depth, S_IRUGO | S_IWUSR); 831 832 static ssize_t lio_target_nacl_show_tag( 833 struct se_node_acl *se_nacl, 834 char *page) 835 { 836 return snprintf(page, PAGE_SIZE, "%s", se_nacl->acl_tag); 837 } 838 839 static ssize_t lio_target_nacl_store_tag( 840 struct se_node_acl *se_nacl, 841 const char *page, 842 size_t count) 843 { 844 int ret; 845 846 ret = core_tpg_set_initiator_node_tag(se_nacl->se_tpg, se_nacl, page); 847 848 if (ret < 0) 849 return ret; 850 return count; 851 } 852 853 TF_NACL_BASE_ATTR(lio_target, tag, S_IRUGO | S_IWUSR); 854 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, 859 NULL, 860 }; 861 862 static int lio_target_init_nodeacl(struct se_node_acl *se_nacl, 863 const char *name) 864 { 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; 868 869 stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2, 870 GFP_KERNEL); 871 if (!stats_cg->default_groups) { 872 pr_err("Unable to allocate memory for" 873 " stats_cg->default_groups\n"); 874 return -ENOMEM; 875 } 876 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); 881 882 return 0; 883 } 884 885 static void lio_target_cleanup_nodeacl( struct se_node_acl *se_nacl) 886 { 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; 891 int i; 892 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); 898 } 899 kfree(stats_cg->default_groups); 900 } 901 902 /* End items for lio_target_acl_cit */ 903 904 /* Start items for lio_target_tpg_attrib_cit */ 905 906 #define DEF_TPG_ATTRIB(name) \ 907 \ 908 static ssize_t iscsi_tpg_attrib_show_##name( \ 909 struct se_portal_group *se_tpg, \ 910 char *page) \ 911 { \ 912 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 913 struct iscsi_portal_group, tpg_se_tpg); \ 914 ssize_t rb; \ 915 \ 916 if (iscsit_get_tpg(tpg) < 0) \ 917 return -EINVAL; \ 918 \ 919 rb = sprintf(page, "%u\n", tpg->tpg_attrib.name); \ 920 iscsit_put_tpg(tpg); \ 921 return rb; \ 922 } \ 923 \ 924 static ssize_t iscsi_tpg_attrib_store_##name( \ 925 struct se_portal_group *se_tpg, \ 926 const char *page, \ 927 size_t count) \ 928 { \ 929 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 930 struct iscsi_portal_group, tpg_se_tpg); \ 931 u32 val; \ 932 int ret; \ 933 \ 934 if (iscsit_get_tpg(tpg) < 0) \ 935 return -EINVAL; \ 936 \ 937 ret = kstrtou32(page, 0, &val); \ 938 if (ret) \ 939 goto out; \ 940 ret = iscsit_ta_##name(tpg, val); \ 941 if (ret < 0) \ 942 goto out; \ 943 \ 944 iscsit_put_tpg(tpg); \ 945 return count; \ 946 out: \ 947 iscsit_put_tpg(tpg); \ 948 return ret; \ 949 } 950 951 #define TPG_ATTR(_name, _mode) TF_TPG_ATTRIB_ATTR(iscsi, _name, _mode); 952 953 /* 954 * Define iscsi_tpg_attrib_s_authentication 955 */ 956 DEF_TPG_ATTRIB(authentication); 957 TPG_ATTR(authentication, S_IRUGO | S_IWUSR); 958 /* 959 * Define iscsi_tpg_attrib_s_login_timeout 960 */ 961 DEF_TPG_ATTRIB(login_timeout); 962 TPG_ATTR(login_timeout, S_IRUGO | S_IWUSR); 963 /* 964 * Define iscsi_tpg_attrib_s_netif_timeout 965 */ 966 DEF_TPG_ATTRIB(netif_timeout); 967 TPG_ATTR(netif_timeout, S_IRUGO | S_IWUSR); 968 /* 969 * Define iscsi_tpg_attrib_s_generate_node_acls 970 */ 971 DEF_TPG_ATTRIB(generate_node_acls); 972 TPG_ATTR(generate_node_acls, S_IRUGO | S_IWUSR); 973 /* 974 * Define iscsi_tpg_attrib_s_default_cmdsn_depth 975 */ 976 DEF_TPG_ATTRIB(default_cmdsn_depth); 977 TPG_ATTR(default_cmdsn_depth, S_IRUGO | S_IWUSR); 978 /* 979 Define iscsi_tpg_attrib_s_cache_dynamic_acls 980 */ 981 DEF_TPG_ATTRIB(cache_dynamic_acls); 982 TPG_ATTR(cache_dynamic_acls, S_IRUGO | S_IWUSR); 983 /* 984 * Define iscsi_tpg_attrib_s_demo_mode_write_protect 985 */ 986 DEF_TPG_ATTRIB(demo_mode_write_protect); 987 TPG_ATTR(demo_mode_write_protect, S_IRUGO | S_IWUSR); 988 /* 989 * Define iscsi_tpg_attrib_s_prod_mode_write_protect 990 */ 991 DEF_TPG_ATTRIB(prod_mode_write_protect); 992 TPG_ATTR(prod_mode_write_protect, S_IRUGO | S_IWUSR); 993 /* 994 * Define iscsi_tpg_attrib_s_demo_mode_discovery, 995 */ 996 DEF_TPG_ATTRIB(demo_mode_discovery); 997 TPG_ATTR(demo_mode_discovery, S_IRUGO | S_IWUSR); 998 /* 999 * Define iscsi_tpg_attrib_s_default_erl 1000 */ 1001 DEF_TPG_ATTRIB(default_erl); 1002 TPG_ATTR(default_erl, S_IRUGO | S_IWUSR); 1003 /* 1004 * Define iscsi_tpg_attrib_s_t10_pi 1005 */ 1006 DEF_TPG_ATTRIB(t10_pi); 1007 TPG_ATTR(t10_pi, S_IRUGO | S_IWUSR); 1008 /* 1009 * Define iscsi_tpg_attrib_s_fabric_prot_type 1010 */ 1011 DEF_TPG_ATTRIB(fabric_prot_type); 1012 TPG_ATTR(fabric_prot_type, S_IRUGO | S_IWUSR); 1013 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, 1027 NULL, 1028 }; 1029 1030 /* End items for lio_target_tpg_attrib_cit */ 1031 1032 /* Start items for lio_target_tpg_auth_cit */ 1033 1034 #define __DEF_TPG_AUTH_STR(prefix, name, flags) \ 1035 static ssize_t __iscsi_##prefix##_show_##name( \ 1036 struct se_portal_group *se_tpg, \ 1037 char *page) \ 1038 { \ 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; \ 1042 \ 1043 if (!capable(CAP_SYS_ADMIN)) \ 1044 return -EPERM; \ 1045 \ 1046 return snprintf(page, PAGE_SIZE, "%s\n", auth->name); \ 1047 } \ 1048 \ 1049 static ssize_t __iscsi_##prefix##_store_##name( \ 1050 struct se_portal_group *se_tpg, \ 1051 const char *page, \ 1052 size_t count) \ 1053 { \ 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; \ 1057 \ 1058 if (!capable(CAP_SYS_ADMIN)) \ 1059 return -EPERM; \ 1060 \ 1061 snprintf(auth->name, sizeof(auth->name), "%s", page); \ 1062 if (!(strncmp("NULL", auth->name, 4))) \ 1063 auth->naf_flags &= ~flags; \ 1064 else \ 1065 auth->naf_flags |= flags; \ 1066 \ 1067 if ((auth->naf_flags & NAF_USERID_IN_SET) && \ 1068 (auth->naf_flags & NAF_PASSWORD_IN_SET)) \ 1069 auth->authenticate_target = 1; \ 1070 else \ 1071 auth->authenticate_target = 0; \ 1072 \ 1073 return count; \ 1074 } 1075 1076 #define __DEF_TPG_AUTH_INT(prefix, name) \ 1077 static ssize_t __iscsi_##prefix##_show_##name( \ 1078 struct se_portal_group *se_tpg, \ 1079 char *page) \ 1080 { \ 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; \ 1084 \ 1085 if (!capable(CAP_SYS_ADMIN)) \ 1086 return -EPERM; \ 1087 \ 1088 return snprintf(page, PAGE_SIZE, "%d\n", auth->name); \ 1089 } 1090 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, \ 1095 char *page) \ 1096 { \ 1097 return __iscsi_tpg_auth_show_##name(se_tpg, page); \ 1098 } \ 1099 \ 1100 static ssize_t iscsi_tpg_auth_store_##name( \ 1101 struct se_portal_group *se_tpg, \ 1102 const char *page, \ 1103 size_t count) \ 1104 { \ 1105 return __iscsi_tpg_auth_store_##name(se_tpg, page, count); \ 1106 } 1107 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, \ 1112 char *page) \ 1113 { \ 1114 return __iscsi_tpg_auth_show_##name(se_tpg, page); \ 1115 } 1116 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); 1119 1120 /* 1121 * * One-way authentication userid 1122 * */ 1123 DEF_TPG_AUTH_STR(userid, NAF_USERID_SET); 1124 TPG_AUTH_ATTR(userid, S_IRUGO | S_IWUSR); 1125 /* 1126 * * One-way authentication password 1127 * */ 1128 DEF_TPG_AUTH_STR(password, NAF_PASSWORD_SET); 1129 TPG_AUTH_ATTR(password, S_IRUGO | S_IWUSR); 1130 /* 1131 * * Enforce mutual authentication 1132 * */ 1133 DEF_TPG_AUTH_INT(authenticate_target); 1134 TPG_AUTH_ATTR_RO(authenticate_target); 1135 /* 1136 * * Mutual authentication userid 1137 * */ 1138 DEF_TPG_AUTH_STR(userid_mutual, NAF_USERID_IN_SET); 1139 TPG_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR); 1140 /* 1141 * * Mutual authentication password 1142 * */ 1143 DEF_TPG_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET); 1144 TPG_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR); 1145 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, 1152 NULL, 1153 }; 1154 1155 /* End items for lio_target_tpg_auth_cit */ 1156 1157 /* Start items for lio_target_tpg_param_cit */ 1158 1159 #define DEF_TPG_PARAM(name) \ 1160 static ssize_t iscsi_tpg_param_show_##name( \ 1161 struct se_portal_group *se_tpg, \ 1162 char *page) \ 1163 { \ 1164 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 1165 struct iscsi_portal_group, tpg_se_tpg); \ 1166 struct iscsi_param *param; \ 1167 ssize_t rb; \ 1168 \ 1169 if (iscsit_get_tpg(tpg) < 0) \ 1170 return -EINVAL; \ 1171 \ 1172 param = iscsi_find_param_from_key(__stringify(name), \ 1173 tpg->param_list); \ 1174 if (!param) { \ 1175 iscsit_put_tpg(tpg); \ 1176 return -EINVAL; \ 1177 } \ 1178 rb = snprintf(page, PAGE_SIZE, "%s\n", param->value); \ 1179 \ 1180 iscsit_put_tpg(tpg); \ 1181 return rb; \ 1182 } \ 1183 static ssize_t iscsi_tpg_param_store_##name( \ 1184 struct se_portal_group *se_tpg, \ 1185 const char *page, \ 1186 size_t count) \ 1187 { \ 1188 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 1189 struct iscsi_portal_group, tpg_se_tpg); \ 1190 char *buf; \ 1191 int ret, len; \ 1192 \ 1193 buf = kzalloc(PAGE_SIZE, GFP_KERNEL); \ 1194 if (!buf) \ 1195 return -ENOMEM; \ 1196 len = snprintf(buf, PAGE_SIZE, "%s=%s", __stringify(name), page); \ 1197 if (isspace(buf[len-1])) \ 1198 buf[len-1] = '\0'; /* Kill newline */ \ 1199 \ 1200 if (iscsit_get_tpg(tpg) < 0) { \ 1201 kfree(buf); \ 1202 return -EINVAL; \ 1203 } \ 1204 \ 1205 ret = iscsi_change_param_value(buf, tpg->param_list, 1); \ 1206 if (ret < 0) \ 1207 goto out; \ 1208 \ 1209 kfree(buf); \ 1210 iscsit_put_tpg(tpg); \ 1211 return count; \ 1212 out: \ 1213 kfree(buf); \ 1214 iscsit_put_tpg(tpg); \ 1215 return -EINVAL; \ 1216 } 1217 1218 #define TPG_PARAM_ATTR(_name, _mode) TF_TPG_PARAM_ATTR(iscsi, _name, _mode); 1219 1220 DEF_TPG_PARAM(AuthMethod); 1221 TPG_PARAM_ATTR(AuthMethod, S_IRUGO | S_IWUSR); 1222 1223 DEF_TPG_PARAM(HeaderDigest); 1224 TPG_PARAM_ATTR(HeaderDigest, S_IRUGO | S_IWUSR); 1225 1226 DEF_TPG_PARAM(DataDigest); 1227 TPG_PARAM_ATTR(DataDigest, S_IRUGO | S_IWUSR); 1228 1229 DEF_TPG_PARAM(MaxConnections); 1230 TPG_PARAM_ATTR(MaxConnections, S_IRUGO | S_IWUSR); 1231 1232 DEF_TPG_PARAM(TargetAlias); 1233 TPG_PARAM_ATTR(TargetAlias, S_IRUGO | S_IWUSR); 1234 1235 DEF_TPG_PARAM(InitialR2T); 1236 TPG_PARAM_ATTR(InitialR2T, S_IRUGO | S_IWUSR); 1237 1238 DEF_TPG_PARAM(ImmediateData); 1239 TPG_PARAM_ATTR(ImmediateData, S_IRUGO | S_IWUSR); 1240 1241 DEF_TPG_PARAM(MaxRecvDataSegmentLength); 1242 TPG_PARAM_ATTR(MaxRecvDataSegmentLength, S_IRUGO | S_IWUSR); 1243 1244 DEF_TPG_PARAM(MaxXmitDataSegmentLength); 1245 TPG_PARAM_ATTR(MaxXmitDataSegmentLength, S_IRUGO | S_IWUSR); 1246 1247 DEF_TPG_PARAM(MaxBurstLength); 1248 TPG_PARAM_ATTR(MaxBurstLength, S_IRUGO | S_IWUSR); 1249 1250 DEF_TPG_PARAM(FirstBurstLength); 1251 TPG_PARAM_ATTR(FirstBurstLength, S_IRUGO | S_IWUSR); 1252 1253 DEF_TPG_PARAM(DefaultTime2Wait); 1254 TPG_PARAM_ATTR(DefaultTime2Wait, S_IRUGO | S_IWUSR); 1255 1256 DEF_TPG_PARAM(DefaultTime2Retain); 1257 TPG_PARAM_ATTR(DefaultTime2Retain, S_IRUGO | S_IWUSR); 1258 1259 DEF_TPG_PARAM(MaxOutstandingR2T); 1260 TPG_PARAM_ATTR(MaxOutstandingR2T, S_IRUGO | S_IWUSR); 1261 1262 DEF_TPG_PARAM(DataPDUInOrder); 1263 TPG_PARAM_ATTR(DataPDUInOrder, S_IRUGO | S_IWUSR); 1264 1265 DEF_TPG_PARAM(DataSequenceInOrder); 1266 TPG_PARAM_ATTR(DataSequenceInOrder, S_IRUGO | S_IWUSR); 1267 1268 DEF_TPG_PARAM(ErrorRecoveryLevel); 1269 TPG_PARAM_ATTR(ErrorRecoveryLevel, S_IRUGO | S_IWUSR); 1270 1271 DEF_TPG_PARAM(IFMarker); 1272 TPG_PARAM_ATTR(IFMarker, S_IRUGO | S_IWUSR); 1273 1274 DEF_TPG_PARAM(OFMarker); 1275 TPG_PARAM_ATTR(OFMarker, S_IRUGO | S_IWUSR); 1276 1277 DEF_TPG_PARAM(IFMarkInt); 1278 TPG_PARAM_ATTR(IFMarkInt, S_IRUGO | S_IWUSR); 1279 1280 DEF_TPG_PARAM(OFMarkInt); 1281 TPG_PARAM_ATTR(OFMarkInt, S_IRUGO | S_IWUSR); 1282 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, 1305 NULL, 1306 }; 1307 1308 /* End items for lio_target_tpg_param_cit */ 1309 1310 /* Start items for lio_target_tpg_cit */ 1311 1312 static ssize_t lio_target_tpg_show_enable( 1313 struct se_portal_group *se_tpg, 1314 char *page) 1315 { 1316 struct iscsi_portal_group *tpg = container_of(se_tpg, 1317 struct iscsi_portal_group, tpg_se_tpg); 1318 ssize_t len; 1319 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); 1324 1325 return len; 1326 } 1327 1328 static ssize_t lio_target_tpg_store_enable( 1329 struct se_portal_group *se_tpg, 1330 const char *page, 1331 size_t count) 1332 { 1333 struct iscsi_portal_group *tpg = container_of(se_tpg, 1334 struct iscsi_portal_group, tpg_se_tpg); 1335 u32 op; 1336 int ret; 1337 1338 ret = kstrtou32(page, 0, &op); 1339 if (ret) 1340 return ret; 1341 if ((op != 1) && (op != 0)) { 1342 pr_err("Illegal value for tpg_enable: %u\n", op); 1343 return -EINVAL; 1344 } 1345 1346 ret = iscsit_get_tpg(tpg); 1347 if (ret < 0) 1348 return -EINVAL; 1349 1350 if (op) { 1351 ret = iscsit_tpg_enable_portal_group(tpg); 1352 if (ret < 0) 1353 goto out; 1354 } else { 1355 /* 1356 * iscsit_tpg_disable_portal_group() assumes force=1 1357 */ 1358 ret = iscsit_tpg_disable_portal_group(tpg, 1); 1359 if (ret < 0) 1360 goto out; 1361 } 1362 1363 iscsit_put_tpg(tpg); 1364 return count; 1365 out: 1366 iscsit_put_tpg(tpg); 1367 return -EINVAL; 1368 } 1369 1370 TF_TPG_BASE_ATTR(lio_target, enable, S_IRUGO | S_IWUSR); 1371 1372 static ssize_t lio_target_tpg_show_dynamic_sessions( 1373 struct se_portal_group *se_tpg, 1374 char *page) 1375 { 1376 return target_show_dynamic_sessions(se_tpg, page); 1377 } 1378 1379 TF_TPG_BASE_ATTR_RO(lio_target, dynamic_sessions); 1380 1381 static struct configfs_attribute *lio_target_tpg_attrs[] = { 1382 &lio_target_tpg_enable.attr, 1383 &lio_target_tpg_dynamic_sessions.attr, 1384 NULL, 1385 }; 1386 1387 /* End items for lio_target_tpg_cit */ 1388 1389 /* Start items for lio_target_tiqn_cit */ 1390 1391 static struct se_portal_group *lio_target_tiqn_addtpg( 1392 struct se_wwn *wwn, 1393 struct config_group *group, 1394 const char *name) 1395 { 1396 struct iscsi_portal_group *tpg; 1397 struct iscsi_tiqn *tiqn; 1398 char *tpgt_str; 1399 int ret; 1400 u16 tpgt; 1401 1402 tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn); 1403 /* 1404 * Only tpgt_# directory groups can be created below 1405 * target/iscsi/iqn.superturodiskarry/ 1406 */ 1407 tpgt_str = strstr(name, "tpgt_"); 1408 if (!tpgt_str) { 1409 pr_err("Unable to locate \"tpgt_#\" directory" 1410 " group\n"); 1411 return NULL; 1412 } 1413 tpgt_str += 5; /* Skip ahead of "tpgt_" */ 1414 ret = kstrtou16(tpgt_str, 0, &tpgt); 1415 if (ret) 1416 return NULL; 1417 1418 tpg = iscsit_alloc_portal_group(tiqn, tpgt); 1419 if (!tpg) 1420 return NULL; 1421 1422 ret = core_tpg_register(wwn, &tpg->tpg_se_tpg, SCSI_PROTOCOL_ISCSI); 1423 if (ret < 0) 1424 return NULL; 1425 1426 ret = iscsit_tpg_add_portal_group(tiqn, tpg); 1427 if (ret != 0) 1428 goto out; 1429 1430 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn); 1431 pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated TPG: %s\n", 1432 name); 1433 return &tpg->tpg_se_tpg; 1434 out: 1435 core_tpg_deregister(&tpg->tpg_se_tpg); 1436 kfree(tpg); 1437 return NULL; 1438 } 1439 1440 static void lio_target_tiqn_deltpg(struct se_portal_group *se_tpg) 1441 { 1442 struct iscsi_portal_group *tpg; 1443 struct iscsi_tiqn *tiqn; 1444 1445 tpg = container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg); 1446 tiqn = tpg->tpg_tiqn; 1447 /* 1448 * iscsit_tpg_del_portal_group() assumes force=1 1449 */ 1450 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> Releasing TPG\n"); 1451 iscsit_tpg_del_portal_group(tiqn, tpg, 1); 1452 } 1453 1454 /* End items for lio_target_tiqn_cit */ 1455 1456 /* Start LIO-Target TIQN struct contig_item lio_target_cit */ 1457 1458 static ssize_t lio_target_wwn_show_attr_lio_version( 1459 struct target_fabric_configfs *tf, 1460 char *page) 1461 { 1462 return sprintf(page, "Datera Inc. iSCSI Target "ISCSIT_VERSION"\n"); 1463 } 1464 1465 TF_WWN_ATTR_RO(lio_target, lio_version); 1466 1467 static struct configfs_attribute *lio_target_wwn_attrs[] = { 1468 &lio_target_wwn_lio_version.attr, 1469 NULL, 1470 }; 1471 1472 static struct se_wwn *lio_target_call_coreaddtiqn( 1473 struct target_fabric_configfs *tf, 1474 struct config_group *group, 1475 const char *name) 1476 { 1477 struct config_group *stats_cg; 1478 struct iscsi_tiqn *tiqn; 1479 1480 tiqn = iscsit_add_tiqn((unsigned char *)name); 1481 if (IS_ERR(tiqn)) 1482 return ERR_CAST(tiqn); 1483 /* 1484 * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group. 1485 */ 1486 stats_cg = &tiqn->tiqn_wwn.fabric_stat_group; 1487 1488 stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 6, 1489 GFP_KERNEL); 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); 1495 } 1496 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); 1513 1514 pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn); 1515 pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:" 1516 " %s\n", name); 1517 return &tiqn->tiqn_wwn; 1518 } 1519 1520 static void lio_target_call_coredeltiqn( 1521 struct se_wwn *wwn) 1522 { 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; 1526 int i; 1527 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); 1533 } 1534 kfree(stats_cg->default_groups); 1535 1536 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s\n", 1537 tiqn->tiqn); 1538 iscsit_del_tiqn(tiqn); 1539 } 1540 1541 /* End LIO-Target TIQN struct contig_lio_target_cit */ 1542 1543 /* Start lio_target_discovery_auth_cit */ 1544 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, \ 1549 char *page) \ 1550 { \ 1551 return __iscsi_disc_show_##name(&iscsit_global->discovery_acl, \ 1552 page); \ 1553 } \ 1554 static ssize_t iscsi_disc_store_##name( \ 1555 struct target_fabric_configfs *tf, \ 1556 const char *page, \ 1557 size_t count) \ 1558 { \ 1559 return __iscsi_disc_store_##name(&iscsit_global->discovery_acl, \ 1560 page, count); \ 1561 } 1562 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, \ 1567 char *page) \ 1568 { \ 1569 return __iscsi_disc_show_##name(&iscsit_global->discovery_acl, \ 1570 page); \ 1571 } 1572 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) 1575 1576 /* 1577 * One-way authentication userid 1578 */ 1579 DEF_DISC_AUTH_STR(userid, NAF_USERID_SET); 1580 DISC_AUTH_ATTR(userid, S_IRUGO | S_IWUSR); 1581 /* 1582 * One-way authentication password 1583 */ 1584 DEF_DISC_AUTH_STR(password, NAF_PASSWORD_SET); 1585 DISC_AUTH_ATTR(password, S_IRUGO | S_IWUSR); 1586 /* 1587 * Enforce mutual authentication 1588 */ 1589 DEF_DISC_AUTH_INT(authenticate_target); 1590 DISC_AUTH_ATTR_RO(authenticate_target); 1591 /* 1592 * Mutual authentication userid 1593 */ 1594 DEF_DISC_AUTH_STR(userid_mutual, NAF_USERID_IN_SET); 1595 DISC_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR); 1596 /* 1597 * Mutual authentication password 1598 */ 1599 DEF_DISC_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET); 1600 DISC_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR); 1601 1602 /* 1603 * enforce_discovery_auth 1604 */ 1605 static ssize_t iscsi_disc_show_enforce_discovery_auth( 1606 struct target_fabric_configfs *tf, 1607 char *page) 1608 { 1609 struct iscsi_node_auth *discovery_auth = &iscsit_global->discovery_acl.node_auth; 1610 1611 return sprintf(page, "%d\n", discovery_auth->enforce_discovery_auth); 1612 } 1613 1614 static ssize_t iscsi_disc_store_enforce_discovery_auth( 1615 struct target_fabric_configfs *tf, 1616 const char *page, 1617 size_t count) 1618 { 1619 struct iscsi_param *param; 1620 struct iscsi_portal_group *discovery_tpg = iscsit_global->discovery_tpg; 1621 u32 op; 1622 int err; 1623 1624 err = kstrtou32(page, 0, &op); 1625 if (err) 1626 return -EINVAL; 1627 if ((op != 1) && (op != 0)) { 1628 pr_err("Illegal value for enforce_discovery_auth:" 1629 " %u\n", op); 1630 return -EINVAL; 1631 } 1632 1633 if (!discovery_tpg) { 1634 pr_err("iscsit_global->discovery_tpg is NULL\n"); 1635 return -EINVAL; 1636 } 1637 1638 param = iscsi_find_param_from_key(AUTHMETHOD, 1639 discovery_tpg->param_list); 1640 if (!param) 1641 return -EINVAL; 1642 1643 if (op) { 1644 /* 1645 * Reset the AuthMethod key to CHAP. 1646 */ 1647 if (iscsi_update_param_value(param, CHAP) < 0) 1648 return -EINVAL; 1649 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"); 1655 } else { 1656 /* 1657 * Reset the AuthMethod key to CHAP,None 1658 */ 1659 if (iscsi_update_param_value(param, "CHAP,None") < 0) 1660 return -EINVAL; 1661 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"); 1667 } 1668 1669 return count; 1670 } 1671 1672 DISC_AUTH_ATTR(enforce_discovery_auth, S_IRUGO | S_IWUSR); 1673 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, 1681 NULL, 1682 }; 1683 1684 /* End lio_target_discovery_auth_cit */ 1685 1686 /* Start functions for target_core_fabric_ops */ 1687 1688 static char *iscsi_get_fabric_name(void) 1689 { 1690 return "iSCSI"; 1691 } 1692 1693 static int iscsi_get_cmd_state(struct se_cmd *se_cmd) 1694 { 1695 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1696 1697 return cmd->i_state; 1698 } 1699 1700 static u32 lio_sess_get_index(struct se_session *se_sess) 1701 { 1702 struct iscsi_session *sess = se_sess->fabric_sess_ptr; 1703 1704 return sess->session_index; 1705 } 1706 1707 static u32 lio_sess_get_initiator_sid( 1708 struct se_session *se_sess, 1709 unsigned char *buf, 1710 u32 size) 1711 { 1712 struct iscsi_session *sess = se_sess->fabric_sess_ptr; 1713 /* 1714 * iSCSI Initiator Session Identifier from RFC-3720. 1715 */ 1716 return snprintf(buf, size, "%6phN", sess->isid); 1717 } 1718 1719 static int lio_queue_data_in(struct se_cmd *se_cmd) 1720 { 1721 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1722 1723 cmd->i_state = ISTATE_SEND_DATAIN; 1724 cmd->conn->conn_transport->iscsit_queue_data_in(cmd->conn, cmd); 1725 1726 return 0; 1727 } 1728 1729 static int lio_write_pending(struct se_cmd *se_cmd) 1730 { 1731 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1732 struct iscsi_conn *conn = cmd->conn; 1733 1734 if (!cmd->immediate_data && !cmd->unsolicited_data) 1735 return conn->conn_transport->iscsit_get_dataout(conn, cmd, false); 1736 1737 return 0; 1738 } 1739 1740 static int lio_write_pending_status(struct se_cmd *se_cmd) 1741 { 1742 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1743 int ret; 1744 1745 spin_lock_bh(&cmd->istate_lock); 1746 ret = !(cmd->cmd_flags & ICF_GOT_LAST_DATAOUT); 1747 spin_unlock_bh(&cmd->istate_lock); 1748 1749 return ret; 1750 } 1751 1752 static int lio_queue_status(struct se_cmd *se_cmd) 1753 { 1754 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1755 1756 cmd->i_state = ISTATE_SEND_STATUS; 1757 1758 if (cmd->se_cmd.scsi_status || cmd->sense_reason) { 1759 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state); 1760 return 0; 1761 } 1762 cmd->conn->conn_transport->iscsit_queue_status(cmd->conn, cmd); 1763 1764 return 0; 1765 } 1766 1767 static void lio_queue_tm_rsp(struct se_cmd *se_cmd) 1768 { 1769 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1770 1771 cmd->i_state = ISTATE_SEND_TASKMGTRSP; 1772 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state); 1773 } 1774 1775 static void lio_aborted_task(struct se_cmd *se_cmd) 1776 { 1777 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1778 1779 cmd->conn->conn_transport->iscsit_aborted_task(cmd->conn, cmd); 1780 } 1781 1782 static inline struct iscsi_portal_group *iscsi_tpg(struct se_portal_group *se_tpg) 1783 { 1784 return container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg); 1785 } 1786 1787 static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg) 1788 { 1789 return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn; 1790 } 1791 1792 static u16 lio_tpg_get_tag(struct se_portal_group *se_tpg) 1793 { 1794 return iscsi_tpg(se_tpg)->tpgt; 1795 } 1796 1797 static u32 lio_tpg_get_default_depth(struct se_portal_group *se_tpg) 1798 { 1799 return iscsi_tpg(se_tpg)->tpg_attrib.default_cmdsn_depth; 1800 } 1801 1802 static int lio_tpg_check_demo_mode(struct se_portal_group *se_tpg) 1803 { 1804 return iscsi_tpg(se_tpg)->tpg_attrib.generate_node_acls; 1805 } 1806 1807 static int lio_tpg_check_demo_mode_cache(struct se_portal_group *se_tpg) 1808 { 1809 return iscsi_tpg(se_tpg)->tpg_attrib.cache_dynamic_acls; 1810 } 1811 1812 static int lio_tpg_check_demo_mode_write_protect( 1813 struct se_portal_group *se_tpg) 1814 { 1815 return iscsi_tpg(se_tpg)->tpg_attrib.demo_mode_write_protect; 1816 } 1817 1818 static int lio_tpg_check_prod_mode_write_protect( 1819 struct se_portal_group *se_tpg) 1820 { 1821 return iscsi_tpg(se_tpg)->tpg_attrib.prod_mode_write_protect; 1822 } 1823 1824 static int lio_tpg_check_prot_fabric_only( 1825 struct se_portal_group *se_tpg) 1826 { 1827 /* 1828 * Only report fabric_prot_type if t10_pi has also been enabled 1829 * for incoming ib_isert sessions. 1830 */ 1831 if (!iscsi_tpg(se_tpg)->tpg_attrib.t10_pi) 1832 return 0; 1833 return iscsi_tpg(se_tpg)->tpg_attrib.fabric_prot_type; 1834 } 1835 1836 /* 1837 * Called with spin_lock_bh(struct se_portal_group->session_lock) held.. 1838 * 1839 * Also, this function calls iscsit_inc_session_usage_count() on the 1840 * struct iscsi_session in question. 1841 */ 1842 static int lio_tpg_shutdown_session(struct se_session *se_sess) 1843 { 1844 struct iscsi_session *sess = se_sess->fabric_sess_ptr; 1845 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); 1851 return 0; 1852 } 1853 atomic_set(&sess->session_reinstatement, 1); 1854 spin_unlock(&sess->conn_lock); 1855 1856 iscsit_stop_time2retain_timer(sess); 1857 iscsit_stop_session(sess, 1, 1); 1858 1859 return 1; 1860 } 1861 1862 /* 1863 * Calls iscsit_dec_session_usage_count() as inverse of 1864 * lio_tpg_shutdown_session() 1865 */ 1866 static void lio_tpg_close_session(struct se_session *se_sess) 1867 { 1868 struct iscsi_session *sess = se_sess->fabric_sess_ptr; 1869 /* 1870 * If the iSCSI Session for the iSCSI Initiator Node exists, 1871 * forcefully shutdown the iSCSI NEXUS. 1872 */ 1873 iscsit_close_session(sess); 1874 } 1875 1876 static u32 lio_tpg_get_inst_index(struct se_portal_group *se_tpg) 1877 { 1878 return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn_index; 1879 } 1880 1881 static void lio_set_default_node_attributes(struct se_node_acl *se_acl) 1882 { 1883 struct iscsi_node_acl *acl = container_of(se_acl, struct iscsi_node_acl, 1884 se_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); 1888 1889 acl->node_attrib.nacl = acl; 1890 iscsit_set_default_node_attribues(acl, tpg); 1891 } 1892 1893 static int lio_check_stop_free(struct se_cmd *se_cmd) 1894 { 1895 return target_put_sess_cmd(se_cmd); 1896 } 1897 1898 static void lio_release_cmd(struct se_cmd *se_cmd) 1899 { 1900 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1901 1902 pr_debug("Entering lio_release_cmd for se_cmd: %p\n", se_cmd); 1903 iscsit_release_cmd(cmd); 1904 } 1905 1906 const struct target_core_fabric_ops iscsi_ops = { 1907 .module = THIS_MODULE, 1908 .name = "iscsi", 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, 1944 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, 1956 }; 1957