?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390: add 'install' target to 'make help'
[linux/fpc-iii.git] / drivers / scsi / qla2xxx / tcm_qla2xxx.c
blob3ba2e9564b9a78f000c234fa1be7bb05e24eaebd
1 /*******************************************************************************
2 * This file contains tcm implementation using v4 configfs fabric infrastructure
3 * for QLogic target mode HBAs
4 *
5 * (c) Copyright 2010-2013 Datera, Inc.
6 *
7 * Author: Nicholas A. Bellinger <nab@daterainc.com>
8 *
9 * tcm_qla2xxx_parse_wwn() and tcm_qla2xxx_format_wwn() contains code from
10 * the TCM_FC / Open-FCoE.org fabric module.
11 *
12 * Copyright (c) 2010 Cisco Systems, Inc
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 ****************************************************************************/
24
25
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <generated/utsrelease.h>
29 #include <linux/utsname.h>
30 #include <linux/vmalloc.h>
31 #include <linux/init.h>
32 #include <linux/list.h>
33 #include <linux/slab.h>
34 #include <linux/kthread.h>
35 #include <linux/types.h>
36 #include <linux/string.h>
37 #include <linux/configfs.h>
38 #include <linux/ctype.h>
39 #include <asm/unaligned.h>
40 #include <scsi/scsi.h>
41 #include <scsi/scsi_host.h>
42 #include <scsi/scsi_device.h>
43 #include <scsi/scsi_cmnd.h>
44 #include <target/target_core_base.h>
45 #include <target/target_core_fabric.h>
46
47 #include "qla_def.h"
48 #include "qla_target.h"
49 #include "tcm_qla2xxx.h"
50
51 static struct workqueue_struct *tcm_qla2xxx_free_wq;
52 static struct workqueue_struct *tcm_qla2xxx_cmd_wq;
53
54 /*
55 * Parse WWN.
56 * If strict, we require lower-case hex and colon separators to be sure
57 * the name is the same as what would be generated by ft_format_wwn()
58 * so the name and wwn are mapped one-to-one.
59 */
60 static ssize_t tcm_qla2xxx_parse_wwn(const char *name, u64 *wwn, int strict)
61 {
62 const char *cp;
63 char c;
64 u32 nibble;
65 u32 byte = 0;
66 u32 pos = 0;
67 u32 err;
68
69 *wwn = 0;
70 for (cp = name; cp < &name[TCM_QLA2XXX_NAMELEN - 1]; cp++) {
71 c = *cp;
72 if (c == '\n' && cp[1] == '\0')
73 continue;
74 if (strict && pos++ == 2 && byte++ < 7) {
75 pos = 0;
76 if (c == ':')
77 continue;
78 err = 1;
79 goto fail;
80 }
81 if (c == '\0') {
82 err = 2;
83 if (strict && byte != 8)
84 goto fail;
85 return cp - name;
86 }
87 err = 3;
88 if (isdigit(c))
89 nibble = c - '0';
90 else if (isxdigit(c) && (islower(c) || !strict))
91 nibble = tolower(c) - 'a' + 10;
92 else
93 goto fail;
94 *wwn = (*wwn << 4) | nibble;
95 }
96 err = 4;
97 fail:
98 pr_debug("err %u len %zu pos %u byte %u\n",
99 err, cp - name, pos, byte);
100 return -1;
101 }
102
103 static ssize_t tcm_qla2xxx_format_wwn(char *buf, size_t len, u64 wwn)
104 {
105 u8 b[8];
106
107 put_unaligned_be64(wwn, b);
108 return snprintf(buf, len,
109 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
110 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
111 }
112
113 static char *tcm_qla2xxx_get_fabric_name(void)
114 {
115 return "qla2xxx";
116 }
117
118 /*
119 * From drivers/scsi/scsi_transport_fc.c:fc_parse_wwn
120 */
121 static int tcm_qla2xxx_npiv_extract_wwn(const char *ns, u64 *nm)
122 {
123 unsigned int i, j;
124 u8 wwn[8];
125
126 memset(wwn, 0, sizeof(wwn));
127
128 /* Validate and store the new name */
129 for (i = 0, j = 0; i < 16; i++) {
130 int value;
131
132 value = hex_to_bin(*ns++);
133 if (value >= 0)
134 j = (j << 4) | value;
135 else
136 return -EINVAL;
137
138 if (i % 2) {
139 wwn[i/2] = j & 0xff;
140 j = 0;
141 }
142 }
143
144 *nm = wwn_to_u64(wwn);
145 return 0;
146 }
147
148 /*
149 * This parsing logic follows drivers/scsi/scsi_transport_fc.c:
150 * store_fc_host_vport_create()
151 */
152 static int tcm_qla2xxx_npiv_parse_wwn(
153 const char *name,
154 size_t count,
155 u64 *wwpn,
156 u64 *wwnn)
157 {
158 unsigned int cnt = count;
159 int rc;
160
161 *wwpn = 0;
162 *wwnn = 0;
163
164 /* count may include a LF at end of string */
165 if (name[cnt-1] == '\n' || name[cnt-1] == 0)
166 cnt--;
167
168 /* validate we have enough characters for WWPN */
169 if ((cnt != (16+1+16)) || (name[16] != ':'))
170 return -EINVAL;
171
172 rc = tcm_qla2xxx_npiv_extract_wwn(&name[0], wwpn);
173 if (rc != 0)
174 return rc;
175
176 rc = tcm_qla2xxx_npiv_extract_wwn(&name[17], wwnn);
177 if (rc != 0)
178 return rc;
179
180 return 0;
181 }
182
183 static char *tcm_qla2xxx_npiv_get_fabric_name(void)
184 {
185 return "qla2xxx_npiv";
186 }
187
188 static char *tcm_qla2xxx_get_fabric_wwn(struct se_portal_group *se_tpg)
189 {
190 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
191 struct tcm_qla2xxx_tpg, se_tpg);
192 struct tcm_qla2xxx_lport *lport = tpg->lport;
193
194 return lport->lport_naa_name;
195 }
196
197 static u16 tcm_qla2xxx_get_tag(struct se_portal_group *se_tpg)
198 {
199 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
200 struct tcm_qla2xxx_tpg, se_tpg);
201 return tpg->lport_tpgt;
202 }
203
204 static int tcm_qla2xxx_check_demo_mode(struct se_portal_group *se_tpg)
205 {
206 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
207 struct tcm_qla2xxx_tpg, se_tpg);
208
209 return tpg->tpg_attrib.generate_node_acls;
210 }
211
212 static int tcm_qla2xxx_check_demo_mode_cache(struct se_portal_group *se_tpg)
213 {
214 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
215 struct tcm_qla2xxx_tpg, se_tpg);
216
217 return tpg->tpg_attrib.cache_dynamic_acls;
218 }
219
220 static int tcm_qla2xxx_check_demo_write_protect(struct se_portal_group *se_tpg)
221 {
222 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
223 struct tcm_qla2xxx_tpg, se_tpg);
224
225 return tpg->tpg_attrib.demo_mode_write_protect;
226 }
227
228 static int tcm_qla2xxx_check_prod_write_protect(struct se_portal_group *se_tpg)
229 {
230 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
231 struct tcm_qla2xxx_tpg, se_tpg);
232
233 return tpg->tpg_attrib.prod_mode_write_protect;
234 }
235
236 static int tcm_qla2xxx_check_demo_mode_login_only(struct se_portal_group *se_tpg)
237 {
238 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
239 struct tcm_qla2xxx_tpg, se_tpg);
240
241 return tpg->tpg_attrib.demo_mode_login_only;
242 }
243
244 static int tcm_qla2xxx_check_prot_fabric_only(struct se_portal_group *se_tpg)
245 {
246 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
247 struct tcm_qla2xxx_tpg, se_tpg);
248
249 return tpg->tpg_attrib.fabric_prot_type;
250 }
251
252 static u32 tcm_qla2xxx_tpg_get_inst_index(struct se_portal_group *se_tpg)
253 {
254 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
255 struct tcm_qla2xxx_tpg, se_tpg);
256
257 return tpg->lport_tpgt;
258 }
259
260 static void tcm_qla2xxx_complete_mcmd(struct work_struct *work)
261 {
262 struct qla_tgt_mgmt_cmd *mcmd = container_of(work,
263 struct qla_tgt_mgmt_cmd, free_work);
264
265 transport_generic_free_cmd(&mcmd->se_cmd, 0);
266 }
267
268 /*
269 * Called from qla_target_template->free_mcmd(), and will call
270 * tcm_qla2xxx_release_cmd() via normal struct target_core_fabric_ops
271 * release callback. qla_hw_data->hardware_lock is expected to be held
272 */
273 static void tcm_qla2xxx_free_mcmd(struct qla_tgt_mgmt_cmd *mcmd)
274 {
275 INIT_WORK(&mcmd->free_work, tcm_qla2xxx_complete_mcmd);
276 queue_work(tcm_qla2xxx_free_wq, &mcmd->free_work);
277 }
278
279 static void tcm_qla2xxx_complete_free(struct work_struct *work)
280 {
281 struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
282
283 cmd->cmd_in_wq = 0;
284
285 WARN_ON(cmd->cmd_flags & BIT_16);
286
287 cmd->cmd_flags |= BIT_16;
288 transport_generic_free_cmd(&cmd->se_cmd, 0);
289 }
290
291 /*
292 * Called from qla_target_template->free_cmd(), and will call
293 * tcm_qla2xxx_release_cmd via normal struct target_core_fabric_ops
294 * release callback. qla_hw_data->hardware_lock is expected to be held
295 */
296 static void tcm_qla2xxx_free_cmd(struct qla_tgt_cmd *cmd)
297 {
298 cmd->cmd_in_wq = 1;
299 INIT_WORK(&cmd->work, tcm_qla2xxx_complete_free);
300 queue_work(tcm_qla2xxx_free_wq, &cmd->work);
301 }
302
303 /*
304 * Called from struct target_core_fabric_ops->check_stop_free() context
305 */
306 static int tcm_qla2xxx_check_stop_free(struct se_cmd *se_cmd)
307 {
308 struct qla_tgt_cmd *cmd;
309
310 if ((se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) == 0) {
311 cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
312 cmd->cmd_flags |= BIT_14;
313 }
314
315 return target_put_sess_cmd(se_cmd);
316 }
317
318 /* tcm_qla2xxx_release_cmd - Callback from TCM Core to release underlying
319 * fabric descriptor @se_cmd command to release
320 */
321 static void tcm_qla2xxx_release_cmd(struct se_cmd *se_cmd)
322 {
323 struct qla_tgt_cmd *cmd;
324
325 if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) {
326 struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,
327 struct qla_tgt_mgmt_cmd, se_cmd);
328 qlt_free_mcmd(mcmd);
329 return;
330 }
331
332 cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
333 qlt_free_cmd(cmd);
334 }
335
336 static int tcm_qla2xxx_shutdown_session(struct se_session *se_sess)
337 {
338 struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
339 struct scsi_qla_host *vha;
340 unsigned long flags;
341
342 BUG_ON(!sess);
343 vha = sess->vha;
344
345 spin_lock_irqsave(&vha->hw->hardware_lock, flags);
346 target_sess_cmd_list_set_waiting(se_sess);
347 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
348
349 return 1;
350 }
351
352 static void tcm_qla2xxx_close_session(struct se_session *se_sess)
353 {
354 struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
355 struct scsi_qla_host *vha;
356 unsigned long flags;
357
358 BUG_ON(!sess);
359 vha = sess->vha;
360
361 spin_lock_irqsave(&vha->hw->hardware_lock, flags);
362 qlt_unreg_sess(sess);
363 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
364 }
365
366 static u32 tcm_qla2xxx_sess_get_index(struct se_session *se_sess)
367 {
368 return 0;
369 }
370
371 static int tcm_qla2xxx_write_pending(struct se_cmd *se_cmd)
372 {
373 struct qla_tgt_cmd *cmd = container_of(se_cmd,
374 struct qla_tgt_cmd, se_cmd);
375 cmd->cmd_flags |= BIT_3;
376 cmd->bufflen = se_cmd->data_length;
377 cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
378
379 cmd->sg_cnt = se_cmd->t_data_nents;
380 cmd->sg = se_cmd->t_data_sg;
381
382 cmd->prot_sg_cnt = se_cmd->t_prot_nents;
383 cmd->prot_sg = se_cmd->t_prot_sg;
384 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;
385 se_cmd->pi_err = 0;
386
387 /*
388 * qla_target.c:qlt_rdy_to_xfer() will call pci_map_sg() to setup
389 * the SGL mappings into PCIe memory for incoming FCP WRITE data.
390 */
391 return qlt_rdy_to_xfer(cmd);
392 }
393
394 static int tcm_qla2xxx_write_pending_status(struct se_cmd *se_cmd)
395 {
396 unsigned long flags;
397 /*
398 * Check for WRITE_PENDING status to determine if we need to wait for
399 * CTIO aborts to be posted via hardware in tcm_qla2xxx_handle_data().
400 */
401 spin_lock_irqsave(&se_cmd->t_state_lock, flags);
402 if (se_cmd->t_state == TRANSPORT_WRITE_PENDING ||
403 se_cmd->t_state == TRANSPORT_COMPLETE_QF_WP) {
404 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
405 wait_for_completion_timeout(&se_cmd->t_transport_stop_comp,
406 3 * HZ);
407 return 0;
408 }
409 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
410
411 return 0;
412 }
413
414 static void tcm_qla2xxx_set_default_node_attrs(struct se_node_acl *nacl)
415 {
416 return;
417 }
418
419 static int tcm_qla2xxx_get_cmd_state(struct se_cmd *se_cmd)
420 {
421 if (!(se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
422 struct qla_tgt_cmd *cmd = container_of(se_cmd,
423 struct qla_tgt_cmd, se_cmd);
424 return cmd->state;
425 }
426
427 return 0;
428 }
429
430 /*
431 * Called from process context in qla_target.c:qlt_do_work() code
432 */
433 static int tcm_qla2xxx_handle_cmd(scsi_qla_host_t *vha, struct qla_tgt_cmd *cmd,
434 unsigned char *cdb, uint32_t data_length, int fcp_task_attr,
435 int data_dir, int bidi)
436 {
437 struct se_cmd *se_cmd = &cmd->se_cmd;
438 struct se_session *se_sess;
439 struct qla_tgt_sess *sess;
440 int flags = TARGET_SCF_ACK_KREF;
441
442 if (bidi)
443 flags |= TARGET_SCF_BIDI_OP;
444
445 sess = cmd->sess;
446 if (!sess) {
447 pr_err("Unable to locate struct qla_tgt_sess from qla_tgt_cmd\n");
448 return -EINVAL;
449 }
450
451 se_sess = sess->se_sess;
452 if (!se_sess) {
453 pr_err("Unable to locate active struct se_session\n");
454 return -EINVAL;
455 }
456
457 return target_submit_cmd(se_cmd, se_sess, cdb, &cmd->sense_buffer[0],
458 cmd->unpacked_lun, data_length, fcp_task_attr,
459 data_dir, flags);
460 }
461
462 static void tcm_qla2xxx_handle_data_work(struct work_struct *work)
463 {
464 struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
465
466 /*
467 * Ensure that the complete FCP WRITE payload has been received.
468 * Otherwise return an exception via CHECK_CONDITION status.
469 */
470 cmd->cmd_in_wq = 0;
471 cmd->cmd_flags |= BIT_11;
472 if (!cmd->write_data_transferred) {
473 /*
474 * Check if se_cmd has already been aborted via LUN_RESET, and
475 * waiting upon completion in tcm_qla2xxx_write_pending_status()
476 */
477 if (cmd->se_cmd.transport_state & CMD_T_ABORTED) {
478 complete(&cmd->se_cmd.t_transport_stop_comp);
479 return;
480 }
481
482 if (cmd->se_cmd.pi_err)
483 transport_generic_request_failure(&cmd->se_cmd,
484 cmd->se_cmd.pi_err);
485 else
486 transport_generic_request_failure(&cmd->se_cmd,
487 TCM_CHECK_CONDITION_ABORT_CMD);
488
489 return;
490 }
491
492 return target_execute_cmd(&cmd->se_cmd);
493 }
494
495 /*
496 * Called from qla_target.c:qlt_do_ctio_completion()
497 */
498 static void tcm_qla2xxx_handle_data(struct qla_tgt_cmd *cmd)
499 {
500 cmd->cmd_flags |= BIT_10;
501 cmd->cmd_in_wq = 1;
502 INIT_WORK(&cmd->work, tcm_qla2xxx_handle_data_work);
503 queue_work(tcm_qla2xxx_free_wq, &cmd->work);
504 }
505
506 static void tcm_qla2xxx_handle_dif_work(struct work_struct *work)
507 {
508 struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work);
509
510 /* take an extra kref to prevent cmd free too early.
511 * need to wait for SCSI status/check condition to
512 * finish responding generate by transport_generic_request_failure.
513 */
514 kref_get(&cmd->se_cmd.cmd_kref);
515 transport_generic_request_failure(&cmd->se_cmd, cmd->se_cmd.pi_err);
516 }
517
518 /*
519 * Called from qla_target.c:qlt_do_ctio_completion()
520 */
521 static void tcm_qla2xxx_handle_dif_err(struct qla_tgt_cmd *cmd)
522 {
523 INIT_WORK(&cmd->work, tcm_qla2xxx_handle_dif_work);
524 queue_work(tcm_qla2xxx_free_wq, &cmd->work);
525 }
526
527 /*
528 * Called from qla_target.c:qlt_issue_task_mgmt()
529 */
530 static int tcm_qla2xxx_handle_tmr(struct qla_tgt_mgmt_cmd *mcmd, uint32_t lun,
531 uint8_t tmr_func, uint32_t tag)
532 {
533 struct qla_tgt_sess *sess = mcmd->sess;
534 struct se_cmd *se_cmd = &mcmd->se_cmd;
535
536 return target_submit_tmr(se_cmd, sess->se_sess, NULL, lun, mcmd,
537 tmr_func, GFP_ATOMIC, tag, TARGET_SCF_ACK_KREF);
538 }
539
540 static int tcm_qla2xxx_queue_data_in(struct se_cmd *se_cmd)
541 {
542 struct qla_tgt_cmd *cmd = container_of(se_cmd,
543 struct qla_tgt_cmd, se_cmd);
544
545 cmd->cmd_flags |= BIT_4;
546 cmd->bufflen = se_cmd->data_length;
547 cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
548
549 cmd->sg_cnt = se_cmd->t_data_nents;
550 cmd->sg = se_cmd->t_data_sg;
551 cmd->offset = 0;
552
553 cmd->prot_sg_cnt = se_cmd->t_prot_nents;
554 cmd->prot_sg = se_cmd->t_prot_sg;
555 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size;
556 se_cmd->pi_err = 0;
557
558 /*
559 * Now queue completed DATA_IN the qla2xxx LLD and response ring
560 */
561 return qlt_xmit_response(cmd, QLA_TGT_XMIT_DATA|QLA_TGT_XMIT_STATUS,
562 se_cmd->scsi_status);
563 }
564
565 static int tcm_qla2xxx_queue_status(struct se_cmd *se_cmd)
566 {
567 struct qla_tgt_cmd *cmd = container_of(se_cmd,
568 struct qla_tgt_cmd, se_cmd);
569 int xmit_type = QLA_TGT_XMIT_STATUS;
570
571 cmd->bufflen = se_cmd->data_length;
572 cmd->sg = NULL;
573 cmd->sg_cnt = 0;
574 cmd->offset = 0;
575 cmd->dma_data_direction = target_reverse_dma_direction(se_cmd);
576 if (cmd->cmd_flags & BIT_5) {
577 pr_crit("Bit_5 already set for cmd = %p.\n", cmd);
578 dump_stack();
579 }
580 cmd->cmd_flags |= BIT_5;
581
582 if (se_cmd->data_direction == DMA_FROM_DEVICE) {
583 /*
584 * For FCP_READ with CHECK_CONDITION status, clear cmd->bufflen
585 * for qla_tgt_xmit_response LLD code
586 */
587 if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
588 se_cmd->se_cmd_flags &= ~SCF_OVERFLOW_BIT;
589 se_cmd->residual_count = 0;
590 }
591 se_cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
592 se_cmd->residual_count += se_cmd->data_length;
593
594 cmd->bufflen = 0;
595 }
596 /*
597 * Now queue status response to qla2xxx LLD code and response ring
598 */
599 return qlt_xmit_response(cmd, xmit_type, se_cmd->scsi_status);
600 }
601
602 static void tcm_qla2xxx_queue_tm_rsp(struct se_cmd *se_cmd)
603 {
604 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
605 struct qla_tgt_mgmt_cmd *mcmd = container_of(se_cmd,
606 struct qla_tgt_mgmt_cmd, se_cmd);
607
608 pr_debug("queue_tm_rsp: mcmd: %p func: 0x%02x response: 0x%02x\n",
609 mcmd, se_tmr->function, se_tmr->response);
610 /*
611 * Do translation between TCM TM response codes and
612 * QLA2xxx FC TM response codes.
613 */
614 switch (se_tmr->response) {
615 case TMR_FUNCTION_COMPLETE:
616 mcmd->fc_tm_rsp = FC_TM_SUCCESS;
617 break;
618 case TMR_TASK_DOES_NOT_EXIST:
619 mcmd->fc_tm_rsp = FC_TM_BAD_CMD;
620 break;
621 case TMR_FUNCTION_REJECTED:
622 mcmd->fc_tm_rsp = FC_TM_REJECT;
623 break;
624 case TMR_LUN_DOES_NOT_EXIST:
625 default:
626 mcmd->fc_tm_rsp = FC_TM_FAILED;
627 break;
628 }
629 /*
630 * Queue the TM response to QLA2xxx LLD to build a
631 * CTIO response packet.
632 */
633 qlt_xmit_tm_rsp(mcmd);
634 }
635
636 static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd)
637 {
638 struct qla_tgt_cmd *cmd = container_of(se_cmd,
639 struct qla_tgt_cmd, se_cmd);
640 qlt_abort_cmd(cmd);
641 }
642
643 static void tcm_qla2xxx_clear_sess_lookup(struct tcm_qla2xxx_lport *,
644 struct tcm_qla2xxx_nacl *, struct qla_tgt_sess *);
645 /*
646 * Expected to be called with struct qla_hw_data->hardware_lock held
647 */
648 static void tcm_qla2xxx_clear_nacl_from_fcport_map(struct qla_tgt_sess *sess)
649 {
650 struct se_node_acl *se_nacl = sess->se_sess->se_node_acl;
651 struct se_portal_group *se_tpg = se_nacl->se_tpg;
652 struct se_wwn *se_wwn = se_tpg->se_tpg_wwn;
653 struct tcm_qla2xxx_lport *lport = container_of(se_wwn,
654 struct tcm_qla2xxx_lport, lport_wwn);
655 struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
656 struct tcm_qla2xxx_nacl, se_node_acl);
657 void *node;
658
659 pr_debug("fc_rport domain: port_id 0x%06x\n", nacl->nport_id);
660
661 node = btree_remove32(&lport->lport_fcport_map, nacl->nport_id);
662 if (WARN_ON(node && (node != se_nacl))) {
663 /*
664 * The nacl no longer matches what we think it should be.
665 * Most likely a new dynamic acl has been added while
666 * someone dropped the hardware lock. It clearly is a
667 * bug elsewhere, but this bit can't make things worse.
668 */
669 btree_insert32(&lport->lport_fcport_map, nacl->nport_id,
670 node, GFP_ATOMIC);
671 }
672
673 pr_debug("Removed from fcport_map: %p for WWNN: 0x%016LX, port_id: 0x%06x\n",
674 se_nacl, nacl->nport_wwnn, nacl->nport_id);
675 /*
676 * Now clear the se_nacl and session pointers from our HW lport lookup
677 * table mapping for this initiator's fabric S_ID and LOOP_ID entries.
678 *
679 * This is done ahead of callbacks into tcm_qla2xxx_free_session() ->
680 * target_wait_for_sess_cmds() before the session waits for outstanding
681 * I/O to complete, to avoid a race between session shutdown execution
682 * and incoming ATIOs or TMRs picking up a stale se_node_act reference.
683 */
684 tcm_qla2xxx_clear_sess_lookup(lport, nacl, sess);
685 }
686
687 static void tcm_qla2xxx_release_session(struct kref *kref)
688 {
689 struct se_session *se_sess = container_of(kref,
690 struct se_session, sess_kref);
691
692 qlt_unreg_sess(se_sess->fabric_sess_ptr);
693 }
694
695 static void tcm_qla2xxx_put_sess(struct qla_tgt_sess *sess)
696 {
697 if (!sess)
698 return;
699
700 assert_spin_locked(&sess->vha->hw->hardware_lock);
701 kref_put(&sess->se_sess->sess_kref, tcm_qla2xxx_release_session);
702 }
703
704 static void tcm_qla2xxx_shutdown_sess(struct qla_tgt_sess *sess)
705 {
706 assert_spin_locked(&sess->vha->hw->hardware_lock);
707 target_sess_cmd_list_set_waiting(sess->se_sess);
708 }
709
710 static int tcm_qla2xxx_init_nodeacl(struct se_node_acl *se_nacl,
711 const char *name)
712 {
713 struct tcm_qla2xxx_nacl *nacl =
714 container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
715 u64 wwnn;
716
717 if (tcm_qla2xxx_parse_wwn(name, &wwnn, 1) < 0)
718 return -EINVAL;
719
720 nacl->nport_wwnn = wwnn;
721 tcm_qla2xxx_format_wwn(&nacl->nport_name[0], TCM_QLA2XXX_NAMELEN, wwnn);
722
723 return 0;
724 }
725
726 /* Start items for tcm_qla2xxx_tpg_attrib_cit */
727
728 #define DEF_QLA_TPG_ATTRIB(name) \
729 \
730 static ssize_t tcm_qla2xxx_tpg_attrib_##name##_show( \
731 struct config_item *item, char *page) \
732 { \
733 struct se_portal_group *se_tpg = attrib_to_tpg(item); \
734 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg, \
735 struct tcm_qla2xxx_tpg, se_tpg); \
736 \
737 return sprintf(page, "%u\n", tpg->tpg_attrib.name); \
738 } \
739 \
740 static ssize_t tcm_qla2xxx_tpg_attrib_##name##_store( \
741 struct config_item *item, const char *page, size_t count) \
742 { \
743 struct se_portal_group *se_tpg = attrib_to_tpg(item); \
744 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg, \
745 struct tcm_qla2xxx_tpg, se_tpg); \
746 struct tcm_qla2xxx_tpg_attrib *a = &tpg->tpg_attrib; \
747 unsigned long val; \
748 int ret; \
749 \
750 ret = kstrtoul(page, 0, &val); \
751 if (ret < 0) { \
752 pr_err("kstrtoul() failed with" \
753 " ret: %d\n", ret); \
754 return -EINVAL; \
755 } \
756 \
757 if ((val != 0) && (val != 1)) { \
758 pr_err("Illegal boolean value %lu\n", val); \
759 return -EINVAL; \
760 } \
761 \
762 a->name = val; \
763 \
764 return count; \
765 } \
766 CONFIGFS_ATTR(tcm_qla2xxx_tpg_attrib_, name)
767
768 DEF_QLA_TPG_ATTRIB(generate_node_acls);
769 DEF_QLA_TPG_ATTRIB(cache_dynamic_acls);
770 DEF_QLA_TPG_ATTRIB(demo_mode_write_protect);
771 DEF_QLA_TPG_ATTRIB(prod_mode_write_protect);
772 DEF_QLA_TPG_ATTRIB(demo_mode_login_only);
773
774 static struct configfs_attribute *tcm_qla2xxx_tpg_attrib_attrs[] = {
775 &tcm_qla2xxx_tpg_attrib_attr_generate_node_acls,
776 &tcm_qla2xxx_tpg_attrib_attr_cache_dynamic_acls,
777 &tcm_qla2xxx_tpg_attrib_attr_demo_mode_write_protect,
778 &tcm_qla2xxx_tpg_attrib_attr_prod_mode_write_protect,
779 &tcm_qla2xxx_tpg_attrib_attr_demo_mode_login_only,
780 NULL,
781 };
782
783 /* End items for tcm_qla2xxx_tpg_attrib_cit */
784
785 static ssize_t tcm_qla2xxx_tpg_enable_show(struct config_item *item,
786 char *page)
787 {
788 struct se_portal_group *se_tpg = to_tpg(item);
789 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
790 struct tcm_qla2xxx_tpg, se_tpg);
791
792 return snprintf(page, PAGE_SIZE, "%d\n",
793 atomic_read(&tpg->lport_tpg_enabled));
794 }
795
796 static void tcm_qla2xxx_depend_tpg(struct work_struct *work)
797 {
798 struct tcm_qla2xxx_tpg *base_tpg = container_of(work,
799 struct tcm_qla2xxx_tpg, tpg_base_work);
800 struct se_portal_group *se_tpg = &base_tpg->se_tpg;
801 struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha;
802
803 if (!target_depend_item(&se_tpg->tpg_group.cg_item)) {
804 atomic_set(&base_tpg->lport_tpg_enabled, 1);
805 qlt_enable_vha(base_vha);
806 }
807 complete(&base_tpg->tpg_base_comp);
808 }
809
810 static void tcm_qla2xxx_undepend_tpg(struct work_struct *work)
811 {
812 struct tcm_qla2xxx_tpg *base_tpg = container_of(work,
813 struct tcm_qla2xxx_tpg, tpg_base_work);
814 struct se_portal_group *se_tpg = &base_tpg->se_tpg;
815 struct scsi_qla_host *base_vha = base_tpg->lport->qla_vha;
816
817 if (!qlt_stop_phase1(base_vha->vha_tgt.qla_tgt)) {
818 atomic_set(&base_tpg->lport_tpg_enabled, 0);
819 target_undepend_item(&se_tpg->tpg_group.cg_item);
820 }
821 complete(&base_tpg->tpg_base_comp);
822 }
823
824 static ssize_t tcm_qla2xxx_tpg_enable_store(struct config_item *item,
825 const char *page, size_t count)
826 {
827 struct se_portal_group *se_tpg = to_tpg(item);
828 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
829 struct tcm_qla2xxx_tpg, se_tpg);
830 unsigned long op;
831 int rc;
832
833 rc = kstrtoul(page, 0, &op);
834 if (rc < 0) {
835 pr_err("kstrtoul() returned %d\n", rc);
836 return -EINVAL;
837 }
838 if ((op != 1) && (op != 0)) {
839 pr_err("Illegal value for tpg_enable: %lu\n", op);
840 return -EINVAL;
841 }
842 if (op) {
843 if (atomic_read(&tpg->lport_tpg_enabled))
844 return -EEXIST;
845
846 INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_depend_tpg);
847 } else {
848 if (!atomic_read(&tpg->lport_tpg_enabled))
849 return count;
850
851 INIT_WORK(&tpg->tpg_base_work, tcm_qla2xxx_undepend_tpg);
852 }
853 init_completion(&tpg->tpg_base_comp);
854 schedule_work(&tpg->tpg_base_work);
855 wait_for_completion(&tpg->tpg_base_comp);
856
857 if (op) {
858 if (!atomic_read(&tpg->lport_tpg_enabled))
859 return -ENODEV;
860 } else {
861 if (atomic_read(&tpg->lport_tpg_enabled))
862 return -EPERM;
863 }
864 return count;
865 }
866
867 static ssize_t tcm_qla2xxx_tpg_dynamic_sessions_show(struct config_item *item,
868 char *page)
869 {
870 return target_show_dynamic_sessions(to_tpg(item), page);
871 }
872
873 static ssize_t tcm_qla2xxx_tpg_fabric_prot_type_store(struct config_item *item,
874 const char *page, size_t count)
875 {
876 struct se_portal_group *se_tpg = to_tpg(item);
877 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
878 struct tcm_qla2xxx_tpg, se_tpg);
879 unsigned long val;
880 int ret = kstrtoul(page, 0, &val);
881
882 if (ret) {
883 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret);
884 return ret;
885 }
886 if (val != 0 && val != 1 && val != 3) {
887 pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val);
888 return -EINVAL;
889 }
890 tpg->tpg_attrib.fabric_prot_type = val;
891
892 return count;
893 }
894
895 static ssize_t tcm_qla2xxx_tpg_fabric_prot_type_show(struct config_item *item,
896 char *page)
897 {
898 struct se_portal_group *se_tpg = to_tpg(item);
899 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
900 struct tcm_qla2xxx_tpg, se_tpg);
901
902 return sprintf(page, "%d\n", tpg->tpg_attrib.fabric_prot_type);
903 }
904
905 CONFIGFS_ATTR_WO(tcm_qla2xxx_tpg_, enable);
906 CONFIGFS_ATTR_RO(tcm_qla2xxx_tpg_, dynamic_sessions);
907 CONFIGFS_ATTR(tcm_qla2xxx_tpg_, fabric_prot_type);
908
909 static struct configfs_attribute *tcm_qla2xxx_tpg_attrs[] = {
910 &tcm_qla2xxx_tpg_attr_enable,
911 &tcm_qla2xxx_tpg_attr_dynamic_sessions,
912 &tcm_qla2xxx_tpg_attr_fabric_prot_type,
913 NULL,
914 };
915
916 static struct se_portal_group *tcm_qla2xxx_make_tpg(
917 struct se_wwn *wwn,
918 struct config_group *group,
919 const char *name)
920 {
921 struct tcm_qla2xxx_lport *lport = container_of(wwn,
922 struct tcm_qla2xxx_lport, lport_wwn);
923 struct tcm_qla2xxx_tpg *tpg;
924 unsigned long tpgt;
925 int ret;
926
927 if (strstr(name, "tpgt_") != name)
928 return ERR_PTR(-EINVAL);
929 if (kstrtoul(name + 5, 10, &tpgt) || tpgt > USHRT_MAX)
930 return ERR_PTR(-EINVAL);
931
932 if ((tpgt != 1)) {
933 pr_err("In non NPIV mode, a single TPG=1 is used for HW port mappings\n");
934 return ERR_PTR(-ENOSYS);
935 }
936
937 tpg = kzalloc(sizeof(struct tcm_qla2xxx_tpg), GFP_KERNEL);
938 if (!tpg) {
939 pr_err("Unable to allocate struct tcm_qla2xxx_tpg\n");
940 return ERR_PTR(-ENOMEM);
941 }
942 tpg->lport = lport;
943 tpg->lport_tpgt = tpgt;
944 /*
945 * By default allow READ-ONLY TPG demo-mode access w/ cached dynamic
946 * NodeACLs
947 */
948 tpg->tpg_attrib.generate_node_acls = 1;
949 tpg->tpg_attrib.demo_mode_write_protect = 1;
950 tpg->tpg_attrib.cache_dynamic_acls = 1;
951 tpg->tpg_attrib.demo_mode_login_only = 1;
952
953 ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
954 if (ret < 0) {
955 kfree(tpg);
956 return NULL;
957 }
958
959 lport->tpg_1 = tpg;
960
961 return &tpg->se_tpg;
962 }
963
964 static void tcm_qla2xxx_drop_tpg(struct se_portal_group *se_tpg)
965 {
966 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
967 struct tcm_qla2xxx_tpg, se_tpg);
968 struct tcm_qla2xxx_lport *lport = tpg->lport;
969 struct scsi_qla_host *vha = lport->qla_vha;
970 /*
971 * Call into qla2x_target.c LLD logic to shutdown the active
972 * FC Nexuses and disable target mode operation for this qla_hw_data
973 */
974 if (vha->vha_tgt.qla_tgt && !vha->vha_tgt.qla_tgt->tgt_stop)
975 qlt_stop_phase1(vha->vha_tgt.qla_tgt);
976
977 core_tpg_deregister(se_tpg);
978 /*
979 * Clear local TPG=1 pointer for non NPIV mode.
980 */
981 lport->tpg_1 = NULL;
982 kfree(tpg);
983 }
984
985 static ssize_t tcm_qla2xxx_npiv_tpg_enable_show(struct config_item *item,
986 char *page)
987 {
988 return tcm_qla2xxx_tpg_enable_show(item, page);
989 }
990
991 static ssize_t tcm_qla2xxx_npiv_tpg_enable_store(struct config_item *item,
992 const char *page, size_t count)
993 {
994 struct se_portal_group *se_tpg = to_tpg(item);
995 struct se_wwn *se_wwn = se_tpg->se_tpg_wwn;
996 struct tcm_qla2xxx_lport *lport = container_of(se_wwn,
997 struct tcm_qla2xxx_lport, lport_wwn);
998 struct scsi_qla_host *vha = lport->qla_vha;
999 struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
1000 struct tcm_qla2xxx_tpg, se_tpg);
1001 unsigned long op;
1002 int rc;
1003
1004 rc = kstrtoul(page, 0, &op);
1005 if (rc < 0) {
1006 pr_err("kstrtoul() returned %d\n", rc);
1007 return -EINVAL;
1008 }
1009 if ((op != 1) && (op != 0)) {
1010 pr_err("Illegal value for tpg_enable: %lu\n", op);
1011 return -EINVAL;
1012 }
1013 if (op) {
1014 if (atomic_read(&tpg->lport_tpg_enabled))
1015 return -EEXIST;
1016
1017 atomic_set(&tpg->lport_tpg_enabled, 1);
1018 qlt_enable_vha(vha);
1019 } else {
1020 if (!atomic_read(&tpg->lport_tpg_enabled))
1021 return count;
1022
1023 atomic_set(&tpg->lport_tpg_enabled, 0);
1024 qlt_stop_phase1(vha->vha_tgt.qla_tgt);
1025 }
1026
1027 return count;
1028 }
1029
1030 CONFIGFS_ATTR(tcm_qla2xxx_npiv_tpg_, enable);
1031
1032 static struct configfs_attribute *tcm_qla2xxx_npiv_tpg_attrs[] = {
1033 &tcm_qla2xxx_npiv_tpg_attr_enable,
1034 NULL,
1035 };
1036
1037 static struct se_portal_group *tcm_qla2xxx_npiv_make_tpg(
1038 struct se_wwn *wwn,
1039 struct config_group *group,
1040 const char *name)
1041 {
1042 struct tcm_qla2xxx_lport *lport = container_of(wwn,
1043 struct tcm_qla2xxx_lport, lport_wwn);
1044 struct tcm_qla2xxx_tpg *tpg;
1045 unsigned long tpgt;
1046 int ret;
1047
1048 if (strstr(name, "tpgt_") != name)
1049 return ERR_PTR(-EINVAL);
1050 if (kstrtoul(name + 5, 10, &tpgt) || tpgt > USHRT_MAX)
1051 return ERR_PTR(-EINVAL);
1052
1053 tpg = kzalloc(sizeof(struct tcm_qla2xxx_tpg), GFP_KERNEL);
1054 if (!tpg) {
1055 pr_err("Unable to allocate struct tcm_qla2xxx_tpg\n");
1056 return ERR_PTR(-ENOMEM);
1057 }
1058 tpg->lport = lport;
1059 tpg->lport_tpgt = tpgt;
1060
1061 /*
1062 * By default allow READ-ONLY TPG demo-mode access w/ cached dynamic
1063 * NodeACLs
1064 */
1065 tpg->tpg_attrib.generate_node_acls = 1;
1066 tpg->tpg_attrib.demo_mode_write_protect = 1;
1067 tpg->tpg_attrib.cache_dynamic_acls = 1;
1068 tpg->tpg_attrib.demo_mode_login_only = 1;
1069
1070 ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
1071 if (ret < 0) {
1072 kfree(tpg);
1073 return NULL;
1074 }
1075 lport->tpg_1 = tpg;
1076 return &tpg->se_tpg;
1077 }
1078
1079 /*
1080 * Expected to be called with struct qla_hw_data->hardware_lock held
1081 */
1082 static struct qla_tgt_sess *tcm_qla2xxx_find_sess_by_s_id(
1083 scsi_qla_host_t *vha,
1084 const uint8_t *s_id)
1085 {
1086 struct tcm_qla2xxx_lport *lport;
1087 struct se_node_acl *se_nacl;
1088 struct tcm_qla2xxx_nacl *nacl;
1089 u32 key;
1090
1091 lport = vha->vha_tgt.target_lport_ptr;
1092 if (!lport) {
1093 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1094 dump_stack();
1095 return NULL;
1096 }
1097
1098 key = sid_to_key(s_id);
1099 pr_debug("find_sess_by_s_id: 0x%06x\n", key);
1100
1101 se_nacl = btree_lookup32(&lport->lport_fcport_map, key);
1102 if (!se_nacl) {
1103 pr_debug("Unable to locate s_id: 0x%06x\n", key);
1104 return NULL;
1105 }
1106 pr_debug("find_sess_by_s_id: located se_nacl: %p, initiatorname: %s\n",
1107 se_nacl, se_nacl->initiatorname);
1108
1109 nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1110 if (!nacl->qla_tgt_sess) {
1111 pr_err("Unable to locate struct qla_tgt_sess\n");
1112 return NULL;
1113 }
1114
1115 return nacl->qla_tgt_sess;
1116 }
1117
1118 /*
1119 * Expected to be called with struct qla_hw_data->hardware_lock held
1120 */
1121 static void tcm_qla2xxx_set_sess_by_s_id(
1122 struct tcm_qla2xxx_lport *lport,
1123 struct se_node_acl *new_se_nacl,
1124 struct tcm_qla2xxx_nacl *nacl,
1125 struct se_session *se_sess,
1126 struct qla_tgt_sess *qla_tgt_sess,
1127 uint8_t *s_id)
1128 {
1129 u32 key;
1130 void *slot;
1131 int rc;
1132
1133 key = sid_to_key(s_id);
1134 pr_debug("set_sess_by_s_id: %06x\n", key);
1135
1136 slot = btree_lookup32(&lport->lport_fcport_map, key);
1137 if (!slot) {
1138 if (new_se_nacl) {
1139 pr_debug("Setting up new fc_port entry to new_se_nacl\n");
1140 nacl->nport_id = key;
1141 rc = btree_insert32(&lport->lport_fcport_map, key,
1142 new_se_nacl, GFP_ATOMIC);
1143 if (rc)
1144 printk(KERN_ERR "Unable to insert s_id into fcport_map: %06x\n",
1145 (int)key);
1146 } else {
1147 pr_debug("Wiping nonexisting fc_port entry\n");
1148 }
1149
1150 qla_tgt_sess->se_sess = se_sess;
1151 nacl->qla_tgt_sess = qla_tgt_sess;
1152 return;
1153 }
1154
1155 if (nacl->qla_tgt_sess) {
1156 if (new_se_nacl == NULL) {
1157 pr_debug("Clearing existing nacl->qla_tgt_sess and fc_port entry\n");
1158 btree_remove32(&lport->lport_fcport_map, key);
1159 nacl->qla_tgt_sess = NULL;
1160 return;
1161 }
1162 pr_debug("Replacing existing nacl->qla_tgt_sess and fc_port entry\n");
1163 btree_update32(&lport->lport_fcport_map, key, new_se_nacl);
1164 qla_tgt_sess->se_sess = se_sess;
1165 nacl->qla_tgt_sess = qla_tgt_sess;
1166 return;
1167 }
1168
1169 if (new_se_nacl == NULL) {
1170 pr_debug("Clearing existing fc_port entry\n");
1171 btree_remove32(&lport->lport_fcport_map, key);
1172 return;
1173 }
1174
1175 pr_debug("Replacing existing fc_port entry w/o active nacl->qla_tgt_sess\n");
1176 btree_update32(&lport->lport_fcport_map, key, new_se_nacl);
1177 qla_tgt_sess->se_sess = se_sess;
1178 nacl->qla_tgt_sess = qla_tgt_sess;
1179
1180 pr_debug("Setup nacl->qla_tgt_sess %p by s_id for se_nacl: %p, initiatorname: %s\n",
1181 nacl->qla_tgt_sess, new_se_nacl, new_se_nacl->initiatorname);
1182 }
1183
1184 /*
1185 * Expected to be called with struct qla_hw_data->hardware_lock held
1186 */
1187 static struct qla_tgt_sess *tcm_qla2xxx_find_sess_by_loop_id(
1188 scsi_qla_host_t *vha,
1189 const uint16_t loop_id)
1190 {
1191 struct tcm_qla2xxx_lport *lport;
1192 struct se_node_acl *se_nacl;
1193 struct tcm_qla2xxx_nacl *nacl;
1194 struct tcm_qla2xxx_fc_loopid *fc_loopid;
1195
1196 lport = vha->vha_tgt.target_lport_ptr;
1197 if (!lport) {
1198 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1199 dump_stack();
1200 return NULL;
1201 }
1202
1203 pr_debug("find_sess_by_loop_id: Using loop_id: 0x%04x\n", loop_id);
1204
1205 fc_loopid = lport->lport_loopid_map + loop_id;
1206 se_nacl = fc_loopid->se_nacl;
1207 if (!se_nacl) {
1208 pr_debug("Unable to locate se_nacl by loop_id: 0x%04x\n",
1209 loop_id);
1210 return NULL;
1211 }
1212
1213 nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1214
1215 if (!nacl->qla_tgt_sess) {
1216 pr_err("Unable to locate struct qla_tgt_sess\n");
1217 return NULL;
1218 }
1219
1220 return nacl->qla_tgt_sess;
1221 }
1222
1223 /*
1224 * Expected to be called with struct qla_hw_data->hardware_lock held
1225 */
1226 static void tcm_qla2xxx_set_sess_by_loop_id(
1227 struct tcm_qla2xxx_lport *lport,
1228 struct se_node_acl *new_se_nacl,
1229 struct tcm_qla2xxx_nacl *nacl,
1230 struct se_session *se_sess,
1231 struct qla_tgt_sess *qla_tgt_sess,
1232 uint16_t loop_id)
1233 {
1234 struct se_node_acl *saved_nacl;
1235 struct tcm_qla2xxx_fc_loopid *fc_loopid;
1236
1237 pr_debug("set_sess_by_loop_id: Using loop_id: 0x%04x\n", loop_id);
1238
1239 fc_loopid = &((struct tcm_qla2xxx_fc_loopid *)
1240 lport->lport_loopid_map)[loop_id];
1241
1242 saved_nacl = fc_loopid->se_nacl;
1243 if (!saved_nacl) {
1244 pr_debug("Setting up new fc_loopid->se_nacl to new_se_nacl\n");
1245 fc_loopid->se_nacl = new_se_nacl;
1246 if (qla_tgt_sess->se_sess != se_sess)
1247 qla_tgt_sess->se_sess = se_sess;
1248 if (nacl->qla_tgt_sess != qla_tgt_sess)
1249 nacl->qla_tgt_sess = qla_tgt_sess;
1250 return;
1251 }
1252
1253 if (nacl->qla_tgt_sess) {
1254 if (new_se_nacl == NULL) {
1255 pr_debug("Clearing nacl->qla_tgt_sess and fc_loopid->se_nacl\n");
1256 fc_loopid->se_nacl = NULL;
1257 nacl->qla_tgt_sess = NULL;
1258 return;
1259 }
1260
1261 pr_debug("Replacing existing nacl->qla_tgt_sess and fc_loopid->se_nacl\n");
1262 fc_loopid->se_nacl = new_se_nacl;
1263 if (qla_tgt_sess->se_sess != se_sess)
1264 qla_tgt_sess->se_sess = se_sess;
1265 if (nacl->qla_tgt_sess != qla_tgt_sess)
1266 nacl->qla_tgt_sess = qla_tgt_sess;
1267 return;
1268 }
1269
1270 if (new_se_nacl == NULL) {
1271 pr_debug("Clearing fc_loopid->se_nacl\n");
1272 fc_loopid->se_nacl = NULL;
1273 return;
1274 }
1275
1276 pr_debug("Replacing existing fc_loopid->se_nacl w/o active nacl->qla_tgt_sess\n");
1277 fc_loopid->se_nacl = new_se_nacl;
1278 if (qla_tgt_sess->se_sess != se_sess)
1279 qla_tgt_sess->se_sess = se_sess;
1280 if (nacl->qla_tgt_sess != qla_tgt_sess)
1281 nacl->qla_tgt_sess = qla_tgt_sess;
1282
1283 pr_debug("Setup nacl->qla_tgt_sess %p by loop_id for se_nacl: %p, initiatorname: %s\n",
1284 nacl->qla_tgt_sess, new_se_nacl, new_se_nacl->initiatorname);
1285 }
1286
1287 /*
1288 * Should always be called with qla_hw_data->hardware_lock held.
1289 */
1290 static void tcm_qla2xxx_clear_sess_lookup(struct tcm_qla2xxx_lport *lport,
1291 struct tcm_qla2xxx_nacl *nacl, struct qla_tgt_sess *sess)
1292 {
1293 struct se_session *se_sess = sess->se_sess;
1294 unsigned char be_sid[3];
1295
1296 be_sid[0] = sess->s_id.b.domain;
1297 be_sid[1] = sess->s_id.b.area;
1298 be_sid[2] = sess->s_id.b.al_pa;
1299
1300 tcm_qla2xxx_set_sess_by_s_id(lport, NULL, nacl, se_sess,
1301 sess, be_sid);
1302 tcm_qla2xxx_set_sess_by_loop_id(lport, NULL, nacl, se_sess,
1303 sess, sess->loop_id);
1304 }
1305
1306 static void tcm_qla2xxx_free_session(struct qla_tgt_sess *sess)
1307 {
1308 struct qla_tgt *tgt = sess->tgt;
1309 struct qla_hw_data *ha = tgt->ha;
1310 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
1311 struct se_session *se_sess;
1312 struct tcm_qla2xxx_lport *lport;
1313
1314 BUG_ON(in_interrupt());
1315
1316 se_sess = sess->se_sess;
1317 if (!se_sess) {
1318 pr_err("struct qla_tgt_sess->se_sess is NULL\n");
1319 dump_stack();
1320 return;
1321 }
1322
1323 lport = vha->vha_tgt.target_lport_ptr;
1324 if (!lport) {
1325 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1326 dump_stack();
1327 return;
1328 }
1329 target_wait_for_sess_cmds(se_sess);
1330
1331 transport_deregister_session_configfs(sess->se_sess);
1332 transport_deregister_session(sess->se_sess);
1333 }
1334
1335 /*
1336 * Called via qlt_create_sess():ha->qla2x_tmpl->check_initiator_node_acl()
1337 * to locate struct se_node_acl
1338 */
1339 static int tcm_qla2xxx_check_initiator_node_acl(
1340 scsi_qla_host_t *vha,
1341 unsigned char *fc_wwpn,
1342 void *qla_tgt_sess,
1343 uint8_t *s_id,
1344 uint16_t loop_id)
1345 {
1346 struct qla_hw_data *ha = vha->hw;
1347 struct tcm_qla2xxx_lport *lport;
1348 struct tcm_qla2xxx_tpg *tpg;
1349 struct tcm_qla2xxx_nacl *nacl;
1350 struct se_portal_group *se_tpg;
1351 struct se_node_acl *se_nacl;
1352 struct se_session *se_sess;
1353 struct qla_tgt_sess *sess = qla_tgt_sess;
1354 unsigned char port_name[36];
1355 unsigned long flags;
1356 int num_tags = (ha->fw_xcb_count) ? ha->fw_xcb_count :
1357 TCM_QLA2XXX_DEFAULT_TAGS;
1358
1359 lport = vha->vha_tgt.target_lport_ptr;
1360 if (!lport) {
1361 pr_err("Unable to locate struct tcm_qla2xxx_lport\n");
1362 dump_stack();
1363 return -EINVAL;
1364 }
1365 /*
1366 * Locate the TPG=1 reference..
1367 */
1368 tpg = lport->tpg_1;
1369 if (!tpg) {
1370 pr_err("Unable to lcoate struct tcm_qla2xxx_lport->tpg_1\n");
1371 return -EINVAL;
1372 }
1373 se_tpg = &tpg->se_tpg;
1374
1375 se_sess = transport_init_session_tags(num_tags,
1376 sizeof(struct qla_tgt_cmd),
1377 TARGET_PROT_ALL);
1378 if (IS_ERR(se_sess)) {
1379 pr_err("Unable to initialize struct se_session\n");
1380 return PTR_ERR(se_sess);
1381 }
1382 /*
1383 * Format the FCP Initiator port_name into colon seperated values to
1384 * match the format by tcm_qla2xxx explict ConfigFS NodeACLs.
1385 */
1386 memset(&port_name, 0, 36);
1387 snprintf(port_name, sizeof(port_name), "%8phC", fc_wwpn);
1388 /*
1389 * Locate our struct se_node_acl either from an explict NodeACL created
1390 * via ConfigFS, or via running in TPG demo mode.
1391 */
1392 se_sess->se_node_acl = core_tpg_check_initiator_node_acl(se_tpg,
1393 port_name);
1394 if (!se_sess->se_node_acl) {
1395 transport_free_session(se_sess);
1396 return -EINVAL;
1397 }
1398 se_nacl = se_sess->se_node_acl;
1399 nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
1400 /*
1401 * And now setup the new se_nacl and session pointers into our HW lport
1402 * mappings for fabric S_ID and LOOP_ID.
1403 */
1404 spin_lock_irqsave(&ha->hardware_lock, flags);
1405 tcm_qla2xxx_set_sess_by_s_id(lport, se_nacl, nacl, se_sess,
1406 qla_tgt_sess, s_id);
1407 tcm_qla2xxx_set_sess_by_loop_id(lport, se_nacl, nacl, se_sess,
1408 qla_tgt_sess, loop_id);
1409 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1410 /*
1411 * Finally register the new FC Nexus with TCM
1412 */
1413 transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
1414
1415 return 0;
1416 }
1417
1418 static void tcm_qla2xxx_update_sess(struct qla_tgt_sess *sess, port_id_t s_id,
1419 uint16_t loop_id, bool conf_compl_supported)
1420 {
1421 struct qla_tgt *tgt = sess->tgt;
1422 struct qla_hw_data *ha = tgt->ha;
1423 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
1424 struct tcm_qla2xxx_lport *lport = vha->vha_tgt.target_lport_ptr;
1425 struct se_node_acl *se_nacl = sess->se_sess->se_node_acl;
1426 struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
1427 struct tcm_qla2xxx_nacl, se_node_acl);
1428 u32 key;
1429
1430
1431 if (sess->loop_id != loop_id || sess->s_id.b24 != s_id.b24)
1432 pr_info("Updating session %p from port %8phC loop_id %d -> %d s_id %x:%x:%x -> %x:%x:%x\n",
1433 sess, sess->port_name,
1434 sess->loop_id, loop_id, sess->s_id.b.domain,
1435 sess->s_id.b.area, sess->s_id.b.al_pa, s_id.b.domain,
1436 s_id.b.area, s_id.b.al_pa);
1437
1438 if (sess->loop_id != loop_id) {
1439 /*
1440 * Because we can shuffle loop IDs around and we
1441 * update different sessions non-atomically, we might
1442 * have overwritten this session's old loop ID
1443 * already, and we might end up overwriting some other
1444 * session that will be updated later. So we have to
1445 * be extra careful and we can't warn about those things...
1446 */
1447 if (lport->lport_loopid_map[sess->loop_id].se_nacl == se_nacl)
1448 lport->lport_loopid_map[sess->loop_id].se_nacl = NULL;
1449
1450 lport->lport_loopid_map[loop_id].se_nacl = se_nacl;
1451
1452 sess->loop_id = loop_id;
1453 }
1454
1455 if (sess->s_id.b24 != s_id.b24) {
1456 key = (((u32) sess->s_id.b.domain << 16) |
1457 ((u32) sess->s_id.b.area << 8) |
1458 ((u32) sess->s_id.b.al_pa));
1459
1460 if (btree_lookup32(&lport->lport_fcport_map, key))
1461 WARN(btree_remove32(&lport->lport_fcport_map, key) != se_nacl,
1462 "Found wrong se_nacl when updating s_id %x:%x:%x\n",
1463 sess->s_id.b.domain, sess->s_id.b.area, sess->s_id.b.al_pa);
1464 else
1465 WARN(1, "No lport_fcport_map entry for s_id %x:%x:%x\n",
1466 sess->s_id.b.domain, sess->s_id.b.area, sess->s_id.b.al_pa);
1467
1468 key = (((u32) s_id.b.domain << 16) |
1469 ((u32) s_id.b.area << 8) |
1470 ((u32) s_id.b.al_pa));
1471
1472 if (btree_lookup32(&lport->lport_fcport_map, key)) {
1473 WARN(1, "Already have lport_fcport_map entry for s_id %x:%x:%x\n",
1474 s_id.b.domain, s_id.b.area, s_id.b.al_pa);
1475 btree_update32(&lport->lport_fcport_map, key, se_nacl);
1476 } else {
1477 btree_insert32(&lport->lport_fcport_map, key, se_nacl, GFP_ATOMIC);
1478 }
1479
1480 sess->s_id = s_id;
1481 nacl->nport_id = key;
1482 }
1483
1484 sess->conf_compl_supported = conf_compl_supported;
1485
1486 /* Reset logout parameters to default */
1487 sess->logout_on_delete = 1;
1488 sess->keep_nport_handle = 0;
1489 }
1490
1491 /*
1492 * Calls into tcm_qla2xxx used by qla2xxx LLD I/O path.
1493 */
1494 static struct qla_tgt_func_tmpl tcm_qla2xxx_template = {
1495 .handle_cmd = tcm_qla2xxx_handle_cmd,
1496 .handle_data = tcm_qla2xxx_handle_data,
1497 .handle_dif_err = tcm_qla2xxx_handle_dif_err,
1498 .handle_tmr = tcm_qla2xxx_handle_tmr,
1499 .free_cmd = tcm_qla2xxx_free_cmd,
1500 .free_mcmd = tcm_qla2xxx_free_mcmd,
1501 .free_session = tcm_qla2xxx_free_session,
1502 .update_sess = tcm_qla2xxx_update_sess,
1503 .check_initiator_node_acl = tcm_qla2xxx_check_initiator_node_acl,
1504 .find_sess_by_s_id = tcm_qla2xxx_find_sess_by_s_id,
1505 .find_sess_by_loop_id = tcm_qla2xxx_find_sess_by_loop_id,
1506 .clear_nacl_from_fcport_map = tcm_qla2xxx_clear_nacl_from_fcport_map,
1507 .put_sess = tcm_qla2xxx_put_sess,
1508 .shutdown_sess = tcm_qla2xxx_shutdown_sess,
1509 };
1510
1511 static int tcm_qla2xxx_init_lport(struct tcm_qla2xxx_lport *lport)
1512 {
1513 int rc;
1514
1515 rc = btree_init32(&lport->lport_fcport_map);
1516 if (rc) {
1517 pr_err("Unable to initialize lport->lport_fcport_map btree\n");
1518 return rc;
1519 }
1520
1521 lport->lport_loopid_map = vmalloc(sizeof(struct tcm_qla2xxx_fc_loopid) *
1522 65536);
1523 if (!lport->lport_loopid_map) {
1524 pr_err("Unable to allocate lport->lport_loopid_map of %zu bytes\n",
1525 sizeof(struct tcm_qla2xxx_fc_loopid) * 65536);
1526 btree_destroy32(&lport->lport_fcport_map);
1527 return -ENOMEM;
1528 }
1529 memset(lport->lport_loopid_map, 0, sizeof(struct tcm_qla2xxx_fc_loopid)
1530 * 65536);
1531 pr_debug("qla2xxx: Allocated lport_loopid_map of %zu bytes\n",
1532 sizeof(struct tcm_qla2xxx_fc_loopid) * 65536);
1533 return 0;
1534 }
1535
1536 static int tcm_qla2xxx_lport_register_cb(struct scsi_qla_host *vha,
1537 void *target_lport_ptr,
1538 u64 npiv_wwpn, u64 npiv_wwnn)
1539 {
1540 struct qla_hw_data *ha = vha->hw;
1541 struct tcm_qla2xxx_lport *lport =
1542 (struct tcm_qla2xxx_lport *)target_lport_ptr;
1543 /*
1544 * Setup tgt_ops, local pointer to vha and target_lport_ptr
1545 */
1546 ha->tgt.tgt_ops = &tcm_qla2xxx_template;
1547 vha->vha_tgt.target_lport_ptr = target_lport_ptr;
1548 lport->qla_vha = vha;
1549
1550 return 0;
1551 }
1552
1553 static struct se_wwn *tcm_qla2xxx_make_lport(
1554 struct target_fabric_configfs *tf,
1555 struct config_group *group,
1556 const char *name)
1557 {
1558 struct tcm_qla2xxx_lport *lport;
1559 u64 wwpn;
1560 int ret = -ENODEV;
1561
1562 if (tcm_qla2xxx_parse_wwn(name, &wwpn, 1) < 0)
1563 return ERR_PTR(-EINVAL);
1564
1565 lport = kzalloc(sizeof(struct tcm_qla2xxx_lport), GFP_KERNEL);
1566 if (!lport) {
1567 pr_err("Unable to allocate struct tcm_qla2xxx_lport\n");
1568 return ERR_PTR(-ENOMEM);
1569 }
1570 lport->lport_wwpn = wwpn;
1571 tcm_qla2xxx_format_wwn(&lport->lport_name[0], TCM_QLA2XXX_NAMELEN,
1572 wwpn);
1573 sprintf(lport->lport_naa_name, "naa.%016llx", (unsigned long long) wwpn);
1574
1575 ret = tcm_qla2xxx_init_lport(lport);
1576 if (ret != 0)
1577 goto out;
1578
1579 ret = qlt_lport_register(lport, wwpn, 0, 0,
1580 tcm_qla2xxx_lport_register_cb);
1581 if (ret != 0)
1582 goto out_lport;
1583
1584 return &lport->lport_wwn;
1585 out_lport:
1586 vfree(lport->lport_loopid_map);
1587 btree_destroy32(&lport->lport_fcport_map);
1588 out:
1589 kfree(lport);
1590 return ERR_PTR(ret);
1591 }
1592
1593 static void tcm_qla2xxx_drop_lport(struct se_wwn *wwn)
1594 {
1595 struct tcm_qla2xxx_lport *lport = container_of(wwn,
1596 struct tcm_qla2xxx_lport, lport_wwn);
1597 struct scsi_qla_host *vha = lport->qla_vha;
1598 struct se_node_acl *node;
1599 u32 key = 0;
1600
1601 /*
1602 * Call into qla2x_target.c LLD logic to complete the
1603 * shutdown of struct qla_tgt after the call to
1604 * qlt_stop_phase1() from tcm_qla2xxx_drop_tpg() above..
1605 */
1606 if (vha->vha_tgt.qla_tgt && !vha->vha_tgt.qla_tgt->tgt_stopped)
1607 qlt_stop_phase2(vha->vha_tgt.qla_tgt);
1608
1609 qlt_lport_deregister(vha);
1610
1611 vfree(lport->lport_loopid_map);
1612 btree_for_each_safe32(&lport->lport_fcport_map, key, node)
1613 btree_remove32(&lport->lport_fcport_map, key);
1614 btree_destroy32(&lport->lport_fcport_map);
1615 kfree(lport);
1616 }
1617
1618 static int tcm_qla2xxx_lport_register_npiv_cb(struct scsi_qla_host *base_vha,
1619 void *target_lport_ptr,
1620 u64 npiv_wwpn, u64 npiv_wwnn)
1621 {
1622 struct fc_vport *vport;
1623 struct Scsi_Host *sh = base_vha->host;
1624 struct scsi_qla_host *npiv_vha;
1625 struct tcm_qla2xxx_lport *lport =
1626 (struct tcm_qla2xxx_lport *)target_lport_ptr;
1627 struct tcm_qla2xxx_lport *base_lport =
1628 (struct tcm_qla2xxx_lport *)base_vha->vha_tgt.target_lport_ptr;
1629 struct fc_vport_identifiers vport_id;
1630
1631 if (!qla_tgt_mode_enabled(base_vha)) {
1632 pr_err("qla2xxx base_vha not enabled for target mode\n");
1633 return -EPERM;
1634 }
1635
1636 if (!base_lport || !base_lport->tpg_1 ||
1637 !atomic_read(&base_lport->tpg_1->lport_tpg_enabled)) {
1638 pr_err("qla2xxx base_lport or tpg_1 not available\n");
1639 return -EPERM;
1640 }
1641
1642 memset(&vport_id, 0, sizeof(vport_id));
1643 vport_id.port_name = npiv_wwpn;
1644 vport_id.node_name = npiv_wwnn;
1645 vport_id.roles = FC_PORT_ROLE_FCP_INITIATOR;
1646 vport_id.vport_type = FC_PORTTYPE_NPIV;
1647 vport_id.disable = false;
1648
1649 vport = fc_vport_create(sh, 0, &vport_id);
1650 if (!vport) {
1651 pr_err("fc_vport_create failed for qla2xxx_npiv\n");
1652 return -ENODEV;
1653 }
1654 /*
1655 * Setup local pointer to NPIV vhba + target_lport_ptr
1656 */
1657 npiv_vha = (struct scsi_qla_host *)vport->dd_data;
1658 npiv_vha->vha_tgt.target_lport_ptr = target_lport_ptr;
1659 lport->qla_vha = npiv_vha;
1660 scsi_host_get(npiv_vha->host);
1661 return 0;
1662 }
1663
1664
1665 static struct se_wwn *tcm_qla2xxx_npiv_make_lport(
1666 struct target_fabric_configfs *tf,
1667 struct config_group *group,
1668 const char *name)
1669 {
1670 struct tcm_qla2xxx_lport *lport;
1671 u64 phys_wwpn, npiv_wwpn, npiv_wwnn;
1672 char *p, tmp[128];
1673 int ret;
1674
1675 snprintf(tmp, 128, "%s", name);
1676
1677 p = strchr(tmp, '@');
1678 if (!p) {
1679 pr_err("Unable to locate NPIV '@' seperator\n");
1680 return ERR_PTR(-EINVAL);
1681 }
1682 *p++ = '\0';
1683
1684 if (tcm_qla2xxx_parse_wwn(tmp, &phys_wwpn, 1) < 0)
1685 return ERR_PTR(-EINVAL);
1686
1687 if (tcm_qla2xxx_npiv_parse_wwn(p, strlen(p)+1,
1688 &npiv_wwpn, &npiv_wwnn) < 0)
1689 return ERR_PTR(-EINVAL);
1690
1691 lport = kzalloc(sizeof(struct tcm_qla2xxx_lport), GFP_KERNEL);
1692 if (!lport) {
1693 pr_err("Unable to allocate struct tcm_qla2xxx_lport for NPIV\n");
1694 return ERR_PTR(-ENOMEM);
1695 }
1696 lport->lport_npiv_wwpn = npiv_wwpn;
1697 lport->lport_npiv_wwnn = npiv_wwnn;
1698 sprintf(lport->lport_naa_name, "naa.%016llx", (unsigned long long) npiv_wwpn);
1699
1700 ret = tcm_qla2xxx_init_lport(lport);
1701 if (ret != 0)
1702 goto out;
1703
1704 ret = qlt_lport_register(lport, phys_wwpn, npiv_wwpn, npiv_wwnn,
1705 tcm_qla2xxx_lport_register_npiv_cb);
1706 if (ret != 0)
1707 goto out_lport;
1708
1709 return &lport->lport_wwn;
1710 out_lport:
1711 vfree(lport->lport_loopid_map);
1712 btree_destroy32(&lport->lport_fcport_map);
1713 out:
1714 kfree(lport);
1715 return ERR_PTR(ret);
1716 }
1717
1718 static void tcm_qla2xxx_npiv_drop_lport(struct se_wwn *wwn)
1719 {
1720 struct tcm_qla2xxx_lport *lport = container_of(wwn,
1721 struct tcm_qla2xxx_lport, lport_wwn);
1722 struct scsi_qla_host *npiv_vha = lport->qla_vha;
1723 struct qla_hw_data *ha = npiv_vha->hw;
1724 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
1725
1726 scsi_host_put(npiv_vha->host);
1727 /*
1728 * Notify libfc that we want to release the vha->fc_vport
1729 */
1730 fc_vport_terminate(npiv_vha->fc_vport);
1731 scsi_host_put(base_vha->host);
1732 kfree(lport);
1733 }
1734
1735
1736 static ssize_t tcm_qla2xxx_wwn_version_show(struct config_item *item,
1737 char *page)
1738 {
1739 return sprintf(page,
1740 "TCM QLOGIC QLA2XXX NPIV capable fabric module %s on %s/%s on "
1741 UTS_RELEASE"\n", TCM_QLA2XXX_VERSION, utsname()->sysname,
1742 utsname()->machine);
1743 }
1744
1745 CONFIGFS_ATTR_RO(tcm_qla2xxx_wwn_, version);
1746
1747 static struct configfs_attribute *tcm_qla2xxx_wwn_attrs[] = {
1748 &tcm_qla2xxx_wwn_attr_version,
1749 NULL,
1750 };
1751
1752 static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
1753 .module = THIS_MODULE,
1754 .name = "qla2xxx",
1755 .node_acl_size = sizeof(struct tcm_qla2xxx_nacl),
1756 /*
1757 * XXX: Limit assumes single page per scatter-gather-list entry.
1758 * Current maximum is ~4.9 MB per se_cmd->t_data_sg with PAGE_SIZE=4096
1759 */
1760 .max_data_sg_nents = 1200,
1761 .get_fabric_name = tcm_qla2xxx_get_fabric_name,
1762 .tpg_get_wwn = tcm_qla2xxx_get_fabric_wwn,
1763 .tpg_get_tag = tcm_qla2xxx_get_tag,
1764 .tpg_check_demo_mode = tcm_qla2xxx_check_demo_mode,
1765 .tpg_check_demo_mode_cache = tcm_qla2xxx_check_demo_mode_cache,
1766 .tpg_check_demo_mode_write_protect =
1767 tcm_qla2xxx_check_demo_write_protect,
1768 .tpg_check_prod_mode_write_protect =
1769 tcm_qla2xxx_check_prod_write_protect,
1770 .tpg_check_prot_fabric_only = tcm_qla2xxx_check_prot_fabric_only,
1771 .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
1772 .tpg_get_inst_index = tcm_qla2xxx_tpg_get_inst_index,
1773 .check_stop_free = tcm_qla2xxx_check_stop_free,
1774 .release_cmd = tcm_qla2xxx_release_cmd,
1775 .shutdown_session = tcm_qla2xxx_shutdown_session,
1776 .close_session = tcm_qla2xxx_close_session,
1777 .sess_get_index = tcm_qla2xxx_sess_get_index,
1778 .sess_get_initiator_sid = NULL,
1779 .write_pending = tcm_qla2xxx_write_pending,
1780 .write_pending_status = tcm_qla2xxx_write_pending_status,
1781 .set_default_node_attributes = tcm_qla2xxx_set_default_node_attrs,
1782 .get_cmd_state = tcm_qla2xxx_get_cmd_state,
1783 .queue_data_in = tcm_qla2xxx_queue_data_in,
1784 .queue_status = tcm_qla2xxx_queue_status,
1785 .queue_tm_rsp = tcm_qla2xxx_queue_tm_rsp,
1786 .aborted_task = tcm_qla2xxx_aborted_task,
1787 /*
1788 * Setup function pointers for generic logic in
1789 * target_core_fabric_configfs.c
1790 */
1791 .fabric_make_wwn = tcm_qla2xxx_make_lport,
1792 .fabric_drop_wwn = tcm_qla2xxx_drop_lport,
1793 .fabric_make_tpg = tcm_qla2xxx_make_tpg,
1794 .fabric_drop_tpg = tcm_qla2xxx_drop_tpg,
1795 .fabric_init_nodeacl = tcm_qla2xxx_init_nodeacl,
1796
1797 .tfc_wwn_attrs = tcm_qla2xxx_wwn_attrs,
1798 .tfc_tpg_base_attrs = tcm_qla2xxx_tpg_attrs,
1799 .tfc_tpg_attrib_attrs = tcm_qla2xxx_tpg_attrib_attrs,
1800 };
1801
1802 static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
1803 .module = THIS_MODULE,
1804 .name = "qla2xxx_npiv",
1805 .node_acl_size = sizeof(struct tcm_qla2xxx_nacl),
1806 .get_fabric_name = tcm_qla2xxx_npiv_get_fabric_name,
1807 .tpg_get_wwn = tcm_qla2xxx_get_fabric_wwn,
1808 .tpg_get_tag = tcm_qla2xxx_get_tag,
1809 .tpg_check_demo_mode = tcm_qla2xxx_check_demo_mode,
1810 .tpg_check_demo_mode_cache = tcm_qla2xxx_check_demo_mode_cache,
1811 .tpg_check_demo_mode_write_protect = tcm_qla2xxx_check_demo_mode,
1812 .tpg_check_prod_mode_write_protect =
1813 tcm_qla2xxx_check_prod_write_protect,
1814 .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
1815 .tpg_get_inst_index = tcm_qla2xxx_tpg_get_inst_index,
1816 .check_stop_free = tcm_qla2xxx_check_stop_free,
1817 .release_cmd = tcm_qla2xxx_release_cmd,
1818 .shutdown_session = tcm_qla2xxx_shutdown_session,
1819 .close_session = tcm_qla2xxx_close_session,
1820 .sess_get_index = tcm_qla2xxx_sess_get_index,
1821 .sess_get_initiator_sid = NULL,
1822 .write_pending = tcm_qla2xxx_write_pending,
1823 .write_pending_status = tcm_qla2xxx_write_pending_status,
1824 .set_default_node_attributes = tcm_qla2xxx_set_default_node_attrs,
1825 .get_cmd_state = tcm_qla2xxx_get_cmd_state,
1826 .queue_data_in = tcm_qla2xxx_queue_data_in,
1827 .queue_status = tcm_qla2xxx_queue_status,
1828 .queue_tm_rsp = tcm_qla2xxx_queue_tm_rsp,
1829 .aborted_task = tcm_qla2xxx_aborted_task,
1830 /*
1831 * Setup function pointers for generic logic in
1832 * target_core_fabric_configfs.c
1833 */
1834 .fabric_make_wwn = tcm_qla2xxx_npiv_make_lport,
1835 .fabric_drop_wwn = tcm_qla2xxx_npiv_drop_lport,
1836 .fabric_make_tpg = tcm_qla2xxx_npiv_make_tpg,
1837 .fabric_drop_tpg = tcm_qla2xxx_drop_tpg,
1838 .fabric_init_nodeacl = tcm_qla2xxx_init_nodeacl,
1839
1840 .tfc_wwn_attrs = tcm_qla2xxx_wwn_attrs,
1841 .tfc_tpg_base_attrs = tcm_qla2xxx_npiv_tpg_attrs,
1842 };
1843
1844 static int tcm_qla2xxx_register_configfs(void)
1845 {
1846 int ret;
1847
1848 pr_debug("TCM QLOGIC QLA2XXX fabric module %s on %s/%s on "
1849 UTS_RELEASE"\n", TCM_QLA2XXX_VERSION, utsname()->sysname,
1850 utsname()->machine);
1851
1852 ret = target_register_template(&tcm_qla2xxx_ops);
1853 if (ret)
1854 return ret;
1855
1856 ret = target_register_template(&tcm_qla2xxx_npiv_ops);
1857 if (ret)
1858 goto out_fabric;
1859
1860 tcm_qla2xxx_free_wq = alloc_workqueue("tcm_qla2xxx_free",
1861 WQ_MEM_RECLAIM, 0);
1862 if (!tcm_qla2xxx_free_wq) {
1863 ret = -ENOMEM;
1864 goto out_fabric_npiv;
1865 }
1866
1867 tcm_qla2xxx_cmd_wq = alloc_workqueue("tcm_qla2xxx_cmd", 0, 0);
1868 if (!tcm_qla2xxx_cmd_wq) {
1869 ret = -ENOMEM;
1870 goto out_free_wq;
1871 }
1872
1873 return 0;
1874
1875 out_free_wq:
1876 destroy_workqueue(tcm_qla2xxx_free_wq);
1877 out_fabric_npiv:
1878 target_unregister_template(&tcm_qla2xxx_npiv_ops);
1879 out_fabric:
1880 target_unregister_template(&tcm_qla2xxx_ops);
1881 return ret;
1882 }
1883
1884 static void tcm_qla2xxx_deregister_configfs(void)
1885 {
1886 destroy_workqueue(tcm_qla2xxx_cmd_wq);
1887 destroy_workqueue(tcm_qla2xxx_free_wq);
1888
1889 target_unregister_template(&tcm_qla2xxx_ops);
1890 target_unregister_template(&tcm_qla2xxx_npiv_ops);
1891 }
1892
1893 static int __init tcm_qla2xxx_init(void)
1894 {
1895 int ret;
1896
1897 ret = tcm_qla2xxx_register_configfs();
1898 if (ret < 0)
1899 return ret;
1900
1901 return 0;
1902 }
1903
1904 static void __exit tcm_qla2xxx_exit(void)
1905 {
1906 tcm_qla2xxx_deregister_configfs();
1907 }
1908
1909 MODULE_DESCRIPTION("TCM QLA24XX+ series NPIV enabled fabric driver");
1910 MODULE_LICENSE("GPL");
1911 module_init(tcm_qla2xxx_init);
1912 module_exit(tcm_qla2xxx_exit);
Linux with added FPC-III support