Commit | Line | Data |
---|---|---|
3699d92a KP |
1 | /* |
2 | * Copyright (c) 2010 Cisco Systems, Inc. | |
3 | * | |
4 | * Portions based on tcm_loop_fabric_scsi.c and libfc/fc_fcp.c | |
5 | * | |
6 | * Copyright (c) 2007 Intel Corporation. All rights reserved. | |
7 | * Copyright (c) 2008 Red Hat, Inc. All rights reserved. | |
8 | * Copyright (c) 2008 Mike Christie | |
9 | * Copyright (c) 2009 Rising Tide, Inc. | |
10 | * Copyright (c) 2009 Linux-iSCSI.org | |
11 | * Copyright (c) 2009 Nicholas A. Bellinger <nab@linux-iscsi.org> | |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify it | |
14 | * under the terms and conditions of the GNU General Public License, | |
15 | * version 2, as published by the Free Software Foundation. | |
16 | * | |
17 | * This program is distributed in the hope it will be useful, but WITHOUT | |
18 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
19 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
20 | * more details. | |
21 | * | |
22 | * You should have received a copy of the GNU General Public License along with | |
23 | * this program; if not, write to the Free Software Foundation, Inc., | |
24 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
25 | */ | |
26 | ||
27 | /* XXX TBD some includes may be extraneous */ | |
28 | ||
29 | #include <linux/module.h> | |
30 | #include <linux/moduleparam.h> | |
3699d92a KP |
31 | #include <generated/utsrelease.h> |
32 | #include <linux/utsname.h> | |
33 | #include <linux/init.h> | |
34 | #include <linux/slab.h> | |
35 | #include <linux/kthread.h> | |
36 | #include <linux/types.h> | |
37 | #include <linux/string.h> | |
38 | #include <linux/configfs.h> | |
39 | #include <linux/ctype.h> | |
40 | #include <linux/hash.h> | |
6708bb27 | 41 | #include <linux/ratelimit.h> |
3699d92a KP |
42 | #include <asm/unaligned.h> |
43 | #include <scsi/scsi.h> | |
44 | #include <scsi/scsi_host.h> | |
45 | #include <scsi/scsi_device.h> | |
46 | #include <scsi/scsi_cmnd.h> | |
47 | #include <scsi/libfc.h> | |
48 | #include <scsi/fc_encode.h> | |
49 | ||
50 | #include <target/target_core_base.h> | |
c4795fb2 | 51 | #include <target/target_core_fabric.h> |
3699d92a | 52 | #include <target/target_core_configfs.h> |
3699d92a KP |
53 | #include <target/configfs_macros.h> |
54 | ||
55 | #include "tcm_fc.h" | |
56 | ||
57 | /* | |
58 | * Deliver read data back to initiator. | |
59 | * XXX TBD handle resource problems later. | |
60 | */ | |
61 | int ft_queue_data_in(struct se_cmd *se_cmd) | |
62 | { | |
63 | struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); | |
3699d92a KP |
64 | struct fc_frame *fp = NULL; |
65 | struct fc_exch *ep; | |
66 | struct fc_lport *lport; | |
ec98f782 | 67 | struct scatterlist *sg = NULL; |
3699d92a KP |
68 | size_t remaining; |
69 | u32 f_ctl = FC_FC_EX_CTX | FC_FC_REL_OFF; | |
ec98f782 | 70 | u32 mem_off = 0; |
3699d92a KP |
71 | u32 fh_off = 0; |
72 | u32 frame_off = 0; | |
73 | size_t frame_len = 0; | |
ec98f782 | 74 | size_t mem_len = 0; |
3699d92a KP |
75 | size_t tlen; |
76 | size_t off_in_page; | |
ec98f782 | 77 | struct page *page = NULL; |
3699d92a KP |
78 | int use_sg; |
79 | int error; | |
80 | void *page_addr; | |
81 | void *from; | |
82 | void *to = NULL; | |
83 | ||
e1c40382 MR |
84 | if (cmd->aborted) |
85 | return 0; | |
3699d92a KP |
86 | ep = fc_seq_exch(cmd->seq); |
87 | lport = ep->lp; | |
88 | cmd->seq = lport->tt.seq_start_next(cmd->seq); | |
89 | ||
3699d92a KP |
90 | remaining = se_cmd->data_length; |
91 | ||
92 | /* | |
05d1c7c0 | 93 | * Setup to use first mem list entry, unless no data. |
3699d92a | 94 | */ |
ec98f782 | 95 | BUG_ON(remaining && !se_cmd->t_data_sg); |
05d1c7c0 | 96 | if (remaining) { |
ec98f782 AG |
97 | sg = se_cmd->t_data_sg; |
98 | mem_len = sg->length; | |
99 | mem_off = sg->offset; | |
100 | page = sg_page(sg); | |
3699d92a KP |
101 | } |
102 | ||
103 | /* no scatter/gather in skb for odd word length due to fc_seq_send() */ | |
104 | use_sg = !(remaining % 4); | |
105 | ||
106 | while (remaining) { | |
107 | if (!mem_len) { | |
ec98f782 AG |
108 | sg = sg_next(sg); |
109 | mem_len = min((size_t)sg->length, remaining); | |
110 | mem_off = sg->offset; | |
111 | page = sg_page(sg); | |
3699d92a KP |
112 | } |
113 | if (!frame_len) { | |
114 | /* | |
115 | * If lport's has capability of Large Send Offload LSO) | |
116 | * , then allow 'frame_len' to be as big as 'lso_max' | |
117 | * if indicated transfer length is >= lport->lso_max | |
118 | */ | |
119 | frame_len = (lport->seq_offload) ? lport->lso_max : | |
120 | cmd->sess->max_frame; | |
121 | frame_len = min(frame_len, remaining); | |
122 | fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len); | |
123 | if (!fp) | |
124 | return -ENOMEM; | |
125 | to = fc_frame_payload_get(fp, 0); | |
126 | fh_off = frame_off; | |
127 | frame_off += frame_len; | |
128 | /* | |
129 | * Setup the frame's max payload which is used by base | |
130 | * driver to indicate HW about max frame size, so that | |
131 | * HW can do fragmentation appropriately based on | |
132 | * "gso_max_size" of underline netdev. | |
133 | */ | |
134 | fr_max_payload(fp) = cmd->sess->max_frame; | |
135 | } | |
136 | tlen = min(mem_len, frame_len); | |
137 | ||
138 | if (use_sg) { | |
05d1c7c0 | 139 | off_in_page = mem_off; |
3699d92a KP |
140 | BUG_ON(!page); |
141 | get_page(page); | |
142 | skb_fill_page_desc(fp_skb(fp), | |
143 | skb_shinfo(fp_skb(fp))->nr_frags, | |
144 | page, off_in_page, tlen); | |
145 | fr_len(fp) += tlen; | |
146 | fp_skb(fp)->data_len += tlen; | |
147 | fp_skb(fp)->truesize += | |
148 | PAGE_SIZE << compound_order(page); | |
05d1c7c0 | 149 | } else { |
3699d92a | 150 | BUG_ON(!page); |
ca747d61 | 151 | from = kmap_atomic(page + (mem_off >> PAGE_SHIFT)); |
3699d92a KP |
152 | page_addr = from; |
153 | from += mem_off & ~PAGE_MASK; | |
154 | tlen = min(tlen, (size_t)(PAGE_SIZE - | |
155 | (mem_off & ~PAGE_MASK))); | |
156 | memcpy(to, from, tlen); | |
ca747d61 | 157 | kunmap_atomic(page_addr); |
3699d92a | 158 | to += tlen; |
3699d92a KP |
159 | } |
160 | ||
161 | mem_off += tlen; | |
162 | mem_len -= tlen; | |
163 | frame_len -= tlen; | |
164 | remaining -= tlen; | |
165 | ||
166 | if (frame_len && | |
167 | (skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN)) | |
168 | continue; | |
169 | if (!remaining) | |
170 | f_ctl |= FC_FC_END_SEQ; | |
171 | fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid, | |
172 | FC_TYPE_FCP, f_ctl, fh_off); | |
173 | error = lport->tt.seq_send(lport, cmd->seq, fp); | |
174 | if (error) { | |
175 | /* XXX For now, initiator will retry */ | |
6708bb27 | 176 | pr_err_ratelimited("%s: Failed to send frame %p, " |
95efa286 | 177 | "xid <0x%x>, remaining %zu, " |
3699d92a KP |
178 | "lso_max <0x%x>\n", |
179 | __func__, fp, ep->xid, | |
180 | remaining, lport->lso_max); | |
181 | } | |
182 | } | |
183 | return ft_queue_status(se_cmd); | |
184 | } | |
185 | ||
b8b22533 CH |
186 | static void ft_execute_work(struct work_struct *work) |
187 | { | |
188 | struct ft_cmd *cmd = container_of(work, struct ft_cmd, work); | |
189 | ||
190 | target_execute_cmd(&cmd->se_cmd); | |
191 | } | |
192 | ||
3699d92a KP |
193 | /* |
194 | * Receive write data frame. | |
195 | */ | |
196 | void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp) | |
197 | { | |
198 | struct se_cmd *se_cmd = &cmd->se_cmd; | |
199 | struct fc_seq *seq = cmd->seq; | |
200 | struct fc_exch *ep; | |
201 | struct fc_lport *lport; | |
3699d92a | 202 | struct fc_frame_header *fh; |
ec98f782 AG |
203 | struct scatterlist *sg = NULL; |
204 | u32 mem_off = 0; | |
3699d92a KP |
205 | u32 rel_off; |
206 | size_t frame_len; | |
ec98f782 | 207 | size_t mem_len = 0; |
3699d92a | 208 | size_t tlen; |
ec98f782 | 209 | struct page *page = NULL; |
3699d92a KP |
210 | void *page_addr; |
211 | void *from; | |
212 | void *to; | |
213 | u32 f_ctl; | |
214 | void *buf; | |
215 | ||
3699d92a KP |
216 | fh = fc_frame_header_get(fp); |
217 | if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF)) | |
218 | goto drop; | |
219 | ||
dcd998cc KP |
220 | f_ctl = ntoh24(fh->fh_f_ctl); |
221 | ep = fc_seq_exch(seq); | |
222 | lport = ep->lp; | |
223 | if (cmd->was_ddp_setup) { | |
224 | BUG_ON(!ep); | |
225 | BUG_ON(!lport); | |
079587b4 KP |
226 | /* |
227 | * Since DDP (Large Rx offload) was setup for this request, | |
228 | * payload is expected to be copied directly to user buffers. | |
229 | */ | |
230 | buf = fc_frame_payload_get(fp, 1); | |
231 | if (buf) | |
232 | pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, " | |
dcd998cc KP |
233 | "cmd->sg_cnt 0x%x. DDP was setup" |
234 | " hence not expected to receive frame with " | |
079587b4 KP |
235 | "payload, Frame will be dropped if" |
236 | "'Sequence Initiative' bit in f_ctl is" | |
dcd998cc | 237 | "not set\n", __func__, ep->xid, f_ctl, |
e182d682 | 238 | se_cmd->t_data_sg, se_cmd->t_data_nents); |
079587b4 KP |
239 | /* |
240 | * Invalidate HW DDP context if it was setup for respective | |
241 | * command. Invalidation of HW DDP context is requited in both | |
242 | * situation (success and error). | |
243 | */ | |
244 | ft_invl_hw_context(cmd); | |
3699d92a | 245 | |
079587b4 KP |
246 | /* |
247 | * If "Sequence Initiative (TSI)" bit set in f_ctl, means last | |
248 | * write data frame is received successfully where payload is | |
249 | * posted directly to user buffer and only the last frame's | |
250 | * header is posted in receive queue. | |
251 | * | |
252 | * If "Sequence Initiative (TSI)" bit is not set, means error | |
253 | * condition w.r.t. DDP, hence drop the packet and let explict | |
254 | * ABORTS from other end of exchange timer trigger the recovery. | |
255 | */ | |
256 | if (f_ctl & FC_FC_SEQ_INIT) | |
257 | goto last_frame; | |
258 | else | |
259 | goto drop; | |
260 | } | |
3699d92a KP |
261 | |
262 | rel_off = ntohl(fh->fh_parm_offset); | |
263 | frame_len = fr_len(fp); | |
264 | if (frame_len <= sizeof(*fh)) | |
265 | goto drop; | |
266 | frame_len -= sizeof(*fh); | |
267 | from = fc_frame_payload_get(fp, 0); | |
268 | if (rel_off >= se_cmd->data_length) | |
269 | goto drop; | |
270 | if (frame_len + rel_off > se_cmd->data_length) | |
271 | frame_len = se_cmd->data_length - rel_off; | |
272 | ||
273 | /* | |
05d1c7c0 | 274 | * Setup to use first mem list entry, unless no data. |
3699d92a | 275 | */ |
ec98f782 | 276 | BUG_ON(frame_len && !se_cmd->t_data_sg); |
05d1c7c0 | 277 | if (frame_len) { |
ec98f782 AG |
278 | sg = se_cmd->t_data_sg; |
279 | mem_len = sg->length; | |
280 | mem_off = sg->offset; | |
281 | page = sg_page(sg); | |
3699d92a KP |
282 | } |
283 | ||
284 | while (frame_len) { | |
285 | if (!mem_len) { | |
ec98f782 AG |
286 | sg = sg_next(sg); |
287 | mem_len = sg->length; | |
288 | mem_off = sg->offset; | |
289 | page = sg_page(sg); | |
3699d92a KP |
290 | } |
291 | if (rel_off >= mem_len) { | |
292 | rel_off -= mem_len; | |
293 | mem_len = 0; | |
294 | continue; | |
295 | } | |
296 | mem_off += rel_off; | |
297 | mem_len -= rel_off; | |
298 | rel_off = 0; | |
299 | ||
300 | tlen = min(mem_len, frame_len); | |
301 | ||
ca747d61 | 302 | to = kmap_atomic(page + (mem_off >> PAGE_SHIFT)); |
05d1c7c0 AG |
303 | page_addr = to; |
304 | to += mem_off & ~PAGE_MASK; | |
305 | tlen = min(tlen, (size_t)(PAGE_SIZE - | |
306 | (mem_off & ~PAGE_MASK))); | |
307 | memcpy(to, from, tlen); | |
ca747d61 | 308 | kunmap_atomic(page_addr); |
05d1c7c0 | 309 | |
3699d92a KP |
310 | from += tlen; |
311 | frame_len -= tlen; | |
312 | mem_off += tlen; | |
313 | mem_len -= tlen; | |
314 | cmd->write_data_len += tlen; | |
315 | } | |
316 | last_frame: | |
b8b22533 CH |
317 | if (cmd->write_data_len == se_cmd->data_length) { |
318 | INIT_WORK(&cmd->work, ft_execute_work); | |
319 | queue_work(cmd->sess->tport->tpg->workqueue, &cmd->work); | |
320 | } | |
3699d92a KP |
321 | drop: |
322 | fc_frame_free(fp); | |
323 | } | |
dcd998cc KP |
324 | |
325 | /* | |
326 | * Handle and cleanup any HW specific resources if | |
327 | * received ABORTS, errors, timeouts. | |
328 | */ | |
329 | void ft_invl_hw_context(struct ft_cmd *cmd) | |
330 | { | |
331 | struct fc_seq *seq = cmd->seq; | |
332 | struct fc_exch *ep = NULL; | |
333 | struct fc_lport *lport = NULL; | |
334 | ||
335 | BUG_ON(!cmd); | |
336 | ||
337 | /* Cleanup the DDP context in HW if DDP was setup */ | |
338 | if (cmd->was_ddp_setup && seq) { | |
339 | ep = fc_seq_exch(seq); | |
340 | if (ep) { | |
341 | lport = ep->lp; | |
342 | if (lport && (ep->xid <= lport->lro_xid)) | |
343 | /* | |
344 | * "ddp_done" trigger invalidation of HW | |
345 | * specific DDP context | |
346 | */ | |
347 | cmd->write_data_len = lport->tt.ddp_done(lport, | |
348 | ep->xid); | |
349 | ||
350 | /* | |
351 | * Resetting same variable to indicate HW's | |
352 | * DDP context has been invalidated to avoid | |
353 | * re_invalidation of same context (context is | |
354 | * identified using ep->xid) | |
355 | */ | |
356 | cmd->was_ddp_setup = 0; | |
357 | } | |
358 | } | |
359 | } |