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