?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] libiscsi: fix nop handling
[linux-2.6/x86.git] / drivers / scsi / iscsi_tcp.c
blob9b418522c9bf503b2210028e19c6563931e09f4a
1 /*
2 * iSCSI Initiator over TCP/IP Data-Path
3 *
4 * Copyright (C) 2004 Dmitry Yusupov
5 * Copyright (C) 2004 Alex Aizman
6 * Copyright (C) 2005 - 2006 Mike Christie
7 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
8 * maintained by open-iscsi@googlegroups.com
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published
12 * by the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * See the file COPYING included with this distribution for more details.
21 *
22 * Credits:
23 * Christoph Hellwig
24 * FUJITA Tomonori
25 * Arne Redlich
26 * Zhenyu Wang
27 */
28
29 #include <linux/types.h>
30 #include <linux/list.h>
31 #include <linux/inet.h>
32 #include <linux/file.h>
33 #include <linux/blkdev.h>
34 #include <linux/crypto.h>
35 #include <linux/delay.h>
36 #include <linux/kfifo.h>
37 #include <linux/scatterlist.h>
38 #include <net/tcp.h>
39 #include <scsi/scsi_cmnd.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_host.h>
42 #include <scsi/scsi.h>
43 #include <scsi/scsi_transport_iscsi.h>
44
45 #include "iscsi_tcp.h"
46
47 MODULE_AUTHOR("Dmitry Yusupov <dmitry_yus@yahoo.com>, "
48 "Alex Aizman <itn780@yahoo.com>");
49 MODULE_DESCRIPTION("iSCSI/TCP data-path");
50 MODULE_LICENSE("GPL");
51 #undef DEBUG_TCP
52 #define DEBUG_ASSERT
53
54 #ifdef DEBUG_TCP
55 #define debug_tcp(fmt...) printk(KERN_INFO "tcp: " fmt)
56 #else
57 #define debug_tcp(fmt...)
58 #endif
59
60 #ifndef DEBUG_ASSERT
61 #ifdef BUG_ON
62 #undef BUG_ON
63 #endif
64 #define BUG_ON(expr)
65 #endif
66
67 static unsigned int iscsi_max_lun = 512;
68 module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);
69
70 static int iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
71 struct iscsi_chunk *chunk);
72
73 static inline void
74 iscsi_buf_init_iov(struct iscsi_buf *ibuf, char *vbuf, int size)
75 {
76 ibuf->sg.page = virt_to_page(vbuf);
77 ibuf->sg.offset = offset_in_page(vbuf);
78 ibuf->sg.length = size;
79 ibuf->sent = 0;
80 ibuf->use_sendmsg = 1;
81 }
82
83 static inline void
84 iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg)
85 {
86 ibuf->sg.page = sg->page;
87 ibuf->sg.offset = sg->offset;
88 ibuf->sg.length = sg->length;
89 /*
90 * Fastpath: sg element fits into single page
91 */
92 if (sg->length + sg->offset <= PAGE_SIZE && !PageSlab(sg->page))
93 ibuf->use_sendmsg = 0;
94 else
95 ibuf->use_sendmsg = 1;
96 ibuf->sent = 0;
97 }
98
99 static inline int
100 iscsi_buf_left(struct iscsi_buf *ibuf)
101 {
102 int rc;
103
104 rc = ibuf->sg.length - ibuf->sent;
105 BUG_ON(rc < 0);
106 return rc;
107 }
108
109 static inline void
110 iscsi_hdr_digest(struct iscsi_conn *conn, struct iscsi_buf *buf,
111 u8* crc)
112 {
113 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
114
115 crypto_hash_digest(&tcp_conn->tx_hash, &buf->sg, buf->sg.length, crc);
116 buf->sg.length += ISCSI_DIGEST_SIZE;
117 }
118
119 /*
120 * Scatterlist handling: inside the iscsi_chunk, we
121 * remember an index into the scatterlist, and set data/size
122 * to the current scatterlist entry. For highmem pages, we
123 * kmap as needed.
124 *
125 * Note that the page is unmapped when we return from
126 * TCP's data_ready handler, so we may end up mapping and
127 * unmapping the same page repeatedly. The whole reason
128 * for this is that we shouldn't keep the page mapped
129 * outside the softirq.
130 */
131
132 /**
133 * iscsi_tcp_chunk_init_sg - init indicated scatterlist entry
134 * @chunk: the buffer object
135 * @idx: index into scatterlist
136 * @offset: byte offset into that sg entry
137 *
138 * This function sets up the chunk so that subsequent
139 * data is copied to the indicated sg entry, at the given
140 * offset.
141 */
142 static inline void
143 iscsi_tcp_chunk_init_sg(struct iscsi_chunk *chunk,
144 unsigned int idx, unsigned int offset)
145 {
146 struct scatterlist *sg;
147
148 BUG_ON(chunk->sg == NULL);
149
150 sg = &chunk->sg[idx];
151 chunk->sg_index = idx;
152 chunk->sg_offset = offset;
153 chunk->size = min(sg->length - offset, chunk->total_size);
154 chunk->data = NULL;
155 }
156
157 /**
158 * iscsi_tcp_chunk_map - map the current S/G page
159 * @chunk: iscsi chunk
160 *
161 * We only need to possibly kmap data if scatter lists are being used,
162 * because the iscsi passthrough and internal IO paths will never use high
163 * mem pages.
164 */
165 static inline void
166 iscsi_tcp_chunk_map(struct iscsi_chunk *chunk)
167 {
168 struct scatterlist *sg;
169
170 if (chunk->data != NULL || !chunk->sg)
171 return;
172
173 sg = &chunk->sg[chunk->sg_index];
174 BUG_ON(chunk->sg_mapped);
175 BUG_ON(sg->length == 0);
176 chunk->sg_mapped = kmap_atomic(sg->page, KM_SOFTIRQ0);
177 chunk->data = chunk->sg_mapped + sg->offset + chunk->sg_offset;
178 }
179
180 static inline void
181 iscsi_tcp_chunk_unmap(struct iscsi_chunk *chunk)
182 {
183 if (chunk->sg_mapped) {
184 kunmap_atomic(chunk->sg_mapped, KM_SOFTIRQ0);
185 chunk->sg_mapped = NULL;
186 chunk->data = NULL;
187 }
188 }
189
190 /*
191 * Splice the digest buffer into the buffer
192 */
193 static inline void
194 iscsi_tcp_chunk_splice_digest(struct iscsi_chunk *chunk, void *digest)
195 {
196 chunk->data = digest;
197 chunk->digest_len = ISCSI_DIGEST_SIZE;
198 chunk->total_size += ISCSI_DIGEST_SIZE;
199 chunk->size = ISCSI_DIGEST_SIZE;
200 chunk->copied = 0;
201 chunk->sg = NULL;
202 chunk->sg_index = 0;
203 chunk->hash = NULL;
204 }
205
206 /**
207 * iscsi_tcp_chunk_done - check whether the chunk is complete
208 * @chunk: iscsi chunk to check
209 *
210 * Check if we're done receiving this chunk. If the receive
211 * buffer is full but we expect more data, move on to the
212 * next entry in the scatterlist.
213 *
214 * If the amount of data we received isn't a multiple of 4,
215 * we will transparently receive the pad bytes, too.
216 *
217 * This function must be re-entrant.
218 */
219 static inline int
220 iscsi_tcp_chunk_done(struct iscsi_chunk *chunk)
221 {
222 static unsigned char padbuf[ISCSI_PAD_LEN];
223 unsigned int pad;
224
225 if (chunk->copied < chunk->size) {
226 iscsi_tcp_chunk_map(chunk);
227 return 0;
228 }
229
230 chunk->total_copied += chunk->copied;
231 chunk->copied = 0;
232 chunk->size = 0;
233
234 /* Unmap the current scatterlist page, if there is one. */
235 iscsi_tcp_chunk_unmap(chunk);
236
237 /* Do we have more scatterlist entries? */
238 if (chunk->total_copied < chunk->total_size) {
239 /* Proceed to the next entry in the scatterlist. */
240 iscsi_tcp_chunk_init_sg(chunk, chunk->sg_index + 1, 0);
241 iscsi_tcp_chunk_map(chunk);
242 BUG_ON(chunk->size == 0);
243 return 0;
244 }
245
246 /* Do we need to handle padding? */
247 pad = iscsi_padding(chunk->total_copied);
248 if (pad != 0) {
249 debug_tcp("consume %d pad bytes\n", pad);
250 chunk->total_size += pad;
251 chunk->size = pad;
252 chunk->data = padbuf;
253 return 0;
254 }
255
256 /*
257 * Set us up for receiving the data digest. hdr digest
258 * is completely handled in hdr done function.
259 */
260 if (chunk->hash) {
261 if (chunk->digest_len == 0) {
262 crypto_hash_final(chunk->hash, chunk->digest);
263 iscsi_tcp_chunk_splice_digest(chunk,
264 chunk->recv_digest);
265 return 0;
266 }
267 }
268
269 return 1;
270 }
271
272 /**
273 * iscsi_tcp_chunk_recv - copy data to chunk
274 * @tcp_conn: the iSCSI TCP connection
275 * @chunk: the buffer to copy to
276 * @ptr: data pointer
277 * @len: amount of data available
278 *
279 * This function copies up to @len bytes to the
280 * given buffer, and returns the number of bytes
281 * consumed, which can actually be less than @len.
282 *
283 * If hash digest is enabled, the function will update the
284 * hash while copying.
285 * Combining these two operations doesn't buy us a lot (yet),
286 * but in the future we could implement combined copy+crc,
287 * just way we do for network layer checksums.
288 */
289 static int
290 iscsi_tcp_chunk_recv(struct iscsi_tcp_conn *tcp_conn,
291 struct iscsi_chunk *chunk, const void *ptr,
292 unsigned int len)
293 {
294 struct scatterlist sg;
295 unsigned int copy, copied = 0;
296
297 while (!iscsi_tcp_chunk_done(chunk)) {
298 if (copied == len)
299 goto out;
300
301 copy = min(len - copied, chunk->size - chunk->copied);
302 memcpy(chunk->data + chunk->copied, ptr + copied, copy);
303
304 if (chunk->hash) {
305 sg_init_one(&sg, ptr + copied, copy);
306 crypto_hash_update(chunk->hash, &sg, copy);
307 }
308 chunk->copied += copy;
309 copied += copy;
310 }
311
312 out:
313 return copied;
314 }
315
316 static inline void
317 iscsi_tcp_dgst_header(struct hash_desc *hash, const void *hdr, size_t hdrlen,
318 unsigned char digest[ISCSI_DIGEST_SIZE])
319 {
320 struct scatterlist sg;
321
322 sg_init_one(&sg, hdr, hdrlen);
323 crypto_hash_digest(hash, &sg, hdrlen, digest);
324 }
325
326 static inline int
327 iscsi_tcp_dgst_verify(struct iscsi_tcp_conn *tcp_conn,
328 struct iscsi_chunk *chunk)
329 {
330 if (!chunk->digest_len)
331 return 1;
332
333 if (memcmp(chunk->recv_digest, chunk->digest, chunk->digest_len)) {
334 debug_scsi("digest mismatch\n");
335 return 0;
336 }
337
338 return 1;
339 }
340
341 /*
342 * Helper function to set up chunk buffer
343 */
344 static inline void
345 __iscsi_chunk_init(struct iscsi_chunk *chunk, size_t size,
346 iscsi_chunk_done_fn_t *done, struct hash_desc *hash)
347 {
348 memset(chunk, 0, sizeof(*chunk));
349 chunk->total_size = size;
350 chunk->done = done;
351
352 if (hash) {
353 chunk->hash = hash;
354 crypto_hash_init(hash);
355 }
356 }
357
358 static inline void
359 iscsi_chunk_init_linear(struct iscsi_chunk *chunk, void *data, size_t size,
360 iscsi_chunk_done_fn_t *done, struct hash_desc *hash)
361 {
362 __iscsi_chunk_init(chunk, size, done, hash);
363 chunk->data = data;
364 chunk->size = size;
365 }
366
367 static inline int
368 iscsi_chunk_seek_sg(struct iscsi_chunk *chunk,
369 struct scatterlist *sg, unsigned int sg_count,
370 unsigned int offset, size_t size,
371 iscsi_chunk_done_fn_t *done, struct hash_desc *hash)
372 {
373 unsigned int i;
374
375 __iscsi_chunk_init(chunk, size, done, hash);
376 for (i = 0; i < sg_count; ++i) {
377 if (offset < sg[i].length) {
378 chunk->sg = sg;
379 chunk->sg_count = sg_count;
380 iscsi_tcp_chunk_init_sg(chunk, i, offset);
381 return 0;
382 }
383 offset -= sg[i].length;
384 }
385
386 return ISCSI_ERR_DATA_OFFSET;
387 }
388
389 /**
390 * iscsi_tcp_hdr_recv_prep - prep chunk for hdr reception
391 * @tcp_conn: iscsi connection to prep for
392 *
393 * This function always passes NULL for the hash argument, because when this
394 * function is called we do not yet know the final size of the header and want
395 * to delay the digest processing until we know that.
396 */
397 static void
398 iscsi_tcp_hdr_recv_prep(struct iscsi_tcp_conn *tcp_conn)
399 {
400 debug_tcp("iscsi_tcp_hdr_recv_prep(%p%s)\n", tcp_conn,
401 tcp_conn->iscsi_conn->hdrdgst_en ? ", digest enabled" : "");
402 iscsi_chunk_init_linear(&tcp_conn->in.chunk,
403 tcp_conn->in.hdr_buf, sizeof(struct iscsi_hdr),
404 iscsi_tcp_hdr_recv_done, NULL);
405 }
406
407 /*
408 * Handle incoming reply to any other type of command
409 */
410 static int
411 iscsi_tcp_data_recv_done(struct iscsi_tcp_conn *tcp_conn,
412 struct iscsi_chunk *chunk)
413 {
414 struct iscsi_conn *conn = tcp_conn->iscsi_conn;
415 int rc = 0;
416
417 if (!iscsi_tcp_dgst_verify(tcp_conn, chunk))
418 return ISCSI_ERR_DATA_DGST;
419
420 rc = iscsi_complete_pdu(conn, tcp_conn->in.hdr,
421 conn->data, tcp_conn->in.datalen);
422 if (rc)
423 return rc;
424
425 iscsi_tcp_hdr_recv_prep(tcp_conn);
426 return 0;
427 }
428
429 static void
430 iscsi_tcp_data_recv_prep(struct iscsi_tcp_conn *tcp_conn)
431 {
432 struct iscsi_conn *conn = tcp_conn->iscsi_conn;
433 struct hash_desc *rx_hash = NULL;
434
435 if (conn->datadgst_en)
436 rx_hash = &tcp_conn->rx_hash;
437
438 iscsi_chunk_init_linear(&tcp_conn->in.chunk,
439 conn->data, tcp_conn->in.datalen,
440 iscsi_tcp_data_recv_done, rx_hash);
441 }
442
443 /*
444 * must be called with session lock
445 */
446 static void
447 iscsi_tcp_cleanup_ctask(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
448 {
449 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
450 struct iscsi_r2t_info *r2t;
451 struct scsi_cmnd *sc;
452
453 /* flush ctask's r2t queues */
454 while (__kfifo_get(tcp_ctask->r2tqueue, (void*)&r2t, sizeof(void*))) {
455 __kfifo_put(tcp_ctask->r2tpool.queue, (void*)&r2t,
456 sizeof(void*));
457 debug_scsi("iscsi_tcp_cleanup_ctask pending r2t dropped\n");
458 }
459
460 sc = ctask->sc;
461 if (unlikely(!sc))
462 return;
463
464 tcp_ctask->xmstate = XMSTATE_IDLE;
465 tcp_ctask->r2t = NULL;
466 }
467
468 /**
469 * iscsi_data_rsp - SCSI Data-In Response processing
470 * @conn: iscsi connection
471 * @ctask: scsi command task
472 **/
473 static int
474 iscsi_data_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
475 {
476 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
477 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
478 struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)tcp_conn->in.hdr;
479 struct iscsi_session *session = conn->session;
480 struct scsi_cmnd *sc = ctask->sc;
481 int datasn = be32_to_cpu(rhdr->datasn);
482
483 iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
484 /*
485 * setup Data-In byte counter (gets decremented..)
486 */
487 ctask->data_count = tcp_conn->in.datalen;
488
489 if (tcp_conn->in.datalen == 0)
490 return 0;
491
492 if (tcp_ctask->exp_datasn != datasn) {
493 debug_tcp("%s: ctask->exp_datasn(%d) != rhdr->datasn(%d)\n",
494 __FUNCTION__, tcp_ctask->exp_datasn, datasn);
495 return ISCSI_ERR_DATASN;
496 }
497
498 tcp_ctask->exp_datasn++;
499
500 tcp_ctask->data_offset = be32_to_cpu(rhdr->offset);
501 if (tcp_ctask->data_offset + tcp_conn->in.datalen > scsi_bufflen(sc)) {
502 debug_tcp("%s: data_offset(%d) + data_len(%d) > total_length_in(%d)\n",
503 __FUNCTION__, tcp_ctask->data_offset,
504 tcp_conn->in.datalen, scsi_bufflen(sc));
505 return ISCSI_ERR_DATA_OFFSET;
506 }
507
508 if (rhdr->flags & ISCSI_FLAG_DATA_STATUS) {
509 sc->result = (DID_OK << 16) | rhdr->cmd_status;
510 conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
511 if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW |
512 ISCSI_FLAG_DATA_OVERFLOW)) {
513 int res_count = be32_to_cpu(rhdr->residual_count);
514
515 if (res_count > 0 &&
516 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
517 res_count <= scsi_bufflen(sc)))
518 scsi_set_resid(sc, res_count);
519 else
520 sc->result = (DID_BAD_TARGET << 16) |
521 rhdr->cmd_status;
522 }
523 }
524
525 conn->datain_pdus_cnt++;
526 return 0;
527 }
528
529 /**
530 * iscsi_solicit_data_init - initialize first Data-Out
531 * @conn: iscsi connection
532 * @ctask: scsi command task
533 * @r2t: R2T info
534 *
535 * Notes:
536 * Initialize first Data-Out within this R2T sequence and finds
537 * proper data_offset within this SCSI command.
538 *
539 * This function is called with connection lock taken.
540 **/
541 static void
542 iscsi_solicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
543 struct iscsi_r2t_info *r2t)
544 {
545 struct iscsi_data *hdr;
546 struct scsi_cmnd *sc = ctask->sc;
547 int i, sg_count = 0;
548 struct scatterlist *sg;
549
550 hdr = &r2t->dtask.hdr;
551 memset(hdr, 0, sizeof(struct iscsi_data));
552 hdr->ttt = r2t->ttt;
553 hdr->datasn = cpu_to_be32(r2t->solicit_datasn);
554 r2t->solicit_datasn++;
555 hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
556 memcpy(hdr->lun, ctask->hdr->lun, sizeof(hdr->lun));
557 hdr->itt = ctask->hdr->itt;
558 hdr->exp_statsn = r2t->exp_statsn;
559 hdr->offset = cpu_to_be32(r2t->data_offset);
560 if (r2t->data_length > conn->max_xmit_dlength) {
561 hton24(hdr->dlength, conn->max_xmit_dlength);
562 r2t->data_count = conn->max_xmit_dlength;
563 hdr->flags = 0;
564 } else {
565 hton24(hdr->dlength, r2t->data_length);
566 r2t->data_count = r2t->data_length;
567 hdr->flags = ISCSI_FLAG_CMD_FINAL;
568 }
569 conn->dataout_pdus_cnt++;
570
571 r2t->sent = 0;
572
573 iscsi_buf_init_iov(&r2t->headbuf, (char*)hdr,
574 sizeof(struct iscsi_hdr));
575
576 sg = scsi_sglist(sc);
577 r2t->sg = NULL;
578 for (i = 0; i < scsi_sg_count(sc); i++, sg += 1) {
579 /* FIXME: prefetch ? */
580 if (sg_count + sg->length > r2t->data_offset) {
581 int page_offset;
582
583 /* sg page found! */
584
585 /* offset within this page */
586 page_offset = r2t->data_offset - sg_count;
587
588 /* fill in this buffer */
589 iscsi_buf_init_sg(&r2t->sendbuf, sg);
590 r2t->sendbuf.sg.offset += page_offset;
591 r2t->sendbuf.sg.length -= page_offset;
592
593 /* xmit logic will continue with next one */
594 r2t->sg = sg + 1;
595 break;
596 }
597 sg_count += sg->length;
598 }
599 BUG_ON(r2t->sg == NULL);
600 }
601
602 /**
603 * iscsi_r2t_rsp - iSCSI R2T Response processing
604 * @conn: iscsi connection
605 * @ctask: scsi command task
606 **/
607 static int
608 iscsi_r2t_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
609 {
610 struct iscsi_r2t_info *r2t;
611 struct iscsi_session *session = conn->session;
612 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
613 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
614 struct iscsi_r2t_rsp *rhdr = (struct iscsi_r2t_rsp *)tcp_conn->in.hdr;
615 int r2tsn = be32_to_cpu(rhdr->r2tsn);
616 int rc;
617
618 if (tcp_conn->in.datalen) {
619 printk(KERN_ERR "iscsi_tcp: invalid R2t with datalen %d\n",
620 tcp_conn->in.datalen);
621 return ISCSI_ERR_DATALEN;
622 }
623
624 if (tcp_ctask->exp_datasn != r2tsn){
625 debug_tcp("%s: ctask->exp_datasn(%d) != rhdr->r2tsn(%d)\n",
626 __FUNCTION__, tcp_ctask->exp_datasn, r2tsn);
627 return ISCSI_ERR_R2TSN;
628 }
629
630 /* fill-in new R2T associated with the task */
631 spin_lock(&session->lock);
632 iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
633
634 if (!ctask->sc || session->state != ISCSI_STATE_LOGGED_IN) {
635 printk(KERN_INFO "iscsi_tcp: dropping R2T itt %d in "
636 "recovery...\n", ctask->itt);
637 spin_unlock(&session->lock);
638 return 0;
639 }
640
641 rc = __kfifo_get(tcp_ctask->r2tpool.queue, (void*)&r2t, sizeof(void*));
642 BUG_ON(!rc);
643
644 r2t->exp_statsn = rhdr->statsn;
645 r2t->data_length = be32_to_cpu(rhdr->data_length);
646 if (r2t->data_length == 0) {
647 printk(KERN_ERR "iscsi_tcp: invalid R2T with zero data len\n");
648 spin_unlock(&session->lock);
649 return ISCSI_ERR_DATALEN;
650 }
651
652 if (r2t->data_length > session->max_burst)
653 debug_scsi("invalid R2T with data len %u and max burst %u."
654 "Attempting to execute request.\n",
655 r2t->data_length, session->max_burst);
656
657 r2t->data_offset = be32_to_cpu(rhdr->data_offset);
658 if (r2t->data_offset + r2t->data_length > scsi_bufflen(ctask->sc)) {
659 spin_unlock(&session->lock);
660 printk(KERN_ERR "iscsi_tcp: invalid R2T with data len %u at "
661 "offset %u and total length %d\n", r2t->data_length,
662 r2t->data_offset, scsi_bufflen(ctask->sc));
663 return ISCSI_ERR_DATALEN;
664 }
665
666 r2t->ttt = rhdr->ttt; /* no flip */
667 r2t->solicit_datasn = 0;
668
669 iscsi_solicit_data_init(conn, ctask, r2t);
670
671 tcp_ctask->exp_datasn = r2tsn + 1;
672 __kfifo_put(tcp_ctask->r2tqueue, (void*)&r2t, sizeof(void*));
673 tcp_ctask->xmstate |= XMSTATE_SOL_HDR_INIT;
674 conn->r2t_pdus_cnt++;
675
676 iscsi_requeue_ctask(ctask);
677 spin_unlock(&session->lock);
678
679 return 0;
680 }
681
682 /*
683 * Handle incoming reply to DataIn command
684 */
685 static int
686 iscsi_tcp_process_data_in(struct iscsi_tcp_conn *tcp_conn,
687 struct iscsi_chunk *chunk)
688 {
689 struct iscsi_conn *conn = tcp_conn->iscsi_conn;
690 struct iscsi_hdr *hdr = tcp_conn->in.hdr;
691 int rc;
692
693 if (!iscsi_tcp_dgst_verify(tcp_conn, chunk))
694 return ISCSI_ERR_DATA_DGST;
695
696 /* check for non-exceptional status */
697 if (hdr->flags & ISCSI_FLAG_DATA_STATUS) {
698 rc = iscsi_complete_pdu(conn, tcp_conn->in.hdr, NULL, 0);
699 if (rc)
700 return rc;
701 }
702
703 iscsi_tcp_hdr_recv_prep(tcp_conn);
704 return 0;
705 }
706
707 /**
708 * iscsi_tcp_hdr_dissect - process PDU header
709 * @conn: iSCSI connection
710 * @hdr: PDU header
711 *
712 * This function analyzes the header of the PDU received,
713 * and performs several sanity checks. If the PDU is accompanied
714 * by data, the receive buffer is set up to copy the incoming data
715 * to the correct location.
716 */
717 static int
718 iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
719 {
720 int rc = 0, opcode, ahslen;
721 struct iscsi_session *session = conn->session;
722 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
723 struct iscsi_cmd_task *ctask;
724 uint32_t itt;
725
726 /* verify PDU length */
727 tcp_conn->in.datalen = ntoh24(hdr->dlength);
728 if (tcp_conn->in.datalen > conn->max_recv_dlength) {
729 printk(KERN_ERR "iscsi_tcp: datalen %d > %d\n",
730 tcp_conn->in.datalen, conn->max_recv_dlength);
731 return ISCSI_ERR_DATALEN;
732 }
733
734 /* Additional header segments. So far, we don't
735 * process additional headers.
736 */
737 ahslen = hdr->hlength << 2;
738
739 opcode = hdr->opcode & ISCSI_OPCODE_MASK;
740 /* verify itt (itt encoding: age+cid+itt) */
741 rc = iscsi_verify_itt(conn, hdr, &itt);
742 if (rc == ISCSI_ERR_NO_SCSI_CMD) {
743 /* XXX: what does this do? */
744 tcp_conn->in.datalen = 0; /* force drop */
745 return 0;
746 } else if (rc)
747 return rc;
748
749 debug_tcp("opcode 0x%x ahslen %d datalen %d\n",
750 opcode, ahslen, tcp_conn->in.datalen);
751
752 switch(opcode) {
753 case ISCSI_OP_SCSI_DATA_IN:
754 ctask = session->cmds[itt];
755 rc = iscsi_data_rsp(conn, ctask);
756 if (rc)
757 return rc;
758 if (tcp_conn->in.datalen) {
759 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
760 struct hash_desc *rx_hash = NULL;
761
762 /*
763 * Setup copy of Data-In into the Scsi_Cmnd
764 * Scatterlist case:
765 * We set up the iscsi_chunk to point to the next
766 * scatterlist entry to copy to. As we go along,
767 * we move on to the next scatterlist entry and
768 * update the digest per-entry.
769 */
770 if (conn->datadgst_en)
771 rx_hash = &tcp_conn->rx_hash;
772
773 debug_tcp("iscsi_tcp_begin_data_in(%p, offset=%d, "
774 "datalen=%d)\n", tcp_conn,
775 tcp_ctask->data_offset,
776 tcp_conn->in.datalen);
777 return iscsi_chunk_seek_sg(&tcp_conn->in.chunk,
778 scsi_sglist(ctask->sc),
779 scsi_sg_count(ctask->sc),
780 tcp_ctask->data_offset,
781 tcp_conn->in.datalen,
782 iscsi_tcp_process_data_in,
783 rx_hash);
784 }
785 /* fall through */
786 case ISCSI_OP_SCSI_CMD_RSP:
787 if (tcp_conn->in.datalen) {
788 iscsi_tcp_data_recv_prep(tcp_conn);
789 return 0;
790 }
791 rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
792 break;
793 case ISCSI_OP_R2T:
794 ctask = session->cmds[itt];
795 if (ahslen)
796 rc = ISCSI_ERR_AHSLEN;
797 else if (ctask->sc->sc_data_direction == DMA_TO_DEVICE)
798 rc = iscsi_r2t_rsp(conn, ctask);
799 else
800 rc = ISCSI_ERR_PROTO;
801 break;
802 case ISCSI_OP_LOGIN_RSP:
803 case ISCSI_OP_TEXT_RSP:
804 case ISCSI_OP_REJECT:
805 case ISCSI_OP_ASYNC_EVENT:
806 /*
807 * It is possible that we could get a PDU with a buffer larger
808 * than 8K, but there are no targets that currently do this.
809 * For now we fail until we find a vendor that needs it
810 */
811 if (ISCSI_DEF_MAX_RECV_SEG_LEN < tcp_conn->in.datalen) {
812 printk(KERN_ERR "iscsi_tcp: received buffer of len %u "
813 "but conn buffer is only %u (opcode %0x)\n",
814 tcp_conn->in.datalen,
815 ISCSI_DEF_MAX_RECV_SEG_LEN, opcode);
816 rc = ISCSI_ERR_PROTO;
817 break;
818 }
819
820 /* If there's data coming in with the response,
821 * receive it to the connection's buffer.
822 */
823 if (tcp_conn->in.datalen) {
824 iscsi_tcp_data_recv_prep(tcp_conn);
825 return 0;
826 }
827 /* fall through */
828 case ISCSI_OP_LOGOUT_RSP:
829 case ISCSI_OP_NOOP_IN:
830 case ISCSI_OP_SCSI_TMFUNC_RSP:
831 rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
832 break;
833 default:
834 rc = ISCSI_ERR_BAD_OPCODE;
835 break;
836 }
837
838 if (rc == 0) {
839 /* Anything that comes with data should have
840 * been handled above. */
841 if (tcp_conn->in.datalen)
842 return ISCSI_ERR_PROTO;
843 iscsi_tcp_hdr_recv_prep(tcp_conn);
844 }
845
846 return rc;
847 }
848
849 static inline void
850 partial_sg_digest_update(struct hash_desc *desc, struct scatterlist *sg,
851 int offset, int length)
852 {
853 struct scatterlist temp;
854
855 sg_init_table(&temp, 1);
856 sg_set_page(&temp, sg_page(sg), length, offset);
857 crypto_hash_update(desc, &temp, length);
858 }
859
860 /**
861 * iscsi_tcp_hdr_recv_done - process PDU header
862 *
863 * This is the callback invoked when the PDU header has
864 * been received. If the header is followed by additional
865 * header segments, we go back for more data.
866 */
867 static int
868 iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
869 struct iscsi_chunk *chunk)
870 {
871 struct iscsi_conn *conn = tcp_conn->iscsi_conn;
872 struct iscsi_hdr *hdr;
873
874 /* Check if there are additional header segments
875 * *prior* to computing the digest, because we
876 * may need to go back to the caller for more.
877 */
878 hdr = (struct iscsi_hdr *) tcp_conn->in.hdr_buf;
879 if (chunk->copied == sizeof(struct iscsi_hdr) && hdr->hlength) {
880 /* Bump the header length - the caller will
881 * just loop around and get the AHS for us, and
882 * call again. */
883 unsigned int ahslen = hdr->hlength << 2;
884
885 /* Make sure we don't overflow */
886 if (sizeof(*hdr) + ahslen > sizeof(tcp_conn->in.hdr_buf))
887 return ISCSI_ERR_AHSLEN;
888
889 chunk->total_size += ahslen;
890 chunk->size += ahslen;
891 return 0;
892 }
893
894 /* We're done processing the header. See if we're doing
895 * header digests; if so, set up the recv_digest buffer
896 * and go back for more. */
897 if (conn->hdrdgst_en) {
898 if (chunk->digest_len == 0) {
899 iscsi_tcp_chunk_splice_digest(chunk,
900 chunk->recv_digest);
901 return 0;
902 }
903 iscsi_tcp_dgst_header(&tcp_conn->rx_hash, hdr,
904 chunk->total_copied - ISCSI_DIGEST_SIZE,
905 chunk->digest);
906
907 if (!iscsi_tcp_dgst_verify(tcp_conn, chunk))
908 return ISCSI_ERR_HDR_DGST;
909 }
910
911 tcp_conn->in.hdr = hdr;
912 return iscsi_tcp_hdr_dissect(conn, hdr);
913 }
914
915 /**
916 * iscsi_tcp_recv - TCP receive in sendfile fashion
917 * @rd_desc: read descriptor
918 * @skb: socket buffer
919 * @offset: offset in skb
920 * @len: skb->len - offset
921 **/
922 static int
923 iscsi_tcp_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
924 unsigned int offset, size_t len)
925 {
926 struct iscsi_conn *conn = rd_desc->arg.data;
927 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
928 struct iscsi_chunk *chunk = &tcp_conn->in.chunk;
929 struct skb_seq_state seq;
930 unsigned int consumed = 0;
931 int rc = 0;
932
933 debug_tcp("in %d bytes\n", skb->len - offset);
934
935 if (unlikely(conn->suspend_rx)) {
936 debug_tcp("conn %d Rx suspended!\n", conn->id);
937 return 0;
938 }
939
940 skb_prepare_seq_read(skb, offset, skb->len, &seq);
941 while (1) {
942 unsigned int avail;
943 const u8 *ptr;
944
945 avail = skb_seq_read(consumed, &ptr, &seq);
946 if (avail == 0)
947 break;
948 BUG_ON(chunk->copied >= chunk->size);
949
950 debug_tcp("skb %p ptr=%p avail=%u\n", skb, ptr, avail);
951 rc = iscsi_tcp_chunk_recv(tcp_conn, chunk, ptr, avail);
952 BUG_ON(rc == 0);
953 consumed += rc;
954
955 if (chunk->total_copied >= chunk->total_size) {
956 rc = chunk->done(tcp_conn, chunk);
957 if (rc != 0) {
958 skb_abort_seq_read(&seq);
959 goto error;
960 }
961
962 /* The done() functions sets up the
963 * next chunk. */
964 }
965 }
966
967 conn->rxdata_octets += consumed;
968 return consumed;
969
970 error:
971 debug_tcp("Error receiving PDU, errno=%d\n", rc);
972 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
973 return 0;
974 }
975
976 static void
977 iscsi_tcp_data_ready(struct sock *sk, int flag)
978 {
979 struct iscsi_conn *conn = sk->sk_user_data;
980 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
981 read_descriptor_t rd_desc;
982
983 read_lock(&sk->sk_callback_lock);
984
985 /*
986 * Use rd_desc to pass 'conn' to iscsi_tcp_recv.
987 * We set count to 1 because we want the network layer to
988 * hand us all the skbs that are available. iscsi_tcp_recv
989 * handled pdus that cross buffers or pdus that still need data.
990 */
991 rd_desc.arg.data = conn;
992 rd_desc.count = 1;
993 tcp_read_sock(sk, &rd_desc, iscsi_tcp_recv);
994
995 read_unlock(&sk->sk_callback_lock);
996
997 /* If we had to (atomically) map a highmem page,
998 * unmap it now. */
999 iscsi_tcp_chunk_unmap(&tcp_conn->in.chunk);
1000 }
1001
1002 static void
1003 iscsi_tcp_state_change(struct sock *sk)
1004 {
1005 struct iscsi_tcp_conn *tcp_conn;
1006 struct iscsi_conn *conn;
1007 struct iscsi_session *session;
1008 void (*old_state_change)(struct sock *);
1009
1010 read_lock(&sk->sk_callback_lock);
1011
1012 conn = (struct iscsi_conn*)sk->sk_user_data;
1013 session = conn->session;
1014
1015 if ((sk->sk_state == TCP_CLOSE_WAIT ||
1016 sk->sk_state == TCP_CLOSE) &&
1017 !atomic_read(&sk->sk_rmem_alloc)) {
1018 debug_tcp("iscsi_tcp_state_change: TCP_CLOSE|TCP_CLOSE_WAIT\n");
1019 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1020 }
1021
1022 tcp_conn = conn->dd_data;
1023 old_state_change = tcp_conn->old_state_change;
1024
1025 read_unlock(&sk->sk_callback_lock);
1026
1027 old_state_change(sk);
1028 }
1029
1030 /**
1031 * iscsi_write_space - Called when more output buffer space is available
1032 * @sk: socket space is available for
1033 **/
1034 static void
1035 iscsi_write_space(struct sock *sk)
1036 {
1037 struct iscsi_conn *conn = (struct iscsi_conn*)sk->sk_user_data;
1038 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1039
1040 tcp_conn->old_write_space(sk);
1041 debug_tcp("iscsi_write_space: cid %d\n", conn->id);
1042 scsi_queue_work(conn->session->host, &conn->xmitwork);
1043 }
1044
1045 static void
1046 iscsi_conn_set_callbacks(struct iscsi_conn *conn)
1047 {
1048 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1049 struct sock *sk = tcp_conn->sock->sk;
1050
1051 /* assign new callbacks */
1052 write_lock_bh(&sk->sk_callback_lock);
1053 sk->sk_user_data = conn;
1054 tcp_conn->old_data_ready = sk->sk_data_ready;
1055 tcp_conn->old_state_change = sk->sk_state_change;
1056 tcp_conn->old_write_space = sk->sk_write_space;
1057 sk->sk_data_ready = iscsi_tcp_data_ready;
1058 sk->sk_state_change = iscsi_tcp_state_change;
1059 sk->sk_write_space = iscsi_write_space;
1060 write_unlock_bh(&sk->sk_callback_lock);
1061 }
1062
1063 static void
1064 iscsi_conn_restore_callbacks(struct iscsi_tcp_conn *tcp_conn)
1065 {
1066 struct sock *sk = tcp_conn->sock->sk;
1067
1068 /* restore socket callbacks, see also: iscsi_conn_set_callbacks() */
1069 write_lock_bh(&sk->sk_callback_lock);
1070 sk->sk_user_data = NULL;
1071 sk->sk_data_ready = tcp_conn->old_data_ready;
1072 sk->sk_state_change = tcp_conn->old_state_change;
1073 sk->sk_write_space = tcp_conn->old_write_space;
1074 sk->sk_no_check = 0;
1075 write_unlock_bh(&sk->sk_callback_lock);
1076 }
1077
1078 /**
1079 * iscsi_send - generic send routine
1080 * @sk: kernel's socket
1081 * @buf: buffer to write from
1082 * @size: actual size to write
1083 * @flags: socket's flags
1084 */
1085 static inline int
1086 iscsi_send(struct iscsi_conn *conn, struct iscsi_buf *buf, int size, int flags)
1087 {
1088 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1089 struct socket *sk = tcp_conn->sock;
1090 int offset = buf->sg.offset + buf->sent, res;
1091
1092 /*
1093 * if we got use_sg=0 or are sending something we kmallocd
1094 * then we did not have to do kmap (kmap returns page_address)
1095 *
1096 * if we got use_sg > 0, but had to drop down, we do not
1097 * set clustering so this should only happen for that
1098 * slab case.
1099 */
1100 if (buf->use_sendmsg)
1101 res = sock_no_sendpage(sk, buf->sg.page, offset, size, flags);
1102 else
1103 res = tcp_conn->sendpage(sk, buf->sg.page, offset, size, flags);
1104
1105 if (res >= 0) {
1106 conn->txdata_octets += res;
1107 buf->sent += res;
1108 return res;
1109 }
1110
1111 tcp_conn->sendpage_failures_cnt++;
1112 if (res == -EAGAIN)
1113 res = -ENOBUFS;
1114 else
1115 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1116 return res;
1117 }
1118
1119 /**
1120 * iscsi_sendhdr - send PDU Header via tcp_sendpage()
1121 * @conn: iscsi connection
1122 * @buf: buffer to write from
1123 * @datalen: lenght of data to be sent after the header
1124 *
1125 * Notes:
1126 * (Tx, Fast Path)
1127 **/
1128 static inline int
1129 iscsi_sendhdr(struct iscsi_conn *conn, struct iscsi_buf *buf, int datalen)
1130 {
1131 int flags = 0; /* MSG_DONTWAIT; */
1132 int res, size;
1133
1134 size = buf->sg.length - buf->sent;
1135 BUG_ON(buf->sent + size > buf->sg.length);
1136 if (buf->sent + size != buf->sg.length || datalen)
1137 flags |= MSG_MORE;
1138
1139 res = iscsi_send(conn, buf, size, flags);
1140 debug_tcp("sendhdr %d bytes, sent %d res %d\n", size, buf->sent, res);
1141 if (res >= 0) {
1142 if (size != res)
1143 return -EAGAIN;
1144 return 0;
1145 }
1146
1147 return res;
1148 }
1149
1150 /**
1151 * iscsi_sendpage - send one page of iSCSI Data-Out.
1152 * @conn: iscsi connection
1153 * @buf: buffer to write from
1154 * @count: remaining data
1155 * @sent: number of bytes sent
1156 *
1157 * Notes:
1158 * (Tx, Fast Path)
1159 **/
1160 static inline int
1161 iscsi_sendpage(struct iscsi_conn *conn, struct iscsi_buf *buf,
1162 int *count, int *sent)
1163 {
1164 int flags = 0; /* MSG_DONTWAIT; */
1165 int res, size;
1166
1167 size = buf->sg.length - buf->sent;
1168 BUG_ON(buf->sent + size > buf->sg.length);
1169 if (size > *count)
1170 size = *count;
1171 if (buf->sent + size != buf->sg.length || *count != size)
1172 flags |= MSG_MORE;
1173
1174 res = iscsi_send(conn, buf, size, flags);
1175 debug_tcp("sendpage: %d bytes, sent %d left %d sent %d res %d\n",
1176 size, buf->sent, *count, *sent, res);
1177 if (res >= 0) {
1178 *count -= res;
1179 *sent += res;
1180 if (size != res)
1181 return -EAGAIN;
1182 return 0;
1183 }
1184
1185 return res;
1186 }
1187
1188 static inline void
1189 iscsi_data_digest_init(struct iscsi_tcp_conn *tcp_conn,
1190 struct iscsi_tcp_cmd_task *tcp_ctask)
1191 {
1192 crypto_hash_init(&tcp_conn->tx_hash);
1193 tcp_ctask->digest_count = 4;
1194 }
1195
1196 /**
1197 * iscsi_solicit_data_cont - initialize next Data-Out
1198 * @conn: iscsi connection
1199 * @ctask: scsi command task
1200 * @r2t: R2T info
1201 * @left: bytes left to transfer
1202 *
1203 * Notes:
1204 * Initialize next Data-Out within this R2T sequence and continue
1205 * to process next Scatter-Gather element(if any) of this SCSI command.
1206 *
1207 * Called under connection lock.
1208 **/
1209 static void
1210 iscsi_solicit_data_cont(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
1211 struct iscsi_r2t_info *r2t, int left)
1212 {
1213 struct iscsi_data *hdr;
1214 int new_offset;
1215
1216 hdr = &r2t->dtask.hdr;
1217 memset(hdr, 0, sizeof(struct iscsi_data));
1218 hdr->ttt = r2t->ttt;
1219 hdr->datasn = cpu_to_be32(r2t->solicit_datasn);
1220 r2t->solicit_datasn++;
1221 hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
1222 memcpy(hdr->lun, ctask->hdr->lun, sizeof(hdr->lun));
1223 hdr->itt = ctask->hdr->itt;
1224 hdr->exp_statsn = r2t->exp_statsn;
1225 new_offset = r2t->data_offset + r2t->sent;
1226 hdr->offset = cpu_to_be32(new_offset);
1227 if (left > conn->max_xmit_dlength) {
1228 hton24(hdr->dlength, conn->max_xmit_dlength);
1229 r2t->data_count = conn->max_xmit_dlength;
1230 } else {
1231 hton24(hdr->dlength, left);
1232 r2t->data_count = left;
1233 hdr->flags = ISCSI_FLAG_CMD_FINAL;
1234 }
1235 conn->dataout_pdus_cnt++;
1236
1237 iscsi_buf_init_iov(&r2t->headbuf, (char*)hdr,
1238 sizeof(struct iscsi_hdr));
1239
1240 if (iscsi_buf_left(&r2t->sendbuf))
1241 return;
1242
1243 iscsi_buf_init_sg(&r2t->sendbuf, r2t->sg);
1244 r2t->sg += 1;
1245 }
1246
1247 static void iscsi_set_padding(struct iscsi_tcp_cmd_task *tcp_ctask,
1248 unsigned long len)
1249 {
1250 tcp_ctask->pad_count = len & (ISCSI_PAD_LEN - 1);
1251 if (!tcp_ctask->pad_count)
1252 return;
1253
1254 tcp_ctask->pad_count = ISCSI_PAD_LEN - tcp_ctask->pad_count;
1255 debug_scsi("write padding %d bytes\n", tcp_ctask->pad_count);
1256 tcp_ctask->xmstate |= XMSTATE_W_PAD;
1257 }
1258
1259 /**
1260 * iscsi_tcp_cmd_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands
1261 * @conn: iscsi connection
1262 * @ctask: scsi command task
1263 * @sc: scsi command
1264 **/
1265 static void
1266 iscsi_tcp_cmd_init(struct iscsi_cmd_task *ctask)
1267 {
1268 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1269
1270 BUG_ON(__kfifo_len(tcp_ctask->r2tqueue));
1271 tcp_ctask->xmstate = XMSTATE_CMD_HDR_INIT;
1272 }
1273
1274 /**
1275 * iscsi_tcp_mtask_xmit - xmit management(immediate) task
1276 * @conn: iscsi connection
1277 * @mtask: task management task
1278 *
1279 * Notes:
1280 * The function can return -EAGAIN in which case caller must
1281 * call it again later, or recover. '0' return code means successful
1282 * xmit.
1283 *
1284 * Management xmit state machine consists of these states:
1285 * XMSTATE_IMM_HDR_INIT - calculate digest of PDU Header
1286 * XMSTATE_IMM_HDR - PDU Header xmit in progress
1287 * XMSTATE_IMM_DATA - PDU Data xmit in progress
1288 * XMSTATE_IDLE - management PDU is done
1289 **/
1290 static int
1291 iscsi_tcp_mtask_xmit(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
1292 {
1293 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
1294 int rc;
1295
1296 debug_scsi("mtask deq [cid %d state %x itt 0x%x]\n",
1297 conn->id, tcp_mtask->xmstate, mtask->itt);
1298
1299 if (tcp_mtask->xmstate & XMSTATE_IMM_HDR_INIT) {
1300 iscsi_buf_init_iov(&tcp_mtask->headbuf, (char*)mtask->hdr,
1301 sizeof(struct iscsi_hdr));
1302
1303 if (mtask->data_count) {
1304 tcp_mtask->xmstate |= XMSTATE_IMM_DATA;
1305 iscsi_buf_init_iov(&tcp_mtask->sendbuf,
1306 (char*)mtask->data,
1307 mtask->data_count);
1308 }
1309
1310 if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE &&
1311 conn->stop_stage != STOP_CONN_RECOVER &&
1312 conn->hdrdgst_en)
1313 iscsi_hdr_digest(conn, &tcp_mtask->headbuf,
1314 (u8*)tcp_mtask->hdrext);
1315
1316 tcp_mtask->sent = 0;
1317 tcp_mtask->xmstate &= ~XMSTATE_IMM_HDR_INIT;
1318 tcp_mtask->xmstate |= XMSTATE_IMM_HDR;
1319 }
1320
1321 if (tcp_mtask->xmstate & XMSTATE_IMM_HDR) {
1322 rc = iscsi_sendhdr(conn, &tcp_mtask->headbuf,
1323 mtask->data_count);
1324 if (rc)
1325 return rc;
1326 tcp_mtask->xmstate &= ~XMSTATE_IMM_HDR;
1327 }
1328
1329 if (tcp_mtask->xmstate & XMSTATE_IMM_DATA) {
1330 BUG_ON(!mtask->data_count);
1331 tcp_mtask->xmstate &= ~XMSTATE_IMM_DATA;
1332 /* FIXME: implement.
1333 * Virtual buffer could be spreaded across multiple pages...
1334 */
1335 do {
1336 int rc;
1337
1338 rc = iscsi_sendpage(conn, &tcp_mtask->sendbuf,
1339 &mtask->data_count, &tcp_mtask->sent);
1340 if (rc) {
1341 tcp_mtask->xmstate |= XMSTATE_IMM_DATA;
1342 return rc;
1343 }
1344 } while (mtask->data_count);
1345 }
1346
1347 BUG_ON(tcp_mtask->xmstate != XMSTATE_IDLE);
1348 if (mtask->hdr->itt == RESERVED_ITT) {
1349 struct iscsi_session *session = conn->session;
1350
1351 spin_lock_bh(&session->lock);
1352 iscsi_free_mgmt_task(conn, mtask);
1353 spin_unlock_bh(&session->lock);
1354 }
1355 return 0;
1356 }
1357
1358 static int
1359 iscsi_send_cmd_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1360 {
1361 struct scsi_cmnd *sc = ctask->sc;
1362 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1363 int rc = 0;
1364
1365 if (tcp_ctask->xmstate & XMSTATE_CMD_HDR_INIT) {
1366 tcp_ctask->sent = 0;
1367 tcp_ctask->sg_count = 0;
1368 tcp_ctask->exp_datasn = 0;
1369
1370 if (sc->sc_data_direction == DMA_TO_DEVICE) {
1371 struct scatterlist *sg = scsi_sglist(sc);
1372
1373 iscsi_buf_init_sg(&tcp_ctask->sendbuf, sg);
1374 tcp_ctask->sg = sg + 1;
1375 tcp_ctask->bad_sg = sg + scsi_sg_count(sc);
1376
1377 debug_scsi("cmd [itt 0x%x total %d imm_data %d "
1378 "unsol count %d, unsol offset %d]\n",
1379 ctask->itt, scsi_bufflen(sc),
1380 ctask->imm_count, ctask->unsol_count,
1381 ctask->unsol_offset);
1382 }
1383
1384 iscsi_buf_init_iov(&tcp_ctask->headbuf, (char*)ctask->hdr,
1385 ctask->hdr_len);
1386
1387 if (conn->hdrdgst_en)
1388 iscsi_hdr_digest(conn, &tcp_ctask->headbuf,
1389 iscsi_next_hdr(ctask));
1390 tcp_ctask->xmstate &= ~XMSTATE_CMD_HDR_INIT;
1391 tcp_ctask->xmstate |= XMSTATE_CMD_HDR_XMIT;
1392 }
1393
1394 if (tcp_ctask->xmstate & XMSTATE_CMD_HDR_XMIT) {
1395 rc = iscsi_sendhdr(conn, &tcp_ctask->headbuf, ctask->imm_count);
1396 if (rc)
1397 return rc;
1398 tcp_ctask->xmstate &= ~XMSTATE_CMD_HDR_XMIT;
1399
1400 if (sc->sc_data_direction != DMA_TO_DEVICE)
1401 return 0;
1402
1403 if (ctask->imm_count) {
1404 tcp_ctask->xmstate |= XMSTATE_IMM_DATA;
1405 iscsi_set_padding(tcp_ctask, ctask->imm_count);
1406
1407 if (ctask->conn->datadgst_en) {
1408 iscsi_data_digest_init(ctask->conn->dd_data,
1409 tcp_ctask);
1410 tcp_ctask->immdigest = 0;
1411 }
1412 }
1413
1414 if (ctask->unsol_count)
1415 tcp_ctask->xmstate |=
1416 XMSTATE_UNS_HDR | XMSTATE_UNS_INIT;
1417 }
1418 return rc;
1419 }
1420
1421 static int
1422 iscsi_send_padding(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1423 {
1424 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1425 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1426 int sent = 0, rc;
1427
1428 if (tcp_ctask->xmstate & XMSTATE_W_PAD) {
1429 iscsi_buf_init_iov(&tcp_ctask->sendbuf, (char*)&tcp_ctask->pad,
1430 tcp_ctask->pad_count);
1431 if (conn->datadgst_en)
1432 crypto_hash_update(&tcp_conn->tx_hash,
1433 &tcp_ctask->sendbuf.sg,
1434 tcp_ctask->sendbuf.sg.length);
1435 } else if (!(tcp_ctask->xmstate & XMSTATE_W_RESEND_PAD))
1436 return 0;
1437
1438 tcp_ctask->xmstate &= ~XMSTATE_W_PAD;
1439 tcp_ctask->xmstate &= ~XMSTATE_W_RESEND_PAD;
1440 debug_scsi("sending %d pad bytes for itt 0x%x\n",
1441 tcp_ctask->pad_count, ctask->itt);
1442 rc = iscsi_sendpage(conn, &tcp_ctask->sendbuf, &tcp_ctask->pad_count,
1443 &sent);
1444 if (rc) {
1445 debug_scsi("padding send failed %d\n", rc);
1446 tcp_ctask->xmstate |= XMSTATE_W_RESEND_PAD;
1447 }
1448 return rc;
1449 }
1450
1451 static int
1452 iscsi_send_digest(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
1453 struct iscsi_buf *buf, uint32_t *digest)
1454 {
1455 struct iscsi_tcp_cmd_task *tcp_ctask;
1456 struct iscsi_tcp_conn *tcp_conn;
1457 int rc, sent = 0;
1458
1459 if (!conn->datadgst_en)
1460 return 0;
1461
1462 tcp_ctask = ctask->dd_data;
1463 tcp_conn = conn->dd_data;
1464
1465 if (!(tcp_ctask->xmstate & XMSTATE_W_RESEND_DATA_DIGEST)) {
1466 crypto_hash_final(&tcp_conn->tx_hash, (u8*)digest);
1467 iscsi_buf_init_iov(buf, (char*)digest, 4);
1468 }
1469 tcp_ctask->xmstate &= ~XMSTATE_W_RESEND_DATA_DIGEST;
1470
1471 rc = iscsi_sendpage(conn, buf, &tcp_ctask->digest_count, &sent);
1472 if (!rc)
1473 debug_scsi("sent digest 0x%x for itt 0x%x\n", *digest,
1474 ctask->itt);
1475 else {
1476 debug_scsi("sending digest 0x%x failed for itt 0x%x!\n",
1477 *digest, ctask->itt);
1478 tcp_ctask->xmstate |= XMSTATE_W_RESEND_DATA_DIGEST;
1479 }
1480 return rc;
1481 }
1482
1483 static int
1484 iscsi_send_data(struct iscsi_cmd_task *ctask, struct iscsi_buf *sendbuf,
1485 struct scatterlist **sg, int *sent, int *count,
1486 struct iscsi_buf *digestbuf, uint32_t *digest)
1487 {
1488 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1489 struct iscsi_conn *conn = ctask->conn;
1490 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1491 int rc, buf_sent, offset;
1492
1493 while (*count) {
1494 buf_sent = 0;
1495 offset = sendbuf->sent;
1496
1497 rc = iscsi_sendpage(conn, sendbuf, count, &buf_sent);
1498 *sent = *sent + buf_sent;
1499 if (buf_sent && conn->datadgst_en)
1500 partial_sg_digest_update(&tcp_conn->tx_hash,
1501 &sendbuf->sg, sendbuf->sg.offset + offset,
1502 buf_sent);
1503 if (!iscsi_buf_left(sendbuf) && *sg != tcp_ctask->bad_sg) {
1504 iscsi_buf_init_sg(sendbuf, *sg);
1505 *sg = *sg + 1;
1506 }
1507
1508 if (rc)
1509 return rc;
1510 }
1511
1512 rc = iscsi_send_padding(conn, ctask);
1513 if (rc)
1514 return rc;
1515
1516 return iscsi_send_digest(conn, ctask, digestbuf, digest);
1517 }
1518
1519 static int
1520 iscsi_send_unsol_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1521 {
1522 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1523 struct iscsi_data_task *dtask;
1524 int rc;
1525
1526 tcp_ctask->xmstate |= XMSTATE_UNS_DATA;
1527 if (tcp_ctask->xmstate & XMSTATE_UNS_INIT) {
1528 dtask = &tcp_ctask->unsol_dtask;
1529
1530 iscsi_prep_unsolicit_data_pdu(ctask, &dtask->hdr);
1531 iscsi_buf_init_iov(&tcp_ctask->headbuf, (char*)&dtask->hdr,
1532 sizeof(struct iscsi_hdr));
1533 if (conn->hdrdgst_en)
1534 iscsi_hdr_digest(conn, &tcp_ctask->headbuf,
1535 (u8*)dtask->hdrext);
1536
1537 tcp_ctask->xmstate &= ~XMSTATE_UNS_INIT;
1538 iscsi_set_padding(tcp_ctask, ctask->data_count);
1539 }
1540
1541 rc = iscsi_sendhdr(conn, &tcp_ctask->headbuf, ctask->data_count);
1542 if (rc) {
1543 tcp_ctask->xmstate &= ~XMSTATE_UNS_DATA;
1544 tcp_ctask->xmstate |= XMSTATE_UNS_HDR;
1545 return rc;
1546 }
1547
1548 if (conn->datadgst_en) {
1549 dtask = &tcp_ctask->unsol_dtask;
1550 iscsi_data_digest_init(ctask->conn->dd_data, tcp_ctask);
1551 dtask->digest = 0;
1552 }
1553
1554 debug_scsi("uns dout [itt 0x%x dlen %d sent %d]\n",
1555 ctask->itt, ctask->unsol_count, tcp_ctask->sent);
1556 return 0;
1557 }
1558
1559 static int
1560 iscsi_send_unsol_pdu(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1561 {
1562 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1563 int rc;
1564
1565 if (tcp_ctask->xmstate & XMSTATE_UNS_HDR) {
1566 BUG_ON(!ctask->unsol_count);
1567 tcp_ctask->xmstate &= ~XMSTATE_UNS_HDR;
1568 send_hdr:
1569 rc = iscsi_send_unsol_hdr(conn, ctask);
1570 if (rc)
1571 return rc;
1572 }
1573
1574 if (tcp_ctask->xmstate & XMSTATE_UNS_DATA) {
1575 struct iscsi_data_task *dtask = &tcp_ctask->unsol_dtask;
1576 int start = tcp_ctask->sent;
1577
1578 rc = iscsi_send_data(ctask, &tcp_ctask->sendbuf, &tcp_ctask->sg,
1579 &tcp_ctask->sent, &ctask->data_count,
1580 &dtask->digestbuf, &dtask->digest);
1581 ctask->unsol_count -= tcp_ctask->sent - start;
1582 if (rc)
1583 return rc;
1584 tcp_ctask->xmstate &= ~XMSTATE_UNS_DATA;
1585 /*
1586 * Done with the Data-Out. Next, check if we need
1587 * to send another unsolicited Data-Out.
1588 */
1589 if (ctask->unsol_count) {
1590 debug_scsi("sending more uns\n");
1591 tcp_ctask->xmstate |= XMSTATE_UNS_INIT;
1592 goto send_hdr;
1593 }
1594 }
1595 return 0;
1596 }
1597
1598 static int iscsi_send_sol_pdu(struct iscsi_conn *conn,
1599 struct iscsi_cmd_task *ctask)
1600 {
1601 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1602 struct iscsi_session *session = conn->session;
1603 struct iscsi_r2t_info *r2t;
1604 struct iscsi_data_task *dtask;
1605 int left, rc;
1606
1607 if (tcp_ctask->xmstate & XMSTATE_SOL_HDR_INIT) {
1608 if (!tcp_ctask->r2t) {
1609 spin_lock_bh(&session->lock);
1610 __kfifo_get(tcp_ctask->r2tqueue, (void*)&tcp_ctask->r2t,
1611 sizeof(void*));
1612 spin_unlock_bh(&session->lock);
1613 }
1614 send_hdr:
1615 r2t = tcp_ctask->r2t;
1616 dtask = &r2t->dtask;
1617
1618 if (conn->hdrdgst_en)
1619 iscsi_hdr_digest(conn, &r2t->headbuf,
1620 (u8*)dtask->hdrext);
1621 tcp_ctask->xmstate &= ~XMSTATE_SOL_HDR_INIT;
1622 tcp_ctask->xmstate |= XMSTATE_SOL_HDR;
1623 }
1624
1625 if (tcp_ctask->xmstate & XMSTATE_SOL_HDR) {
1626 r2t = tcp_ctask->r2t;
1627 dtask = &r2t->dtask;
1628
1629 rc = iscsi_sendhdr(conn, &r2t->headbuf, r2t->data_count);
1630 if (rc)
1631 return rc;
1632 tcp_ctask->xmstate &= ~XMSTATE_SOL_HDR;
1633 tcp_ctask->xmstate |= XMSTATE_SOL_DATA;
1634
1635 if (conn->datadgst_en) {
1636 iscsi_data_digest_init(conn->dd_data, tcp_ctask);
1637 dtask->digest = 0;
1638 }
1639
1640 iscsi_set_padding(tcp_ctask, r2t->data_count);
1641 debug_scsi("sol dout [dsn %d itt 0x%x dlen %d sent %d]\n",
1642 r2t->solicit_datasn - 1, ctask->itt, r2t->data_count,
1643 r2t->sent);
1644 }
1645
1646 if (tcp_ctask->xmstate & XMSTATE_SOL_DATA) {
1647 r2t = tcp_ctask->r2t;
1648 dtask = &r2t->dtask;
1649
1650 rc = iscsi_send_data(ctask, &r2t->sendbuf, &r2t->sg,
1651 &r2t->sent, &r2t->data_count,
1652 &dtask->digestbuf, &dtask->digest);
1653 if (rc)
1654 return rc;
1655 tcp_ctask->xmstate &= ~XMSTATE_SOL_DATA;
1656
1657 /*
1658 * Done with this Data-Out. Next, check if we have
1659 * to send another Data-Out for this R2T.
1660 */
1661 BUG_ON(r2t->data_length - r2t->sent < 0);
1662 left = r2t->data_length - r2t->sent;
1663 if (left) {
1664 iscsi_solicit_data_cont(conn, ctask, r2t, left);
1665 goto send_hdr;
1666 }
1667
1668 /*
1669 * Done with this R2T. Check if there are more
1670 * outstanding R2Ts ready to be processed.
1671 */
1672 spin_lock_bh(&session->lock);
1673 tcp_ctask->r2t = NULL;
1674 __kfifo_put(tcp_ctask->r2tpool.queue, (void*)&r2t,
1675 sizeof(void*));
1676 if (__kfifo_get(tcp_ctask->r2tqueue, (void*)&r2t,
1677 sizeof(void*))) {
1678 tcp_ctask->r2t = r2t;
1679 spin_unlock_bh(&session->lock);
1680 goto send_hdr;
1681 }
1682 spin_unlock_bh(&session->lock);
1683 }
1684 return 0;
1685 }
1686
1687 /**
1688 * iscsi_tcp_ctask_xmit - xmit normal PDU task
1689 * @conn: iscsi connection
1690 * @ctask: iscsi command task
1691 *
1692 * Notes:
1693 * The function can return -EAGAIN in which case caller must
1694 * call it again later, or recover. '0' return code means successful
1695 * xmit.
1696 * The function is devided to logical helpers (above) for the different
1697 * xmit stages.
1698 *
1699 *iscsi_send_cmd_hdr()
1700 * XMSTATE_CMD_HDR_INIT - prepare Header and Data buffers Calculate
1701 * Header Digest
1702 * XMSTATE_CMD_HDR_XMIT - Transmit header in progress
1703 *
1704 *iscsi_send_padding
1705 * XMSTATE_W_PAD - Prepare and send pading
1706 * XMSTATE_W_RESEND_PAD - retry send pading
1707 *
1708 *iscsi_send_digest
1709 * XMSTATE_W_RESEND_DATA_DIGEST - Finalize and send Data Digest
1710 * XMSTATE_W_RESEND_DATA_DIGEST - retry sending digest
1711 *
1712 *iscsi_send_unsol_hdr
1713 * XMSTATE_UNS_INIT - prepare un-solicit data header and digest
1714 * XMSTATE_UNS_HDR - send un-solicit header
1715 *
1716 *iscsi_send_unsol_pdu
1717 * XMSTATE_UNS_DATA - send un-solicit data in progress
1718 *
1719 *iscsi_send_sol_pdu
1720 * XMSTATE_SOL_HDR_INIT - solicit data header and digest initialize
1721 * XMSTATE_SOL_HDR - send solicit header
1722 * XMSTATE_SOL_DATA - send solicit data
1723 *
1724 *iscsi_tcp_ctask_xmit
1725 * XMSTATE_IMM_DATA - xmit managment data (??)
1726 **/
1727 static int
1728 iscsi_tcp_ctask_xmit(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1729 {
1730 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1731 int rc = 0;
1732
1733 debug_scsi("ctask deq [cid %d xmstate %x itt 0x%x]\n",
1734 conn->id, tcp_ctask->xmstate, ctask->itt);
1735
1736 rc = iscsi_send_cmd_hdr(conn, ctask);
1737 if (rc)
1738 return rc;
1739 if (ctask->sc->sc_data_direction != DMA_TO_DEVICE)
1740 return 0;
1741
1742 if (tcp_ctask->xmstate & XMSTATE_IMM_DATA) {
1743 rc = iscsi_send_data(ctask, &tcp_ctask->sendbuf, &tcp_ctask->sg,
1744 &tcp_ctask->sent, &ctask->imm_count,
1745 &tcp_ctask->immbuf, &tcp_ctask->immdigest);
1746 if (rc)
1747 return rc;
1748 tcp_ctask->xmstate &= ~XMSTATE_IMM_DATA;
1749 }
1750
1751 rc = iscsi_send_unsol_pdu(conn, ctask);
1752 if (rc)
1753 return rc;
1754
1755 rc = iscsi_send_sol_pdu(conn, ctask);
1756 if (rc)
1757 return rc;
1758
1759 return rc;
1760 }
1761
1762 static struct iscsi_cls_conn *
1763 iscsi_tcp_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx)
1764 {
1765 struct iscsi_conn *conn;
1766 struct iscsi_cls_conn *cls_conn;
1767 struct iscsi_tcp_conn *tcp_conn;
1768
1769 cls_conn = iscsi_conn_setup(cls_session, conn_idx);
1770 if (!cls_conn)
1771 return NULL;
1772 conn = cls_conn->dd_data;
1773 /*
1774 * due to strange issues with iser these are not set
1775 * in iscsi_conn_setup
1776 */
1777 conn->max_recv_dlength = ISCSI_DEF_MAX_RECV_SEG_LEN;
1778
1779 tcp_conn = kzalloc(sizeof(*tcp_conn), GFP_KERNEL);
1780 if (!tcp_conn)
1781 goto tcp_conn_alloc_fail;
1782
1783 conn->dd_data = tcp_conn;
1784 tcp_conn->iscsi_conn = conn;
1785
1786 tcp_conn->tx_hash.tfm = crypto_alloc_hash("crc32c", 0,
1787 CRYPTO_ALG_ASYNC);
1788 tcp_conn->tx_hash.flags = 0;
1789 if (IS_ERR(tcp_conn->tx_hash.tfm)) {
1790 printk(KERN_ERR "Could not create connection due to crc32c "
1791 "loading error %ld. Make sure the crc32c module is "
1792 "built as a module or into the kernel\n",
1793 PTR_ERR(tcp_conn->tx_hash.tfm));
1794 goto free_tcp_conn;
1795 }
1796
1797 tcp_conn->rx_hash.tfm = crypto_alloc_hash("crc32c", 0,
1798 CRYPTO_ALG_ASYNC);
1799 tcp_conn->rx_hash.flags = 0;
1800 if (IS_ERR(tcp_conn->rx_hash.tfm)) {
1801 printk(KERN_ERR "Could not create connection due to crc32c "
1802 "loading error %ld. Make sure the crc32c module is "
1803 "built as a module or into the kernel\n",
1804 PTR_ERR(tcp_conn->rx_hash.tfm));
1805 goto free_tx_tfm;
1806 }
1807
1808 return cls_conn;
1809
1810 free_tx_tfm:
1811 crypto_free_hash(tcp_conn->tx_hash.tfm);
1812 free_tcp_conn:
1813 kfree(tcp_conn);
1814 tcp_conn_alloc_fail:
1815 iscsi_conn_teardown(cls_conn);
1816 return NULL;
1817 }
1818
1819 static void
1820 iscsi_tcp_release_conn(struct iscsi_conn *conn)
1821 {
1822 struct iscsi_session *session = conn->session;
1823 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1824 struct socket *sock = tcp_conn->sock;
1825
1826 if (!sock)
1827 return;
1828
1829 sock_hold(sock->sk);
1830 iscsi_conn_restore_callbacks(tcp_conn);
1831 sock_put(sock->sk);
1832
1833 spin_lock_bh(&session->lock);
1834 tcp_conn->sock = NULL;
1835 conn->recv_lock = NULL;
1836 spin_unlock_bh(&session->lock);
1837 sockfd_put(sock);
1838 }
1839
1840 static void
1841 iscsi_tcp_conn_destroy(struct iscsi_cls_conn *cls_conn)
1842 {
1843 struct iscsi_conn *conn = cls_conn->dd_data;
1844 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1845
1846 iscsi_tcp_release_conn(conn);
1847 iscsi_conn_teardown(cls_conn);
1848
1849 if (tcp_conn->tx_hash.tfm)
1850 crypto_free_hash(tcp_conn->tx_hash.tfm);
1851 if (tcp_conn->rx_hash.tfm)
1852 crypto_free_hash(tcp_conn->rx_hash.tfm);
1853
1854 kfree(tcp_conn);
1855 }
1856
1857 static void
1858 iscsi_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
1859 {
1860 struct iscsi_conn *conn = cls_conn->dd_data;
1861
1862 iscsi_conn_stop(cls_conn, flag);
1863 iscsi_tcp_release_conn(conn);
1864 }
1865
1866 static int iscsi_tcp_get_addr(struct iscsi_conn *conn, struct socket *sock,
1867 char *buf, int *port,
1868 int (*getname)(struct socket *, struct sockaddr *,
1869 int *addrlen))
1870 {
1871 struct sockaddr_storage *addr;
1872 struct sockaddr_in6 *sin6;
1873 struct sockaddr_in *sin;
1874 int rc = 0, len;
1875
1876 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
1877 if (!addr)
1878 return -ENOMEM;
1879
1880 if (getname(sock, (struct sockaddr *) addr, &len)) {
1881 rc = -ENODEV;
1882 goto free_addr;
1883 }
1884
1885 switch (addr->ss_family) {
1886 case AF_INET:
1887 sin = (struct sockaddr_in *)addr;
1888 spin_lock_bh(&conn->session->lock);
1889 sprintf(buf, NIPQUAD_FMT, NIPQUAD(sin->sin_addr.s_addr));
1890 *port = be16_to_cpu(sin->sin_port);
1891 spin_unlock_bh(&conn->session->lock);
1892 break;
1893 case AF_INET6:
1894 sin6 = (struct sockaddr_in6 *)addr;
1895 spin_lock_bh(&conn->session->lock);
1896 sprintf(buf, NIP6_FMT, NIP6(sin6->sin6_addr));
1897 *port = be16_to_cpu(sin6->sin6_port);
1898 spin_unlock_bh(&conn->session->lock);
1899 break;
1900 }
1901 free_addr:
1902 kfree(addr);
1903 return rc;
1904 }
1905
1906 static int
1907 iscsi_tcp_conn_bind(struct iscsi_cls_session *cls_session,
1908 struct iscsi_cls_conn *cls_conn, uint64_t transport_eph,
1909 int is_leading)
1910 {
1911 struct iscsi_conn *conn = cls_conn->dd_data;
1912 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1913 struct sock *sk;
1914 struct socket *sock;
1915 int err;
1916
1917 /* lookup for existing socket */
1918 sock = sockfd_lookup((int)transport_eph, &err);
1919 if (!sock) {
1920 printk(KERN_ERR "iscsi_tcp: sockfd_lookup failed %d\n", err);
1921 return -EEXIST;
1922 }
1923 /*
1924 * copy these values now because if we drop the session
1925 * userspace may still want to query the values since we will
1926 * be using them for the reconnect
1927 */
1928 err = iscsi_tcp_get_addr(conn, sock, conn->portal_address,
1929 &conn->portal_port, kernel_getpeername);
1930 if (err)
1931 goto free_socket;
1932
1933 err = iscsi_tcp_get_addr(conn, sock, conn->local_address,
1934 &conn->local_port, kernel_getsockname);
1935 if (err)
1936 goto free_socket;
1937
1938 err = iscsi_conn_bind(cls_session, cls_conn, is_leading);
1939 if (err)
1940 goto free_socket;
1941
1942 /* bind iSCSI connection and socket */
1943 tcp_conn->sock = sock;
1944
1945 /* setup Socket parameters */
1946 sk = sock->sk;
1947 sk->sk_reuse = 1;
1948 sk->sk_sndtimeo = 15 * HZ; /* FIXME: make it configurable */
1949 sk->sk_allocation = GFP_ATOMIC;
1950
1951 /* FIXME: disable Nagle's algorithm */
1952
1953 /*
1954 * Intercept TCP callbacks for sendfile like receive
1955 * processing.
1956 */
1957 conn->recv_lock = &sk->sk_callback_lock;
1958 iscsi_conn_set_callbacks(conn);
1959 tcp_conn->sendpage = tcp_conn->sock->ops->sendpage;
1960 /*
1961 * set receive state machine into initial state
1962 */
1963 iscsi_tcp_hdr_recv_prep(tcp_conn);
1964 return 0;
1965
1966 free_socket:
1967 sockfd_put(sock);
1968 return err;
1969 }
1970
1971 /* called with host lock */
1972 static void
1973 iscsi_tcp_mgmt_init(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
1974 {
1975 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
1976 tcp_mtask->xmstate = XMSTATE_IMM_HDR_INIT;
1977 }
1978
1979 static int
1980 iscsi_r2tpool_alloc(struct iscsi_session *session)
1981 {
1982 int i;
1983 int cmd_i;
1984
1985 /*
1986 * initialize per-task: R2T pool and xmit queue
1987 */
1988 for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
1989 struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
1990 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1991
1992 /*
1993 * pre-allocated x4 as much r2ts to handle race when
1994 * target acks DataOut faster than we data_xmit() queues
1995 * could replenish r2tqueue.
1996 */
1997
1998 /* R2T pool */
1999 if (iscsi_pool_init(&tcp_ctask->r2tpool, session->max_r2t * 4, NULL,
2000 sizeof(struct iscsi_r2t_info))) {
2001 goto r2t_alloc_fail;
2002 }
2003
2004 /* R2T xmit queue */
2005 tcp_ctask->r2tqueue = kfifo_alloc(
2006 session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
2007 if (tcp_ctask->r2tqueue == ERR_PTR(-ENOMEM)) {
2008 iscsi_pool_free(&tcp_ctask->r2tpool);
2009 goto r2t_alloc_fail;
2010 }
2011 }
2012
2013 return 0;
2014
2015 r2t_alloc_fail:
2016 for (i = 0; i < cmd_i; i++) {
2017 struct iscsi_cmd_task *ctask = session->cmds[i];
2018 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2019
2020 kfifo_free(tcp_ctask->r2tqueue);
2021 iscsi_pool_free(&tcp_ctask->r2tpool);
2022 }
2023 return -ENOMEM;
2024 }
2025
2026 static void
2027 iscsi_r2tpool_free(struct iscsi_session *session)
2028 {
2029 int i;
2030
2031 for (i = 0; i < session->cmds_max; i++) {
2032 struct iscsi_cmd_task *ctask = session->cmds[i];
2033 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2034
2035 kfifo_free(tcp_ctask->r2tqueue);
2036 iscsi_pool_free(&tcp_ctask->r2tpool);
2037 }
2038 }
2039
2040 static int
2041 iscsi_conn_set_param(struct iscsi_cls_conn *cls_conn, enum iscsi_param param,
2042 char *buf, int buflen)
2043 {
2044 struct iscsi_conn *conn = cls_conn->dd_data;
2045 struct iscsi_session *session = conn->session;
2046 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
2047 int value;
2048
2049 switch(param) {
2050 case ISCSI_PARAM_HDRDGST_EN:
2051 iscsi_set_param(cls_conn, param, buf, buflen);
2052 break;
2053 case ISCSI_PARAM_DATADGST_EN:
2054 iscsi_set_param(cls_conn, param, buf, buflen);
2055 tcp_conn->sendpage = conn->datadgst_en ?
2056 sock_no_sendpage : tcp_conn->sock->ops->sendpage;
2057 break;
2058 case ISCSI_PARAM_MAX_R2T:
2059 sscanf(buf, "%d", &value);
2060 if (session->max_r2t == roundup_pow_of_two(value))
2061 break;
2062 iscsi_r2tpool_free(session);
2063 iscsi_set_param(cls_conn, param, buf, buflen);
2064 if (session->max_r2t & (session->max_r2t - 1))
2065 session->max_r2t = roundup_pow_of_two(session->max_r2t);
2066 if (iscsi_r2tpool_alloc(session))
2067 return -ENOMEM;
2068 break;
2069 default:
2070 return iscsi_set_param(cls_conn, param, buf, buflen);
2071 }
2072
2073 return 0;
2074 }
2075
2076 static int
2077 iscsi_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
2078 enum iscsi_param param, char *buf)
2079 {
2080 struct iscsi_conn *conn = cls_conn->dd_data;
2081 int len;
2082
2083 switch(param) {
2084 case ISCSI_PARAM_CONN_PORT:
2085 spin_lock_bh(&conn->session->lock);
2086 len = sprintf(buf, "%hu\n", conn->portal_port);
2087 spin_unlock_bh(&conn->session->lock);
2088 break;
2089 case ISCSI_PARAM_CONN_ADDRESS:
2090 spin_lock_bh(&conn->session->lock);
2091 len = sprintf(buf, "%s\n", conn->portal_address);
2092 spin_unlock_bh(&conn->session->lock);
2093 break;
2094 default:
2095 return iscsi_conn_get_param(cls_conn, param, buf);
2096 }
2097
2098 return len;
2099 }
2100
2101 static int
2102 iscsi_tcp_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
2103 char *buf)
2104 {
2105 struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
2106 int len;
2107
2108 switch (param) {
2109 case ISCSI_HOST_PARAM_IPADDRESS:
2110 spin_lock_bh(&session->lock);
2111 if (!session->leadconn)
2112 len = -ENODEV;
2113 else
2114 len = sprintf(buf, "%s\n",
2115 session->leadconn->local_address);
2116 spin_unlock_bh(&session->lock);
2117 break;
2118 default:
2119 return iscsi_host_get_param(shost, param, buf);
2120 }
2121 return len;
2122 }
2123
2124 static void
2125 iscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn, struct iscsi_stats *stats)
2126 {
2127 struct iscsi_conn *conn = cls_conn->dd_data;
2128 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
2129
2130 stats->txdata_octets = conn->txdata_octets;
2131 stats->rxdata_octets = conn->rxdata_octets;
2132 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
2133 stats->dataout_pdus = conn->dataout_pdus_cnt;
2134 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
2135 stats->datain_pdus = conn->datain_pdus_cnt;
2136 stats->r2t_pdus = conn->r2t_pdus_cnt;
2137 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
2138 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
2139 stats->custom_length = 3;
2140 strcpy(stats->custom[0].desc, "tx_sendpage_failures");
2141 stats->custom[0].value = tcp_conn->sendpage_failures_cnt;
2142 strcpy(stats->custom[1].desc, "rx_discontiguous_hdr");
2143 stats->custom[1].value = tcp_conn->discontiguous_hdr_cnt;
2144 strcpy(stats->custom[2].desc, "eh_abort_cnt");
2145 stats->custom[2].value = conn->eh_abort_cnt;
2146 }
2147
2148 static struct iscsi_cls_session *
2149 iscsi_tcp_session_create(struct iscsi_transport *iscsit,
2150 struct scsi_transport_template *scsit,
2151 uint16_t cmds_max, uint16_t qdepth,
2152 uint32_t initial_cmdsn, uint32_t *hostno)
2153 {
2154 struct iscsi_cls_session *cls_session;
2155 struct iscsi_session *session;
2156 uint32_t hn;
2157 int cmd_i;
2158
2159 cls_session = iscsi_session_setup(iscsit, scsit, cmds_max, qdepth,
2160 sizeof(struct iscsi_tcp_cmd_task),
2161 sizeof(struct iscsi_tcp_mgmt_task),
2162 initial_cmdsn, &hn);
2163 if (!cls_session)
2164 return NULL;
2165 *hostno = hn;
2166
2167 session = class_to_transport_session(cls_session);
2168 for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
2169 struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
2170 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2171
2172 ctask->hdr = &tcp_ctask->hdr.cmd_hdr;
2173 ctask->hdr_max = sizeof(tcp_ctask->hdr) - ISCSI_DIGEST_SIZE;
2174 }
2175
2176 for (cmd_i = 0; cmd_i < session->mgmtpool_max; cmd_i++) {
2177 struct iscsi_mgmt_task *mtask = session->mgmt_cmds[cmd_i];
2178 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
2179
2180 mtask->hdr = &tcp_mtask->hdr;
2181 }
2182
2183 if (iscsi_r2tpool_alloc(class_to_transport_session(cls_session)))
2184 goto r2tpool_alloc_fail;
2185
2186 return cls_session;
2187
2188 r2tpool_alloc_fail:
2189 iscsi_session_teardown(cls_session);
2190 return NULL;
2191 }
2192
2193 static void iscsi_tcp_session_destroy(struct iscsi_cls_session *cls_session)
2194 {
2195 iscsi_r2tpool_free(class_to_transport_session(cls_session));
2196 iscsi_session_teardown(cls_session);
2197 }
2198
2199 static int iscsi_tcp_slave_configure(struct scsi_device *sdev)
2200 {
2201 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_ANY);
2202 blk_queue_dma_alignment(sdev->request_queue, 0);
2203 return 0;
2204 }
2205
2206 static struct scsi_host_template iscsi_sht = {
2207 .module = THIS_MODULE,
2208 .name = "iSCSI Initiator over TCP/IP",
2209 .queuecommand = iscsi_queuecommand,
2210 .change_queue_depth = iscsi_change_queue_depth,
2211 .can_queue = ISCSI_DEF_XMIT_CMDS_MAX - 1,
2212 .sg_tablesize = ISCSI_SG_TABLESIZE,
2213 .max_sectors = 0xFFFF,
2214 .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN,
2215 .eh_abort_handler = iscsi_eh_abort,
2216 .eh_device_reset_handler= iscsi_eh_device_reset,
2217 .eh_host_reset_handler = iscsi_eh_host_reset,
2218 .use_clustering = DISABLE_CLUSTERING,
2219 .slave_configure = iscsi_tcp_slave_configure,
2220 .proc_name = "iscsi_tcp",
2221 .this_id = -1,
2222 };
2223
2224 static struct iscsi_transport iscsi_tcp_transport = {
2225 .owner = THIS_MODULE,
2226 .name = "tcp",
2227 .caps = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST
2228 | CAP_DATADGST,
2229 .param_mask = ISCSI_MAX_RECV_DLENGTH |
2230 ISCSI_MAX_XMIT_DLENGTH |
2231 ISCSI_HDRDGST_EN |
2232 ISCSI_DATADGST_EN |
2233 ISCSI_INITIAL_R2T_EN |
2234 ISCSI_MAX_R2T |
2235 ISCSI_IMM_DATA_EN |
2236 ISCSI_FIRST_BURST |
2237 ISCSI_MAX_BURST |
2238 ISCSI_PDU_INORDER_EN |
2239 ISCSI_DATASEQ_INORDER_EN |
2240 ISCSI_ERL |
2241 ISCSI_CONN_PORT |
2242 ISCSI_CONN_ADDRESS |
2243 ISCSI_EXP_STATSN |
2244 ISCSI_PERSISTENT_PORT |
2245 ISCSI_PERSISTENT_ADDRESS |
2246 ISCSI_TARGET_NAME | ISCSI_TPGT |
2247 ISCSI_USERNAME | ISCSI_PASSWORD |
2248 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
2249 ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
2250 ISCSI_LU_RESET_TMO |
2251 ISCSI_PING_TMO | ISCSI_RECV_TMO,
2252 .host_param_mask = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
2253 ISCSI_HOST_INITIATOR_NAME |
2254 ISCSI_HOST_NETDEV_NAME,
2255 .host_template = &iscsi_sht,
2256 .conndata_size = sizeof(struct iscsi_conn),
2257 .max_conn = 1,
2258 .max_cmd_len = ISCSI_TCP_MAX_CMD_LEN,
2259 /* session management */
2260 .create_session = iscsi_tcp_session_create,
2261 .destroy_session = iscsi_tcp_session_destroy,
2262 /* connection management */
2263 .create_conn = iscsi_tcp_conn_create,
2264 .bind_conn = iscsi_tcp_conn_bind,
2265 .destroy_conn = iscsi_tcp_conn_destroy,
2266 .set_param = iscsi_conn_set_param,
2267 .get_conn_param = iscsi_tcp_conn_get_param,
2268 .get_session_param = iscsi_session_get_param,
2269 .start_conn = iscsi_conn_start,
2270 .stop_conn = iscsi_tcp_conn_stop,
2271 /* iscsi host params */
2272 .get_host_param = iscsi_tcp_host_get_param,
2273 .set_host_param = iscsi_host_set_param,
2274 /* IO */
2275 .send_pdu = iscsi_conn_send_pdu,
2276 .get_stats = iscsi_conn_get_stats,
2277 .init_cmd_task = iscsi_tcp_cmd_init,
2278 .init_mgmt_task = iscsi_tcp_mgmt_init,
2279 .xmit_cmd_task = iscsi_tcp_ctask_xmit,
2280 .xmit_mgmt_task = iscsi_tcp_mtask_xmit,
2281 .cleanup_cmd_task = iscsi_tcp_cleanup_ctask,
2282 /* recovery */
2283 .session_recovery_timedout = iscsi_session_recovery_timedout,
2284 };
2285
2286 static int __init
2287 iscsi_tcp_init(void)
2288 {
2289 if (iscsi_max_lun < 1) {
2290 printk(KERN_ERR "iscsi_tcp: Invalid max_lun value of %u\n",
2291 iscsi_max_lun);
2292 return -EINVAL;
2293 }
2294 iscsi_tcp_transport.max_lun = iscsi_max_lun;
2295
2296 if (!iscsi_register_transport(&iscsi_tcp_transport))
2297 return -ENODEV;
2298
2299 return 0;
2300 }
2301
2302 static void __exit
2303 iscsi_tcp_exit(void)
2304 {
2305 iscsi_unregister_transport(&iscsi_tcp_transport);
2306 }
2307
2308 module_init(iscsi_tcp_init);
2309 module_exit(iscsi_tcp_exit);
x86 "subsystem" repository