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

source code of linux/drivers/nvme/target/fcloop.c