drivers/nvme/target/fcloop.c

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