drivers/nvme/target/fcloop.c

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