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 || 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 tls_req->tport = NULL; 333 schedule_work(&tls_req->work); 334 return ret; 335 } 336 337 tls_req->status = 0; 338 tls_req->tport = rport->targetport->private; 339 ret = nvmet_fc_rcv_ls_req(rport->targetport, &tls_req->tgt_ls_req, 340 lsreq->rqstaddr, lsreq->rqstlen); 341 342 return ret; 343 } 344 345 static int 346 fcloop_xmt_ls_rsp(struct nvmet_fc_target_port *tport, 347 struct nvmefc_tgt_ls_req *tgt_lsreq) 348 { 349 struct fcloop_lsreq *tls_req = tgt_ls_req_to_lsreq(tgt_lsreq); 350 struct nvmefc_ls_req *lsreq = tls_req->lsreq; 351 352 memcpy(lsreq->rspaddr, tgt_lsreq->rspbuf, 353 ((lsreq->rsplen < tgt_lsreq->rsplen) ? 354 lsreq->rsplen : tgt_lsreq->rsplen)); 355 tgt_lsreq->done(tgt_lsreq); 356 357 schedule_work(&tls_req->work); 358 359 return 0; 360 } 361 362 static void 363 fcloop_tfcp_req_free(struct kref *ref) 364 { 365 struct fcloop_fcpreq *tfcp_req = 366 container_of(ref, struct fcloop_fcpreq, ref); 367 368 kfree(tfcp_req); 369 } 370 371 static void 372 fcloop_tfcp_req_put(struct fcloop_fcpreq *tfcp_req) 373 { 374 kref_put(&tfcp_req->ref, fcloop_tfcp_req_free); 375 } 376 377 static int 378 fcloop_tfcp_req_get(struct fcloop_fcpreq *tfcp_req) 379 { 380 return kref_get_unless_zero(&tfcp_req->ref); 381 } 382 383 static void 384 fcloop_call_host_done(struct nvmefc_fcp_req *fcpreq, 385 struct fcloop_fcpreq *tfcp_req, int status) 386 { 387 struct fcloop_ini_fcpreq *inireq = NULL; 388 389 if (fcpreq) { 390 inireq = fcpreq->private; 391 spin_lock(&inireq->inilock); 392 inireq->tfcp_req = NULL; 393 spin_unlock(&inireq->inilock); 394 395 fcpreq->status = status; 396 fcpreq->done(fcpreq); 397 } 398 399 /* release original io reference on tgt struct */ 400 fcloop_tfcp_req_put(tfcp_req); 401 } 402 403 static void 404 fcloop_fcp_recv_work(struct work_struct *work) 405 { 406 struct fcloop_fcpreq *tfcp_req = 407 container_of(work, struct fcloop_fcpreq, fcp_rcv_work); 408 struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq; 409 int ret = 0; 410 bool aborted = false; 411 412 spin_lock(&tfcp_req->reqlock); 413 switch (tfcp_req->inistate) { 414 case INI_IO_START: 415 tfcp_req->inistate = INI_IO_ACTIVE; 416 break; 417 case INI_IO_ABORTED: 418 aborted = true; 419 break; 420 default: 421 spin_unlock(&tfcp_req->reqlock); 422 WARN_ON(1); 423 return; 424 } 425 spin_unlock(&tfcp_req->reqlock); 426 427 if (unlikely(aborted)) 428 ret = -ECANCELED; 429 else 430 ret = nvmet_fc_rcv_fcp_req(tfcp_req->tport->targetport, 431 &tfcp_req->tgt_fcp_req, 432 fcpreq->cmdaddr, fcpreq->cmdlen); 433 if (ret) 434 fcloop_call_host_done(fcpreq, tfcp_req, ret); 435 436 return; 437 } 438 439 static void 440 fcloop_fcp_abort_recv_work(struct work_struct *work) 441 { 442 struct fcloop_fcpreq *tfcp_req = 443 container_of(work, struct fcloop_fcpreq, abort_rcv_work); 444 struct nvmefc_fcp_req *fcpreq; 445 bool completed = false; 446 447 spin_lock(&tfcp_req->reqlock); 448 fcpreq = tfcp_req->fcpreq; 449 switch (tfcp_req->inistate) { 450 case INI_IO_ABORTED: 451 break; 452 case INI_IO_COMPLETED: 453 completed = true; 454 break; 455 default: 456 spin_unlock(&tfcp_req->reqlock); 457 WARN_ON(1); 458 return; 459 } 460 spin_unlock(&tfcp_req->reqlock); 461 462 if (unlikely(completed)) { 463 /* remove reference taken in original abort downcall */ 464 fcloop_tfcp_req_put(tfcp_req); 465 return; 466 } 467 468 if (tfcp_req->tport->targetport) 469 nvmet_fc_rcv_fcp_abort(tfcp_req->tport->targetport, 470 &tfcp_req->tgt_fcp_req); 471 472 spin_lock(&tfcp_req->reqlock); 473 tfcp_req->fcpreq = NULL; 474 spin_unlock(&tfcp_req->reqlock); 475 476 fcloop_call_host_done(fcpreq, tfcp_req, -ECANCELED); 477 /* call_host_done releases reference for abort downcall */ 478 } 479 480 /* 481 * FCP IO operation done by target completion. 482 * call back up initiator "done" flows. 483 */ 484 static void 485 fcloop_tgt_fcprqst_done_work(struct work_struct *work) 486 { 487 struct fcloop_fcpreq *tfcp_req = 488 container_of(work, struct fcloop_fcpreq, tio_done_work); 489 struct nvmefc_fcp_req *fcpreq; 490 491 spin_lock(&tfcp_req->reqlock); 492 fcpreq = tfcp_req->fcpreq; 493 tfcp_req->inistate = INI_IO_COMPLETED; 494 spin_unlock(&tfcp_req->reqlock); 495 496 fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status); 497 } 498 499 500 static int 501 fcloop_fcp_req(struct nvme_fc_local_port *localport, 502 struct nvme_fc_remote_port *remoteport, 503 void *hw_queue_handle, 504 struct nvmefc_fcp_req *fcpreq) 505 { 506 struct fcloop_rport *rport = remoteport->private; 507 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 508 struct fcloop_fcpreq *tfcp_req; 509 510 if (!rport->targetport) 511 return -ECONNREFUSED; 512 513 tfcp_req = kzalloc(sizeof(*tfcp_req), GFP_KERNEL); 514 if (!tfcp_req) 515 return -ENOMEM; 516 517 inireq->fcpreq = fcpreq; 518 inireq->tfcp_req = tfcp_req; 519 spin_lock_init(&inireq->inilock); 520 521 tfcp_req->fcpreq = fcpreq; 522 tfcp_req->tport = rport->targetport->private; 523 tfcp_req->inistate = INI_IO_START; 524 spin_lock_init(&tfcp_req->reqlock); 525 INIT_WORK(&tfcp_req->fcp_rcv_work, fcloop_fcp_recv_work); 526 INIT_WORK(&tfcp_req->abort_rcv_work, fcloop_fcp_abort_recv_work); 527 INIT_WORK(&tfcp_req->tio_done_work, fcloop_tgt_fcprqst_done_work); 528 kref_init(&tfcp_req->ref); 529 530 schedule_work(&tfcp_req->fcp_rcv_work); 531 532 return 0; 533 } 534 535 static void 536 fcloop_fcp_copy_data(u8 op, struct scatterlist *data_sg, 537 struct scatterlist *io_sg, u32 offset, u32 length) 538 { 539 void *data_p, *io_p; 540 u32 data_len, io_len, tlen; 541 542 io_p = sg_virt(io_sg); 543 io_len = io_sg->length; 544 545 for ( ; offset; ) { 546 tlen = min_t(u32, offset, io_len); 547 offset -= tlen; 548 io_len -= tlen; 549 if (!io_len) { 550 io_sg = sg_next(io_sg); 551 io_p = sg_virt(io_sg); 552 io_len = io_sg->length; 553 } else 554 io_p += tlen; 555 } 556 557 data_p = sg_virt(data_sg); 558 data_len = data_sg->length; 559 560 for ( ; length; ) { 561 tlen = min_t(u32, io_len, data_len); 562 tlen = min_t(u32, tlen, length); 563 564 if (op == NVMET_FCOP_WRITEDATA) 565 memcpy(data_p, io_p, tlen); 566 else 567 memcpy(io_p, data_p, tlen); 568 569 length -= tlen; 570 571 io_len -= tlen; 572 if ((!io_len) && (length)) { 573 io_sg = sg_next(io_sg); 574 io_p = sg_virt(io_sg); 575 io_len = io_sg->length; 576 } else 577 io_p += tlen; 578 579 data_len -= tlen; 580 if ((!data_len) && (length)) { 581 data_sg = sg_next(data_sg); 582 data_p = sg_virt(data_sg); 583 data_len = data_sg->length; 584 } else 585 data_p += tlen; 586 } 587 } 588 589 static int 590 fcloop_fcp_op(struct nvmet_fc_target_port *tgtport, 591 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 592 { 593 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 594 struct nvmefc_fcp_req *fcpreq; 595 u32 rsplen = 0, xfrlen = 0; 596 int fcp_err = 0, active, aborted; 597 u8 op = tgt_fcpreq->op; 598 599 spin_lock(&tfcp_req->reqlock); 600 fcpreq = tfcp_req->fcpreq; 601 active = tfcp_req->active; 602 aborted = tfcp_req->aborted; 603 tfcp_req->active = true; 604 spin_unlock(&tfcp_req->reqlock); 605 606 if (unlikely(active)) 607 /* illegal - call while i/o active */ 608 return -EALREADY; 609 610 if (unlikely(aborted)) { 611 /* target transport has aborted i/o prior */ 612 spin_lock(&tfcp_req->reqlock); 613 tfcp_req->active = false; 614 spin_unlock(&tfcp_req->reqlock); 615 tgt_fcpreq->transferred_length = 0; 616 tgt_fcpreq->fcp_error = -ECANCELED; 617 tgt_fcpreq->done(tgt_fcpreq); 618 return 0; 619 } 620 621 /* 622 * if fcpreq is NULL, the I/O has been aborted (from 623 * initiator side). For the target side, act as if all is well 624 * but don't actually move data. 625 */ 626 627 switch (op) { 628 case NVMET_FCOP_WRITEDATA: 629 xfrlen = tgt_fcpreq->transfer_length; 630 if (fcpreq) { 631 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 632 fcpreq->first_sgl, tgt_fcpreq->offset, 633 xfrlen); 634 fcpreq->transferred_length += xfrlen; 635 } 636 break; 637 638 case NVMET_FCOP_READDATA: 639 case NVMET_FCOP_READDATA_RSP: 640 xfrlen = tgt_fcpreq->transfer_length; 641 if (fcpreq) { 642 fcloop_fcp_copy_data(op, tgt_fcpreq->sg, 643 fcpreq->first_sgl, tgt_fcpreq->offset, 644 xfrlen); 645 fcpreq->transferred_length += xfrlen; 646 } 647 if (op == NVMET_FCOP_READDATA) 648 break; 649 650 /* Fall-Thru to RSP handling */ 651 652 case NVMET_FCOP_RSP: 653 if (fcpreq) { 654 rsplen = ((fcpreq->rsplen < tgt_fcpreq->rsplen) ? 655 fcpreq->rsplen : tgt_fcpreq->rsplen); 656 memcpy(fcpreq->rspaddr, tgt_fcpreq->rspaddr, rsplen); 657 if (rsplen < tgt_fcpreq->rsplen) 658 fcp_err = -E2BIG; 659 fcpreq->rcv_rsplen = rsplen; 660 fcpreq->status = 0; 661 } 662 tfcp_req->status = 0; 663 break; 664 665 default: 666 fcp_err = -EINVAL; 667 break; 668 } 669 670 spin_lock(&tfcp_req->reqlock); 671 tfcp_req->active = false; 672 spin_unlock(&tfcp_req->reqlock); 673 674 tgt_fcpreq->transferred_length = xfrlen; 675 tgt_fcpreq->fcp_error = fcp_err; 676 tgt_fcpreq->done(tgt_fcpreq); 677 678 return 0; 679 } 680 681 static void 682 fcloop_tgt_fcp_abort(struct nvmet_fc_target_port *tgtport, 683 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 684 { 685 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 686 687 /* 688 * mark aborted only in case there were 2 threads in transport 689 * (one doing io, other doing abort) and only kills ops posted 690 * after the abort request 691 */ 692 spin_lock(&tfcp_req->reqlock); 693 tfcp_req->aborted = true; 694 spin_unlock(&tfcp_req->reqlock); 695 696 tfcp_req->status = NVME_SC_INTERNAL; 697 698 /* 699 * nothing more to do. If io wasn't active, the transport should 700 * immediately call the req_release. If it was active, the op 701 * will complete, and the lldd should call req_release. 702 */ 703 } 704 705 static void 706 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport, 707 struct nvmefc_tgt_fcp_req *tgt_fcpreq) 708 { 709 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq); 710 711 schedule_work(&tfcp_req->tio_done_work); 712 } 713 714 static void 715 fcloop_ls_abort(struct nvme_fc_local_port *localport, 716 struct nvme_fc_remote_port *remoteport, 717 struct nvmefc_ls_req *lsreq) 718 { 719 } 720 721 static void 722 fcloop_fcp_abort(struct nvme_fc_local_port *localport, 723 struct nvme_fc_remote_port *remoteport, 724 void *hw_queue_handle, 725 struct nvmefc_fcp_req *fcpreq) 726 { 727 struct fcloop_ini_fcpreq *inireq = fcpreq->private; 728 struct fcloop_fcpreq *tfcp_req; 729 bool abortio = true; 730 731 spin_lock(&inireq->inilock); 732 tfcp_req = inireq->tfcp_req; 733 if (tfcp_req) 734 fcloop_tfcp_req_get(tfcp_req); 735 spin_unlock(&inireq->inilock); 736 737 if (!tfcp_req) 738 /* abort has already been called */ 739 return; 740 741 /* break initiator/target relationship for io */ 742 spin_lock(&tfcp_req->reqlock); 743 switch (tfcp_req->inistate) { 744 case INI_IO_START: 745 case INI_IO_ACTIVE: 746 tfcp_req->inistate = INI_IO_ABORTED; 747 break; 748 case INI_IO_COMPLETED: 749 abortio = false; 750 break; 751 default: 752 spin_unlock(&tfcp_req->reqlock); 753 WARN_ON(1); 754 return; 755 } 756 spin_unlock(&tfcp_req->reqlock); 757 758 if (abortio) 759 /* leave the reference while the work item is scheduled */ 760 WARN_ON(!schedule_work(&tfcp_req->abort_rcv_work)); 761 else { 762 /* 763 * as the io has already had the done callback made, 764 * nothing more to do. So release the reference taken above 765 */ 766 fcloop_tfcp_req_put(tfcp_req); 767 } 768 } 769 770 static void 771 fcloop_nport_free(struct kref *ref) 772 { 773 struct fcloop_nport *nport = 774 container_of(ref, struct fcloop_nport, ref); 775 unsigned long flags; 776 777 spin_lock_irqsave(&fcloop_lock, flags); 778 list_del(&nport->nport_list); 779 spin_unlock_irqrestore(&fcloop_lock, flags); 780 781 kfree(nport); 782 } 783 784 static void 785 fcloop_nport_put(struct fcloop_nport *nport) 786 { 787 kref_put(&nport->ref, fcloop_nport_free); 788 } 789 790 static int 791 fcloop_nport_get(struct fcloop_nport *nport) 792 { 793 return kref_get_unless_zero(&nport->ref); 794 } 795 796 static void 797 fcloop_localport_delete(struct nvme_fc_local_port *localport) 798 { 799 struct fcloop_lport_priv *lport_priv = localport->private; 800 struct fcloop_lport *lport = lport_priv->lport; 801 802 /* release any threads waiting for the unreg to complete */ 803 complete(&lport->unreg_done); 804 } 805 806 static void 807 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport) 808 { 809 struct fcloop_rport *rport = remoteport->private; 810 811 fcloop_nport_put(rport->nport); 812 } 813 814 static void 815 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport) 816 { 817 struct fcloop_tport *tport = targetport->private; 818 819 fcloop_nport_put(tport->nport); 820 } 821 822 #define FCLOOP_HW_QUEUES 4 823 #define FCLOOP_SGL_SEGS 256 824 #define FCLOOP_DMABOUND_4G 0xFFFFFFFF 825 826 static struct nvme_fc_port_template fctemplate = { 827 .localport_delete = fcloop_localport_delete, 828 .remoteport_delete = fcloop_remoteport_delete, 829 .create_queue = fcloop_create_queue, 830 .delete_queue = fcloop_delete_queue, 831 .ls_req = fcloop_ls_req, 832 .fcp_io = fcloop_fcp_req, 833 .ls_abort = fcloop_ls_abort, 834 .fcp_abort = fcloop_fcp_abort, 835 .max_hw_queues = FCLOOP_HW_QUEUES, 836 .max_sgl_segments = FCLOOP_SGL_SEGS, 837 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 838 .dma_boundary = FCLOOP_DMABOUND_4G, 839 /* sizes of additional private data for data structures */ 840 .local_priv_sz = sizeof(struct fcloop_lport_priv), 841 .remote_priv_sz = sizeof(struct fcloop_rport), 842 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq), 843 .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq), 844 }; 845 846 static struct nvmet_fc_target_template tgttemplate = { 847 .targetport_delete = fcloop_targetport_delete, 848 .xmt_ls_rsp = fcloop_xmt_ls_rsp, 849 .fcp_op = fcloop_fcp_op, 850 .fcp_abort = fcloop_tgt_fcp_abort, 851 .fcp_req_release = fcloop_fcp_req_release, 852 .max_hw_queues = FCLOOP_HW_QUEUES, 853 .max_sgl_segments = FCLOOP_SGL_SEGS, 854 .max_dif_sgl_segments = FCLOOP_SGL_SEGS, 855 .dma_boundary = FCLOOP_DMABOUND_4G, 856 /* optional features */ 857 .target_features = 0, 858 /* sizes of additional private data for data structures */ 859 .target_priv_sz = sizeof(struct fcloop_tport), 860 }; 861 862 static ssize_t 863 fcloop_create_local_port(struct device *dev, struct device_attribute *attr, 864 const char *buf, size_t count) 865 { 866 struct nvme_fc_port_info pinfo; 867 struct fcloop_ctrl_options *opts; 868 struct nvme_fc_local_port *localport; 869 struct fcloop_lport *lport; 870 struct fcloop_lport_priv *lport_priv; 871 unsigned long flags; 872 int ret = -ENOMEM; 873 874 lport = kzalloc(sizeof(*lport), GFP_KERNEL); 875 if (!lport) 876 return -ENOMEM; 877 878 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 879 if (!opts) 880 goto out_free_lport; 881 882 ret = fcloop_parse_options(opts, buf); 883 if (ret) 884 goto out_free_opts; 885 886 /* everything there ? */ 887 if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) { 888 ret = -EINVAL; 889 goto out_free_opts; 890 } 891 892 memset(&pinfo, 0, sizeof(pinfo)); 893 pinfo.node_name = opts->wwnn; 894 pinfo.port_name = opts->wwpn; 895 pinfo.port_role = opts->roles; 896 pinfo.port_id = opts->fcaddr; 897 898 ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport); 899 if (!ret) { 900 /* success */ 901 lport_priv = localport->private; 902 lport_priv->lport = lport; 903 904 lport->localport = localport; 905 INIT_LIST_HEAD(&lport->lport_list); 906 907 spin_lock_irqsave(&fcloop_lock, flags); 908 list_add_tail(&lport->lport_list, &fcloop_lports); 909 spin_unlock_irqrestore(&fcloop_lock, flags); 910 } 911 912 out_free_opts: 913 kfree(opts); 914 out_free_lport: 915 /* free only if we're going to fail */ 916 if (ret) 917 kfree(lport); 918 919 return ret ? ret : count; 920 } 921 922 923 static void 924 __unlink_local_port(struct fcloop_lport *lport) 925 { 926 list_del(&lport->lport_list); 927 } 928 929 static int 930 __wait_localport_unreg(struct fcloop_lport *lport) 931 { 932 int ret; 933 934 init_completion(&lport->unreg_done); 935 936 ret = nvme_fc_unregister_localport(lport->localport); 937 938 wait_for_completion(&lport->unreg_done); 939 940 kfree(lport); 941 942 return ret; 943 } 944 945 946 static ssize_t 947 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr, 948 const char *buf, size_t count) 949 { 950 struct fcloop_lport *tlport, *lport = NULL; 951 u64 nodename, portname; 952 unsigned long flags; 953 int ret; 954 955 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 956 if (ret) 957 return ret; 958 959 spin_lock_irqsave(&fcloop_lock, flags); 960 961 list_for_each_entry(tlport, &fcloop_lports, lport_list) { 962 if (tlport->localport->node_name == nodename && 963 tlport->localport->port_name == portname) { 964 lport = tlport; 965 __unlink_local_port(lport); 966 break; 967 } 968 } 969 spin_unlock_irqrestore(&fcloop_lock, flags); 970 971 if (!lport) 972 return -ENOENT; 973 974 ret = __wait_localport_unreg(lport); 975 976 return ret ? ret : count; 977 } 978 979 static struct fcloop_nport * 980 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport) 981 { 982 struct fcloop_nport *newnport, *nport = NULL; 983 struct fcloop_lport *tmplport, *lport = NULL; 984 struct fcloop_ctrl_options *opts; 985 unsigned long flags; 986 u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS; 987 int ret; 988 989 opts = kzalloc(sizeof(*opts), GFP_KERNEL); 990 if (!opts) 991 return NULL; 992 993 ret = fcloop_parse_options(opts, buf); 994 if (ret) 995 goto out_free_opts; 996 997 /* everything there ? */ 998 if ((opts->mask & opts_mask) != opts_mask) { 999 ret = -EINVAL; 1000 goto out_free_opts; 1001 } 1002 1003 newnport = kzalloc(sizeof(*newnport), GFP_KERNEL); 1004 if (!newnport) 1005 goto out_free_opts; 1006 1007 INIT_LIST_HEAD(&newnport->nport_list); 1008 newnport->node_name = opts->wwnn; 1009 newnport->port_name = opts->wwpn; 1010 if (opts->mask & NVMF_OPT_ROLES) 1011 newnport->port_role = opts->roles; 1012 if (opts->mask & NVMF_OPT_FCADDR) 1013 newnport->port_id = opts->fcaddr; 1014 kref_init(&newnport->ref); 1015 1016 spin_lock_irqsave(&fcloop_lock, flags); 1017 1018 list_for_each_entry(tmplport, &fcloop_lports, lport_list) { 1019 if (tmplport->localport->node_name == opts->wwnn && 1020 tmplport->localport->port_name == opts->wwpn) 1021 goto out_invalid_opts; 1022 1023 if (tmplport->localport->node_name == opts->lpwwnn && 1024 tmplport->localport->port_name == opts->lpwwpn) 1025 lport = tmplport; 1026 } 1027 1028 if (remoteport) { 1029 if (!lport) 1030 goto out_invalid_opts; 1031 newnport->lport = lport; 1032 } 1033 1034 list_for_each_entry(nport, &fcloop_nports, nport_list) { 1035 if (nport->node_name == opts->wwnn && 1036 nport->port_name == opts->wwpn) { 1037 if ((remoteport && nport->rport) || 1038 (!remoteport && nport->tport)) { 1039 nport = NULL; 1040 goto out_invalid_opts; 1041 } 1042 1043 fcloop_nport_get(nport); 1044 1045 spin_unlock_irqrestore(&fcloop_lock, flags); 1046 1047 if (remoteport) 1048 nport->lport = lport; 1049 if (opts->mask & NVMF_OPT_ROLES) 1050 nport->port_role = opts->roles; 1051 if (opts->mask & NVMF_OPT_FCADDR) 1052 nport->port_id = opts->fcaddr; 1053 goto out_free_newnport; 1054 } 1055 } 1056 1057 list_add_tail(&newnport->nport_list, &fcloop_nports); 1058 1059 spin_unlock_irqrestore(&fcloop_lock, flags); 1060 1061 kfree(opts); 1062 return newnport; 1063 1064 out_invalid_opts: 1065 spin_unlock_irqrestore(&fcloop_lock, flags); 1066 out_free_newnport: 1067 kfree(newnport); 1068 out_free_opts: 1069 kfree(opts); 1070 return nport; 1071 } 1072 1073 static ssize_t 1074 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr, 1075 const char *buf, size_t count) 1076 { 1077 struct nvme_fc_remote_port *remoteport; 1078 struct fcloop_nport *nport; 1079 struct fcloop_rport *rport; 1080 struct nvme_fc_port_info pinfo; 1081 int ret; 1082 1083 nport = fcloop_alloc_nport(buf, count, true); 1084 if (!nport) 1085 return -EIO; 1086 1087 memset(&pinfo, 0, sizeof(pinfo)); 1088 pinfo.node_name = nport->node_name; 1089 pinfo.port_name = nport->port_name; 1090 pinfo.port_role = nport->port_role; 1091 pinfo.port_id = nport->port_id; 1092 1093 ret = nvme_fc_register_remoteport(nport->lport->localport, 1094 &pinfo, &remoteport); 1095 if (ret || !remoteport) { 1096 fcloop_nport_put(nport); 1097 return ret; 1098 } 1099 1100 /* success */ 1101 rport = remoteport->private; 1102 rport->remoteport = remoteport; 1103 rport->targetport = (nport->tport) ? nport->tport->targetport : NULL; 1104 if (nport->tport) { 1105 nport->tport->remoteport = remoteport; 1106 nport->tport->lport = nport->lport; 1107 } 1108 rport->nport = nport; 1109 rport->lport = nport->lport; 1110 nport->rport = rport; 1111 1112 return count; 1113 } 1114 1115 1116 static struct fcloop_rport * 1117 __unlink_remote_port(struct fcloop_nport *nport) 1118 { 1119 struct fcloop_rport *rport = nport->rport; 1120 1121 if (rport && nport->tport) 1122 nport->tport->remoteport = NULL; 1123 nport->rport = NULL; 1124 1125 return rport; 1126 } 1127 1128 static int 1129 __remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport) 1130 { 1131 if (!rport) 1132 return -EALREADY; 1133 1134 return nvme_fc_unregister_remoteport(rport->remoteport); 1135 } 1136 1137 static ssize_t 1138 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr, 1139 const char *buf, size_t count) 1140 { 1141 struct fcloop_nport *nport = NULL, *tmpport; 1142 static struct fcloop_rport *rport; 1143 u64 nodename, portname; 1144 unsigned long flags; 1145 int ret; 1146 1147 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1148 if (ret) 1149 return ret; 1150 1151 spin_lock_irqsave(&fcloop_lock, flags); 1152 1153 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1154 if (tmpport->node_name == nodename && 1155 tmpport->port_name == portname && tmpport->rport) { 1156 nport = tmpport; 1157 rport = __unlink_remote_port(nport); 1158 break; 1159 } 1160 } 1161 1162 spin_unlock_irqrestore(&fcloop_lock, flags); 1163 1164 if (!nport) 1165 return -ENOENT; 1166 1167 ret = __remoteport_unreg(nport, rport); 1168 1169 return ret ? ret : count; 1170 } 1171 1172 static ssize_t 1173 fcloop_create_target_port(struct device *dev, struct device_attribute *attr, 1174 const char *buf, size_t count) 1175 { 1176 struct nvmet_fc_target_port *targetport; 1177 struct fcloop_nport *nport; 1178 struct fcloop_tport *tport; 1179 struct nvmet_fc_port_info tinfo; 1180 int ret; 1181 1182 nport = fcloop_alloc_nport(buf, count, false); 1183 if (!nport) 1184 return -EIO; 1185 1186 tinfo.node_name = nport->node_name; 1187 tinfo.port_name = nport->port_name; 1188 tinfo.port_id = nport->port_id; 1189 1190 ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL, 1191 &targetport); 1192 if (ret) { 1193 fcloop_nport_put(nport); 1194 return ret; 1195 } 1196 1197 /* success */ 1198 tport = targetport->private; 1199 tport->targetport = targetport; 1200 tport->remoteport = (nport->rport) ? nport->rport->remoteport : NULL; 1201 if (nport->rport) 1202 nport->rport->targetport = targetport; 1203 tport->nport = nport; 1204 tport->lport = nport->lport; 1205 nport->tport = tport; 1206 1207 return count; 1208 } 1209 1210 1211 static struct fcloop_tport * 1212 __unlink_target_port(struct fcloop_nport *nport) 1213 { 1214 struct fcloop_tport *tport = nport->tport; 1215 1216 if (tport && nport->rport) 1217 nport->rport->targetport = NULL; 1218 nport->tport = NULL; 1219 1220 return tport; 1221 } 1222 1223 static int 1224 __targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport) 1225 { 1226 if (!tport) 1227 return -EALREADY; 1228 1229 return nvmet_fc_unregister_targetport(tport->targetport); 1230 } 1231 1232 static ssize_t 1233 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr, 1234 const char *buf, size_t count) 1235 { 1236 struct fcloop_nport *nport = NULL, *tmpport; 1237 struct fcloop_tport *tport = NULL; 1238 u64 nodename, portname; 1239 unsigned long flags; 1240 int ret; 1241 1242 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf); 1243 if (ret) 1244 return ret; 1245 1246 spin_lock_irqsave(&fcloop_lock, flags); 1247 1248 list_for_each_entry(tmpport, &fcloop_nports, nport_list) { 1249 if (tmpport->node_name == nodename && 1250 tmpport->port_name == portname && tmpport->tport) { 1251 nport = tmpport; 1252 tport = __unlink_target_port(nport); 1253 break; 1254 } 1255 } 1256 1257 spin_unlock_irqrestore(&fcloop_lock, flags); 1258 1259 if (!nport) 1260 return -ENOENT; 1261 1262 ret = __targetport_unreg(nport, tport); 1263 1264 return ret ? ret : count; 1265 } 1266 1267 1268 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port); 1269 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port); 1270 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port); 1271 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port); 1272 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port); 1273 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port); 1274 1275 static struct attribute *fcloop_dev_attrs[] = { 1276 &dev_attr_add_local_port.attr, 1277 &dev_attr_del_local_port.attr, 1278 &dev_attr_add_remote_port.attr, 1279 &dev_attr_del_remote_port.attr, 1280 &dev_attr_add_target_port.attr, 1281 &dev_attr_del_target_port.attr, 1282 NULL 1283 }; 1284 1285 static struct attribute_group fclopp_dev_attrs_group = { 1286 .attrs = fcloop_dev_attrs, 1287 }; 1288 1289 static const struct attribute_group *fcloop_dev_attr_groups[] = { 1290 &fclopp_dev_attrs_group, 1291 NULL, 1292 }; 1293 1294 static struct class *fcloop_class; 1295 static struct device *fcloop_device; 1296 1297 1298 static int __init fcloop_init(void) 1299 { 1300 int ret; 1301 1302 fcloop_class = class_create(THIS_MODULE, "fcloop"); 1303 if (IS_ERR(fcloop_class)) { 1304 pr_err("couldn't register class fcloop\n"); 1305 ret = PTR_ERR(fcloop_class); 1306 return ret; 1307 } 1308 1309 fcloop_device = device_create_with_groups( 1310 fcloop_class, NULL, MKDEV(0, 0), NULL, 1311 fcloop_dev_attr_groups, "ctl"); 1312 if (IS_ERR(fcloop_device)) { 1313 pr_err("couldn't create ctl device!\n"); 1314 ret = PTR_ERR(fcloop_device); 1315 goto out_destroy_class; 1316 } 1317 1318 get_device(fcloop_device); 1319 1320 return 0; 1321 1322 out_destroy_class: 1323 class_destroy(fcloop_class); 1324 return ret; 1325 } 1326 1327 static void __exit fcloop_exit(void) 1328 { 1329 struct fcloop_lport *lport; 1330 struct fcloop_nport *nport; 1331 struct fcloop_tport *tport; 1332 struct fcloop_rport *rport; 1333 unsigned long flags; 1334 int ret; 1335 1336 spin_lock_irqsave(&fcloop_lock, flags); 1337 1338 for (;;) { 1339 nport = list_first_entry_or_null(&fcloop_nports, 1340 typeof(*nport), nport_list); 1341 if (!nport) 1342 break; 1343 1344 tport = __unlink_target_port(nport); 1345 rport = __unlink_remote_port(nport); 1346 1347 spin_unlock_irqrestore(&fcloop_lock, flags); 1348 1349 ret = __targetport_unreg(nport, tport); 1350 if (ret) 1351 pr_warn("%s: Failed deleting target port\n", __func__); 1352 1353 ret = __remoteport_unreg(nport, rport); 1354 if (ret) 1355 pr_warn("%s: Failed deleting remote port\n", __func__); 1356 1357 spin_lock_irqsave(&fcloop_lock, flags); 1358 } 1359 1360 for (;;) { 1361 lport = list_first_entry_or_null(&fcloop_lports, 1362 typeof(*lport), lport_list); 1363 if (!lport) 1364 break; 1365 1366 __unlink_local_port(lport); 1367 1368 spin_unlock_irqrestore(&fcloop_lock, flags); 1369 1370 ret = __wait_localport_unreg(lport); 1371 if (ret) 1372 pr_warn("%s: Failed deleting local port\n", __func__); 1373 1374 spin_lock_irqsave(&fcloop_lock, flags); 1375 } 1376 1377 spin_unlock_irqrestore(&fcloop_lock, flags); 1378 1379 put_device(fcloop_device); 1380 1381 device_destroy(fcloop_class, MKDEV(0, 0)); 1382 class_destroy(fcloop_class); 1383 } 1384 1385 module_init(fcloop_init); 1386 module_exit(fcloop_exit); 1387 1388 MODULE_LICENSE("GPL v2"); 1389