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