]>
Commit | Line | Data |
---|---|---|
d613b6a7 JS |
1 | /******************************************************************* |
2 | * This file is part of the Emulex Linux Device Driver for * | |
d080abe0 JS |
3 | * Fibre Channsel Host Bus Adapters. * |
4 | * Copyright (C) 2017 Broadcom. All Rights Reserved. The term * | |
5 | * “Broadcom” refers to Broadcom Limited and/or its subsidiaries. * | |
d613b6a7 JS |
6 | * Copyright (C) 2004-2016 Emulex. All rights reserved. * |
7 | * EMULEX and SLI are trademarks of Emulex. * | |
d080abe0 | 8 | * www.broadcom.com * |
d613b6a7 JS |
9 | * Portions Copyright (C) 2004-2005 Christoph Hellwig * |
10 | * * | |
11 | * This program is free software; you can redistribute it and/or * | |
12 | * modify it under the terms of version 2 of the GNU General * | |
13 | * Public License as published by the Free Software Foundation. * | |
14 | * This program is distributed in the hope that it will be useful. * | |
15 | * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * | |
16 | * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * | |
17 | * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * | |
18 | * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * | |
19 | * TO BE LEGALLY INVALID. See the GNU General Public License for * | |
20 | * more details, a copy of which can be found in the file COPYING * | |
21 | * included with this package. * | |
22 | ********************************************************************/ | |
23 | #include <linux/pci.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/delay.h> | |
27 | #include <asm/unaligned.h> | |
28 | #include <linux/crc-t10dif.h> | |
29 | #include <net/checksum.h> | |
30 | ||
31 | #include <scsi/scsi.h> | |
32 | #include <scsi/scsi_device.h> | |
33 | #include <scsi/scsi_eh.h> | |
34 | #include <scsi/scsi_host.h> | |
35 | #include <scsi/scsi_tcq.h> | |
36 | #include <scsi/scsi_transport_fc.h> | |
37 | #include <scsi/fc/fc_fs.h> | |
38 | ||
39 | #include <../drivers/nvme/host/nvme.h> | |
40 | #include <linux/nvme-fc-driver.h> | |
41 | ||
42 | #include "lpfc_version.h" | |
43 | #include "lpfc_hw4.h" | |
44 | #include "lpfc_hw.h" | |
45 | #include "lpfc_sli.h" | |
46 | #include "lpfc_sli4.h" | |
47 | #include "lpfc_nl.h" | |
48 | #include "lpfc_disc.h" | |
49 | #include "lpfc.h" | |
50 | #include "lpfc_scsi.h" | |
51 | #include "lpfc_nvme.h" | |
52 | #include "lpfc_nvmet.h" | |
53 | #include "lpfc_logmsg.h" | |
54 | #include "lpfc_crtn.h" | |
55 | #include "lpfc_vport.h" | |
2b65e182 | 56 | #include "lpfc_debugfs.h" |
d613b6a7 JS |
57 | |
58 | static struct lpfc_iocbq *lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *, | |
59 | struct lpfc_nvmet_rcv_ctx *, | |
60 | dma_addr_t rspbuf, | |
61 | uint16_t rspsize); | |
62 | static struct lpfc_iocbq *lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *, | |
63 | struct lpfc_nvmet_rcv_ctx *); | |
64 | static int lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *, | |
65 | struct lpfc_nvmet_rcv_ctx *, | |
66 | uint32_t, uint16_t); | |
67 | static int lpfc_nvmet_unsol_fcp_issue_abort(struct lpfc_hba *, | |
68 | struct lpfc_nvmet_rcv_ctx *, | |
69 | uint32_t, uint16_t); | |
70 | static int lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *, | |
71 | struct lpfc_nvmet_rcv_ctx *, | |
72 | uint32_t, uint16_t); | |
73 | ||
86c67379 JS |
74 | void |
75 | lpfc_nvmet_defer_release(struct lpfc_hba *phba, struct lpfc_nvmet_rcv_ctx *ctxp) | |
76 | { | |
77 | unsigned long iflag; | |
78 | ||
79 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, | |
80 | "6313 NVMET Defer ctx release xri x%x flg x%x\n", | |
81 | ctxp->oxid, ctxp->flag); | |
82 | ||
83 | spin_lock_irqsave(&phba->sli4_hba.abts_nvme_buf_list_lock, iflag); | |
84 | if (ctxp->flag & LPFC_NVMET_CTX_RLS) { | |
85 | spin_unlock_irqrestore(&phba->sli4_hba.abts_nvme_buf_list_lock, | |
86 | iflag); | |
87 | return; | |
88 | } | |
89 | ctxp->flag |= LPFC_NVMET_CTX_RLS; | |
90 | list_add_tail(&ctxp->list, &phba->sli4_hba.lpfc_abts_nvmet_ctx_list); | |
91 | spin_unlock_irqrestore(&phba->sli4_hba.abts_nvme_buf_list_lock, iflag); | |
92 | } | |
93 | ||
d613b6a7 JS |
94 | /** |
95 | * lpfc_nvmet_xmt_ls_rsp_cmp - Completion handler for LS Response | |
96 | * @phba: Pointer to HBA context object. | |
97 | * @cmdwqe: Pointer to driver command WQE object. | |
98 | * @wcqe: Pointer to driver response CQE object. | |
99 | * | |
100 | * The function is called from SLI ring event handler with no | |
101 | * lock held. This function is the completion handler for NVME LS commands | |
102 | * The function frees memory resources used for the NVME commands. | |
103 | **/ | |
104 | static void | |
105 | lpfc_nvmet_xmt_ls_rsp_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
106 | struct lpfc_wcqe_complete *wcqe) | |
107 | { | |
108 | struct lpfc_nvmet_tgtport *tgtp; | |
109 | struct nvmefc_tgt_ls_req *rsp; | |
110 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
111 | uint32_t status, result; | |
112 | ||
113 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
114 | result = wcqe->parameter; | |
115 | if (!phba->targetport) | |
116 | goto out; | |
117 | ||
118 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
119 | ||
120 | if (status) | |
121 | atomic_inc(&tgtp->xmt_ls_rsp_error); | |
122 | else | |
123 | atomic_inc(&tgtp->xmt_ls_rsp_cmpl); | |
124 | ||
125 | out: | |
126 | ctxp = cmdwqe->context2; | |
127 | rsp = &ctxp->ctx.ls_req; | |
128 | ||
2b65e182 JS |
129 | lpfc_nvmeio_data(phba, "NVMET LS CMPL: xri x%x stat x%x result x%x\n", |
130 | ctxp->oxid, status, result); | |
131 | ||
d613b6a7 JS |
132 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, |
133 | "6038 %s: Entrypoint: ctx %p status %x/%x\n", __func__, | |
134 | ctxp, status, result); | |
135 | ||
136 | lpfc_nlp_put(cmdwqe->context1); | |
137 | cmdwqe->context2 = NULL; | |
138 | cmdwqe->context3 = NULL; | |
139 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
140 | rsp->done(rsp); | |
141 | kfree(ctxp); | |
142 | } | |
143 | ||
144 | /** | |
6c621a22 | 145 | * lpfc_nvmet_ctxbuf_post - Repost a NVMET RQ DMA buffer and clean up context |
d613b6a7 JS |
146 | * @phba: HBA buffer is associated with |
147 | * @ctxp: context to clean up | |
148 | * @mp: Buffer to free | |
149 | * | |
150 | * Description: Frees the given DMA buffer in the appropriate way given by | |
151 | * reposting it to its associated RQ so it can be reused. | |
152 | * | |
153 | * Notes: Takes phba->hbalock. Can be called with or without other locks held. | |
154 | * | |
155 | * Returns: None | |
156 | **/ | |
157 | void | |
6c621a22 | 158 | lpfc_nvmet_ctxbuf_post(struct lpfc_hba *phba, struct lpfc_nvmet_ctxbuf *ctx_buf) |
d613b6a7 | 159 | { |
eeeb51d8 | 160 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
6c621a22 | 161 | struct lpfc_nvmet_rcv_ctx *ctxp = ctx_buf->context; |
a8cf5dfe JS |
162 | struct lpfc_nvmet_tgtport *tgtp; |
163 | struct fc_frame_header *fc_hdr; | |
164 | struct rqb_dmabuf *nvmebuf; | |
165 | struct lpfc_dmabuf *hbufp; | |
166 | uint32_t *payload; | |
167 | uint32_t size, oxid, sid, rc; | |
6c621a22 JS |
168 | unsigned long iflag; |
169 | ||
170 | if (ctxp->txrdy) { | |
171 | pci_pool_free(phba->txrdy_payload_pool, ctxp->txrdy, | |
172 | ctxp->txrdy_phys); | |
173 | ctxp->txrdy = NULL; | |
174 | ctxp->txrdy_phys = 0; | |
d613b6a7 | 175 | } |
6c621a22 JS |
176 | ctxp->state = LPFC_NVMET_STE_FREE; |
177 | ||
a8cf5dfe JS |
178 | spin_lock_irqsave(&phba->sli4_hba.nvmet_io_wait_lock, iflag); |
179 | if (phba->sli4_hba.nvmet_io_wait_cnt) { | |
180 | hbufp = &nvmebuf->hbuf; | |
181 | list_remove_head(&phba->sli4_hba.lpfc_nvmet_io_wait_list, | |
182 | nvmebuf, struct rqb_dmabuf, | |
183 | hbuf.list); | |
184 | phba->sli4_hba.nvmet_io_wait_cnt--; | |
185 | spin_unlock_irqrestore(&phba->sli4_hba.nvmet_io_wait_lock, | |
186 | iflag); | |
187 | ||
188 | fc_hdr = (struct fc_frame_header *)(nvmebuf->hbuf.virt); | |
189 | oxid = be16_to_cpu(fc_hdr->fh_ox_id); | |
190 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
191 | payload = (uint32_t *)(nvmebuf->dbuf.virt); | |
192 | size = nvmebuf->bytes_recv; | |
193 | sid = sli4_sid_from_fc_hdr(fc_hdr); | |
194 | ||
195 | ctxp = (struct lpfc_nvmet_rcv_ctx *)ctx_buf->context; | |
196 | memset(ctxp, 0, sizeof(ctxp->ctx)); | |
197 | ctxp->wqeq = NULL; | |
198 | ctxp->txrdy = NULL; | |
199 | ctxp->offset = 0; | |
200 | ctxp->phba = phba; | |
201 | ctxp->size = size; | |
202 | ctxp->oxid = oxid; | |
203 | ctxp->sid = sid; | |
204 | ctxp->state = LPFC_NVMET_STE_RCV; | |
205 | ctxp->entry_cnt = 1; | |
206 | ctxp->flag = 0; | |
207 | ctxp->ctxbuf = ctx_buf; | |
208 | spin_lock_init(&ctxp->ctxlock); | |
209 | ||
210 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS | |
211 | if (phba->ktime_on) { | |
212 | ctxp->ts_cmd_nvme = ktime_get_ns(); | |
213 | ctxp->ts_isr_cmd = ctxp->ts_cmd_nvme; | |
214 | ctxp->ts_nvme_data = 0; | |
215 | ctxp->ts_data_wqput = 0; | |
216 | ctxp->ts_isr_data = 0; | |
217 | ctxp->ts_data_nvme = 0; | |
218 | ctxp->ts_nvme_status = 0; | |
219 | ctxp->ts_status_wqput = 0; | |
220 | ctxp->ts_isr_status = 0; | |
221 | ctxp->ts_status_nvme = 0; | |
d613b6a7 | 222 | } |
a8cf5dfe JS |
223 | #endif |
224 | atomic_inc(&tgtp->rcv_fcp_cmd_in); | |
225 | /* | |
226 | * The calling sequence should be: | |
227 | * nvmet_fc_rcv_fcp_req->lpfc_nvmet_xmt_fcp_op/cmp- req->done | |
228 | * lpfc_nvmet_xmt_fcp_op_cmp should free the allocated ctxp. | |
229 | * When we return from nvmet_fc_rcv_fcp_req, all relevant info | |
230 | * the NVME command / FC header is stored. | |
231 | * A buffer has already been reposted for this IO, so just free | |
232 | * the nvmebuf. | |
233 | */ | |
234 | rc = nvmet_fc_rcv_fcp_req(phba->targetport, &ctxp->ctx.fcp_req, | |
235 | payload, size); | |
236 | ||
237 | /* Process FCP command */ | |
238 | if (rc == 0) { | |
239 | atomic_inc(&tgtp->rcv_fcp_cmd_out); | |
240 | nvmebuf->hrq->rqbp->rqb_free_buffer(phba, nvmebuf); | |
241 | return; | |
242 | } | |
243 | ||
244 | atomic_inc(&tgtp->rcv_fcp_cmd_drop); | |
245 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
246 | "2582 FCP Drop IO x%x: err x%x: x%x x%x x%x\n", | |
247 | ctxp->oxid, rc, | |
248 | atomic_read(&tgtp->rcv_fcp_cmd_in), | |
249 | atomic_read(&tgtp->rcv_fcp_cmd_out), | |
250 | atomic_read(&tgtp->xmt_fcp_release)); | |
251 | ||
252 | lpfc_nvmet_defer_release(phba, ctxp); | |
253 | lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, sid, oxid); | |
254 | nvmebuf->hrq->rqbp->rqb_free_buffer(phba, nvmebuf); | |
255 | return; | |
d613b6a7 | 256 | } |
a8cf5dfe JS |
257 | spin_unlock_irqrestore(&phba->sli4_hba.nvmet_io_wait_lock, iflag); |
258 | ||
6c621a22 JS |
259 | spin_lock_irqsave(&phba->sli4_hba.nvmet_io_lock, iflag); |
260 | list_add_tail(&ctx_buf->list, | |
261 | &phba->sli4_hba.lpfc_nvmet_ctx_list); | |
262 | phba->sli4_hba.nvmet_ctx_cnt++; | |
263 | spin_unlock_irqrestore(&phba->sli4_hba.nvmet_io_lock, iflag); | |
eeeb51d8 | 264 | #endif |
d613b6a7 JS |
265 | } |
266 | ||
2b65e182 JS |
267 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
268 | static void | |
269 | lpfc_nvmet_ktime(struct lpfc_hba *phba, | |
270 | struct lpfc_nvmet_rcv_ctx *ctxp) | |
271 | { | |
272 | uint64_t seg1, seg2, seg3, seg4, seg5; | |
273 | uint64_t seg6, seg7, seg8, seg9, seg10; | |
274 | ||
275 | if (!phba->ktime_on) | |
276 | return; | |
277 | ||
278 | if (!ctxp->ts_isr_cmd || !ctxp->ts_cmd_nvme || | |
279 | !ctxp->ts_nvme_data || !ctxp->ts_data_wqput || | |
280 | !ctxp->ts_isr_data || !ctxp->ts_data_nvme || | |
281 | !ctxp->ts_nvme_status || !ctxp->ts_status_wqput || | |
282 | !ctxp->ts_isr_status || !ctxp->ts_status_nvme) | |
283 | return; | |
284 | ||
285 | if (ctxp->ts_isr_cmd > ctxp->ts_cmd_nvme) | |
286 | return; | |
287 | if (ctxp->ts_cmd_nvme > ctxp->ts_nvme_data) | |
288 | return; | |
289 | if (ctxp->ts_nvme_data > ctxp->ts_data_wqput) | |
290 | return; | |
291 | if (ctxp->ts_data_wqput > ctxp->ts_isr_data) | |
292 | return; | |
293 | if (ctxp->ts_isr_data > ctxp->ts_data_nvme) | |
294 | return; | |
295 | if (ctxp->ts_data_nvme > ctxp->ts_nvme_status) | |
296 | return; | |
297 | if (ctxp->ts_nvme_status > ctxp->ts_status_wqput) | |
298 | return; | |
299 | if (ctxp->ts_status_wqput > ctxp->ts_isr_status) | |
300 | return; | |
301 | if (ctxp->ts_isr_status > ctxp->ts_status_nvme) | |
302 | return; | |
303 | /* | |
304 | * Segment 1 - Time from FCP command received by MSI-X ISR | |
305 | * to FCP command is passed to NVME Layer. | |
306 | * Segment 2 - Time from FCP command payload handed | |
307 | * off to NVME Layer to Driver receives a Command op | |
308 | * from NVME Layer. | |
309 | * Segment 3 - Time from Driver receives a Command op | |
310 | * from NVME Layer to Command is put on WQ. | |
311 | * Segment 4 - Time from Driver WQ put is done | |
312 | * to MSI-X ISR for Command cmpl. | |
313 | * Segment 5 - Time from MSI-X ISR for Command cmpl to | |
314 | * Command cmpl is passed to NVME Layer. | |
315 | * Segment 6 - Time from Command cmpl is passed to NVME | |
316 | * Layer to Driver receives a RSP op from NVME Layer. | |
317 | * Segment 7 - Time from Driver receives a RSP op from | |
318 | * NVME Layer to WQ put is done on TRSP FCP Status. | |
319 | * Segment 8 - Time from Driver WQ put is done on TRSP | |
320 | * FCP Status to MSI-X ISR for TRSP cmpl. | |
321 | * Segment 9 - Time from MSI-X ISR for TRSP cmpl to | |
322 | * TRSP cmpl is passed to NVME Layer. | |
323 | * Segment 10 - Time from FCP command received by | |
324 | * MSI-X ISR to command is completed on wire. | |
325 | * (Segments 1 thru 8) for READDATA / WRITEDATA | |
326 | * (Segments 1 thru 4) for READDATA_RSP | |
327 | */ | |
328 | seg1 = ctxp->ts_cmd_nvme - ctxp->ts_isr_cmd; | |
329 | seg2 = (ctxp->ts_nvme_data - ctxp->ts_isr_cmd) - seg1; | |
330 | seg3 = (ctxp->ts_data_wqput - ctxp->ts_isr_cmd) - | |
331 | seg1 - seg2; | |
332 | seg4 = (ctxp->ts_isr_data - ctxp->ts_isr_cmd) - | |
333 | seg1 - seg2 - seg3; | |
334 | seg5 = (ctxp->ts_data_nvme - ctxp->ts_isr_cmd) - | |
335 | seg1 - seg2 - seg3 - seg4; | |
336 | ||
337 | /* For auto rsp commands seg6 thru seg10 will be 0 */ | |
338 | if (ctxp->ts_nvme_status > ctxp->ts_data_nvme) { | |
339 | seg6 = (ctxp->ts_nvme_status - | |
340 | ctxp->ts_isr_cmd) - | |
341 | seg1 - seg2 - seg3 - seg4 - seg5; | |
342 | seg7 = (ctxp->ts_status_wqput - | |
343 | ctxp->ts_isr_cmd) - | |
344 | seg1 - seg2 - seg3 - | |
345 | seg4 - seg5 - seg6; | |
346 | seg8 = (ctxp->ts_isr_status - | |
347 | ctxp->ts_isr_cmd) - | |
348 | seg1 - seg2 - seg3 - seg4 - | |
349 | seg5 - seg6 - seg7; | |
350 | seg9 = (ctxp->ts_status_nvme - | |
351 | ctxp->ts_isr_cmd) - | |
352 | seg1 - seg2 - seg3 - seg4 - | |
353 | seg5 - seg6 - seg7 - seg8; | |
354 | seg10 = (ctxp->ts_isr_status - | |
355 | ctxp->ts_isr_cmd); | |
356 | } else { | |
357 | seg6 = 0; | |
358 | seg7 = 0; | |
359 | seg8 = 0; | |
360 | seg9 = 0; | |
361 | seg10 = (ctxp->ts_isr_data - ctxp->ts_isr_cmd); | |
362 | } | |
363 | ||
364 | phba->ktime_seg1_total += seg1; | |
365 | if (seg1 < phba->ktime_seg1_min) | |
366 | phba->ktime_seg1_min = seg1; | |
367 | else if (seg1 > phba->ktime_seg1_max) | |
368 | phba->ktime_seg1_max = seg1; | |
369 | ||
370 | phba->ktime_seg2_total += seg2; | |
371 | if (seg2 < phba->ktime_seg2_min) | |
372 | phba->ktime_seg2_min = seg2; | |
373 | else if (seg2 > phba->ktime_seg2_max) | |
374 | phba->ktime_seg2_max = seg2; | |
375 | ||
376 | phba->ktime_seg3_total += seg3; | |
377 | if (seg3 < phba->ktime_seg3_min) | |
378 | phba->ktime_seg3_min = seg3; | |
379 | else if (seg3 > phba->ktime_seg3_max) | |
380 | phba->ktime_seg3_max = seg3; | |
381 | ||
382 | phba->ktime_seg4_total += seg4; | |
383 | if (seg4 < phba->ktime_seg4_min) | |
384 | phba->ktime_seg4_min = seg4; | |
385 | else if (seg4 > phba->ktime_seg4_max) | |
386 | phba->ktime_seg4_max = seg4; | |
387 | ||
388 | phba->ktime_seg5_total += seg5; | |
389 | if (seg5 < phba->ktime_seg5_min) | |
390 | phba->ktime_seg5_min = seg5; | |
391 | else if (seg5 > phba->ktime_seg5_max) | |
392 | phba->ktime_seg5_max = seg5; | |
393 | ||
394 | phba->ktime_data_samples++; | |
395 | if (!seg6) | |
396 | goto out; | |
397 | ||
398 | phba->ktime_seg6_total += seg6; | |
399 | if (seg6 < phba->ktime_seg6_min) | |
400 | phba->ktime_seg6_min = seg6; | |
401 | else if (seg6 > phba->ktime_seg6_max) | |
402 | phba->ktime_seg6_max = seg6; | |
403 | ||
404 | phba->ktime_seg7_total += seg7; | |
405 | if (seg7 < phba->ktime_seg7_min) | |
406 | phba->ktime_seg7_min = seg7; | |
407 | else if (seg7 > phba->ktime_seg7_max) | |
408 | phba->ktime_seg7_max = seg7; | |
409 | ||
410 | phba->ktime_seg8_total += seg8; | |
411 | if (seg8 < phba->ktime_seg8_min) | |
412 | phba->ktime_seg8_min = seg8; | |
413 | else if (seg8 > phba->ktime_seg8_max) | |
414 | phba->ktime_seg8_max = seg8; | |
415 | ||
416 | phba->ktime_seg9_total += seg9; | |
417 | if (seg9 < phba->ktime_seg9_min) | |
418 | phba->ktime_seg9_min = seg9; | |
419 | else if (seg9 > phba->ktime_seg9_max) | |
420 | phba->ktime_seg9_max = seg9; | |
421 | out: | |
422 | phba->ktime_seg10_total += seg10; | |
423 | if (seg10 < phba->ktime_seg10_min) | |
424 | phba->ktime_seg10_min = seg10; | |
425 | else if (seg10 > phba->ktime_seg10_max) | |
426 | phba->ktime_seg10_max = seg10; | |
427 | phba->ktime_status_samples++; | |
428 | } | |
429 | #endif | |
430 | ||
d613b6a7 JS |
431 | /** |
432 | * lpfc_nvmet_xmt_fcp_op_cmp - Completion handler for FCP Response | |
433 | * @phba: Pointer to HBA context object. | |
434 | * @cmdwqe: Pointer to driver command WQE object. | |
435 | * @wcqe: Pointer to driver response CQE object. | |
436 | * | |
437 | * The function is called from SLI ring event handler with no | |
438 | * lock held. This function is the completion handler for NVME FCP commands | |
439 | * The function frees memory resources used for the NVME commands. | |
440 | **/ | |
441 | static void | |
442 | lpfc_nvmet_xmt_fcp_op_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
443 | struct lpfc_wcqe_complete *wcqe) | |
444 | { | |
445 | struct lpfc_nvmet_tgtport *tgtp; | |
446 | struct nvmefc_tgt_fcp_req *rsp; | |
447 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
448 | uint32_t status, result, op, start_clean; | |
2b65e182 JS |
449 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
450 | uint32_t id; | |
451 | #endif | |
d613b6a7 JS |
452 | |
453 | ctxp = cmdwqe->context2; | |
86c67379 JS |
454 | ctxp->flag &= ~LPFC_NVMET_IO_INP; |
455 | ||
d613b6a7 JS |
456 | rsp = &ctxp->ctx.fcp_req; |
457 | op = rsp->op; | |
d613b6a7 JS |
458 | |
459 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
460 | result = wcqe->parameter; | |
461 | ||
86c67379 JS |
462 | if (phba->targetport) |
463 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
464 | else | |
465 | tgtp = NULL; | |
d613b6a7 | 466 | |
2b65e182 JS |
467 | lpfc_nvmeio_data(phba, "NVMET FCP CMPL: xri x%x op x%x status x%x\n", |
468 | ctxp->oxid, op, status); | |
469 | ||
d613b6a7 JS |
470 | if (status) { |
471 | rsp->fcp_error = NVME_SC_DATA_XFER_ERROR; | |
472 | rsp->transferred_length = 0; | |
86c67379 JS |
473 | if (tgtp) |
474 | atomic_inc(&tgtp->xmt_fcp_rsp_error); | |
475 | ||
476 | /* pick up SLI4 exhange busy condition */ | |
477 | if (bf_get(lpfc_wcqe_c_xb, wcqe)) { | |
478 | ctxp->flag |= LPFC_NVMET_XBUSY; | |
479 | ||
480 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
481 | "6315 IO Cmpl XBUSY: xri x%x: %x/%x\n", | |
482 | ctxp->oxid, status, result); | |
483 | } else { | |
484 | ctxp->flag &= ~LPFC_NVMET_XBUSY; | |
485 | } | |
486 | ||
d613b6a7 JS |
487 | } else { |
488 | rsp->fcp_error = NVME_SC_SUCCESS; | |
489 | if (op == NVMET_FCOP_RSP) | |
490 | rsp->transferred_length = rsp->rsplen; | |
491 | else | |
492 | rsp->transferred_length = rsp->transfer_length; | |
86c67379 JS |
493 | if (tgtp) |
494 | atomic_inc(&tgtp->xmt_fcp_rsp_cmpl); | |
d613b6a7 JS |
495 | } |
496 | ||
d613b6a7 JS |
497 | if ((op == NVMET_FCOP_READDATA_RSP) || |
498 | (op == NVMET_FCOP_RSP)) { | |
499 | /* Sanity check */ | |
500 | ctxp->state = LPFC_NVMET_STE_DONE; | |
501 | ctxp->entry_cnt++; | |
86c67379 | 502 | |
2b65e182 JS |
503 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
504 | if (phba->ktime_on) { | |
505 | if (rsp->op == NVMET_FCOP_READDATA_RSP) { | |
506 | ctxp->ts_isr_data = | |
507 | cmdwqe->isr_timestamp; | |
508 | ctxp->ts_data_nvme = | |
509 | ktime_get_ns(); | |
510 | ctxp->ts_nvme_status = | |
511 | ctxp->ts_data_nvme; | |
512 | ctxp->ts_status_wqput = | |
513 | ctxp->ts_data_nvme; | |
514 | ctxp->ts_isr_status = | |
515 | ctxp->ts_data_nvme; | |
516 | ctxp->ts_status_nvme = | |
517 | ctxp->ts_data_nvme; | |
518 | } else { | |
519 | ctxp->ts_isr_status = | |
520 | cmdwqe->isr_timestamp; | |
521 | ctxp->ts_status_nvme = | |
522 | ktime_get_ns(); | |
523 | } | |
524 | } | |
525 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
526 | id = smp_processor_id(); | |
527 | if (ctxp->cpu != id) | |
528 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
529 | "6703 CPU Check cmpl: " | |
530 | "cpu %d expect %d\n", | |
531 | id, ctxp->cpu); | |
532 | if (ctxp->cpu < LPFC_CHECK_CPU_CNT) | |
533 | phba->cpucheck_cmpl_io[id]++; | |
534 | } | |
535 | #endif | |
d613b6a7 | 536 | rsp->done(rsp); |
2b65e182 JS |
537 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
538 | if (phba->ktime_on) | |
539 | lpfc_nvmet_ktime(phba, ctxp); | |
540 | #endif | |
19b58d94 | 541 | /* lpfc_nvmet_xmt_fcp_release() will recycle the context */ |
d613b6a7 JS |
542 | } else { |
543 | ctxp->entry_cnt++; | |
544 | start_clean = offsetof(struct lpfc_iocbq, wqe); | |
545 | memset(((char *)cmdwqe) + start_clean, 0, | |
546 | (sizeof(struct lpfc_iocbq) - start_clean)); | |
2b65e182 JS |
547 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
548 | if (phba->ktime_on) { | |
549 | ctxp->ts_isr_data = cmdwqe->isr_timestamp; | |
550 | ctxp->ts_data_nvme = ktime_get_ns(); | |
551 | } | |
552 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
553 | id = smp_processor_id(); | |
554 | if (ctxp->cpu != id) | |
555 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
556 | "6704 CPU Check cmdcmpl: " | |
557 | "cpu %d expect %d\n", | |
558 | id, ctxp->cpu); | |
559 | if (ctxp->cpu < LPFC_CHECK_CPU_CNT) | |
560 | phba->cpucheck_ccmpl_io[id]++; | |
561 | } | |
562 | #endif | |
d613b6a7 JS |
563 | rsp->done(rsp); |
564 | } | |
565 | } | |
566 | ||
567 | static int | |
568 | lpfc_nvmet_xmt_ls_rsp(struct nvmet_fc_target_port *tgtport, | |
569 | struct nvmefc_tgt_ls_req *rsp) | |
570 | { | |
571 | struct lpfc_nvmet_rcv_ctx *ctxp = | |
572 | container_of(rsp, struct lpfc_nvmet_rcv_ctx, ctx.ls_req); | |
573 | struct lpfc_hba *phba = ctxp->phba; | |
574 | struct hbq_dmabuf *nvmebuf = | |
575 | (struct hbq_dmabuf *)ctxp->rqb_buffer; | |
576 | struct lpfc_iocbq *nvmewqeq; | |
577 | struct lpfc_nvmet_tgtport *nvmep = tgtport->private; | |
578 | struct lpfc_dmabuf dmabuf; | |
579 | struct ulp_bde64 bpl; | |
580 | int rc; | |
581 | ||
582 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
583 | "6023 %s: Entrypoint ctx %p %p\n", __func__, | |
584 | ctxp, tgtport); | |
585 | ||
586 | nvmewqeq = lpfc_nvmet_prep_ls_wqe(phba, ctxp, rsp->rspdma, | |
587 | rsp->rsplen); | |
588 | if (nvmewqeq == NULL) { | |
589 | atomic_inc(&nvmep->xmt_ls_drop); | |
590 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
591 | "6150 LS Drop IO x%x: Prep\n", | |
592 | ctxp->oxid); | |
593 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
547077a4 | 594 | atomic_inc(&nvmep->xmt_ls_abort); |
d613b6a7 JS |
595 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, |
596 | ctxp->sid, ctxp->oxid); | |
597 | return -ENOMEM; | |
598 | } | |
599 | ||
600 | /* Save numBdes for bpl2sgl */ | |
601 | nvmewqeq->rsvd2 = 1; | |
602 | nvmewqeq->hba_wqidx = 0; | |
603 | nvmewqeq->context3 = &dmabuf; | |
604 | dmabuf.virt = &bpl; | |
605 | bpl.addrLow = nvmewqeq->wqe.xmit_sequence.bde.addrLow; | |
606 | bpl.addrHigh = nvmewqeq->wqe.xmit_sequence.bde.addrHigh; | |
607 | bpl.tus.f.bdeSize = rsp->rsplen; | |
608 | bpl.tus.f.bdeFlags = 0; | |
609 | bpl.tus.w = le32_to_cpu(bpl.tus.w); | |
610 | ||
611 | nvmewqeq->wqe_cmpl = lpfc_nvmet_xmt_ls_rsp_cmp; | |
612 | nvmewqeq->iocb_cmpl = NULL; | |
613 | nvmewqeq->context2 = ctxp; | |
614 | ||
2b65e182 JS |
615 | lpfc_nvmeio_data(phba, "NVMET LS RESP: xri x%x wqidx x%x len x%x\n", |
616 | ctxp->oxid, nvmewqeq->hba_wqidx, rsp->rsplen); | |
617 | ||
d613b6a7 JS |
618 | rc = lpfc_sli4_issue_wqe(phba, LPFC_ELS_RING, nvmewqeq); |
619 | if (rc == WQE_SUCCESS) { | |
620 | /* | |
621 | * Okay to repost buffer here, but wait till cmpl | |
622 | * before freeing ctxp and iocbq. | |
623 | */ | |
624 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
625 | ctxp->rqb_buffer = 0; | |
626 | atomic_inc(&nvmep->xmt_ls_rsp); | |
627 | return 0; | |
628 | } | |
629 | /* Give back resources */ | |
630 | atomic_inc(&nvmep->xmt_ls_drop); | |
631 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
632 | "6151 LS Drop IO x%x: Issue %d\n", | |
633 | ctxp->oxid, rc); | |
634 | ||
635 | lpfc_nlp_put(nvmewqeq->context1); | |
636 | ||
637 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
547077a4 | 638 | atomic_inc(&nvmep->xmt_ls_abort); |
d613b6a7 JS |
639 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, ctxp->sid, ctxp->oxid); |
640 | return -ENXIO; | |
641 | } | |
642 | ||
643 | static int | |
644 | lpfc_nvmet_xmt_fcp_op(struct nvmet_fc_target_port *tgtport, | |
645 | struct nvmefc_tgt_fcp_req *rsp) | |
646 | { | |
647 | struct lpfc_nvmet_tgtport *lpfc_nvmep = tgtport->private; | |
648 | struct lpfc_nvmet_rcv_ctx *ctxp = | |
649 | container_of(rsp, struct lpfc_nvmet_rcv_ctx, ctx.fcp_req); | |
650 | struct lpfc_hba *phba = ctxp->phba; | |
651 | struct lpfc_iocbq *nvmewqeq; | |
223b78ea | 652 | int rc; |
2b65e182 JS |
653 | |
654 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS | |
655 | if (phba->ktime_on) { | |
656 | if (rsp->op == NVMET_FCOP_RSP) | |
657 | ctxp->ts_nvme_status = ktime_get_ns(); | |
658 | else | |
659 | ctxp->ts_nvme_data = ktime_get_ns(); | |
660 | } | |
661 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_IO) { | |
223b78ea | 662 | int id = smp_processor_id(); |
2b65e182 JS |
663 | ctxp->cpu = id; |
664 | if (id < LPFC_CHECK_CPU_CNT) | |
665 | phba->cpucheck_xmt_io[id]++; | |
666 | if (rsp->hwqid != id) { | |
667 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
668 | "6705 CPU Check OP: " | |
669 | "cpu %d expect %d\n", | |
670 | id, rsp->hwqid); | |
671 | ctxp->cpu = rsp->hwqid; | |
672 | } | |
673 | } | |
674 | #endif | |
d613b6a7 | 675 | |
d613b6a7 | 676 | /* Sanity check */ |
86c67379 JS |
677 | if ((ctxp->flag & LPFC_NVMET_ABTS_RCV) || |
678 | (ctxp->state == LPFC_NVMET_STE_ABORT)) { | |
d613b6a7 JS |
679 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); |
680 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
86c67379 | 681 | "6102 IO xri x%x aborted\n", |
d613b6a7 | 682 | ctxp->oxid); |
a5068b46 | 683 | rc = -ENXIO; |
d613b6a7 JS |
684 | goto aerr; |
685 | } | |
686 | ||
687 | nvmewqeq = lpfc_nvmet_prep_fcp_wqe(phba, ctxp); | |
688 | if (nvmewqeq == NULL) { | |
689 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); | |
690 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
691 | "6152 FCP Drop IO x%x: Prep\n", | |
692 | ctxp->oxid); | |
a5068b46 | 693 | rc = -ENXIO; |
d613b6a7 JS |
694 | goto aerr; |
695 | } | |
696 | ||
697 | nvmewqeq->wqe_cmpl = lpfc_nvmet_xmt_fcp_op_cmp; | |
698 | nvmewqeq->iocb_cmpl = NULL; | |
699 | nvmewqeq->context2 = ctxp; | |
700 | nvmewqeq->iocb_flag |= LPFC_IO_NVMET; | |
701 | ctxp->wqeq->hba_wqidx = rsp->hwqid; | |
702 | ||
2b65e182 JS |
703 | lpfc_nvmeio_data(phba, "NVMET FCP CMND: xri x%x op x%x len x%x\n", |
704 | ctxp->oxid, rsp->op, rsp->rsplen); | |
705 | ||
61f3d4bf | 706 | ctxp->flag |= LPFC_NVMET_IO_INP; |
d613b6a7 | 707 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, nvmewqeq); |
d613b6a7 | 708 | if (rc == WQE_SUCCESS) { |
2b65e182 JS |
709 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
710 | if (!phba->ktime_on) | |
711 | return 0; | |
712 | if (rsp->op == NVMET_FCOP_RSP) | |
713 | ctxp->ts_status_wqput = ktime_get_ns(); | |
714 | else | |
715 | ctxp->ts_data_wqput = ktime_get_ns(); | |
716 | #endif | |
d613b6a7 JS |
717 | return 0; |
718 | } | |
719 | ||
720 | /* Give back resources */ | |
721 | atomic_inc(&lpfc_nvmep->xmt_fcp_drop); | |
722 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
723 | "6153 FCP Drop IO x%x: Issue: %d\n", | |
724 | ctxp->oxid, rc); | |
725 | ||
726 | ctxp->wqeq->hba_wqidx = 0; | |
727 | nvmewqeq->context2 = NULL; | |
728 | nvmewqeq->context3 = NULL; | |
a5068b46 | 729 | rc = -EBUSY; |
d613b6a7 | 730 | aerr: |
a5068b46 | 731 | return rc; |
d613b6a7 JS |
732 | } |
733 | ||
734 | static void | |
735 | lpfc_nvmet_targetport_delete(struct nvmet_fc_target_port *targetport) | |
736 | { | |
737 | struct lpfc_nvmet_tgtport *tport = targetport->private; | |
738 | ||
739 | /* release any threads waiting for the unreg to complete */ | |
740 | complete(&tport->tport_unreg_done); | |
741 | } | |
742 | ||
a97ec51b JS |
743 | static void |
744 | lpfc_nvmet_xmt_fcp_abort(struct nvmet_fc_target_port *tgtport, | |
745 | struct nvmefc_tgt_fcp_req *req) | |
746 | { | |
747 | struct lpfc_nvmet_tgtport *lpfc_nvmep = tgtport->private; | |
748 | struct lpfc_nvmet_rcv_ctx *ctxp = | |
749 | container_of(req, struct lpfc_nvmet_rcv_ctx, ctx.fcp_req); | |
750 | struct lpfc_hba *phba = ctxp->phba; | |
86c67379 | 751 | unsigned long flags; |
a97ec51b JS |
752 | |
753 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
86c67379 JS |
754 | "6103 Abort op: oxri x%x flg x%x cnt %d\n", |
755 | ctxp->oxid, ctxp->flag, ctxp->entry_cnt); | |
a97ec51b | 756 | |
86c67379 JS |
757 | lpfc_nvmeio_data(phba, "NVMET FCP ABRT: " |
758 | "xri x%x flg x%x cnt x%x\n", | |
759 | ctxp->oxid, ctxp->flag, ctxp->entry_cnt); | |
a97ec51b JS |
760 | |
761 | atomic_inc(&lpfc_nvmep->xmt_fcp_abort); | |
762 | ctxp->entry_cnt++; | |
86c67379 JS |
763 | spin_lock_irqsave(&ctxp->ctxlock, flags); |
764 | ||
765 | /* Since iaab/iaar are NOT set, we need to check | |
766 | * if the firmware is in process of aborting IO | |
767 | */ | |
768 | if (ctxp->flag & LPFC_NVMET_XBUSY) { | |
769 | spin_unlock_irqrestore(&ctxp->ctxlock, flags); | |
770 | return; | |
771 | } | |
a97ec51b JS |
772 | ctxp->flag |= LPFC_NVMET_ABORT_OP; |
773 | if (ctxp->flag & LPFC_NVMET_IO_INP) | |
774 | lpfc_nvmet_sol_fcp_issue_abort(phba, ctxp, ctxp->sid, | |
775 | ctxp->oxid); | |
776 | else | |
777 | lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, ctxp->sid, | |
778 | ctxp->oxid); | |
86c67379 | 779 | spin_unlock_irqrestore(&ctxp->ctxlock, flags); |
a97ec51b JS |
780 | } |
781 | ||
19b58d94 JS |
782 | static void |
783 | lpfc_nvmet_xmt_fcp_release(struct nvmet_fc_target_port *tgtport, | |
784 | struct nvmefc_tgt_fcp_req *rsp) | |
785 | { | |
547077a4 | 786 | struct lpfc_nvmet_tgtport *lpfc_nvmep = tgtport->private; |
19b58d94 JS |
787 | struct lpfc_nvmet_rcv_ctx *ctxp = |
788 | container_of(rsp, struct lpfc_nvmet_rcv_ctx, ctx.fcp_req); | |
789 | struct lpfc_hba *phba = ctxp->phba; | |
790 | unsigned long flags; | |
791 | bool aborting = false; | |
792 | ||
793 | spin_lock_irqsave(&ctxp->ctxlock, flags); | |
86c67379 JS |
794 | if ((ctxp->flag & LPFC_NVMET_ABORT_OP) || |
795 | (ctxp->flag & LPFC_NVMET_XBUSY)) { | |
19b58d94 | 796 | aborting = true; |
19b58d94 | 797 | /* let the abort path do the real release */ |
86c67379 | 798 | lpfc_nvmet_defer_release(phba, ctxp); |
19b58d94 | 799 | } |
86c67379 | 800 | spin_unlock_irqrestore(&ctxp->ctxlock, flags); |
19b58d94 | 801 | |
9094367a AB |
802 | lpfc_nvmeio_data(phba, "NVMET FCP FREE: xri x%x ste %d abt %d\n", ctxp->oxid, |
803 | ctxp->state, aborting); | |
19b58d94 | 804 | |
547077a4 JS |
805 | atomic_inc(&lpfc_nvmep->xmt_fcp_release); |
806 | ||
86c67379 JS |
807 | if (aborting) |
808 | return; | |
809 | ||
6c621a22 | 810 | lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf); |
19b58d94 JS |
811 | } |
812 | ||
d613b6a7 JS |
813 | static struct nvmet_fc_target_template lpfc_tgttemplate = { |
814 | .targetport_delete = lpfc_nvmet_targetport_delete, | |
815 | .xmt_ls_rsp = lpfc_nvmet_xmt_ls_rsp, | |
816 | .fcp_op = lpfc_nvmet_xmt_fcp_op, | |
a97ec51b | 817 | .fcp_abort = lpfc_nvmet_xmt_fcp_abort, |
19b58d94 | 818 | .fcp_req_release = lpfc_nvmet_xmt_fcp_release, |
d613b6a7 JS |
819 | |
820 | .max_hw_queues = 1, | |
821 | .max_sgl_segments = LPFC_NVMET_DEFAULT_SEGS, | |
822 | .max_dif_sgl_segments = LPFC_NVMET_DEFAULT_SEGS, | |
823 | .dma_boundary = 0xFFFFFFFF, | |
824 | ||
825 | /* optional features */ | |
826 | .target_features = 0, | |
827 | /* sizes of additional private data for data structures */ | |
828 | .target_priv_sz = sizeof(struct lpfc_nvmet_tgtport), | |
829 | }; | |
830 | ||
6c621a22 JS |
831 | void |
832 | lpfc_nvmet_cleanup_io_context(struct lpfc_hba *phba) | |
833 | { | |
834 | struct lpfc_nvmet_ctxbuf *ctx_buf, *next_ctx_buf; | |
835 | unsigned long flags; | |
836 | ||
837 | list_for_each_entry_safe( | |
838 | ctx_buf, next_ctx_buf, | |
839 | &phba->sli4_hba.lpfc_nvmet_ctx_list, list) { | |
840 | spin_lock_irqsave( | |
841 | &phba->sli4_hba.abts_nvme_buf_list_lock, flags); | |
842 | list_del_init(&ctx_buf->list); | |
843 | spin_unlock_irqrestore( | |
844 | &phba->sli4_hba.abts_nvme_buf_list_lock, flags); | |
845 | __lpfc_clear_active_sglq(phba, | |
846 | ctx_buf->sglq->sli4_lxritag); | |
847 | ctx_buf->sglq->state = SGL_FREED; | |
848 | ctx_buf->sglq->ndlp = NULL; | |
849 | ||
850 | spin_lock_irqsave(&phba->sli4_hba.sgl_list_lock, flags); | |
851 | list_add_tail(&ctx_buf->sglq->list, | |
852 | &phba->sli4_hba.lpfc_nvmet_sgl_list); | |
853 | spin_unlock_irqrestore(&phba->sli4_hba.sgl_list_lock, | |
854 | flags); | |
855 | ||
856 | lpfc_sli_release_iocbq(phba, ctx_buf->iocbq); | |
857 | kfree(ctx_buf->context); | |
858 | } | |
859 | } | |
860 | ||
861 | int | |
862 | lpfc_nvmet_setup_io_context(struct lpfc_hba *phba) | |
863 | { | |
864 | struct lpfc_nvmet_ctxbuf *ctx_buf; | |
865 | struct lpfc_iocbq *nvmewqe; | |
866 | union lpfc_wqe128 *wqe; | |
867 | int i; | |
868 | ||
869 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME, | |
870 | "6403 Allocate NVMET resources for %d XRIs\n", | |
871 | phba->sli4_hba.nvmet_xri_cnt); | |
872 | ||
873 | /* For all nvmet xris, allocate resources needed to process a | |
874 | * received command on a per xri basis. | |
875 | */ | |
876 | for (i = 0; i < phba->sli4_hba.nvmet_xri_cnt; i++) { | |
877 | ctx_buf = kzalloc(sizeof(*ctx_buf), GFP_KERNEL); | |
878 | if (!ctx_buf) { | |
879 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
880 | "6404 Ran out of memory for NVMET\n"); | |
881 | return -ENOMEM; | |
882 | } | |
883 | ||
884 | ctx_buf->context = kzalloc(sizeof(*ctx_buf->context), | |
885 | GFP_KERNEL); | |
886 | if (!ctx_buf->context) { | |
887 | kfree(ctx_buf); | |
888 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
889 | "6405 Ran out of NVMET " | |
890 | "context memory\n"); | |
891 | return -ENOMEM; | |
892 | } | |
893 | ctx_buf->context->ctxbuf = ctx_buf; | |
894 | ||
895 | ctx_buf->iocbq = lpfc_sli_get_iocbq(phba); | |
896 | if (!ctx_buf->iocbq) { | |
897 | kfree(ctx_buf->context); | |
898 | kfree(ctx_buf); | |
899 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
900 | "6406 Ran out of NVMET iocb/WQEs\n"); | |
901 | return -ENOMEM; | |
902 | } | |
903 | ctx_buf->iocbq->iocb_flag = LPFC_IO_NVMET; | |
904 | nvmewqe = ctx_buf->iocbq; | |
905 | wqe = (union lpfc_wqe128 *)&nvmewqe->wqe; | |
906 | /* Initialize WQE */ | |
907 | memset(wqe, 0, sizeof(union lpfc_wqe)); | |
908 | /* Word 7 */ | |
909 | bf_set(wqe_ct, &wqe->generic.wqe_com, SLI4_CT_RPI); | |
910 | bf_set(wqe_class, &wqe->generic.wqe_com, CLASS3); | |
911 | bf_set(wqe_pu, &wqe->generic.wqe_com, 1); | |
912 | /* Word 10 */ | |
913 | bf_set(wqe_nvme, &wqe->fcp_tsend.wqe_com, 1); | |
914 | bf_set(wqe_ebde_cnt, &wqe->generic.wqe_com, 0); | |
915 | bf_set(wqe_qosd, &wqe->generic.wqe_com, 0); | |
916 | ||
917 | ctx_buf->iocbq->context1 = NULL; | |
918 | spin_lock(&phba->sli4_hba.sgl_list_lock); | |
919 | ctx_buf->sglq = __lpfc_sli_get_nvmet_sglq(phba, ctx_buf->iocbq); | |
920 | spin_unlock(&phba->sli4_hba.sgl_list_lock); | |
921 | if (!ctx_buf->sglq) { | |
922 | lpfc_sli_release_iocbq(phba, ctx_buf->iocbq); | |
923 | kfree(ctx_buf->context); | |
924 | kfree(ctx_buf); | |
925 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, | |
926 | "6407 Ran out of NVMET XRIs\n"); | |
927 | return -ENOMEM; | |
928 | } | |
929 | spin_lock(&phba->sli4_hba.nvmet_io_lock); | |
930 | list_add_tail(&ctx_buf->list, | |
931 | &phba->sli4_hba.lpfc_nvmet_ctx_list); | |
932 | spin_unlock(&phba->sli4_hba.nvmet_io_lock); | |
933 | } | |
934 | phba->sli4_hba.nvmet_ctx_cnt = phba->sli4_hba.nvmet_xri_cnt; | |
935 | return 0; | |
936 | } | |
937 | ||
d613b6a7 JS |
938 | int |
939 | lpfc_nvmet_create_targetport(struct lpfc_hba *phba) | |
940 | { | |
941 | struct lpfc_vport *vport = phba->pport; | |
942 | struct lpfc_nvmet_tgtport *tgtp; | |
943 | struct nvmet_fc_port_info pinfo; | |
6c621a22 | 944 | int error; |
d613b6a7 JS |
945 | |
946 | if (phba->targetport) | |
947 | return 0; | |
948 | ||
6c621a22 JS |
949 | error = lpfc_nvmet_setup_io_context(phba); |
950 | if (error) | |
951 | return error; | |
952 | ||
d613b6a7 JS |
953 | memset(&pinfo, 0, sizeof(struct nvmet_fc_port_info)); |
954 | pinfo.node_name = wwn_to_u64(vport->fc_nodename.u.wwn); | |
955 | pinfo.port_name = wwn_to_u64(vport->fc_portname.u.wwn); | |
956 | pinfo.port_id = vport->fc_myDID; | |
957 | ||
4d4c4a4a JS |
958 | /* Limit to LPFC_MAX_NVME_SEG_CNT. |
959 | * For now need + 1 to get around NVME transport logic. | |
960 | */ | |
961 | if (phba->cfg_sg_seg_cnt > LPFC_MAX_NVME_SEG_CNT) { | |
962 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME | LOG_INIT, | |
963 | "6400 Reducing sg segment cnt to %d\n", | |
964 | LPFC_MAX_NVME_SEG_CNT); | |
965 | phba->cfg_nvme_seg_cnt = LPFC_MAX_NVME_SEG_CNT; | |
966 | } else { | |
967 | phba->cfg_nvme_seg_cnt = phba->cfg_sg_seg_cnt; | |
968 | } | |
969 | lpfc_tgttemplate.max_sgl_segments = phba->cfg_nvme_seg_cnt + 1; | |
d613b6a7 | 970 | lpfc_tgttemplate.max_hw_queues = phba->cfg_nvme_io_channel; |
d613b6a7 | 971 | lpfc_tgttemplate.target_features = NVMET_FCTGTFEAT_READDATA_RSP | |
39498fae JS |
972 | NVMET_FCTGTFEAT_CMD_IN_ISR | |
973 | NVMET_FCTGTFEAT_OPDONE_IN_ISR; | |
d613b6a7 | 974 | |
7d708033 | 975 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
976 | error = nvmet_fc_register_targetport(&pinfo, &lpfc_tgttemplate, |
977 | &phba->pcidev->dev, | |
978 | &phba->targetport); | |
166d7211 | 979 | #else |
6c621a22 | 980 | error = -ENOENT; |
166d7211 | 981 | #endif |
d613b6a7 JS |
982 | if (error) { |
983 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
984 | "6025 Cannot register NVME targetport " | |
985 | "x%x\n", error); | |
986 | phba->targetport = NULL; | |
6c621a22 JS |
987 | |
988 | lpfc_nvmet_cleanup_io_context(phba); | |
989 | ||
d613b6a7 JS |
990 | } else { |
991 | tgtp = (struct lpfc_nvmet_tgtport *) | |
992 | phba->targetport->private; | |
993 | tgtp->phba = phba; | |
994 | ||
995 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
996 | "6026 Registered NVME " | |
997 | "targetport: %p, private %p " | |
998 | "portnm %llx nodenm %llx\n", | |
999 | phba->targetport, tgtp, | |
1000 | pinfo.port_name, pinfo.node_name); | |
1001 | ||
1002 | atomic_set(&tgtp->rcv_ls_req_in, 0); | |
1003 | atomic_set(&tgtp->rcv_ls_req_out, 0); | |
1004 | atomic_set(&tgtp->rcv_ls_req_drop, 0); | |
1005 | atomic_set(&tgtp->xmt_ls_abort, 0); | |
547077a4 | 1006 | atomic_set(&tgtp->xmt_ls_abort_cmpl, 0); |
d613b6a7 JS |
1007 | atomic_set(&tgtp->xmt_ls_rsp, 0); |
1008 | atomic_set(&tgtp->xmt_ls_drop, 0); | |
1009 | atomic_set(&tgtp->xmt_ls_rsp_error, 0); | |
1010 | atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0); | |
1011 | atomic_set(&tgtp->rcv_fcp_cmd_in, 0); | |
1012 | atomic_set(&tgtp->rcv_fcp_cmd_out, 0); | |
1013 | atomic_set(&tgtp->rcv_fcp_cmd_drop, 0); | |
d613b6a7 JS |
1014 | atomic_set(&tgtp->xmt_fcp_drop, 0); |
1015 | atomic_set(&tgtp->xmt_fcp_read_rsp, 0); | |
1016 | atomic_set(&tgtp->xmt_fcp_read, 0); | |
1017 | atomic_set(&tgtp->xmt_fcp_write, 0); | |
1018 | atomic_set(&tgtp->xmt_fcp_rsp, 0); | |
547077a4 | 1019 | atomic_set(&tgtp->xmt_fcp_release, 0); |
d613b6a7 JS |
1020 | atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0); |
1021 | atomic_set(&tgtp->xmt_fcp_rsp_error, 0); | |
1022 | atomic_set(&tgtp->xmt_fcp_rsp_drop, 0); | |
547077a4 JS |
1023 | atomic_set(&tgtp->xmt_fcp_abort, 0); |
1024 | atomic_set(&tgtp->xmt_fcp_abort_cmpl, 0); | |
1025 | atomic_set(&tgtp->xmt_abort_unsol, 0); | |
1026 | atomic_set(&tgtp->xmt_abort_sol, 0); | |
d613b6a7 JS |
1027 | atomic_set(&tgtp->xmt_abort_rsp, 0); |
1028 | atomic_set(&tgtp->xmt_abort_rsp_error, 0); | |
d613b6a7 JS |
1029 | } |
1030 | return error; | |
1031 | } | |
1032 | ||
1033 | int | |
1034 | lpfc_nvmet_update_targetport(struct lpfc_hba *phba) | |
1035 | { | |
1036 | struct lpfc_vport *vport = phba->pport; | |
1037 | ||
1038 | if (!phba->targetport) | |
1039 | return 0; | |
1040 | ||
1041 | lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME, | |
1042 | "6007 Update NVMET port %p did x%x\n", | |
1043 | phba->targetport, vport->fc_myDID); | |
1044 | ||
1045 | phba->targetport->port_id = vport->fc_myDID; | |
1046 | return 0; | |
1047 | } | |
1048 | ||
318083ad JS |
1049 | /** |
1050 | * lpfc_sli4_nvmet_xri_aborted - Fast-path process of nvmet xri abort | |
1051 | * @phba: pointer to lpfc hba data structure. | |
1052 | * @axri: pointer to the nvmet xri abort wcqe structure. | |
1053 | * | |
1054 | * This routine is invoked by the worker thread to process a SLI4 fast-path | |
1055 | * NVMET aborted xri. | |
1056 | **/ | |
1057 | void | |
1058 | lpfc_sli4_nvmet_xri_aborted(struct lpfc_hba *phba, | |
1059 | struct sli4_wcqe_xri_aborted *axri) | |
1060 | { | |
86c67379 JS |
1061 | uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri); |
1062 | uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri); | |
1063 | struct lpfc_nvmet_rcv_ctx *ctxp, *next_ctxp; | |
1064 | struct lpfc_nodelist *ndlp; | |
1065 | unsigned long iflag = 0; | |
1066 | int rrq_empty = 0; | |
1067 | bool released = false; | |
1068 | ||
1069 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1070 | "6317 XB aborted xri x%x rxid x%x\n", xri, rxid); | |
1071 | ||
1072 | if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) | |
1073 | return; | |
1074 | spin_lock_irqsave(&phba->hbalock, iflag); | |
1075 | spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1076 | list_for_each_entry_safe(ctxp, next_ctxp, | |
1077 | &phba->sli4_hba.lpfc_abts_nvmet_ctx_list, | |
1078 | list) { | |
6c621a22 | 1079 | if (ctxp->ctxbuf->sglq->sli4_xritag != xri) |
86c67379 JS |
1080 | continue; |
1081 | ||
1082 | /* Check if we already received a free context call | |
1083 | * and we have completed processing an abort situation. | |
1084 | */ | |
1085 | if (ctxp->flag & LPFC_NVMET_CTX_RLS && | |
1086 | !(ctxp->flag & LPFC_NVMET_ABORT_OP)) { | |
1087 | list_del(&ctxp->list); | |
1088 | released = true; | |
1089 | } | |
1090 | ctxp->flag &= ~LPFC_NVMET_XBUSY; | |
1091 | spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1092 | ||
1093 | rrq_empty = list_empty(&phba->active_rrq_list); | |
1094 | spin_unlock_irqrestore(&phba->hbalock, iflag); | |
1095 | ndlp = lpfc_findnode_did(phba->pport, ctxp->sid); | |
1096 | if (ndlp && NLP_CHK_NODE_ACT(ndlp) && | |
1097 | (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE || | |
1098 | ndlp->nlp_state == NLP_STE_MAPPED_NODE)) { | |
1099 | lpfc_set_rrq_active(phba, ndlp, | |
6c621a22 | 1100 | ctxp->ctxbuf->sglq->sli4_lxritag, |
86c67379 JS |
1101 | rxid, 1); |
1102 | lpfc_sli4_abts_err_handler(phba, ndlp, axri); | |
1103 | } | |
1104 | ||
1105 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1106 | "6318 XB aborted %x flg x%x (%x)\n", | |
1107 | ctxp->oxid, ctxp->flag, released); | |
1108 | if (released) | |
6c621a22 JS |
1109 | lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf); |
1110 | ||
86c67379 JS |
1111 | if (rrq_empty) |
1112 | lpfc_worker_wake_up(phba); | |
1113 | return; | |
1114 | } | |
1115 | spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1116 | spin_unlock_irqrestore(&phba->hbalock, iflag); | |
1117 | } | |
1118 | ||
1119 | int | |
1120 | lpfc_nvmet_rcv_unsol_abort(struct lpfc_vport *vport, | |
1121 | struct fc_frame_header *fc_hdr) | |
1122 | ||
1123 | { | |
1124 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) | |
1125 | struct lpfc_hba *phba = vport->phba; | |
1126 | struct lpfc_nvmet_rcv_ctx *ctxp, *next_ctxp; | |
1127 | struct nvmefc_tgt_fcp_req *rsp; | |
1128 | uint16_t xri; | |
1129 | unsigned long iflag = 0; | |
1130 | ||
1131 | xri = be16_to_cpu(fc_hdr->fh_ox_id); | |
1132 | ||
1133 | spin_lock_irqsave(&phba->hbalock, iflag); | |
1134 | spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1135 | list_for_each_entry_safe(ctxp, next_ctxp, | |
1136 | &phba->sli4_hba.lpfc_abts_nvmet_ctx_list, | |
1137 | list) { | |
6c621a22 | 1138 | if (ctxp->ctxbuf->sglq->sli4_xritag != xri) |
86c67379 JS |
1139 | continue; |
1140 | ||
1141 | spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1142 | spin_unlock_irqrestore(&phba->hbalock, iflag); | |
1143 | ||
1144 | spin_lock_irqsave(&ctxp->ctxlock, iflag); | |
1145 | ctxp->flag |= LPFC_NVMET_ABTS_RCV; | |
1146 | spin_unlock_irqrestore(&ctxp->ctxlock, iflag); | |
1147 | ||
1148 | lpfc_nvmeio_data(phba, | |
1149 | "NVMET ABTS RCV: xri x%x CPU %02x rjt %d\n", | |
1150 | xri, smp_processor_id(), 0); | |
1151 | ||
1152 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1153 | "6319 NVMET Rcv ABTS:acc xri x%x\n", xri); | |
1154 | ||
1155 | rsp = &ctxp->ctx.fcp_req; | |
1156 | nvmet_fc_rcv_fcp_abort(phba->targetport, rsp); | |
1157 | ||
1158 | /* Respond with BA_ACC accordingly */ | |
1159 | lpfc_sli4_seq_abort_rsp(vport, fc_hdr, 1); | |
1160 | return 0; | |
1161 | } | |
1162 | spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock); | |
1163 | spin_unlock_irqrestore(&phba->hbalock, iflag); | |
1164 | ||
1165 | lpfc_nvmeio_data(phba, "NVMET ABTS RCV: xri x%x CPU %02x rjt %d\n", | |
1166 | xri, smp_processor_id(), 1); | |
1167 | ||
1168 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
1169 | "6320 NVMET Rcv ABTS:rjt xri x%x\n", xri); | |
1170 | ||
1171 | /* Respond with BA_RJT accordingly */ | |
1172 | lpfc_sli4_seq_abort_rsp(vport, fc_hdr, 0); | |
86c67379 | 1173 | #endif |
b06e13c3 | 1174 | return 0; |
318083ad JS |
1175 | } |
1176 | ||
d613b6a7 JS |
1177 | void |
1178 | lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba) | |
1179 | { | |
7d708033 | 1180 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
1181 | struct lpfc_nvmet_tgtport *tgtp; |
1182 | ||
1183 | if (phba->nvmet_support == 0) | |
1184 | return; | |
1185 | if (phba->targetport) { | |
1186 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1187 | init_completion(&tgtp->tport_unreg_done); | |
1188 | nvmet_fc_unregister_targetport(phba->targetport); | |
1189 | wait_for_completion_timeout(&tgtp->tport_unreg_done, 5); | |
6c621a22 | 1190 | lpfc_nvmet_cleanup_io_context(phba); |
d613b6a7 JS |
1191 | } |
1192 | phba->targetport = NULL; | |
166d7211 | 1193 | #endif |
d613b6a7 JS |
1194 | } |
1195 | ||
1196 | /** | |
1197 | * lpfc_nvmet_unsol_ls_buffer - Process an unsolicited event data buffer | |
1198 | * @phba: pointer to lpfc hba data structure. | |
1199 | * @pring: pointer to a SLI ring. | |
1200 | * @nvmebuf: pointer to lpfc nvme command HBQ data structure. | |
1201 | * | |
1202 | * This routine is used for processing the WQE associated with a unsolicited | |
1203 | * event. It first determines whether there is an existing ndlp that matches | |
1204 | * the DID from the unsolicited WQE. If not, it will create a new one with | |
1205 | * the DID from the unsolicited WQE. The ELS command from the unsolicited | |
1206 | * WQE is then used to invoke the proper routine and to set up proper state | |
1207 | * of the discovery state machine. | |
1208 | **/ | |
1209 | static void | |
1210 | lpfc_nvmet_unsol_ls_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, | |
1211 | struct hbq_dmabuf *nvmebuf) | |
1212 | { | |
7d708033 | 1213 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
1214 | struct lpfc_nvmet_tgtport *tgtp; |
1215 | struct fc_frame_header *fc_hdr; | |
1216 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
1217 | uint32_t *payload; | |
1218 | uint32_t size, oxid, sid, rc; | |
1219 | ||
1220 | if (!nvmebuf || !phba->targetport) { | |
1221 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1222 | "6154 LS Drop IO\n"); | |
2b65e182 JS |
1223 | oxid = 0; |
1224 | size = 0; | |
1225 | sid = 0; | |
547077a4 | 1226 | ctxp = NULL; |
d613b6a7 JS |
1227 | goto dropit; |
1228 | } | |
1229 | ||
1230 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1231 | payload = (uint32_t *)(nvmebuf->dbuf.virt); | |
1232 | fc_hdr = (struct fc_frame_header *)(nvmebuf->hbuf.virt); | |
1233 | size = bf_get(lpfc_rcqe_length, &nvmebuf->cq_event.cqe.rcqe_cmpl); | |
1234 | oxid = be16_to_cpu(fc_hdr->fh_ox_id); | |
1235 | sid = sli4_sid_from_fc_hdr(fc_hdr); | |
1236 | ||
1237 | ctxp = kzalloc(sizeof(struct lpfc_nvmet_rcv_ctx), GFP_ATOMIC); | |
1238 | if (ctxp == NULL) { | |
1239 | atomic_inc(&tgtp->rcv_ls_req_drop); | |
1240 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1241 | "6155 LS Drop IO x%x: Alloc\n", | |
1242 | oxid); | |
1243 | dropit: | |
2b65e182 JS |
1244 | lpfc_nvmeio_data(phba, "NVMET LS DROP: " |
1245 | "xri x%x sz %d from %06x\n", | |
1246 | oxid, size, sid); | |
d613b6a7 JS |
1247 | if (nvmebuf) |
1248 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
1249 | return; | |
1250 | } | |
1251 | ctxp->phba = phba; | |
1252 | ctxp->size = size; | |
1253 | ctxp->oxid = oxid; | |
1254 | ctxp->sid = sid; | |
1255 | ctxp->wqeq = NULL; | |
1256 | ctxp->state = LPFC_NVMET_STE_RCV; | |
1257 | ctxp->rqb_buffer = (void *)nvmebuf; | |
2b65e182 JS |
1258 | |
1259 | lpfc_nvmeio_data(phba, "NVMET LS RCV: xri x%x sz %d from %06x\n", | |
1260 | oxid, size, sid); | |
d613b6a7 JS |
1261 | /* |
1262 | * The calling sequence should be: | |
1263 | * nvmet_fc_rcv_ls_req -> lpfc_nvmet_xmt_ls_rsp/cmp ->_req->done | |
1264 | * lpfc_nvmet_xmt_ls_rsp_cmp should free the allocated ctxp. | |
1265 | */ | |
1266 | atomic_inc(&tgtp->rcv_ls_req_in); | |
1267 | rc = nvmet_fc_rcv_ls_req(phba->targetport, &ctxp->ctx.ls_req, | |
1268 | payload, size); | |
1269 | ||
1270 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
1271 | "6037 %s: ctx %p sz %d rc %d: %08x %08x %08x " | |
1272 | "%08x %08x %08x\n", __func__, ctxp, size, rc, | |
1273 | *payload, *(payload+1), *(payload+2), | |
1274 | *(payload+3), *(payload+4), *(payload+5)); | |
2b65e182 | 1275 | |
d613b6a7 JS |
1276 | if (rc == 0) { |
1277 | atomic_inc(&tgtp->rcv_ls_req_out); | |
1278 | return; | |
1279 | } | |
2b65e182 JS |
1280 | |
1281 | lpfc_nvmeio_data(phba, "NVMET LS DROP: xri x%x sz %d from %06x\n", | |
1282 | oxid, size, sid); | |
1283 | ||
d613b6a7 JS |
1284 | atomic_inc(&tgtp->rcv_ls_req_drop); |
1285 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1286 | "6156 LS Drop IO x%x: nvmet_fc_rcv_ls_req %d\n", | |
1287 | ctxp->oxid, rc); | |
1288 | ||
1289 | /* We assume a rcv'ed cmd ALWAYs fits into 1 buffer */ | |
1290 | if (nvmebuf) | |
1291 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
1292 | ||
1293 | atomic_inc(&tgtp->xmt_ls_abort); | |
1294 | lpfc_nvmet_unsol_ls_issue_abort(phba, ctxp, sid, oxid); | |
166d7211 | 1295 | #endif |
d613b6a7 JS |
1296 | } |
1297 | ||
1298 | /** | |
1299 | * lpfc_nvmet_unsol_fcp_buffer - Process an unsolicited event data buffer | |
1300 | * @phba: pointer to lpfc hba data structure. | |
1301 | * @pring: pointer to a SLI ring. | |
1302 | * @nvmebuf: pointer to lpfc nvme command HBQ data structure. | |
1303 | * | |
1304 | * This routine is used for processing the WQE associated with a unsolicited | |
1305 | * event. It first determines whether there is an existing ndlp that matches | |
1306 | * the DID from the unsolicited WQE. If not, it will create a new one with | |
1307 | * the DID from the unsolicited WQE. The ELS command from the unsolicited | |
1308 | * WQE is then used to invoke the proper routine and to set up proper state | |
1309 | * of the discovery state machine. | |
1310 | **/ | |
1311 | static void | |
1312 | lpfc_nvmet_unsol_fcp_buffer(struct lpfc_hba *phba, | |
1313 | struct lpfc_sli_ring *pring, | |
1314 | struct rqb_dmabuf *nvmebuf, | |
1315 | uint64_t isr_timestamp) | |
1316 | { | |
7d708033 | 1317 | #if (IS_ENABLED(CONFIG_NVME_TARGET_FC)) |
d613b6a7 JS |
1318 | struct lpfc_nvmet_rcv_ctx *ctxp; |
1319 | struct lpfc_nvmet_tgtport *tgtp; | |
1320 | struct fc_frame_header *fc_hdr; | |
6c621a22 | 1321 | struct lpfc_nvmet_ctxbuf *ctx_buf; |
d613b6a7 | 1322 | uint32_t *payload; |
a8cf5dfe | 1323 | uint32_t size, oxid, sid, rc, qno; |
6c621a22 | 1324 | unsigned long iflag; |
2b65e182 JS |
1325 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
1326 | uint32_t id; | |
1327 | #endif | |
d613b6a7 | 1328 | |
6c621a22 | 1329 | ctx_buf = NULL; |
d613b6a7 JS |
1330 | if (!nvmebuf || !phba->targetport) { |
1331 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
6c621a22 | 1332 | "6157 NVMET FCP Drop IO\n"); |
2b65e182 JS |
1333 | oxid = 0; |
1334 | size = 0; | |
1335 | sid = 0; | |
547077a4 | 1336 | ctxp = NULL; |
d613b6a7 JS |
1337 | goto dropit; |
1338 | } | |
1339 | ||
6c621a22 JS |
1340 | spin_lock_irqsave(&phba->sli4_hba.nvmet_io_lock, iflag); |
1341 | if (phba->sli4_hba.nvmet_ctx_cnt) { | |
1342 | list_remove_head(&phba->sli4_hba.lpfc_nvmet_ctx_list, | |
1343 | ctx_buf, struct lpfc_nvmet_ctxbuf, list); | |
1344 | phba->sli4_hba.nvmet_ctx_cnt--; | |
1345 | } | |
1346 | spin_unlock_irqrestore(&phba->sli4_hba.nvmet_io_lock, iflag); | |
d613b6a7 | 1347 | |
d613b6a7 | 1348 | fc_hdr = (struct fc_frame_header *)(nvmebuf->hbuf.virt); |
d613b6a7 | 1349 | oxid = be16_to_cpu(fc_hdr->fh_ox_id); |
a8cf5dfe | 1350 | size = nvmebuf->bytes_recv; |
d613b6a7 | 1351 | |
a8cf5dfe JS |
1352 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
1353 | if (phba->cpucheck_on & LPFC_CHECK_NVMET_RCV) { | |
1354 | id = smp_processor_id(); | |
1355 | if (id < LPFC_CHECK_CPU_CNT) | |
1356 | phba->cpucheck_rcv_io[id]++; | |
1357 | } | |
1358 | #endif | |
1359 | ||
1360 | lpfc_nvmeio_data(phba, "NVMET FCP RCV: xri x%x sz %d CPU %02x\n", | |
1361 | oxid, size, smp_processor_id()); | |
1362 | ||
6c621a22 | 1363 | if (!ctx_buf) { |
a8cf5dfe JS |
1364 | /* Queue this NVME IO to process later */ |
1365 | spin_lock_irqsave(&phba->sli4_hba.nvmet_io_wait_lock, iflag); | |
1366 | list_add_tail(&nvmebuf->hbuf.list, | |
1367 | &phba->sli4_hba.lpfc_nvmet_io_wait_list); | |
1368 | phba->sli4_hba.nvmet_io_wait_cnt++; | |
1369 | phba->sli4_hba.nvmet_io_wait_total++; | |
1370 | spin_unlock_irqrestore(&phba->sli4_hba.nvmet_io_wait_lock, | |
1371 | iflag); | |
1372 | ||
1373 | /* Post a brand new DMA buffer to RQ */ | |
1374 | qno = nvmebuf->idx; | |
1375 | lpfc_post_rq_buffer( | |
1376 | phba, phba->sli4_hba.nvmet_mrq_hdr[qno], | |
1377 | phba->sli4_hba.nvmet_mrq_data[qno], 1, qno); | |
d613b6a7 JS |
1378 | return; |
1379 | } | |
d613b6a7 JS |
1380 | |
1381 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1382 | payload = (uint32_t *)(nvmebuf->dbuf.virt); | |
d613b6a7 JS |
1383 | sid = sli4_sid_from_fc_hdr(fc_hdr); |
1384 | ||
6c621a22 | 1385 | ctxp = (struct lpfc_nvmet_rcv_ctx *)ctx_buf->context; |
d613b6a7 JS |
1386 | memset(ctxp, 0, sizeof(ctxp->ctx)); |
1387 | ctxp->wqeq = NULL; | |
1388 | ctxp->txrdy = NULL; | |
1389 | ctxp->offset = 0; | |
1390 | ctxp->phba = phba; | |
1391 | ctxp->size = size; | |
1392 | ctxp->oxid = oxid; | |
1393 | ctxp->sid = sid; | |
1394 | ctxp->state = LPFC_NVMET_STE_RCV; | |
d613b6a7 JS |
1395 | ctxp->entry_cnt = 1; |
1396 | ctxp->flag = 0; | |
6c621a22 | 1397 | ctxp->ctxbuf = ctx_buf; |
2b7824d0 | 1398 | spin_lock_init(&ctxp->ctxlock); |
d613b6a7 | 1399 | |
2b65e182 JS |
1400 | #ifdef CONFIG_SCSI_LPFC_DEBUG_FS |
1401 | if (phba->ktime_on) { | |
1402 | ctxp->ts_isr_cmd = isr_timestamp; | |
1403 | ctxp->ts_cmd_nvme = ktime_get_ns(); | |
1404 | ctxp->ts_nvme_data = 0; | |
1405 | ctxp->ts_data_wqput = 0; | |
1406 | ctxp->ts_isr_data = 0; | |
1407 | ctxp->ts_data_nvme = 0; | |
1408 | ctxp->ts_nvme_status = 0; | |
1409 | ctxp->ts_status_wqput = 0; | |
1410 | ctxp->ts_isr_status = 0; | |
1411 | ctxp->ts_status_nvme = 0; | |
1412 | } | |
2b65e182 JS |
1413 | #endif |
1414 | ||
d613b6a7 JS |
1415 | atomic_inc(&tgtp->rcv_fcp_cmd_in); |
1416 | /* | |
1417 | * The calling sequence should be: | |
1418 | * nvmet_fc_rcv_fcp_req -> lpfc_nvmet_xmt_fcp_op/cmp -> req->done | |
1419 | * lpfc_nvmet_xmt_fcp_op_cmp should free the allocated ctxp. | |
6c621a22 JS |
1420 | * When we return from nvmet_fc_rcv_fcp_req, all relevant info in |
1421 | * the NVME command / FC header is stored, so we are free to repost | |
1422 | * the buffer. | |
d613b6a7 JS |
1423 | */ |
1424 | rc = nvmet_fc_rcv_fcp_req(phba->targetport, &ctxp->ctx.fcp_req, | |
1425 | payload, size); | |
1426 | ||
1427 | /* Process FCP command */ | |
1428 | if (rc == 0) { | |
1429 | atomic_inc(&tgtp->rcv_fcp_cmd_out); | |
6c621a22 | 1430 | lpfc_rq_buf_free(phba, &nvmebuf->hbuf); /* repost */ |
d613b6a7 JS |
1431 | return; |
1432 | } | |
1433 | ||
1434 | atomic_inc(&tgtp->rcv_fcp_cmd_drop); | |
1435 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
547077a4 JS |
1436 | "6159 FCP Drop IO x%x: err x%x: x%x x%x x%x\n", |
1437 | ctxp->oxid, rc, | |
1438 | atomic_read(&tgtp->rcv_fcp_cmd_in), | |
1439 | atomic_read(&tgtp->rcv_fcp_cmd_out), | |
1440 | atomic_read(&tgtp->xmt_fcp_release)); | |
d613b6a7 | 1441 | dropit: |
2b65e182 JS |
1442 | lpfc_nvmeio_data(phba, "NVMET FCP DROP: xri x%x sz %d from %06x\n", |
1443 | oxid, size, sid); | |
d613b6a7 | 1444 | if (oxid) { |
6c621a22 | 1445 | lpfc_nvmet_defer_release(phba, ctxp); |
d613b6a7 | 1446 | lpfc_nvmet_unsol_fcp_issue_abort(phba, ctxp, sid, oxid); |
6c621a22 | 1447 | lpfc_rq_buf_free(phba, &nvmebuf->hbuf); /* repost */ |
d613b6a7 JS |
1448 | return; |
1449 | } | |
1450 | ||
6c621a22 JS |
1451 | if (ctx_buf) |
1452 | lpfc_nvmet_ctxbuf_post(phba, ctx_buf); | |
1453 | ||
1454 | if (nvmebuf) | |
1455 | lpfc_rq_buf_free(phba, &nvmebuf->hbuf); /* repost */ | |
166d7211 | 1456 | #endif |
d613b6a7 JS |
1457 | } |
1458 | ||
1459 | /** | |
1460 | * lpfc_nvmet_unsol_ls_event - Process an unsolicited event from an nvme nport | |
1461 | * @phba: pointer to lpfc hba data structure. | |
1462 | * @pring: pointer to a SLI ring. | |
1463 | * @nvmebuf: pointer to received nvme data structure. | |
1464 | * | |
1465 | * This routine is used to process an unsolicited event received from a SLI | |
1466 | * (Service Level Interface) ring. The actual processing of the data buffer | |
1467 | * associated with the unsolicited event is done by invoking the routine | |
1468 | * lpfc_nvmet_unsol_ls_buffer() after properly set up the buffer from the | |
1469 | * SLI RQ on which the unsolicited event was received. | |
1470 | **/ | |
1471 | void | |
1472 | lpfc_nvmet_unsol_ls_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, | |
1473 | struct lpfc_iocbq *piocb) | |
1474 | { | |
1475 | struct lpfc_dmabuf *d_buf; | |
1476 | struct hbq_dmabuf *nvmebuf; | |
1477 | ||
1478 | d_buf = piocb->context2; | |
1479 | nvmebuf = container_of(d_buf, struct hbq_dmabuf, dbuf); | |
1480 | ||
1481 | if (phba->nvmet_support == 0) { | |
1482 | lpfc_in_buf_free(phba, &nvmebuf->dbuf); | |
1483 | return; | |
1484 | } | |
1485 | lpfc_nvmet_unsol_ls_buffer(phba, pring, nvmebuf); | |
1486 | } | |
1487 | ||
1488 | /** | |
1489 | * lpfc_nvmet_unsol_fcp_event - Process an unsolicited event from an nvme nport | |
1490 | * @phba: pointer to lpfc hba data structure. | |
1491 | * @pring: pointer to a SLI ring. | |
1492 | * @nvmebuf: pointer to received nvme data structure. | |
1493 | * | |
1494 | * This routine is used to process an unsolicited event received from a SLI | |
1495 | * (Service Level Interface) ring. The actual processing of the data buffer | |
1496 | * associated with the unsolicited event is done by invoking the routine | |
1497 | * lpfc_nvmet_unsol_fcp_buffer() after properly set up the buffer from the | |
1498 | * SLI RQ on which the unsolicited event was received. | |
1499 | **/ | |
1500 | void | |
1501 | lpfc_nvmet_unsol_fcp_event(struct lpfc_hba *phba, | |
1502 | struct lpfc_sli_ring *pring, | |
1503 | struct rqb_dmabuf *nvmebuf, | |
1504 | uint64_t isr_timestamp) | |
1505 | { | |
1506 | if (phba->nvmet_support == 0) { | |
6c621a22 | 1507 | lpfc_rq_buf_free(phba, &nvmebuf->hbuf); |
d613b6a7 JS |
1508 | return; |
1509 | } | |
1510 | lpfc_nvmet_unsol_fcp_buffer(phba, pring, nvmebuf, | |
1511 | isr_timestamp); | |
1512 | } | |
1513 | ||
1514 | /** | |
1515 | * lpfc_nvmet_prep_ls_wqe - Allocate and prepare a lpfc wqe data structure | |
1516 | * @phba: pointer to a host N_Port data structure. | |
1517 | * @ctxp: Context info for NVME LS Request | |
1518 | * @rspbuf: DMA buffer of NVME command. | |
1519 | * @rspsize: size of the NVME command. | |
1520 | * | |
1521 | * This routine is used for allocating a lpfc-WQE data structure from | |
1522 | * the driver lpfc-WQE free-list and prepare the WQE with the parameters | |
1523 | * passed into the routine for discovery state machine to issue an Extended | |
1524 | * Link Service (NVME) commands. It is a generic lpfc-WQE allocation | |
1525 | * and preparation routine that is used by all the discovery state machine | |
1526 | * routines and the NVME command-specific fields will be later set up by | |
1527 | * the individual discovery machine routines after calling this routine | |
1528 | * allocating and preparing a generic WQE data structure. It fills in the | |
1529 | * Buffer Descriptor Entries (BDEs), allocates buffers for both command | |
1530 | * payload and response payload (if expected). The reference count on the | |
1531 | * ndlp is incremented by 1 and the reference to the ndlp is put into | |
1532 | * context1 of the WQE data structure for this WQE to hold the ndlp | |
1533 | * reference for the command's callback function to access later. | |
1534 | * | |
1535 | * Return code | |
1536 | * Pointer to the newly allocated/prepared nvme wqe data structure | |
1537 | * NULL - when nvme wqe data structure allocation/preparation failed | |
1538 | **/ | |
1539 | static struct lpfc_iocbq * | |
1540 | lpfc_nvmet_prep_ls_wqe(struct lpfc_hba *phba, | |
1541 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
1542 | dma_addr_t rspbuf, uint16_t rspsize) | |
1543 | { | |
1544 | struct lpfc_nodelist *ndlp; | |
1545 | struct lpfc_iocbq *nvmewqe; | |
1546 | union lpfc_wqe *wqe; | |
1547 | ||
1548 | if (!lpfc_is_link_up(phba)) { | |
1549 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1550 | "6104 lpfc_nvmet_prep_ls_wqe: link err: " | |
1551 | "NPORT x%x oxid:x%x\n", | |
1552 | ctxp->sid, ctxp->oxid); | |
1553 | return NULL; | |
1554 | } | |
1555 | ||
1556 | /* Allocate buffer for command wqe */ | |
1557 | nvmewqe = lpfc_sli_get_iocbq(phba); | |
1558 | if (nvmewqe == NULL) { | |
1559 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1560 | "6105 lpfc_nvmet_prep_ls_wqe: No WQE: " | |
1561 | "NPORT x%x oxid:x%x\n", | |
1562 | ctxp->sid, ctxp->oxid); | |
1563 | return NULL; | |
1564 | } | |
1565 | ||
1566 | ndlp = lpfc_findnode_did(phba->pport, ctxp->sid); | |
1567 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1568 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1569 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1570 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC, | |
1571 | "6106 lpfc_nvmet_prep_ls_wqe: No ndlp: " | |
1572 | "NPORT x%x oxid:x%x\n", | |
1573 | ctxp->sid, ctxp->oxid); | |
1574 | goto nvme_wqe_free_wqeq_exit; | |
1575 | } | |
1576 | ctxp->wqeq = nvmewqe; | |
1577 | ||
1578 | /* prevent preparing wqe with NULL ndlp reference */ | |
1579 | nvmewqe->context1 = lpfc_nlp_get(ndlp); | |
1580 | if (nvmewqe->context1 == NULL) | |
1581 | goto nvme_wqe_free_wqeq_exit; | |
1582 | nvmewqe->context2 = ctxp; | |
1583 | ||
1584 | wqe = &nvmewqe->wqe; | |
1585 | memset(wqe, 0, sizeof(union lpfc_wqe)); | |
1586 | ||
1587 | /* Words 0 - 2 */ | |
1588 | wqe->xmit_sequence.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1589 | wqe->xmit_sequence.bde.tus.f.bdeSize = rspsize; | |
1590 | wqe->xmit_sequence.bde.addrLow = le32_to_cpu(putPaddrLow(rspbuf)); | |
1591 | wqe->xmit_sequence.bde.addrHigh = le32_to_cpu(putPaddrHigh(rspbuf)); | |
1592 | ||
1593 | /* Word 3 */ | |
1594 | ||
1595 | /* Word 4 */ | |
1596 | ||
1597 | /* Word 5 */ | |
1598 | bf_set(wqe_dfctl, &wqe->xmit_sequence.wge_ctl, 0); | |
1599 | bf_set(wqe_ls, &wqe->xmit_sequence.wge_ctl, 1); | |
1600 | bf_set(wqe_la, &wqe->xmit_sequence.wge_ctl, 0); | |
8b361639 | 1601 | bf_set(wqe_rctl, &wqe->xmit_sequence.wge_ctl, FC_RCTL_ELS4_REP); |
d613b6a7 JS |
1602 | bf_set(wqe_type, &wqe->xmit_sequence.wge_ctl, FC_TYPE_NVME); |
1603 | ||
1604 | /* Word 6 */ | |
1605 | bf_set(wqe_ctxt_tag, &wqe->xmit_sequence.wqe_com, | |
1606 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1607 | bf_set(wqe_xri_tag, &wqe->xmit_sequence.wqe_com, nvmewqe->sli4_xritag); | |
1608 | ||
1609 | /* Word 7 */ | |
1610 | bf_set(wqe_cmnd, &wqe->xmit_sequence.wqe_com, | |
1611 | CMD_XMIT_SEQUENCE64_WQE); | |
1612 | bf_set(wqe_ct, &wqe->xmit_sequence.wqe_com, SLI4_CT_RPI); | |
1613 | bf_set(wqe_class, &wqe->xmit_sequence.wqe_com, CLASS3); | |
1614 | bf_set(wqe_pu, &wqe->xmit_sequence.wqe_com, 0); | |
1615 | ||
1616 | /* Word 8 */ | |
1617 | wqe->xmit_sequence.wqe_com.abort_tag = nvmewqe->iotag; | |
1618 | ||
1619 | /* Word 9 */ | |
1620 | bf_set(wqe_reqtag, &wqe->xmit_sequence.wqe_com, nvmewqe->iotag); | |
1621 | /* Needs to be set by caller */ | |
1622 | bf_set(wqe_rcvoxid, &wqe->xmit_sequence.wqe_com, ctxp->oxid); | |
1623 | ||
1624 | /* Word 10 */ | |
1625 | bf_set(wqe_dbde, &wqe->xmit_sequence.wqe_com, 1); | |
1626 | bf_set(wqe_iod, &wqe->xmit_sequence.wqe_com, LPFC_WQE_IOD_WRITE); | |
1627 | bf_set(wqe_lenloc, &wqe->xmit_sequence.wqe_com, | |
1628 | LPFC_WQE_LENLOC_WORD12); | |
1629 | bf_set(wqe_ebde_cnt, &wqe->xmit_sequence.wqe_com, 0); | |
1630 | ||
1631 | /* Word 11 */ | |
1632 | bf_set(wqe_cqid, &wqe->xmit_sequence.wqe_com, | |
1633 | LPFC_WQE_CQ_ID_DEFAULT); | |
1634 | bf_set(wqe_cmd_type, &wqe->xmit_sequence.wqe_com, | |
1635 | OTHER_COMMAND); | |
1636 | ||
1637 | /* Word 12 */ | |
1638 | wqe->xmit_sequence.xmit_len = rspsize; | |
1639 | ||
1640 | nvmewqe->retry = 1; | |
1641 | nvmewqe->vport = phba->pport; | |
1642 | nvmewqe->drvrTimeout = (phba->fc_ratov * 3) + LPFC_DRVR_TIMEOUT; | |
1643 | nvmewqe->iocb_flag |= LPFC_IO_NVME_LS; | |
1644 | ||
1645 | /* Xmit NVME response to remote NPORT <did> */ | |
1646 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC, | |
1647 | "6039 Xmit NVME LS response to remote " | |
1648 | "NPORT x%x iotag:x%x oxid:x%x size:x%x\n", | |
1649 | ndlp->nlp_DID, nvmewqe->iotag, ctxp->oxid, | |
1650 | rspsize); | |
1651 | return nvmewqe; | |
1652 | ||
1653 | nvme_wqe_free_wqeq_exit: | |
1654 | nvmewqe->context2 = NULL; | |
1655 | nvmewqe->context3 = NULL; | |
1656 | lpfc_sli_release_iocbq(phba, nvmewqe); | |
1657 | return NULL; | |
1658 | } | |
1659 | ||
1660 | ||
1661 | static struct lpfc_iocbq * | |
1662 | lpfc_nvmet_prep_fcp_wqe(struct lpfc_hba *phba, | |
1663 | struct lpfc_nvmet_rcv_ctx *ctxp) | |
1664 | { | |
1665 | struct nvmefc_tgt_fcp_req *rsp = &ctxp->ctx.fcp_req; | |
1666 | struct lpfc_nvmet_tgtport *tgtp; | |
1667 | struct sli4_sge *sgl; | |
1668 | struct lpfc_nodelist *ndlp; | |
1669 | struct lpfc_iocbq *nvmewqe; | |
1670 | struct scatterlist *sgel; | |
1671 | union lpfc_wqe128 *wqe; | |
1672 | uint32_t *txrdy; | |
1673 | dma_addr_t physaddr; | |
1674 | int i, cnt; | |
1675 | int xc = 1; | |
1676 | ||
1677 | if (!lpfc_is_link_up(phba)) { | |
1678 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1679 | "6107 lpfc_nvmet_prep_fcp_wqe: link err:" | |
1680 | "NPORT x%x oxid:x%x\n", ctxp->sid, | |
1681 | ctxp->oxid); | |
1682 | return NULL; | |
1683 | } | |
1684 | ||
1685 | ndlp = lpfc_findnode_did(phba->pport, ctxp->sid); | |
1686 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
1687 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
1688 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
1689 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1690 | "6108 lpfc_nvmet_prep_fcp_wqe: no ndlp: " | |
1691 | "NPORT x%x oxid:x%x\n", | |
1692 | ctxp->sid, ctxp->oxid); | |
1693 | return NULL; | |
1694 | } | |
1695 | ||
4d4c4a4a | 1696 | if (rsp->sg_cnt > phba->cfg_nvme_seg_cnt) { |
d613b6a7 JS |
1697 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, |
1698 | "6109 lpfc_nvmet_prep_fcp_wqe: seg cnt err: " | |
4d4c4a4a JS |
1699 | "NPORT x%x oxid:x%x cnt %d\n", |
1700 | ctxp->sid, ctxp->oxid, phba->cfg_nvme_seg_cnt); | |
d613b6a7 JS |
1701 | return NULL; |
1702 | } | |
1703 | ||
1704 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
1705 | nvmewqe = ctxp->wqeq; | |
1706 | if (nvmewqe == NULL) { | |
1707 | /* Allocate buffer for command wqe */ | |
6c621a22 | 1708 | nvmewqe = ctxp->ctxbuf->iocbq; |
d613b6a7 JS |
1709 | if (nvmewqe == NULL) { |
1710 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1711 | "6110 lpfc_nvmet_prep_fcp_wqe: No " | |
1712 | "WQE: NPORT x%x oxid:x%x\n", | |
1713 | ctxp->sid, ctxp->oxid); | |
1714 | return NULL; | |
1715 | } | |
1716 | ctxp->wqeq = nvmewqe; | |
1717 | xc = 0; /* create new XRI */ | |
1718 | nvmewqe->sli4_lxritag = NO_XRI; | |
1719 | nvmewqe->sli4_xritag = NO_XRI; | |
1720 | } | |
1721 | ||
1722 | /* Sanity check */ | |
1723 | if (((ctxp->state == LPFC_NVMET_STE_RCV) && | |
1724 | (ctxp->entry_cnt == 1)) || | |
1725 | ((ctxp->state == LPFC_NVMET_STE_DATA) && | |
1726 | (ctxp->entry_cnt > 1))) { | |
1727 | wqe = (union lpfc_wqe128 *)&nvmewqe->wqe; | |
1728 | } else { | |
1729 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1730 | "6111 Wrong state %s: %d cnt %d\n", | |
1731 | __func__, ctxp->state, ctxp->entry_cnt); | |
1732 | return NULL; | |
1733 | } | |
1734 | ||
6c621a22 | 1735 | sgl = (struct sli4_sge *)ctxp->ctxbuf->sglq->sgl; |
d613b6a7 JS |
1736 | switch (rsp->op) { |
1737 | case NVMET_FCOP_READDATA: | |
1738 | case NVMET_FCOP_READDATA_RSP: | |
1739 | /* Words 0 - 2 : The first sg segment */ | |
1740 | sgel = &rsp->sg[0]; | |
1741 | physaddr = sg_dma_address(sgel); | |
1742 | wqe->fcp_tsend.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1743 | wqe->fcp_tsend.bde.tus.f.bdeSize = sg_dma_len(sgel); | |
1744 | wqe->fcp_tsend.bde.addrLow = cpu_to_le32(putPaddrLow(physaddr)); | |
1745 | wqe->fcp_tsend.bde.addrHigh = | |
1746 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1747 | ||
1748 | /* Word 3 */ | |
1749 | wqe->fcp_tsend.payload_offset_len = 0; | |
1750 | ||
1751 | /* Word 4 */ | |
1752 | wqe->fcp_tsend.relative_offset = ctxp->offset; | |
1753 | ||
1754 | /* Word 5 */ | |
1755 | ||
1756 | /* Word 6 */ | |
1757 | bf_set(wqe_ctxt_tag, &wqe->fcp_tsend.wqe_com, | |
1758 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1759 | bf_set(wqe_xri_tag, &wqe->fcp_tsend.wqe_com, | |
1760 | nvmewqe->sli4_xritag); | |
1761 | ||
1762 | /* Word 7 */ | |
1763 | bf_set(wqe_cmnd, &wqe->fcp_tsend.wqe_com, CMD_FCP_TSEND64_WQE); | |
1764 | ||
1765 | /* Word 8 */ | |
1766 | wqe->fcp_tsend.wqe_com.abort_tag = nvmewqe->iotag; | |
1767 | ||
1768 | /* Word 9 */ | |
1769 | bf_set(wqe_reqtag, &wqe->fcp_tsend.wqe_com, nvmewqe->iotag); | |
1770 | bf_set(wqe_rcvoxid, &wqe->fcp_tsend.wqe_com, ctxp->oxid); | |
1771 | ||
1772 | /* Word 10 */ | |
1773 | bf_set(wqe_nvme, &wqe->fcp_tsend.wqe_com, 1); | |
1774 | bf_set(wqe_dbde, &wqe->fcp_tsend.wqe_com, 1); | |
1775 | bf_set(wqe_iod, &wqe->fcp_tsend.wqe_com, LPFC_WQE_IOD_WRITE); | |
1776 | bf_set(wqe_lenloc, &wqe->fcp_tsend.wqe_com, | |
1777 | LPFC_WQE_LENLOC_WORD12); | |
1778 | bf_set(wqe_ebde_cnt, &wqe->fcp_tsend.wqe_com, 0); | |
1779 | bf_set(wqe_xc, &wqe->fcp_tsend.wqe_com, xc); | |
1780 | bf_set(wqe_nvme, &wqe->fcp_tsend.wqe_com, 1); | |
1781 | if (phba->cfg_nvme_oas) | |
1782 | bf_set(wqe_oas, &wqe->fcp_tsend.wqe_com, 1); | |
1783 | ||
1784 | /* Word 11 */ | |
1785 | bf_set(wqe_cqid, &wqe->fcp_tsend.wqe_com, | |
1786 | LPFC_WQE_CQ_ID_DEFAULT); | |
1787 | bf_set(wqe_cmd_type, &wqe->fcp_tsend.wqe_com, | |
1788 | FCP_COMMAND_TSEND); | |
1789 | ||
1790 | /* Word 12 */ | |
1791 | wqe->fcp_tsend.fcp_data_len = rsp->transfer_length; | |
1792 | ||
1793 | /* Setup 2 SKIP SGEs */ | |
1794 | sgl->addr_hi = 0; | |
1795 | sgl->addr_lo = 0; | |
1796 | sgl->word2 = 0; | |
1797 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1798 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1799 | sgl->sge_len = 0; | |
1800 | sgl++; | |
1801 | sgl->addr_hi = 0; | |
1802 | sgl->addr_lo = 0; | |
1803 | sgl->word2 = 0; | |
1804 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1805 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1806 | sgl->sge_len = 0; | |
1807 | sgl++; | |
1808 | if (rsp->op == NVMET_FCOP_READDATA_RSP) { | |
1809 | atomic_inc(&tgtp->xmt_fcp_read_rsp); | |
1810 | bf_set(wqe_ar, &wqe->fcp_tsend.wqe_com, 1); | |
1811 | if ((ndlp->nlp_flag & NLP_SUPPRESS_RSP) && | |
1812 | (rsp->rsplen == 12)) { | |
1813 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 1); | |
1814 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 0); | |
1815 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 0); | |
1816 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, 0); | |
1817 | } else { | |
1818 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1819 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 1); | |
1820 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 1); | |
1821 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, | |
1822 | ((rsp->rsplen >> 2) - 1)); | |
1823 | memcpy(&wqe->words[16], rsp->rspaddr, | |
1824 | rsp->rsplen); | |
1825 | } | |
1826 | } else { | |
1827 | atomic_inc(&tgtp->xmt_fcp_read); | |
1828 | ||
1829 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1830 | bf_set(wqe_wqes, &wqe->fcp_tsend.wqe_com, 0); | |
1831 | bf_set(wqe_irsp, &wqe->fcp_tsend.wqe_com, 0); | |
1832 | bf_set(wqe_ar, &wqe->fcp_tsend.wqe_com, 0); | |
1833 | bf_set(wqe_irsplen, &wqe->fcp_tsend.wqe_com, 0); | |
1834 | } | |
1835 | ctxp->state = LPFC_NVMET_STE_DATA; | |
1836 | break; | |
1837 | ||
1838 | case NVMET_FCOP_WRITEDATA: | |
1839 | /* Words 0 - 2 : The first sg segment */ | |
1840 | txrdy = pci_pool_alloc(phba->txrdy_payload_pool, | |
1841 | GFP_KERNEL, &physaddr); | |
1842 | if (!txrdy) { | |
1843 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_IOERR, | |
1844 | "6041 Bad txrdy buffer: oxid x%x\n", | |
1845 | ctxp->oxid); | |
1846 | return NULL; | |
1847 | } | |
1848 | ctxp->txrdy = txrdy; | |
1849 | ctxp->txrdy_phys = physaddr; | |
1850 | wqe->fcp_treceive.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1851 | wqe->fcp_treceive.bde.tus.f.bdeSize = TXRDY_PAYLOAD_LEN; | |
1852 | wqe->fcp_treceive.bde.addrLow = | |
1853 | cpu_to_le32(putPaddrLow(physaddr)); | |
1854 | wqe->fcp_treceive.bde.addrHigh = | |
1855 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1856 | ||
1857 | /* Word 3 */ | |
1858 | wqe->fcp_treceive.payload_offset_len = TXRDY_PAYLOAD_LEN; | |
1859 | ||
1860 | /* Word 4 */ | |
1861 | wqe->fcp_treceive.relative_offset = ctxp->offset; | |
1862 | ||
1863 | /* Word 5 */ | |
1864 | ||
1865 | /* Word 6 */ | |
1866 | bf_set(wqe_ctxt_tag, &wqe->fcp_treceive.wqe_com, | |
1867 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1868 | bf_set(wqe_xri_tag, &wqe->fcp_treceive.wqe_com, | |
1869 | nvmewqe->sli4_xritag); | |
1870 | ||
1871 | /* Word 7 */ | |
1872 | bf_set(wqe_ar, &wqe->fcp_treceive.wqe_com, 0); | |
1873 | bf_set(wqe_cmnd, &wqe->fcp_treceive.wqe_com, | |
1874 | CMD_FCP_TRECEIVE64_WQE); | |
1875 | ||
1876 | /* Word 8 */ | |
1877 | wqe->fcp_treceive.wqe_com.abort_tag = nvmewqe->iotag; | |
1878 | ||
1879 | /* Word 9 */ | |
1880 | bf_set(wqe_reqtag, &wqe->fcp_treceive.wqe_com, nvmewqe->iotag); | |
1881 | bf_set(wqe_rcvoxid, &wqe->fcp_treceive.wqe_com, ctxp->oxid); | |
1882 | ||
1883 | /* Word 10 */ | |
1884 | bf_set(wqe_nvme, &wqe->fcp_treceive.wqe_com, 1); | |
1885 | bf_set(wqe_dbde, &wqe->fcp_treceive.wqe_com, 1); | |
1886 | bf_set(wqe_iod, &wqe->fcp_treceive.wqe_com, LPFC_WQE_IOD_READ); | |
1887 | bf_set(wqe_lenloc, &wqe->fcp_treceive.wqe_com, | |
1888 | LPFC_WQE_LENLOC_WORD12); | |
1889 | bf_set(wqe_xc, &wqe->fcp_treceive.wqe_com, xc); | |
1890 | bf_set(wqe_wqes, &wqe->fcp_treceive.wqe_com, 0); | |
1891 | bf_set(wqe_irsp, &wqe->fcp_treceive.wqe_com, 0); | |
1892 | bf_set(wqe_irsplen, &wqe->fcp_treceive.wqe_com, 0); | |
1893 | bf_set(wqe_nvme, &wqe->fcp_treceive.wqe_com, 1); | |
1894 | if (phba->cfg_nvme_oas) | |
1895 | bf_set(wqe_oas, &wqe->fcp_treceive.wqe_com, 1); | |
1896 | ||
1897 | /* Word 11 */ | |
1898 | bf_set(wqe_cqid, &wqe->fcp_treceive.wqe_com, | |
1899 | LPFC_WQE_CQ_ID_DEFAULT); | |
1900 | bf_set(wqe_cmd_type, &wqe->fcp_treceive.wqe_com, | |
1901 | FCP_COMMAND_TRECEIVE); | |
1902 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1903 | ||
1904 | /* Word 12 */ | |
1905 | wqe->fcp_tsend.fcp_data_len = rsp->transfer_length; | |
1906 | ||
1907 | /* Setup 1 TXRDY and 1 SKIP SGE */ | |
1908 | txrdy[0] = 0; | |
1909 | txrdy[1] = cpu_to_be32(rsp->transfer_length); | |
1910 | txrdy[2] = 0; | |
1911 | ||
1912 | sgl->addr_hi = putPaddrHigh(physaddr); | |
1913 | sgl->addr_lo = putPaddrLow(physaddr); | |
1914 | sgl->word2 = 0; | |
1915 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); | |
1916 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1917 | sgl->sge_len = cpu_to_le32(TXRDY_PAYLOAD_LEN); | |
1918 | sgl++; | |
1919 | sgl->addr_hi = 0; | |
1920 | sgl->addr_lo = 0; | |
1921 | sgl->word2 = 0; | |
1922 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_SKIP); | |
1923 | sgl->word2 = cpu_to_le32(sgl->word2); | |
1924 | sgl->sge_len = 0; | |
1925 | sgl++; | |
1926 | ctxp->state = LPFC_NVMET_STE_DATA; | |
1927 | atomic_inc(&tgtp->xmt_fcp_write); | |
1928 | break; | |
1929 | ||
1930 | case NVMET_FCOP_RSP: | |
1931 | /* Words 0 - 2 */ | |
d613b6a7 JS |
1932 | physaddr = rsp->rspdma; |
1933 | wqe->fcp_trsp.bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; | |
1934 | wqe->fcp_trsp.bde.tus.f.bdeSize = rsp->rsplen; | |
1935 | wqe->fcp_trsp.bde.addrLow = | |
1936 | cpu_to_le32(putPaddrLow(physaddr)); | |
1937 | wqe->fcp_trsp.bde.addrHigh = | |
1938 | cpu_to_le32(putPaddrHigh(physaddr)); | |
1939 | ||
1940 | /* Word 3 */ | |
1941 | wqe->fcp_trsp.response_len = rsp->rsplen; | |
1942 | ||
1943 | /* Word 4 */ | |
1944 | wqe->fcp_trsp.rsvd_4_5[0] = 0; | |
1945 | ||
1946 | ||
1947 | /* Word 5 */ | |
1948 | ||
1949 | /* Word 6 */ | |
1950 | bf_set(wqe_ctxt_tag, &wqe->fcp_trsp.wqe_com, | |
1951 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
1952 | bf_set(wqe_xri_tag, &wqe->fcp_trsp.wqe_com, | |
1953 | nvmewqe->sli4_xritag); | |
1954 | ||
1955 | /* Word 7 */ | |
1956 | bf_set(wqe_ag, &wqe->fcp_trsp.wqe_com, 1); | |
1957 | bf_set(wqe_cmnd, &wqe->fcp_trsp.wqe_com, CMD_FCP_TRSP64_WQE); | |
1958 | ||
1959 | /* Word 8 */ | |
1960 | wqe->fcp_trsp.wqe_com.abort_tag = nvmewqe->iotag; | |
1961 | ||
1962 | /* Word 9 */ | |
1963 | bf_set(wqe_reqtag, &wqe->fcp_trsp.wqe_com, nvmewqe->iotag); | |
1964 | bf_set(wqe_rcvoxid, &wqe->fcp_trsp.wqe_com, ctxp->oxid); | |
1965 | ||
1966 | /* Word 10 */ | |
1967 | bf_set(wqe_nvme, &wqe->fcp_trsp.wqe_com, 1); | |
1968 | bf_set(wqe_dbde, &wqe->fcp_trsp.wqe_com, 0); | |
1969 | bf_set(wqe_iod, &wqe->fcp_trsp.wqe_com, LPFC_WQE_IOD_WRITE); | |
1970 | bf_set(wqe_lenloc, &wqe->fcp_trsp.wqe_com, | |
1971 | LPFC_WQE_LENLOC_WORD3); | |
1972 | bf_set(wqe_xc, &wqe->fcp_trsp.wqe_com, xc); | |
1973 | bf_set(wqe_nvme, &wqe->fcp_trsp.wqe_com, 1); | |
1974 | if (phba->cfg_nvme_oas) | |
1975 | bf_set(wqe_oas, &wqe->fcp_trsp.wqe_com, 1); | |
1976 | ||
1977 | /* Word 11 */ | |
1978 | bf_set(wqe_cqid, &wqe->fcp_trsp.wqe_com, | |
1979 | LPFC_WQE_CQ_ID_DEFAULT); | |
1980 | bf_set(wqe_cmd_type, &wqe->fcp_trsp.wqe_com, | |
1981 | FCP_COMMAND_TRSP); | |
1982 | bf_set(wqe_sup, &wqe->fcp_tsend.wqe_com, 0); | |
1983 | ctxp->state = LPFC_NVMET_STE_RSP; | |
1984 | ||
1985 | if (rsp->rsplen == LPFC_NVMET_SUCCESS_LEN) { | |
1986 | /* Good response - all zero's on wire */ | |
1987 | bf_set(wqe_wqes, &wqe->fcp_trsp.wqe_com, 0); | |
1988 | bf_set(wqe_irsp, &wqe->fcp_trsp.wqe_com, 0); | |
1989 | bf_set(wqe_irsplen, &wqe->fcp_trsp.wqe_com, 0); | |
1990 | } else { | |
1991 | bf_set(wqe_wqes, &wqe->fcp_trsp.wqe_com, 1); | |
1992 | bf_set(wqe_irsp, &wqe->fcp_trsp.wqe_com, 1); | |
1993 | bf_set(wqe_irsplen, &wqe->fcp_trsp.wqe_com, | |
1994 | ((rsp->rsplen >> 2) - 1)); | |
1995 | memcpy(&wqe->words[16], rsp->rspaddr, rsp->rsplen); | |
1996 | } | |
1997 | ||
1998 | /* Use rspbuf, NOT sg list */ | |
1999 | rsp->sg_cnt = 0; | |
2000 | sgl->word2 = 0; | |
2001 | atomic_inc(&tgtp->xmt_fcp_rsp); | |
2002 | break; | |
2003 | ||
2004 | default: | |
2005 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_IOERR, | |
2006 | "6064 Unknown Rsp Op %d\n", | |
2007 | rsp->op); | |
2008 | return NULL; | |
2009 | } | |
2010 | ||
2011 | nvmewqe->retry = 1; | |
2012 | nvmewqe->vport = phba->pport; | |
2013 | nvmewqe->drvrTimeout = (phba->fc_ratov * 3) + LPFC_DRVR_TIMEOUT; | |
2014 | nvmewqe->context1 = ndlp; | |
2015 | ||
2016 | for (i = 0; i < rsp->sg_cnt; i++) { | |
2017 | sgel = &rsp->sg[i]; | |
2018 | physaddr = sg_dma_address(sgel); | |
2019 | cnt = sg_dma_len(sgel); | |
2020 | sgl->addr_hi = putPaddrHigh(physaddr); | |
2021 | sgl->addr_lo = putPaddrLow(physaddr); | |
2022 | sgl->word2 = 0; | |
2023 | bf_set(lpfc_sli4_sge_type, sgl, LPFC_SGE_TYPE_DATA); | |
2024 | bf_set(lpfc_sli4_sge_offset, sgl, ctxp->offset); | |
2025 | if ((i+1) == rsp->sg_cnt) | |
2026 | bf_set(lpfc_sli4_sge_last, sgl, 1); | |
2027 | sgl->word2 = cpu_to_le32(sgl->word2); | |
2028 | sgl->sge_len = cpu_to_le32(cnt); | |
2029 | sgl++; | |
2030 | ctxp->offset += cnt; | |
2031 | } | |
2032 | return nvmewqe; | |
2033 | } | |
2034 | ||
2035 | /** | |
2036 | * lpfc_nvmet_sol_fcp_abort_cmp - Completion handler for ABTS | |
2037 | * @phba: Pointer to HBA context object. | |
2038 | * @cmdwqe: Pointer to driver command WQE object. | |
2039 | * @wcqe: Pointer to driver response CQE object. | |
2040 | * | |
2041 | * The function is called from SLI ring event handler with no | |
2042 | * lock held. This function is the completion handler for NVME ABTS for FCP cmds | |
2043 | * The function frees memory resources used for the NVME commands. | |
2044 | **/ | |
2045 | static void | |
2046 | lpfc_nvmet_sol_fcp_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
2047 | struct lpfc_wcqe_complete *wcqe) | |
2048 | { | |
2049 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
2050 | struct lpfc_nvmet_tgtport *tgtp; | |
2051 | uint32_t status, result; | |
19b58d94 JS |
2052 | unsigned long flags; |
2053 | bool released = false; | |
d613b6a7 JS |
2054 | |
2055 | ctxp = cmdwqe->context2; | |
2056 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
2057 | result = wcqe->parameter; | |
2058 | ||
2059 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
547077a4 JS |
2060 | if (ctxp->flag & LPFC_NVMET_ABORT_OP) |
2061 | atomic_inc(&tgtp->xmt_fcp_abort_cmpl); | |
d613b6a7 | 2062 | |
d613b6a7 | 2063 | ctxp->state = LPFC_NVMET_STE_DONE; |
86c67379 JS |
2064 | |
2065 | /* Check if we already received a free context call | |
2066 | * and we have completed processing an abort situation. | |
2067 | */ | |
19b58d94 | 2068 | spin_lock_irqsave(&ctxp->ctxlock, flags); |
86c67379 JS |
2069 | if ((ctxp->flag & LPFC_NVMET_CTX_RLS) && |
2070 | !(ctxp->flag & LPFC_NVMET_XBUSY)) { | |
2071 | list_del(&ctxp->list); | |
19b58d94 | 2072 | released = true; |
86c67379 | 2073 | } |
19b58d94 JS |
2074 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
2075 | spin_unlock_irqrestore(&ctxp->ctxlock, flags); | |
547077a4 | 2076 | atomic_inc(&tgtp->xmt_abort_rsp); |
19b58d94 | 2077 | |
86c67379 JS |
2078 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, |
2079 | "6165 ABORT cmpl: xri x%x flg x%x (%d) " | |
2080 | "WCQE: %08x %08x %08x %08x\n", | |
2081 | ctxp->oxid, ctxp->flag, released, | |
2082 | wcqe->word0, wcqe->total_data_placed, | |
2083 | result, wcqe->word3); | |
2084 | ||
6c621a22 JS |
2085 | cmdwqe->context2 = NULL; |
2086 | cmdwqe->context3 = NULL; | |
19b58d94 JS |
2087 | /* |
2088 | * if transport has released ctx, then can reuse it. Otherwise, | |
2089 | * will be recycled by transport release call. | |
2090 | */ | |
2091 | if (released) | |
6c621a22 | 2092 | lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf); |
d613b6a7 | 2093 | |
6c621a22 | 2094 | /* This is the iocbq for the abort, not the command */ |
d613b6a7 | 2095 | lpfc_sli_release_iocbq(phba, cmdwqe); |
86c67379 JS |
2096 | |
2097 | /* Since iaab/iaar are NOT set, there is no work left. | |
2098 | * For LPFC_NVMET_XBUSY, lpfc_sli4_nvmet_xri_aborted | |
2099 | * should have been called already. | |
2100 | */ | |
d613b6a7 JS |
2101 | } |
2102 | ||
2103 | /** | |
86c67379 | 2104 | * lpfc_nvmet_unsol_fcp_abort_cmp - Completion handler for ABTS |
d613b6a7 JS |
2105 | * @phba: Pointer to HBA context object. |
2106 | * @cmdwqe: Pointer to driver command WQE object. | |
2107 | * @wcqe: Pointer to driver response CQE object. | |
2108 | * | |
2109 | * The function is called from SLI ring event handler with no | |
2110 | * lock held. This function is the completion handler for NVME ABTS for FCP cmds | |
2111 | * The function frees memory resources used for the NVME commands. | |
2112 | **/ | |
2113 | static void | |
86c67379 JS |
2114 | lpfc_nvmet_unsol_fcp_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, |
2115 | struct lpfc_wcqe_complete *wcqe) | |
d613b6a7 JS |
2116 | { |
2117 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
2118 | struct lpfc_nvmet_tgtport *tgtp; | |
19b58d94 | 2119 | unsigned long flags; |
d613b6a7 | 2120 | uint32_t status, result; |
19b58d94 | 2121 | bool released = false; |
d613b6a7 JS |
2122 | |
2123 | ctxp = cmdwqe->context2; | |
2124 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
2125 | result = wcqe->parameter; | |
2126 | ||
2127 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
547077a4 JS |
2128 | if (ctxp->flag & LPFC_NVMET_ABORT_OP) |
2129 | atomic_inc(&tgtp->xmt_fcp_abort_cmpl); | |
d613b6a7 | 2130 | |
86c67379 JS |
2131 | if (!ctxp) { |
2132 | /* if context is clear, related io alrady complete */ | |
2133 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
2134 | "6070 ABTS cmpl: WCQE: %08x %08x %08x %08x\n", | |
2135 | wcqe->word0, wcqe->total_data_placed, | |
2136 | result, wcqe->word3); | |
2137 | return; | |
2138 | } | |
2139 | ||
2140 | /* Sanity check */ | |
2141 | if (ctxp->state != LPFC_NVMET_STE_ABORT) { | |
2142 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, | |
2143 | "6112 ABTS Wrong state:%d oxid x%x\n", | |
2144 | ctxp->state, ctxp->oxid); | |
2145 | } | |
2146 | ||
2147 | /* Check if we already received a free context call | |
2148 | * and we have completed processing an abort situation. | |
2149 | */ | |
2150 | ctxp->state = LPFC_NVMET_STE_DONE; | |
2151 | spin_lock_irqsave(&ctxp->ctxlock, flags); | |
2152 | if ((ctxp->flag & LPFC_NVMET_CTX_RLS) && | |
2153 | !(ctxp->flag & LPFC_NVMET_XBUSY)) { | |
2154 | list_del(&ctxp->list); | |
2155 | released = true; | |
2156 | } | |
2157 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; | |
2158 | spin_unlock_irqrestore(&ctxp->ctxlock, flags); | |
547077a4 | 2159 | atomic_inc(&tgtp->xmt_abort_rsp); |
86c67379 | 2160 | |
d613b6a7 | 2161 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, |
86c67379 JS |
2162 | "6316 ABTS cmpl xri x%x flg x%x (%x) " |
2163 | "WCQE: %08x %08x %08x %08x\n", | |
2164 | ctxp->oxid, ctxp->flag, released, | |
2165 | wcqe->word0, wcqe->total_data_placed, | |
d613b6a7 | 2166 | result, wcqe->word3); |
6c621a22 JS |
2167 | |
2168 | cmdwqe->context2 = NULL; | |
2169 | cmdwqe->context3 = NULL; | |
86c67379 JS |
2170 | /* |
2171 | * if transport has released ctx, then can reuse it. Otherwise, | |
2172 | * will be recycled by transport release call. | |
2173 | */ | |
2174 | if (released) | |
6c621a22 | 2175 | lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf); |
19b58d94 | 2176 | |
86c67379 JS |
2177 | /* Since iaab/iaar are NOT set, there is no work left. |
2178 | * For LPFC_NVMET_XBUSY, lpfc_sli4_nvmet_xri_aborted | |
2179 | * should have been called already. | |
2180 | */ | |
d613b6a7 JS |
2181 | } |
2182 | ||
2183 | /** | |
2184 | * lpfc_nvmet_xmt_ls_abort_cmp - Completion handler for ABTS | |
2185 | * @phba: Pointer to HBA context object. | |
2186 | * @cmdwqe: Pointer to driver command WQE object. | |
2187 | * @wcqe: Pointer to driver response CQE object. | |
2188 | * | |
2189 | * The function is called from SLI ring event handler with no | |
2190 | * lock held. This function is the completion handler for NVME ABTS for LS cmds | |
2191 | * The function frees memory resources used for the NVME commands. | |
2192 | **/ | |
2193 | static void | |
2194 | lpfc_nvmet_xmt_ls_abort_cmp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdwqe, | |
2195 | struct lpfc_wcqe_complete *wcqe) | |
2196 | { | |
2197 | struct lpfc_nvmet_rcv_ctx *ctxp; | |
2198 | struct lpfc_nvmet_tgtport *tgtp; | |
2199 | uint32_t status, result; | |
2200 | ||
2201 | ctxp = cmdwqe->context2; | |
2202 | status = bf_get(lpfc_wcqe_c_status, wcqe); | |
2203 | result = wcqe->parameter; | |
2204 | ||
2205 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
547077a4 | 2206 | atomic_inc(&tgtp->xmt_ls_abort_cmpl); |
d613b6a7 JS |
2207 | |
2208 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
2209 | "6083 Abort cmpl: ctx %p WCQE: %08x %08x %08x %08x\n", | |
2210 | ctxp, wcqe->word0, wcqe->total_data_placed, | |
2211 | result, wcqe->word3); | |
2212 | ||
2213 | if (ctxp) { | |
2214 | cmdwqe->context2 = NULL; | |
2215 | cmdwqe->context3 = NULL; | |
2216 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
2217 | kfree(ctxp); | |
2218 | } else | |
2219 | lpfc_sli_release_iocbq(phba, cmdwqe); | |
2220 | } | |
2221 | ||
2222 | static int | |
2223 | lpfc_nvmet_unsol_issue_abort(struct lpfc_hba *phba, | |
2224 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
2225 | uint32_t sid, uint16_t xri) | |
2226 | { | |
2227 | struct lpfc_nvmet_tgtport *tgtp; | |
2228 | struct lpfc_iocbq *abts_wqeq; | |
2229 | union lpfc_wqe *wqe_abts; | |
2230 | struct lpfc_nodelist *ndlp; | |
2231 | ||
2232 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
86c67379 | 2233 | "6067 ABTS: sid %x xri x%x/x%x\n", |
318083ad | 2234 | sid, xri, ctxp->wqeq->sli4_xritag); |
d613b6a7 JS |
2235 | |
2236 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
2237 | ||
2238 | ndlp = lpfc_findnode_did(phba->pport, sid); | |
2239 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
2240 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
2241 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
2242 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
2243 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
2244 | "6134 Drop ABTS - wrong NDLP state x%x.\n", | |
b5ccc7d6 | 2245 | (ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE); |
d613b6a7 JS |
2246 | |
2247 | /* No failure to an ABTS request. */ | |
2248 | return 0; | |
2249 | } | |
2250 | ||
2251 | abts_wqeq = ctxp->wqeq; | |
2252 | wqe_abts = &abts_wqeq->wqe; | |
2253 | ctxp->state = LPFC_NVMET_STE_ABORT; | |
2254 | ||
2255 | /* | |
2256 | * Since we zero the whole WQE, we need to ensure we set the WQE fields | |
2257 | * that were initialized in lpfc_sli4_nvmet_alloc. | |
2258 | */ | |
2259 | memset(wqe_abts, 0, sizeof(union lpfc_wqe)); | |
2260 | ||
2261 | /* Word 5 */ | |
2262 | bf_set(wqe_dfctl, &wqe_abts->xmit_sequence.wge_ctl, 0); | |
2263 | bf_set(wqe_ls, &wqe_abts->xmit_sequence.wge_ctl, 1); | |
2264 | bf_set(wqe_la, &wqe_abts->xmit_sequence.wge_ctl, 0); | |
2265 | bf_set(wqe_rctl, &wqe_abts->xmit_sequence.wge_ctl, FC_RCTL_BA_ABTS); | |
2266 | bf_set(wqe_type, &wqe_abts->xmit_sequence.wge_ctl, FC_TYPE_BLS); | |
2267 | ||
2268 | /* Word 6 */ | |
2269 | bf_set(wqe_ctxt_tag, &wqe_abts->xmit_sequence.wqe_com, | |
2270 | phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]); | |
2271 | bf_set(wqe_xri_tag, &wqe_abts->xmit_sequence.wqe_com, | |
2272 | abts_wqeq->sli4_xritag); | |
2273 | ||
2274 | /* Word 7 */ | |
2275 | bf_set(wqe_cmnd, &wqe_abts->xmit_sequence.wqe_com, | |
2276 | CMD_XMIT_SEQUENCE64_WQE); | |
2277 | bf_set(wqe_ct, &wqe_abts->xmit_sequence.wqe_com, SLI4_CT_RPI); | |
2278 | bf_set(wqe_class, &wqe_abts->xmit_sequence.wqe_com, CLASS3); | |
2279 | bf_set(wqe_pu, &wqe_abts->xmit_sequence.wqe_com, 0); | |
2280 | ||
2281 | /* Word 8 */ | |
2282 | wqe_abts->xmit_sequence.wqe_com.abort_tag = abts_wqeq->iotag; | |
2283 | ||
2284 | /* Word 9 */ | |
2285 | bf_set(wqe_reqtag, &wqe_abts->xmit_sequence.wqe_com, abts_wqeq->iotag); | |
2286 | /* Needs to be set by caller */ | |
2287 | bf_set(wqe_rcvoxid, &wqe_abts->xmit_sequence.wqe_com, xri); | |
2288 | ||
2289 | /* Word 10 */ | |
2290 | bf_set(wqe_dbde, &wqe_abts->xmit_sequence.wqe_com, 1); | |
2291 | bf_set(wqe_iod, &wqe_abts->xmit_sequence.wqe_com, LPFC_WQE_IOD_WRITE); | |
2292 | bf_set(wqe_lenloc, &wqe_abts->xmit_sequence.wqe_com, | |
2293 | LPFC_WQE_LENLOC_WORD12); | |
2294 | bf_set(wqe_ebde_cnt, &wqe_abts->xmit_sequence.wqe_com, 0); | |
2295 | bf_set(wqe_qosd, &wqe_abts->xmit_sequence.wqe_com, 0); | |
2296 | ||
2297 | /* Word 11 */ | |
2298 | bf_set(wqe_cqid, &wqe_abts->xmit_sequence.wqe_com, | |
2299 | LPFC_WQE_CQ_ID_DEFAULT); | |
2300 | bf_set(wqe_cmd_type, &wqe_abts->xmit_sequence.wqe_com, | |
2301 | OTHER_COMMAND); | |
2302 | ||
2303 | abts_wqeq->vport = phba->pport; | |
2304 | abts_wqeq->context1 = ndlp; | |
2305 | abts_wqeq->context2 = ctxp; | |
2306 | abts_wqeq->context3 = NULL; | |
2307 | abts_wqeq->rsvd2 = 0; | |
2308 | /* hba_wqidx should already be setup from command we are aborting */ | |
2309 | abts_wqeq->iocb.ulpCommand = CMD_XMIT_SEQUENCE64_CR; | |
2310 | abts_wqeq->iocb.ulpLe = 1; | |
2311 | ||
2312 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, | |
2313 | "6069 Issue ABTS to xri x%x reqtag x%x\n", | |
2314 | xri, abts_wqeq->iotag); | |
2315 | return 1; | |
2316 | } | |
2317 | ||
2318 | static int | |
2319 | lpfc_nvmet_sol_fcp_issue_abort(struct lpfc_hba *phba, | |
2320 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
2321 | uint32_t sid, uint16_t xri) | |
2322 | { | |
2323 | struct lpfc_nvmet_tgtport *tgtp; | |
2324 | struct lpfc_iocbq *abts_wqeq; | |
2325 | union lpfc_wqe *abts_wqe; | |
2326 | struct lpfc_nodelist *ndlp; | |
2327 | unsigned long flags; | |
2328 | int rc; | |
2329 | ||
2330 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
2331 | if (!ctxp->wqeq) { | |
6c621a22 | 2332 | ctxp->wqeq = ctxp->ctxbuf->iocbq; |
d613b6a7 JS |
2333 | ctxp->wqeq->hba_wqidx = 0; |
2334 | } | |
2335 | ||
2336 | ndlp = lpfc_findnode_did(phba->pport, sid); | |
2337 | if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || | |
2338 | ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) && | |
2339 | (ndlp->nlp_state != NLP_STE_MAPPED_NODE))) { | |
2340 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
2341 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
86c67379 | 2342 | "6160 Drop ABORT - wrong NDLP state x%x.\n", |
b5ccc7d6 | 2343 | (ndlp) ? ndlp->nlp_state : NLP_STE_MAX_STATE); |
d613b6a7 JS |
2344 | |
2345 | /* No failure to an ABTS request. */ | |
86c67379 | 2346 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 JS |
2347 | return 0; |
2348 | } | |
2349 | ||
2350 | /* Issue ABTS for this WQE based on iotag */ | |
2351 | ctxp->abort_wqeq = lpfc_sli_get_iocbq(phba); | |
2352 | if (!ctxp->abort_wqeq) { | |
547077a4 | 2353 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
d613b6a7 | 2354 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, |
86c67379 | 2355 | "6161 ABORT failed: No wqeqs: " |
d613b6a7 JS |
2356 | "xri: x%x\n", ctxp->oxid); |
2357 | /* No failure to an ABTS request. */ | |
86c67379 | 2358 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 JS |
2359 | return 0; |
2360 | } | |
2361 | abts_wqeq = ctxp->abort_wqeq; | |
2362 | abts_wqe = &abts_wqeq->wqe; | |
2363 | ctxp->state = LPFC_NVMET_STE_ABORT; | |
2364 | ||
2365 | /* Announce entry to new IO submit field. */ | |
86c67379 JS |
2366 | lpfc_printf_log(phba, KERN_INFO, LOG_NVME_ABTS, |
2367 | "6162 ABORT Request to rport DID x%06x " | |
d613b6a7 JS |
2368 | "for xri x%x x%x\n", |
2369 | ctxp->sid, ctxp->oxid, ctxp->wqeq->sli4_xritag); | |
2370 | ||
2371 | /* If the hba is getting reset, this flag is set. It is | |
2372 | * cleared when the reset is complete and rings reestablished. | |
2373 | */ | |
2374 | spin_lock_irqsave(&phba->hbalock, flags); | |
2375 | /* driver queued commands are in process of being flushed */ | |
2376 | if (phba->hba_flag & HBA_NVME_IOQ_FLUSH) { | |
2377 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
547077a4 | 2378 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
d613b6a7 JS |
2379 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, |
2380 | "6163 Driver in reset cleanup - flushing " | |
2381 | "NVME Req now. hba_flag x%x oxid x%x\n", | |
2382 | phba->hba_flag, ctxp->oxid); | |
2383 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
86c67379 | 2384 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 JS |
2385 | return 0; |
2386 | } | |
2387 | ||
2388 | /* Outstanding abort is in progress */ | |
2389 | if (abts_wqeq->iocb_flag & LPFC_DRIVER_ABORTED) { | |
2390 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
547077a4 | 2391 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
d613b6a7 JS |
2392 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME, |
2393 | "6164 Outstanding NVME I/O Abort Request " | |
2394 | "still pending on oxid x%x\n", | |
2395 | ctxp->oxid); | |
2396 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
86c67379 | 2397 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 JS |
2398 | return 0; |
2399 | } | |
2400 | ||
2401 | /* Ready - mark outstanding as aborted by driver. */ | |
2402 | abts_wqeq->iocb_flag |= LPFC_DRIVER_ABORTED; | |
2403 | ||
2404 | /* WQEs are reused. Clear stale data and set key fields to | |
2405 | * zero like ia, iaab, iaar, xri_tag, and ctxt_tag. | |
2406 | */ | |
2407 | memset(abts_wqe, 0, sizeof(union lpfc_wqe)); | |
2408 | ||
2409 | /* word 3 */ | |
2410 | bf_set(abort_cmd_criteria, &abts_wqe->abort_cmd, T_XRI_TAG); | |
2411 | ||
2412 | /* word 7 */ | |
2413 | bf_set(wqe_ct, &abts_wqe->abort_cmd.wqe_com, 0); | |
2414 | bf_set(wqe_cmnd, &abts_wqe->abort_cmd.wqe_com, CMD_ABORT_XRI_CX); | |
2415 | ||
2416 | /* word 8 - tell the FW to abort the IO associated with this | |
2417 | * outstanding exchange ID. | |
2418 | */ | |
2419 | abts_wqe->abort_cmd.wqe_com.abort_tag = ctxp->wqeq->sli4_xritag; | |
2420 | ||
2421 | /* word 9 - this is the iotag for the abts_wqe completion. */ | |
2422 | bf_set(wqe_reqtag, &abts_wqe->abort_cmd.wqe_com, | |
2423 | abts_wqeq->iotag); | |
2424 | ||
2425 | /* word 10 */ | |
2426 | bf_set(wqe_qosd, &abts_wqe->abort_cmd.wqe_com, 1); | |
2427 | bf_set(wqe_lenloc, &abts_wqe->abort_cmd.wqe_com, LPFC_WQE_LENLOC_NONE); | |
2428 | ||
2429 | /* word 11 */ | |
2430 | bf_set(wqe_cmd_type, &abts_wqe->abort_cmd.wqe_com, OTHER_COMMAND); | |
2431 | bf_set(wqe_wqec, &abts_wqe->abort_cmd.wqe_com, 1); | |
2432 | bf_set(wqe_cqid, &abts_wqe->abort_cmd.wqe_com, LPFC_WQE_CQ_ID_DEFAULT); | |
2433 | ||
2434 | /* ABTS WQE must go to the same WQ as the WQE to be aborted */ | |
2435 | abts_wqeq->hba_wqidx = ctxp->wqeq->hba_wqidx; | |
2436 | abts_wqeq->wqe_cmpl = lpfc_nvmet_sol_fcp_abort_cmp; | |
2437 | abts_wqeq->iocb_cmpl = 0; | |
2438 | abts_wqeq->iocb_flag |= LPFC_IO_NVME; | |
2439 | abts_wqeq->context2 = ctxp; | |
2440 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, abts_wqeq); | |
2441 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
547077a4 JS |
2442 | if (rc == WQE_SUCCESS) { |
2443 | atomic_inc(&tgtp->xmt_abort_sol); | |
d613b6a7 | 2444 | return 0; |
547077a4 | 2445 | } |
d613b6a7 | 2446 | |
547077a4 | 2447 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
86c67379 | 2448 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 | 2449 | lpfc_sli_release_iocbq(phba, abts_wqeq); |
86c67379 JS |
2450 | lpfc_printf_log(phba, KERN_ERR, LOG_NVME_ABTS, |
2451 | "6166 Failed ABORT issue_wqe with status x%x " | |
d613b6a7 JS |
2452 | "for oxid x%x.\n", |
2453 | rc, ctxp->oxid); | |
2454 | return 1; | |
2455 | } | |
2456 | ||
2457 | ||
2458 | static int | |
2459 | lpfc_nvmet_unsol_fcp_issue_abort(struct lpfc_hba *phba, | |
2460 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
2461 | uint32_t sid, uint16_t xri) | |
2462 | { | |
2463 | struct lpfc_nvmet_tgtport *tgtp; | |
2464 | struct lpfc_iocbq *abts_wqeq; | |
2465 | unsigned long flags; | |
2466 | int rc; | |
2467 | ||
2468 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
2469 | if (!ctxp->wqeq) { | |
6c621a22 | 2470 | ctxp->wqeq = ctxp->ctxbuf->iocbq; |
d613b6a7 JS |
2471 | ctxp->wqeq->hba_wqidx = 0; |
2472 | } | |
2473 | ||
2474 | rc = lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri); | |
2475 | if (rc == 0) | |
2476 | goto aerr; | |
2477 | ||
2478 | spin_lock_irqsave(&phba->hbalock, flags); | |
2479 | abts_wqeq = ctxp->wqeq; | |
86c67379 JS |
2480 | abts_wqeq->wqe_cmpl = lpfc_nvmet_unsol_fcp_abort_cmp; |
2481 | abts_wqeq->iocb_cmpl = NULL; | |
d613b6a7 JS |
2482 | abts_wqeq->iocb_flag |= LPFC_IO_NVMET; |
2483 | rc = lpfc_sli4_issue_wqe(phba, LPFC_FCP_RING, abts_wqeq); | |
2484 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
2485 | if (rc == WQE_SUCCESS) { | |
d613b6a7 JS |
2486 | return 0; |
2487 | } | |
2488 | ||
2489 | aerr: | |
547077a4 | 2490 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
86c67379 | 2491 | ctxp->flag &= ~LPFC_NVMET_ABORT_OP; |
d613b6a7 JS |
2492 | atomic_inc(&tgtp->xmt_abort_rsp_error); |
2493 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
2494 | "6135 Failed to Issue ABTS for oxid x%x. Status x%x\n", | |
2495 | ctxp->oxid, rc); | |
2496 | return 1; | |
2497 | } | |
2498 | ||
2499 | static int | |
2500 | lpfc_nvmet_unsol_ls_issue_abort(struct lpfc_hba *phba, | |
2501 | struct lpfc_nvmet_rcv_ctx *ctxp, | |
2502 | uint32_t sid, uint16_t xri) | |
2503 | { | |
2504 | struct lpfc_nvmet_tgtport *tgtp; | |
2505 | struct lpfc_iocbq *abts_wqeq; | |
2506 | union lpfc_wqe *wqe_abts; | |
2507 | unsigned long flags; | |
2508 | int rc; | |
2509 | ||
2510 | tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private; | |
2511 | if (!ctxp->wqeq) { | |
2512 | /* Issue ABTS for this WQE based on iotag */ | |
2513 | ctxp->wqeq = lpfc_sli_get_iocbq(phba); | |
2514 | if (!ctxp->wqeq) { | |
2515 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
2516 | "6068 Abort failed: No wqeqs: " | |
2517 | "xri: x%x\n", xri); | |
2518 | /* No failure to an ABTS request. */ | |
2519 | kfree(ctxp); | |
2520 | return 0; | |
2521 | } | |
2522 | } | |
2523 | abts_wqeq = ctxp->wqeq; | |
2524 | wqe_abts = &abts_wqeq->wqe; | |
6c621a22 | 2525 | |
d613b6a7 JS |
2526 | lpfc_nvmet_unsol_issue_abort(phba, ctxp, sid, xri); |
2527 | ||
2528 | spin_lock_irqsave(&phba->hbalock, flags); | |
2529 | abts_wqeq->wqe_cmpl = lpfc_nvmet_xmt_ls_abort_cmp; | |
2530 | abts_wqeq->iocb_cmpl = 0; | |
2531 | abts_wqeq->iocb_flag |= LPFC_IO_NVME_LS; | |
2532 | rc = lpfc_sli4_issue_wqe(phba, LPFC_ELS_RING, abts_wqeq); | |
2533 | spin_unlock_irqrestore(&phba->hbalock, flags); | |
2534 | if (rc == WQE_SUCCESS) { | |
547077a4 | 2535 | atomic_inc(&tgtp->xmt_abort_unsol); |
d613b6a7 JS |
2536 | return 0; |
2537 | } | |
2538 | ||
2539 | atomic_inc(&tgtp->xmt_abort_rsp_error); | |
2540 | abts_wqeq->context2 = NULL; | |
2541 | abts_wqeq->context3 = NULL; | |
2542 | lpfc_sli_release_iocbq(phba, abts_wqeq); | |
2543 | kfree(ctxp); | |
2544 | lpfc_printf_log(phba, KERN_WARNING, LOG_NVME_ABTS, | |
2545 | "6056 Failed to Issue ABTS. Status x%x\n", rc); | |
2546 | return 0; | |
2547 | } |