1 /* 2 * Copyright (c) 2016 Avago Technologies. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of version 2 of the GNU General Public License as 6 * published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful. 9 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 10 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 11 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED, EXCEPT TO 12 * THE EXTENT THAT SUCH DISCLAIMERS ARE HELD TO BE LEGALLY INVALID. 13 * See the GNU General Public License for more details, a copy of which 14 * can be found in the file COPYING included with this package 15 */ 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 #include <linux/module.h> 18 #include <linux/parser.h> 19 #include <uapi/scsi/fc/fc_fs.h> 20 21 #include "../host/nvme.h" 22 #include "../target/nvmet.h" 23 #include <linux/nvme-fc-driver.h> 24 #include <linux/nvme-fc.h> 25 26 27 enum { 28 NVMF_OPT_ERR = 0, 29 NVMF_OPT_WWNN = 1 << 0, 30 NVMF_OPT_WWPN = 1 << 1, 31 NVMF_OPT_ROLES = 1 << 2, 32 NVMF_OPT_FCADDR = 1 << 3, 33 NVMF_OPT_LPWWNN = 1 << 4, 34 NVMF_OPT_LPWWPN = 1 << 5, 35 }; 36 37 struct fcloop_ctrl_options { 38 int mask; 39 u64 wwnn; 40 u64 wwpn; 41 u32 roles; 42 u32 fcaddr; 43 u64 lpwwnn; 44 u64 lpwwpn; 45 }; 46 47 static const match_table_t opt_tokens = { 48 { NVMF_OPT_WWNN, "wwnn=%s" }, 49 { NVMF_OPT_WWPN, "wwpn=%s" }, 50 { NVMF_OPT_ROLES, "roles=%d" }, 51 { NVMF_OPT_FCADDR, "fcaddr=%x" }, 52 { NVMF_OPT_LPWWNN, "lpwwnn=%s" }, 53 { NVMF_OPT_LPWWPN, "lpwwpn=%s" }, 54 { NVMF_OPT_ERR, NULL } 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 (match_u64(args, &token64)) { 79 ret = -EINVAL; 80 goto out_free_options; 81 } 82 opts->wwnn = token64; 83 break; 84 case NVMF_OPT_WWPN: 85 if (match_u64(args, &token64)) { 86 ret = -EINVAL; 87 goto out_free_options; 88 } 89 opts->wwpn = token64; 90 break; 91 case NVMF_OPT_ROLES: 92 if (match_int(args, &token)) { 93 ret = -EINVAL; 94 goto out_free_options; 95 } 96 opts->roles = token; 97 break; 98 case NVMF_OPT_FCADDR: 99 if (match_hex(args, &token)) { 100 ret = -EINVAL; 101 goto out_free_options; 102 } 103 opts->fcaddr = token; 104 break; 105 case NVMF_OPT_LPWWNN: 106 if (match_u64(args, &token64)) { 107 ret = -EINVAL; 108 goto out_free_options; 109 } 110 opts->lpwwnn = token64; 111 break; 112 case NVMF_OPT_LPWWPN: 113 if (match_u64(args, &token64)) { 114 ret = -EINVAL; 115 goto out_free_options; 116 } 117 opts->lpwwpn = token64; 118 break; 119 default: 120 pr_warn("unknown parameter or missing value '%s'\n", p); 121 ret = -EINVAL; 122 goto out_free_options; 123 } 124 } 125 126 out_free_options: 127 kfree(options); 128 return ret; 129 } 130 131 132 static int 133 fcloop_parse_nm_options(struct device *dev, u64 *nname, u64 *pname, 134 const char *buf) 135 { 136 substring_t args[MAX_OPT_ARGS]; 137 char *options, *o, *p; 138 int token, ret = 0; 139 u64 token64; 140 141 *nname = -1; 142 *pname = -1; 143 144 options = o = kstrdup(buf, GFP_KERNEL); 145 if (!options) 146 return -ENOMEM; 147 148 while ((p = strsep(&o, ",\n")) != NULL) { 149 if (!*p) 150 continue; 151 152 token = match_token(p, opt_tokens, args); 153 switch (token) { 154 case NVMF_OPT_WWNN: 155 if (match_u64(args, &token64)) { 156 ret = -EINVAL; 157 goto out_free_options; 158 } 159 *nname = token64; 160 break; 161 case NVMF_OPT_WWPN: 162 if (match_u64(args, &token64)) { 163 ret = -EINVAL; 164 goto out_free_options; 165 } 166 *pname = token64; 167 break; 168 default: 169 pr_warn("unknown parameter or missing value '%s'\n", p); 170 ret = -EINVAL; 171 goto out_free_options; 172 } 173 } 174 175 out_free_options: 176 kfree(options); 177 178 if (!ret) { 179 if (*nname == -1) 180 return -EINVAL; 181 if (*pname == -1) 182 return -EINVAL; 183 } 184 185 return ret; 186 } 187 188 189 #define LPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN) 190 191 #define RPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN | \ 192 NVMF_OPT_LPWWNN | NVMF_OPT_LPWWPN) 193 194 #define TGTPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN) 195 196 197 static DEFINE_SPINLOCK(fcloop_lock); 198 static LIST_HEAD(fcloop_lports); 199 static LIST_HEAD(fcloop_nports); 200 201 struct fcloop_lport { 202 struct nvme_fc_local_port *localport; 203 struct list_head lport_list; 204 struct completion unreg_done; 205 }; 206 207 struct fcloop_lport_priv { 208 struct fcloop_lport *lport; 209 }; 210 211 struct fcloop_rport { 212 struct nvme_fc_remote_port *remoteport; 213 struct nvmet_fc_target_port *targetport; 214 struct fcloop_nport *nport; 215 struct fcloop_lport *lport; 216 }; 217 218 struct fcloop_tport { 219 struct nvmet_fc_target_port *targetport; 220 struct nvme_fc_remote_port *remoteport; 221 struct fcloop_nport *nport; 222 struct fcloop_lport *lport; 223 }; 224 225 struct fcloop_nport { 226 struct fcloop_rport *rport; 227 struct fcloop_tport *tport; 228 struct fcloop_lport *lport; 229 struct list_head nport_list; 230 struct kref ref; 231 u64 node_name; 232 u64 port_name; 233 u32 port_role; 234 u32 port_id; 235 }; 236 237 struct fcloop_lsreq { 238 struct fcloop_tport *tport; 239 struct nvmefc_ls_req *lsreq; 240 struct work_struct work; 241 struct nvmefc_tgt_ls_req tgt_ls_req; 242 int status; 243 }; 244 245 enum { 246 INI_IO_START = 0, 247 INI_IO_ACTIVE = 1, 248 INI_IO_ABORTED = 2, 249 INI_IO_COMPLETED = 3, 250 }; 251 252 struct fcloop_fcpreq { 253 struct fcloop_tport *tport; 254 struct nvmefc_fcp_req *fcpreq; 255 spinlock_t reqlock; 256 u16 status; 257 u32 inistate; 258 bool active; 259 bool aborted; 260 struct kref ref; 261 struct work_struct fcp_rcv_work; 262 struct work_struct abort_rcv_work; 263 struct work_struct tio_done_work; 264 struct nvmefc_tgt_fcp_req tgt_fcp_req; 265 }; 266 267 struct fcloop_ini_fcpreq { 268 struct nvmefc_fcp_req *fcpreq; 269 struct fcloop_fcpreq *tfcp_req; 270 spinlock_t inilock; 271 }; 272 273 static inline struct fcloop_lsreq * 274 tgt_ls_req_to_lsreq(struct nvmefc_tgt_ls_req *tgt_lsreq) 275 { 276 return container_of(tgt_lsreq, struct fcloop_lsreq, tgt_ls_req); 277 } 278 279 static inline struct fcloop_fcpreq * 280 tgt_fcp_req_to_fcpreq(struct nvmefc_tgt_fcp_req *tgt_fcpreq) 281 { 282 return container_of(tgt_fcpreq, struct fcloop_fcpreq, tgt_fcp_req); 283 } 284 285 286 static int 287 fcloop_create_queue(struct nvme_fc_local_port *localport, 288 unsigned int qidx, u16 qsize, 289 void **handle) 290 { 291 *handle = localport; 292 return 0; 293 } 294 295 static void 296 fcloop_delete_queue(struct nvme_fc_local_port *localport, 297 unsigned int idx, void *handle) 298 { 299 } 300 301 302 /* 303 * Transmit of LS RSP done (e.g. buffers all set). call back up 304 * initiator "done" flows. 305 */ 306 static void 307 fcloop_tgt_lsrqst_done_work(struct work_struct *work) 308 { 309 struct fcloop_lsreq *tls_req = 310 container_of(work, struct fcloop_lsreq, work); 311 struct fcloop_tport *tport = tls_req->tport; 312 struct nvmefc_ls_req *lsreq = tls_req->lsreq; 313 314 if (tport->remoteport) 315 lsreq->done(lsreq, tls_req->status); 316 } 317 318 static int 319 fcloop_ls_req(struct nvme_fc_local_port *localport, 320 struct nvme_fc_remote_port *remoteport, 321 struct nvmefc_ls_req *lsreq) 322 { 323 struct fcloop_lsreq *tls_req = lsreq->private; 324 struct fcloop_rport *rport = remoteport->private; 325 int ret = 0; 326 327 tls_req->lsreq = lsreq; 328 INIT_WORK(&tls_req->work, fcloop_tgt_lsrqst_done_work); 329 330 if (!rport->targetport) { 331 tls_req->status = -ECONNREFUSED; 332 schedule_work(&tls_req->work); 333 return ret; 334 } 335 336 tls_req->status = 0; 337 tls_req->tport = rport->targetport->private; 338 ret = nvmet_fc_rcv_ls_req(rport->targetport, &tls_req->tgt_ls_req, 339 lsreq->rqstaddr, lsreq->rqstlen); 340 341 return ret; 342 } 343 344 static int 345 fcloop_xmt_ls_rsp(struct nvmet_fc_target_port *tport, 346 struct nvmefc_tgt_ls_req *tgt_lsreq) 347 { 348 struct fcloop_lsreq *tls_req = tgt_ls_req_to_lsreq(tgt_lsreq); 349 struct nvmefc_ls_req *lsreq = tls_req->lsreq; 350 351 memcpy(lsreq->rspaddr, tgt_lsreq->rspbuf, 352 ((lsreq->rsplen < tgt_lsreq->rsplen) ? 353 lsreq->rsplen : tgt_lsreq->rsplen)); 354 tgt_lsreq->done(tgt_lsreq); 355 356 schedule_work(&tls_req->work); 357 358 return 0; 359 } 360 361 static void 362 fcloop_tfcp_req_free(struct kref *ref) 363 { 364 struct fcloop_fcpreq *tfcp_req = 365 container_of(ref, struct fcloop_fcpreq, ref); 366 367 kfree(tfcp_req); 368 } 369 370 static void 371 fcloop_tfcp_req_put(struct fcloop_fcpreq *tfcp_req) 372 { 373 kref_put(&tfcp_req->ref, fcloop_tfcp_req_free); 374 } 375 376 static int 377 fcloop_tfcp_req_get(struct fcloop_fcpreq *tfcp_req) 378 { 379 return kref_get_unless_zero(&tfcp_req->ref); 380 } 381 382 static void 383 fcloop_call_host_done(struct nvmefc_fcp_req *fcpreq, 384 struct fcloop_fcpreq *tfcp_req, int status) 385 { 386 struct fcloop_ini_fcpreq *inireq = NULL; 387 388 if (fcpreq) { 389 inireq = fcpreq->private; 390 spin_lock(&inireq->inilock); 391 inireq->tfcp_req = NULL; 392 spin_unlock(&inireq->inilock); 393 394 fcpreq->status = status; 395 fcpreq->done(fcpreq); 396 } 397 398 /* release original io reference on tgt struct */ 399 fcloop_tfcp_req_put(tfcp_req); 400 } 401 402 static void 403 fcloop_fcp_recv_work(struct work_struct *work) 404 { 405 struct fcloop_fcpreq *tfcp_req = 406 container_of(work, struct fcloop_fcpreq, fcp_rcv_work); 407 struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq; 408 int ret = 0; 409 bool aborted = false; 410 411 spin_lock(&tfcp_req->reqlock); 412 switch (tfcp_req->inistate) { 413 case INI_IO_START: 414 tfcp_req->inistate = INI_IO_ACTIVE; 415 break; 416 case INI_IO_ABORTED: 417 aborted = true; 418 break; 419 default: 420 spin_unlock(&tfcp_req->reqlock); 421 WARN_ON(1); 422 return; 423 } 424 spin_unlock(&tfcp_req->reqlock); 425 426 if (unlikely(aborted)) 427 ret = -ECANCELED; 428 else 429 ret = nvmet_fc_rcv_fcp_req(tfcp_req->tport->targetport, 430 &tfcp_req->tgt_fcp_req, 431 fcpreq->cmdaddr, fcpreq->cmdlen); 432 if (ret) 433 fcloop_call_host_done(fcpreq, tfcp_req, ret); 434 435 return; 436 } 437 438 static void 439 fcloop_fcp_abort_recv_work(struct work_struct *work) 440 { 441 struct fcloop_fcpreq *tfcp_req = 442 container_of(work, struct fcloop_fcpreq, abort_rcv_work); 443 struct nvmefc_fcp_req *fcpreq; 444 bool completed = false; 445 446 spin_lock(&tfcp_req->reqlock); 447 fcpreq = tfcp_req->fcpreq; 448 switch (tfcp_req->inistate) { 449 case INI_IO_ABORTED: 450 break; 451 case INI_IO_COMPLETED: 452 completed = true; 453 break; 454 default: 455 spin_unlock(&tfcp_req->reqlock); 456 WARN_ON(1); 457 return; 458 } 459 spin_unlock(&tfcp_req->reqlock); 460 461 if (unlikely(completed)) { 462 /* remove reference taken in original abort downcall */ 463 fcloop_tfcp_req_put(tfcp_req); 464 return; 465 } 466 467 if (tfcp_req->tport->targetport) 468 nvmet_fc_rcv_fcp_abort(tfcp_req->tport->targetport, 469 &tfcp_req->tgt_fcp_req); 470 471 spin_lock(&tfcp_req->reqlock); 472 tfcp_req->fcpreq = NULL; 473 spin_unlock(&tfcp_req->reqlock); 474 475 fcloop_call_host_done(fcpreq, tfcp_req, -ECANCELED); 476 /* call_host_done releases reference for abort downcall */ 477 } 478 479 /* 480 * FCP IO operation done by target completion. 481 * call back up initiator "done" flows. 482 */ 483 static void 484 fcloop_tgt_fcprqst_done_work(struct work_struct *work) 485 { 486 struct fcloop_fcpreq *tfcp_req = 487 container_of(work, struct fcloop_fcpreq, tio_done_work); 488 struct nvmefc_fcp_req *fcpreq; 489 490 spin_lock(&tfcp_req->reqlock); 491 fcpreq = tfcp_req->fcpreq; 492 tfcp_req->inistate = INI_IO_COMPLETED; 493 spin_unlock(&tfcp_req->reqlock); 494 495 fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status); 496 } 497 498 499 static int 500 fcloop_fcp_req(struct nvme_fc_local_port *localport, 501 struct nvme_fc_remote_port *remoteport, 502 void *hw_queue_handle, 503 struct nvmefc_fcp_req *fcpreq) 504 { 505 struct fcloop_rport *rport = remoteport->private; 506 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 507 struct fcloop_fcpreq *tfcp_req; 508 509 if (!rport->targetport) 510 return -ECONNREFUSED; 511 512 tfcp_req = kzalloc(sizeof(*tfcp_req), GFP_KERNEL); 513 if (!tfcp_req) 514 return -ENOMEM; 515 516 inireq->fcpreq = fcpreq; 517 inireq->tfcp_req = tfcp_req; 518 spin_lock_init(&inireq->inilock); 519 520 tfcp_req->fcpreq = fcpreq; 521 tfcp_req->tport = rport->targetport->private; 522 tfcp_req->inistate = INI_IO_START; 523 spin_lock_init(&tfcp_req->reqlock); 524 INIT_WORK(&tfcp_req->fcp_rcv_work, fcloop_fcp_recv_work); 525 INIT_WORK(&tfcp_req->abort_rcv_work, fcloop_fcp_abort_recv_work); 526 INIT_WORK(&tfcp_req->tio_done_work, fcloop_tgt_fcprqst_done_work); 527 kref_init(&tfcp_req->ref); 528 529 schedule_work(&tfcp_req->fcp_rcv_work); 530 531 return 0; 532 } 533 534 static void 535 fcloop_fcp_copy_data(u8 op, struct scatterlist *data_sg, 536 struct scatterlist *io_sg, u32 offset, u32 length) 537 { 538 void *data_p, *io_p; 539 u32 data_len, io_len, tlen; 540 541 io_p = sg_virt(io_sg); 542 io_len = io_sg->length; 543 544 for ( ; offset; ) { 545 tlen = min_t(u32, offset, io_len); 546 offset -= tlen; 547 io_len -= tlen; 548 if (!io_len) { 549 io_sg = sg_next(io_sg); 550 io_p = sg_virt(io_sg); 551 io_len = io_sg->length; 552 } else 553 io_p += tlen; 554 } 555 556 data_p = sg_virt(data_sg); 557 data_len = data_sg->length; 558 559 for ( ; length; ) { 560 tlen = min_t(u32, io_len, data_len); 561 tlen = min_t(u32, tlen, length); 562 563 if (op == NVMET_FCOP_WRITEDATA) 564 memcpy(data_p, io_p, tlen); 565 else 566 memcpy(io_p, data_p, tlen); 567 568 length -= tlen; 569 570 io_len -= tlen; 571 if ((!io_len) && (length)) { 572 io_sg = sg_next(io_sg); 573 io_p = sg_virt(io_sg); 574 io_len = io_sg->length; 575 } else 576 io_p += tlen; 577 578 data_len -= tlen; 579 if ((!data_len) && (length)) { 580 data_sg = sg_next(data_sg); 581 data_p = sg_virt(data_sg); 582 data_len = data_sg->length; 583 } else 584 data_p += tlen; 585 } 586 } 587 588 static int 589 fcloop_fcp_op(struct nvmet_fc_target_port *tgtport, 590 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 591 { 592 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 593 struct nvmefc_fcp_req *fcpreq; 594 u32 rsplen = 0, xfrlen = 0; 595 int fcp_err = 0, active, aborted; 596 u8 op = tgt_fcpreq->op; 597 598 spin_lock(&tfcp_req->reqlock); 599 fcpreq = tfcp_req->fcpreq; 600 active = tfcp_req->active; 601 aborted = tfcp_req->aborted; 602 tfcp_req->active = true; 603 spin_unlock(&tfcp_req->reqlock); 604 605 if (unlikely(active)) 606 /* illegal - call while i/o active */ 607 return -EALREADY; 608 609 if (unlikely(aborted)) { 610 /* target transport has aborted i/o prior */ 611 spin_lock(&tfcp_req->reqlock); 612 tfcp_req->active = false; 613 spin_unlock(&tfcp_req->reqlock); 614 tgt_fcpreq->transferred_length = 0; 615 tgt_fcpreq->fcp_error = -ECANCELED; 616 tgt_fcpreq->done(tgt_fcpreq); 617 return 0; 618 } 619 620 /* 621 * if fcpreq is NULL, the I/O has been aborted (from 622 * initiator side). For the target side, act as if all is well 623 * but don't actually move data. 624 */ 625 626 switch (op) { 627 case NVMET_FCOP_WRITEDATA: 628 xfrlen = tgt_fcpreq->transfer_length; 629 if (fcpreq) { 630 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 631 fcpreq->first_sgl, tgt_fcpreq->offset, 632 xfrlen); 633 fcpreq->transferred_length += xfrlen; 634 } 635 break; 636 637 case NVMET_FCOP_READDATA: 638 case NVMET_FCOP_READDATA_RSP: 639 xfrlen = tgt_fcpreq->transfer_length; 640 if (fcpreq) { 641 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 642 fcpreq->first_sgl, tgt_fcpreq->offset, 643 xfrlen); 644 fcpreq->transferred_length += xfrlen; 645 } 646 if (op == NVMET_FCOP_READDATA) 647 break; 648 649 /* Fall-Thru to RSP handling */ 650 651 case NVMET_FCOP_RSP: 652 if (fcpreq) { 653 rsplen = ((fcpreq->rsplen < tgt_fcpreq->rsplen) ? 654 fcpreq->rsplen : tgt_fcpreq->rsplen); 655 memcpy(fcpreq->rspaddr, tgt_fcpreq->rspaddr, rsplen); 656 if (rsplen < tgt_fcpreq->rsplen) 657 fcp_err = -E2BIG; 658 fcpreq->rcv_rsplen = rsplen; 659 fcpreq->status = 0; 660 } 661 tfcp_req->status = 0; 662 break; 663 664 default: 665 fcp_err = -EINVAL; 666 break; 667 } 668 669 spin_lock(&tfcp_req->reqlock); 670 tfcp_req->active = false; 671 spin_unlock(&tfcp_req->reqlock); 672 673 tgt_fcpreq->transferred_length = xfrlen; 674 tgt_fcpreq->fcp_error = fcp_err; 675 tgt_fcpreq->done(tgt_fcpreq); 676 677 return 0; 678 } 679 680 static void 681 fcloop_tgt_fcp_abort(struct nvmet_fc_target_port *tgtport, 682 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 683 { 684 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 685 686 /* 687 * mark aborted only in case there were 2 threads in transport 688 * (one doing io, other doing abort) and only kills ops posted 689 * after the abort request 690 */ 691 spin_lock(&tfcp_req->reqlock); 692 tfcp_req->aborted = true; 693 spin_unlock(&tfcp_req->reqlock); 694 695 tfcp_req->status = NVME_SC_INTERNAL; 696 697 /* 698 * nothing more to do. If io wasn't active, the transport should 699 * immediately call the req_release. If it was active, the op 700 * will complete, and the lldd should call req_release. 701 */ 702 } 703 704 static void 705 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport, 706 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 707 { 708 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 709 710 schedule_work(&tfcp_req->tio_done_work); 711 } 712 713 static void 714 fcloop_ls_abort(struct nvme_fc_local_port *localport, 715 struct nvme_fc_remote_port *remoteport, 716 struct nvmefc_ls_req *lsreq) 717 { 718 } 719 720 static void 721 fcloop_fcp_abort(struct nvme_fc_local_port *localport, 722 struct nvme_fc_remote_port *remoteport, 723 void *hw_queue_handle, 724 struct nvmefc_fcp_req *fcpreq) 725 { 726 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 727 struct fcloop_fcpreq *tfcp_req; 728 bool abortio = true; 729 730 spin_lock(&inireq->inilock); 731 tfcp_req = inireq->tfcp_req; 732 if (tfcp_req) 733 fcloop_tfcp_req_get(tfcp_req); 734 spin_unlock(&inireq->inilock); 735 736 if (!tfcp_req) 737 /* abort has already been called */ 738 return; 739 740 /* break initiator/target relationship for io */ 741 spin_lock(&tfcp_req->reqlock); 742 switch (tfcp_req->inistate) { 743 case INI_IO_START: 744 case INI_IO_ACTIVE: 745 tfcp_req->inistate = INI_IO_ABORTED; 746 break; 747 case INI_IO_COMPLETED: 748 abortio = false; 749 break; 750 default: 751 spin_unlock(&tfcp_req->reqlock); 752 WARN_ON(1); 753 return; 754 } 755 spin_unlock(&tfcp_req->reqlock); 756 757 if (abortio) 758 /* leave the reference while the work item is scheduled */ 759 WARN_ON(!schedule_work(&tfcp_req->abort_rcv_work)); 760 else { 761 /* 762 * as the io has already had the done callback made, 763 * nothing more to do. So release the reference taken above 764 */ 765 fcloop_tfcp_req_put(tfcp_req); 766 } 767 } 768 769 static void 770 fcloop_nport_free(struct kref *ref) 771 { 772 struct fcloop_nport *nport = 773 container_of(ref, struct fcloop_nport, ref); 774 unsigned long flags; 775 776 spin_lock_irqsave(&fcloop_lock, flags); 777 list_del(&nport->nport_list); 778 spin_unlock_irqrestore(&fcloop_lock, flags); 779 780 kfree(nport); 781 } 782 783 static void 784 fcloop_nport_put(struct fcloop_nport *nport) 785 { 786 kref_put(&nport->ref, fcloop_nport_free); 787 } 788 789 static int 790 fcloop_nport_get(struct fcloop_nport *nport) 791 { 792 return kref_get_unless_zero(&nport->ref); 793 } 794 795 static void 796 fcloop_localport_delete(struct nvme_fc_local_port *localport) 797 { 798 struct fcloop_lport_priv *lport_priv = localport->private; 799 struct fcloop_lport *lport = lport_priv->lport; 800 801 /* release any threads waiting for the unreg to complete */ 802 complete(&lport->unreg_done); 803 } 804 805 static void 806 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport) 807 { 808 struct fcloop_rport *rport = remoteport->private; 809 810 fcloop_nport_put(rport->nport); 811 } 812 813 static void 814 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport) 815 { 816 struct fcloop_tport *tport = targetport->private; 817 818 fcloop_nport_put(tport->nport); 819 } 820 821 #define FCLOOP_HW_QUEUES 4 822 #define FCLOOP_SGL_SEGS 256 823 #define FCLOOP_DMABOUND_4G 0xFFFFFFFF 824 825 static struct nvme_fc_port_template fctemplate = { 826 .localport_delete = fcloop_localport_delete, 827 .remoteport_delete = fcloop_remoteport_delete, 828 .create_queue = fcloop_create_queue, 829 .delete_queue = fcloop_delete_queue, 830 .ls_req = fcloop_ls_req, 831 .fcp_io = fcloop_fcp_req, 832 .ls_abort = fcloop_ls_abort, 833 .fcp_abort = fcloop_fcp_abort, 834 .max_hw_queues = FCLOOP_HW_QUEUES, 835 .max_sgl_segments = FCLOOP_SGL_SEGS, 836 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 837 .dma_boundary = FCLOOP_DMABOUND_4G, 838 /* sizes of additional private data for data structures */ 839 .local_priv_sz = sizeof(struct fcloop_lport_priv), 840 .remote_priv_sz = sizeof(struct fcloop_rport), 841 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq), 842 .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq), 843 }; 844 845 static struct nvmet_fc_target_template tgttemplate = { 846 .targetport_delete = fcloop_targetport_delete, 847 .xmt_ls_rsp = fcloop_xmt_ls_rsp, 848 .fcp_op = fcloop_fcp_op, 849 .fcp_abort = fcloop_tgt_fcp_abort, 850 .fcp_req_release = fcloop_fcp_req_release, 851 .max_hw_queues = FCLOOP_HW_QUEUES, 852 .max_sgl_segments = FCLOOP_SGL_SEGS, 853 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 854 .dma_boundary = FCLOOP_DMABOUND_4G, 855 /* optional features */ 856 .target_features = 0, 857 /* sizes of additional private data for data structures */ 858 .target_priv_sz = sizeof(struct fcloop_tport), 859 }; 860 861 static ssize_t 862 fcloop_create_local_port(struct device *dev, struct device_attribute *attr, 863 const char *buf, size_t count) 864 { 865 struct nvme_fc_port_info pinfo; 866 struct fcloop_ctrl_options *opts; 867 struct nvme_fc_local_port *localport; 868 struct fcloop_lport *lport; 869 struct fcloop_lport_priv *lport_priv; 870 unsigned long flags; 871 int ret = -ENOMEM; 872 873 lport = kzalloc(sizeof(*lport), GFP_KERNEL); 874 if (!lport) 875 return -ENOMEM; 876 877 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 878 if (!opts) 879 goto out_free_lport; 880 881 ret = fcloop_parse_options(opts, buf); 882 if (ret) 883 goto out_free_opts; 884 885 /* everything there ? */ 886 if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) { 887 ret = -EINVAL; 888 goto out_free_opts; 889 } 890 891 memset(&pinfo, 0, sizeof(pinfo)); 892 pinfo.node_name = opts->wwnn; 893 pinfo.port_name = opts->wwpn; 894 pinfo.port_role = opts->roles; 895 pinfo.port_id = opts->fcaddr; 896 897 ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport); 898 if (!ret) { 899 /* success */ 900 lport_priv = localport->private; 901 lport_priv->lport = lport; 902 903 lport->localport = localport; 904 INIT_LIST_HEAD(&lport->lport_list); 905 906 spin_lock_irqsave(&fcloop_lock, flags); 907 list_add_tail(&lport->lport_list, &fcloop_lports); 908 spin_unlock_irqrestore(&fcloop_lock, flags); 909 } 910 911 out_free_opts: 912 kfree(opts); 913 out_free_lport: 914 /* free only if we're going to fail */ 915 if (ret) 916 kfree(lport); 917 918 return ret ? ret : count; 919 } 920 921 922 static void 923 __unlink_local_port(struct fcloop_lport *lport) 924 { 925 list_del(&lport->lport_list); 926 } 927 928 static int 929 __wait_localport_unreg(struct fcloop_lport *lport) 930 { 931 int ret; 932 933 init_completion(&lport->unreg_done); 934 935 ret = nvme_fc_unregister_localport(lport->localport); 936 937 wait_for_completion(&lport->unreg_done); 938 939 kfree(lport); 940 941 return ret; 942 } 943 944 945 static ssize_t 946 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr, 947 const char *buf, size_t count) 948 { 949 struct fcloop_lport *tlport, *lport = NULL; 950 u64 nodename, portname; 951 unsigned long flags; 952 int ret; 953 954 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 955 if (ret) 956 return ret; 957 958 spin_lock_irqsave(&fcloop_lock, flags); 959 960 list_for_each_entry(tlport, &fcloop_lports, lport_list) { 961 if (tlport->localport->node_name == nodename && 962 tlport->localport->port_name == portname) { 963 lport = tlport; 964 __unlink_local_port(lport); 965 break; 966 } 967 } 968 spin_unlock_irqrestore(&fcloop_lock, flags); 969 970 if (!lport) 971 return -ENOENT; 972 973 ret = __wait_localport_unreg(lport); 974 975 return ret ? ret : count; 976 } 977 978 static struct fcloop_nport * 979 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport) 980 { 981 struct fcloop_nport *newnport, *nport = NULL; 982 struct fcloop_lport *tmplport, *lport = NULL; 983 struct fcloop_ctrl_options *opts; 984 unsigned long flags; 985 u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS; 986 int ret; 987 988 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 989 if (!opts) 990 return NULL; 991 992 ret = fcloop_parse_options(opts, buf); 993 if (ret) 994 goto out_free_opts; 995 996 /* everything there ? */ 997 if ((opts->mask & opts_mask) != opts_mask) { 998 ret = -EINVAL; 999 goto out_free_opts; 1000 } 1001 1002 newnport = kzalloc(sizeof(*newnport), GFP_KERNEL); 1003 if (!newnport) 1004 goto out_free_opts; 1005 1006 INIT_LIST_HEAD(&newnport->nport_list); 1007 newnport->node_name = opts->wwnn; 1008 newnport->port_name = opts->wwpn; 1009 if (opts->mask & NVMF_OPT_ROLES) 1010 newnport->port_role = opts->roles; 1011 if (opts->mask & NVMF_OPT_FCADDR) 1012 newnport->port_id = opts->fcaddr; 1013 kref_init(&newnport->ref); 1014 1015 spin_lock_irqsave(&fcloop_lock, flags); 1016 1017 list_for_each_entry(tmplport, &fcloop_lports, lport_list) { 1018 if (tmplport->localport->node_name == opts->wwnn && 1019 tmplport->localport->port_name == opts->wwpn) 1020 goto out_invalid_opts; 1021 1022 if (tmplport->localport->node_name == opts->lpwwnn && 1023 tmplport->localport->port_name == opts->lpwwpn) 1024 lport = tmplport; 1025 } 1026 1027 if (remoteport) { 1028 if (!lport) 1029 goto out_invalid_opts; 1030 newnport->lport = lport; 1031 } 1032 1033 list_for_each_entry(nport, &fcloop_nports, nport_list) { 1034 if (nport->node_name == opts->wwnn && 1035 nport->port_name == opts->wwpn) { 1036 if ((remoteport && nport->rport) || 1037 (!remoteport && nport->tport)) { 1038 nport = NULL; 1039 goto out_invalid_opts; 1040 } 1041 1042 fcloop_nport_get(nport); 1043 1044 spin_unlock_irqrestore(&fcloop_lock, flags); 1045 1046 if (remoteport) 1047 nport->lport = lport; 1048 if (opts->mask & NVMF_OPT_ROLES) 1049 nport->port_role = opts->roles; 1050 if (opts->mask & NVMF_OPT_FCADDR) 1051 nport->port_id = opts->fcaddr; 1052 goto out_free_newnport; 1053 } 1054 } 1055 1056 list_add_tail(&newnport->nport_list, &fcloop_nports); 1057 1058 spin_unlock_irqrestore(&fcloop_lock, flags); 1059 1060 kfree(opts); 1061 return newnport; 1062 1063 out_invalid_opts: 1064 spin_unlock_irqrestore(&fcloop_lock, flags); 1065 out_free_newnport: 1066 kfree(newnport); 1067 out_free_opts: 1068 kfree(opts); 1069 return nport; 1070 } 1071 1072 static ssize_t 1073 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr, 1074 const char *buf, size_t count) 1075 { 1076 struct nvme_fc_remote_port *remoteport; 1077 struct fcloop_nport *nport; 1078 struct fcloop_rport *rport; 1079 struct nvme_fc_port_info pinfo; 1080 int ret; 1081 1082 nport = fcloop_alloc_nport(buf, count, true); 1083 if (!nport) 1084 return -EIO; 1085 1086 memset(&pinfo, 0, sizeof(pinfo)); 1087 pinfo.node_name = nport->node_name; 1088 pinfo.port_name = nport->port_name; 1089 pinfo.port_role = nport->port_role; 1090 pinfo.port_id = nport->port_id; 1091 1092 ret = nvme_fc_register_remoteport(nport->lport->localport, 1093 &pinfo, &remoteport); 1094 if (ret || !remoteport) { 1095 fcloop_nport_put(nport); 1096 return ret; 1097 } 1098 1099 /* success */ 1100 rport = remoteport->private; 1101 rport->remoteport = remoteport; 1102 rport->targetport = (nport->tport) ? nport->tport->targetport : NULL; 1103 if (nport->tport) { 1104 nport->tport->remoteport = remoteport; 1105 nport->tport->lport = nport->lport; 1106 } 1107 rport->nport = nport; 1108 rport->lport = nport->lport; 1109 nport->rport = rport; 1110 1111 return count; 1112 } 1113 1114 1115 static struct fcloop_rport * 1116 __unlink_remote_port(struct fcloop_nport *nport) 1117 { 1118 struct fcloop_rport *rport = nport->rport; 1119 1120 if (rport && nport->tport) 1121 nport->tport->remoteport = NULL; 1122 nport->rport = NULL; 1123 1124 return rport; 1125 } 1126 1127 static int 1128 __remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport) 1129 { 1130 if (!rport) 1131 return -EALREADY; 1132 1133 return nvme_fc_unregister_remoteport(rport->remoteport); 1134 } 1135 1136 static ssize_t 1137 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr, 1138 const char *buf, size_t count) 1139 { 1140 struct fcloop_nport *nport = NULL, *tmpport; 1141 static struct fcloop_rport *rport; 1142 u64 nodename, portname; 1143 unsigned long flags; 1144 int ret; 1145 1146 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1147 if (ret) 1148 return ret; 1149 1150 spin_lock_irqsave(&fcloop_lock, flags); 1151 1152 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1153 if (tmpport->node_name == nodename && 1154 tmpport->port_name == portname && tmpport->rport) { 1155 nport = tmpport; 1156 rport = __unlink_remote_port(nport); 1157 break; 1158 } 1159 } 1160 1161 spin_unlock_irqrestore(&fcloop_lock, flags); 1162 1163 if (!nport) 1164 return -ENOENT; 1165 1166 ret = __remoteport_unreg(nport, rport); 1167 1168 return ret ? ret : count; 1169 } 1170 1171 static ssize_t 1172 fcloop_create_target_port(struct device *dev, struct device_attribute *attr, 1173 const char *buf, size_t count) 1174 { 1175 struct nvmet_fc_target_port *targetport; 1176 struct fcloop_nport *nport; 1177 struct fcloop_tport *tport; 1178 struct nvmet_fc_port_info tinfo; 1179 int ret; 1180 1181 nport = fcloop_alloc_nport(buf, count, false); 1182 if (!nport) 1183 return -EIO; 1184 1185 tinfo.node_name = nport->node_name; 1186 tinfo.port_name = nport->port_name; 1187 tinfo.port_id = nport->port_id; 1188 1189 ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL, 1190 &targetport); 1191 if (ret) { 1192 fcloop_nport_put(nport); 1193 return ret; 1194 } 1195 1196 /* success */ 1197 tport = targetport->private; 1198 tport->targetport = targetport; 1199 tport->remoteport = (nport->rport) ? nport->rport->remoteport : NULL; 1200 if (nport->rport) 1201 nport->rport->targetport = targetport; 1202 tport->nport = nport; 1203 tport->lport = nport->lport; 1204 nport->tport = tport; 1205 1206 return count; 1207 } 1208 1209 1210 static struct fcloop_tport * 1211 __unlink_target_port(struct fcloop_nport *nport) 1212 { 1213 struct fcloop_tport *tport = nport->tport; 1214 1215 if (tport && nport->rport) 1216 nport->rport->targetport = NULL; 1217 nport->tport = NULL; 1218 1219 return tport; 1220 } 1221 1222 static int 1223 __targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport) 1224 { 1225 if (!tport) 1226 return -EALREADY; 1227 1228 return nvmet_fc_unregister_targetport(tport->targetport); 1229 } 1230 1231 static ssize_t 1232 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr, 1233 const char *buf, size_t count) 1234 { 1235 struct fcloop_nport *nport = NULL, *tmpport; 1236 struct fcloop_tport *tport = NULL; 1237 u64 nodename, portname; 1238 unsigned long flags; 1239 int ret; 1240 1241 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1242 if (ret) 1243 return ret; 1244 1245 spin_lock_irqsave(&fcloop_lock, flags); 1246 1247 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1248 if (tmpport->node_name == nodename && 1249 tmpport->port_name == portname && tmpport->tport) { 1250 nport = tmpport; 1251 tport = __unlink_target_port(nport); 1252 break; 1253 } 1254 } 1255 1256 spin_unlock_irqrestore(&fcloop_lock, flags); 1257 1258 if (!nport) 1259 return -ENOENT; 1260 1261 ret = __targetport_unreg(nport, tport); 1262 1263 return ret ? ret : count; 1264 } 1265 1266 1267 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port); 1268 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port); 1269 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port); 1270 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port); 1271 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port); 1272 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port); 1273 1274 static struct attribute *fcloop_dev_attrs[] = { 1275 &dev_attr_add_local_port.attr, 1276 &dev_attr_del_local_port.attr, 1277 &dev_attr_add_remote_port.attr, 1278 &dev_attr_del_remote_port.attr, 1279 &dev_attr_add_target_port.attr, 1280 &dev_attr_del_target_port.attr, 1281 NULL 1282 }; 1283 1284 static struct attribute_group fclopp_dev_attrs_group = { 1285 .attrs = fcloop_dev_attrs, 1286 }; 1287 1288 static const struct attribute_group *fcloop_dev_attr_groups[] = { 1289 &fclopp_dev_attrs_group, 1290 NULL, 1291 }; 1292 1293 static struct class *fcloop_class; 1294 static struct device *fcloop_device; 1295 1296 1297 static int __init fcloop_init(void) 1298 { 1299 int ret; 1300 1301 fcloop_class = class_create(THIS_MODULE, "fcloop"); 1302 if (IS_ERR(fcloop_class)) { 1303 pr_err("couldn't register class fcloop\n"); 1304 ret = PTR_ERR(fcloop_class); 1305 return ret; 1306 } 1307 1308 fcloop_device = device_create_with_groups( 1309 fcloop_class, NULL, MKDEV(0, 0), NULL, 1310 fcloop_dev_attr_groups, "ctl"); 1311 if (IS_ERR(fcloop_device)) { 1312 pr_err("couldn't create ctl device!\n"); 1313 ret = PTR_ERR(fcloop_device); 1314 goto out_destroy_class; 1315 } 1316 1317 get_device(fcloop_device); 1318 1319 return 0; 1320 1321 out_destroy_class: 1322 class_destroy(fcloop_class); 1323 return ret; 1324 } 1325 1326 static void __exit fcloop_exit(void) 1327 { 1328 struct fcloop_lport *lport; 1329 struct fcloop_nport *nport; 1330 struct fcloop_tport *tport; 1331 struct fcloop_rport *rport; 1332 unsigned long flags; 1333 int ret; 1334 1335 spin_lock_irqsave(&fcloop_lock, flags); 1336 1337 for (;;) { 1338 nport = list_first_entry_or_null(&fcloop_nports, 1339 typeof(*nport), nport_list); 1340 if (!nport) 1341 break; 1342 1343 tport = __unlink_target_port(nport); 1344 rport = __unlink_remote_port(nport); 1345 1346 spin_unlock_irqrestore(&fcloop_lock, flags); 1347 1348 ret = __targetport_unreg(nport, tport); 1349 if (ret) 1350 pr_warn("%s: Failed deleting target port\n", __func__); 1351 1352 ret = __remoteport_unreg(nport, rport); 1353 if (ret) 1354 pr_warn("%s: Failed deleting remote port\n", __func__); 1355 1356 spin_lock_irqsave(&fcloop_lock, flags); 1357 } 1358 1359 for (;;) { 1360 lport = list_first_entry_or_null(&fcloop_lports, 1361 typeof(*lport), lport_list); 1362 if (!lport) 1363 break; 1364 1365 __unlink_local_port(lport); 1366 1367 spin_unlock_irqrestore(&fcloop_lock, flags); 1368 1369 ret = __wait_localport_unreg(lport); 1370 if (ret) 1371 pr_warn("%s: Failed deleting local port\n", __func__); 1372 1373 spin_lock_irqsave(&fcloop_lock, flags); 1374 } 1375 1376 spin_unlock_irqrestore(&fcloop_lock, flags); 1377 1378 put_device(fcloop_device); 1379 1380 device_destroy(fcloop_class, MKDEV(0, 0)); 1381 class_destroy(fcloop_class); 1382 } 1383 1384 module_init(fcloop_init); 1385 module_exit(fcloop_exit); 1386 1387 MODULE_LICENSE("GPL v2"); 1388