drivers/nvme/target/fcloop.c

   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         int active;
 573
 574         /*
 575          * mark aborted only in case there were 2 threads in transport
 576          * (one doing io, other doing abort) and only kills ops posted
 577          * after the abort request
 578          */
 579         spin_lock(&tfcp_req->reqlock);
 580         active = tfcp_req->active;
 581         tfcp_req->aborted = true;
 582         spin_unlock(&tfcp_req->reqlock);
 583
 584         tfcp_req->status = NVME_SC_FC_TRANSPORT_ABORTED;
 585
 586         /*
 587          * nothing more to do. If io wasn't active, the transport should
 588          * immediately call the req_release. If it was active, the op
 589          * will complete, and the lldd should call req_release.
 590          */
 591 }
 592
 593 static void
 594 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport,
 595                         struct nvmefc_tgt_fcp_req *tgt_fcpreq)
 596 {
 597         struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
 598
 599         schedule_work(&tfcp_req->work);
 600 }
 601
 602 static void
 603 fcloop_ls_abort(struct nvme_fc_local_port *localport,
 604                         struct nvme_fc_remote_port *remoteport,
 605                                 struct nvmefc_ls_req *lsreq)
 606 {
 607 }
 608
 609 static void
 610 fcloop_fcp_abort(struct nvme_fc_local_port *localport,
 611                         struct nvme_fc_remote_port *remoteport,
 612                         void *hw_queue_handle,
 613                         struct nvmefc_fcp_req *fcpreq)
 614 {
 615         struct fcloop_rport *rport = remoteport->private;
 616         struct fcloop_ini_fcpreq *inireq = fcpreq->private;
 617         struct fcloop_fcpreq *tfcp_req = inireq->tfcp_req;
 618
 619         if (!tfcp_req)
 620                 /* abort has already been called */
 621                 return;
 622
 623         if (rport->targetport)
 624                 nvmet_fc_rcv_fcp_abort(rport->targetport,
 625                                         &tfcp_req->tgt_fcp_req);
 626
 627         /* break initiator/target relationship for io */
 628         spin_lock(&tfcp_req->reqlock);
 629         inireq->tfcp_req = NULL;
 630         tfcp_req->fcpreq = NULL;
 631         spin_unlock(&tfcp_req->reqlock);
 632
 633         /* post the aborted io completion */
 634         fcpreq->status = -ECANCELED;
 635         schedule_work(&inireq->iniwork);
 636 }
 637
 638 static void
 639 fcloop_localport_delete(struct nvme_fc_local_port *localport)
 640 {
 641         struct fcloop_lport *lport = localport->private;
 642
 643         /* release any threads waiting for the unreg to complete */
 644         complete(&lport->unreg_done);
 645 }
 646
 647 static void
 648 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport)
 649 {
 650         struct fcloop_rport *rport = remoteport->private;
 651
 652         /* release any threads waiting for the unreg to complete */
 653         complete(&rport->nport->rport_unreg_done);
 654 }
 655
 656 static void
 657 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport)
 658 {
 659         struct fcloop_tport *tport = targetport->private;
 660
 661         /* release any threads waiting for the unreg to complete */
 662         complete(&tport->nport->tport_unreg_done);
 663 }
 664
 665 #define FCLOOP_HW_QUEUES                4
 666 #define FCLOOP_SGL_SEGS                 256
 667 #define FCLOOP_DMABOUND_4G              0xFFFFFFFF
 668
 669 static struct nvme_fc_port_template fctemplate = {
 670         .localport_delete       = fcloop_localport_delete,
 671         .remoteport_delete      = fcloop_remoteport_delete,
 672         .create_queue           = fcloop_create_queue,
 673         .delete_queue           = fcloop_delete_queue,
 674         .ls_req                 = fcloop_ls_req,
 675         .fcp_io                 = fcloop_fcp_req,
 676         .ls_abort               = fcloop_ls_abort,
 677         .fcp_abort              = fcloop_fcp_abort,
 678         .max_hw_queues          = FCLOOP_HW_QUEUES,
 679         .max_sgl_segments       = FCLOOP_SGL_SEGS,
 680         .max_dif_sgl_segments   = FCLOOP_SGL_SEGS,
 681         .dma_boundary           = FCLOOP_DMABOUND_4G,
 682         /* sizes of additional private data for data structures */
 683         .local_priv_sz          = sizeof(struct fcloop_lport),
 684         .remote_priv_sz         = sizeof(struct fcloop_rport),
 685         .lsrqst_priv_sz         = sizeof(struct fcloop_lsreq),
 686         .fcprqst_priv_sz        = sizeof(struct fcloop_ini_fcpreq),
 687 };
 688
 689 static struct nvmet_fc_target_template tgttemplate = {
 690         .targetport_delete      = fcloop_targetport_delete,
 691         .xmt_ls_rsp             = fcloop_xmt_ls_rsp,
 692         .fcp_op                 = fcloop_fcp_op,
 693         .fcp_abort              = fcloop_tgt_fcp_abort,
 694         .fcp_req_release        = fcloop_fcp_req_release,
 695         .max_hw_queues          = FCLOOP_HW_QUEUES,
 696         .max_sgl_segments       = FCLOOP_SGL_SEGS,
 697         .max_dif_sgl_segments   = FCLOOP_SGL_SEGS,
 698         .dma_boundary           = FCLOOP_DMABOUND_4G,
 699         /* optional features */
 700         .target_features        = NVMET_FCTGTFEAT_CMD_IN_ISR |
 701                                   NVMET_FCTGTFEAT_NEEDS_CMD_CPUSCHED |
 702                                   NVMET_FCTGTFEAT_OPDONE_IN_ISR,
 703         /* sizes of additional private data for data structures */
 704         .target_priv_sz         = sizeof(struct fcloop_tport),
 705 };
 706
 707 static ssize_t
 708 fcloop_create_local_port(struct device *dev, struct device_attribute *attr,
 709                 const char *buf, size_t count)
 710 {
 711         struct nvme_fc_port_info pinfo;
 712         struct fcloop_ctrl_options *opts;
 713         struct nvme_fc_local_port *localport;
 714         struct fcloop_lport *lport;
 715         int ret;
 716
 717         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 718         if (!opts)
 719                 return -ENOMEM;
 720
 721         ret = fcloop_parse_options(opts, buf);
 722         if (ret)
 723                 goto out_free_opts;
 724
 725         /* everything there ? */
 726         if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) {
 727                 ret = -EINVAL;
 728                 goto out_free_opts;
 729         }
 730
 731         pinfo.node_name = opts->wwnn;
 732         pinfo.port_name = opts->wwpn;
 733         pinfo.port_role = opts->roles;
 734         pinfo.port_id = opts->fcaddr;
 735
 736         ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport);
 737         if (!ret) {
 738                 unsigned long flags;
 739
 740                 /* success */
 741                 lport = localport->private;
 742                 lport->localport = localport;
 743                 INIT_LIST_HEAD(&lport->lport_list);
 744
 745                 spin_lock_irqsave(&fcloop_lock, flags);
 746                 list_add_tail(&lport->lport_list, &fcloop_lports);
 747                 spin_unlock_irqrestore(&fcloop_lock, flags);
 748
 749                 /* mark all of the input buffer consumed */
 750                 ret = count;
 751         }
 752
 753 out_free_opts:
 754         kfree(opts);
 755         return ret ? ret : count;
 756 }
 757
 758
 759 static void
 760 __unlink_local_port(struct fcloop_lport *lport)
 761 {
 762         list_del(&lport->lport_list);
 763 }
 764
 765 static int
 766 __wait_localport_unreg(struct fcloop_lport *lport)
 767 {
 768         int ret;
 769
 770         init_completion(&lport->unreg_done);
 771
 772         ret = nvme_fc_unregister_localport(lport->localport);
 773
 774         wait_for_completion(&lport->unreg_done);
 775
 776         return ret;
 777 }
 778
 779
 780 static ssize_t
 781 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr,
 782                 const char *buf, size_t count)
 783 {
 784         struct fcloop_lport *tlport, *lport = NULL;
 785         u64 nodename, portname;
 786         unsigned long flags;
 787         int ret;
 788
 789         ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
 790         if (ret)
 791                 return ret;
 792
 793         spin_lock_irqsave(&fcloop_lock, flags);
 794
 795         list_for_each_entry(tlport, &fcloop_lports, lport_list) {
 796                 if (tlport->localport->node_name == nodename &&
 797                     tlport->localport->port_name == portname) {
 798                         lport = tlport;
 799                         __unlink_local_port(lport);
 800                         break;
 801                 }
 802         }
 803         spin_unlock_irqrestore(&fcloop_lock, flags);
 804
 805         if (!lport)
 806                 return -ENOENT;
 807
 808         ret = __wait_localport_unreg(lport);
 809
 810         return ret ? ret : count;
 811 }
 812
 813 static void
 814 fcloop_nport_free(struct kref *ref)
 815 {
 816         struct fcloop_nport *nport =
 817                 container_of(ref, struct fcloop_nport, ref);
 818         unsigned long flags;
 819
 820         spin_lock_irqsave(&fcloop_lock, flags);
 821         list_del(&nport->nport_list);
 822         spin_unlock_irqrestore(&fcloop_lock, flags);
 823
 824         kfree(nport);
 825 }
 826
 827 static void
 828 fcloop_nport_put(struct fcloop_nport *nport)
 829 {
 830         kref_put(&nport->ref, fcloop_nport_free);
 831 }
 832
 833 static int
 834 fcloop_nport_get(struct fcloop_nport *nport)
 835 {
 836         return kref_get_unless_zero(&nport->ref);
 837 }
 838
 839 static struct fcloop_nport *
 840 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport)
 841 {
 842         struct fcloop_nport *newnport, *nport = NULL;
 843         struct fcloop_lport *tmplport, *lport = NULL;
 844         struct fcloop_ctrl_options *opts;
 845         unsigned long flags;
 846         u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS;
 847         int ret;
 848
 849         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 850         if (!opts)
 851                 return NULL;
 852
 853         ret = fcloop_parse_options(opts, buf);
 854         if (ret)
 855                 goto out_free_opts;
 856
 857         /* everything there ? */
 858         if ((opts->mask & opts_mask) != opts_mask) {
 859                 ret = -EINVAL;
 860                 goto out_free_opts;
 861         }
 862
 863         newnport = kzalloc(sizeof(*newnport), GFP_KERNEL);
 864         if (!newnport)
 865                 goto out_free_opts;
 866
 867         INIT_LIST_HEAD(&newnport->nport_list);
 868         newnport->node_name = opts->wwnn;
 869         newnport->port_name = opts->wwpn;
 870         if (opts->mask & NVMF_OPT_ROLES)
 871                 newnport->port_role = opts->roles;
 872         if (opts->mask & NVMF_OPT_FCADDR)
 873                 newnport->port_id = opts->fcaddr;
 874         kref_init(&newnport->ref);
 875
 876         spin_lock_irqsave(&fcloop_lock, flags);
 877
 878         list_for_each_entry(tmplport, &fcloop_lports, lport_list) {
 879                 if (tmplport->localport->node_name == opts->wwnn &&
 880                     tmplport->localport->port_name == opts->wwpn)
 881                         goto out_invalid_opts;
 882
 883                 if (tmplport->localport->node_name == opts->lpwwnn &&
 884                     tmplport->localport->port_name == opts->lpwwpn)
 885                         lport = tmplport;
 886         }
 887
 888         if (remoteport) {
 889                 if (!lport)
 890                         goto out_invalid_opts;
 891                 newnport->lport = lport;
 892         }
 893
 894         list_for_each_entry(nport, &fcloop_nports, nport_list) {
 895                 if (nport->node_name == opts->wwnn &&
 896                     nport->port_name == opts->wwpn) {
 897                         if ((remoteport && nport->rport) ||
 898                             (!remoteport && nport->tport)) {
 899                                 nport = NULL;
 900                                 goto out_invalid_opts;
 901                         }
 902
 903                         fcloop_nport_get(nport);
 904
 905                         spin_unlock_irqrestore(&fcloop_lock, flags);
 906
 907                         if (remoteport)
 908                                 nport->lport = lport;
 909                         if (opts->mask & NVMF_OPT_ROLES)
 910                                 nport->port_role = opts->roles;
 911                         if (opts->mask & NVMF_OPT_FCADDR)
 912                                 nport->port_id = opts->fcaddr;
 913                         goto out_free_newnport;
 914                 }
 915         }
 916
 917         list_add_tail(&newnport->nport_list, &fcloop_nports);
 918
 919         spin_unlock_irqrestore(&fcloop_lock, flags);
 920
 921         kfree(opts);
 922         return newnport;
 923
 924 out_invalid_opts:
 925         spin_unlock_irqrestore(&fcloop_lock, flags);
 926 out_free_newnport:
 927         kfree(newnport);
 928 out_free_opts:
 929         kfree(opts);
 930         return nport;
 931 }
 932
 933 static ssize_t
 934 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr,
 935                 const char *buf, size_t count)
 936 {
 937         struct nvme_fc_remote_port *remoteport;
 938         struct fcloop_nport *nport;
 939         struct fcloop_rport *rport;
 940         struct nvme_fc_port_info pinfo;
 941         int ret;
 942
 943         nport = fcloop_alloc_nport(buf, count, true);
 944         if (!nport)
 945                 return -EIO;
 946
 947         pinfo.node_name = nport->node_name;
 948         pinfo.port_name = nport->port_name;
 949         pinfo.port_role = nport->port_role;
 950         pinfo.port_id = nport->port_id;
 951
 952         ret = nvme_fc_register_remoteport(nport->lport->localport,
 953                                                 &pinfo, &remoteport);
 954         if (ret || !remoteport) {
 955                 fcloop_nport_put(nport);
 956                 return ret;
 957         }
 958
 959         /* success */
 960         rport = remoteport->private;
 961         rport->remoteport = remoteport;
 962         rport->targetport = (nport->tport) ?  nport->tport->targetport : NULL;
 963         if (nport->tport) {
 964                 nport->tport->remoteport = remoteport;
 965                 nport->tport->lport = nport->lport;
 966         }
 967         rport->nport = nport;
 968         rport->lport = nport->lport;
 969         nport->rport = rport;
 970
 971         return count;
 972 }
 973
 974
 975 static struct fcloop_rport *
 976 __unlink_remote_port(struct fcloop_nport *nport)
 977 {
 978         struct fcloop_rport *rport = nport->rport;
 979
 980         if (rport && nport->tport)
 981                 nport->tport->remoteport = NULL;
 982         nport->rport = NULL;
 983
 984         return rport;
 985 }
 986
 987 static int
 988 __wait_remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport)
 989 {
 990         int ret;
 991
 992         if (!rport)
 993                 return -EALREADY;
 994
 995         init_completion(&nport->rport_unreg_done);
 996
 997         ret = nvme_fc_unregister_remoteport(rport->remoteport);
 998         if (ret)
 999                 return ret;
1000
1001         wait_for_completion(&nport->rport_unreg_done);
1002
1003         fcloop_nport_put(nport);
1004
1005         return ret;
1006 }
1007
1008 static ssize_t
1009 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr,
1010                 const char *buf, size_t count)
1011 {
1012         struct fcloop_nport *nport = NULL, *tmpport;
1013         static struct fcloop_rport *rport;
1014         u64 nodename, portname;
1015         unsigned long flags;
1016         int ret;
1017
1018         ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1019         if (ret)
1020                 return ret;
1021
1022         spin_lock_irqsave(&fcloop_lock, flags);
1023
1024         list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1025                 if (tmpport->node_name == nodename &&
1026                     tmpport->port_name == portname && tmpport->rport) {
1027                         nport = tmpport;
1028                         rport = __unlink_remote_port(nport);
1029                         break;
1030                 }
1031         }
1032
1033         spin_unlock_irqrestore(&fcloop_lock, flags);
1034
1035         if (!nport)
1036                 return -ENOENT;
1037
1038         ret = __wait_remoteport_unreg(nport, rport);
1039
1040         return ret ? ret : count;
1041 }
1042
1043 static ssize_t
1044 fcloop_create_target_port(struct device *dev, struct device_attribute *attr,
1045                 const char *buf, size_t count)
1046 {
1047         struct nvmet_fc_target_port *targetport;
1048         struct fcloop_nport *nport;
1049         struct fcloop_tport *tport;
1050         struct nvmet_fc_port_info tinfo;
1051         int ret;
1052
1053         nport = fcloop_alloc_nport(buf, count, false);
1054         if (!nport)
1055                 return -EIO;
1056
1057         tinfo.node_name = nport->node_name;
1058         tinfo.port_name = nport->port_name;
1059         tinfo.port_id = nport->port_id;
1060
1061         ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL,
1062                                                 &targetport);
1063         if (ret) {
1064                 fcloop_nport_put(nport);
1065                 return ret;
1066         }
1067
1068         /* success */
1069         tport = targetport->private;
1070         tport->targetport = targetport;
1071         tport->remoteport = (nport->rport) ?  nport->rport->remoteport : NULL;
1072         if (nport->rport)
1073                 nport->rport->targetport = targetport;
1074         tport->nport = nport;
1075         tport->lport = nport->lport;
1076         nport->tport = tport;
1077
1078         return count;
1079 }
1080
1081
1082 static struct fcloop_tport *
1083 __unlink_target_port(struct fcloop_nport *nport)
1084 {
1085         struct fcloop_tport *tport = nport->tport;
1086
1087         if (tport && nport->rport)
1088                 nport->rport->targetport = NULL;
1089         nport->tport = NULL;
1090
1091         return tport;
1092 }
1093
1094 static int
1095 __wait_targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport)
1096 {
1097         int ret;
1098
1099         if (!tport)
1100                 return -EALREADY;
1101
1102         init_completion(&nport->tport_unreg_done);
1103
1104         ret = nvmet_fc_unregister_targetport(tport->targetport);
1105         if (ret)
1106                 return ret;
1107
1108         wait_for_completion(&nport->tport_unreg_done);
1109
1110         fcloop_nport_put(nport);
1111
1112         return ret;
1113 }
1114
1115 static ssize_t
1116 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr,
1117                 const char *buf, size_t count)
1118 {
1119         struct fcloop_nport *nport = NULL, *tmpport;
1120         struct fcloop_tport *tport;
1121         u64 nodename, portname;
1122         unsigned long flags;
1123         int ret;
1124
1125         ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1126         if (ret)
1127                 return ret;
1128
1129         spin_lock_irqsave(&fcloop_lock, flags);
1130
1131         list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1132                 if (tmpport->node_name == nodename &&
1133                     tmpport->port_name == portname && tmpport->tport) {
1134                         nport = tmpport;
1135                         tport = __unlink_target_port(nport);
1136                         break;
1137                 }
1138         }
1139
1140         spin_unlock_irqrestore(&fcloop_lock, flags);
1141
1142         if (!nport)
1143                 return -ENOENT;
1144
1145         ret = __wait_targetport_unreg(nport, tport);
1146
1147         return ret ? ret : count;
1148 }
1149
1150
1151 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port);
1152 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port);
1153 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port);
1154 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port);
1155 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port);
1156 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port);
1157
1158 static struct attribute *fcloop_dev_attrs[] = {
1159         &dev_attr_add_local_port.attr,
1160         &dev_attr_del_local_port.attr,
1161         &dev_attr_add_remote_port.attr,
1162         &dev_attr_del_remote_port.attr,
1163         &dev_attr_add_target_port.attr,
1164         &dev_attr_del_target_port.attr,
1165         NULL
1166 };
1167
1168 static struct attribute_group fclopp_dev_attrs_group = {
1169         .attrs          = fcloop_dev_attrs,
1170 };
1171
1172 static const struct attribute_group *fcloop_dev_attr_groups[] = {
1173         &fclopp_dev_attrs_group,
1174         NULL,
1175 };
1176
1177 static struct class *fcloop_class;
1178 static struct device *fcloop_device;
1179
1180
1181 static int __init fcloop_init(void)
1182 {
1183         int ret;
1184
1185         fcloop_class = class_create(THIS_MODULE, "fcloop");
1186         if (IS_ERR(fcloop_class)) {
1187                 pr_err("couldn't register class fcloop\n");
1188                 ret = PTR_ERR(fcloop_class);
1189                 return ret;
1190         }
1191
1192         fcloop_device = device_create_with_groups(
1193                                 fcloop_class, NULL, MKDEV(0, 0), NULL,
1194                                 fcloop_dev_attr_groups, "ctl");
1195         if (IS_ERR(fcloop_device)) {
1196                 pr_err("couldn't create ctl device!\n");
1197                 ret = PTR_ERR(fcloop_device);
1198                 goto out_destroy_class;
1199         }
1200
1201         get_device(fcloop_device);
1202
1203         return 0;
1204
1205 out_destroy_class:
1206         class_destroy(fcloop_class);
1207         return ret;
1208 }
1209
1210 static void __exit fcloop_exit(void)
1211 {
1212         struct fcloop_lport *lport;
1213         struct fcloop_nport *nport;
1214         struct fcloop_tport *tport;
1215         struct fcloop_rport *rport;
1216         unsigned long flags;
1217         int ret;
1218
1219         spin_lock_irqsave(&fcloop_lock, flags);
1220
1221         for (;;) {
1222                 nport = list_first_entry_or_null(&fcloop_nports,
1223                                                 typeof(*nport), nport_list);
1224                 if (!nport)
1225                         break;
1226
1227                 tport = __unlink_target_port(nport);
1228                 rport = __unlink_remote_port(nport);
1229
1230                 spin_unlock_irqrestore(&fcloop_lock, flags);
1231
1232                 ret = __wait_targetport_unreg(nport, tport);
1233                 if (ret)
1234                         pr_warn("%s: Failed deleting target port\n", __func__);
1235
1236                 ret = __wait_remoteport_unreg(nport, rport);
1237                 if (ret)
1238                         pr_warn("%s: Failed deleting remote port\n", __func__);
1239
1240                 spin_lock_irqsave(&fcloop_lock, flags);
1241         }
1242
1243         for (;;) {
1244                 lport = list_first_entry_or_null(&fcloop_lports,
1245                                                 typeof(*lport), lport_list);
1246                 if (!lport)
1247                         break;
1248
1249                 __unlink_local_port(lport);
1250
1251                 spin_unlock_irqrestore(&fcloop_lock, flags);
1252
1253                 ret = __wait_localport_unreg(lport);
1254                 if (ret)
1255                         pr_warn("%s: Failed deleting local port\n", __func__);
1256
1257                 spin_lock_irqsave(&fcloop_lock, flags);
1258         }
1259
1260         spin_unlock_irqrestore(&fcloop_lock, flags);
1261
1262         put_device(fcloop_device);
1263
1264         device_destroy(fcloop_class, MKDEV(0, 0));
1265         class_destroy(fcloop_class);
1266 }
1267
1268 module_init(fcloop_init);
1269 module_exit(fcloop_exit);
1270
1271 MODULE_LICENSE("GPL v2");