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