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