1
2
3
4
5
6
7#include <target/target_core_base.h>
8#include <target/target_core_fabric.h>
9#include "efct_driver.h"
10#include "efct_lio.h"
11
12
13
14
15
16
17static struct workqueue_struct *lio_wq;
18
19static int
20efct_format_wwn(char *str, size_t len, const char *pre, u64 wwn)
21{
22 u8 a[8];
23
24 put_unaligned_be64(wwn, a);
25 return snprintf(str, len, "%s%8phC", pre, a);
26}
27
28static int
29efct_lio_parse_wwn(const char *name, u64 *wwp, u8 npiv)
30{
31 int num;
32 u8 b[8];
33
34 if (npiv) {
35 num = sscanf(name,
36 "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
37 &b[0], &b[1], &b[2], &b[3], &b[4], &b[5], &b[6],
38 &b[7]);
39 } else {
40 num = sscanf(name,
41 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
42 &b[0], &b[1], &b[2], &b[3], &b[4], &b[5], &b[6],
43 &b[7]);
44 }
45
46 if (num != 8)
47 return -EINVAL;
48
49 *wwp = get_unaligned_be64(b);
50 return 0;
51}
52
53static int
54efct_lio_parse_npiv_wwn(const char *name, size_t size, u64 *wwpn, u64 *wwnn)
55{
56 unsigned int cnt = size;
57 int rc;
58
59 *wwpn = *wwnn = 0;
60 if (name[cnt - 1] == '\n' || name[cnt - 1] == 0)
61 cnt--;
62
63
64 if ((cnt != (16 + 1 + 16)) || (name[16] != ':'))
65 return -EINVAL;
66
67 rc = efct_lio_parse_wwn(&name[0], wwpn, 1);
68 if (rc)
69 return rc;
70
71 rc = efct_lio_parse_wwn(&name[17], wwnn, 1);
72 if (rc)
73 return rc;
74
75 return 0;
76}
77
78static ssize_t
79efct_lio_tpg_enable_show(struct config_item *item, char *page)
80{
81 struct se_portal_group *se_tpg = to_tpg(item);
82 struct efct_lio_tpg *tpg =
83 container_of(se_tpg, struct efct_lio_tpg, tpg);
84
85 return snprintf(page, PAGE_SIZE, "%d\n", tpg->enabled);
86}
87
88static ssize_t
89efct_lio_tpg_enable_store(struct config_item *item, const char *page,
90 size_t count)
91{
92 struct se_portal_group *se_tpg = to_tpg(item);
93 struct efct_lio_tpg *tpg =
94 container_of(se_tpg, struct efct_lio_tpg, tpg);
95 struct efct *efct;
96 struct efc *efc;
97 unsigned long op;
98
99 if (!tpg->nport || !tpg->nport->efct) {
100 pr_err("%s: Unable to find EFCT device\n", __func__);
101 return -EINVAL;
102 }
103
104 efct = tpg->nport->efct;
105 efc = efct->efcport;
106
107 if (kstrtoul(page, 0, &op) < 0)
108 return -EINVAL;
109
110 if (op == 1) {
111 int ret;
112
113 tpg->enabled = true;
114 efc_log_debug(efct, "enable portal group %d\n", tpg->tpgt);
115
116 ret = efct_xport_control(efct->xport, EFCT_XPORT_PORT_ONLINE);
117 if (ret) {
118 efct->tgt_efct.lio_nport = NULL;
119 efc_log_debug(efct, "cannot bring port online\n");
120 return ret;
121 }
122 } else if (op == 0) {
123 efc_log_debug(efct, "disable portal group %d\n", tpg->tpgt);
124
125 if (efc->domain && efc->domain->nport)
126 efct_scsi_tgt_del_nport(efc, efc->domain->nport);
127
128 tpg->enabled = false;
129 } else {
130 return -EINVAL;
131 }
132
133 return count;
134}
135
136static ssize_t
137efct_lio_npiv_tpg_enable_show(struct config_item *item, char *page)
138{
139 struct se_portal_group *se_tpg = to_tpg(item);
140 struct efct_lio_tpg *tpg =
141 container_of(se_tpg, struct efct_lio_tpg, tpg);
142
143 return snprintf(page, PAGE_SIZE, "%d\n", tpg->enabled);
144}
145
146static ssize_t
147efct_lio_npiv_tpg_enable_store(struct config_item *item, const char *page,
148 size_t count)
149{
150 struct se_portal_group *se_tpg = to_tpg(item);
151 struct efct_lio_tpg *tpg =
152 container_of(se_tpg, struct efct_lio_tpg, tpg);
153 struct efct_lio_vport *lio_vport = tpg->vport;
154 struct efct *efct;
155 struct efc *efc;
156 unsigned long op;
157
158 if (kstrtoul(page, 0, &op) < 0)
159 return -EINVAL;
160
161 if (!lio_vport) {
162 pr_err("Unable to find vport\n");
163 return -EINVAL;
164 }
165
166 efct = lio_vport->efct;
167 efc = efct->efcport;
168
169 if (op == 1) {
170 tpg->enabled = true;
171 efc_log_debug(efct, "enable portal group %d\n", tpg->tpgt);
172
173 if (efc->domain) {
174 int ret;
175
176 ret = efc_nport_vport_new(efc->domain,
177 lio_vport->npiv_wwpn,
178 lio_vport->npiv_wwnn,
179 U32_MAX, false, true,
180 NULL, NULL);
181 if (ret != 0) {
182 efc_log_err(efct, "Failed to create Vport\n");
183 return ret;
184 }
185 return count;
186 }
187
188 if (!(efc_vport_create_spec(efc, lio_vport->npiv_wwnn,
189 lio_vport->npiv_wwpn, U32_MAX,
190 false, true, NULL, NULL)))
191 return -ENOMEM;
192
193 } else if (op == 0) {
194 efc_log_debug(efct, "disable portal group %d\n", tpg->tpgt);
195
196 tpg->enabled = false;
197
198
199
200 if (efc->domain) {
201 efc_nport_vport_del(efct->efcport, efc->domain,
202 lio_vport->npiv_wwpn,
203 lio_vport->npiv_wwnn);
204 return count;
205 }
206 } else {
207 return -EINVAL;
208 }
209 return count;
210}
211
212static char *efct_lio_get_fabric_wwn(struct se_portal_group *se_tpg)
213{
214 struct efct_lio_tpg *tpg =
215 container_of(se_tpg, struct efct_lio_tpg, tpg);
216
217 return tpg->nport->wwpn_str;
218}
219
220static char *efct_lio_get_npiv_fabric_wwn(struct se_portal_group *se_tpg)
221{
222 struct efct_lio_tpg *tpg =
223 container_of(se_tpg, struct efct_lio_tpg, tpg);
224
225 return tpg->vport->wwpn_str;
226}
227
228static u16 efct_lio_get_tag(struct se_portal_group *se_tpg)
229{
230 struct efct_lio_tpg *tpg =
231 container_of(se_tpg, struct efct_lio_tpg, tpg);
232
233 return tpg->tpgt;
234}
235
236static u16 efct_lio_get_npiv_tag(struct se_portal_group *se_tpg)
237{
238 struct efct_lio_tpg *tpg =
239 container_of(se_tpg, struct efct_lio_tpg, tpg);
240
241 return tpg->tpgt;
242}
243
244static int efct_lio_check_demo_mode(struct se_portal_group *se_tpg)
245{
246 return 1;
247}
248
249static int efct_lio_check_demo_mode_cache(struct se_portal_group *se_tpg)
250{
251 return 1;
252}
253
254static int efct_lio_check_demo_write_protect(struct se_portal_group *se_tpg)
255{
256 struct efct_lio_tpg *tpg =
257 container_of(se_tpg, struct efct_lio_tpg, tpg);
258
259 return tpg->tpg_attrib.demo_mode_write_protect;
260}
261
262static int
263efct_lio_npiv_check_demo_write_protect(struct se_portal_group *se_tpg)
264{
265 struct efct_lio_tpg *tpg =
266 container_of(se_tpg, struct efct_lio_tpg, tpg);
267
268 return tpg->tpg_attrib.demo_mode_write_protect;
269}
270
271static int efct_lio_check_prod_write_protect(struct se_portal_group *se_tpg)
272{
273 struct efct_lio_tpg *tpg =
274 container_of(se_tpg, struct efct_lio_tpg, tpg);
275
276 return tpg->tpg_attrib.prod_mode_write_protect;
277}
278
279static int
280efct_lio_npiv_check_prod_write_protect(struct se_portal_group *se_tpg)
281{
282 struct efct_lio_tpg *tpg =
283 container_of(se_tpg, struct efct_lio_tpg, tpg);
284
285 return tpg->tpg_attrib.prod_mode_write_protect;
286}
287
288static u32 efct_lio_tpg_get_inst_index(struct se_portal_group *se_tpg)
289{
290 return 1;
291}
292
293static int efct_lio_check_stop_free(struct se_cmd *se_cmd)
294{
295 struct efct_scsi_tgt_io *ocp =
296 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
297 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
298
299 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_CHK_STOP_FREE);
300 return target_put_sess_cmd(se_cmd);
301}
302
303static int
304efct_lio_abort_tgt_cb(struct efct_io *io,
305 enum efct_scsi_io_status scsi_status,
306 u32 flags, void *arg)
307{
308 efct_lio_io_printf(io, "Abort done, status:%d\n", scsi_status);
309 return 0;
310}
311
312static void
313efct_lio_aborted_task(struct se_cmd *se_cmd)
314{
315 struct efct_scsi_tgt_io *ocp =
316 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
317 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
318
319 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_ABORTED_TASK);
320
321 if (ocp->rsp_sent)
322 return;
323
324
325 ocp->aborting = true;
326 ocp->err = EFCT_SCSI_STATUS_ABORTED;
327
328 efct_scsi_tgt_abort_io(io, efct_lio_abort_tgt_cb, NULL);
329}
330
331static void efct_lio_release_cmd(struct se_cmd *se_cmd)
332{
333 struct efct_scsi_tgt_io *ocp =
334 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
335 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
336 struct efct *efct = io->efct;
337
338 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_RELEASE_CMD);
339 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_CMPL_CMD);
340 efct_scsi_io_complete(io);
341 atomic_sub_return(1, &efct->tgt_efct.ios_in_use);
342}
343
344static void efct_lio_close_session(struct se_session *se_sess)
345{
346 struct efc_node *node = se_sess->fabric_sess_ptr;
347
348 pr_debug("se_sess=%p node=%p", se_sess, node);
349
350 if (!node) {
351 pr_debug("node is NULL");
352 return;
353 }
354
355 efc_node_post_shutdown(node, NULL);
356}
357
358static u32 efct_lio_sess_get_index(struct se_session *se_sess)
359{
360 return 0;
361}
362
363static void efct_lio_set_default_node_attrs(struct se_node_acl *nacl)
364{
365}
366
367static int efct_lio_get_cmd_state(struct se_cmd *cmd)
368{
369 struct efct_scsi_tgt_io *ocp =
370 container_of(cmd, struct efct_scsi_tgt_io, cmd);
371 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
372
373 if (!io)
374 return 0;
375
376 return io->tgt_io.state;
377}
378
379static int
380efct_lio_sg_map(struct efct_io *io)
381{
382 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
383 struct se_cmd *cmd = &ocp->cmd;
384
385 ocp->seg_map_cnt = pci_map_sg(io->efct->pci, cmd->t_data_sg,
386 cmd->t_data_nents, cmd->data_direction);
387 if (ocp->seg_map_cnt == 0)
388 return -EFAULT;
389 return 0;
390}
391
392static void
393efct_lio_sg_unmap(struct efct_io *io)
394{
395 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
396 struct se_cmd *cmd = &ocp->cmd;
397
398 if (WARN_ON(!ocp->seg_map_cnt || !cmd->t_data_sg))
399 return;
400
401 pci_unmap_sg(io->efct->pci, cmd->t_data_sg,
402 ocp->seg_map_cnt, cmd->data_direction);
403 ocp->seg_map_cnt = 0;
404}
405
406static int
407efct_lio_status_done(struct efct_io *io,
408 enum efct_scsi_io_status scsi_status,
409 u32 flags, void *arg)
410{
411 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
412
413 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_RSP_DONE);
414 if (scsi_status != EFCT_SCSI_STATUS_GOOD) {
415 efct_lio_io_printf(io, "callback completed with error=%d\n",
416 scsi_status);
417 ocp->err = scsi_status;
418 }
419 if (ocp->seg_map_cnt)
420 efct_lio_sg_unmap(io);
421
422 efct_lio_io_printf(io, "status=%d, err=%d flags=0x%x, dir=%d\n",
423 scsi_status, ocp->err, flags, ocp->ddir);
424
425 efct_set_lio_io_state(io, EFCT_LIO_STATE_TGT_GENERIC_FREE);
426 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
427 return 0;
428}
429
430static int
431efct_lio_datamove_done(struct efct_io *io, enum efct_scsi_io_status scsi_status,
432 u32 flags, void *arg);
433
434static int
435efct_lio_write_pending(struct se_cmd *cmd)
436{
437 struct efct_scsi_tgt_io *ocp =
438 container_of(cmd, struct efct_scsi_tgt_io, cmd);
439 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
440 struct efct_scsi_sgl *sgl = io->sgl;
441 struct scatterlist *sg;
442 u32 flags = 0, cnt, curcnt;
443 u64 length = 0;
444
445 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_WRITE_PENDING);
446 efct_lio_io_printf(io, "trans_state=0x%x se_cmd_flags=0x%x\n",
447 cmd->transport_state, cmd->se_cmd_flags);
448
449 if (ocp->seg_cnt == 0) {
450 ocp->seg_cnt = cmd->t_data_nents;
451 ocp->cur_seg = 0;
452 if (efct_lio_sg_map(io)) {
453 efct_lio_io_printf(io, "efct_lio_sg_map failed\n");
454 return -EFAULT;
455 }
456 }
457 curcnt = (ocp->seg_map_cnt - ocp->cur_seg);
458 curcnt = (curcnt < io->sgl_allocated) ? curcnt : io->sgl_allocated;
459
460 for (cnt = 0, sg = cmd->t_data_sg; cnt < ocp->cur_seg; cnt++,
461 sg = sg_next(sg))
462 ;
463
464 for (cnt = 0; cnt < curcnt; cnt++, sg = sg_next(sg)) {
465 sgl[cnt].addr = sg_dma_address(sg);
466 sgl[cnt].dif_addr = 0;
467 sgl[cnt].len = sg_dma_len(sg);
468 length += sgl[cnt].len;
469 ocp->cur_seg++;
470 }
471
472 if (ocp->cur_seg == ocp->seg_cnt)
473 flags = EFCT_SCSI_LAST_DATAPHASE;
474
475 return efct_scsi_recv_wr_data(io, flags, sgl, curcnt, length,
476 efct_lio_datamove_done, NULL);
477}
478
479static int
480efct_lio_queue_data_in(struct se_cmd *cmd)
481{
482 struct efct_scsi_tgt_io *ocp =
483 container_of(cmd, struct efct_scsi_tgt_io, cmd);
484 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
485 struct efct_scsi_sgl *sgl = io->sgl;
486 struct scatterlist *sg = NULL;
487 uint flags = 0, cnt = 0, curcnt = 0;
488 u64 length = 0;
489
490 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_QUEUE_DATA_IN);
491
492 if (ocp->seg_cnt == 0) {
493 if (cmd->data_length) {
494 ocp->seg_cnt = cmd->t_data_nents;
495 ocp->cur_seg = 0;
496 if (efct_lio_sg_map(io)) {
497 efct_lio_io_printf(io,
498 "efct_lio_sg_map failed\n");
499 return -EAGAIN;
500 }
501 } else {
502
503 struct efct_scsi_cmd_resp rsp;
504
505 memset(&rsp, 0, sizeof(rsp));
506 efct_lio_io_printf(io,
507 "cmd : %p length 0, send status\n",
508 cmd);
509 return efct_scsi_send_resp(io, 0, &rsp,
510 efct_lio_status_done, NULL);
511 }
512 }
513 curcnt = min(ocp->seg_map_cnt - ocp->cur_seg, io->sgl_allocated);
514
515 while (cnt < curcnt) {
516 sg = &cmd->t_data_sg[ocp->cur_seg];
517 sgl[cnt].addr = sg_dma_address(sg);
518 sgl[cnt].dif_addr = 0;
519 if (ocp->transferred_len + sg_dma_len(sg) >= cmd->data_length)
520 sgl[cnt].len = cmd->data_length - ocp->transferred_len;
521 else
522 sgl[cnt].len = sg_dma_len(sg);
523
524 ocp->transferred_len += sgl[cnt].len;
525 length += sgl[cnt].len;
526 ocp->cur_seg++;
527 cnt++;
528 if (ocp->transferred_len == cmd->data_length)
529 break;
530 }
531
532 if (ocp->transferred_len == cmd->data_length) {
533 flags = EFCT_SCSI_LAST_DATAPHASE;
534 ocp->seg_cnt = ocp->cur_seg;
535 }
536
537
538 if (cmd->residual_count)
539 flags |= EFCT_SCSI_NO_AUTO_RESPONSE;
540
541 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_SEND_RD_DATA);
542
543 return efct_scsi_send_rd_data(io, flags, sgl, curcnt, length,
544 efct_lio_datamove_done, NULL);
545}
546
547static void
548efct_lio_send_resp(struct efct_io *io, enum efct_scsi_io_status scsi_status,
549 u32 flags)
550{
551 struct efct_scsi_cmd_resp rsp;
552 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
553 struct se_cmd *cmd = &io->tgt_io.cmd;
554 int rc;
555
556 if (flags & EFCT_SCSI_IO_CMPL_RSP_SENT) {
557 ocp->rsp_sent = true;
558 efct_set_lio_io_state(io, EFCT_LIO_STATE_TGT_GENERIC_FREE);
559 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
560 return;
561 }
562
563
564 memset(&rsp, 0, sizeof(rsp));
565 rsp.scsi_status = cmd->scsi_status;
566 rsp.sense_data = (uint8_t *)io->tgt_io.sense_buffer;
567 rsp.sense_data_length = cmd->scsi_sense_length;
568
569
570 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
571 rsp.residual = -cmd->residual_count;
572 else if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT)
573 rsp.residual = cmd->residual_count;
574
575 rc = efct_scsi_send_resp(io, 0, &rsp, efct_lio_status_done, NULL);
576 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_SEND_RSP);
577 if (rc != 0) {
578 efct_lio_io_printf(io, "Read done, send rsp failed %d\n", rc);
579 efct_set_lio_io_state(io, EFCT_LIO_STATE_TGT_GENERIC_FREE);
580 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
581 } else {
582 ocp->rsp_sent = true;
583 }
584}
585
586static int
587efct_lio_datamove_done(struct efct_io *io, enum efct_scsi_io_status scsi_status,
588 u32 flags, void *arg)
589{
590 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
591
592 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_DATA_DONE);
593 if (scsi_status != EFCT_SCSI_STATUS_GOOD) {
594 efct_lio_io_printf(io, "callback completed with error=%d\n",
595 scsi_status);
596 ocp->err = scsi_status;
597 }
598 efct_lio_io_printf(io, "seg_map_cnt=%d\n", ocp->seg_map_cnt);
599 if (ocp->seg_map_cnt) {
600 if (ocp->err == EFCT_SCSI_STATUS_GOOD &&
601 ocp->cur_seg < ocp->seg_cnt) {
602 int rc;
603
604 efct_lio_io_printf(io, "continuing cmd at segm=%d\n",
605 ocp->cur_seg);
606 if (ocp->ddir == DMA_TO_DEVICE)
607 rc = efct_lio_write_pending(&ocp->cmd);
608 else
609 rc = efct_lio_queue_data_in(&ocp->cmd);
610 if (!rc)
611 return 0;
612
613 ocp->err = EFCT_SCSI_STATUS_ERROR;
614 efct_lio_io_printf(io, "could not continue command\n");
615 }
616 efct_lio_sg_unmap(io);
617 }
618
619 if (io->tgt_io.aborting) {
620 efct_lio_io_printf(io, "IO done aborted\n");
621 return 0;
622 }
623
624 if (ocp->ddir == DMA_TO_DEVICE) {
625 efct_lio_io_printf(io, "Write done, trans_state=0x%x\n",
626 io->tgt_io.cmd.transport_state);
627 if (scsi_status != EFCT_SCSI_STATUS_GOOD) {
628 transport_generic_request_failure(&io->tgt_io.cmd,
629 TCM_CHECK_CONDITION_ABORT_CMD);
630 efct_set_lio_io_state(io,
631 EFCT_LIO_STATE_TGT_GENERIC_REQ_FAILURE);
632 } else {
633 efct_set_lio_io_state(io,
634 EFCT_LIO_STATE_TGT_EXECUTE_CMD);
635 target_execute_cmd(&io->tgt_io.cmd);
636 }
637 } else {
638 efct_lio_send_resp(io, scsi_status, flags);
639 }
640 return 0;
641}
642
643static int
644efct_lio_tmf_done(struct efct_io *io, enum efct_scsi_io_status scsi_status,
645 u32 flags, void *arg)
646{
647 efct_lio_tmfio_printf(io, "cmd=%p status=%d, flags=0x%x\n",
648 &io->tgt_io.cmd, scsi_status, flags);
649
650 efct_set_lio_io_state(io, EFCT_LIO_STATE_TGT_GENERIC_FREE);
651 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
652 return 0;
653}
654
655static int
656efct_lio_null_tmf_done(struct efct_io *tmfio,
657 enum efct_scsi_io_status scsi_status,
658 u32 flags, void *arg)
659{
660 efct_lio_tmfio_printf(tmfio, "cmd=%p status=%d, flags=0x%x\n",
661 &tmfio->tgt_io.cmd, scsi_status, flags);
662
663
664 efct_scsi_io_complete(tmfio);
665 return 0;
666}
667
668static int
669efct_lio_queue_status(struct se_cmd *cmd)
670{
671 struct efct_scsi_cmd_resp rsp;
672 struct efct_scsi_tgt_io *ocp =
673 container_of(cmd, struct efct_scsi_tgt_io, cmd);
674 struct efct_io *io = container_of(ocp, struct efct_io, tgt_io);
675 int rc = 0;
676
677 efct_set_lio_io_state(io, EFCT_LIO_STATE_TFO_QUEUE_STATUS);
678 efct_lio_io_printf(io,
679 "status=0x%x trans_state=0x%x se_cmd_flags=0x%x sns_len=%d\n",
680 cmd->scsi_status, cmd->transport_state, cmd->se_cmd_flags,
681 cmd->scsi_sense_length);
682
683 memset(&rsp, 0, sizeof(rsp));
684 rsp.scsi_status = cmd->scsi_status;
685 rsp.sense_data = (u8 *)io->tgt_io.sense_buffer;
686 rsp.sense_data_length = cmd->scsi_sense_length;
687
688
689
690
691 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
692 rsp.residual = -cmd->residual_count;
693 else if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT)
694 rsp.residual = cmd->residual_count;
695
696 rc = efct_scsi_send_resp(io, 0, &rsp, efct_lio_status_done, NULL);
697 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_SEND_RSP);
698 if (rc == 0)
699 ocp->rsp_sent = true;
700 return rc;
701}
702
703static void efct_lio_queue_tm_rsp(struct se_cmd *cmd)
704{
705 struct efct_scsi_tgt_io *ocp =
706 container_of(cmd, struct efct_scsi_tgt_io, cmd);
707 struct efct_io *tmfio = container_of(ocp, struct efct_io, tgt_io);
708 struct se_tmr_req *se_tmr = cmd->se_tmr_req;
709 u8 rspcode;
710
711 efct_lio_tmfio_printf(tmfio, "cmd=%p function=0x%x tmr->response=%d\n",
712 cmd, se_tmr->function, se_tmr->response);
713 switch (se_tmr->response) {
714 case TMR_FUNCTION_COMPLETE:
715 rspcode = EFCT_SCSI_TMF_FUNCTION_COMPLETE;
716 break;
717 case TMR_TASK_DOES_NOT_EXIST:
718 rspcode = EFCT_SCSI_TMF_FUNCTION_IO_NOT_FOUND;
719 break;
720 case TMR_LUN_DOES_NOT_EXIST:
721 rspcode = EFCT_SCSI_TMF_INCORRECT_LOGICAL_UNIT_NUMBER;
722 break;
723 case TMR_FUNCTION_REJECTED:
724 default:
725 rspcode = EFCT_SCSI_TMF_FUNCTION_REJECTED;
726 break;
727 }
728 efct_scsi_send_tmf_resp(tmfio, rspcode, NULL, efct_lio_tmf_done, NULL);
729}
730
731static struct efct *efct_find_wwpn(u64 wwpn)
732{
733 struct efct *efct;
734
735
736 list_for_each_entry(efct, &efct_devices, list_entry) {
737
738 if (wwpn == efct_get_wwpn(&efct->hw))
739 return efct;
740 }
741
742 return NULL;
743}
744
745static struct se_wwn *
746efct_lio_make_nport(struct target_fabric_configfs *tf,
747 struct config_group *group, const char *name)
748{
749 struct efct_lio_nport *lio_nport;
750 struct efct *efct;
751 int ret;
752 u64 wwpn;
753
754 ret = efct_lio_parse_wwn(name, &wwpn, 0);
755 if (ret)
756 return ERR_PTR(ret);
757
758 efct = efct_find_wwpn(wwpn);
759 if (!efct) {
760 pr_err("cannot find EFCT for base wwpn %s\n", name);
761 return ERR_PTR(-ENXIO);
762 }
763
764 lio_nport = kzalloc(sizeof(*lio_nport), GFP_KERNEL);
765 if (!lio_nport)
766 return ERR_PTR(-ENOMEM);
767
768 lio_nport->efct = efct;
769 lio_nport->wwpn = wwpn;
770 efct_format_wwn(lio_nport->wwpn_str, sizeof(lio_nport->wwpn_str),
771 "naa.", wwpn);
772 efct->tgt_efct.lio_nport = lio_nport;
773
774 return &lio_nport->nport_wwn;
775}
776
777static struct se_wwn *
778efct_lio_npiv_make_nport(struct target_fabric_configfs *tf,
779 struct config_group *group, const char *name)
780{
781 struct efct_lio_vport *lio_vport;
782 struct efct *efct;
783 int ret;
784 u64 p_wwpn, npiv_wwpn, npiv_wwnn;
785 char *p, *pbuf, tmp[128];
786 struct efct_lio_vport_list_t *vport_list;
787 struct fc_vport *new_fc_vport;
788 struct fc_vport_identifiers vport_id;
789 unsigned long flags = 0;
790
791 snprintf(tmp, sizeof(tmp), "%s", name);
792 pbuf = &tmp[0];
793
794 p = strsep(&pbuf, "@");
795
796 if (!p || !pbuf) {
797 pr_err("Unable to find separator operator(@)\n");
798 return ERR_PTR(-EINVAL);
799 }
800
801 ret = efct_lio_parse_wwn(p, &p_wwpn, 0);
802 if (ret)
803 return ERR_PTR(ret);
804
805 ret = efct_lio_parse_npiv_wwn(pbuf, strlen(pbuf), &npiv_wwpn,
806 &npiv_wwnn);
807 if (ret)
808 return ERR_PTR(ret);
809
810 efct = efct_find_wwpn(p_wwpn);
811 if (!efct) {
812 pr_err("cannot find EFCT for base wwpn %s\n", name);
813 return ERR_PTR(-ENXIO);
814 }
815
816 lio_vport = kzalloc(sizeof(*lio_vport), GFP_KERNEL);
817 if (!lio_vport)
818 return ERR_PTR(-ENOMEM);
819
820 lio_vport->efct = efct;
821 lio_vport->wwpn = p_wwpn;
822 lio_vport->npiv_wwpn = npiv_wwpn;
823 lio_vport->npiv_wwnn = npiv_wwnn;
824
825 efct_format_wwn(lio_vport->wwpn_str, sizeof(lio_vport->wwpn_str),
826 "naa.", npiv_wwpn);
827
828 vport_list = kzalloc(sizeof(*vport_list), GFP_KERNEL);
829 if (!vport_list) {
830 kfree(lio_vport);
831 return ERR_PTR(-ENOMEM);
832 }
833
834 vport_list->lio_vport = lio_vport;
835
836 memset(&vport_id, 0, sizeof(vport_id));
837 vport_id.port_name = npiv_wwpn;
838 vport_id.node_name = npiv_wwnn;
839 vport_id.roles = FC_PORT_ROLE_FCP_INITIATOR;
840 vport_id.vport_type = FC_PORTTYPE_NPIV;
841 vport_id.disable = false;
842
843 new_fc_vport = fc_vport_create(efct->shost, 0, &vport_id);
844 if (!new_fc_vport) {
845 efc_log_err(efct, "fc_vport_create failed\n");
846 kfree(lio_vport);
847 kfree(vport_list);
848 return ERR_PTR(-ENOMEM);
849 }
850
851 lio_vport->fc_vport = new_fc_vport;
852 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
853 INIT_LIST_HEAD(&vport_list->list_entry);
854 list_add_tail(&vport_list->list_entry, &efct->tgt_efct.vport_list);
855 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
856
857 return &lio_vport->vport_wwn;
858}
859
860static void
861efct_lio_drop_nport(struct se_wwn *wwn)
862{
863 struct efct_lio_nport *lio_nport =
864 container_of(wwn, struct efct_lio_nport, nport_wwn);
865 struct efct *efct = lio_nport->efct;
866
867
868
869
870 kfree(efct->tgt_efct.lio_nport);
871 efct->tgt_efct.lio_nport = NULL;
872}
873
874static void
875efct_lio_npiv_drop_nport(struct se_wwn *wwn)
876{
877 struct efct_lio_vport *lio_vport =
878 container_of(wwn, struct efct_lio_vport, vport_wwn);
879 struct efct_lio_vport_list_t *vport, *next_vport;
880 struct efct *efct = lio_vport->efct;
881 unsigned long flags = 0;
882
883 if (lio_vport->fc_vport)
884 fc_vport_terminate(lio_vport->fc_vport);
885
886 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
887
888 list_for_each_entry_safe(vport, next_vport, &efct->tgt_efct.vport_list,
889 list_entry) {
890 if (vport->lio_vport == lio_vport) {
891 list_del(&vport->list_entry);
892 kfree(vport->lio_vport);
893 kfree(vport);
894 break;
895 }
896 }
897 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
898}
899
900static struct se_portal_group *
901efct_lio_make_tpg(struct se_wwn *wwn, const char *name)
902{
903 struct efct_lio_nport *lio_nport =
904 container_of(wwn, struct efct_lio_nport, nport_wwn);
905 struct efct_lio_tpg *tpg;
906 struct efct *efct;
907 unsigned long n;
908 int ret;
909
910 if (strstr(name, "tpgt_") != name)
911 return ERR_PTR(-EINVAL);
912 if (kstrtoul(name + 5, 10, &n) || n > USHRT_MAX)
913 return ERR_PTR(-EINVAL);
914
915 tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
916 if (!tpg)
917 return ERR_PTR(-ENOMEM);
918
919 tpg->nport = lio_nport;
920 tpg->tpgt = n;
921 tpg->enabled = false;
922
923 tpg->tpg_attrib.generate_node_acls = 1;
924 tpg->tpg_attrib.demo_mode_write_protect = 1;
925 tpg->tpg_attrib.cache_dynamic_acls = 1;
926 tpg->tpg_attrib.demo_mode_login_only = 1;
927 tpg->tpg_attrib.session_deletion_wait = 1;
928
929 ret = core_tpg_register(wwn, &tpg->tpg, SCSI_PROTOCOL_FCP);
930 if (ret < 0) {
931 kfree(tpg);
932 return NULL;
933 }
934 efct = lio_nport->efct;
935 efct->tgt_efct.tpg = tpg;
936 efc_log_debug(efct, "create portal group %d\n", tpg->tpgt);
937
938 xa_init(&efct->lookup);
939 return &tpg->tpg;
940}
941
942static void
943efct_lio_drop_tpg(struct se_portal_group *se_tpg)
944{
945 struct efct_lio_tpg *tpg =
946 container_of(se_tpg, struct efct_lio_tpg, tpg);
947
948 struct efct *efct = tpg->nport->efct;
949
950 efc_log_debug(efct, "drop portal group %d\n", tpg->tpgt);
951 tpg->nport->efct->tgt_efct.tpg = NULL;
952 core_tpg_deregister(se_tpg);
953 xa_destroy(&efct->lookup);
954 kfree(tpg);
955}
956
957static struct se_portal_group *
958efct_lio_npiv_make_tpg(struct se_wwn *wwn, const char *name)
959{
960 struct efct_lio_vport *lio_vport =
961 container_of(wwn, struct efct_lio_vport, vport_wwn);
962 struct efct_lio_tpg *tpg;
963 struct efct *efct;
964 unsigned long n;
965 int ret;
966
967 efct = lio_vport->efct;
968 if (strstr(name, "tpgt_") != name)
969 return ERR_PTR(-EINVAL);
970 if (kstrtoul(name + 5, 10, &n) || n > USHRT_MAX)
971 return ERR_PTR(-EINVAL);
972
973 if (n != 1) {
974 efc_log_err(efct, "Invalid tpgt index: %ld provided\n", n);
975 return ERR_PTR(-EINVAL);
976 }
977
978 tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
979 if (!tpg)
980 return ERR_PTR(-ENOMEM);
981
982 tpg->vport = lio_vport;
983 tpg->tpgt = n;
984 tpg->enabled = false;
985
986 tpg->tpg_attrib.generate_node_acls = 1;
987 tpg->tpg_attrib.demo_mode_write_protect = 1;
988 tpg->tpg_attrib.cache_dynamic_acls = 1;
989 tpg->tpg_attrib.demo_mode_login_only = 1;
990 tpg->tpg_attrib.session_deletion_wait = 1;
991
992 ret = core_tpg_register(wwn, &tpg->tpg, SCSI_PROTOCOL_FCP);
993
994 if (ret < 0) {
995 kfree(tpg);
996 return NULL;
997 }
998 lio_vport->tpg = tpg;
999 efc_log_debug(efct, "create vport portal group %d\n", tpg->tpgt);
1000
1001 return &tpg->tpg;
1002}
1003
1004static void
1005efct_lio_npiv_drop_tpg(struct se_portal_group *se_tpg)
1006{
1007 struct efct_lio_tpg *tpg =
1008 container_of(se_tpg, struct efct_lio_tpg, tpg);
1009
1010 efc_log_debug(tpg->vport->efct, "drop npiv portal group %d\n",
1011 tpg->tpgt);
1012 core_tpg_deregister(se_tpg);
1013 kfree(tpg);
1014}
1015
1016static int
1017efct_lio_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
1018{
1019 struct efct_lio_nacl *nacl;
1020 u64 wwnn;
1021
1022 if (efct_lio_parse_wwn(name, &wwnn, 0) < 0)
1023 return -EINVAL;
1024
1025 nacl = container_of(se_nacl, struct efct_lio_nacl, se_node_acl);
1026 nacl->nport_wwnn = wwnn;
1027
1028 efct_format_wwn(nacl->nport_name, sizeof(nacl->nport_name), "", wwnn);
1029 return 0;
1030}
1031
1032static int efct_lio_check_demo_mode_login_only(struct se_portal_group *stpg)
1033{
1034 struct efct_lio_tpg *tpg = container_of(stpg, struct efct_lio_tpg, tpg);
1035
1036 return tpg->tpg_attrib.demo_mode_login_only;
1037}
1038
1039static int
1040efct_lio_npiv_check_demo_mode_login_only(struct se_portal_group *stpg)
1041{
1042 struct efct_lio_tpg *tpg = container_of(stpg, struct efct_lio_tpg, tpg);
1043
1044 return tpg->tpg_attrib.demo_mode_login_only;
1045}
1046
1047static struct efct_lio_tpg *
1048efct_get_vport_tpg(struct efc_node *node)
1049{
1050 struct efct *efct;
1051 u64 wwpn = node->nport->wwpn;
1052 struct efct_lio_vport_list_t *vport, *next;
1053 struct efct_lio_vport *lio_vport = NULL;
1054 struct efct_lio_tpg *tpg = NULL;
1055 unsigned long flags = 0;
1056
1057 efct = node->efc->base;
1058 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
1059 list_for_each_entry_safe(vport, next, &efct->tgt_efct.vport_list,
1060 list_entry) {
1061 lio_vport = vport->lio_vport;
1062 if (wwpn && lio_vport && lio_vport->npiv_wwpn == wwpn) {
1063 efc_log_debug(efct, "found tpg on vport\n");
1064 tpg = lio_vport->tpg;
1065 break;
1066 }
1067 }
1068 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
1069 return tpg;
1070}
1071
1072static void
1073_efct_tgt_node_free(struct kref *arg)
1074{
1075 struct efct_node *tgt_node = container_of(arg, struct efct_node, ref);
1076 struct efc_node *node = tgt_node->node;
1077
1078 efc_scsi_del_initiator_complete(node->efc, node);
1079 kfree(tgt_node);
1080}
1081
1082static int efct_session_cb(struct se_portal_group *se_tpg,
1083 struct se_session *se_sess, void *private)
1084{
1085 struct efc_node *node = private;
1086 struct efct_node *tgt_node;
1087 struct efct *efct = node->efc->base;
1088
1089 tgt_node = kzalloc(sizeof(*tgt_node), GFP_KERNEL);
1090 if (!tgt_node)
1091 return -ENOMEM;
1092
1093 kref_init(&tgt_node->ref);
1094 tgt_node->release = _efct_tgt_node_free;
1095
1096 tgt_node->session = se_sess;
1097 node->tgt_node = tgt_node;
1098 tgt_node->efct = efct;
1099
1100 tgt_node->node = node;
1101
1102 tgt_node->node_fc_id = node->rnode.fc_id;
1103 tgt_node->port_fc_id = node->nport->fc_id;
1104 tgt_node->vpi = node->nport->indicator;
1105 tgt_node->rpi = node->rnode.indicator;
1106
1107 spin_lock_init(&tgt_node->active_ios_lock);
1108 INIT_LIST_HEAD(&tgt_node->active_ios);
1109
1110 return 0;
1111}
1112
1113int efct_scsi_tgt_new_device(struct efct *efct)
1114{
1115 u32 total_ios;
1116
1117
1118 efct->tgt_efct.max_sge = sli_get_max_sge(&efct->hw.sli);
1119 efct->tgt_efct.max_sgl = sli_get_max_sgl(&efct->hw.sli);
1120
1121
1122 atomic_set(&efct->tgt_efct.ios_in_use, 0);
1123 total_ios = efct->hw.config.n_io;
1124 efc_log_debug(efct, "total_ios=%d\n", total_ios);
1125 efct->tgt_efct.watermark_min =
1126 (total_ios * EFCT_WATERMARK_LOW_PCT) / 100;
1127 efct->tgt_efct.watermark_max =
1128 (total_ios * EFCT_WATERMARK_HIGH_PCT) / 100;
1129 atomic_set(&efct->tgt_efct.io_high_watermark,
1130 efct->tgt_efct.watermark_max);
1131 atomic_set(&efct->tgt_efct.watermark_hit, 0);
1132 atomic_set(&efct->tgt_efct.initiator_count, 0);
1133
1134 lio_wq = create_singlethread_workqueue("efct_lio_worker");
1135 if (!lio_wq) {
1136 efc_log_err(efct, "workqueue create failed\n");
1137 return -EIO;
1138 }
1139
1140 spin_lock_init(&efct->tgt_efct.efct_lio_lock);
1141 INIT_LIST_HEAD(&efct->tgt_efct.vport_list);
1142
1143 return 0;
1144}
1145
1146int efct_scsi_tgt_del_device(struct efct *efct)
1147{
1148 flush_workqueue(lio_wq);
1149
1150 return 0;
1151}
1152
1153int
1154efct_scsi_tgt_new_nport(struct efc *efc, struct efc_nport *nport)
1155{
1156 struct efct *efct = nport->efc->base;
1157
1158 efc_log_debug(efct, "New SPORT: %s bound to %s\n", nport->display_name,
1159 efct->tgt_efct.lio_nport->wwpn_str);
1160
1161 return 0;
1162}
1163
1164void
1165efct_scsi_tgt_del_nport(struct efc *efc, struct efc_nport *nport)
1166{
1167 efc_log_debug(efc, "Del SPORT: %s\n", nport->display_name);
1168}
1169
1170static void efct_lio_setup_session(struct work_struct *work)
1171{
1172 struct efct_lio_wq_data *wq_data =
1173 container_of(work, struct efct_lio_wq_data, work);
1174 struct efct *efct = wq_data->efct;
1175 struct efc_node *node = wq_data->ptr;
1176 char wwpn[WWN_NAME_LEN];
1177 struct efct_lio_tpg *tpg;
1178 struct efct_node *tgt_node;
1179 struct se_portal_group *se_tpg;
1180 struct se_session *se_sess;
1181 int watermark;
1182 int ini_count;
1183 u64 id;
1184
1185
1186
1187
1188 tpg = efct_get_vport_tpg(node);
1189 if (tpg) {
1190 se_tpg = &tpg->tpg;
1191 } else if (efct->tgt_efct.tpg) {
1192 tpg = efct->tgt_efct.tpg;
1193 se_tpg = &tpg->tpg;
1194 } else {
1195 efc_log_err(efct, "failed to init session\n");
1196 return;
1197 }
1198
1199
1200
1201
1202
1203
1204 efct_format_wwn(wwpn, sizeof(wwpn), "", efc_node_get_wwpn(node));
1205
1206 se_sess = target_setup_session(se_tpg, 0, 0, TARGET_PROT_NORMAL, wwpn,
1207 node, efct_session_cb);
1208 if (IS_ERR(se_sess)) {
1209 efc_log_err(efct, "failed to setup session\n");
1210 kfree(wq_data);
1211 efc_scsi_sess_reg_complete(node, -EIO);
1212 return;
1213 }
1214
1215 tgt_node = node->tgt_node;
1216 id = (u64) tgt_node->port_fc_id << 32 | tgt_node->node_fc_id;
1217
1218 efc_log_debug(efct, "new initiator sess=%p node=%p id: %llx\n",
1219 se_sess, node, id);
1220
1221 if (xa_err(xa_store(&efct->lookup, id, tgt_node, GFP_KERNEL)))
1222 efc_log_err(efct, "Node lookup store failed\n");
1223
1224 efc_scsi_sess_reg_complete(node, 0);
1225
1226
1227 ini_count = atomic_add_return(1, &efct->tgt_efct.initiator_count);
1228 watermark = efct->tgt_efct.watermark_max -
1229 ini_count * EFCT_IO_WATERMARK_PER_INITIATOR;
1230 watermark = (efct->tgt_efct.watermark_min > watermark) ?
1231 efct->tgt_efct.watermark_min : watermark;
1232 atomic_set(&efct->tgt_efct.io_high_watermark, watermark);
1233
1234 kfree(wq_data);
1235}
1236
1237int efct_scsi_new_initiator(struct efc *efc, struct efc_node *node)
1238{
1239 struct efct *efct = node->efc->base;
1240 struct efct_lio_wq_data *wq_data;
1241
1242
1243
1244
1245
1246 wq_data = kzalloc(sizeof(*wq_data), GFP_ATOMIC);
1247 if (!wq_data)
1248 return -ENOMEM;
1249
1250 wq_data->ptr = node;
1251 wq_data->efct = efct;
1252 INIT_WORK(&wq_data->work, efct_lio_setup_session);
1253 queue_work(lio_wq, &wq_data->work);
1254 return EFC_SCSI_CALL_ASYNC;
1255}
1256
1257static void efct_lio_remove_session(struct work_struct *work)
1258{
1259 struct efct_lio_wq_data *wq_data =
1260 container_of(work, struct efct_lio_wq_data, work);
1261 struct efct *efct = wq_data->efct;
1262 struct efc_node *node = wq_data->ptr;
1263 struct efct_node *tgt_node;
1264 struct se_session *se_sess;
1265
1266 tgt_node = node->tgt_node;
1267 if (!tgt_node) {
1268
1269
1270
1271
1272 efc_log_err(efct, "unreg session for NULL session\n");
1273 efc_scsi_del_initiator_complete(node->efc, node);
1274 return;
1275 }
1276
1277 se_sess = tgt_node->session;
1278 efc_log_debug(efct, "unreg session se_sess=%p node=%p\n",
1279 se_sess, node);
1280
1281
1282 target_stop_session(se_sess);
1283
1284
1285 target_wait_for_sess_cmds(se_sess);
1286 target_remove_session(se_sess);
1287 tgt_node->session = NULL;
1288 node->tgt_node = NULL;
1289 kref_put(&tgt_node->ref, tgt_node->release);
1290
1291 kfree(wq_data);
1292}
1293
1294int efct_scsi_del_initiator(struct efc *efc, struct efc_node *node, int reason)
1295{
1296 struct efct *efct = node->efc->base;
1297 struct efct_node *tgt_node = node->tgt_node;
1298 struct efct_lio_wq_data *wq_data;
1299 int watermark;
1300 int ini_count;
1301 u64 id;
1302
1303 if (reason == EFCT_SCSI_INITIATOR_MISSING)
1304 return EFC_SCSI_CALL_COMPLETE;
1305
1306 if (!tgt_node) {
1307 efc_log_err(efct, "tgt_node is NULL\n");
1308 return -EIO;
1309 }
1310
1311 wq_data = kzalloc(sizeof(*wq_data), GFP_ATOMIC);
1312 if (!wq_data)
1313 return -ENOMEM;
1314
1315 id = (u64) tgt_node->port_fc_id << 32 | tgt_node->node_fc_id;
1316 xa_erase(&efct->lookup, id);
1317
1318 wq_data->ptr = node;
1319 wq_data->efct = efct;
1320 INIT_WORK(&wq_data->work, efct_lio_remove_session);
1321 queue_work(lio_wq, &wq_data->work);
1322
1323
1324
1325
1326 ini_count = atomic_sub_return(1, &efct->tgt_efct.initiator_count);
1327
1328 watermark = efct->tgt_efct.watermark_max -
1329 ini_count * EFCT_IO_WATERMARK_PER_INITIATOR;
1330 watermark = (efct->tgt_efct.watermark_min > watermark) ?
1331 efct->tgt_efct.watermark_min : watermark;
1332 atomic_set(&efct->tgt_efct.io_high_watermark, watermark);
1333
1334 return EFC_SCSI_CALL_ASYNC;
1335}
1336
1337void efct_scsi_recv_cmd(struct efct_io *io, uint64_t lun, u8 *cdb,
1338 u32 cdb_len, u32 flags)
1339{
1340 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
1341 struct se_cmd *se_cmd = &io->tgt_io.cmd;
1342 struct efct *efct = io->efct;
1343 char *ddir;
1344 struct efct_node *tgt_node;
1345 struct se_session *se_sess;
1346 int rc = 0;
1347
1348 memset(ocp, 0, sizeof(struct efct_scsi_tgt_io));
1349 efct_set_lio_io_state(io, EFCT_LIO_STATE_SCSI_RECV_CMD);
1350 atomic_add_return(1, &efct->tgt_efct.ios_in_use);
1351
1352
1353 io->timeout = efct->target_io_timer_sec;
1354
1355 if (flags & EFCT_SCSI_CMD_SIMPLE)
1356 ocp->task_attr = TCM_SIMPLE_TAG;
1357 else if (flags & EFCT_SCSI_CMD_HEAD_OF_QUEUE)
1358 ocp->task_attr = TCM_HEAD_TAG;
1359 else if (flags & EFCT_SCSI_CMD_ORDERED)
1360 ocp->task_attr = TCM_ORDERED_TAG;
1361 else if (flags & EFCT_SCSI_CMD_ACA)
1362 ocp->task_attr = TCM_ACA_TAG;
1363
1364 switch (flags & (EFCT_SCSI_CMD_DIR_IN | EFCT_SCSI_CMD_DIR_OUT)) {
1365 case EFCT_SCSI_CMD_DIR_IN:
1366 ddir = "FROM_INITIATOR";
1367 ocp->ddir = DMA_TO_DEVICE;
1368 break;
1369 case EFCT_SCSI_CMD_DIR_OUT:
1370 ddir = "TO_INITIATOR";
1371 ocp->ddir = DMA_FROM_DEVICE;
1372 break;
1373 case EFCT_SCSI_CMD_DIR_IN | EFCT_SCSI_CMD_DIR_OUT:
1374 ddir = "BIDIR";
1375 ocp->ddir = DMA_BIDIRECTIONAL;
1376 break;
1377 default:
1378 ddir = "NONE";
1379 ocp->ddir = DMA_NONE;
1380 break;
1381 }
1382
1383 ocp->lun = lun;
1384 efct_lio_io_printf(io, "new cmd=0x%x ddir=%s dl=%u\n",
1385 cdb[0], ddir, io->exp_xfer_len);
1386
1387 tgt_node = io->node;
1388 se_sess = tgt_node->session;
1389 if (!se_sess) {
1390 efc_log_err(efct, "No session found to submit IO se_cmd: %p\n",
1391 &ocp->cmd);
1392 efct_scsi_io_free(io);
1393 return;
1394 }
1395
1396 efct_set_lio_io_state(io, EFCT_LIO_STATE_TGT_SUBMIT_CMD);
1397 rc = target_init_cmd(se_cmd, se_sess, &io->tgt_io.sense_buffer[0],
1398 ocp->lun, io->exp_xfer_len, ocp->task_attr,
1399 ocp->ddir, TARGET_SCF_ACK_KREF);
1400 if (rc) {
1401 efc_log_err(efct, "failed to init cmd se_cmd: %p\n", se_cmd);
1402 efct_scsi_io_free(io);
1403 return;
1404 }
1405
1406 if (target_submit_prep(se_cmd, cdb, NULL, 0, NULL, 0,
1407 NULL, 0, GFP_ATOMIC))
1408 return;
1409
1410 target_submit(se_cmd);
1411}
1412
1413int
1414efct_scsi_recv_tmf(struct efct_io *tmfio, u32 lun, enum efct_scsi_tmf_cmd cmd,
1415 struct efct_io *io_to_abort, u32 flags)
1416{
1417 unsigned char tmr_func;
1418 struct efct *efct = tmfio->efct;
1419 struct efct_scsi_tgt_io *ocp = &tmfio->tgt_io;
1420 struct efct_node *tgt_node;
1421 struct se_session *se_sess;
1422 int rc;
1423
1424 memset(ocp, 0, sizeof(struct efct_scsi_tgt_io));
1425 efct_set_lio_io_state(tmfio, EFCT_LIO_STATE_SCSI_RECV_TMF);
1426 atomic_add_return(1, &efct->tgt_efct.ios_in_use);
1427 efct_lio_tmfio_printf(tmfio, "%s: new tmf %x lun=%u\n",
1428 tmfio->display_name, cmd, lun);
1429
1430 switch (cmd) {
1431 case EFCT_SCSI_TMF_ABORT_TASK:
1432 tmr_func = TMR_ABORT_TASK;
1433 break;
1434 case EFCT_SCSI_TMF_ABORT_TASK_SET:
1435 tmr_func = TMR_ABORT_TASK_SET;
1436 break;
1437 case EFCT_SCSI_TMF_CLEAR_TASK_SET:
1438 tmr_func = TMR_CLEAR_TASK_SET;
1439 break;
1440 case EFCT_SCSI_TMF_LOGICAL_UNIT_RESET:
1441 tmr_func = TMR_LUN_RESET;
1442 break;
1443 case EFCT_SCSI_TMF_CLEAR_ACA:
1444 tmr_func = TMR_CLEAR_ACA;
1445 break;
1446 case EFCT_SCSI_TMF_TARGET_RESET:
1447 tmr_func = TMR_TARGET_WARM_RESET;
1448 break;
1449 case EFCT_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT:
1450 case EFCT_SCSI_TMF_QUERY_TASK_SET:
1451 default:
1452 goto tmf_fail;
1453 }
1454
1455 tmfio->tgt_io.tmf = tmr_func;
1456 tmfio->tgt_io.lun = lun;
1457 tmfio->tgt_io.io_to_abort = io_to_abort;
1458
1459 tgt_node = tmfio->node;
1460
1461 se_sess = tgt_node->session;
1462 if (!se_sess)
1463 return 0;
1464
1465 rc = target_submit_tmr(&ocp->cmd, se_sess, NULL, lun, ocp, tmr_func,
1466 GFP_ATOMIC, tmfio->init_task_tag, TARGET_SCF_ACK_KREF);
1467
1468 efct_set_lio_io_state(tmfio, EFCT_LIO_STATE_TGT_SUBMIT_TMR);
1469 if (rc)
1470 goto tmf_fail;
1471
1472 return 0;
1473
1474tmf_fail:
1475 efct_scsi_send_tmf_resp(tmfio, EFCT_SCSI_TMF_FUNCTION_REJECTED,
1476 NULL, efct_lio_null_tmf_done, NULL);
1477 return 0;
1478}
1479
1480
1481
1482#define DEF_EFCT_TPG_ATTRIB(name) \
1483 \
1484static ssize_t efct_lio_tpg_attrib_##name##_show( \
1485 struct config_item *item, char *page) \
1486{ \
1487 struct se_portal_group *se_tpg = to_tpg(item); \
1488 struct efct_lio_tpg *tpg = container_of(se_tpg, \
1489 struct efct_lio_tpg, tpg); \
1490 \
1491 return sprintf(page, "%u\n", tpg->tpg_attrib.name); \
1492} \
1493 \
1494static ssize_t efct_lio_tpg_attrib_##name##_store( \
1495 struct config_item *item, const char *page, size_t count) \
1496{ \
1497 struct se_portal_group *se_tpg = to_tpg(item); \
1498 struct efct_lio_tpg *tpg = container_of(se_tpg, \
1499 struct efct_lio_tpg, tpg); \
1500 struct efct_lio_tpg_attrib *a = &tpg->tpg_attrib; \
1501 unsigned long val; \
1502 int ret; \
1503 \
1504 ret = kstrtoul(page, 0, &val); \
1505 if (ret < 0) { \
1506 pr_err("kstrtoul() failed with ret: %d\n", ret); \
1507 return ret; \
1508 } \
1509 \
1510 if (val != 0 && val != 1) { \
1511 pr_err("Illegal boolean value %lu\n", val); \
1512 return -EINVAL; \
1513 } \
1514 \
1515 a->name = val; \
1516 \
1517 return count; \
1518} \
1519CONFIGFS_ATTR(efct_lio_tpg_attrib_, name)
1520
1521DEF_EFCT_TPG_ATTRIB(generate_node_acls);
1522DEF_EFCT_TPG_ATTRIB(cache_dynamic_acls);
1523DEF_EFCT_TPG_ATTRIB(demo_mode_write_protect);
1524DEF_EFCT_TPG_ATTRIB(prod_mode_write_protect);
1525DEF_EFCT_TPG_ATTRIB(demo_mode_login_only);
1526DEF_EFCT_TPG_ATTRIB(session_deletion_wait);
1527
1528static struct configfs_attribute *efct_lio_tpg_attrib_attrs[] = {
1529 &efct_lio_tpg_attrib_attr_generate_node_acls,
1530 &efct_lio_tpg_attrib_attr_cache_dynamic_acls,
1531 &efct_lio_tpg_attrib_attr_demo_mode_write_protect,
1532 &efct_lio_tpg_attrib_attr_prod_mode_write_protect,
1533 &efct_lio_tpg_attrib_attr_demo_mode_login_only,
1534 &efct_lio_tpg_attrib_attr_session_deletion_wait,
1535 NULL,
1536};
1537
1538#define DEF_EFCT_NPIV_TPG_ATTRIB(name) \
1539 \
1540static ssize_t efct_lio_npiv_tpg_attrib_##name##_show( \
1541 struct config_item *item, char *page) \
1542{ \
1543 struct se_portal_group *se_tpg = to_tpg(item); \
1544 struct efct_lio_tpg *tpg = container_of(se_tpg, \
1545 struct efct_lio_tpg, tpg); \
1546 \
1547 return sprintf(page, "%u\n", tpg->tpg_attrib.name); \
1548} \
1549 \
1550static ssize_t efct_lio_npiv_tpg_attrib_##name##_store( \
1551 struct config_item *item, const char *page, size_t count) \
1552{ \
1553 struct se_portal_group *se_tpg = to_tpg(item); \
1554 struct efct_lio_tpg *tpg = container_of(se_tpg, \
1555 struct efct_lio_tpg, tpg); \
1556 struct efct_lio_tpg_attrib *a = &tpg->tpg_attrib; \
1557 unsigned long val; \
1558 int ret; \
1559 \
1560 ret = kstrtoul(page, 0, &val); \
1561 if (ret < 0) { \
1562 pr_err("kstrtoul() failed with ret: %d\n", ret); \
1563 return ret; \
1564 } \
1565 \
1566 if (val != 0 && val != 1) { \
1567 pr_err("Illegal boolean value %lu\n", val); \
1568 return -EINVAL; \
1569 } \
1570 \
1571 a->name = val; \
1572 \
1573 return count; \
1574} \
1575CONFIGFS_ATTR(efct_lio_npiv_tpg_attrib_, name)
1576
1577DEF_EFCT_NPIV_TPG_ATTRIB(generate_node_acls);
1578DEF_EFCT_NPIV_TPG_ATTRIB(cache_dynamic_acls);
1579DEF_EFCT_NPIV_TPG_ATTRIB(demo_mode_write_protect);
1580DEF_EFCT_NPIV_TPG_ATTRIB(prod_mode_write_protect);
1581DEF_EFCT_NPIV_TPG_ATTRIB(demo_mode_login_only);
1582DEF_EFCT_NPIV_TPG_ATTRIB(session_deletion_wait);
1583
1584static struct configfs_attribute *efct_lio_npiv_tpg_attrib_attrs[] = {
1585 &efct_lio_npiv_tpg_attrib_attr_generate_node_acls,
1586 &efct_lio_npiv_tpg_attrib_attr_cache_dynamic_acls,
1587 &efct_lio_npiv_tpg_attrib_attr_demo_mode_write_protect,
1588 &efct_lio_npiv_tpg_attrib_attr_prod_mode_write_protect,
1589 &efct_lio_npiv_tpg_attrib_attr_demo_mode_login_only,
1590 &efct_lio_npiv_tpg_attrib_attr_session_deletion_wait,
1591 NULL,
1592};
1593
1594CONFIGFS_ATTR(efct_lio_tpg_, enable);
1595static struct configfs_attribute *efct_lio_tpg_attrs[] = {
1596 &efct_lio_tpg_attr_enable, NULL };
1597CONFIGFS_ATTR(efct_lio_npiv_tpg_, enable);
1598static struct configfs_attribute *efct_lio_npiv_tpg_attrs[] = {
1599 &efct_lio_npiv_tpg_attr_enable, NULL };
1600
1601static const struct target_core_fabric_ops efct_lio_ops = {
1602 .module = THIS_MODULE,
1603 .fabric_name = "efct",
1604 .node_acl_size = sizeof(struct efct_lio_nacl),
1605 .max_data_sg_nents = 65535,
1606 .tpg_get_wwn = efct_lio_get_fabric_wwn,
1607 .tpg_get_tag = efct_lio_get_tag,
1608 .fabric_init_nodeacl = efct_lio_init_nodeacl,
1609 .tpg_check_demo_mode = efct_lio_check_demo_mode,
1610 .tpg_check_demo_mode_cache = efct_lio_check_demo_mode_cache,
1611 .tpg_check_demo_mode_write_protect = efct_lio_check_demo_write_protect,
1612 .tpg_check_prod_mode_write_protect = efct_lio_check_prod_write_protect,
1613 .tpg_get_inst_index = efct_lio_tpg_get_inst_index,
1614 .check_stop_free = efct_lio_check_stop_free,
1615 .aborted_task = efct_lio_aborted_task,
1616 .release_cmd = efct_lio_release_cmd,
1617 .close_session = efct_lio_close_session,
1618 .sess_get_index = efct_lio_sess_get_index,
1619 .write_pending = efct_lio_write_pending,
1620 .set_default_node_attributes = efct_lio_set_default_node_attrs,
1621 .get_cmd_state = efct_lio_get_cmd_state,
1622 .queue_data_in = efct_lio_queue_data_in,
1623 .queue_status = efct_lio_queue_status,
1624 .queue_tm_rsp = efct_lio_queue_tm_rsp,
1625 .fabric_make_wwn = efct_lio_make_nport,
1626 .fabric_drop_wwn = efct_lio_drop_nport,
1627 .fabric_make_tpg = efct_lio_make_tpg,
1628 .fabric_drop_tpg = efct_lio_drop_tpg,
1629 .tpg_check_demo_mode_login_only = efct_lio_check_demo_mode_login_only,
1630 .tpg_check_prot_fabric_only = NULL,
1631 .sess_get_initiator_sid = NULL,
1632 .tfc_tpg_base_attrs = efct_lio_tpg_attrs,
1633 .tfc_tpg_attrib_attrs = efct_lio_tpg_attrib_attrs,
1634};
1635
1636static const struct target_core_fabric_ops efct_lio_npiv_ops = {
1637 .module = THIS_MODULE,
1638 .fabric_name = "efct_npiv",
1639 .node_acl_size = sizeof(struct efct_lio_nacl),
1640 .max_data_sg_nents = 65535,
1641 .tpg_get_wwn = efct_lio_get_npiv_fabric_wwn,
1642 .tpg_get_tag = efct_lio_get_npiv_tag,
1643 .fabric_init_nodeacl = efct_lio_init_nodeacl,
1644 .tpg_check_demo_mode = efct_lio_check_demo_mode,
1645 .tpg_check_demo_mode_cache = efct_lio_check_demo_mode_cache,
1646 .tpg_check_demo_mode_write_protect =
1647 efct_lio_npiv_check_demo_write_protect,
1648 .tpg_check_prod_mode_write_protect =
1649 efct_lio_npiv_check_prod_write_protect,
1650 .tpg_get_inst_index = efct_lio_tpg_get_inst_index,
1651 .check_stop_free = efct_lio_check_stop_free,
1652 .aborted_task = efct_lio_aborted_task,
1653 .release_cmd = efct_lio_release_cmd,
1654 .close_session = efct_lio_close_session,
1655 .sess_get_index = efct_lio_sess_get_index,
1656 .write_pending = efct_lio_write_pending,
1657 .set_default_node_attributes = efct_lio_set_default_node_attrs,
1658 .get_cmd_state = efct_lio_get_cmd_state,
1659 .queue_data_in = efct_lio_queue_data_in,
1660 .queue_status = efct_lio_queue_status,
1661 .queue_tm_rsp = efct_lio_queue_tm_rsp,
1662 .fabric_make_wwn = efct_lio_npiv_make_nport,
1663 .fabric_drop_wwn = efct_lio_npiv_drop_nport,
1664 .fabric_make_tpg = efct_lio_npiv_make_tpg,
1665 .fabric_drop_tpg = efct_lio_npiv_drop_tpg,
1666 .tpg_check_demo_mode_login_only =
1667 efct_lio_npiv_check_demo_mode_login_only,
1668 .tpg_check_prot_fabric_only = NULL,
1669 .sess_get_initiator_sid = NULL,
1670 .tfc_tpg_base_attrs = efct_lio_npiv_tpg_attrs,
1671 .tfc_tpg_attrib_attrs = efct_lio_npiv_tpg_attrib_attrs,
1672};
1673
1674int efct_scsi_tgt_driver_init(void)
1675{
1676 int rc;
1677
1678
1679 rc = target_register_template(&efct_lio_ops);
1680 if (rc < 0) {
1681 pr_err("target_fabric_configfs_register failed with %d\n", rc);
1682 return rc;
1683 }
1684 rc = target_register_template(&efct_lio_npiv_ops);
1685 if (rc < 0) {
1686 pr_err("target_fabric_configfs_register failed with %d\n", rc);
1687 target_unregister_template(&efct_lio_ops);
1688 return rc;
1689 }
1690 return 0;
1691}
1692
1693int efct_scsi_tgt_driver_exit(void)
1694{
1695 target_unregister_template(&efct_lio_ops);
1696 target_unregister_template(&efct_lio_npiv_ops);
1697 return 0;
1698}
1699
