?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / nvme / target / fcloop.c
blob68213f0a052bbeb977a3df81785f86f35eed0056
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 fcloop_verify_addr(substring_t *s)
47 {
48 size_t blen = s->to - s->from + 1;
49
50 if (strnlen(s->from, blen) != NVME_FC_TRADDR_HEXNAMELEN + 2 ||
51 strncmp(s->from, "0x", 2))
52 return -EINVAL;
53
54 return 0;
55 }
56
57 static int
58 fcloop_parse_options(struct fcloop_ctrl_options *opts,
59 const char *buf)
60 {
61 substring_t args[MAX_OPT_ARGS];
62 char *options, *o, *p;
63 int token, ret = 0;
64 u64 token64;
65
66 options = o = kstrdup(buf, GFP_KERNEL);
67 if (!options)
68 return -ENOMEM;
69
70 while ((p = strsep(&o, ",\n")) != NULL) {
71 if (!*p)
72 continue;
73
74 token = match_token(p, opt_tokens, args);
75 opts->mask |= token;
76 switch (token) {
77 case NVMF_OPT_WWNN:
78 if (fcloop_verify_addr(args) ||
79 match_u64(args, &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(args) ||
87 match_u64(args, &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, &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, &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(args) ||
109 match_u64(args, &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(args) ||
117 match_u64(args, &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
130 out_free_options:
131 kfree(options);
132 return ret;
133 }
134
135
136 static int
137 fcloop_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(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, opt_tokens, args);
157 switch (token) {
158 case NVMF_OPT_WWNN:
159 if (fcloop_verify_addr(args) ||
160 match_u64(args, &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(args) ||
168 match_u64(args, &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
181 out_free_options:
182 kfree(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
203 static DEFINE_SPINLOCK(fcloop_lock);
204 static LIST_HEAD(fcloop_lports);
205 static LIST_HEAD(fcloop_nports);
206
207 struct fcloop_lport {
208 struct nvme_fc_local_port *localport;
209 struct list_head lport_list;
210 struct completion unreg_done;
211 };
212
213 struct fcloop_lport_priv {
214 struct fcloop_lport *lport;
215 };
216
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;
222 spinlock_t lock;
223 struct list_head ls_list;
224 struct work_struct ls_work;
225 };
226
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;
232 spinlock_t lock;
233 struct list_head ls_list;
234 struct work_struct ls_work;
235 };
236
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;
242 struct kref ref;
243 u64 node_name;
244 u64 port_name;
245 u32 port_role;
246 u32 port_id;
247 };
248
249 struct 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
257 struct fcloop_rscn {
258 struct fcloop_tport *tport;
259 struct work_struct work;
260 };
261
262 enum {
263 INI_IO_START = 0,
264 INI_IO_ACTIVE = 1,
265 INI_IO_ABORTED = 2,
266 INI_IO_COMPLETED = 3,
267 };
268
269 struct 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
284 struct fcloop_ini_fcpreq {
285 struct nvmefc_fcp_req *fcpreq;
286 struct fcloop_fcpreq *tfcp_req;
287 spinlock_t inilock;
288 };
289
290 static inline struct fcloop_lsreq *
291 ls_rsp_to_lsreq(struct nvmefc_ls_rsp *lsrsp)
292 {
293 return container_of(lsrsp, struct fcloop_lsreq, ls_rsp);
294 }
295
296 static inline struct fcloop_fcpreq *
297 tgt_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
303 static int
304 fcloop_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
312 static void
313 fcloop_delete_queue(struct nvme_fc_local_port *localport,
314 unsigned int idx, void *handle)
315 {
316 }
317
318 static void
319 fcloop_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(&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(&tls_req->ls_list);
333 spin_unlock(&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(&rport->lock);
342 }
343 spin_unlock(&rport->lock);
344 }
345
346 static int
347 fcloop_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(&tls_req->ls_list);
357
358 if (!rport->targetport) {
359 tls_req->status = -ECONNREFUSED;
360 spin_lock(&rport->lock);
361 list_add_tail(&rport->ls_list, &tls_req->ls_list);
362 spin_unlock(&rport->lock);
363 schedule_work(&rport->ls_work);
364 return ret;
365 }
366
367 tls_req->status = 0;
368 ret = nvmet_fc_rcv_ls_req(rport->targetport, rport,
369 &tls_req->ls_rsp,
370 lsreq->rqstaddr, lsreq->rqstlen);
371
372 return ret;
373 }
374
375 static int
376 fcloop_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(&rport->lock);
394 list_add_tail(&rport->ls_list, &tls_req->ls_list);
395 spin_unlock(&rport->lock);
396 schedule_work(&rport->ls_work);
397 }
398
399 return 0;
400 }
401
402 static void
403 fcloop_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(&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(&tls_req->ls_list);
417 spin_unlock(&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(&tport->lock);
426 }
427 spin_unlock(&tport->lock);
428 }
429
430 static int
431 fcloop_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(&tls_req->ls_list);
445
446 if (!tport->remoteport) {
447 tls_req->status = -ECONNREFUSED;
448 spin_lock(&tport->lock);
449 list_add_tail(&tport->ls_list, &tls_req->ls_list);
450 spin_unlock(&tport->lock);
451 schedule_work(&tport->ls_work);
452 return ret;
453 }
454
455 tls_req->status = 0;
456 ret = nvme_fc_rcv_ls_req(tport->remoteport, &tls_req->ls_rsp,
457 lsreq->rqstaddr, lsreq->rqstlen);
458
459 return ret;
460 }
461
462 static int
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)
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(&tport->lock);
481 list_add_tail(&tport->ls_list, &tls_req->ls_list);
482 spin_unlock(&tport->lock);
483 schedule_work(&tport->ls_work);
484 }
485
486 return 0;
487 }
488
489 static void
490 fcloop_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 */
499 static void
500 fcloop_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(tport->remoteport);
508 kfree(tgt_rscn);
509 }
510
511 static void
512 fcloop_tgt_discovery_evt(struct nvmet_fc_target_port *tgtport)
513 {
514 struct fcloop_rscn *tgt_rscn;
515
516 tgt_rscn = kzalloc(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 schedule_work(&tgt_rscn->work);
524 }
525
526 static void
527 fcloop_tfcp_req_free(struct kref *ref)
528 {
529 struct fcloop_fcpreq *tfcp_req =
530 container_of(ref, struct fcloop_fcpreq, ref);
531
532 kfree(tfcp_req);
533 }
534
535 static void
536 fcloop_tfcp_req_put(struct fcloop_fcpreq *tfcp_req)
537 {
538 kref_put(&tfcp_req->ref, fcloop_tfcp_req_free);
539 }
540
541 static int
542 fcloop_tfcp_req_get(struct fcloop_fcpreq *tfcp_req)
543 {
544 return kref_get_unless_zero(&tfcp_req->ref);
545 }
546
547 static void
548 fcloop_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(&inireq->inilock);
556 inireq->tfcp_req = NULL;
557 spin_unlock(&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
567 static bool drop_fabric_opcode;
568 #define DROP_OPCODE_MASK 0x00FF
569 /* fabrics opcode will have a bit set above 1st byte */
570 static int drop_opcode = -1;
571 static int drop_instance;
572 static int drop_amount;
573 static 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 */
581 static 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
611 static void
612 fcloop_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 int ret = 0;
618 bool aborted = false;
619
620 spin_lock_irq(&tfcp_req->reqlock);
621 switch (tfcp_req->inistate) {
622 case INI_IO_START:
623 tfcp_req->inistate = INI_IO_ACTIVE;
624 break;
625 case INI_IO_ABORTED:
626 aborted = true;
627 break;
628 default:
629 spin_unlock_irq(&tfcp_req->reqlock);
630 WARN_ON(1);
631 return;
632 }
633 spin_unlock_irq(&tfcp_req->reqlock);
634
635 if (unlikely(aborted))
636 ret = -ECANCELED;
637 else {
638 if (likely(!check_for_drop(tfcp_req)))
639 ret = nvmet_fc_rcv_fcp_req(tfcp_req->tport->targetport,
640 &tfcp_req->tgt_fcp_req,
641 fcpreq->cmdaddr, fcpreq->cmdlen);
642 else
643 pr_info("%s: dropped command ********\n", __func__);
644 }
645 if (ret)
646 fcloop_call_host_done(fcpreq, tfcp_req, ret);
647
648 return;
649 }
650
651 static void
652 fcloop_fcp_abort_recv_work(struct work_struct *work)
653 {
654 struct fcloop_fcpreq *tfcp_req =
655 container_of(work, struct fcloop_fcpreq, abort_rcv_work);
656 struct nvmefc_fcp_req *fcpreq;
657 bool completed = false;
658
659 spin_lock_irq(&tfcp_req->reqlock);
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_irq(&tfcp_req->reqlock);
669 WARN_ON(1);
670 return;
671 }
672 spin_unlock_irq(&tfcp_req->reqlock);
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(tfcp_req->tport->targetport,
682 &tfcp_req->tgt_fcp_req);
683
684 spin_lock_irq(&tfcp_req->reqlock);
685 tfcp_req->fcpreq = NULL;
686 spin_unlock_irq(&tfcp_req->reqlock);
687
688 fcloop_call_host_done(fcpreq, tfcp_req, -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 */
696 static void
697 fcloop_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
703 spin_lock_irq(&tfcp_req->reqlock);
704 fcpreq = tfcp_req->fcpreq;
705 tfcp_req->inistate = INI_IO_COMPLETED;
706 spin_unlock_irq(&tfcp_req->reqlock);
707
708 fcloop_call_host_done(fcpreq, tfcp_req, tfcp_req->status);
709 }
710
711
712 static int
713 fcloop_fcp_req(struct nvme_fc_local_port *localport,
714 struct nvme_fc_remote_port *remoteport,
715 void *hw_queue_handle,
716 struct nvmefc_fcp_req *fcpreq)
717 {
718 struct fcloop_rport *rport = remoteport->private;
719 struct fcloop_ini_fcpreq *inireq = fcpreq->private;
720 struct fcloop_fcpreq *tfcp_req;
721
722 if (!rport->targetport)
723 return -ECONNREFUSED;
724
725 tfcp_req = kzalloc(sizeof(*tfcp_req), GFP_ATOMIC);
726 if (!tfcp_req)
727 return -ENOMEM;
728
729 inireq->fcpreq = fcpreq;
730 inireq->tfcp_req = tfcp_req;
731 spin_lock_init(&inireq->inilock);
732
733 tfcp_req->fcpreq = fcpreq;
734 tfcp_req->tport = rport->targetport->private;
735 tfcp_req->inistate = INI_IO_START;
736 spin_lock_init(&tfcp_req->reqlock);
737 INIT_WORK(&tfcp_req->fcp_rcv_work, fcloop_fcp_recv_work);
738 INIT_WORK(&tfcp_req->abort_rcv_work, fcloop_fcp_abort_recv_work);
739 INIT_WORK(&tfcp_req->tio_done_work, fcloop_tgt_fcprqst_done_work);
740 kref_init(&tfcp_req->ref);
741
742 schedule_work(&tfcp_req->fcp_rcv_work);
743
744 return 0;
745 }
746
747 static void
748 fcloop_fcp_copy_data(u8 op, struct scatterlist *data_sg,
749 struct scatterlist *io_sg, u32 offset, u32 length)
750 {
751 void *data_p, *io_p;
752 u32 data_len, io_len, tlen;
753
754 io_p = sg_virt(io_sg);
755 io_len = io_sg->length;
756
757 for ( ; offset; ) {
758 tlen = min_t(u32, offset, io_len);
759 offset -= tlen;
760 io_len -= tlen;
761 if (!io_len) {
762 io_sg = sg_next(io_sg);
763 io_p = sg_virt(io_sg);
764 io_len = io_sg->length;
765 } else
766 io_p += tlen;
767 }
768
769 data_p = sg_virt(data_sg);
770 data_len = data_sg->length;
771
772 for ( ; length; ) {
773 tlen = min_t(u32, io_len, data_len);
774 tlen = min_t(u32, tlen, length);
775
776 if (op == NVMET_FCOP_WRITEDATA)
777 memcpy(data_p, io_p, tlen);
778 else
779 memcpy(io_p, data_p, tlen);
780
781 length -= tlen;
782
783 io_len -= tlen;
784 if ((!io_len) && (length)) {
785 io_sg = sg_next(io_sg);
786 io_p = sg_virt(io_sg);
787 io_len = io_sg->length;
788 } else
789 io_p += tlen;
790
791 data_len -= tlen;
792 if ((!data_len) && (length)) {
793 data_sg = sg_next(data_sg);
794 data_p = sg_virt(data_sg);
795 data_len = data_sg->length;
796 } else
797 data_p += tlen;
798 }
799 }
800
801 static int
802 fcloop_fcp_op(struct nvmet_fc_target_port *tgtport,
803 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
804 {
805 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
806 struct nvmefc_fcp_req *fcpreq;
807 u32 rsplen = 0, xfrlen = 0;
808 int fcp_err = 0, active, aborted;
809 u8 op = tgt_fcpreq->op;
810
811 spin_lock_irq(&tfcp_req->reqlock);
812 fcpreq = tfcp_req->fcpreq;
813 active = tfcp_req->active;
814 aborted = tfcp_req->aborted;
815 tfcp_req->active = true;
816 spin_unlock_irq(&tfcp_req->reqlock);
817
818 if (unlikely(active))
819 /* illegal - call while i/o active */
820 return -EALREADY;
821
822 if (unlikely(aborted)) {
823 /* target transport has aborted i/o prior */
824 spin_lock_irq(&tfcp_req->reqlock);
825 tfcp_req->active = false;
826 spin_unlock_irq(&tfcp_req->reqlock);
827 tgt_fcpreq->transferred_length = 0;
828 tgt_fcpreq->fcp_error = -ECANCELED;
829 tgt_fcpreq->done(tgt_fcpreq);
830 return 0;
831 }
832
833 /*
834 * if fcpreq is NULL, the I/O has been aborted (from
835 * initiator side). For the target side, act as if all is well
836 * but don't actually move data.
837 */
838
839 switch (op) {
840 case NVMET_FCOP_WRITEDATA:
841 xfrlen = tgt_fcpreq->transfer_length;
842 if (fcpreq) {
843 fcloop_fcp_copy_data(op, tgt_fcpreq->sg,
844 fcpreq->first_sgl, tgt_fcpreq->offset,
845 xfrlen);
846 fcpreq->transferred_length += xfrlen;
847 }
848 break;
849
850 case NVMET_FCOP_READDATA:
851 case NVMET_FCOP_READDATA_RSP:
852 xfrlen = tgt_fcpreq->transfer_length;
853 if (fcpreq) {
854 fcloop_fcp_copy_data(op, tgt_fcpreq->sg,
855 fcpreq->first_sgl, tgt_fcpreq->offset,
856 xfrlen);
857 fcpreq->transferred_length += xfrlen;
858 }
859 if (op == NVMET_FCOP_READDATA)
860 break;
861
862 /* Fall-Thru to RSP handling */
863 fallthrough;
864
865 case NVMET_FCOP_RSP:
866 if (fcpreq) {
867 rsplen = ((fcpreq->rsplen < tgt_fcpreq->rsplen) ?
868 fcpreq->rsplen : tgt_fcpreq->rsplen);
869 memcpy(fcpreq->rspaddr, tgt_fcpreq->rspaddr, rsplen);
870 if (rsplen < tgt_fcpreq->rsplen)
871 fcp_err = -E2BIG;
872 fcpreq->rcv_rsplen = rsplen;
873 fcpreq->status = 0;
874 }
875 tfcp_req->status = 0;
876 break;
877
878 default:
879 fcp_err = -EINVAL;
880 break;
881 }
882
883 spin_lock_irq(&tfcp_req->reqlock);
884 tfcp_req->active = false;
885 spin_unlock_irq(&tfcp_req->reqlock);
886
887 tgt_fcpreq->transferred_length = xfrlen;
888 tgt_fcpreq->fcp_error = fcp_err;
889 tgt_fcpreq->done(tgt_fcpreq);
890
891 return 0;
892 }
893
894 static void
895 fcloop_tgt_fcp_abort(struct nvmet_fc_target_port *tgtport,
896 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
897 {
898 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
899
900 /*
901 * mark aborted only in case there were 2 threads in transport
902 * (one doing io, other doing abort) and only kills ops posted
903 * after the abort request
904 */
905 spin_lock_irq(&tfcp_req->reqlock);
906 tfcp_req->aborted = true;
907 spin_unlock_irq(&tfcp_req->reqlock);
908
909 tfcp_req->status = NVME_SC_INTERNAL;
910
911 /*
912 * nothing more to do. If io wasn't active, the transport should
913 * immediately call the req_release. If it was active, the op
914 * will complete, and the lldd should call req_release.
915 */
916 }
917
918 static void
919 fcloop_fcp_req_release(struct nvmet_fc_target_port *tgtport,
920 struct nvmefc_tgt_fcp_req *tgt_fcpreq)
921 {
922 struct fcloop_fcpreq *tfcp_req = tgt_fcp_req_to_fcpreq(tgt_fcpreq);
923
924 schedule_work(&tfcp_req->tio_done_work);
925 }
926
927 static void
928 fcloop_h2t_ls_abort(struct nvme_fc_local_port *localport,
929 struct nvme_fc_remote_port *remoteport,
930 struct nvmefc_ls_req *lsreq)
931 {
932 }
933
934 static void
935 fcloop_t2h_ls_abort(struct nvmet_fc_target_port *targetport,
936 void *hosthandle, struct nvmefc_ls_req *lsreq)
937 {
938 }
939
940 static void
941 fcloop_fcp_abort(struct nvme_fc_local_port *localport,
942 struct nvme_fc_remote_port *remoteport,
943 void *hw_queue_handle,
944 struct nvmefc_fcp_req *fcpreq)
945 {
946 struct fcloop_ini_fcpreq *inireq = fcpreq->private;
947 struct fcloop_fcpreq *tfcp_req;
948 bool abortio = true;
949
950 spin_lock(&inireq->inilock);
951 tfcp_req = inireq->tfcp_req;
952 if (tfcp_req)
953 fcloop_tfcp_req_get(tfcp_req);
954 spin_unlock(&inireq->inilock);
955
956 if (!tfcp_req)
957 /* abort has already been called */
958 return;
959
960 /* break initiator/target relationship for io */
961 spin_lock_irq(&tfcp_req->reqlock);
962 switch (tfcp_req->inistate) {
963 case INI_IO_START:
964 case INI_IO_ACTIVE:
965 tfcp_req->inistate = INI_IO_ABORTED;
966 break;
967 case INI_IO_COMPLETED:
968 abortio = false;
969 break;
970 default:
971 spin_unlock_irq(&tfcp_req->reqlock);
972 WARN_ON(1);
973 return;
974 }
975 spin_unlock_irq(&tfcp_req->reqlock);
976
977 if (abortio)
978 /* leave the reference while the work item is scheduled */
979 WARN_ON(!schedule_work(&tfcp_req->abort_rcv_work));
980 else {
981 /*
982 * as the io has already had the done callback made,
983 * nothing more to do. So release the reference taken above
984 */
985 fcloop_tfcp_req_put(tfcp_req);
986 }
987 }
988
989 static void
990 fcloop_nport_free(struct kref *ref)
991 {
992 struct fcloop_nport *nport =
993 container_of(ref, struct fcloop_nport, ref);
994 unsigned long flags;
995
996 spin_lock_irqsave(&fcloop_lock, flags);
997 list_del(&nport->nport_list);
998 spin_unlock_irqrestore(&fcloop_lock, flags);
999
1000 kfree(nport);
1001 }
1002
1003 static void
1004 fcloop_nport_put(struct fcloop_nport *nport)
1005 {
1006 kref_put(&nport->ref, fcloop_nport_free);
1007 }
1008
1009 static int
1010 fcloop_nport_get(struct fcloop_nport *nport)
1011 {
1012 return kref_get_unless_zero(&nport->ref);
1013 }
1014
1015 static void
1016 fcloop_localport_delete(struct nvme_fc_local_port *localport)
1017 {
1018 struct fcloop_lport_priv *lport_priv = localport->private;
1019 struct fcloop_lport *lport = lport_priv->lport;
1020
1021 /* release any threads waiting for the unreg to complete */
1022 complete(&lport->unreg_done);
1023 }
1024
1025 static void
1026 fcloop_remoteport_delete(struct nvme_fc_remote_port *remoteport)
1027 {
1028 struct fcloop_rport *rport = remoteport->private;
1029
1030 flush_work(&rport->ls_work);
1031 fcloop_nport_put(rport->nport);
1032 }
1033
1034 static void
1035 fcloop_targetport_delete(struct nvmet_fc_target_port *targetport)
1036 {
1037 struct fcloop_tport *tport = targetport->private;
1038
1039 flush_work(&tport->ls_work);
1040 fcloop_nport_put(tport->nport);
1041 }
1042
1043 #define FCLOOP_HW_QUEUES 4
1044 #define FCLOOP_SGL_SEGS 256
1045 #define FCLOOP_DMABOUND_4G 0xFFFFFFFF
1046
1047 static struct nvme_fc_port_template fctemplate = {
1048 .localport_delete = fcloop_localport_delete,
1049 .remoteport_delete = fcloop_remoteport_delete,
1050 .create_queue = fcloop_create_queue,
1051 .delete_queue = fcloop_delete_queue,
1052 .ls_req = fcloop_h2t_ls_req,
1053 .fcp_io = fcloop_fcp_req,
1054 .ls_abort = fcloop_h2t_ls_abort,
1055 .fcp_abort = fcloop_fcp_abort,
1056 .xmt_ls_rsp = fcloop_t2h_xmt_ls_rsp,
1057 .max_hw_queues = FCLOOP_HW_QUEUES,
1058 .max_sgl_segments = FCLOOP_SGL_SEGS,
1059 .max_dif_sgl_segments = FCLOOP_SGL_SEGS,
1060 .dma_boundary = FCLOOP_DMABOUND_4G,
1061 /* sizes of additional private data for data structures */
1062 .local_priv_sz = sizeof(struct fcloop_lport_priv),
1063 .remote_priv_sz = sizeof(struct fcloop_rport),
1064 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq),
1065 .fcprqst_priv_sz = sizeof(struct fcloop_ini_fcpreq),
1066 };
1067
1068 static struct nvmet_fc_target_template tgttemplate = {
1069 .targetport_delete = fcloop_targetport_delete,
1070 .xmt_ls_rsp = fcloop_h2t_xmt_ls_rsp,
1071 .fcp_op = fcloop_fcp_op,
1072 .fcp_abort = fcloop_tgt_fcp_abort,
1073 .fcp_req_release = fcloop_fcp_req_release,
1074 .discovery_event = fcloop_tgt_discovery_evt,
1075 .ls_req = fcloop_t2h_ls_req,
1076 .ls_abort = fcloop_t2h_ls_abort,
1077 .host_release = fcloop_t2h_host_release,
1078 .max_hw_queues = FCLOOP_HW_QUEUES,
1079 .max_sgl_segments = FCLOOP_SGL_SEGS,
1080 .max_dif_sgl_segments = FCLOOP_SGL_SEGS,
1081 .dma_boundary = FCLOOP_DMABOUND_4G,
1082 /* optional features */
1083 .target_features = 0,
1084 /* sizes of additional private data for data structures */
1085 .target_priv_sz = sizeof(struct fcloop_tport),
1086 .lsrqst_priv_sz = sizeof(struct fcloop_lsreq),
1087 };
1088
1089 static ssize_t
1090 fcloop_create_local_port(struct device *dev, struct device_attribute *attr,
1091 const char *buf, size_t count)
1092 {
1093 struct nvme_fc_port_info pinfo;
1094 struct fcloop_ctrl_options *opts;
1095 struct nvme_fc_local_port *localport;
1096 struct fcloop_lport *lport;
1097 struct fcloop_lport_priv *lport_priv;
1098 unsigned long flags;
1099 int ret = -ENOMEM;
1100
1101 lport = kzalloc(sizeof(*lport), GFP_KERNEL);
1102 if (!lport)
1103 return -ENOMEM;
1104
1105 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1106 if (!opts)
1107 goto out_free_lport;
1108
1109 ret = fcloop_parse_options(opts, buf);
1110 if (ret)
1111 goto out_free_opts;
1112
1113 /* everything there ? */
1114 if ((opts->mask & LPORT_OPTS) != LPORT_OPTS) {
1115 ret = -EINVAL;
1116 goto out_free_opts;
1117 }
1118
1119 memset(&pinfo, 0, sizeof(pinfo));
1120 pinfo.node_name = opts->wwnn;
1121 pinfo.port_name = opts->wwpn;
1122 pinfo.port_role = opts->roles;
1123 pinfo.port_id = opts->fcaddr;
1124
1125 ret = nvme_fc_register_localport(&pinfo, &fctemplate, NULL, &localport);
1126 if (!ret) {
1127 /* success */
1128 lport_priv = localport->private;
1129 lport_priv->lport = lport;
1130
1131 lport->localport = localport;
1132 INIT_LIST_HEAD(&lport->lport_list);
1133
1134 spin_lock_irqsave(&fcloop_lock, flags);
1135 list_add_tail(&lport->lport_list, &fcloop_lports);
1136 spin_unlock_irqrestore(&fcloop_lock, flags);
1137 }
1138
1139 out_free_opts:
1140 kfree(opts);
1141 out_free_lport:
1142 /* free only if we're going to fail */
1143 if (ret)
1144 kfree(lport);
1145
1146 return ret ? ret : count;
1147 }
1148
1149
1150 static void
1151 __unlink_local_port(struct fcloop_lport *lport)
1152 {
1153 list_del(&lport->lport_list);
1154 }
1155
1156 static int
1157 __wait_localport_unreg(struct fcloop_lport *lport)
1158 {
1159 int ret;
1160
1161 init_completion(&lport->unreg_done);
1162
1163 ret = nvme_fc_unregister_localport(lport->localport);
1164
1165 wait_for_completion(&lport->unreg_done);
1166
1167 kfree(lport);
1168
1169 return ret;
1170 }
1171
1172
1173 static ssize_t
1174 fcloop_delete_local_port(struct device *dev, struct device_attribute *attr,
1175 const char *buf, size_t count)
1176 {
1177 struct fcloop_lport *tlport, *lport = NULL;
1178 u64 nodename, portname;
1179 unsigned long flags;
1180 int ret;
1181
1182 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1183 if (ret)
1184 return ret;
1185
1186 spin_lock_irqsave(&fcloop_lock, flags);
1187
1188 list_for_each_entry(tlport, &fcloop_lports, lport_list) {
1189 if (tlport->localport->node_name == nodename &&
1190 tlport->localport->port_name == portname) {
1191 lport = tlport;
1192 __unlink_local_port(lport);
1193 break;
1194 }
1195 }
1196 spin_unlock_irqrestore(&fcloop_lock, flags);
1197
1198 if (!lport)
1199 return -ENOENT;
1200
1201 ret = __wait_localport_unreg(lport);
1202
1203 return ret ? ret : count;
1204 }
1205
1206 static struct fcloop_nport *
1207 fcloop_alloc_nport(const char *buf, size_t count, bool remoteport)
1208 {
1209 struct fcloop_nport *newnport, *nport = NULL;
1210 struct fcloop_lport *tmplport, *lport = NULL;
1211 struct fcloop_ctrl_options *opts;
1212 unsigned long flags;
1213 u32 opts_mask = (remoteport) ? RPORT_OPTS : TGTPORT_OPTS;
1214 int ret;
1215
1216 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1217 if (!opts)
1218 return NULL;
1219
1220 ret = fcloop_parse_options(opts, buf);
1221 if (ret)
1222 goto out_free_opts;
1223
1224 /* everything there ? */
1225 if ((opts->mask & opts_mask) != opts_mask) {
1226 ret = -EINVAL;
1227 goto out_free_opts;
1228 }
1229
1230 newnport = kzalloc(sizeof(*newnport), GFP_KERNEL);
1231 if (!newnport)
1232 goto out_free_opts;
1233
1234 INIT_LIST_HEAD(&newnport->nport_list);
1235 newnport->node_name = opts->wwnn;
1236 newnport->port_name = opts->wwpn;
1237 if (opts->mask & NVMF_OPT_ROLES)
1238 newnport->port_role = opts->roles;
1239 if (opts->mask & NVMF_OPT_FCADDR)
1240 newnport->port_id = opts->fcaddr;
1241 kref_init(&newnport->ref);
1242
1243 spin_lock_irqsave(&fcloop_lock, flags);
1244
1245 list_for_each_entry(tmplport, &fcloop_lports, lport_list) {
1246 if (tmplport->localport->node_name == opts->wwnn &&
1247 tmplport->localport->port_name == opts->wwpn)
1248 goto out_invalid_opts;
1249
1250 if (tmplport->localport->node_name == opts->lpwwnn &&
1251 tmplport->localport->port_name == opts->lpwwpn)
1252 lport = tmplport;
1253 }
1254
1255 if (remoteport) {
1256 if (!lport)
1257 goto out_invalid_opts;
1258 newnport->lport = lport;
1259 }
1260
1261 list_for_each_entry(nport, &fcloop_nports, nport_list) {
1262 if (nport->node_name == opts->wwnn &&
1263 nport->port_name == opts->wwpn) {
1264 if ((remoteport && nport->rport) ||
1265 (!remoteport && nport->tport)) {
1266 nport = NULL;
1267 goto out_invalid_opts;
1268 }
1269
1270 fcloop_nport_get(nport);
1271
1272 spin_unlock_irqrestore(&fcloop_lock, flags);
1273
1274 if (remoteport)
1275 nport->lport = lport;
1276 if (opts->mask & NVMF_OPT_ROLES)
1277 nport->port_role = opts->roles;
1278 if (opts->mask & NVMF_OPT_FCADDR)
1279 nport->port_id = opts->fcaddr;
1280 goto out_free_newnport;
1281 }
1282 }
1283
1284 list_add_tail(&newnport->nport_list, &fcloop_nports);
1285
1286 spin_unlock_irqrestore(&fcloop_lock, flags);
1287
1288 kfree(opts);
1289 return newnport;
1290
1291 out_invalid_opts:
1292 spin_unlock_irqrestore(&fcloop_lock, flags);
1293 out_free_newnport:
1294 kfree(newnport);
1295 out_free_opts:
1296 kfree(opts);
1297 return nport;
1298 }
1299
1300 static ssize_t
1301 fcloop_create_remote_port(struct device *dev, struct device_attribute *attr,
1302 const char *buf, size_t count)
1303 {
1304 struct nvme_fc_remote_port *remoteport;
1305 struct fcloop_nport *nport;
1306 struct fcloop_rport *rport;
1307 struct nvme_fc_port_info pinfo;
1308 int ret;
1309
1310 nport = fcloop_alloc_nport(buf, count, true);
1311 if (!nport)
1312 return -EIO;
1313
1314 memset(&pinfo, 0, sizeof(pinfo));
1315 pinfo.node_name = nport->node_name;
1316 pinfo.port_name = nport->port_name;
1317 pinfo.port_role = nport->port_role;
1318 pinfo.port_id = nport->port_id;
1319
1320 ret = nvme_fc_register_remoteport(nport->lport->localport,
1321 &pinfo, &remoteport);
1322 if (ret || !remoteport) {
1323 fcloop_nport_put(nport);
1324 return ret;
1325 }
1326
1327 /* success */
1328 rport = remoteport->private;
1329 rport->remoteport = remoteport;
1330 rport->targetport = (nport->tport) ? nport->tport->targetport : NULL;
1331 if (nport->tport) {
1332 nport->tport->remoteport = remoteport;
1333 nport->tport->lport = nport->lport;
1334 }
1335 rport->nport = nport;
1336 rport->lport = nport->lport;
1337 nport->rport = rport;
1338 spin_lock_init(&rport->lock);
1339 INIT_WORK(&rport->ls_work, fcloop_rport_lsrqst_work);
1340 INIT_LIST_HEAD(&rport->ls_list);
1341
1342 return count;
1343 }
1344
1345
1346 static struct fcloop_rport *
1347 __unlink_remote_port(struct fcloop_nport *nport)
1348 {
1349 struct fcloop_rport *rport = nport->rport;
1350
1351 if (rport && nport->tport)
1352 nport->tport->remoteport = NULL;
1353 nport->rport = NULL;
1354
1355 return rport;
1356 }
1357
1358 static int
1359 __remoteport_unreg(struct fcloop_nport *nport, struct fcloop_rport *rport)
1360 {
1361 if (!rport)
1362 return -EALREADY;
1363
1364 return nvme_fc_unregister_remoteport(rport->remoteport);
1365 }
1366
1367 static ssize_t
1368 fcloop_delete_remote_port(struct device *dev, struct device_attribute *attr,
1369 const char *buf, size_t count)
1370 {
1371 struct fcloop_nport *nport = NULL, *tmpport;
1372 static struct fcloop_rport *rport;
1373 u64 nodename, portname;
1374 unsigned long flags;
1375 int ret;
1376
1377 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1378 if (ret)
1379 return ret;
1380
1381 spin_lock_irqsave(&fcloop_lock, flags);
1382
1383 list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1384 if (tmpport->node_name == nodename &&
1385 tmpport->port_name == portname && tmpport->rport) {
1386 nport = tmpport;
1387 rport = __unlink_remote_port(nport);
1388 break;
1389 }
1390 }
1391
1392 spin_unlock_irqrestore(&fcloop_lock, flags);
1393
1394 if (!nport)
1395 return -ENOENT;
1396
1397 ret = __remoteport_unreg(nport, rport);
1398
1399 return ret ? ret : count;
1400 }
1401
1402 static ssize_t
1403 fcloop_create_target_port(struct device *dev, struct device_attribute *attr,
1404 const char *buf, size_t count)
1405 {
1406 struct nvmet_fc_target_port *targetport;
1407 struct fcloop_nport *nport;
1408 struct fcloop_tport *tport;
1409 struct nvmet_fc_port_info tinfo;
1410 int ret;
1411
1412 nport = fcloop_alloc_nport(buf, count, false);
1413 if (!nport)
1414 return -EIO;
1415
1416 tinfo.node_name = nport->node_name;
1417 tinfo.port_name = nport->port_name;
1418 tinfo.port_id = nport->port_id;
1419
1420 ret = nvmet_fc_register_targetport(&tinfo, &tgttemplate, NULL,
1421 &targetport);
1422 if (ret) {
1423 fcloop_nport_put(nport);
1424 return ret;
1425 }
1426
1427 /* success */
1428 tport = targetport->private;
1429 tport->targetport = targetport;
1430 tport->remoteport = (nport->rport) ? nport->rport->remoteport : NULL;
1431 if (nport->rport)
1432 nport->rport->targetport = targetport;
1433 tport->nport = nport;
1434 tport->lport = nport->lport;
1435 nport->tport = tport;
1436 spin_lock_init(&tport->lock);
1437 INIT_WORK(&tport->ls_work, fcloop_tport_lsrqst_work);
1438 INIT_LIST_HEAD(&tport->ls_list);
1439
1440 return count;
1441 }
1442
1443
1444 static struct fcloop_tport *
1445 __unlink_target_port(struct fcloop_nport *nport)
1446 {
1447 struct fcloop_tport *tport = nport->tport;
1448
1449 if (tport && nport->rport)
1450 nport->rport->targetport = NULL;
1451 nport->tport = NULL;
1452
1453 return tport;
1454 }
1455
1456 static int
1457 __targetport_unreg(struct fcloop_nport *nport, struct fcloop_tport *tport)
1458 {
1459 if (!tport)
1460 return -EALREADY;
1461
1462 return nvmet_fc_unregister_targetport(tport->targetport);
1463 }
1464
1465 static ssize_t
1466 fcloop_delete_target_port(struct device *dev, struct device_attribute *attr,
1467 const char *buf, size_t count)
1468 {
1469 struct fcloop_nport *nport = NULL, *tmpport;
1470 struct fcloop_tport *tport = NULL;
1471 u64 nodename, portname;
1472 unsigned long flags;
1473 int ret;
1474
1475 ret = fcloop_parse_nm_options(dev, &nodename, &portname, buf);
1476 if (ret)
1477 return ret;
1478
1479 spin_lock_irqsave(&fcloop_lock, flags);
1480
1481 list_for_each_entry(tmpport, &fcloop_nports, nport_list) {
1482 if (tmpport->node_name == nodename &&
1483 tmpport->port_name == portname && tmpport->tport) {
1484 nport = tmpport;
1485 tport = __unlink_target_port(nport);
1486 break;
1487 }
1488 }
1489
1490 spin_unlock_irqrestore(&fcloop_lock, flags);
1491
1492 if (!nport)
1493 return -ENOENT;
1494
1495 ret = __targetport_unreg(nport, tport);
1496
1497 return ret ? ret : count;
1498 }
1499
1500 static ssize_t
1501 fcloop_set_cmd_drop(struct device *dev, struct device_attribute *attr,
1502 const char *buf, size_t count)
1503 {
1504 unsigned int opcode;
1505 int starting, amount;
1506
1507 if (sscanf(buf, "%x:%d:%d", &opcode, &starting, &amount) != 3)
1508 return -EBADRQC;
1509
1510 drop_current_cnt = 0;
1511 drop_fabric_opcode = (opcode & ~DROP_OPCODE_MASK) ? true : false;
1512 drop_opcode = (opcode & DROP_OPCODE_MASK);
1513 drop_instance = starting;
1514 /* the check to drop routine uses instance + count to know when
1515 * to end. Thus, if dropping 1 instance, count should be 0.
1516 * so subtract 1 from the count.
1517 */
1518 drop_amount = amount - 1;
1519
1520 pr_info("%s: DROP: Starting at instance %d of%s opcode x%x drop +%d "
1521 "instances\n",
1522 __func__, drop_instance, drop_fabric_opcode ? " fabric" : "",
1523 drop_opcode, drop_amount);
1524
1525 return count;
1526 }
1527
1528
1529 static DEVICE_ATTR(add_local_port, 0200, NULL, fcloop_create_local_port);
1530 static DEVICE_ATTR(del_local_port, 0200, NULL, fcloop_delete_local_port);
1531 static DEVICE_ATTR(add_remote_port, 0200, NULL, fcloop_create_remote_port);
1532 static DEVICE_ATTR(del_remote_port, 0200, NULL, fcloop_delete_remote_port);
1533 static DEVICE_ATTR(add_target_port, 0200, NULL, fcloop_create_target_port);
1534 static DEVICE_ATTR(del_target_port, 0200, NULL, fcloop_delete_target_port);
1535 static DEVICE_ATTR(set_cmd_drop, 0200, NULL, fcloop_set_cmd_drop);
1536
1537 static struct attribute *fcloop_dev_attrs[] = {
1538 &dev_attr_add_local_port.attr,
1539 &dev_attr_del_local_port.attr,
1540 &dev_attr_add_remote_port.attr,
1541 &dev_attr_del_remote_port.attr,
1542 &dev_attr_add_target_port.attr,
1543 &dev_attr_del_target_port.attr,
1544 &dev_attr_set_cmd_drop.attr,
1545 NULL
1546 };
1547
1548 static struct attribute_group fclopp_dev_attrs_group = {
1549 .attrs = fcloop_dev_attrs,
1550 };
1551
1552 static const struct attribute_group *fcloop_dev_attr_groups[] = {
1553 &fclopp_dev_attrs_group,
1554 NULL,
1555 };
1556
1557 static struct class *fcloop_class;
1558 static struct device *fcloop_device;
1559
1560
1561 static int __init fcloop_init(void)
1562 {
1563 int ret;
1564
1565 fcloop_class = class_create(THIS_MODULE, "fcloop");
1566 if (IS_ERR(fcloop_class)) {
1567 pr_err("couldn't register class fcloop\n");
1568 ret = PTR_ERR(fcloop_class);
1569 return ret;
1570 }
1571
1572 fcloop_device = device_create_with_groups(
1573 fcloop_class, NULL, MKDEV(0, 0), NULL,
1574 fcloop_dev_attr_groups, "ctl");
1575 if (IS_ERR(fcloop_device)) {
1576 pr_err("couldn't create ctl device!\n");
1577 ret = PTR_ERR(fcloop_device);
1578 goto out_destroy_class;
1579 }
1580
1581 get_device(fcloop_device);
1582
1583 return 0;
1584
1585 out_destroy_class:
1586 class_destroy(fcloop_class);
1587 return ret;
1588 }
1589
1590 static void __exit fcloop_exit(void)
1591 {
1592 struct fcloop_lport *lport = NULL;
1593 struct fcloop_nport *nport = NULL;
1594 struct fcloop_tport *tport;
1595 struct fcloop_rport *rport;
1596 unsigned long flags;
1597 int ret;
1598
1599 spin_lock_irqsave(&fcloop_lock, flags);
1600
1601 for (;;) {
1602 nport = list_first_entry_or_null(&fcloop_nports,
1603 typeof(*nport), nport_list);
1604 if (!nport)
1605 break;
1606
1607 tport = __unlink_target_port(nport);
1608 rport = __unlink_remote_port(nport);
1609
1610 spin_unlock_irqrestore(&fcloop_lock, flags);
1611
1612 ret = __targetport_unreg(nport, tport);
1613 if (ret)
1614 pr_warn("%s: Failed deleting target port\n", __func__);
1615
1616 ret = __remoteport_unreg(nport, rport);
1617 if (ret)
1618 pr_warn("%s: Failed deleting remote port\n", __func__);
1619
1620 spin_lock_irqsave(&fcloop_lock, flags);
1621 }
1622
1623 for (;;) {
1624 lport = list_first_entry_or_null(&fcloop_lports,
1625 typeof(*lport), lport_list);
1626 if (!lport)
1627 break;
1628
1629 __unlink_local_port(lport);
1630
1631 spin_unlock_irqrestore(&fcloop_lock, flags);
1632
1633 ret = __wait_localport_unreg(lport);
1634 if (ret)
1635 pr_warn("%s: Failed deleting local port\n", __func__);
1636
1637 spin_lock_irqsave(&fcloop_lock, flags);
1638 }
1639
1640 spin_unlock_irqrestore(&fcloop_lock, flags);
1641
1642 put_device(fcloop_device);
1643
1644 device_destroy(fcloop_class, MKDEV(0, 0));
1645 class_destroy(fcloop_class);
1646 }
1647
1648 module_init(fcloop_init);
1649 module_exit(fcloop_exit);
1650
1651 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support