1 /* 2 * SBP2 target driver (SCSI over IEEE1394 in target mode) 3 * 4 * Copyright (C) 2011 Chris Boot <bootc@bootc.net> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software Foundation, 18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 */ 20 21 #define KMSG_COMPONENT "sbp_target" 22 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 23 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/init.h> 27 #include <linux/types.h> 28 #include <linux/string.h> 29 #include <linux/configfs.h> 30 #include <linux/ctype.h> 31 #include <linux/firewire.h> 32 #include <linux/firewire-constants.h> 33 #include <scsi/scsi.h> 34 #include <scsi/scsi_tcq.h> 35 #include <target/target_core_base.h> 36 #include <target/target_core_backend.h> 37 #include <target/target_core_fabric.h> 38 #include <target/target_core_fabric_configfs.h> 39 #include <target/target_core_configfs.h> 40 #include <target/configfs_macros.h> 41 #include <asm/unaligned.h> 42 43 #include "sbp_target.h" 44 45 static const struct target_core_fabric_ops sbp_ops; 46 47 /* FireWire address region for management and command block address handlers */ 48 static const struct fw_address_region sbp_register_region = { 49 .start = CSR_REGISTER_BASE + 0x10000, 50 .end = 0x1000000000000ULL, 51 }; 52 53 static const u32 sbp_unit_directory_template[] = { 54 0x1200609e, /* unit_specifier_id: NCITS/T10 */ 55 0x13010483, /* unit_sw_version: 1155D Rev 4 */ 56 0x3800609e, /* command_set_specifier_id: NCITS/T10 */ 57 0x390104d8, /* command_set: SPC-2 */ 58 0x3b000000, /* command_set_revision: 0 */ 59 0x3c000001, /* firmware_revision: 1 */ 60 }; 61 62 #define SESSION_MAINTENANCE_INTERVAL HZ 63 64 static atomic_t login_id = ATOMIC_INIT(0); 65 66 static void session_maintenance_work(struct work_struct *); 67 static int sbp_run_transaction(struct fw_card *, int, int, int, int, 68 unsigned long long, void *, size_t); 69 70 static int read_peer_guid(u64 *guid, const struct sbp_management_request *req) 71 { 72 int ret; 73 __be32 high, low; 74 75 ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST, 76 req->node_addr, req->generation, req->speed, 77 (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4, 78 &high, sizeof(high)); 79 if (ret != RCODE_COMPLETE) 80 return ret; 81 82 ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST, 83 req->node_addr, req->generation, req->speed, 84 (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4, 85 &low, sizeof(low)); 86 if (ret != RCODE_COMPLETE) 87 return ret; 88 89 *guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low); 90 91 return RCODE_COMPLETE; 92 } 93 94 static struct sbp_session *sbp_session_find_by_guid( 95 struct sbp_tpg *tpg, u64 guid) 96 { 97 struct se_session *se_sess; 98 struct sbp_session *sess, *found = NULL; 99 100 spin_lock_bh(&tpg->se_tpg.session_lock); 101 list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) { 102 sess = se_sess->fabric_sess_ptr; 103 if (sess->guid == guid) 104 found = sess; 105 } 106 spin_unlock_bh(&tpg->se_tpg.session_lock); 107 108 return found; 109 } 110 111 static struct sbp_login_descriptor *sbp_login_find_by_lun( 112 struct sbp_session *session, struct se_lun *lun) 113 { 114 struct sbp_login_descriptor *login, *found = NULL; 115 116 spin_lock_bh(&session->lock); 117 list_for_each_entry(login, &session->login_list, link) { 118 if (login->lun == lun) 119 found = login; 120 } 121 spin_unlock_bh(&session->lock); 122 123 return found; 124 } 125 126 static int sbp_login_count_all_by_lun( 127 struct sbp_tpg *tpg, 128 struct se_lun *lun, 129 int exclusive) 130 { 131 struct se_session *se_sess; 132 struct sbp_session *sess; 133 struct sbp_login_descriptor *login; 134 int count = 0; 135 136 spin_lock_bh(&tpg->se_tpg.session_lock); 137 list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) { 138 sess = se_sess->fabric_sess_ptr; 139 140 spin_lock_bh(&sess->lock); 141 list_for_each_entry(login, &sess->login_list, link) { 142 if (login->lun != lun) 143 continue; 144 145 if (!exclusive || login->exclusive) 146 count++; 147 } 148 spin_unlock_bh(&sess->lock); 149 } 150 spin_unlock_bh(&tpg->se_tpg.session_lock); 151 152 return count; 153 } 154 155 static struct sbp_login_descriptor *sbp_login_find_by_id( 156 struct sbp_tpg *tpg, int login_id) 157 { 158 struct se_session *se_sess; 159 struct sbp_session *sess; 160 struct sbp_login_descriptor *login, *found = NULL; 161 162 spin_lock_bh(&tpg->se_tpg.session_lock); 163 list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) { 164 sess = se_sess->fabric_sess_ptr; 165 166 spin_lock_bh(&sess->lock); 167 list_for_each_entry(login, &sess->login_list, link) { 168 if (login->login_id == login_id) 169 found = login; 170 } 171 spin_unlock_bh(&sess->lock); 172 } 173 spin_unlock_bh(&tpg->se_tpg.session_lock); 174 175 return found; 176 } 177 178 static struct se_lun *sbp_get_lun_from_tpg(struct sbp_tpg *tpg, int lun) 179 { 180 struct se_portal_group *se_tpg = &tpg->se_tpg; 181 struct se_lun *se_lun; 182 183 if (lun >= TRANSPORT_MAX_LUNS_PER_TPG) 184 return ERR_PTR(-EINVAL); 185 186 spin_lock(&se_tpg->tpg_lun_lock); 187 se_lun = se_tpg->tpg_lun_list[lun]; 188 189 if (se_lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) 190 se_lun = ERR_PTR(-ENODEV); 191 192 spin_unlock(&se_tpg->tpg_lun_lock); 193 194 return se_lun; 195 } 196 197 static struct sbp_session *sbp_session_create( 198 struct sbp_tpg *tpg, 199 u64 guid) 200 { 201 struct sbp_session *sess; 202 int ret; 203 char guid_str[17]; 204 struct se_node_acl *se_nacl; 205 206 sess = kmalloc(sizeof(*sess), GFP_KERNEL); 207 if (!sess) { 208 pr_err("failed to allocate session descriptor\n"); 209 return ERR_PTR(-ENOMEM); 210 } 211 212 sess->se_sess = transport_init_session(TARGET_PROT_NORMAL); 213 if (IS_ERR(sess->se_sess)) { 214 pr_err("failed to init se_session\n"); 215 216 ret = PTR_ERR(sess->se_sess); 217 kfree(sess); 218 return ERR_PTR(ret); 219 } 220 221 snprintf(guid_str, sizeof(guid_str), "%016llx", guid); 222 223 se_nacl = core_tpg_check_initiator_node_acl(&tpg->se_tpg, guid_str); 224 if (!se_nacl) { 225 pr_warn("Node ACL not found for %s\n", guid_str); 226 227 transport_free_session(sess->se_sess); 228 kfree(sess); 229 230 return ERR_PTR(-EPERM); 231 } 232 233 sess->se_sess->se_node_acl = se_nacl; 234 235 spin_lock_init(&sess->lock); 236 INIT_LIST_HEAD(&sess->login_list); 237 INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work); 238 239 sess->guid = guid; 240 241 transport_register_session(&tpg->se_tpg, se_nacl, sess->se_sess, sess); 242 243 return sess; 244 } 245 246 static void sbp_session_release(struct sbp_session *sess, bool cancel_work) 247 { 248 spin_lock_bh(&sess->lock); 249 if (!list_empty(&sess->login_list)) { 250 spin_unlock_bh(&sess->lock); 251 return; 252 } 253 spin_unlock_bh(&sess->lock); 254 255 if (cancel_work) 256 cancel_delayed_work_sync(&sess->maint_work); 257 258 transport_deregister_session_configfs(sess->se_sess); 259 transport_deregister_session(sess->se_sess); 260 261 if (sess->card) 262 fw_card_put(sess->card); 263 264 kfree(sess); 265 } 266 267 static void sbp_target_agent_unregister(struct sbp_target_agent *); 268 269 static void sbp_login_release(struct sbp_login_descriptor *login, 270 bool cancel_work) 271 { 272 struct sbp_session *sess = login->sess; 273 274 /* FIXME: abort/wait on tasks */ 275 276 sbp_target_agent_unregister(login->tgt_agt); 277 278 if (sess) { 279 spin_lock_bh(&sess->lock); 280 list_del(&login->link); 281 spin_unlock_bh(&sess->lock); 282 283 sbp_session_release(sess, cancel_work); 284 } 285 286 kfree(login); 287 } 288 289 static struct sbp_target_agent *sbp_target_agent_register( 290 struct sbp_login_descriptor *); 291 292 static void sbp_management_request_login( 293 struct sbp_management_agent *agent, struct sbp_management_request *req, 294 int *status_data_size) 295 { 296 struct sbp_tport *tport = agent->tport; 297 struct sbp_tpg *tpg = tport->tpg; 298 struct se_lun *se_lun; 299 int ret; 300 u64 guid; 301 struct sbp_session *sess; 302 struct sbp_login_descriptor *login; 303 struct sbp_login_response_block *response; 304 int login_response_len; 305 306 se_lun = sbp_get_lun_from_tpg(tpg, 307 LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc))); 308 if (IS_ERR(se_lun)) { 309 pr_notice("login to unknown LUN: %d\n", 310 LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc))); 311 312 req->status.status = cpu_to_be32( 313 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 314 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP)); 315 return; 316 } 317 318 ret = read_peer_guid(&guid, req); 319 if (ret != RCODE_COMPLETE) { 320 pr_warn("failed to read peer GUID: %d\n", ret); 321 322 req->status.status = cpu_to_be32( 323 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) | 324 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR)); 325 return; 326 } 327 328 pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n", 329 se_lun->unpacked_lun, guid); 330 331 sess = sbp_session_find_by_guid(tpg, guid); 332 if (sess) { 333 login = sbp_login_find_by_lun(sess, se_lun); 334 if (login) { 335 pr_notice("initiator already logged-in\n"); 336 337 /* 338 * SBP-2 R4 says we should return access denied, but 339 * that can confuse initiators. Instead we need to 340 * treat this like a reconnect, but send the login 341 * response block like a fresh login. 342 * 343 * This is required particularly in the case of Apple 344 * devices booting off the FireWire target, where 345 * the firmware has an active login to the target. When 346 * the OS takes control of the session it issues its own 347 * LOGIN rather than a RECONNECT. To avoid the machine 348 * waiting until the reconnect_hold expires, we can skip 349 * the ACCESS_DENIED errors to speed things up. 350 */ 351 352 goto already_logged_in; 353 } 354 } 355 356 /* 357 * check exclusive bit in login request 358 * reject with access_denied if any logins present 359 */ 360 if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) && 361 sbp_login_count_all_by_lun(tpg, se_lun, 0)) { 362 pr_warn("refusing exclusive login with other active logins\n"); 363 364 req->status.status = cpu_to_be32( 365 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 366 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED)); 367 return; 368 } 369 370 /* 371 * check exclusive bit in any existing login descriptor 372 * reject with access_denied if any exclusive logins present 373 */ 374 if (sbp_login_count_all_by_lun(tpg, se_lun, 1)) { 375 pr_warn("refusing login while another exclusive login present\n"); 376 377 req->status.status = cpu_to_be32( 378 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 379 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED)); 380 return; 381 } 382 383 /* 384 * check we haven't exceeded the number of allowed logins 385 * reject with resources_unavailable if we have 386 */ 387 if (sbp_login_count_all_by_lun(tpg, se_lun, 0) >= 388 tport->max_logins_per_lun) { 389 pr_warn("max number of logins reached\n"); 390 391 req->status.status = cpu_to_be32( 392 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 393 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL)); 394 return; 395 } 396 397 if (!sess) { 398 sess = sbp_session_create(tpg, guid); 399 if (IS_ERR(sess)) { 400 switch (PTR_ERR(sess)) { 401 case -EPERM: 402 ret = SBP_STATUS_ACCESS_DENIED; 403 break; 404 default: 405 ret = SBP_STATUS_RESOURCES_UNAVAIL; 406 break; 407 } 408 409 req->status.status = cpu_to_be32( 410 STATUS_BLOCK_RESP( 411 STATUS_RESP_REQUEST_COMPLETE) | 412 STATUS_BLOCK_SBP_STATUS(ret)); 413 return; 414 } 415 416 sess->node_id = req->node_addr; 417 sess->card = fw_card_get(req->card); 418 sess->generation = req->generation; 419 sess->speed = req->speed; 420 421 schedule_delayed_work(&sess->maint_work, 422 SESSION_MAINTENANCE_INTERVAL); 423 } 424 425 /* only take the latest reconnect_hold into account */ 426 sess->reconnect_hold = min( 427 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)), 428 tport->max_reconnect_timeout) - 1; 429 430 login = kmalloc(sizeof(*login), GFP_KERNEL); 431 if (!login) { 432 pr_err("failed to allocate login descriptor\n"); 433 434 sbp_session_release(sess, true); 435 436 req->status.status = cpu_to_be32( 437 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 438 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL)); 439 return; 440 } 441 442 login->sess = sess; 443 login->lun = se_lun; 444 login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo); 445 login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)); 446 login->login_id = atomic_inc_return(&login_id); 447 448 login->tgt_agt = sbp_target_agent_register(login); 449 if (IS_ERR(login->tgt_agt)) { 450 ret = PTR_ERR(login->tgt_agt); 451 pr_err("failed to map command block handler: %d\n", ret); 452 453 sbp_session_release(sess, true); 454 kfree(login); 455 456 req->status.status = cpu_to_be32( 457 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 458 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL)); 459 return; 460 } 461 462 spin_lock_bh(&sess->lock); 463 list_add_tail(&login->link, &sess->login_list); 464 spin_unlock_bh(&sess->lock); 465 466 already_logged_in: 467 response = kzalloc(sizeof(*response), GFP_KERNEL); 468 if (!response) { 469 pr_err("failed to allocate login response block\n"); 470 471 sbp_login_release(login, true); 472 473 req->status.status = cpu_to_be32( 474 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 475 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL)); 476 return; 477 } 478 479 login_response_len = clamp_val( 480 LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)), 481 12, sizeof(*response)); 482 response->misc = cpu_to_be32( 483 ((login_response_len & 0xffff) << 16) | 484 (login->login_id & 0xffff)); 485 response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff); 486 addr_to_sbp2_pointer(login->tgt_agt->handler.offset, 487 &response->command_block_agent); 488 489 ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST, 490 sess->node_id, sess->generation, sess->speed, 491 sbp2_pointer_to_addr(&req->orb.ptr2), response, 492 login_response_len); 493 if (ret != RCODE_COMPLETE) { 494 pr_debug("failed to write login response block: %x\n", ret); 495 496 kfree(response); 497 sbp_login_release(login, true); 498 499 req->status.status = cpu_to_be32( 500 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) | 501 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR)); 502 return; 503 } 504 505 kfree(response); 506 507 req->status.status = cpu_to_be32( 508 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 509 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK)); 510 } 511 512 static void sbp_management_request_query_logins( 513 struct sbp_management_agent *agent, struct sbp_management_request *req, 514 int *status_data_size) 515 { 516 pr_notice("QUERY LOGINS not implemented\n"); 517 /* FIXME: implement */ 518 519 req->status.status = cpu_to_be32( 520 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 521 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 522 } 523 524 static void sbp_management_request_reconnect( 525 struct sbp_management_agent *agent, struct sbp_management_request *req, 526 int *status_data_size) 527 { 528 struct sbp_tport *tport = agent->tport; 529 struct sbp_tpg *tpg = tport->tpg; 530 int ret; 531 u64 guid; 532 struct sbp_login_descriptor *login; 533 534 ret = read_peer_guid(&guid, req); 535 if (ret != RCODE_COMPLETE) { 536 pr_warn("failed to read peer GUID: %d\n", ret); 537 538 req->status.status = cpu_to_be32( 539 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) | 540 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR)); 541 return; 542 } 543 544 pr_notice("mgt_agent RECONNECT from %016llx\n", guid); 545 546 login = sbp_login_find_by_id(tpg, 547 RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc))); 548 549 if (!login) { 550 pr_err("mgt_agent RECONNECT unknown login ID\n"); 551 552 req->status.status = cpu_to_be32( 553 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 554 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED)); 555 return; 556 } 557 558 if (login->sess->guid != guid) { 559 pr_err("mgt_agent RECONNECT login GUID doesn't match\n"); 560 561 req->status.status = cpu_to_be32( 562 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 563 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED)); 564 return; 565 } 566 567 spin_lock_bh(&login->sess->lock); 568 if (login->sess->card) 569 fw_card_put(login->sess->card); 570 571 /* update the node details */ 572 login->sess->generation = req->generation; 573 login->sess->node_id = req->node_addr; 574 login->sess->card = fw_card_get(req->card); 575 login->sess->speed = req->speed; 576 spin_unlock_bh(&login->sess->lock); 577 578 req->status.status = cpu_to_be32( 579 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 580 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK)); 581 } 582 583 static void sbp_management_request_logout( 584 struct sbp_management_agent *agent, struct sbp_management_request *req, 585 int *status_data_size) 586 { 587 struct sbp_tport *tport = agent->tport; 588 struct sbp_tpg *tpg = tport->tpg; 589 int id; 590 struct sbp_login_descriptor *login; 591 592 id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)); 593 594 login = sbp_login_find_by_id(tpg, id); 595 if (!login) { 596 pr_warn("cannot find login: %d\n", id); 597 598 req->status.status = cpu_to_be32( 599 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 600 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN)); 601 return; 602 } 603 604 pr_info("mgt_agent LOGOUT from LUN %d session %d\n", 605 login->lun->unpacked_lun, login->login_id); 606 607 if (req->node_addr != login->sess->node_id) { 608 pr_warn("logout from different node ID\n"); 609 610 req->status.status = cpu_to_be32( 611 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 612 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED)); 613 return; 614 } 615 616 sbp_login_release(login, true); 617 618 req->status.status = cpu_to_be32( 619 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 620 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK)); 621 } 622 623 static void session_check_for_reset(struct sbp_session *sess) 624 { 625 bool card_valid = false; 626 627 spin_lock_bh(&sess->lock); 628 629 if (sess->card) { 630 spin_lock_irq(&sess->card->lock); 631 card_valid = (sess->card->local_node != NULL); 632 spin_unlock_irq(&sess->card->lock); 633 634 if (!card_valid) { 635 fw_card_put(sess->card); 636 sess->card = NULL; 637 } 638 } 639 640 if (!card_valid || (sess->generation != sess->card->generation)) { 641 pr_info("Waiting for reconnect from node: %016llx\n", 642 sess->guid); 643 644 sess->node_id = -1; 645 sess->reconnect_expires = get_jiffies_64() + 646 ((sess->reconnect_hold + 1) * HZ); 647 } 648 649 spin_unlock_bh(&sess->lock); 650 } 651 652 static void session_reconnect_expired(struct sbp_session *sess) 653 { 654 struct sbp_login_descriptor *login, *temp; 655 LIST_HEAD(login_list); 656 657 pr_info("Reconnect timer expired for node: %016llx\n", sess->guid); 658 659 spin_lock_bh(&sess->lock); 660 list_for_each_entry_safe(login, temp, &sess->login_list, link) { 661 login->sess = NULL; 662 list_move_tail(&login->link, &login_list); 663 } 664 spin_unlock_bh(&sess->lock); 665 666 list_for_each_entry_safe(login, temp, &login_list, link) { 667 list_del(&login->link); 668 sbp_login_release(login, false); 669 } 670 671 sbp_session_release(sess, false); 672 } 673 674 static void session_maintenance_work(struct work_struct *work) 675 { 676 struct sbp_session *sess = container_of(work, struct sbp_session, 677 maint_work.work); 678 679 /* could be called while tearing down the session */ 680 spin_lock_bh(&sess->lock); 681 if (list_empty(&sess->login_list)) { 682 spin_unlock_bh(&sess->lock); 683 return; 684 } 685 spin_unlock_bh(&sess->lock); 686 687 if (sess->node_id != -1) { 688 /* check for bus reset and make node_id invalid */ 689 session_check_for_reset(sess); 690 691 schedule_delayed_work(&sess->maint_work, 692 SESSION_MAINTENANCE_INTERVAL); 693 } else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) { 694 /* still waiting for reconnect */ 695 schedule_delayed_work(&sess->maint_work, 696 SESSION_MAINTENANCE_INTERVAL); 697 } else { 698 /* reconnect timeout has expired */ 699 session_reconnect_expired(sess); 700 } 701 } 702 703 static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data, 704 struct sbp_target_agent *agent) 705 { 706 int state; 707 708 switch (tcode) { 709 case TCODE_READ_QUADLET_REQUEST: 710 pr_debug("tgt_agent AGENT_STATE READ\n"); 711 712 spin_lock_bh(&agent->lock); 713 state = agent->state; 714 spin_unlock_bh(&agent->lock); 715 716 *(__be32 *)data = cpu_to_be32(state); 717 718 return RCODE_COMPLETE; 719 720 case TCODE_WRITE_QUADLET_REQUEST: 721 /* ignored */ 722 return RCODE_COMPLETE; 723 724 default: 725 return RCODE_TYPE_ERROR; 726 } 727 } 728 729 static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data, 730 struct sbp_target_agent *agent) 731 { 732 switch (tcode) { 733 case TCODE_WRITE_QUADLET_REQUEST: 734 pr_debug("tgt_agent AGENT_RESET\n"); 735 spin_lock_bh(&agent->lock); 736 agent->state = AGENT_STATE_RESET; 737 spin_unlock_bh(&agent->lock); 738 return RCODE_COMPLETE; 739 740 default: 741 return RCODE_TYPE_ERROR; 742 } 743 } 744 745 static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data, 746 struct sbp_target_agent *agent) 747 { 748 struct sbp2_pointer *ptr = data; 749 750 switch (tcode) { 751 case TCODE_WRITE_BLOCK_REQUEST: 752 spin_lock_bh(&agent->lock); 753 if (agent->state != AGENT_STATE_SUSPENDED && 754 agent->state != AGENT_STATE_RESET) { 755 spin_unlock_bh(&agent->lock); 756 pr_notice("Ignoring ORB_POINTER write while active.\n"); 757 return RCODE_CONFLICT_ERROR; 758 } 759 agent->state = AGENT_STATE_ACTIVE; 760 spin_unlock_bh(&agent->lock); 761 762 agent->orb_pointer = sbp2_pointer_to_addr(ptr); 763 agent->doorbell = false; 764 765 pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n", 766 agent->orb_pointer); 767 768 queue_work(system_unbound_wq, &agent->work); 769 770 return RCODE_COMPLETE; 771 772 case TCODE_READ_BLOCK_REQUEST: 773 pr_debug("tgt_agent ORB_POINTER READ\n"); 774 spin_lock_bh(&agent->lock); 775 addr_to_sbp2_pointer(agent->orb_pointer, ptr); 776 spin_unlock_bh(&agent->lock); 777 return RCODE_COMPLETE; 778 779 default: 780 return RCODE_TYPE_ERROR; 781 } 782 } 783 784 static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data, 785 struct sbp_target_agent *agent) 786 { 787 switch (tcode) { 788 case TCODE_WRITE_QUADLET_REQUEST: 789 spin_lock_bh(&agent->lock); 790 if (agent->state != AGENT_STATE_SUSPENDED) { 791 spin_unlock_bh(&agent->lock); 792 pr_debug("Ignoring DOORBELL while active.\n"); 793 return RCODE_CONFLICT_ERROR; 794 } 795 agent->state = AGENT_STATE_ACTIVE; 796 spin_unlock_bh(&agent->lock); 797 798 agent->doorbell = true; 799 800 pr_debug("tgt_agent DOORBELL\n"); 801 802 queue_work(system_unbound_wq, &agent->work); 803 804 return RCODE_COMPLETE; 805 806 case TCODE_READ_QUADLET_REQUEST: 807 return RCODE_COMPLETE; 808 809 default: 810 return RCODE_TYPE_ERROR; 811 } 812 } 813 814 static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card, 815 int tcode, void *data, struct sbp_target_agent *agent) 816 { 817 switch (tcode) { 818 case TCODE_WRITE_QUADLET_REQUEST: 819 pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n"); 820 /* ignored as we don't send unsolicited status */ 821 return RCODE_COMPLETE; 822 823 case TCODE_READ_QUADLET_REQUEST: 824 return RCODE_COMPLETE; 825 826 default: 827 return RCODE_TYPE_ERROR; 828 } 829 } 830 831 static void tgt_agent_rw(struct fw_card *card, struct fw_request *request, 832 int tcode, int destination, int source, int generation, 833 unsigned long long offset, void *data, size_t length, 834 void *callback_data) 835 { 836 struct sbp_target_agent *agent = callback_data; 837 struct sbp_session *sess = agent->login->sess; 838 int sess_gen, sess_node, rcode; 839 840 spin_lock_bh(&sess->lock); 841 sess_gen = sess->generation; 842 sess_node = sess->node_id; 843 spin_unlock_bh(&sess->lock); 844 845 if (generation != sess_gen) { 846 pr_notice("ignoring request with wrong generation\n"); 847 rcode = RCODE_TYPE_ERROR; 848 goto out; 849 } 850 851 if (source != sess_node) { 852 pr_notice("ignoring request from foreign node (%x != %x)\n", 853 source, sess_node); 854 rcode = RCODE_TYPE_ERROR; 855 goto out; 856 } 857 858 /* turn offset into the offset from the start of the block */ 859 offset -= agent->handler.offset; 860 861 if (offset == 0x00 && length == 4) { 862 /* AGENT_STATE */ 863 rcode = tgt_agent_rw_agent_state(card, tcode, data, agent); 864 } else if (offset == 0x04 && length == 4) { 865 /* AGENT_RESET */ 866 rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent); 867 } else if (offset == 0x08 && length == 8) { 868 /* ORB_POINTER */ 869 rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent); 870 } else if (offset == 0x10 && length == 4) { 871 /* DOORBELL */ 872 rcode = tgt_agent_rw_doorbell(card, tcode, data, agent); 873 } else if (offset == 0x14 && length == 4) { 874 /* UNSOLICITED_STATUS_ENABLE */ 875 rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode, 876 data, agent); 877 } else { 878 rcode = RCODE_ADDRESS_ERROR; 879 } 880 881 out: 882 fw_send_response(card, request, rcode); 883 } 884 885 static void sbp_handle_command(struct sbp_target_request *); 886 static int sbp_send_status(struct sbp_target_request *); 887 static void sbp_free_request(struct sbp_target_request *); 888 889 static void tgt_agent_process_work(struct work_struct *work) 890 { 891 struct sbp_target_request *req = 892 container_of(work, struct sbp_target_request, work); 893 894 pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n", 895 req->orb_pointer, 896 sbp2_pointer_to_addr(&req->orb.next_orb), 897 sbp2_pointer_to_addr(&req->orb.data_descriptor), 898 be32_to_cpu(req->orb.misc)); 899 900 if (req->orb_pointer >> 32) 901 pr_debug("ORB with high bits set\n"); 902 903 switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) { 904 case 0:/* Format specified by this standard */ 905 sbp_handle_command(req); 906 return; 907 case 1: /* Reserved for future standardization */ 908 case 2: /* Vendor-dependent */ 909 req->status.status |= cpu_to_be32( 910 STATUS_BLOCK_RESP( 911 STATUS_RESP_REQUEST_COMPLETE) | 912 STATUS_BLOCK_DEAD(0) | 913 STATUS_BLOCK_LEN(1) | 914 STATUS_BLOCK_SBP_STATUS( 915 SBP_STATUS_REQ_TYPE_NOTSUPP)); 916 sbp_send_status(req); 917 sbp_free_request(req); 918 return; 919 case 3: /* Dummy ORB */ 920 req->status.status |= cpu_to_be32( 921 STATUS_BLOCK_RESP( 922 STATUS_RESP_REQUEST_COMPLETE) | 923 STATUS_BLOCK_DEAD(0) | 924 STATUS_BLOCK_LEN(1) | 925 STATUS_BLOCK_SBP_STATUS( 926 SBP_STATUS_DUMMY_ORB_COMPLETE)); 927 sbp_send_status(req); 928 sbp_free_request(req); 929 return; 930 default: 931 BUG(); 932 } 933 } 934 935 /* used to double-check we haven't been issued an AGENT_RESET */ 936 static inline bool tgt_agent_check_active(struct sbp_target_agent *agent) 937 { 938 bool active; 939 940 spin_lock_bh(&agent->lock); 941 active = (agent->state == AGENT_STATE_ACTIVE); 942 spin_unlock_bh(&agent->lock); 943 944 return active; 945 } 946 947 static void tgt_agent_fetch_work(struct work_struct *work) 948 { 949 struct sbp_target_agent *agent = 950 container_of(work, struct sbp_target_agent, work); 951 struct sbp_session *sess = agent->login->sess; 952 struct sbp_target_request *req; 953 int ret; 954 bool doorbell = agent->doorbell; 955 u64 next_orb = agent->orb_pointer; 956 957 while (next_orb && tgt_agent_check_active(agent)) { 958 req = kzalloc(sizeof(*req), GFP_KERNEL); 959 if (!req) { 960 spin_lock_bh(&agent->lock); 961 agent->state = AGENT_STATE_DEAD; 962 spin_unlock_bh(&agent->lock); 963 return; 964 } 965 966 req->login = agent->login; 967 req->orb_pointer = next_orb; 968 969 req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH( 970 req->orb_pointer >> 32)); 971 req->status.orb_low = cpu_to_be32( 972 req->orb_pointer & 0xfffffffc); 973 974 /* read in the ORB */ 975 ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST, 976 sess->node_id, sess->generation, sess->speed, 977 req->orb_pointer, &req->orb, sizeof(req->orb)); 978 if (ret != RCODE_COMPLETE) { 979 pr_debug("tgt_orb fetch failed: %x\n", ret); 980 req->status.status |= cpu_to_be32( 981 STATUS_BLOCK_SRC( 982 STATUS_SRC_ORB_FINISHED) | 983 STATUS_BLOCK_RESP( 984 STATUS_RESP_TRANSPORT_FAILURE) | 985 STATUS_BLOCK_DEAD(1) | 986 STATUS_BLOCK_LEN(1) | 987 STATUS_BLOCK_SBP_STATUS( 988 SBP_STATUS_UNSPECIFIED_ERROR)); 989 spin_lock_bh(&agent->lock); 990 agent->state = AGENT_STATE_DEAD; 991 spin_unlock_bh(&agent->lock); 992 993 sbp_send_status(req); 994 sbp_free_request(req); 995 return; 996 } 997 998 /* check the next_ORB field */ 999 if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) { 1000 next_orb = 0; 1001 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC( 1002 STATUS_SRC_ORB_FINISHED)); 1003 } else { 1004 next_orb = sbp2_pointer_to_addr(&req->orb.next_orb); 1005 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC( 1006 STATUS_SRC_ORB_CONTINUING)); 1007 } 1008 1009 if (tgt_agent_check_active(agent) && !doorbell) { 1010 INIT_WORK(&req->work, tgt_agent_process_work); 1011 queue_work(system_unbound_wq, &req->work); 1012 } else { 1013 /* don't process this request, just check next_ORB */ 1014 sbp_free_request(req); 1015 } 1016 1017 spin_lock_bh(&agent->lock); 1018 doorbell = agent->doorbell = false; 1019 1020 /* check if we should carry on processing */ 1021 if (next_orb) 1022 agent->orb_pointer = next_orb; 1023 else 1024 agent->state = AGENT_STATE_SUSPENDED; 1025 1026 spin_unlock_bh(&agent->lock); 1027 }; 1028 } 1029 1030 static struct sbp_target_agent *sbp_target_agent_register( 1031 struct sbp_login_descriptor *login) 1032 { 1033 struct sbp_target_agent *agent; 1034 int ret; 1035 1036 agent = kmalloc(sizeof(*agent), GFP_KERNEL); 1037 if (!agent) 1038 return ERR_PTR(-ENOMEM); 1039 1040 spin_lock_init(&agent->lock); 1041 1042 agent->handler.length = 0x20; 1043 agent->handler.address_callback = tgt_agent_rw; 1044 agent->handler.callback_data = agent; 1045 1046 agent->login = login; 1047 agent->state = AGENT_STATE_RESET; 1048 INIT_WORK(&agent->work, tgt_agent_fetch_work); 1049 agent->orb_pointer = 0; 1050 agent->doorbell = false; 1051 1052 ret = fw_core_add_address_handler(&agent->handler, 1053 &sbp_register_region); 1054 if (ret < 0) { 1055 kfree(agent); 1056 return ERR_PTR(ret); 1057 } 1058 1059 return agent; 1060 } 1061 1062 static void sbp_target_agent_unregister(struct sbp_target_agent *agent) 1063 { 1064 fw_core_remove_address_handler(&agent->handler); 1065 cancel_work_sync(&agent->work); 1066 kfree(agent); 1067 } 1068 1069 /* 1070 * Simple wrapper around fw_run_transaction that retries the transaction several 1071 * times in case of failure, with an exponential backoff. 1072 */ 1073 static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id, 1074 int generation, int speed, unsigned long long offset, 1075 void *payload, size_t length) 1076 { 1077 int attempt, ret, delay; 1078 1079 for (attempt = 1; attempt <= 5; attempt++) { 1080 ret = fw_run_transaction(card, tcode, destination_id, 1081 generation, speed, offset, payload, length); 1082 1083 switch (ret) { 1084 case RCODE_COMPLETE: 1085 case RCODE_TYPE_ERROR: 1086 case RCODE_ADDRESS_ERROR: 1087 case RCODE_GENERATION: 1088 return ret; 1089 1090 default: 1091 delay = 5 * attempt * attempt; 1092 usleep_range(delay, delay * 2); 1093 } 1094 } 1095 1096 return ret; 1097 } 1098 1099 /* 1100 * Wrapper around sbp_run_transaction that gets the card, destination, 1101 * generation and speed out of the request's session. 1102 */ 1103 static int sbp_run_request_transaction(struct sbp_target_request *req, 1104 int tcode, unsigned long long offset, void *payload, 1105 size_t length) 1106 { 1107 struct sbp_login_descriptor *login = req->login; 1108 struct sbp_session *sess = login->sess; 1109 struct fw_card *card; 1110 int node_id, generation, speed, ret; 1111 1112 spin_lock_bh(&sess->lock); 1113 card = fw_card_get(sess->card); 1114 node_id = sess->node_id; 1115 generation = sess->generation; 1116 speed = sess->speed; 1117 spin_unlock_bh(&sess->lock); 1118 1119 ret = sbp_run_transaction(card, tcode, node_id, generation, speed, 1120 offset, payload, length); 1121 1122 fw_card_put(card); 1123 1124 return ret; 1125 } 1126 1127 static int sbp_fetch_command(struct sbp_target_request *req) 1128 { 1129 int ret, cmd_len, copy_len; 1130 1131 cmd_len = scsi_command_size(req->orb.command_block); 1132 1133 req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL); 1134 if (!req->cmd_buf) 1135 return -ENOMEM; 1136 1137 memcpy(req->cmd_buf, req->orb.command_block, 1138 min_t(int, cmd_len, sizeof(req->orb.command_block))); 1139 1140 if (cmd_len > sizeof(req->orb.command_block)) { 1141 pr_debug("sbp_fetch_command: filling in long command\n"); 1142 copy_len = cmd_len - sizeof(req->orb.command_block); 1143 1144 ret = sbp_run_request_transaction(req, 1145 TCODE_READ_BLOCK_REQUEST, 1146 req->orb_pointer + sizeof(req->orb), 1147 req->cmd_buf + sizeof(req->orb.command_block), 1148 copy_len); 1149 if (ret != RCODE_COMPLETE) 1150 return -EIO; 1151 } 1152 1153 return 0; 1154 } 1155 1156 static int sbp_fetch_page_table(struct sbp_target_request *req) 1157 { 1158 int pg_tbl_sz, ret; 1159 struct sbp_page_table_entry *pg_tbl; 1160 1161 if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc))) 1162 return 0; 1163 1164 pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) * 1165 sizeof(struct sbp_page_table_entry); 1166 1167 pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL); 1168 if (!pg_tbl) 1169 return -ENOMEM; 1170 1171 ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST, 1172 sbp2_pointer_to_addr(&req->orb.data_descriptor), 1173 pg_tbl, pg_tbl_sz); 1174 if (ret != RCODE_COMPLETE) { 1175 kfree(pg_tbl); 1176 return -EIO; 1177 } 1178 1179 req->pg_tbl = pg_tbl; 1180 return 0; 1181 } 1182 1183 static void sbp_calc_data_length_direction(struct sbp_target_request *req, 1184 u32 *data_len, enum dma_data_direction *data_dir) 1185 { 1186 int data_size, direction, idx; 1187 1188 data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)); 1189 direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc)); 1190 1191 if (!data_size) { 1192 *data_len = 0; 1193 *data_dir = DMA_NONE; 1194 return; 1195 } 1196 1197 *data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE; 1198 1199 if (req->pg_tbl) { 1200 *data_len = 0; 1201 for (idx = 0; idx < data_size; idx++) { 1202 *data_len += be16_to_cpu( 1203 req->pg_tbl[idx].segment_length); 1204 } 1205 } else { 1206 *data_len = data_size; 1207 } 1208 } 1209 1210 static void sbp_handle_command(struct sbp_target_request *req) 1211 { 1212 struct sbp_login_descriptor *login = req->login; 1213 struct sbp_session *sess = login->sess; 1214 int ret, unpacked_lun; 1215 u32 data_length; 1216 enum dma_data_direction data_dir; 1217 1218 ret = sbp_fetch_command(req); 1219 if (ret) { 1220 pr_debug("sbp_handle_command: fetch command failed: %d\n", ret); 1221 goto err; 1222 } 1223 1224 ret = sbp_fetch_page_table(req); 1225 if (ret) { 1226 pr_debug("sbp_handle_command: fetch page table failed: %d\n", 1227 ret); 1228 goto err; 1229 } 1230 1231 unpacked_lun = req->login->lun->unpacked_lun; 1232 sbp_calc_data_length_direction(req, &data_length, &data_dir); 1233 1234 pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n", 1235 req->orb_pointer, unpacked_lun, data_length, data_dir); 1236 1237 if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf, 1238 req->sense_buf, unpacked_lun, data_length, 1239 TCM_SIMPLE_TAG, data_dir, 0)) 1240 goto err; 1241 1242 return; 1243 1244 err: 1245 req->status.status |= cpu_to_be32( 1246 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) | 1247 STATUS_BLOCK_DEAD(0) | 1248 STATUS_BLOCK_LEN(1) | 1249 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR)); 1250 sbp_send_status(req); 1251 sbp_free_request(req); 1252 } 1253 1254 /* 1255 * DMA_TO_DEVICE = read from initiator (SCSI WRITE) 1256 * DMA_FROM_DEVICE = write to initiator (SCSI READ) 1257 */ 1258 static int sbp_rw_data(struct sbp_target_request *req) 1259 { 1260 struct sbp_session *sess = req->login->sess; 1261 int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id, 1262 generation, num_pte, length, tfr_length, 1263 rcode = RCODE_COMPLETE; 1264 struct sbp_page_table_entry *pte; 1265 unsigned long long offset; 1266 struct fw_card *card; 1267 struct sg_mapping_iter iter; 1268 1269 if (req->se_cmd.data_direction == DMA_FROM_DEVICE) { 1270 tcode = TCODE_WRITE_BLOCK_REQUEST; 1271 sg_miter_flags = SG_MITER_FROM_SG; 1272 } else { 1273 tcode = TCODE_READ_BLOCK_REQUEST; 1274 sg_miter_flags = SG_MITER_TO_SG; 1275 } 1276 1277 max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc)); 1278 speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc)); 1279 1280 pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc)); 1281 if (pg_size) { 1282 pr_err("sbp_run_transaction: page size ignored\n"); 1283 pg_size = 0x100 << pg_size; 1284 } 1285 1286 spin_lock_bh(&sess->lock); 1287 card = fw_card_get(sess->card); 1288 node_id = sess->node_id; 1289 generation = sess->generation; 1290 spin_unlock_bh(&sess->lock); 1291 1292 if (req->pg_tbl) { 1293 pte = req->pg_tbl; 1294 num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)); 1295 1296 offset = 0; 1297 length = 0; 1298 } else { 1299 pte = NULL; 1300 num_pte = 0; 1301 1302 offset = sbp2_pointer_to_addr(&req->orb.data_descriptor); 1303 length = req->se_cmd.data_length; 1304 } 1305 1306 sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents, 1307 sg_miter_flags); 1308 1309 while (length || num_pte) { 1310 if (!length) { 1311 offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 | 1312 be32_to_cpu(pte->segment_base_lo); 1313 length = be16_to_cpu(pte->segment_length); 1314 1315 pte++; 1316 num_pte--; 1317 } 1318 1319 sg_miter_next(&iter); 1320 1321 tfr_length = min3(length, max_payload, (int)iter.length); 1322 1323 /* FIXME: take page_size into account */ 1324 1325 rcode = sbp_run_transaction(card, tcode, node_id, 1326 generation, speed, 1327 offset, iter.addr, tfr_length); 1328 1329 if (rcode != RCODE_COMPLETE) 1330 break; 1331 1332 length -= tfr_length; 1333 offset += tfr_length; 1334 iter.consumed = tfr_length; 1335 } 1336 1337 sg_miter_stop(&iter); 1338 fw_card_put(card); 1339 1340 if (rcode == RCODE_COMPLETE) { 1341 WARN_ON(length != 0); 1342 return 0; 1343 } else { 1344 return -EIO; 1345 } 1346 } 1347 1348 static int sbp_send_status(struct sbp_target_request *req) 1349 { 1350 int ret, length; 1351 struct sbp_login_descriptor *login = req->login; 1352 1353 length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4; 1354 1355 ret = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST, 1356 login->status_fifo_addr, &req->status, length); 1357 if (ret != RCODE_COMPLETE) { 1358 pr_debug("sbp_send_status: write failed: 0x%x\n", ret); 1359 return -EIO; 1360 } 1361 1362 pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n", 1363 req->orb_pointer); 1364 1365 return 0; 1366 } 1367 1368 static void sbp_sense_mangle(struct sbp_target_request *req) 1369 { 1370 struct se_cmd *se_cmd = &req->se_cmd; 1371 u8 *sense = req->sense_buf; 1372 u8 *status = req->status.data; 1373 1374 WARN_ON(se_cmd->scsi_sense_length < 18); 1375 1376 switch (sense[0] & 0x7f) { /* sfmt */ 1377 case 0x70: /* current, fixed */ 1378 status[0] = 0 << 6; 1379 break; 1380 case 0x71: /* deferred, fixed */ 1381 status[0] = 1 << 6; 1382 break; 1383 case 0x72: /* current, descriptor */ 1384 case 0x73: /* deferred, descriptor */ 1385 default: 1386 /* 1387 * TODO: SBP-3 specifies what we should do with descriptor 1388 * format sense data 1389 */ 1390 pr_err("sbp_send_sense: unknown sense format: 0x%x\n", 1391 sense[0]); 1392 req->status.status |= cpu_to_be32( 1393 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1394 STATUS_BLOCK_DEAD(0) | 1395 STATUS_BLOCK_LEN(1) | 1396 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED)); 1397 return; 1398 } 1399 1400 status[0] |= se_cmd->scsi_status & 0x3f;/* status */ 1401 status[1] = 1402 (sense[0] & 0x80) | /* valid */ 1403 ((sense[2] & 0xe0) >> 1) | /* mark, eom, ili */ 1404 (sense[2] & 0x0f); /* sense_key */ 1405 status[2] = se_cmd->scsi_asc; /* sense_code */ 1406 status[3] = se_cmd->scsi_ascq; /* sense_qualifier */ 1407 1408 /* information */ 1409 status[4] = sense[3]; 1410 status[5] = sense[4]; 1411 status[6] = sense[5]; 1412 status[7] = sense[6]; 1413 1414 /* CDB-dependent */ 1415 status[8] = sense[8]; 1416 status[9] = sense[9]; 1417 status[10] = sense[10]; 1418 status[11] = sense[11]; 1419 1420 /* fru */ 1421 status[12] = sense[14]; 1422 1423 /* sense_key-dependent */ 1424 status[13] = sense[15]; 1425 status[14] = sense[16]; 1426 status[15] = sense[17]; 1427 1428 req->status.status |= cpu_to_be32( 1429 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1430 STATUS_BLOCK_DEAD(0) | 1431 STATUS_BLOCK_LEN(5) | 1432 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK)); 1433 } 1434 1435 static int sbp_send_sense(struct sbp_target_request *req) 1436 { 1437 struct se_cmd *se_cmd = &req->se_cmd; 1438 1439 if (se_cmd->scsi_sense_length) { 1440 sbp_sense_mangle(req); 1441 } else { 1442 req->status.status |= cpu_to_be32( 1443 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1444 STATUS_BLOCK_DEAD(0) | 1445 STATUS_BLOCK_LEN(1) | 1446 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK)); 1447 } 1448 1449 return sbp_send_status(req); 1450 } 1451 1452 static void sbp_free_request(struct sbp_target_request *req) 1453 { 1454 kfree(req->pg_tbl); 1455 kfree(req->cmd_buf); 1456 kfree(req); 1457 } 1458 1459 static void sbp_mgt_agent_process(struct work_struct *work) 1460 { 1461 struct sbp_management_agent *agent = 1462 container_of(work, struct sbp_management_agent, work); 1463 struct sbp_management_request *req = agent->request; 1464 int ret; 1465 int status_data_len = 0; 1466 1467 /* fetch the ORB from the initiator */ 1468 ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST, 1469 req->node_addr, req->generation, req->speed, 1470 agent->orb_offset, &req->orb, sizeof(req->orb)); 1471 if (ret != RCODE_COMPLETE) { 1472 pr_debug("mgt_orb fetch failed: %x\n", ret); 1473 goto out; 1474 } 1475 1476 pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n", 1477 sbp2_pointer_to_addr(&req->orb.ptr1), 1478 sbp2_pointer_to_addr(&req->orb.ptr2), 1479 be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length), 1480 sbp2_pointer_to_addr(&req->orb.status_fifo)); 1481 1482 if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) || 1483 ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) { 1484 pr_err("mgt_orb bad request\n"); 1485 goto out; 1486 } 1487 1488 switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) { 1489 case MANAGEMENT_ORB_FUNCTION_LOGIN: 1490 sbp_management_request_login(agent, req, &status_data_len); 1491 break; 1492 1493 case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS: 1494 sbp_management_request_query_logins(agent, req, 1495 &status_data_len); 1496 break; 1497 1498 case MANAGEMENT_ORB_FUNCTION_RECONNECT: 1499 sbp_management_request_reconnect(agent, req, &status_data_len); 1500 break; 1501 1502 case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD: 1503 pr_notice("SET PASSWORD not implemented\n"); 1504 1505 req->status.status = cpu_to_be32( 1506 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1507 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1508 1509 break; 1510 1511 case MANAGEMENT_ORB_FUNCTION_LOGOUT: 1512 sbp_management_request_logout(agent, req, &status_data_len); 1513 break; 1514 1515 case MANAGEMENT_ORB_FUNCTION_ABORT_TASK: 1516 pr_notice("ABORT TASK not implemented\n"); 1517 1518 req->status.status = cpu_to_be32( 1519 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1520 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1521 1522 break; 1523 1524 case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET: 1525 pr_notice("ABORT TASK SET not implemented\n"); 1526 1527 req->status.status = cpu_to_be32( 1528 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1529 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1530 1531 break; 1532 1533 case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET: 1534 pr_notice("LOGICAL UNIT RESET not implemented\n"); 1535 1536 req->status.status = cpu_to_be32( 1537 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1538 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1539 1540 break; 1541 1542 case MANAGEMENT_ORB_FUNCTION_TARGET_RESET: 1543 pr_notice("TARGET RESET not implemented\n"); 1544 1545 req->status.status = cpu_to_be32( 1546 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1547 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1548 1549 break; 1550 1551 default: 1552 pr_notice("unknown management function 0x%x\n", 1553 MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))); 1554 1555 req->status.status = cpu_to_be32( 1556 STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) | 1557 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP)); 1558 1559 break; 1560 } 1561 1562 req->status.status |= cpu_to_be32( 1563 STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */ 1564 STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) | 1565 STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32)); 1566 req->status.orb_low = cpu_to_be32(agent->orb_offset); 1567 1568 /* write the status block back to the initiator */ 1569 ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST, 1570 req->node_addr, req->generation, req->speed, 1571 sbp2_pointer_to_addr(&req->orb.status_fifo), 1572 &req->status, 8 + status_data_len); 1573 if (ret != RCODE_COMPLETE) { 1574 pr_debug("mgt_orb status write failed: %x\n", ret); 1575 goto out; 1576 } 1577 1578 out: 1579 fw_card_put(req->card); 1580 kfree(req); 1581 1582 spin_lock_bh(&agent->lock); 1583 agent->state = MANAGEMENT_AGENT_STATE_IDLE; 1584 spin_unlock_bh(&agent->lock); 1585 } 1586 1587 static void sbp_mgt_agent_rw(struct fw_card *card, 1588 struct fw_request *request, int tcode, int destination, int source, 1589 int generation, unsigned long long offset, void *data, size_t length, 1590 void *callback_data) 1591 { 1592 struct sbp_management_agent *agent = callback_data; 1593 struct sbp2_pointer *ptr = data; 1594 int rcode = RCODE_ADDRESS_ERROR; 1595 1596 if (!agent->tport->enable) 1597 goto out; 1598 1599 if ((offset != agent->handler.offset) || (length != 8)) 1600 goto out; 1601 1602 if (tcode == TCODE_WRITE_BLOCK_REQUEST) { 1603 struct sbp_management_request *req; 1604 int prev_state; 1605 1606 spin_lock_bh(&agent->lock); 1607 prev_state = agent->state; 1608 agent->state = MANAGEMENT_AGENT_STATE_BUSY; 1609 spin_unlock_bh(&agent->lock); 1610 1611 if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) { 1612 pr_notice("ignoring management request while busy\n"); 1613 rcode = RCODE_CONFLICT_ERROR; 1614 goto out; 1615 } 1616 1617 req = kzalloc(sizeof(*req), GFP_ATOMIC); 1618 if (!req) { 1619 rcode = RCODE_CONFLICT_ERROR; 1620 goto out; 1621 } 1622 1623 req->card = fw_card_get(card); 1624 req->generation = generation; 1625 req->node_addr = source; 1626 req->speed = fw_get_request_speed(request); 1627 1628 agent->orb_offset = sbp2_pointer_to_addr(ptr); 1629 agent->request = req; 1630 1631 queue_work(system_unbound_wq, &agent->work); 1632 rcode = RCODE_COMPLETE; 1633 } else if (tcode == TCODE_READ_BLOCK_REQUEST) { 1634 addr_to_sbp2_pointer(agent->orb_offset, ptr); 1635 rcode = RCODE_COMPLETE; 1636 } else { 1637 rcode = RCODE_TYPE_ERROR; 1638 } 1639 1640 out: 1641 fw_send_response(card, request, rcode); 1642 } 1643 1644 static struct sbp_management_agent *sbp_management_agent_register( 1645 struct sbp_tport *tport) 1646 { 1647 int ret; 1648 struct sbp_management_agent *agent; 1649 1650 agent = kmalloc(sizeof(*agent), GFP_KERNEL); 1651 if (!agent) 1652 return ERR_PTR(-ENOMEM); 1653 1654 spin_lock_init(&agent->lock); 1655 agent->tport = tport; 1656 agent->handler.length = 0x08; 1657 agent->handler.address_callback = sbp_mgt_agent_rw; 1658 agent->handler.callback_data = agent; 1659 agent->state = MANAGEMENT_AGENT_STATE_IDLE; 1660 INIT_WORK(&agent->work, sbp_mgt_agent_process); 1661 agent->orb_offset = 0; 1662 agent->request = NULL; 1663 1664 ret = fw_core_add_address_handler(&agent->handler, 1665 &sbp_register_region); 1666 if (ret < 0) { 1667 kfree(agent); 1668 return ERR_PTR(ret); 1669 } 1670 1671 return agent; 1672 } 1673 1674 static void sbp_management_agent_unregister(struct sbp_management_agent *agent) 1675 { 1676 fw_core_remove_address_handler(&agent->handler); 1677 cancel_work_sync(&agent->work); 1678 kfree(agent); 1679 } 1680 1681 static int sbp_check_true(struct se_portal_group *se_tpg) 1682 { 1683 return 1; 1684 } 1685 1686 static int sbp_check_false(struct se_portal_group *se_tpg) 1687 { 1688 return 0; 1689 } 1690 1691 static char *sbp_get_fabric_name(void) 1692 { 1693 return "sbp"; 1694 } 1695 1696 static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg) 1697 { 1698 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 1699 struct sbp_tport *tport = tpg->tport; 1700 1701 return &tport->tport_name[0]; 1702 } 1703 1704 static u16 sbp_get_tag(struct se_portal_group *se_tpg) 1705 { 1706 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 1707 return tpg->tport_tpgt; 1708 } 1709 1710 static u32 sbp_get_default_depth(struct se_portal_group *se_tpg) 1711 { 1712 return 1; 1713 } 1714 1715 static struct se_node_acl *sbp_alloc_fabric_acl(struct se_portal_group *se_tpg) 1716 { 1717 struct sbp_nacl *nacl; 1718 1719 nacl = kzalloc(sizeof(struct sbp_nacl), GFP_KERNEL); 1720 if (!nacl) { 1721 pr_err("Unable to allocate struct sbp_nacl\n"); 1722 return NULL; 1723 } 1724 1725 return &nacl->se_node_acl; 1726 } 1727 1728 static void sbp_release_fabric_acl( 1729 struct se_portal_group *se_tpg, 1730 struct se_node_acl *se_nacl) 1731 { 1732 struct sbp_nacl *nacl = 1733 container_of(se_nacl, struct sbp_nacl, se_node_acl); 1734 kfree(nacl); 1735 } 1736 1737 static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg) 1738 { 1739 return 1; 1740 } 1741 1742 static void sbp_release_cmd(struct se_cmd *se_cmd) 1743 { 1744 struct sbp_target_request *req = container_of(se_cmd, 1745 struct sbp_target_request, se_cmd); 1746 1747 sbp_free_request(req); 1748 } 1749 1750 static int sbp_shutdown_session(struct se_session *se_sess) 1751 { 1752 return 0; 1753 } 1754 1755 static void sbp_close_session(struct se_session *se_sess) 1756 { 1757 return; 1758 } 1759 1760 static u32 sbp_sess_get_index(struct se_session *se_sess) 1761 { 1762 return 0; 1763 } 1764 1765 static int sbp_write_pending(struct se_cmd *se_cmd) 1766 { 1767 struct sbp_target_request *req = container_of(se_cmd, 1768 struct sbp_target_request, se_cmd); 1769 int ret; 1770 1771 ret = sbp_rw_data(req); 1772 if (ret) { 1773 req->status.status |= cpu_to_be32( 1774 STATUS_BLOCK_RESP( 1775 STATUS_RESP_TRANSPORT_FAILURE) | 1776 STATUS_BLOCK_DEAD(0) | 1777 STATUS_BLOCK_LEN(1) | 1778 STATUS_BLOCK_SBP_STATUS( 1779 SBP_STATUS_UNSPECIFIED_ERROR)); 1780 sbp_send_status(req); 1781 return ret; 1782 } 1783 1784 target_execute_cmd(se_cmd); 1785 return 0; 1786 } 1787 1788 static int sbp_write_pending_status(struct se_cmd *se_cmd) 1789 { 1790 return 0; 1791 } 1792 1793 static void sbp_set_default_node_attrs(struct se_node_acl *nacl) 1794 { 1795 return; 1796 } 1797 1798 static u32 sbp_get_task_tag(struct se_cmd *se_cmd) 1799 { 1800 struct sbp_target_request *req = container_of(se_cmd, 1801 struct sbp_target_request, se_cmd); 1802 1803 /* only used for printk until we do TMRs */ 1804 return (u32)req->orb_pointer; 1805 } 1806 1807 static int sbp_get_cmd_state(struct se_cmd *se_cmd) 1808 { 1809 return 0; 1810 } 1811 1812 static int sbp_queue_data_in(struct se_cmd *se_cmd) 1813 { 1814 struct sbp_target_request *req = container_of(se_cmd, 1815 struct sbp_target_request, se_cmd); 1816 int ret; 1817 1818 ret = sbp_rw_data(req); 1819 if (ret) { 1820 req->status.status |= cpu_to_be32( 1821 STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) | 1822 STATUS_BLOCK_DEAD(0) | 1823 STATUS_BLOCK_LEN(1) | 1824 STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR)); 1825 sbp_send_status(req); 1826 return ret; 1827 } 1828 1829 return sbp_send_sense(req); 1830 } 1831 1832 /* 1833 * Called after command (no data transfer) or after the write (to device) 1834 * operation is completed 1835 */ 1836 static int sbp_queue_status(struct se_cmd *se_cmd) 1837 { 1838 struct sbp_target_request *req = container_of(se_cmd, 1839 struct sbp_target_request, se_cmd); 1840 1841 return sbp_send_sense(req); 1842 } 1843 1844 static void sbp_queue_tm_rsp(struct se_cmd *se_cmd) 1845 { 1846 } 1847 1848 static void sbp_aborted_task(struct se_cmd *se_cmd) 1849 { 1850 return; 1851 } 1852 1853 static int sbp_check_stop_free(struct se_cmd *se_cmd) 1854 { 1855 struct sbp_target_request *req = container_of(se_cmd, 1856 struct sbp_target_request, se_cmd); 1857 1858 transport_generic_free_cmd(&req->se_cmd, 0); 1859 return 1; 1860 } 1861 1862 /* 1863 * Handlers for Serial Bus Protocol 2/3 (SBP-2 / SBP-3) 1864 */ 1865 static u8 sbp_get_fabric_proto_ident(struct se_portal_group *se_tpg) 1866 { 1867 /* 1868 * Return a IEEE 1394 SCSI Protocol identifier for loopback operations 1869 * This is defined in section 7.5.1 Table 362 in spc4r17 1870 */ 1871 return SCSI_PROTOCOL_SBP; 1872 } 1873 1874 static u32 sbp_get_pr_transport_id( 1875 struct se_portal_group *se_tpg, 1876 struct se_node_acl *se_nacl, 1877 struct t10_pr_registration *pr_reg, 1878 int *format_code, 1879 unsigned char *buf) 1880 { 1881 int ret; 1882 1883 /* 1884 * Set PROTOCOL IDENTIFIER to 3h for SBP 1885 */ 1886 buf[0] = SCSI_PROTOCOL_SBP; 1887 /* 1888 * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI 1889 * over IEEE 1394 1890 */ 1891 ret = hex2bin(&buf[8], se_nacl->initiatorname, 8); 1892 if (ret < 0) 1893 pr_debug("sbp transport_id: invalid hex string\n"); 1894 1895 /* 1896 * The IEEE 1394 Transport ID is a hardcoded 24-byte length 1897 */ 1898 return 24; 1899 } 1900 1901 static u32 sbp_get_pr_transport_id_len( 1902 struct se_portal_group *se_tpg, 1903 struct se_node_acl *se_nacl, 1904 struct t10_pr_registration *pr_reg, 1905 int *format_code) 1906 { 1907 *format_code = 0; 1908 /* 1909 * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI 1910 * over IEEE 1394 1911 * 1912 * The SBP Transport ID is a hardcoded 24-byte length 1913 */ 1914 return 24; 1915 } 1916 1917 /* 1918 * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above 1919 * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations. 1920 */ 1921 static char *sbp_parse_pr_out_transport_id( 1922 struct se_portal_group *se_tpg, 1923 const char *buf, 1924 u32 *out_tid_len, 1925 char **port_nexus_ptr) 1926 { 1927 /* 1928 * Assume the FORMAT CODE 00b from spc4r17, 7.5.4.4 TransportID 1929 * for initiator ports using SCSI over SBP Serial SCSI Protocol 1930 * 1931 * The TransportID for a IEEE 1394 Initiator Port is of fixed size of 1932 * 24 bytes, and IEEE 1394 does not contain a I_T nexus identifier, 1933 * so we return the **port_nexus_ptr set to NULL. 1934 */ 1935 *port_nexus_ptr = NULL; 1936 *out_tid_len = 24; 1937 1938 return (char *)&buf[8]; 1939 } 1940 1941 static int sbp_count_se_tpg_luns(struct se_portal_group *tpg) 1942 { 1943 int i, count = 0; 1944 1945 spin_lock(&tpg->tpg_lun_lock); 1946 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 1947 struct se_lun *se_lun = tpg->tpg_lun_list[i]; 1948 1949 if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE) 1950 continue; 1951 1952 count++; 1953 } 1954 spin_unlock(&tpg->tpg_lun_lock); 1955 1956 return count; 1957 } 1958 1959 static int sbp_update_unit_directory(struct sbp_tport *tport) 1960 { 1961 int num_luns, num_entries, idx = 0, mgt_agt_addr, ret, i; 1962 u32 *data; 1963 1964 if (tport->unit_directory.data) { 1965 fw_core_remove_descriptor(&tport->unit_directory); 1966 kfree(tport->unit_directory.data); 1967 tport->unit_directory.data = NULL; 1968 } 1969 1970 if (!tport->enable || !tport->tpg) 1971 return 0; 1972 1973 num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg); 1974 1975 /* 1976 * Number of entries in the final unit directory: 1977 * - all of those in the template 1978 * - management_agent 1979 * - unit_characteristics 1980 * - reconnect_timeout 1981 * - unit unique ID 1982 * - one for each LUN 1983 * 1984 * MUST NOT include leaf or sub-directory entries 1985 */ 1986 num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns; 1987 1988 if (tport->directory_id != -1) 1989 num_entries++; 1990 1991 /* allocate num_entries + 4 for the header and unique ID leaf */ 1992 data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL); 1993 if (!data) 1994 return -ENOMEM; 1995 1996 /* directory_length */ 1997 data[idx++] = num_entries << 16; 1998 1999 /* directory_id */ 2000 if (tport->directory_id != -1) 2001 data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id; 2002 2003 /* unit directory template */ 2004 memcpy(&data[idx], sbp_unit_directory_template, 2005 sizeof(sbp_unit_directory_template)); 2006 idx += ARRAY_SIZE(sbp_unit_directory_template); 2007 2008 /* management_agent */ 2009 mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4; 2010 data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff); 2011 2012 /* unit_characteristics */ 2013 data[idx++] = 0x3a000000 | 2014 (((tport->mgt_orb_timeout * 2) << 8) & 0xff00) | 2015 SBP_ORB_FETCH_SIZE; 2016 2017 /* reconnect_timeout */ 2018 data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff); 2019 2020 /* unit unique ID (leaf is just after LUNs) */ 2021 data[idx++] = 0x8d000000 | (num_luns + 1); 2022 2023 spin_lock(&tport->tpg->se_tpg.tpg_lun_lock); 2024 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 2025 struct se_lun *se_lun = tport->tpg->se_tpg.tpg_lun_list[i]; 2026 struct se_device *dev; 2027 int type; 2028 2029 if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE) 2030 continue; 2031 2032 spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock); 2033 2034 dev = se_lun->lun_se_dev; 2035 type = dev->transport->get_device_type(dev); 2036 2037 /* logical_unit_number */ 2038 data[idx++] = 0x14000000 | 2039 ((type << 16) & 0x1f0000) | 2040 (se_lun->unpacked_lun & 0xffff); 2041 2042 spin_lock(&tport->tpg->se_tpg.tpg_lun_lock); 2043 } 2044 spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock); 2045 2046 /* unit unique ID leaf */ 2047 data[idx++] = 2 << 16; 2048 data[idx++] = tport->guid >> 32; 2049 data[idx++] = tport->guid; 2050 2051 tport->unit_directory.length = idx; 2052 tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24; 2053 tport->unit_directory.data = data; 2054 2055 ret = fw_core_add_descriptor(&tport->unit_directory); 2056 if (ret < 0) { 2057 kfree(tport->unit_directory.data); 2058 tport->unit_directory.data = NULL; 2059 } 2060 2061 return ret; 2062 } 2063 2064 static ssize_t sbp_parse_wwn(const char *name, u64 *wwn) 2065 { 2066 const char *cp; 2067 char c, nibble; 2068 int pos = 0, err; 2069 2070 *wwn = 0; 2071 for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) { 2072 c = *cp; 2073 if (c == '\n' && cp[1] == '\0') 2074 continue; 2075 if (c == '\0') { 2076 err = 2; 2077 if (pos != 16) 2078 goto fail; 2079 return cp - name; 2080 } 2081 err = 3; 2082 if (isdigit(c)) 2083 nibble = c - '0'; 2084 else if (isxdigit(c)) 2085 nibble = tolower(c) - 'a' + 10; 2086 else 2087 goto fail; 2088 *wwn = (*wwn << 4) | nibble; 2089 pos++; 2090 } 2091 err = 4; 2092 fail: 2093 printk(KERN_INFO "err %u len %zu pos %u\n", 2094 err, cp - name, pos); 2095 return -1; 2096 } 2097 2098 static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn) 2099 { 2100 return snprintf(buf, len, "%016llx", wwn); 2101 } 2102 2103 static struct se_node_acl *sbp_make_nodeacl( 2104 struct se_portal_group *se_tpg, 2105 struct config_group *group, 2106 const char *name) 2107 { 2108 struct se_node_acl *se_nacl, *se_nacl_new; 2109 struct sbp_nacl *nacl; 2110 u64 guid = 0; 2111 u32 nexus_depth = 1; 2112 2113 if (sbp_parse_wwn(name, &guid) < 0) 2114 return ERR_PTR(-EINVAL); 2115 2116 se_nacl_new = sbp_alloc_fabric_acl(se_tpg); 2117 if (!se_nacl_new) 2118 return ERR_PTR(-ENOMEM); 2119 2120 /* 2121 * se_nacl_new may be released by core_tpg_add_initiator_node_acl() 2122 * when converting a NodeACL from demo mode -> explict 2123 */ 2124 se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new, 2125 name, nexus_depth); 2126 if (IS_ERR(se_nacl)) { 2127 sbp_release_fabric_acl(se_tpg, se_nacl_new); 2128 return se_nacl; 2129 } 2130 2131 nacl = container_of(se_nacl, struct sbp_nacl, se_node_acl); 2132 nacl->guid = guid; 2133 sbp_format_wwn(nacl->iport_name, SBP_NAMELEN, guid); 2134 2135 return se_nacl; 2136 } 2137 2138 static void sbp_drop_nodeacl(struct se_node_acl *se_acl) 2139 { 2140 struct sbp_nacl *nacl = 2141 container_of(se_acl, struct sbp_nacl, se_node_acl); 2142 2143 core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1); 2144 kfree(nacl); 2145 } 2146 2147 static int sbp_post_link_lun( 2148 struct se_portal_group *se_tpg, 2149 struct se_lun *se_lun) 2150 { 2151 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2152 2153 return sbp_update_unit_directory(tpg->tport); 2154 } 2155 2156 static void sbp_pre_unlink_lun( 2157 struct se_portal_group *se_tpg, 2158 struct se_lun *se_lun) 2159 { 2160 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2161 struct sbp_tport *tport = tpg->tport; 2162 int ret; 2163 2164 if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) 2165 tport->enable = 0; 2166 2167 ret = sbp_update_unit_directory(tport); 2168 if (ret < 0) 2169 pr_err("unlink LUN: failed to update unit directory\n"); 2170 } 2171 2172 static struct se_portal_group *sbp_make_tpg( 2173 struct se_wwn *wwn, 2174 struct config_group *group, 2175 const char *name) 2176 { 2177 struct sbp_tport *tport = 2178 container_of(wwn, struct sbp_tport, tport_wwn); 2179 2180 struct sbp_tpg *tpg; 2181 unsigned long tpgt; 2182 int ret; 2183 2184 if (strstr(name, "tpgt_") != name) 2185 return ERR_PTR(-EINVAL); 2186 if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX) 2187 return ERR_PTR(-EINVAL); 2188 2189 if (tport->tpg) { 2190 pr_err("Only one TPG per Unit is possible.\n"); 2191 return ERR_PTR(-EBUSY); 2192 } 2193 2194 tpg = kzalloc(sizeof(*tpg), GFP_KERNEL); 2195 if (!tpg) { 2196 pr_err("Unable to allocate struct sbp_tpg\n"); 2197 return ERR_PTR(-ENOMEM); 2198 } 2199 2200 tpg->tport = tport; 2201 tpg->tport_tpgt = tpgt; 2202 tport->tpg = tpg; 2203 2204 /* default attribute values */ 2205 tport->enable = 0; 2206 tport->directory_id = -1; 2207 tport->mgt_orb_timeout = 15; 2208 tport->max_reconnect_timeout = 5; 2209 tport->max_logins_per_lun = 1; 2210 2211 tport->mgt_agt = sbp_management_agent_register(tport); 2212 if (IS_ERR(tport->mgt_agt)) { 2213 ret = PTR_ERR(tport->mgt_agt); 2214 goto out_free_tpg; 2215 } 2216 2217 ret = core_tpg_register(&sbp_ops, wwn, &tpg->se_tpg, tpg, 2218 TRANSPORT_TPG_TYPE_NORMAL); 2219 if (ret < 0) 2220 goto out_unreg_mgt_agt; 2221 2222 return &tpg->se_tpg; 2223 2224 out_unreg_mgt_agt: 2225 sbp_management_agent_unregister(tport->mgt_agt); 2226 out_free_tpg: 2227 tport->tpg = NULL; 2228 kfree(tpg); 2229 return ERR_PTR(ret); 2230 } 2231 2232 static void sbp_drop_tpg(struct se_portal_group *se_tpg) 2233 { 2234 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2235 struct sbp_tport *tport = tpg->tport; 2236 2237 core_tpg_deregister(se_tpg); 2238 sbp_management_agent_unregister(tport->mgt_agt); 2239 tport->tpg = NULL; 2240 kfree(tpg); 2241 } 2242 2243 static struct se_wwn *sbp_make_tport( 2244 struct target_fabric_configfs *tf, 2245 struct config_group *group, 2246 const char *name) 2247 { 2248 struct sbp_tport *tport; 2249 u64 guid = 0; 2250 2251 if (sbp_parse_wwn(name, &guid) < 0) 2252 return ERR_PTR(-EINVAL); 2253 2254 tport = kzalloc(sizeof(*tport), GFP_KERNEL); 2255 if (!tport) { 2256 pr_err("Unable to allocate struct sbp_tport\n"); 2257 return ERR_PTR(-ENOMEM); 2258 } 2259 2260 tport->guid = guid; 2261 sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid); 2262 2263 return &tport->tport_wwn; 2264 } 2265 2266 static void sbp_drop_tport(struct se_wwn *wwn) 2267 { 2268 struct sbp_tport *tport = 2269 container_of(wwn, struct sbp_tport, tport_wwn); 2270 2271 kfree(tport); 2272 } 2273 2274 static ssize_t sbp_wwn_show_attr_version( 2275 struct target_fabric_configfs *tf, 2276 char *page) 2277 { 2278 return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION); 2279 } 2280 2281 TF_WWN_ATTR_RO(sbp, version); 2282 2283 static struct configfs_attribute *sbp_wwn_attrs[] = { 2284 &sbp_wwn_version.attr, 2285 NULL, 2286 }; 2287 2288 static ssize_t sbp_tpg_show_directory_id( 2289 struct se_portal_group *se_tpg, 2290 char *page) 2291 { 2292 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2293 struct sbp_tport *tport = tpg->tport; 2294 2295 if (tport->directory_id == -1) 2296 return sprintf(page, "implicit\n"); 2297 else 2298 return sprintf(page, "%06x\n", tport->directory_id); 2299 } 2300 2301 static ssize_t sbp_tpg_store_directory_id( 2302 struct se_portal_group *se_tpg, 2303 const char *page, 2304 size_t count) 2305 { 2306 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2307 struct sbp_tport *tport = tpg->tport; 2308 unsigned long val; 2309 2310 if (tport->enable) { 2311 pr_err("Cannot change the directory_id on an active target.\n"); 2312 return -EBUSY; 2313 } 2314 2315 if (strstr(page, "implicit") == page) { 2316 tport->directory_id = -1; 2317 } else { 2318 if (kstrtoul(page, 16, &val) < 0) 2319 return -EINVAL; 2320 if (val > 0xffffff) 2321 return -EINVAL; 2322 2323 tport->directory_id = val; 2324 } 2325 2326 return count; 2327 } 2328 2329 static ssize_t sbp_tpg_show_enable( 2330 struct se_portal_group *se_tpg, 2331 char *page) 2332 { 2333 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2334 struct sbp_tport *tport = tpg->tport; 2335 return sprintf(page, "%d\n", tport->enable); 2336 } 2337 2338 static ssize_t sbp_tpg_store_enable( 2339 struct se_portal_group *se_tpg, 2340 const char *page, 2341 size_t count) 2342 { 2343 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2344 struct sbp_tport *tport = tpg->tport; 2345 unsigned long val; 2346 int ret; 2347 2348 if (kstrtoul(page, 0, &val) < 0) 2349 return -EINVAL; 2350 if ((val != 0) && (val != 1)) 2351 return -EINVAL; 2352 2353 if (tport->enable == val) 2354 return count; 2355 2356 if (val) { 2357 if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) { 2358 pr_err("Cannot enable a target with no LUNs!\n"); 2359 return -EINVAL; 2360 } 2361 } else { 2362 /* XXX: force-shutdown sessions instead? */ 2363 spin_lock_bh(&se_tpg->session_lock); 2364 if (!list_empty(&se_tpg->tpg_sess_list)) { 2365 spin_unlock_bh(&se_tpg->session_lock); 2366 return -EBUSY; 2367 } 2368 spin_unlock_bh(&se_tpg->session_lock); 2369 } 2370 2371 tport->enable = val; 2372 2373 ret = sbp_update_unit_directory(tport); 2374 if (ret < 0) { 2375 pr_err("Could not update Config ROM\n"); 2376 return ret; 2377 } 2378 2379 return count; 2380 } 2381 2382 TF_TPG_BASE_ATTR(sbp, directory_id, S_IRUGO | S_IWUSR); 2383 TF_TPG_BASE_ATTR(sbp, enable, S_IRUGO | S_IWUSR); 2384 2385 static struct configfs_attribute *sbp_tpg_base_attrs[] = { 2386 &sbp_tpg_directory_id.attr, 2387 &sbp_tpg_enable.attr, 2388 NULL, 2389 }; 2390 2391 static ssize_t sbp_tpg_attrib_show_mgt_orb_timeout( 2392 struct se_portal_group *se_tpg, 2393 char *page) 2394 { 2395 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2396 struct sbp_tport *tport = tpg->tport; 2397 return sprintf(page, "%d\n", tport->mgt_orb_timeout); 2398 } 2399 2400 static ssize_t sbp_tpg_attrib_store_mgt_orb_timeout( 2401 struct se_portal_group *se_tpg, 2402 const char *page, 2403 size_t count) 2404 { 2405 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2406 struct sbp_tport *tport = tpg->tport; 2407 unsigned long val; 2408 int ret; 2409 2410 if (kstrtoul(page, 0, &val) < 0) 2411 return -EINVAL; 2412 if ((val < 1) || (val > 127)) 2413 return -EINVAL; 2414 2415 if (tport->mgt_orb_timeout == val) 2416 return count; 2417 2418 tport->mgt_orb_timeout = val; 2419 2420 ret = sbp_update_unit_directory(tport); 2421 if (ret < 0) 2422 return ret; 2423 2424 return count; 2425 } 2426 2427 static ssize_t sbp_tpg_attrib_show_max_reconnect_timeout( 2428 struct se_portal_group *se_tpg, 2429 char *page) 2430 { 2431 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2432 struct sbp_tport *tport = tpg->tport; 2433 return sprintf(page, "%d\n", tport->max_reconnect_timeout); 2434 } 2435 2436 static ssize_t sbp_tpg_attrib_store_max_reconnect_timeout( 2437 struct se_portal_group *se_tpg, 2438 const char *page, 2439 size_t count) 2440 { 2441 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2442 struct sbp_tport *tport = tpg->tport; 2443 unsigned long val; 2444 int ret; 2445 2446 if (kstrtoul(page, 0, &val) < 0) 2447 return -EINVAL; 2448 if ((val < 1) || (val > 32767)) 2449 return -EINVAL; 2450 2451 if (tport->max_reconnect_timeout == val) 2452 return count; 2453 2454 tport->max_reconnect_timeout = val; 2455 2456 ret = sbp_update_unit_directory(tport); 2457 if (ret < 0) 2458 return ret; 2459 2460 return count; 2461 } 2462 2463 static ssize_t sbp_tpg_attrib_show_max_logins_per_lun( 2464 struct se_portal_group *se_tpg, 2465 char *page) 2466 { 2467 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2468 struct sbp_tport *tport = tpg->tport; 2469 return sprintf(page, "%d\n", tport->max_logins_per_lun); 2470 } 2471 2472 static ssize_t sbp_tpg_attrib_store_max_logins_per_lun( 2473 struct se_portal_group *se_tpg, 2474 const char *page, 2475 size_t count) 2476 { 2477 struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg); 2478 struct sbp_tport *tport = tpg->tport; 2479 unsigned long val; 2480 2481 if (kstrtoul(page, 0, &val) < 0) 2482 return -EINVAL; 2483 if ((val < 1) || (val > 127)) 2484 return -EINVAL; 2485 2486 /* XXX: also check against current count? */ 2487 2488 tport->max_logins_per_lun = val; 2489 2490 return count; 2491 } 2492 2493 TF_TPG_ATTRIB_ATTR(sbp, mgt_orb_timeout, S_IRUGO | S_IWUSR); 2494 TF_TPG_ATTRIB_ATTR(sbp, max_reconnect_timeout, S_IRUGO | S_IWUSR); 2495 TF_TPG_ATTRIB_ATTR(sbp, max_logins_per_lun, S_IRUGO | S_IWUSR); 2496 2497 static struct configfs_attribute *sbp_tpg_attrib_attrs[] = { 2498 &sbp_tpg_attrib_mgt_orb_timeout.attr, 2499 &sbp_tpg_attrib_max_reconnect_timeout.attr, 2500 &sbp_tpg_attrib_max_logins_per_lun.attr, 2501 NULL, 2502 }; 2503 2504 static const struct target_core_fabric_ops sbp_ops = { 2505 .module = THIS_MODULE, 2506 .name = "sbp", 2507 .get_fabric_name = sbp_get_fabric_name, 2508 .get_fabric_proto_ident = sbp_get_fabric_proto_ident, 2509 .tpg_get_wwn = sbp_get_fabric_wwn, 2510 .tpg_get_tag = sbp_get_tag, 2511 .tpg_get_default_depth = sbp_get_default_depth, 2512 .tpg_get_pr_transport_id = sbp_get_pr_transport_id, 2513 .tpg_get_pr_transport_id_len = sbp_get_pr_transport_id_len, 2514 .tpg_parse_pr_out_transport_id = sbp_parse_pr_out_transport_id, 2515 .tpg_check_demo_mode = sbp_check_true, 2516 .tpg_check_demo_mode_cache = sbp_check_true, 2517 .tpg_check_demo_mode_write_protect = sbp_check_false, 2518 .tpg_check_prod_mode_write_protect = sbp_check_false, 2519 .tpg_alloc_fabric_acl = sbp_alloc_fabric_acl, 2520 .tpg_release_fabric_acl = sbp_release_fabric_acl, 2521 .tpg_get_inst_index = sbp_tpg_get_inst_index, 2522 .release_cmd = sbp_release_cmd, 2523 .shutdown_session = sbp_shutdown_session, 2524 .close_session = sbp_close_session, 2525 .sess_get_index = sbp_sess_get_index, 2526 .write_pending = sbp_write_pending, 2527 .write_pending_status = sbp_write_pending_status, 2528 .set_default_node_attributes = sbp_set_default_node_attrs, 2529 .get_task_tag = sbp_get_task_tag, 2530 .get_cmd_state = sbp_get_cmd_state, 2531 .queue_data_in = sbp_queue_data_in, 2532 .queue_status = sbp_queue_status, 2533 .queue_tm_rsp = sbp_queue_tm_rsp, 2534 .aborted_task = sbp_aborted_task, 2535 .check_stop_free = sbp_check_stop_free, 2536 2537 .fabric_make_wwn = sbp_make_tport, 2538 .fabric_drop_wwn = sbp_drop_tport, 2539 .fabric_make_tpg = sbp_make_tpg, 2540 .fabric_drop_tpg = sbp_drop_tpg, 2541 .fabric_post_link = sbp_post_link_lun, 2542 .fabric_pre_unlink = sbp_pre_unlink_lun, 2543 .fabric_make_np = NULL, 2544 .fabric_drop_np = NULL, 2545 .fabric_make_nodeacl = sbp_make_nodeacl, 2546 .fabric_drop_nodeacl = sbp_drop_nodeacl, 2547 2548 .tfc_wwn_attrs = sbp_wwn_attrs, 2549 .tfc_tpg_base_attrs = sbp_tpg_base_attrs, 2550 .tfc_tpg_attrib_attrs = sbp_tpg_attrib_attrs, 2551 }; 2552 2553 static int __init sbp_init(void) 2554 { 2555 return target_register_template(&sbp_ops); 2556 }; 2557 2558 static void __exit sbp_exit(void) 2559 { 2560 target_unregister_template(&sbp_ops); 2561 }; 2562 2563 MODULE_DESCRIPTION("FireWire SBP fabric driver"); 2564 MODULE_LICENSE("GPL"); 2565 module_init(sbp_init); 2566 module_exit(sbp_exit); 2567