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