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