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