1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2016 Avago Technologies. All rights reserved.
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>
10 #include "../host/nvme.h"
11 #include "../target/nvmet.h"
12 #include <linux/nvme-fc-driver.h>
13 #include <linux/nvme-fc.h>
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,
26 struct fcloop_ctrl_options {
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 }
46 static int fcloop_verify_addr(substring_t *s)
48 size_t blen = s->to - s->from + 1;
50 if (strnlen(s->from, blen) != NVME_FC_TRADDR_HEXNAMELEN + 2 ||
51 strncmp(s->from, "0x", 2))
58 fcloop_parse_options(struct fcloop_ctrl_options *opts,
61 substring_t args[MAX_OPT_ARGS];
62 char *options, *o, *p;
66 options = o = kstrdup(buf, GFP_KERNEL);
70 while ((p = strsep(&o, ",\n")) != NULL) {
74 token = match_token(p, opt_tokens, args);
78 if (fcloop_verify_addr(args) ||
79 match_u64(args, &token64)) {
81 goto out_free_options;
86 if (fcloop_verify_addr(args) ||
87 match_u64(args, &token64)) {
89 goto out_free_options;
94 if (match_int(args, &token)) {
96 goto out_free_options;
100 case NVMF_OPT_FCADDR:
101 if (match_hex(args, &token)) {
103 goto out_free_options;
105 opts->fcaddr = token;
107 case NVMF_OPT_LPWWNN:
108 if (fcloop_verify_addr(args) ||
109 match_u64(args, &token64)) {
111 goto out_free_options;
113 opts->lpwwnn = token64;
115 case NVMF_OPT_LPWWPN:
116 if (fcloop_verify_addr(args) ||
117 match_u64(args, &token64)) {
119 goto out_free_options;
121 opts->lpwwpn = token64;
124 pr_warn("unknown parameter or missing value '%s'\n", p);
126 goto out_free_options;
137 fcloop_parse_nm_options(struct device *dev, u64 *nname, u64 *pname,
140 substring_t args[MAX_OPT_ARGS];
141 char *options, *o, *p;
148 options = o = kstrdup(buf, GFP_KERNEL);
152 while ((p = strsep(&o, ",\n")) != NULL) {
156 token = match_token(p, opt_tokens, args);
159 if (fcloop_verify_addr(args) ||
160 match_u64(args, &token64)) {
162 goto out_free_options;
167 if (fcloop_verify_addr(args) ||
168 match_u64(args, &token64)) {
170 goto out_free_options;
175 pr_warn("unknown parameter or missing value '%s'\n", p);
177 goto out_free_options;
195 #define LPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN)
197 #define RPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN | \
198 NVMF_OPT_LPWWNN | NVMF_OPT_LPWWPN)
200 #define TGTPORT_OPTS (NVMF_OPT_WWNN | NVMF_OPT_WWPN)
203 static DEFINE_SPINLOCK(fcloop_lock);
204 static LIST_HEAD(fcloop_lports);
205 static LIST_HEAD(fcloop_nports);
207 struct fcloop_lport {
208 struct nvme_fc_local_port *localport;
209 struct list_head lport_list;
210 struct completion unreg_done;
213 struct fcloop_lport_priv {
214 struct fcloop_lport *lport;
217 struct fcloop_rport {
218 struct nvme_fc_remote_port *remoteport;
219 struct nvmet_fc_target_port *targetport;
220 struct fcloop_nport *nport;
221 struct fcloop_lport *lport;
223 struct list_head ls_list;
224 struct work_struct ls_work;
227 struct fcloop_tport {
228 struct nvmet_fc_target_port *targetport;
229 struct nvme_fc_remote_port *remoteport;
230 struct fcloop_nport *nport;
231 struct fcloop_lport *lport;
233 struct list_head ls_list;
234 struct work_struct ls_work;
237 struct fcloop_nport {
238 struct fcloop_rport *rport;
239 struct fcloop_tport *tport;
240 struct fcloop_lport *lport;
241 struct list_head nport_list;
249 struct fcloop_lsreq {
250 struct nvmefc_ls_req *lsreq;
251 struct nvmefc_ls_rsp ls_rsp;
252 int lsdir; /* H2T or T2H */
254 struct list_head ls_list; /* fcloop_rport->ls_list */
258 struct fcloop_tport *tport;
259 struct work_struct work;
266 INI_IO_COMPLETED = 3,
269 struct fcloop_fcpreq {
270 struct fcloop_tport *tport;
271 struct nvmefc_fcp_req *fcpreq;
278 struct work_struct fcp_rcv_work;
279 struct work_struct abort_rcv_work;
280 struct work_struct tio_done_work;
281 struct nvmefc_tgt_fcp_req tgt_fcp_req;
284 struct fcloop_ini_fcpreq {
285 struct nvmefc_fcp_req *fcpreq;
286 struct fcloop_fcpreq *tfcp_req;
290 static inline struct fcloop_lsreq *
291 ls_rsp_to_lsreq(struct nvmefc_ls_rsp *lsrsp)
293 return container_of(lsrsp, struct fcloop_lsreq, ls_rsp);
296 static inline struct fcloop_fcpreq *
297 tgt_fcp_req_to_fcpreq(struct nvmefc_tgt_fcp_req *tgt_fcpreq)
299 return container_of(tgt_fcpreq, struct fcloop_fcpreq, tgt_fcp_req);
304 fcloop_create_queue(struct nvme_fc_local_port *localport,
305 unsigned int qidx, u16 qsize,
313 fcloop_delete_queue(struct nvme_fc_local_port *localport,
314 unsigned int idx, void *handle)
319 fcloop_rport_lsrqst_work(struct work_struct *work)
321 struct fcloop_rport *rport =
322 container_of(work, struct fcloop_rport, ls_work);
323 struct fcloop_lsreq *tls_req;
325 spin_lock(&rport->lock);
327 tls_req = list_first_entry_or_null(&rport->ls_list,
328 struct fcloop_lsreq, ls_list);
332 list_del(&tls_req->ls_list);
333 spin_unlock(&rport->lock);
335 tls_req->lsreq->done(tls_req->lsreq, tls_req->status);
337 * callee may free memory containing tls_req.
338 * do not reference lsreq after this.
341 spin_lock(&rport->lock);
343 spin_unlock(&rport->lock);
347 fcloop_h2t_ls_req(struct nvme_fc_local_port *localport,
348 struct nvme_fc_remote_port *remoteport,
349 struct nvmefc_ls_req *lsreq)
351 struct fcloop_lsreq *tls_req = lsreq->private;
352 struct fcloop_rport *rport = remoteport->private;
355 tls_req->lsreq = lsreq;
356 INIT_LIST_HEAD(&tls_req->ls_list);
358 if (!rport->targetport) {
359 tls_req->status = -ECONNREFUSED;
360 spin_lock(&rport->lock);
361 list_add_tail(&tls_req->ls_list, &rport->ls_list);
362 spin_unlock(&rport->lock);
363 schedule_work(&rport->ls_work);
368 ret = nvmet_fc_rcv_ls_req(rport->targetport, rport,
370 lsreq->rqstaddr, lsreq->rqstlen);
376 fcloop_h2t_xmt_ls_rsp(struct nvmet_fc_target_port *targetport,
377 struct nvmefc_ls_rsp *lsrsp)
379 struct fcloop_lsreq *tls_req = ls_rsp_to_lsreq(lsrsp);
380 struct nvmefc_ls_req *lsreq = tls_req->lsreq;
381 struct fcloop_tport *tport = targetport->private;
382 struct nvme_fc_remote_port *remoteport = tport->remoteport;
383 struct fcloop_rport *rport;
385 memcpy(lsreq->rspaddr, lsrsp->rspbuf,
386 ((lsreq->rsplen < lsrsp->rsplen) ?
387 lsreq->rsplen : lsrsp->rsplen));
392 rport = remoteport->private;
393 spin_lock(&rport->lock);
394 list_add_tail(&tls_req->ls_list, &rport->ls_list);
395 spin_unlock(&rport->lock);
396 schedule_work(&rport->ls_work);
403 fcloop_tport_lsrqst_work(struct work_struct *work)
405 struct fcloop_tport *tport =
406 container_of(work, struct fcloop_tport, ls_work);
407 struct fcloop_lsreq *tls_req;
409 spin_lock(&tport->lock);
411 tls_req = list_first_entry_or_null(&tport->ls_list,
412 struct fcloop_lsreq, ls_list);
416 list_del(&tls_req->ls_list);
417 spin_unlock(&tport->lock);
419 tls_req->lsreq->done(tls_req->lsreq, tls_req->status);
421 * callee may free memory containing tls_req.
422 * do not reference lsreq after this.
425 spin_lock(&tport->lock);
427 spin_unlock(&tport->lock);
431 fcloop_t2h_ls_req(struct nvmet_fc_target_port *targetport, void *hosthandle,
432 struct nvmefc_ls_req *lsreq)
434 struct fcloop_lsreq *tls_req = lsreq->private;
435 struct fcloop_tport *tport = targetport->private;
439 * hosthandle should be the dst.rport value.
440 * hosthandle ignored as fcloop currently is
441 * 1:1 tgtport vs remoteport
443 tls_req->lsreq = lsreq;
444 INIT_LIST_HEAD(&tls_req->ls_list);
446 if (!tport->remoteport) {
447 tls_req->status = -ECONNREFUSED;
448 spin_lock(&tport->lock);
449 list_add_tail(&tls_req->ls_list, &tport->ls_list);
450 spin_unlock(&tport->lock);
451 schedule_work(&tport->ls_work);
456 ret = nvme_fc_rcv_ls_req(tport->remoteport, &tls_req->ls_rsp,
457 lsreq->rqstaddr, lsreq->rqstlen);
463 fcloop_t2h_xmt_ls_rsp(struct nvme_fc_local_port *localport,
464 struct nvme_fc_remote_port *remoteport,
465 struct nvmefc_ls_rsp *lsrsp)
467 struct fcloop_lsreq *tls_req = ls_rsp_to_lsreq(lsrsp);
468 struct nvmefc_ls_req *lsreq = tls_req->lsreq;
469 struct fcloop_rport *rport = remoteport->private;
470 struct nvmet_fc_target_port *targetport = rport->targetport;
471 struct fcloop_tport *tport;
473 memcpy(lsreq->rspaddr, lsrsp->rspbuf,
474 ((lsreq->rsplen < lsrsp->rsplen) ?
475 lsreq->rsplen : lsrsp->rsplen));
479 tport = targetport->private;
480 spin_lock(&tport->lock);
481 list_add_tail(&tport->ls_list, &tls_req->ls_list);
482 spin_unlock(&tport->lock);
483 schedule_work(&tport->ls_work);
490 fcloop_t2h_host_release(void *hosthandle)
492 /* host handle ignored for now */
496 * Simulate reception of RSCN and converting it to a initiator transport
497 * call to rescan a remote port.
500 fcloop_tgt_rscn_work(struct work_struct *work)
502 struct fcloop_rscn *tgt_rscn =
503 container_of(work, struct fcloop_rscn, work);
504 struct fcloop_tport *tport = tgt_rscn->tport;
506 if (tport->remoteport)
507 nvme_fc_rescan_remoteport(tport->remoteport);
512 fcloop_tgt_discovery_evt(struct nvmet_fc_target_port *tgtport)
514 struct fcloop_rscn *tgt_rscn;
516 tgt_rscn = kzalloc(sizeof(*tgt_rscn), GFP_KERNEL);
520 tgt_rscn->tport = tgtport->private;
521 INIT_WORK(&tgt_rscn->work, fcloop_tgt_rscn_work);
523 schedule_work(&tgt_rscn->work);
527 fcloop_tfcp_req_free(struct kref *ref)
529 struct fcloop_fcpreq *tfcp_req =
530 container_of(ref, struct fcloop_fcpreq, ref);
536 fcloop_tfcp_req_put(struct fcloop_fcpreq *tfcp_req)
538 kref_put(&tfcp_req->ref, fcloop_tfcp_req_free);
542 fcloop_tfcp_req_get(struct fcloop_fcpreq *tfcp_req)
544 return kref_get_unless_zero(&tfcp_req->ref);
548 fcloop_call_host_done(struct nvmefc_fcp_req *fcpreq,
549 struct fcloop_fcpreq *tfcp_req, int status)
551 struct fcloop_ini_fcpreq *inireq = NULL;
554 inireq = fcpreq->private;
555 spin_lock(&inireq->inilock);
556 inireq->tfcp_req = NULL;
557 spin_unlock(&inireq->inilock);
559 fcpreq->status = status;
560 fcpreq->done(fcpreq);
563 /* release original io reference on tgt struct */
564 fcloop_tfcp_req_put(tfcp_req);
568 fcloop_fcp_recv_work(struct work_struct *work)
570 struct fcloop_fcpreq *tfcp_req =
571 container_of(work, struct fcloop_fcpreq, fcp_rcv_work);
572 struct nvmefc_fcp_req *fcpreq = tfcp_req->fcpreq;
575 bool aborted = false;
577 spin_lock_irqsave(&tfcp_req->reqlock, flags);
578 switch (tfcp_req->inistate) {
580 tfcp_req->inistate = INI_IO_ACTIVE;
586 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
590 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
592 if (unlikely(aborted))
595 ret = nvmet_fc_rcv_fcp_req(tfcp_req->tport->targetport,
596 &tfcp_req->tgt_fcp_req,
597 fcpreq->cmdaddr, fcpreq->cmdlen);
599 fcloop_call_host_done(fcpreq, tfcp_req, ret);
605 fcloop_fcp_abort_recv_work(struct work_struct *work)
607 struct fcloop_fcpreq *tfcp_req =
608 container_of(work, struct fcloop_fcpreq, abort_rcv_work);
609 struct nvmefc_fcp_req *fcpreq;
610 bool completed = false;
613 spin_lock_irqsave(&tfcp_req->reqlock, flags);
614 fcpreq = tfcp_req->fcpreq;
615 switch (tfcp_req->inistate) {
618 case INI_IO_COMPLETED:
622 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
626 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
628 if (unlikely(completed)) {
629 /* remove reference taken in original abort downcall */
630 fcloop_tfcp_req_put(tfcp_req);
634 if (tfcp_req->tport->targetport)
635 nvmet_fc_rcv_fcp_abort(tfcp_req->tport->targetport,
636 &tfcp_req->tgt_fcp_req);
638 spin_lock_irqsave(&tfcp_req->reqlock, flags);
639 tfcp_req->fcpreq = NULL;
640 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
642 fcloop_call_host_done(fcpreq, tfcp_req, -ECANCELED);
643 /* call_host_done releases reference for abort downcall */
647 * FCP IO operation done by target completion.
648 * call back up initiator "done" flows.
651 fcloop_tgt_fcprqst_done_work(struct work_struct *work)
653 struct fcloop_fcpreq *tfcp_req =
654 container_of(work, struct fcloop_fcpreq, tio_done_work);
655 struct nvmefc_fcp_req *fcpreq;
658 spin_lock_irqsave(&tfcp_req->reqlock, flags);
659 fcpreq = tfcp_req->fcpreq;
660 tfcp_req->inistate = INI_IO_COMPLETED;
661 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
663 fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status);
668 fcloop_fcp_req(struct nvme_fc_local_port *localport,
669 struct nvme_fc_remote_port *remoteport,
670 void *hw_queue_handle,
671 struct nvmefc_fcp_req *fcpreq)
673 struct fcloop_rport *rport = remoteport->private;
674 struct fcloop_ini_fcpreq *inireq = fcpreq->private;
675 struct fcloop_fcpreq *tfcp_req;
677 if (!rport->targetport)
678 return -ECONNREFUSED;
680 tfcp_req = kzalloc(sizeof(*tfcp_req), GFP_ATOMIC);
684 inireq->fcpreq = fcpreq;
685 inireq->tfcp_req = tfcp_req;
686 spin_lock_init(&inireq->inilock);
688 tfcp_req->fcpreq = fcpreq;
689 tfcp_req->tport = rport->targetport->private;
690 tfcp_req->inistate = INI_IO_START;
691 spin_lock_init(&tfcp_req->reqlock);
692 INIT_WORK(&tfcp_req->fcp_rcv_work, fcloop_fcp_recv_work);
693 INIT_WORK(&tfcp_req->abort_rcv_work, fcloop_fcp_abort_recv_work);
694 INIT_WORK(&tfcp_req->tio_done_work, fcloop_tgt_fcprqst_done_work);
695 kref_init(&tfcp_req->ref);
697 schedule_work(&tfcp_req->fcp_rcv_work);
703 fcloop_fcp_copy_data(u8 op, struct scatterlist *data_sg,
704 struct scatterlist *io_sg, u32 offset, u32 length)
707 u32 data_len, io_len, tlen;
709 io_p = sg_virt(io_sg);
710 io_len = io_sg->length;
713 tlen = min_t(u32, offset, io_len);
717 io_sg = sg_next(io_sg);
718 io_p = sg_virt(io_sg);
719 io_len = io_sg->length;
724 data_p = sg_virt(data_sg);
725 data_len = data_sg->length;
728 tlen = min_t(u32, io_len, data_len);
729 tlen = min_t(u32, tlen, length);
731 if (op == NVMET_FCOP_WRITEDATA)
732 memcpy(data_p, io_p, tlen);
734 memcpy(io_p, data_p, tlen);
739 if ((!io_len) && (length)) {
740 io_sg = sg_next(io_sg);
741 io_p = sg_virt(io_sg);
742 io_len = io_sg->length;
747 if ((!data_len) && (length)) {
748 data_sg = sg_next(data_sg);
749 data_p = sg_virt(data_sg);
750 data_len = data_sg->length;
757 fcloop_fcp_op(struct nvmet_fc_target_port *tgtport,
758 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
760 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
761 struct nvmefc_fcp_req *fcpreq;
762 u32 rsplen = 0, xfrlen = 0;
763 int fcp_err = 0, active, aborted;
764 u8 op = tgt_fcpreq->op;
767 spin_lock_irqsave(&tfcp_req->reqlock, flags);
768 fcpreq = tfcp_req->fcpreq;
769 active = tfcp_req->active;
770 aborted = tfcp_req->aborted;
771 tfcp_req->active = true;
772 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
774 if (unlikely(active))
775 /* illegal - call while i/o active */
778 if (unlikely(aborted)) {
779 /* target transport has aborted i/o prior */
780 spin_lock_irqsave(&tfcp_req->reqlock, flags);
781 tfcp_req->active = false;
782 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
783 tgt_fcpreq->transferred_length = 0;
784 tgt_fcpreq->fcp_error = -ECANCELED;
785 tgt_fcpreq->done(tgt_fcpreq);
790 * if fcpreq is NULL, the I/O has been aborted (from
791 * initiator side). For the target side, act as if all is well
792 * but don't actually move data.
796 case NVMET_FCOP_WRITEDATA:
797 xfrlen = tgt_fcpreq->transfer_length;
799 fcloop_fcp_copy_data(op, tgt_fcpreq->sg,
800 fcpreq->first_sgl, tgt_fcpreq->offset,
802 fcpreq->transferred_length += xfrlen;
806 case NVMET_FCOP_READDATA:
807 case NVMET_FCOP_READDATA_RSP:
808 xfrlen = tgt_fcpreq->transfer_length;
810 fcloop_fcp_copy_data(op, tgt_fcpreq->sg,
811 fcpreq->first_sgl, tgt_fcpreq->offset,
813 fcpreq->transferred_length += xfrlen;
815 if (op == NVMET_FCOP_READDATA)
818 /* Fall-Thru to RSP handling */
823 rsplen = ((fcpreq->rsplen < tgt_fcpreq->rsplen) ?
824 fcpreq->rsplen : tgt_fcpreq->rsplen);
825 memcpy(fcpreq->rspaddr, tgt_fcpreq->rspaddr, rsplen);
826 if (rsplen < tgt_fcpreq->rsplen)
828 fcpreq->rcv_rsplen = rsplen;
831 tfcp_req->status = 0;
839 spin_lock_irqsave(&tfcp_req->reqlock, flags);
840 tfcp_req->active = false;
841 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
843 tgt_fcpreq->transferred_length = xfrlen;
844 tgt_fcpreq->fcp_error = fcp_err;
845 tgt_fcpreq->done(tgt_fcpreq);
851 fcloop_tgt_fcp_abort(struct nvmet_fc_target_port *tgtport,
852 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
854 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
858 * mark aborted only in case there were 2 threads in transport
859 * (one doing io, other doing abort) and only kills ops posted
860 * after the abort request
862 spin_lock_irqsave(&tfcp_req->reqlock, flags);
863 tfcp_req->aborted = true;
864 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
866 tfcp_req->status = NVME_SC_INTERNAL;
869 * nothing more to do. If io wasn't active, the transport should
870 * immediately call the req_release. If it was active, the op
871 * will complete, and the lldd should call req_release.
876 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport,
877 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
879 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
881 schedule_work(&tfcp_req->tio_done_work);
885 fcloop_h2t_ls_abort(struct nvme_fc_local_port *localport,
886 struct nvme_fc_remote_port *remoteport,
887 struct nvmefc_ls_req *lsreq)
892 fcloop_t2h_ls_abort(struct nvmet_fc_target_port *targetport,
893 void *hosthandle, struct nvmefc_ls_req *lsreq)
898 fcloop_fcp_abort(struct nvme_fc_local_port *localport,
899 struct nvme_fc_remote_port *remoteport,
900 void *hw_queue_handle,
901 struct nvmefc_fcp_req *fcpreq)
903 struct fcloop_ini_fcpreq *inireq = fcpreq->private;
904 struct fcloop_fcpreq *tfcp_req;
908 spin_lock(&inireq->inilock);
909 tfcp_req = inireq->tfcp_req;
911 fcloop_tfcp_req_get(tfcp_req);
912 spin_unlock(&inireq->inilock);
915 /* abort has already been called */
918 /* break initiator/target relationship for io */
919 spin_lock_irqsave(&tfcp_req->reqlock, flags);
920 switch (tfcp_req->inistate) {
923 tfcp_req->inistate = INI_IO_ABORTED;
925 case INI_IO_COMPLETED:
929 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
933 spin_unlock_irqrestore(&tfcp_req->reqlock, flags);
936 /* leave the reference while the work item is scheduled */
937 WARN_ON(!schedule_work(&tfcp_req->abort_rcv_work));
940 * as the io has already had the done callback made,
941 * nothing more to do. So release the reference taken above
943 fcloop_tfcp_req_put(tfcp_req);
948 fcloop_nport_free(struct kref *ref)
950 struct fcloop_nport *nport =
951 container_of(ref, struct fcloop_nport, ref);
954 spin_lock_irqsave(&fcloop_lock, flags);
955 list_del(&nport->nport_list);
956 spin_unlock_irqrestore(&fcloop_lock, flags);
962 fcloop_nport_put(struct fcloop_nport *nport)
964 kref_put(&nport->ref, fcloop_nport_free);
968 fcloop_nport_get(struct fcloop_nport *nport)
970 return kref_get_unless_zero(&nport->ref);
974 fcloop_localport_delete(struct nvme_fc_local_port *localport)
976 struct fcloop_lport_priv *lport_priv = localport->private;
977 struct fcloop_lport *lport = lport_priv->lport;
979 /* release any threads waiting for the unreg to complete */
980 complete(&lport->unreg_done);
984 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport)
986 struct fcloop_rport *rport = remoteport->private;
988 flush_work(&rport->ls_work);
989 fcloop_nport_put(rport->nport);
993 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport)
995 struct fcloop_tport *tport = targetport->private;
997 flush_work(&tport->ls_work);
998 fcloop_nport_put(tport->nport);
1001 #define FCLOOP_HW_QUEUES 4
1002 #define FCLOOP_SGL_SEGS 256
1003 #define FCLOOP_DMABOUND_4G 0xFFFFFFFF
1005 static struct nvme_fc_port_template fctemplate = {
1006 .localport_delete = fcloop_localport_delete,
1007 .remoteport_delete = fcloop_remoteport_delete,
1008 .create_queue = fcloop_create_queue,
1009 .delete_queue = fcloop_delete_queue,
1010 .ls_req = fcloop_h2t_ls_req,
1011 .fcp_io = fcloop_fcp_req,
1012 .ls_abort = fcloop_h2t_ls_abort,
1013 .fcp_abort = fcloop_fcp_abort,
1014 .xmt_ls_rsp = fcloop_t2h_xmt_ls_rsp,
1015 .max_hw_queues = FCLOOP_HW_QUEUES,
1016 .max_sgl_segments = FCLOOP_SGL_SEGS,
1017 .max_dif_sgl_segments = FCLOOP_SGL_SEGS,
1018 .dma_boundary = FCLOOP_DMABOUND_4G,
1019 /* sizes of additional private data for data structures */
1020 .local_priv_sz = sizeof(struct fcloop_lport_priv),
1021 .remote_priv_sz = sizeof(struct fcloop_rport),
1022 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq),
1023 .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq),
1026 static struct nvmet_fc_target_template tgttemplate = {
1027 .targetport_delete = fcloop_targetport_delete,
1028 .xmt_ls_rsp = fcloop_h2t_xmt_ls_rsp,
1029 .fcp_op = fcloop_fcp_op,
1030 .fcp_abort = fcloop_tgt_fcp_abort,
1031 .fcp_req_release = fcloop_fcp_req_release,
1032 .discovery_event = fcloop_tgt_discovery_evt,
1033 .ls_req = fcloop_t2h_ls_req,
1034 .ls_abort = fcloop_t2h_ls_abort,
1035 .host_release = fcloop_t2h_host_release,
1036 .max_hw_queues = FCLOOP_HW_QUEUES,
1037 .max_sgl_segments = FCLOOP_SGL_SEGS,
1038 .max_dif_sgl_segments = FCLOOP_SGL_SEGS,
1039 .dma_boundary = FCLOOP_DMABOUND_4G,
1040 /* optional features */
1041 .target_features = 0,
1042 /* sizes of additional private data for data structures */
1043 .target_priv_sz = sizeof(struct fcloop_tport),
1044 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq),
1048 fcloop_create_local_port(struct device *dev, struct device_attribute *attr,
1049 const char *buf, size_t count)
1051 struct nvme_fc_port_info pinfo;
1052 struct fcloop_ctrl_options *opts;
1053 struct nvme_fc_local_port *localport;
1054 struct fcloop_lport *lport;
1055 struct fcloop_lport_priv *lport_priv;
1056 unsigned long flags;
1059 lport = kzalloc(sizeof(*lport), GFP_KERNEL);
1063 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1065 goto out_free_lport;
1067 ret = fcloop_parse_options(opts, buf);
1071 /* everything there ? */
1072 if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) {
1077 memset(&pinfo, 0, sizeof(pinfo));
1078 pinfo.node_name = opts->wwnn;
1079 pinfo.port_name = opts->wwpn;
1080 pinfo.port_role = opts->roles;
1081 pinfo.port_id = opts->fcaddr;
1083 ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport);
1086 lport_priv = localport->private;
1087 lport_priv->lport = lport;
1089 lport->localport = localport;
1090 INIT_LIST_HEAD(&lport->lport_list);
1092 spin_lock_irqsave(&fcloop_lock, flags);
1093 list_add_tail(&lport->lport_list, &fcloop_lports);
1094 spin_unlock_irqrestore(&fcloop_lock, flags);
1100 /* free only if we're going to fail */
1104 return ret ? ret : count;
1109 __unlink_local_port(struct fcloop_lport *lport)
1111 list_del(&lport->lport_list);
1115 __wait_localport_unreg(struct fcloop_lport *lport)
1119 init_completion(&lport->unreg_done);
1121 ret = nvme_fc_unregister_localport(lport->localport);
1123 wait_for_completion(&lport->unreg_done);
1132 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr,
1133 const char *buf, size_t count)
1135 struct fcloop_lport *tlport, *lport = NULL;
1136 u64 nodename, portname;
1137 unsigned long flags;
1140 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1144 spin_lock_irqsave(&fcloop_lock, flags);
1146 list_for_each_entry(tlport, &fcloop_lports, lport_list) {
1147 if (tlport->localport->node_name == nodename &&
1148 tlport->localport->port_name == portname) {
1150 __unlink_local_port(lport);
1154 spin_unlock_irqrestore(&fcloop_lock, flags);
1159 ret = __wait_localport_unreg(lport);
1161 return ret ? ret : count;
1164 static struct fcloop_nport *
1165 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport)
1167 struct fcloop_nport *newnport, *nport = NULL;
1168 struct fcloop_lport *tmplport, *lport = NULL;
1169 struct fcloop_ctrl_options *opts;
1170 unsigned long flags;
1171 u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS;
1174 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1178 ret = fcloop_parse_options(opts, buf);
1182 /* everything there ? */
1183 if ((opts->mask & opts_mask) != opts_mask) {
1188 newnport = kzalloc(sizeof(*newnport), GFP_KERNEL);
1192 INIT_LIST_HEAD(&newnport->nport_list);
1193 newnport->node_name = opts->wwnn;
1194 newnport->port_name = opts->wwpn;
1195 if (opts->mask & NVMF_OPT_ROLES)
1196 newnport->port_role = opts->roles;
1197 if (opts->mask & NVMF_OPT_FCADDR)
1198 newnport->port_id = opts->fcaddr;
1199 kref_init(&newnport->ref);
1201 spin_lock_irqsave(&fcloop_lock, flags);
1203 list_for_each_entry(tmplport, &fcloop_lports, lport_list) {
1204 if (tmplport->localport->node_name == opts->wwnn &&
1205 tmplport->localport->port_name == opts->wwpn)
1206 goto out_invalid_opts;
1208 if (tmplport->localport->node_name == opts->lpwwnn &&
1209 tmplport->localport->port_name == opts->lpwwpn)
1215 goto out_invalid_opts;
1216 newnport->lport = lport;
1219 list_for_each_entry(nport, &fcloop_nports, nport_list) {
1220 if (nport->node_name == opts->wwnn &&
1221 nport->port_name == opts->wwpn) {
1222 if ((remoteport && nport->rport) ||
1223 (!remoteport && nport->tport)) {
1225 goto out_invalid_opts;
1228 fcloop_nport_get(nport);
1230 spin_unlock_irqrestore(&fcloop_lock, flags);
1233 nport->lport = lport;
1234 if (opts->mask & NVMF_OPT_ROLES)
1235 nport->port_role = opts->roles;
1236 if (opts->mask & NVMF_OPT_FCADDR)
1237 nport->port_id = opts->fcaddr;
1238 goto out_free_newnport;
1242 list_add_tail(&newnport->nport_list, &fcloop_nports);
1244 spin_unlock_irqrestore(&fcloop_lock, flags);
1250 spin_unlock_irqrestore(&fcloop_lock, flags);
1259 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr,
1260 const char *buf, size_t count)
1262 struct nvme_fc_remote_port *remoteport;
1263 struct fcloop_nport *nport;
1264 struct fcloop_rport *rport;
1265 struct nvme_fc_port_info pinfo;
1268 nport = fcloop_alloc_nport(buf, count, true);
1272 memset(&pinfo, 0, sizeof(pinfo));
1273 pinfo.node_name = nport->node_name;
1274 pinfo.port_name = nport->port_name;
1275 pinfo.port_role = nport->port_role;
1276 pinfo.port_id = nport->port_id;
1278 ret = nvme_fc_register_remoteport(nport->lport->localport,
1279 &pinfo, &remoteport);
1280 if (ret || !remoteport) {
1281 fcloop_nport_put(nport);
1286 rport = remoteport->private;
1287 rport->remoteport = remoteport;
1288 rport->targetport = (nport->tport) ? nport->tport->targetport : NULL;
1290 nport->tport->remoteport = remoteport;
1291 nport->tport->lport = nport->lport;
1293 rport->nport = nport;
1294 rport->lport = nport->lport;
1295 nport->rport = rport;
1296 spin_lock_init(&rport->lock);
1297 INIT_WORK(&rport->ls_work, fcloop_rport_lsrqst_work);
1298 INIT_LIST_HEAD(&rport->ls_list);
1304 static struct fcloop_rport *
1305 __unlink_remote_port(struct fcloop_nport *nport)
1307 struct fcloop_rport *rport = nport->rport;
1309 if (rport && nport->tport)
1310 nport->tport->remoteport = NULL;
1311 nport->rport = NULL;
1317 __remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport)
1322 return nvme_fc_unregister_remoteport(rport->remoteport);
1326 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr,
1327 const char *buf, size_t count)
1329 struct fcloop_nport *nport = NULL, *tmpport;
1330 static struct fcloop_rport *rport;
1331 u64 nodename, portname;
1332 unsigned long flags;
1335 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1339 spin_lock_irqsave(&fcloop_lock, flags);
1341 list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1342 if (tmpport->node_name == nodename &&
1343 tmpport->port_name == portname && tmpport->rport) {
1345 rport = __unlink_remote_port(nport);
1350 spin_unlock_irqrestore(&fcloop_lock, flags);
1355 ret = __remoteport_unreg(nport, rport);
1357 return ret ? ret : count;
1361 fcloop_create_target_port(struct device *dev, struct device_attribute *attr,
1362 const char *buf, size_t count)
1364 struct nvmet_fc_target_port *targetport;
1365 struct fcloop_nport *nport;
1366 struct fcloop_tport *tport;
1367 struct nvmet_fc_port_info tinfo;
1370 nport = fcloop_alloc_nport(buf, count, false);
1374 tinfo.node_name = nport->node_name;
1375 tinfo.port_name = nport->port_name;
1376 tinfo.port_id = nport->port_id;
1378 ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL,
1381 fcloop_nport_put(nport);
1386 tport = targetport->private;
1387 tport->targetport = targetport;
1388 tport->remoteport = (nport->rport) ? nport->rport->remoteport : NULL;
1390 nport->rport->targetport = targetport;
1391 tport->nport = nport;
1392 tport->lport = nport->lport;
1393 nport->tport = tport;
1394 spin_lock_init(&tport->lock);
1395 INIT_WORK(&tport->ls_work, fcloop_tport_lsrqst_work);
1396 INIT_LIST_HEAD(&tport->ls_list);
1402 static struct fcloop_tport *
1403 __unlink_target_port(struct fcloop_nport *nport)
1405 struct fcloop_tport *tport = nport->tport;
1407 if (tport && nport->rport)
1408 nport->rport->targetport = NULL;
1409 nport->tport = NULL;
1415 __targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport)
1420 return nvmet_fc_unregister_targetport(tport->targetport);
1424 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr,
1425 const char *buf, size_t count)
1427 struct fcloop_nport *nport = NULL, *tmpport;
1428 struct fcloop_tport *tport = NULL;
1429 u64 nodename, portname;
1430 unsigned long flags;
1433 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1437 spin_lock_irqsave(&fcloop_lock, flags);
1439 list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1440 if (tmpport->node_name == nodename &&
1441 tmpport->port_name == portname && tmpport->tport) {
1443 tport = __unlink_target_port(nport);
1448 spin_unlock_irqrestore(&fcloop_lock, flags);
1453 ret = __targetport_unreg(nport, tport);
1455 return ret ? ret : count;
1459 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port);
1460 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port);
1461 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port);
1462 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port);
1463 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port);
1464 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port);
1466 static struct attribute *fcloop_dev_attrs[] = {
1467 &dev_attr_add_local_port.attr,
1468 &dev_attr_del_local_port.attr,
1469 &dev_attr_add_remote_port.attr,
1470 &dev_attr_del_remote_port.attr,
1471 &dev_attr_add_target_port.attr,
1472 &dev_attr_del_target_port.attr,
1476 static struct attribute_group fclopp_dev_attrs_group = {
1477 .attrs = fcloop_dev_attrs,
1480 static const struct attribute_group *fcloop_dev_attr_groups[] = {
1481 &fclopp_dev_attrs_group,
1485 static struct class *fcloop_class;
1486 static struct device *fcloop_device;
1489 static int __init fcloop_init(void)
1493 fcloop_class = class_create(THIS_MODULE, "fcloop");
1494 if (IS_ERR(fcloop_class)) {
1495 pr_err("couldn't register class fcloop\n");
1496 ret = PTR_ERR(fcloop_class);
1500 fcloop_device = device_create_with_groups(
1501 fcloop_class, NULL, MKDEV(0, 0), NULL,
1502 fcloop_dev_attr_groups, "ctl");
1503 if (IS_ERR(fcloop_device)) {
1504 pr_err("couldn't create ctl device!\n");
1505 ret = PTR_ERR(fcloop_device);
1506 goto out_destroy_class;
1509 get_device(fcloop_device);
1514 class_destroy(fcloop_class);
1518 static void __exit fcloop_exit(void)
1520 struct fcloop_lport *lport;
1521 struct fcloop_nport *nport;
1522 struct fcloop_tport *tport;
1523 struct fcloop_rport *rport;
1524 unsigned long flags;
1527 spin_lock_irqsave(&fcloop_lock, flags);
1530 nport = list_first_entry_or_null(&fcloop_nports,
1531 typeof(*nport), nport_list);
1535 tport = __unlink_target_port(nport);
1536 rport = __unlink_remote_port(nport);
1538 spin_unlock_irqrestore(&fcloop_lock, flags);
1540 ret = __targetport_unreg(nport, tport);
1542 pr_warn("%s: Failed deleting target port\n", __func__);
1544 ret = __remoteport_unreg(nport, rport);
1546 pr_warn("%s: Failed deleting remote port\n", __func__);
1548 spin_lock_irqsave(&fcloop_lock, flags);
1552 lport = list_first_entry_or_null(&fcloop_lports,
1553 typeof(*lport), lport_list);
1557 __unlink_local_port(lport);
1559 spin_unlock_irqrestore(&fcloop_lock, flags);
1561 ret = __wait_localport_unreg(lport);
1563 pr_warn("%s: Failed deleting local port\n", __func__);
1565 spin_lock_irqsave(&fcloop_lock, flags);
1568 spin_unlock_irqrestore(&fcloop_lock, flags);
1570 put_device(fcloop_device);
1572 device_destroy(fcloop_class, MKDEV(0, 0));
1573 class_destroy(fcloop_class);
1576 module_init(fcloop_init);
1577 module_exit(fcloop_exit);
1579 MODULE_LICENSE("GPL v2");