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 | ||
186 | /* | |
187 | * Receive write data frame. | |
188 | */ | |
189 | void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp) | |
190 | { | |
191 | struct se_cmd *se_cmd = &cmd->se_cmd; | |
192 | struct fc_seq *seq = cmd->seq; | |
193 | struct fc_exch *ep; | |
194 | struct fc_lport *lport; | |
3699d92a | 195 | struct fc_frame_header *fh; |
ec98f782 AG |
196 | struct scatterlist *sg = NULL; |
197 | u32 mem_off = 0; | |
3699d92a KP |
198 | u32 rel_off; |
199 | size_t frame_len; | |
ec98f782 | 200 | size_t mem_len = 0; |
3699d92a | 201 | size_t tlen; |
ec98f782 | 202 | struct page *page = NULL; |
3699d92a KP |
203 | void *page_addr; |
204 | void *from; | |
205 | void *to; | |
206 | u32 f_ctl; | |
207 | void *buf; | |
208 | ||
3699d92a KP |
209 | fh = fc_frame_header_get(fp); |
210 | if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF)) | |
211 | goto drop; | |
212 | ||
dcd998cc KP |
213 | f_ctl = ntoh24(fh->fh_f_ctl); |
214 | ep = fc_seq_exch(seq); | |
215 | lport = ep->lp; | |
216 | if (cmd->was_ddp_setup) { | |
217 | BUG_ON(!ep); | |
218 | BUG_ON(!lport); | |
079587b4 KP |
219 | /* |
220 | * Since DDP (Large Rx offload) was setup for this request, | |
221 | * payload is expected to be copied directly to user buffers. | |
222 | */ | |
223 | buf = fc_frame_payload_get(fp, 1); | |
224 | if (buf) | |
225 | pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, " | |
dcd998cc KP |
226 | "cmd->sg_cnt 0x%x. DDP was setup" |
227 | " hence not expected to receive frame with " | |
079587b4 KP |
228 | "payload, Frame will be dropped if" |
229 | "'Sequence Initiative' bit in f_ctl is" | |
dcd998cc | 230 | "not set\n", __func__, ep->xid, f_ctl, |
e182d682 | 231 | se_cmd->t_data_sg, se_cmd->t_data_nents); |
079587b4 KP |
232 | /* |
233 | * Invalidate HW DDP context if it was setup for respective | |
234 | * command. Invalidation of HW DDP context is requited in both | |
235 | * situation (success and error). | |
236 | */ | |
237 | ft_invl_hw_context(cmd); | |
3699d92a | 238 | |
079587b4 KP |
239 | /* |
240 | * If "Sequence Initiative (TSI)" bit set in f_ctl, means last | |
241 | * write data frame is received successfully where payload is | |
242 | * posted directly to user buffer and only the last frame's | |
243 | * header is posted in receive queue. | |
244 | * | |
245 | * If "Sequence Initiative (TSI)" bit is not set, means error | |
246 | * condition w.r.t. DDP, hence drop the packet and let explict | |
247 | * ABORTS from other end of exchange timer trigger the recovery. | |
248 | */ | |
249 | if (f_ctl & FC_FC_SEQ_INIT) | |
250 | goto last_frame; | |
251 | else | |
252 | goto drop; | |
253 | } | |
3699d92a KP |
254 | |
255 | rel_off = ntohl(fh->fh_parm_offset); | |
256 | frame_len = fr_len(fp); | |
257 | if (frame_len <= sizeof(*fh)) | |
258 | goto drop; | |
259 | frame_len -= sizeof(*fh); | |
260 | from = fc_frame_payload_get(fp, 0); | |
261 | if (rel_off >= se_cmd->data_length) | |
262 | goto drop; | |
263 | if (frame_len + rel_off > se_cmd->data_length) | |
264 | frame_len = se_cmd->data_length - rel_off; | |
265 | ||
266 | /* | |
05d1c7c0 | 267 | * Setup to use first mem list entry, unless no data. |
3699d92a | 268 | */ |
ec98f782 | 269 | BUG_ON(frame_len && !se_cmd->t_data_sg); |
05d1c7c0 | 270 | if (frame_len) { |
ec98f782 AG |
271 | sg = se_cmd->t_data_sg; |
272 | mem_len = sg->length; | |
273 | mem_off = sg->offset; | |
274 | page = sg_page(sg); | |
3699d92a KP |
275 | } |
276 | ||
277 | while (frame_len) { | |
278 | if (!mem_len) { | |
ec98f782 AG |
279 | sg = sg_next(sg); |
280 | mem_len = sg->length; | |
281 | mem_off = sg->offset; | |
282 | page = sg_page(sg); | |
3699d92a KP |
283 | } |
284 | if (rel_off >= mem_len) { | |
285 | rel_off -= mem_len; | |
286 | mem_len = 0; | |
287 | continue; | |
288 | } | |
289 | mem_off += rel_off; | |
290 | mem_len -= rel_off; | |
291 | rel_off = 0; | |
292 | ||
293 | tlen = min(mem_len, frame_len); | |
294 | ||
ca747d61 | 295 | to = kmap_atomic(page + (mem_off >> PAGE_SHIFT)); |
05d1c7c0 AG |
296 | page_addr = to; |
297 | to += mem_off & ~PAGE_MASK; | |
298 | tlen = min(tlen, (size_t)(PAGE_SIZE - | |
299 | (mem_off & ~PAGE_MASK))); | |
300 | memcpy(to, from, tlen); | |
ca747d61 | 301 | kunmap_atomic(page_addr); |
05d1c7c0 | 302 | |
3699d92a KP |
303 | from += tlen; |
304 | frame_len -= tlen; | |
305 | mem_off += tlen; | |
306 | mem_len -= tlen; | |
307 | cmd->write_data_len += tlen; | |
308 | } | |
309 | last_frame: | |
310 | if (cmd->write_data_len == se_cmd->data_length) | |
311 | transport_generic_handle_data(se_cmd); | |
312 | drop: | |
313 | fc_frame_free(fp); | |
314 | } | |
dcd998cc KP |
315 | |
316 | /* | |
317 | * Handle and cleanup any HW specific resources if | |
318 | * received ABORTS, errors, timeouts. | |
319 | */ | |
320 | void ft_invl_hw_context(struct ft_cmd *cmd) | |
321 | { | |
322 | struct fc_seq *seq = cmd->seq; | |
323 | struct fc_exch *ep = NULL; | |
324 | struct fc_lport *lport = NULL; | |
325 | ||
326 | BUG_ON(!cmd); | |
327 | ||
328 | /* Cleanup the DDP context in HW if DDP was setup */ | |
329 | if (cmd->was_ddp_setup && seq) { | |
330 | ep = fc_seq_exch(seq); | |
331 | if (ep) { | |
332 | lport = ep->lp; | |
333 | if (lport && (ep->xid <= lport->lro_xid)) | |
334 | /* | |
335 | * "ddp_done" trigger invalidation of HW | |
336 | * specific DDP context | |
337 | */ | |
338 | cmd->write_data_len = lport->tt.ddp_done(lport, | |
339 | ep->xid); | |
340 | ||
341 | /* | |
342 | * Resetting same variable to indicate HW's | |
343 | * DDP context has been invalidated to avoid | |
344 | * re_invalidation of same context (context is | |
345 | * identified using ep->xid) | |
346 | */ | |
347 | cmd->was_ddp_setup = 0; | |
348 | } | |
349 | } | |
350 | } |