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