1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2016 Avago Technologies. All rights reserved. 4 */ 5 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 6 #include <linux/module.h> 7 #include <linux/parser.h> 8 #include <uapi/scsi/fc/fc_fs.h> 9 10 #include "../host/nvme.h" 11 #include "../target/nvmet.h" 12 #include <linux/nvme-fc-driver.h> 13 #include <linux/nvme-fc.h> 14 15 16 enum { 17 NVMF_OPT_ERR = 0, 18 NVMF_OPT_WWNN = 1 << 0, 19 NVMF_OPT_WWPN = 1 << 1, 20 NVMF_OPT_ROLES = 1 << 2, 21 NVMF_OPT_FCADDR = 1 << 3, 22 NVMF_OPT_LPWWNN = 1 << 4, 23 NVMF_OPT_LPWWPN = 1 << 5, 24 }; 25 26 struct fcloop_ctrl_options { 27 int mask; 28 u64 wwnn; 29 u64 wwpn; 30 u32 roles; 31 u32 fcaddr; 32 u64 lpwwnn; 33 u64 lpwwpn; 34 }; 35 36 static const match_table_t opt_tokens = { 37 { NVMF_OPT_WWNN, "wwnn=%s" }, 38 { NVMF_OPT_WWPN, "wwpn=%s" }, 39 { NVMF_OPT_ROLES, "roles=%d" }, 40 { NVMF_OPT_FCADDR, "fcaddr=%x" }, 41 { NVMF_OPT_LPWWNN, "lpwwnn=%s" }, 42 { NVMF_OPT_LPWWPN, "lpwwpn=%s" }, 43 { NVMF_OPT_ERR, NULL } 44 }; 45 46 static int fcloop_verify_addr(substring_t *s) 47 { 48 size_t blen = s->to - s->from + 1; 49 50 if (strnlen(s->from, blen) != NVME_FC_TRADDR_HEXNAMELEN + 2 || 51 strncmp(s->from, "0x", 2)) 52 return -EINVAL; 53 54 return 0; 55 } 56 57 static int 58 fcloop_parse_options(struct fcloop_ctrl_options *opts, 59 const char *buf) 60 { 61 substring_t args[MAX_OPT_ARGS]; 62 char *options, *o, *p; 63 int token, ret = 0; 64 u64 token64; 65 66 options = o = kstrdup(buf, GFP_KERNEL); 67 if (!options) 68 return -ENOMEM; 69 70 while ((p = strsep(&o, ",\n")) != NULL) { 71 if (!*p) 72 continue; 73 74 token = match_token(p, opt_tokens, args); 75 opts->mask |= token; 76 switch (token) { 77 case NVMF_OPT_WWNN: 78 if (fcloop_verify_addr(args) || 79 match_u64(args, &token64)) { 80 ret = -EINVAL; 81 goto out_free_options; 82 } 83 opts->wwnn = token64; 84 break; 85 case NVMF_OPT_WWPN: 86 if (fcloop_verify_addr(args) || 87 match_u64(args, &token64)) { 88 ret = -EINVAL; 89 goto out_free_options; 90 } 91 opts->wwpn = token64; 92 break; 93 case NVMF_OPT_ROLES: 94 if (match_int(args, &token)) { 95 ret = -EINVAL; 96 goto out_free_options; 97 } 98 opts->roles = token; 99 break; 100 case NVMF_OPT_FCADDR: 101 if (match_hex(args, &token)) { 102 ret = -EINVAL; 103 goto out_free_options; 104 } 105 opts->fcaddr = token; 106 break; 107 case NVMF_OPT_LPWWNN: 108 if (fcloop_verify_addr(args) || 109 match_u64(args, &token64)) { 110 ret = -EINVAL; 111 goto out_free_options; 112 } 113 opts->lpwwnn = token64; 114 break; 115 case NVMF_OPT_LPWWPN: 116 if (fcloop_verify_addr(args) || 117 match_u64(args, &token64)) { 118 ret = -EINVAL; 119 goto out_free_options; 120 } 121 opts->lpwwpn = token64; 122 break; 123 default: 124 pr_warn("unknown parameter or missing value '%s'\n", p); 125 ret = -EINVAL; 126 goto out_free_options; 127 } 128 } 129 130 out_free_options: 131 kfree(options); 132 return ret; 133 } 134 135 136 static int 137 fcloop_parse_nm_options(struct device *dev, u64 *nname, u64 *pname, 138 const char *buf) 139 { 140 substring_t args[MAX_OPT_ARGS]; 141 char *options, *o, *p; 142 int token, ret = 0; 143 u64 token64; 144 145 *nname = -1; 146 *pname = -1; 147 148 options = o = kstrdup(buf, GFP_KERNEL); 149 if (!options) 150 return -ENOMEM; 151 152 while ((p = strsep(&o, ",\n")) != NULL) { 153 if (!*p) 154 continue; 155 156 token = match_token(p, opt_tokens, args); 157 switch (token) { 158 case NVMF_OPT_WWNN: 159 if (fcloop_verify_addr(args) || 160 match_u64(args, &token64)) { 161 ret = -EINVAL; 162 goto out_free_options; 163 } 164 *nname = token64; 165 break; 166 case NVMF_OPT_WWPN: 167 if (fcloop_verify_addr(args) || 168 match_u64(args, &token64)) { 169 ret = -EINVAL; 170 goto out_free_options; 171 } 172 *pname = token64; 173 break; 174 default: 175 pr_warn("unknown parameter or missing value '%s'\n", p); 176 ret = -EINVAL; 177 goto out_free_options; 178 } 179 } 180 181 out_free_options: 182 kfree(options); 183 184 if (!ret) { 185 if (*nname == -1) 186 return -EINVAL; 187 if (*pname == -1) 188 return -EINVAL; 189 } 190 191 return ret; 192 } 193 194 195 #define LPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN) 196 197 #define RPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN | \ 198 NVMF_OPT_LPWWNN | NVMF_OPT_LPWWPN) 199 200 #define TGTPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN) 201 202 203 static DEFINE_SPINLOCK(fcloop_lock); 204 static LIST_HEAD(fcloop_lports); 205 static LIST_HEAD(fcloop_nports); 206 207 struct fcloop_lport { 208 struct nvme_fc_local_port *localport; 209 struct list_head lport_list; 210 struct completion unreg_done; 211 }; 212 213 struct fcloop_lport_priv { 214 struct fcloop_lport *lport; 215 }; 216 217 struct fcloop_rport { 218 struct nvme_fc_remote_port *remoteport; 219 struct nvmet_fc_target_port *targetport; 220 struct fcloop_nport *nport; 221 struct fcloop_lport *lport; 222 spinlock_t lock; 223 struct list_head ls_list; 224 struct work_struct ls_work; 225 }; 226 227 struct fcloop_tport { 228 struct nvmet_fc_target_port *targetport; 229 struct nvme_fc_remote_port *remoteport; 230 struct fcloop_nport *nport; 231 struct fcloop_lport *lport; 232 spinlock_t lock; 233 struct list_head ls_list; 234 struct work_struct ls_work; 235 }; 236 237 struct fcloop_nport { 238 struct fcloop_rport *rport; 239 struct fcloop_tport *tport; 240 struct fcloop_lport *lport; 241 struct list_head nport_list; 242 struct kref ref; 243 u64 node_name; 244 u64 port_name; 245 u32 port_role; 246 u32 port_id; 247 }; 248 249 struct fcloop_lsreq { 250 struct nvmefc_ls_req *lsreq; 251 struct nvmefc_ls_rsp ls_rsp; 252 int lsdir; /* H2T or T2H */ 253 int status; 254 struct list_head ls_list; /* fcloop_rport->ls_list */ 255 }; 256 257 struct fcloop_rscn { 258 struct fcloop_tport *tport; 259 struct work_struct work; 260 }; 261 262 enum { 263 INI_IO_START = 0, 264 INI_IO_ACTIVE = 1, 265 INI_IO_ABORTED = 2, 266 INI_IO_COMPLETED = 3, 267 }; 268 269 struct fcloop_fcpreq { 270 struct fcloop_tport *tport; 271 struct nvmefc_fcp_req *fcpreq; 272 spinlock_t reqlock; 273 u16 status; 274 u32 inistate; 275 bool active; 276 bool aborted; 277 struct kref ref; 278 struct work_struct fcp_rcv_work; 279 struct work_struct abort_rcv_work; 280 struct work_struct tio_done_work; 281 struct nvmefc_tgt_fcp_req tgt_fcp_req; 282 }; 283 284 struct fcloop_ini_fcpreq { 285 struct nvmefc_fcp_req *fcpreq; 286 struct fcloop_fcpreq *tfcp_req; 287 spinlock_t inilock; 288 }; 289 290 static inline struct fcloop_lsreq * 291 ls_rsp_to_lsreq(struct nvmefc_ls_rsp *lsrsp) 292 { 293 return container_of(lsrsp, struct fcloop_lsreq, ls_rsp); 294 } 295 296 static inline struct fcloop_fcpreq * 297 tgt_fcp_req_to_fcpreq(struct nvmefc_tgt_fcp_req *tgt_fcpreq) 298 { 299 return container_of(tgt_fcpreq, struct fcloop_fcpreq, tgt_fcp_req); 300 } 301 302 303 static int 304 fcloop_create_queue(struct nvme_fc_local_port *localport, 305 unsigned int qidx, u16 qsize, 306 void **handle) 307 { 308 *handle = localport; 309 return 0; 310 } 311 312 static void 313 fcloop_delete_queue(struct nvme_fc_local_port *localport, 314 unsigned int idx, void *handle) 315 { 316 } 317 318 static void 319 fcloop_rport_lsrqst_work(struct work_struct *work) 320 { 321 struct fcloop_rport *rport = 322 container_of(work, struct fcloop_rport, ls_work); 323 struct fcloop_lsreq *tls_req; 324 325 spin_lock(&rport->lock); 326 for (;;) { 327 tls_req = list_first_entry_or_null(&rport->ls_list, 328 struct fcloop_lsreq, ls_list); 329 if (!tls_req) 330 break; 331 332 list_del(&tls_req->ls_list); 333 spin_unlock(&rport->lock); 334 335 tls_req->lsreq->done(tls_req->lsreq, tls_req->status); 336 /* 337 * callee may free memory containing tls_req. 338 * do not reference lsreq after this. 339 */ 340 341 spin_lock(&rport->lock); 342 } 343 spin_unlock(&rport->lock); 344 } 345 346 static int 347 fcloop_h2t_ls_req(struct nvme_fc_local_port *localport, 348 struct nvme_fc_remote_port *remoteport, 349 struct nvmefc_ls_req *lsreq) 350 { 351 struct fcloop_lsreq *tls_req = lsreq->private; 352 struct fcloop_rport *rport = remoteport->private; 353 int ret = 0; 354 355 tls_req->lsreq = lsreq; 356 INIT_LIST_HEAD(&tls_req->ls_list); 357 358 if (!rport->targetport) { 359 tls_req->status = -ECONNREFUSED; 360 spin_lock(&rport->lock); 361 list_add_tail(&tls_req->ls_list, &rport->ls_list); 362 spin_unlock(&rport->lock); 363 queue_work(nvmet_wq, &rport->ls_work); 364 return ret; 365 } 366 367 tls_req->status = 0; 368 ret = nvmet_fc_rcv_ls_req(rport->targetport, rport, 369 &tls_req->ls_rsp, 370 lsreq->rqstaddr, lsreq->rqstlen); 371 372 return ret; 373 } 374 375 static int 376 fcloop_h2t_xmt_ls_rsp(struct nvmet_fc_target_port *targetport, 377 struct nvmefc_ls_rsp *lsrsp) 378 { 379 struct fcloop_lsreq *tls_req = ls_rsp_to_lsreq(lsrsp); 380 struct nvmefc_ls_req *lsreq = tls_req->lsreq; 381 struct fcloop_tport *tport = targetport->private; 382 struct nvme_fc_remote_port *remoteport = tport->remoteport; 383 struct fcloop_rport *rport; 384 385 memcpy(lsreq->rspaddr, lsrsp->rspbuf, 386 ((lsreq->rsplen < lsrsp->rsplen) ? 387 lsreq->rsplen : lsrsp->rsplen)); 388 389 lsrsp->done(lsrsp); 390 391 if (remoteport) { 392 rport = remoteport->private; 393 spin_lock(&rport->lock); 394 list_add_tail(&tls_req->ls_list, &rport->ls_list); 395 spin_unlock(&rport->lock); 396 queue_work(nvmet_wq, &rport->ls_work); 397 } 398 399 return 0; 400 } 401 402 static void 403 fcloop_tport_lsrqst_work(struct work_struct *work) 404 { 405 struct fcloop_tport *tport = 406 container_of(work, struct fcloop_tport, ls_work); 407 struct fcloop_lsreq *tls_req; 408 409 spin_lock(&tport->lock); 410 for (;;) { 411 tls_req = list_first_entry_or_null(&tport->ls_list, 412 struct fcloop_lsreq, ls_list); 413 if (!tls_req) 414 break; 415 416 list_del(&tls_req->ls_list); 417 spin_unlock(&tport->lock); 418 419 tls_req->lsreq->done(tls_req->lsreq, tls_req->status); 420 /* 421 * callee may free memory containing tls_req. 422 * do not reference lsreq after this. 423 */ 424 425 spin_lock(&tport->lock); 426 } 427 spin_unlock(&tport->lock); 428 } 429 430 static int 431 fcloop_t2h_ls_req(struct nvmet_fc_target_port *targetport, void *hosthandle, 432 struct nvmefc_ls_req *lsreq) 433 { 434 struct fcloop_lsreq *tls_req = lsreq->private; 435 struct fcloop_tport *tport = targetport->private; 436 int ret = 0; 437 438 /* 439 * hosthandle should be the dst.rport value. 440 * hosthandle ignored as fcloop currently is 441 * 1:1 tgtport vs remoteport 442 */ 443 tls_req->lsreq = lsreq; 444 INIT_LIST_HEAD(&tls_req->ls_list); 445 446 if (!tport->remoteport) { 447 tls_req->status = -ECONNREFUSED; 448 spin_lock(&tport->lock); 449 list_add_tail(&tls_req->ls_list, &tport->ls_list); 450 spin_unlock(&tport->lock); 451 queue_work(nvmet_wq, &tport->ls_work); 452 return ret; 453 } 454 455 tls_req->status = 0; 456 ret = nvme_fc_rcv_ls_req(tport->remoteport, &tls_req->ls_rsp, 457 lsreq->rqstaddr, lsreq->rqstlen); 458 459 return ret; 460 } 461 462 static int 463 fcloop_t2h_xmt_ls_rsp(struct nvme_fc_local_port *localport, 464 struct nvme_fc_remote_port *remoteport, 465 struct nvmefc_ls_rsp *lsrsp) 466 { 467 struct fcloop_lsreq *tls_req = ls_rsp_to_lsreq(lsrsp); 468 struct nvmefc_ls_req *lsreq = tls_req->lsreq; 469 struct fcloop_rport *rport = remoteport->private; 470 struct nvmet_fc_target_port *targetport = rport->targetport; 471 struct fcloop_tport *tport; 472 473 memcpy(lsreq->rspaddr, lsrsp->rspbuf, 474 ((lsreq->rsplen < lsrsp->rsplen) ? 475 lsreq->rsplen : lsrsp->rsplen)); 476 lsrsp->done(lsrsp); 477 478 if (targetport) { 479 tport = targetport->private; 480 spin_lock(&tport->lock); 481 list_add_tail(&tport->ls_list, &tls_req->ls_list); 482 spin_unlock(&tport->lock); 483 queue_work(nvmet_wq, &tport->ls_work); 484 } 485 486 return 0; 487 } 488 489 static void 490 fcloop_t2h_host_release(void *hosthandle) 491 { 492 /* host handle ignored for now */ 493 } 494 495 static int 496 fcloop_t2h_host_traddr(void *hosthandle, u64 *wwnn, u64 *wwpn) 497 { 498 struct fcloop_rport *rport = hosthandle; 499 500 *wwnn = rport->lport->localport->node_name; 501 *wwpn = rport->lport->localport->port_name; 502 return 0; 503 } 504 505 /* 506 * Simulate reception of RSCN and converting it to a initiator transport 507 * call to rescan a remote port. 508 */ 509 static void 510 fcloop_tgt_rscn_work(struct work_struct *work) 511 { 512 struct fcloop_rscn *tgt_rscn = 513 container_of(work, struct fcloop_rscn, work); 514 struct fcloop_tport *tport = tgt_rscn->tport; 515 516 if (tport->remoteport) 517 nvme_fc_rescan_remoteport(tport->remoteport); 518 kfree(tgt_rscn); 519 } 520 521 static void 522 fcloop_tgt_discovery_evt(struct nvmet_fc_target_port *tgtport) 523 { 524 struct fcloop_rscn *tgt_rscn; 525 526 tgt_rscn = kzalloc(sizeof(*tgt_rscn), GFP_KERNEL); 527 if (!tgt_rscn) 528 return; 529 530 tgt_rscn->tport = tgtport->private; 531 INIT_WORK(&tgt_rscn->work, fcloop_tgt_rscn_work); 532 533 queue_work(nvmet_wq, &tgt_rscn->work); 534 } 535 536 static void 537 fcloop_tfcp_req_free(struct kref *ref) 538 { 539 struct fcloop_fcpreq *tfcp_req = 540 container_of(ref, struct fcloop_fcpreq, ref); 541 542 kfree(tfcp_req); 543 } 544 545 static void 546 fcloop_tfcp_req_put(struct fcloop_fcpreq *tfcp_req) 547 { 548 kref_put(&tfcp_req->ref, fcloop_tfcp_req_free); 549 } 550 551 static int 552 fcloop_tfcp_req_get(struct fcloop_fcpreq *tfcp_req) 553 { 554 return kref_get_unless_zero(&tfcp_req->ref); 555 } 556 557 static void 558 fcloop_call_host_done(struct nvmefc_fcp_req *fcpreq, 559 struct fcloop_fcpreq *tfcp_req, int status) 560 { 561 struct fcloop_ini_fcpreq *inireq = NULL; 562 563 if (fcpreq) { 564 inireq = fcpreq->private; 565 spin_lock(&inireq->inilock); 566 inireq->tfcp_req = NULL; 567 spin_unlock(&inireq->inilock); 568 569 fcpreq->status = status; 570 fcpreq->done(fcpreq); 571 } 572 573 /* release original io reference on tgt struct */ 574 fcloop_tfcp_req_put(tfcp_req); 575 } 576 577 static bool drop_fabric_opcode; 578 #define DROP_OPCODE_MASK 0x00FF 579 /* fabrics opcode will have a bit set above 1st byte */ 580 static int drop_opcode = -1; 581 static int drop_instance; 582 static int drop_amount; 583 static int drop_current_cnt; 584 585 /* 586 * Routine to parse io and determine if the io is to be dropped. 587 * Returns: 588 * 0 if io is not obstructed 589 * 1 if io was dropped 590 */ 591 static int check_for_drop(struct fcloop_fcpreq *tfcp_req) 592 { 593 struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq; 594 struct nvme_fc_cmd_iu *cmdiu = fcpreq->cmdaddr; 595 struct nvme_command *sqe = &cmdiu->sqe; 596 597 if (drop_opcode == -1) 598 return 0; 599 600 pr_info("%s: seq opcd x%02x fctype x%02x: drop F %s op x%02x " 601 "inst %d start %d amt %d\n", 602 __func__, sqe->common.opcode, sqe->fabrics.fctype, 603 drop_fabric_opcode ? "y" : "n", 604 drop_opcode, drop_current_cnt, drop_instance, drop_amount); 605 606 if ((drop_fabric_opcode && 607 (sqe->common.opcode != nvme_fabrics_command || 608 sqe->fabrics.fctype != drop_opcode)) || 609 (!drop_fabric_opcode && sqe->common.opcode != drop_opcode)) 610 return 0; 611 612 if (++drop_current_cnt >= drop_instance) { 613 if (drop_current_cnt >= drop_instance + drop_amount) 614 drop_opcode = -1; 615 return 1; 616 } 617 618 return 0; 619 } 620 621 static void 622 fcloop_fcp_recv_work(struct work_struct *work) 623 { 624 struct fcloop_fcpreq *tfcp_req = 625 container_of(work, struct fcloop_fcpreq, fcp_rcv_work); 626 struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq; 627 unsigned long flags; 628 int ret = 0; 629 bool aborted = false; 630 631 spin_lock_irqsave(&tfcp_req->reqlock, flags); 632 switch (tfcp_req->inistate) { 633 case INI_IO_START: 634 tfcp_req->inistate = INI_IO_ACTIVE; 635 break; 636 case INI_IO_ABORTED: 637 aborted = true; 638 break; 639 default: 640 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 641 WARN_ON(1); 642 return; 643 } 644 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 645 646 if (unlikely(aborted)) 647 ret = -ECANCELED; 648 else { 649 if (likely(!check_for_drop(tfcp_req))) 650 ret = nvmet_fc_rcv_fcp_req(tfcp_req->tport->targetport, 651 &tfcp_req->tgt_fcp_req, 652 fcpreq->cmdaddr, fcpreq->cmdlen); 653 else 654 pr_info("%s: dropped command ********\n", __func__); 655 } 656 if (ret) 657 fcloop_call_host_done(fcpreq, tfcp_req, ret); 658 } 659 660 static void 661 fcloop_fcp_abort_recv_work(struct work_struct *work) 662 { 663 struct fcloop_fcpreq *tfcp_req = 664 container_of(work, struct fcloop_fcpreq, abort_rcv_work); 665 struct nvmefc_fcp_req *fcpreq; 666 bool completed = false; 667 unsigned long flags; 668 669 spin_lock_irqsave(&tfcp_req->reqlock, flags); 670 fcpreq = tfcp_req->fcpreq; 671 switch (tfcp_req->inistate) { 672 case INI_IO_ABORTED: 673 break; 674 case INI_IO_COMPLETED: 675 completed = true; 676 break; 677 default: 678 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 679 WARN_ON(1); 680 return; 681 } 682 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 683 684 if (unlikely(completed)) { 685 /* remove reference taken in original abort downcall */ 686 fcloop_tfcp_req_put(tfcp_req); 687 return; 688 } 689 690 if (tfcp_req->tport->targetport) 691 nvmet_fc_rcv_fcp_abort(tfcp_req->tport->targetport, 692 &tfcp_req->tgt_fcp_req); 693 694 spin_lock_irqsave(&tfcp_req->reqlock, flags); 695 tfcp_req->fcpreq = NULL; 696 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 697 698 fcloop_call_host_done(fcpreq, tfcp_req, -ECANCELED); 699 /* call_host_done releases reference for abort downcall */ 700 } 701 702 /* 703 * FCP IO operation done by target completion. 704 * call back up initiator "done" flows. 705 */ 706 static void 707 fcloop_tgt_fcprqst_done_work(struct work_struct *work) 708 { 709 struct fcloop_fcpreq *tfcp_req = 710 container_of(work, struct fcloop_fcpreq, tio_done_work); 711 struct nvmefc_fcp_req *fcpreq; 712 unsigned long flags; 713 714 spin_lock_irqsave(&tfcp_req->reqlock, flags); 715 fcpreq = tfcp_req->fcpreq; 716 tfcp_req->inistate = INI_IO_COMPLETED; 717 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 718 719 fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status); 720 } 721 722 723 static int 724 fcloop_fcp_req(struct nvme_fc_local_port *localport, 725 struct nvme_fc_remote_port *remoteport, 726 void *hw_queue_handle, 727 struct nvmefc_fcp_req *fcpreq) 728 { 729 struct fcloop_rport *rport = remoteport->private; 730 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 731 struct fcloop_fcpreq *tfcp_req; 732 733 if (!rport->targetport) 734 return -ECONNREFUSED; 735 736 tfcp_req = kzalloc(sizeof(*tfcp_req), GFP_ATOMIC); 737 if (!tfcp_req) 738 return -ENOMEM; 739 740 inireq->fcpreq = fcpreq; 741 inireq->tfcp_req = tfcp_req; 742 spin_lock_init(&inireq->inilock); 743 744 tfcp_req->fcpreq = fcpreq; 745 tfcp_req->tport = rport->targetport->private; 746 tfcp_req->inistate = INI_IO_START; 747 spin_lock_init(&tfcp_req->reqlock); 748 INIT_WORK(&tfcp_req->fcp_rcv_work, fcloop_fcp_recv_work); 749 INIT_WORK(&tfcp_req->abort_rcv_work, fcloop_fcp_abort_recv_work); 750 INIT_WORK(&tfcp_req->tio_done_work, fcloop_tgt_fcprqst_done_work); 751 kref_init(&tfcp_req->ref); 752 753 queue_work(nvmet_wq, &tfcp_req->fcp_rcv_work); 754 755 return 0; 756 } 757 758 static void 759 fcloop_fcp_copy_data(u8 op, struct scatterlist *data_sg, 760 struct scatterlist *io_sg, u32 offset, u32 length) 761 { 762 void *data_p, *io_p; 763 u32 data_len, io_len, tlen; 764 765 io_p = sg_virt(io_sg); 766 io_len = io_sg->length; 767 768 for ( ; offset; ) { 769 tlen = min_t(u32, offset, io_len); 770 offset -= tlen; 771 io_len -= tlen; 772 if (!io_len) { 773 io_sg = sg_next(io_sg); 774 io_p = sg_virt(io_sg); 775 io_len = io_sg->length; 776 } else 777 io_p += tlen; 778 } 779 780 data_p = sg_virt(data_sg); 781 data_len = data_sg->length; 782 783 for ( ; length; ) { 784 tlen = min_t(u32, io_len, data_len); 785 tlen = min_t(u32, tlen, length); 786 787 if (op == NVMET_FCOP_WRITEDATA) 788 memcpy(data_p, io_p, tlen); 789 else 790 memcpy(io_p, data_p, tlen); 791 792 length -= tlen; 793 794 io_len -= tlen; 795 if ((!io_len) && (length)) { 796 io_sg = sg_next(io_sg); 797 io_p = sg_virt(io_sg); 798 io_len = io_sg->length; 799 } else 800 io_p += tlen; 801 802 data_len -= tlen; 803 if ((!data_len) && (length)) { 804 data_sg = sg_next(data_sg); 805 data_p = sg_virt(data_sg); 806 data_len = data_sg->length; 807 } else 808 data_p += tlen; 809 } 810 } 811 812 static int 813 fcloop_fcp_op(struct nvmet_fc_target_port *tgtport, 814 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 815 { 816 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 817 struct nvmefc_fcp_req *fcpreq; 818 u32 rsplen = 0, xfrlen = 0; 819 int fcp_err = 0, active, aborted; 820 u8 op = tgt_fcpreq->op; 821 unsigned long flags; 822 823 spin_lock_irqsave(&tfcp_req->reqlock, flags); 824 fcpreq = tfcp_req->fcpreq; 825 active = tfcp_req->active; 826 aborted = tfcp_req->aborted; 827 tfcp_req->active = true; 828 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 829 830 if (unlikely(active)) 831 /* illegal - call while i/o active */ 832 return -EALREADY; 833 834 if (unlikely(aborted)) { 835 /* target transport has aborted i/o prior */ 836 spin_lock_irqsave(&tfcp_req->reqlock, flags); 837 tfcp_req->active = false; 838 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 839 tgt_fcpreq->transferred_length = 0; 840 tgt_fcpreq->fcp_error = -ECANCELED; 841 tgt_fcpreq->done(tgt_fcpreq); 842 return 0; 843 } 844 845 /* 846 * if fcpreq is NULL, the I/O has been aborted (from 847 * initiator side). For the target side, act as if all is well 848 * but don't actually move data. 849 */ 850 851 switch (op) { 852 case NVMET_FCOP_WRITEDATA: 853 xfrlen = tgt_fcpreq->transfer_length; 854 if (fcpreq) { 855 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 856 fcpreq->first_sgl, tgt_fcpreq->offset, 857 xfrlen); 858 fcpreq->transferred_length += xfrlen; 859 } 860 break; 861 862 case NVMET_FCOP_READDATA: 863 case NVMET_FCOP_READDATA_RSP: 864 xfrlen = tgt_fcpreq->transfer_length; 865 if (fcpreq) { 866 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 867 fcpreq->first_sgl, tgt_fcpreq->offset, 868 xfrlen); 869 fcpreq->transferred_length += xfrlen; 870 } 871 if (op == NVMET_FCOP_READDATA) 872 break; 873 874 /* Fall-Thru to RSP handling */ 875 fallthrough; 876 877 case NVMET_FCOP_RSP: 878 if (fcpreq) { 879 rsplen = ((fcpreq->rsplen < tgt_fcpreq->rsplen) ? 880 fcpreq->rsplen : tgt_fcpreq->rsplen); 881 memcpy(fcpreq->rspaddr, tgt_fcpreq->rspaddr, rsplen); 882 if (rsplen < tgt_fcpreq->rsplen) 883 fcp_err = -E2BIG; 884 fcpreq->rcv_rsplen = rsplen; 885 fcpreq->status = 0; 886 } 887 tfcp_req->status = 0; 888 break; 889 890 default: 891 fcp_err = -EINVAL; 892 break; 893 } 894 895 spin_lock_irqsave(&tfcp_req->reqlock, flags); 896 tfcp_req->active = false; 897 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 898 899 tgt_fcpreq->transferred_length = xfrlen; 900 tgt_fcpreq->fcp_error = fcp_err; 901 tgt_fcpreq->done(tgt_fcpreq); 902 903 return 0; 904 } 905 906 static void 907 fcloop_tgt_fcp_abort(struct nvmet_fc_target_port *tgtport, 908 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 909 { 910 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 911 unsigned long flags; 912 913 /* 914 * mark aborted only in case there were 2 threads in transport 915 * (one doing io, other doing abort) and only kills ops posted 916 * after the abort request 917 */ 918 spin_lock_irqsave(&tfcp_req->reqlock, flags); 919 tfcp_req->aborted = true; 920 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 921 922 tfcp_req->status = NVME_SC_INTERNAL; 923 924 /* 925 * nothing more to do. If io wasn't active, the transport should 926 * immediately call the req_release. If it was active, the op 927 * will complete, and the lldd should call req_release. 928 */ 929 } 930 931 static void 932 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport, 933 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 934 { 935 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 936 937 queue_work(nvmet_wq, &tfcp_req->tio_done_work); 938 } 939 940 static void 941 fcloop_h2t_ls_abort(struct nvme_fc_local_port *localport, 942 struct nvme_fc_remote_port *remoteport, 943 struct nvmefc_ls_req *lsreq) 944 { 945 } 946 947 static void 948 fcloop_t2h_ls_abort(struct nvmet_fc_target_port *targetport, 949 void *hosthandle, struct nvmefc_ls_req *lsreq) 950 { 951 } 952 953 static void 954 fcloop_fcp_abort(struct nvme_fc_local_port *localport, 955 struct nvme_fc_remote_port *remoteport, 956 void *hw_queue_handle, 957 struct nvmefc_fcp_req *fcpreq) 958 { 959 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 960 struct fcloop_fcpreq *tfcp_req; 961 bool abortio = true; 962 unsigned long flags; 963 964 spin_lock(&inireq->inilock); 965 tfcp_req = inireq->tfcp_req; 966 if (tfcp_req) 967 fcloop_tfcp_req_get(tfcp_req); 968 spin_unlock(&inireq->inilock); 969 970 if (!tfcp_req) 971 /* abort has already been called */ 972 return; 973 974 /* break initiator/target relationship for io */ 975 spin_lock_irqsave(&tfcp_req->reqlock, flags); 976 switch (tfcp_req->inistate) { 977 case INI_IO_START: 978 case INI_IO_ACTIVE: 979 tfcp_req->inistate = INI_IO_ABORTED; 980 break; 981 case INI_IO_COMPLETED: 982 abortio = false; 983 break; 984 default: 985 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 986 WARN_ON(1); 987 return; 988 } 989 spin_unlock_irqrestore(&tfcp_req->reqlock, flags); 990 991 if (abortio) 992 /* leave the reference while the work item is scheduled */ 993 WARN_ON(!queue_work(nvmet_wq, &tfcp_req->abort_rcv_work)); 994 else { 995 /* 996 * as the io has already had the done callback made, 997 * nothing more to do. So release the reference taken above 998 */ 999 fcloop_tfcp_req_put(tfcp_req); 1000 } 1001 } 1002 1003 static void 1004 fcloop_nport_free(struct kref *ref) 1005 { 1006 struct fcloop_nport *nport = 1007 container_of(ref, struct fcloop_nport, ref); 1008 1009 kfree(nport); 1010 } 1011 1012 static void 1013 fcloop_nport_put(struct fcloop_nport *nport) 1014 { 1015 kref_put(&nport->ref, fcloop_nport_free); 1016 } 1017 1018 static int 1019 fcloop_nport_get(struct fcloop_nport *nport) 1020 { 1021 return kref_get_unless_zero(&nport->ref); 1022 } 1023 1024 static void 1025 fcloop_localport_delete(struct nvme_fc_local_port *localport) 1026 { 1027 struct fcloop_lport_priv *lport_priv = localport->private; 1028 struct fcloop_lport *lport = lport_priv->lport; 1029 1030 /* release any threads waiting for the unreg to complete */ 1031 complete(&lport->unreg_done); 1032 } 1033 1034 static void 1035 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport) 1036 { 1037 struct fcloop_rport *rport = remoteport->private; 1038 1039 flush_work(&rport->ls_work); 1040 fcloop_nport_put(rport->nport); 1041 } 1042 1043 static void 1044 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport) 1045 { 1046 struct fcloop_tport *tport = targetport->private; 1047 1048 flush_work(&tport->ls_work); 1049 fcloop_nport_put(tport->nport); 1050 } 1051 1052 #define FCLOOP_HW_QUEUES 4 1053 #define FCLOOP_SGL_SEGS 256 1054 #define FCLOOP_DMABOUND_4G 0xFFFFFFFF 1055 1056 static struct nvme_fc_port_template fctemplate = { 1057 .localport_delete = fcloop_localport_delete, 1058 .remoteport_delete = fcloop_remoteport_delete, 1059 .create_queue = fcloop_create_queue, 1060 .delete_queue = fcloop_delete_queue, 1061 .ls_req = fcloop_h2t_ls_req, 1062 .fcp_io = fcloop_fcp_req, 1063 .ls_abort = fcloop_h2t_ls_abort, 1064 .fcp_abort = fcloop_fcp_abort, 1065 .xmt_ls_rsp = fcloop_t2h_xmt_ls_rsp, 1066 .max_hw_queues = FCLOOP_HW_QUEUES, 1067 .max_sgl_segments = FCLOOP_SGL_SEGS, 1068 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 1069 .dma_boundary = FCLOOP_DMABOUND_4G, 1070 /* sizes of additional private data for data structures */ 1071 .local_priv_sz = sizeof(struct fcloop_lport_priv), 1072 .remote_priv_sz = sizeof(struct fcloop_rport), 1073 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq), 1074 .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq), 1075 }; 1076 1077 static struct nvmet_fc_target_template tgttemplate = { 1078 .targetport_delete = fcloop_targetport_delete, 1079 .xmt_ls_rsp = fcloop_h2t_xmt_ls_rsp, 1080 .fcp_op = fcloop_fcp_op, 1081 .fcp_abort = fcloop_tgt_fcp_abort, 1082 .fcp_req_release = fcloop_fcp_req_release, 1083 .discovery_event = fcloop_tgt_discovery_evt, 1084 .ls_req = fcloop_t2h_ls_req, 1085 .ls_abort = fcloop_t2h_ls_abort, 1086 .host_release = fcloop_t2h_host_release, 1087 .host_traddr = fcloop_t2h_host_traddr, 1088 .max_hw_queues = FCLOOP_HW_QUEUES, 1089 .max_sgl_segments = FCLOOP_SGL_SEGS, 1090 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 1091 .dma_boundary = FCLOOP_DMABOUND_4G, 1092 /* optional features */ 1093 .target_features = 0, 1094 /* sizes of additional private data for data structures */ 1095 .target_priv_sz = sizeof(struct fcloop_tport), 1096 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq), 1097 }; 1098 1099 static ssize_t 1100 fcloop_create_local_port(struct device *dev, struct device_attribute *attr, 1101 const char *buf, size_t count) 1102 { 1103 struct nvme_fc_port_info pinfo; 1104 struct fcloop_ctrl_options *opts; 1105 struct nvme_fc_local_port *localport; 1106 struct fcloop_lport *lport; 1107 struct fcloop_lport_priv *lport_priv; 1108 unsigned long flags; 1109 int ret = -ENOMEM; 1110 1111 lport = kzalloc(sizeof(*lport), GFP_KERNEL); 1112 if (!lport) 1113 return -ENOMEM; 1114 1115 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 1116 if (!opts) 1117 goto out_free_lport; 1118 1119 ret = fcloop_parse_options(opts, buf); 1120 if (ret) 1121 goto out_free_opts; 1122 1123 /* everything there ? */ 1124 if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) { 1125 ret = -EINVAL; 1126 goto out_free_opts; 1127 } 1128 1129 memset(&pinfo, 0, sizeof(pinfo)); 1130 pinfo.node_name = opts->wwnn; 1131 pinfo.port_name = opts->wwpn; 1132 pinfo.port_role = opts->roles; 1133 pinfo.port_id = opts->fcaddr; 1134 1135 ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport); 1136 if (!ret) { 1137 /* success */ 1138 lport_priv = localport->private; 1139 lport_priv->lport = lport; 1140 1141 lport->localport = localport; 1142 INIT_LIST_HEAD(&lport->lport_list); 1143 1144 spin_lock_irqsave(&fcloop_lock, flags); 1145 list_add_tail(&lport->lport_list, &fcloop_lports); 1146 spin_unlock_irqrestore(&fcloop_lock, flags); 1147 } 1148 1149 out_free_opts: 1150 kfree(opts); 1151 out_free_lport: 1152 /* free only if we're going to fail */ 1153 if (ret) 1154 kfree(lport); 1155 1156 return ret ? ret : count; 1157 } 1158 1159 1160 static void 1161 __unlink_local_port(struct fcloop_lport *lport) 1162 { 1163 list_del(&lport->lport_list); 1164 } 1165 1166 static int 1167 __wait_localport_unreg(struct fcloop_lport *lport) 1168 { 1169 int ret; 1170 1171 init_completion(&lport->unreg_done); 1172 1173 ret = nvme_fc_unregister_localport(lport->localport); 1174 1175 if (!ret) 1176 wait_for_completion(&lport->unreg_done); 1177 1178 kfree(lport); 1179 1180 return ret; 1181 } 1182 1183 1184 static ssize_t 1185 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr, 1186 const char *buf, size_t count) 1187 { 1188 struct fcloop_lport *tlport, *lport = NULL; 1189 u64 nodename, portname; 1190 unsigned long flags; 1191 int ret; 1192 1193 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1194 if (ret) 1195 return ret; 1196 1197 spin_lock_irqsave(&fcloop_lock, flags); 1198 1199 list_for_each_entry(tlport, &fcloop_lports, lport_list) { 1200 if (tlport->localport->node_name == nodename && 1201 tlport->localport->port_name == portname) { 1202 lport = tlport; 1203 __unlink_local_port(lport); 1204 break; 1205 } 1206 } 1207 spin_unlock_irqrestore(&fcloop_lock, flags); 1208 1209 if (!lport) 1210 return -ENOENT; 1211 1212 ret = __wait_localport_unreg(lport); 1213 1214 return ret ? ret : count; 1215 } 1216 1217 static struct fcloop_nport * 1218 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport) 1219 { 1220 struct fcloop_nport *newnport, *nport = NULL; 1221 struct fcloop_lport *tmplport, *lport = NULL; 1222 struct fcloop_ctrl_options *opts; 1223 unsigned long flags; 1224 u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS; 1225 int ret; 1226 1227 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 1228 if (!opts) 1229 return NULL; 1230 1231 ret = fcloop_parse_options(opts, buf); 1232 if (ret) 1233 goto out_free_opts; 1234 1235 /* everything there ? */ 1236 if ((opts->mask & opts_mask) != opts_mask) { 1237 ret = -EINVAL; 1238 goto out_free_opts; 1239 } 1240 1241 newnport = kzalloc(sizeof(*newnport), GFP_KERNEL); 1242 if (!newnport) 1243 goto out_free_opts; 1244 1245 INIT_LIST_HEAD(&newnport->nport_list); 1246 newnport->node_name = opts->wwnn; 1247 newnport->port_name = opts->wwpn; 1248 if (opts->mask & NVMF_OPT_ROLES) 1249 newnport->port_role = opts->roles; 1250 if (opts->mask & NVMF_OPT_FCADDR) 1251 newnport->port_id = opts->fcaddr; 1252 kref_init(&newnport->ref); 1253 1254 spin_lock_irqsave(&fcloop_lock, flags); 1255 1256 list_for_each_entry(tmplport, &fcloop_lports, lport_list) { 1257 if (tmplport->localport->node_name == opts->wwnn && 1258 tmplport->localport->port_name == opts->wwpn) 1259 goto out_invalid_opts; 1260 1261 if (tmplport->localport->node_name == opts->lpwwnn && 1262 tmplport->localport->port_name == opts->lpwwpn) 1263 lport = tmplport; 1264 } 1265 1266 if (remoteport) { 1267 if (!lport) 1268 goto out_invalid_opts; 1269 newnport->lport = lport; 1270 } 1271 1272 list_for_each_entry(nport, &fcloop_nports, nport_list) { 1273 if (nport->node_name == opts->wwnn && 1274 nport->port_name == opts->wwpn) { 1275 if ((remoteport && nport->rport) || 1276 (!remoteport && nport->tport)) { 1277 nport = NULL; 1278 goto out_invalid_opts; 1279 } 1280 1281 fcloop_nport_get(nport); 1282 1283 spin_unlock_irqrestore(&fcloop_lock, flags); 1284 1285 if (remoteport) 1286 nport->lport = lport; 1287 if (opts->mask & NVMF_OPT_ROLES) 1288 nport->port_role = opts->roles; 1289 if (opts->mask & NVMF_OPT_FCADDR) 1290 nport->port_id = opts->fcaddr; 1291 goto out_free_newnport; 1292 } 1293 } 1294 1295 list_add_tail(&newnport->nport_list, &fcloop_nports); 1296 1297 spin_unlock_irqrestore(&fcloop_lock, flags); 1298 1299 kfree(opts); 1300 return newnport; 1301 1302 out_invalid_opts: 1303 spin_unlock_irqrestore(&fcloop_lock, flags); 1304 out_free_newnport: 1305 kfree(newnport); 1306 out_free_opts: 1307 kfree(opts); 1308 return nport; 1309 } 1310 1311 static ssize_t 1312 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr, 1313 const char *buf, size_t count) 1314 { 1315 struct nvme_fc_remote_port *remoteport; 1316 struct fcloop_nport *nport; 1317 struct fcloop_rport *rport; 1318 struct nvme_fc_port_info pinfo; 1319 int ret; 1320 1321 nport = fcloop_alloc_nport(buf, count, true); 1322 if (!nport) 1323 return -EIO; 1324 1325 memset(&pinfo, 0, sizeof(pinfo)); 1326 pinfo.node_name = nport->node_name; 1327 pinfo.port_name = nport->port_name; 1328 pinfo.port_role = nport->port_role; 1329 pinfo.port_id = nport->port_id; 1330 1331 ret = nvme_fc_register_remoteport(nport->lport->localport, 1332 &pinfo, &remoteport); 1333 if (ret || !remoteport) { 1334 fcloop_nport_put(nport); 1335 return ret; 1336 } 1337 1338 /* success */ 1339 rport = remoteport->private; 1340 rport->remoteport = remoteport; 1341 rport->targetport = (nport->tport) ? nport->tport->targetport : NULL; 1342 if (nport->tport) { 1343 nport->tport->remoteport = remoteport; 1344 nport->tport->lport = nport->lport; 1345 } 1346 rport->nport = nport; 1347 rport->lport = nport->lport; 1348 nport->rport = rport; 1349 spin_lock_init(&rport->lock); 1350 INIT_WORK(&rport->ls_work, fcloop_rport_lsrqst_work); 1351 INIT_LIST_HEAD(&rport->ls_list); 1352 1353 return count; 1354 } 1355 1356 1357 static struct fcloop_rport * 1358 __unlink_remote_port(struct fcloop_nport *nport) 1359 { 1360 struct fcloop_rport *rport = nport->rport; 1361 1362 if (rport && nport->tport) 1363 nport->tport->remoteport = NULL; 1364 nport->rport = NULL; 1365 1366 list_del(&nport->nport_list); 1367 1368 return rport; 1369 } 1370 1371 static int 1372 __remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport) 1373 { 1374 if (!rport) 1375 return -EALREADY; 1376 1377 return nvme_fc_unregister_remoteport(rport->remoteport); 1378 } 1379 1380 static ssize_t 1381 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr, 1382 const char *buf, size_t count) 1383 { 1384 struct fcloop_nport *nport = NULL, *tmpport; 1385 static struct fcloop_rport *rport; 1386 u64 nodename, portname; 1387 unsigned long flags; 1388 int ret; 1389 1390 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1391 if (ret) 1392 return ret; 1393 1394 spin_lock_irqsave(&fcloop_lock, flags); 1395 1396 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1397 if (tmpport->node_name == nodename && 1398 tmpport->port_name == portname && tmpport->rport) { 1399 nport = tmpport; 1400 rport = __unlink_remote_port(nport); 1401 break; 1402 } 1403 } 1404 1405 spin_unlock_irqrestore(&fcloop_lock, flags); 1406 1407 if (!nport) 1408 return -ENOENT; 1409 1410 ret = __remoteport_unreg(nport, rport); 1411 1412 return ret ? ret : count; 1413 } 1414 1415 static ssize_t 1416 fcloop_create_target_port(struct device *dev, struct device_attribute *attr, 1417 const char *buf, size_t count) 1418 { 1419 struct nvmet_fc_target_port *targetport; 1420 struct fcloop_nport *nport; 1421 struct fcloop_tport *tport; 1422 struct nvmet_fc_port_info tinfo; 1423 int ret; 1424 1425 nport = fcloop_alloc_nport(buf, count, false); 1426 if (!nport) 1427 return -EIO; 1428 1429 tinfo.node_name = nport->node_name; 1430 tinfo.port_name = nport->port_name; 1431 tinfo.port_id = nport->port_id; 1432 1433 ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL, 1434 &targetport); 1435 if (ret) { 1436 fcloop_nport_put(nport); 1437 return ret; 1438 } 1439 1440 /* success */ 1441 tport = targetport->private; 1442 tport->targetport = targetport; 1443 tport->remoteport = (nport->rport) ? nport->rport->remoteport : NULL; 1444 if (nport->rport) 1445 nport->rport->targetport = targetport; 1446 tport->nport = nport; 1447 tport->lport = nport->lport; 1448 nport->tport = tport; 1449 spin_lock_init(&tport->lock); 1450 INIT_WORK(&tport->ls_work, fcloop_tport_lsrqst_work); 1451 INIT_LIST_HEAD(&tport->ls_list); 1452 1453 return count; 1454 } 1455 1456 1457 static struct fcloop_tport * 1458 __unlink_target_port(struct fcloop_nport *nport) 1459 { 1460 struct fcloop_tport *tport = nport->tport; 1461 1462 if (tport && nport->rport) 1463 nport->rport->targetport = NULL; 1464 nport->tport = NULL; 1465 1466 return tport; 1467 } 1468 1469 static int 1470 __targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport) 1471 { 1472 if (!tport) 1473 return -EALREADY; 1474 1475 return nvmet_fc_unregister_targetport(tport->targetport); 1476 } 1477 1478 static ssize_t 1479 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr, 1480 const char *buf, size_t count) 1481 { 1482 struct fcloop_nport *nport = NULL, *tmpport; 1483 struct fcloop_tport *tport = NULL; 1484 u64 nodename, portname; 1485 unsigned long flags; 1486 int ret; 1487 1488 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1489 if (ret) 1490 return ret; 1491 1492 spin_lock_irqsave(&fcloop_lock, flags); 1493 1494 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1495 if (tmpport->node_name == nodename && 1496 tmpport->port_name == portname && tmpport->tport) { 1497 nport = tmpport; 1498 tport = __unlink_target_port(nport); 1499 break; 1500 } 1501 } 1502 1503 spin_unlock_irqrestore(&fcloop_lock, flags); 1504 1505 if (!nport) 1506 return -ENOENT; 1507 1508 ret = __targetport_unreg(nport, tport); 1509 1510 return ret ? ret : count; 1511 } 1512 1513 static ssize_t 1514 fcloop_set_cmd_drop(struct device *dev, struct device_attribute *attr, 1515 const char *buf, size_t count) 1516 { 1517 unsigned int opcode; 1518 int starting, amount; 1519 1520 if (sscanf(buf, "%x:%d:%d", &opcode, &starting, &amount) != 3) 1521 return -EBADRQC; 1522 1523 drop_current_cnt = 0; 1524 drop_fabric_opcode = (opcode & ~DROP_OPCODE_MASK) ? true : false; 1525 drop_opcode = (opcode & DROP_OPCODE_MASK); 1526 drop_instance = starting; 1527 /* the check to drop routine uses instance + count to know when 1528 * to end. Thus, if dropping 1 instance, count should be 0. 1529 * so subtract 1 from the count. 1530 */ 1531 drop_amount = amount - 1; 1532 1533 pr_info("%s: DROP: Starting at instance %d of%s opcode x%x drop +%d " 1534 "instances\n", 1535 __func__, drop_instance, drop_fabric_opcode ? " fabric" : "", 1536 drop_opcode, drop_amount); 1537 1538 return count; 1539 } 1540 1541 1542 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port); 1543 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port); 1544 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port); 1545 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port); 1546 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port); 1547 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port); 1548 static DEVICE_ATTR(set_cmd_drop, 0200, NULL, fcloop_set_cmd_drop); 1549 1550 static struct attribute *fcloop_dev_attrs[] = { 1551 &dev_attr_add_local_port.attr, 1552 &dev_attr_del_local_port.attr, 1553 &dev_attr_add_remote_port.attr, 1554 &dev_attr_del_remote_port.attr, 1555 &dev_attr_add_target_port.attr, 1556 &dev_attr_del_target_port.attr, 1557 &dev_attr_set_cmd_drop.attr, 1558 NULL 1559 }; 1560 1561 static const struct attribute_group fclopp_dev_attrs_group = { 1562 .attrs = fcloop_dev_attrs, 1563 }; 1564 1565 static const struct attribute_group *fcloop_dev_attr_groups[] = { 1566 &fclopp_dev_attrs_group, 1567 NULL, 1568 }; 1569 1570 static const struct class fcloop_class = { 1571 .name = "fcloop", 1572 }; 1573 static struct device *fcloop_device; 1574 1575 1576 static int __init fcloop_init(void) 1577 { 1578 int ret; 1579 1580 ret = class_register(&fcloop_class); 1581 if (ret) { 1582 pr_err("couldn't register class fcloop\n"); 1583 return ret; 1584 } 1585 1586 fcloop_device = device_create_with_groups( 1587 &fcloop_class, NULL, MKDEV(0, 0), NULL, 1588 fcloop_dev_attr_groups, "ctl"); 1589 if (IS_ERR(fcloop_device)) { 1590 pr_err("couldn't create ctl device!\n"); 1591 ret = PTR_ERR(fcloop_device); 1592 goto out_destroy_class; 1593 } 1594 1595 get_device(fcloop_device); 1596 1597 return 0; 1598 1599 out_destroy_class: 1600 class_unregister(&fcloop_class); 1601 return ret; 1602 } 1603 1604 static void __exit fcloop_exit(void) 1605 { 1606 struct fcloop_lport *lport = NULL; 1607 struct fcloop_nport *nport = NULL; 1608 struct fcloop_tport *tport; 1609 struct fcloop_rport *rport; 1610 unsigned long flags; 1611 int ret; 1612 1613 spin_lock_irqsave(&fcloop_lock, flags); 1614 1615 for (;;) { 1616 nport = list_first_entry_or_null(&fcloop_nports, 1617 typeof(*nport), nport_list); 1618 if (!nport) 1619 break; 1620 1621 tport = __unlink_target_port(nport); 1622 rport = __unlink_remote_port(nport); 1623 1624 spin_unlock_irqrestore(&fcloop_lock, flags); 1625 1626 ret = __targetport_unreg(nport, tport); 1627 if (ret) 1628 pr_warn("%s: Failed deleting target port\n", __func__); 1629 1630 ret = __remoteport_unreg(nport, rport); 1631 if (ret) 1632 pr_warn("%s: Failed deleting remote port\n", __func__); 1633 1634 spin_lock_irqsave(&fcloop_lock, flags); 1635 } 1636 1637 for (;;) { 1638 lport = list_first_entry_or_null(&fcloop_lports, 1639 typeof(*lport), lport_list); 1640 if (!lport) 1641 break; 1642 1643 __unlink_local_port(lport); 1644 1645 spin_unlock_irqrestore(&fcloop_lock, flags); 1646 1647 ret = __wait_localport_unreg(lport); 1648 if (ret) 1649 pr_warn("%s: Failed deleting local port\n", __func__); 1650 1651 spin_lock_irqsave(&fcloop_lock, flags); 1652 } 1653 1654 spin_unlock_irqrestore(&fcloop_lock, flags); 1655 1656 put_device(fcloop_device); 1657 1658 device_destroy(&fcloop_class, MKDEV(0, 0)); 1659 class_unregister(&fcloop_class); 1660 } 1661 1662 module_init(fcloop_init); 1663 module_exit(fcloop_exit); 1664 1665 MODULE_DESCRIPTION("NVMe target FC loop transport driver"); 1666 MODULE_LICENSE("GPL v2"); 1667