1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/module.h>
30#include <linux/moduleparam.h>
31#include <linux/utsname.h>
32#include <linux/init.h>
33#include <linux/slab.h>
34#include <linux/kthread.h>
35#include <linux/types.h>
36#include <linux/string.h>
37#include <linux/configfs.h>
38#include <linux/ctype.h>
39#include <linux/hash.h>
40#include <linux/ratelimit.h>
41#include <asm/unaligned.h>
42#include <scsi/scsi.h>
43#include <scsi/scsi_host.h>
44#include <scsi/scsi_device.h>
45#include <scsi/scsi_cmnd.h>
46#include <scsi/libfc.h>
47#include <scsi/fc_encode.h>
48
49#include <target/target_core_base.h>
50#include <target/target_core_fabric.h>
51#include <target/target_core_configfs.h>
52#include <target/configfs_macros.h>
53
54#include "tcm_fc.h"
55
56
57
58
59
60int ft_queue_data_in(struct se_cmd *se_cmd)
61{
62 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
63 struct fc_frame *fp = NULL;
64 struct fc_exch *ep;
65 struct fc_lport *lport;
66 struct scatterlist *sg = NULL;
67 size_t remaining;
68 u32 f_ctl = FC_FC_EX_CTX | FC_FC_REL_OFF;
69 u32 mem_off = 0;
70 u32 fh_off = 0;
71 u32 frame_off = 0;
72 size_t frame_len = 0;
73 size_t mem_len = 0;
74 size_t tlen;
75 size_t off_in_page;
76 struct page *page = NULL;
77 int use_sg;
78 int error;
79 void *page_addr;
80 void *from;
81 void *to = NULL;
82
83 if (cmd->aborted)
84 return 0;
85 ep = fc_seq_exch(cmd->seq);
86 lport = ep->lp;
87 cmd->seq = lport->tt.seq_start_next(cmd->seq);
88
89 remaining = se_cmd->data_length;
90
91
92
93
94 BUG_ON(remaining && !se_cmd->t_data_sg);
95 if (remaining) {
96 sg = se_cmd->t_data_sg;
97 mem_len = sg->length;
98 mem_off = sg->offset;
99 page = sg_page(sg);
100 }
101
102
103 use_sg = !(remaining % 4);
104
105 while (remaining) {
106 if (!mem_len) {
107 sg = sg_next(sg);
108 mem_len = min((size_t)sg->length, remaining);
109 mem_off = sg->offset;
110 page = sg_page(sg);
111 }
112 if (!frame_len) {
113
114
115
116
117
118 frame_len = (lport->seq_offload) ? lport->lso_max :
119 cmd->sess->max_frame;
120 frame_len = min(frame_len, remaining);
121 fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len);
122 if (!fp)
123 return -ENOMEM;
124 to = fc_frame_payload_get(fp, 0);
125 fh_off = frame_off;
126 frame_off += frame_len;
127
128
129
130
131
132
133 fr_max_payload(fp) = cmd->sess->max_frame;
134 }
135 tlen = min(mem_len, frame_len);
136
137 if (use_sg) {
138 off_in_page = mem_off;
139 BUG_ON(!page);
140 get_page(page);
141 skb_fill_page_desc(fp_skb(fp),
142 skb_shinfo(fp_skb(fp))->nr_frags,
143 page, off_in_page, tlen);
144 fr_len(fp) += tlen;
145 fp_skb(fp)->data_len += tlen;
146 fp_skb(fp)->truesize +=
147 PAGE_SIZE << compound_order(page);
148 } else {
149 BUG_ON(!page);
150 from = kmap_atomic(page + (mem_off >> PAGE_SHIFT));
151 page_addr = from;
152 from += mem_off & ~PAGE_MASK;
153 tlen = min(tlen, (size_t)(PAGE_SIZE -
154 (mem_off & ~PAGE_MASK)));
155 memcpy(to, from, tlen);
156 kunmap_atomic(page_addr);
157 to += tlen;
158 }
159
160 mem_off += tlen;
161 mem_len -= tlen;
162 frame_len -= tlen;
163 remaining -= tlen;
164
165 if (frame_len &&
166 (skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN))
167 continue;
168 if (!remaining)
169 f_ctl |= FC_FC_END_SEQ;
170 fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
171 FC_TYPE_FCP, f_ctl, fh_off);
172 error = lport->tt.seq_send(lport, cmd->seq, fp);
173 if (error) {
174
175 pr_err_ratelimited("%s: Failed to send frame %p, "
176 "xid <0x%x>, remaining %zu, "
177 "lso_max <0x%x>\n",
178 __func__, fp, ep->xid,
179 remaining, lport->lso_max);
180 }
181 }
182 return ft_queue_status(se_cmd);
183}
184
185static void ft_execute_work(struct work_struct *work)
186{
187 struct ft_cmd *cmd = container_of(work, struct ft_cmd, work);
188
189 target_execute_cmd(&cmd->se_cmd);
190}
191
192
193
194
195void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
196{
197 struct se_cmd *se_cmd = &cmd->se_cmd;
198 struct fc_seq *seq = cmd->seq;
199 struct fc_exch *ep;
200 struct fc_lport *lport;
201 struct fc_frame_header *fh;
202 struct scatterlist *sg = NULL;
203 u32 mem_off = 0;
204 u32 rel_off;
205 size_t frame_len;
206 size_t mem_len = 0;
207 size_t tlen;
208 struct page *page = NULL;
209 void *page_addr;
210 void *from;
211 void *to;
212 u32 f_ctl;
213 void *buf;
214
215 fh = fc_frame_header_get(fp);
216 if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF))
217 goto drop;
218
219 f_ctl = ntoh24(fh->fh_f_ctl);
220 ep = fc_seq_exch(seq);
221 lport = ep->lp;
222 if (cmd->was_ddp_setup) {
223 BUG_ON(!ep);
224 BUG_ON(!lport);
225
226
227
228
229 buf = fc_frame_payload_get(fp, 1);
230 if (buf)
231 pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, "
232 "cmd->sg_cnt 0x%x. DDP was setup"
233 " hence not expected to receive frame with "
234 "payload, Frame will be dropped if"
235 "'Sequence Initiative' bit in f_ctl is"
236 "not set\n", __func__, ep->xid, f_ctl,
237 se_cmd->t_data_sg, se_cmd->t_data_nents);
238
239
240
241
242
243 ft_invl_hw_context(cmd);
244
245
246
247
248
249
250
251
252
253
254
255 if (f_ctl & FC_FC_SEQ_INIT)
256 goto last_frame;
257 else
258 goto drop;
259 }
260
261 rel_off = ntohl(fh->fh_parm_offset);
262 frame_len = fr_len(fp);
263 if (frame_len <= sizeof(*fh))
264 goto drop;
265 frame_len -= sizeof(*fh);
266 from = fc_frame_payload_get(fp, 0);
267 if (rel_off >= se_cmd->data_length)
268 goto drop;
269 if (frame_len + rel_off > se_cmd->data_length)
270 frame_len = se_cmd->data_length - rel_off;
271
272
273
274
275 BUG_ON(frame_len && !se_cmd->t_data_sg);
276 if (frame_len) {
277 sg = se_cmd->t_data_sg;
278 mem_len = sg->length;
279 mem_off = sg->offset;
280 page = sg_page(sg);
281 }
282
283 while (frame_len) {
284 if (!mem_len) {
285 sg = sg_next(sg);
286 mem_len = sg->length;
287 mem_off = sg->offset;
288 page = sg_page(sg);
289 }
290 if (rel_off >= mem_len) {
291 rel_off -= mem_len;
292 mem_len = 0;
293 continue;
294 }
295 mem_off += rel_off;
296 mem_len -= rel_off;
297 rel_off = 0;
298
299 tlen = min(mem_len, frame_len);
300
301 to = kmap_atomic(page + (mem_off >> PAGE_SHIFT));
302 page_addr = to;
303 to += mem_off & ~PAGE_MASK;
304 tlen = min(tlen, (size_t)(PAGE_SIZE -
305 (mem_off & ~PAGE_MASK)));
306 memcpy(to, from, tlen);
307 kunmap_atomic(page_addr);
308
309 from += tlen;
310 frame_len -= tlen;
311 mem_off += tlen;
312 mem_len -= tlen;
313 cmd->write_data_len += tlen;
314 }
315last_frame:
316 if (cmd->write_data_len == se_cmd->data_length) {
317 INIT_WORK(&cmd->work, ft_execute_work);
318 queue_work(cmd->sess->tport->tpg->workqueue, &cmd->work);
319 }
320drop:
321 fc_frame_free(fp);
322}
323
324
325
326
327
328void ft_invl_hw_context(struct ft_cmd *cmd)
329{
330 struct fc_seq *seq;
331 struct fc_exch *ep = NULL;
332 struct fc_lport *lport = NULL;
333
334 BUG_ON(!cmd);
335 seq = cmd->seq;
336
337
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
345
346
347 cmd->write_data_len = lport->tt.ddp_done(lport,
348 ep->xid);
349
350
351
352
353
354
355
356 cmd->was_ddp_setup = 0;
357 }
358 }
359}
360