blob: 491845f187106c9b289f1b20d8fa459243f7ab0a [file] [log] [blame]
Alex Aizman7ba24712005-08-04 19:30:08 -07001/*
2 * iSCSI Initiator over TCP/IP Data-Path
3 *
4 * Copyright (C) 2004 Dmitry Yusupov
5 * Copyright (C) 2004 Alex Aizman
Mike Christie5bb0b552006-04-06 21:26:46 -05006 * Copyright (C) 2005 - 2006 Mike Christie
7 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
Alex Aizman7ba24712005-08-04 19:30:08 -07008 * 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>
Mike Christie4e7aba72007-05-30 12:57:23 -050032#include <linux/file.h>
Alex Aizman7ba24712005-08-04 19:30:08 -070033#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>
Mike Christied1d81c02007-05-30 12:57:21 -050040#include <scsi/scsi_device.h>
Alex Aizman7ba24712005-08-04 19:30:08 -070041#include <scsi/scsi_host.h>
42#include <scsi/scsi.h>
43#include <scsi/scsi_transport_iscsi.h>
44
45#include "iscsi_tcp.h"
46
47MODULE_AUTHOR("Dmitry Yusupov <dmitry_yus@yahoo.com>, "
48 "Alex Aizman <itn780@yahoo.com>");
49MODULE_DESCRIPTION("iSCSI/TCP data-path");
50MODULE_LICENSE("GPL");
Olaf Kirchda32dd62007-12-13 12:43:21 -060051#undef DEBUG_TCP
Alex Aizman7ba24712005-08-04 19:30:08 -070052#define DEBUG_ASSERT
53
54#ifdef DEBUG_TCP
Mike Christie5bb0b552006-04-06 21:26:46 -050055#define debug_tcp(fmt...) printk(KERN_INFO "tcp: " fmt)
Alex Aizman7ba24712005-08-04 19:30:08 -070056#else
57#define debug_tcp(fmt...)
58#endif
59
Alex Aizman7ba24712005-08-04 19:30:08 -070060#ifndef DEBUG_ASSERT
61#ifdef BUG_ON
62#undef BUG_ON
63#endif
64#define BUG_ON(expr)
65#endif
66
Alex Aizman7ba24712005-08-04 19:30:08 -070067static unsigned int iscsi_max_lun = 512;
68module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);
69
Olaf Kirchda32dd62007-12-13 12:43:21 -060070static int iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
71 struct iscsi_chunk *chunk);
72
Alex Aizman7ba24712005-08-04 19:30:08 -070073static inline void
Alex Aizman7ba24712005-08-04 19:30:08 -070074iscsi_buf_init_iov(struct iscsi_buf *ibuf, char *vbuf, int size)
75{
Olaf Kirchda32dd62007-12-13 12:43:21 -060076 ibuf->sg.page = virt_to_page(vbuf);
77 ibuf->sg.offset = offset_in_page(vbuf);
78 ibuf->sg.length = size;
Alex Aizman7ba24712005-08-04 19:30:08 -070079 ibuf->sent = 0;
Mike Christie7cae5152006-01-13 18:05:47 -060080 ibuf->use_sendmsg = 1;
Alex Aizman7ba24712005-08-04 19:30:08 -070081}
82
83static inline void
84iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg)
85{
Olaf Kirchda32dd62007-12-13 12:43:21 -060086 ibuf->sg.page = sg->page;
87 ibuf->sg.offset = sg->offset;
88 ibuf->sg.length = sg->length;
Alex Aizman7ba24712005-08-04 19:30:08 -070089 /*
90 * Fastpath: sg element fits into single page
91 */
Olaf Kirchda32dd62007-12-13 12:43:21 -060092 if (sg->length + sg->offset <= PAGE_SIZE && !PageSlab(sg->page))
Mike Christie7cae5152006-01-13 18:05:47 -060093 ibuf->use_sendmsg = 0;
94 else
95 ibuf->use_sendmsg = 1;
Alex Aizman7ba24712005-08-04 19:30:08 -070096 ibuf->sent = 0;
97}
98
99static inline int
100iscsi_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
109static inline void
Mike Christieaf973482005-09-12 21:01:32 -0500110iscsi_hdr_digest(struct iscsi_conn *conn, struct iscsi_buf *buf,
111 u8* crc)
Alex Aizman7ba24712005-08-04 19:30:08 -0700112{
Mike Christie5bb0b552006-04-06 21:26:46 -0500113 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
114
James Bottomleyc9802cd2006-09-23 15:33:43 -0500115 crypto_hash_digest(&tcp_conn->tx_hash, &buf->sg, buf->sg.length, crc);
Boaz Harrosh004d6532007-12-13 12:43:23 -0600116 buf->sg.length += ISCSI_DIGEST_SIZE;
Alex Aizman7ba24712005-08-04 19:30:08 -0700117}
118
Olaf Kirchda32dd62007-12-13 12:43:21 -0600119/*
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 */
142static inline void
143iscsi_tcp_chunk_init_sg(struct iscsi_chunk *chunk,
144 unsigned int idx, unsigned int offset)
Alex Aizman7ba24712005-08-04 19:30:08 -0700145{
Olaf Kirchda32dd62007-12-13 12:43:21 -0600146 struct scatterlist *sg;
Alex Aizman7ba24712005-08-04 19:30:08 -0700147
Olaf Kirchda32dd62007-12-13 12:43:21 -0600148 BUG_ON(chunk->sg == NULL);
Alex Aizman7ba24712005-08-04 19:30:08 -0700149
Olaf Kirchda32dd62007-12-13 12:43:21 -0600150 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}
Alex Aizman7ba24712005-08-04 19:30:08 -0700156
Olaf Kirchda32dd62007-12-13 12:43:21 -0600157/**
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 */
165static inline void
166iscsi_tcp_chunk_map(struct iscsi_chunk *chunk)
167{
168 struct scatterlist *sg;
Alex Aizman7ba24712005-08-04 19:30:08 -0700169
Olaf Kirchda32dd62007-12-13 12:43:21 -0600170 if (chunk->data != NULL || !chunk->sg)
171 return;
Alex Aizman7ba24712005-08-04 19:30:08 -0700172
Olaf Kirchda32dd62007-12-13 12:43:21 -0600173 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}
Alex Aizman7ba24712005-08-04 19:30:08 -0700179
Olaf Kirchda32dd62007-12-13 12:43:21 -0600180static inline void
181iscsi_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}
Alex Aizman7ba24712005-08-04 19:30:08 -0700189
Olaf Kirchda32dd62007-12-13 12:43:21 -0600190/*
191 * Splice the digest buffer into the buffer
192 */
193static inline void
194iscsi_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}
Alex Aizman7ba24712005-08-04 19:30:08 -0700205
Olaf Kirchda32dd62007-12-13 12:43:21 -0600206/**
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 */
219static inline int
220iscsi_tcp_chunk_done(struct iscsi_chunk *chunk)
221{
222 static unsigned char padbuf[ISCSI_PAD_LEN];
Boaz Harrosh004d6532007-12-13 12:43:23 -0600223 unsigned int pad;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600224
225 if (chunk->copied < chunk->size) {
226 iscsi_tcp_chunk_map(chunk);
227 return 0;
Alex Aizman7ba24712005-08-04 19:30:08 -0700228 }
229
Olaf Kirchda32dd62007-12-13 12:43:21 -0600230 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? */
Boaz Harrosh004d6532007-12-13 12:43:23 -0600247 pad = iscsi_padding(chunk->total_copied);
248 if (pad != 0) {
Olaf Kirchda32dd62007-12-13 12:43:21 -0600249 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 */
289static int
290iscsi_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
312out:
313 return copied;
314}
315
316static inline void
317iscsi_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
326static inline int
327iscsi_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 */
344static 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
358static inline void
359iscsi_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
367static inline int
368iscsi_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 */
397static void
398iscsi_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 */
410static int
411iscsi_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);
Alex Aizman7ba24712005-08-04 19:30:08 -0700426 return 0;
427}
428
Olaf Kirchda32dd62007-12-13 12:43:21 -0600429static void
430iscsi_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
Mike Christie30a6c652006-04-06 21:13:39 -0500443/*
444 * must be called with session lock
445 */
446static void
Mike Christieb6c395e2006-07-24 15:47:15 -0500447iscsi_tcp_cleanup_ctask(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -0700448{
Mike Christie5bb0b552006-04-06 21:26:46 -0500449 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Mike Christieb6c395e2006-07-24 15:47:15 -0500450 struct iscsi_r2t_info *r2t;
Mike Christie30a6c652006-04-06 21:13:39 -0500451 struct scsi_cmnd *sc;
Alex Aizman7ba24712005-08-04 19:30:08 -0700452
Mike Christieb6c395e2006-07-24 15:47:15 -0500453 /* 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
Mike Christie30a6c652006-04-06 21:13:39 -0500460 sc = ctask->sc;
461 if (unlikely(!sc))
Alex Aizman7ba24712005-08-04 19:30:08 -0700462 return;
Mike Christie30a6c652006-04-06 21:13:39 -0500463
Mike Christie843c0a82007-12-13 12:43:20 -0600464 tcp_ctask->xmstate = XMSTATE_IDLE;
Mike Christie5bb0b552006-04-06 21:26:46 -0500465 tcp_ctask->r2t = NULL;
Alex Aizman7ba24712005-08-04 19:30:08 -0700466}
467
468/**
469 * iscsi_data_rsp - SCSI Data-In Response processing
470 * @conn: iscsi connection
471 * @ctask: scsi command task
472 **/
473static int
474iscsi_data_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
475{
Mike Christie5bb0b552006-04-06 21:26:46 -0500476 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700479 struct iscsi_session *session = conn->session;
Mike Christie857ae0b2007-05-30 12:57:15 -0500480 struct scsi_cmnd *sc = ctask->sc;
Alex Aizman7ba24712005-08-04 19:30:08 -0700481 int datasn = be32_to_cpu(rhdr->datasn);
482
Mike Christie77a23c22007-05-30 12:57:18 -0500483 iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
Alex Aizman7ba24712005-08-04 19:30:08 -0700484 /*
485 * setup Data-In byte counter (gets decremented..)
486 */
Mike Christie5bb0b552006-04-06 21:26:46 -0500487 ctask->data_count = tcp_conn->in.datalen;
Alex Aizman7ba24712005-08-04 19:30:08 -0700488
Mike Christie5bb0b552006-04-06 21:26:46 -0500489 if (tcp_conn->in.datalen == 0)
Alex Aizman7ba24712005-08-04 19:30:08 -0700490 return 0;
491
Mike Christied473cc72007-05-30 12:57:14 -0500492 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);
Alex Aizman7ba24712005-08-04 19:30:08 -0700495 return ISCSI_ERR_DATASN;
Mike Christied473cc72007-05-30 12:57:14 -0500496 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700497
Mike Christied473cc72007-05-30 12:57:14 -0500498 tcp_ctask->exp_datasn++;
Alex Aizman7ba24712005-08-04 19:30:08 -0700499
Mike Christie5bb0b552006-04-06 21:26:46 -0500500 tcp_ctask->data_offset = be32_to_cpu(rhdr->offset);
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900501 if (tcp_ctask->data_offset + tcp_conn->in.datalen > scsi_bufflen(sc)) {
Mike Christie857ae0b2007-05-30 12:57:15 -0500502 debug_tcp("%s: data_offset(%d) + data_len(%d) > total_length_in(%d)\n",
503 __FUNCTION__, tcp_ctask->data_offset,
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900504 tcp_conn->in.datalen, scsi_bufflen(sc));
Alex Aizman7ba24712005-08-04 19:30:08 -0700505 return ISCSI_ERR_DATA_OFFSET;
Mike Christie857ae0b2007-05-30 12:57:15 -0500506 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700507
508 if (rhdr->flags & ISCSI_FLAG_DATA_STATUS) {
Boaz Harrosh7207fea2007-12-13 12:43:22 -0600509 sc->result = (DID_OK << 16) | rhdr->cmd_status;
Alex Aizman7ba24712005-08-04 19:30:08 -0700510 conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
Boaz Harrosh7207fea2007-12-13 12:43:22 -0600511 if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW |
512 ISCSI_FLAG_DATA_OVERFLOW)) {
Alex Aizman7ba24712005-08-04 19:30:08 -0700513 int res_count = be32_to_cpu(rhdr->residual_count);
514
515 if (res_count > 0 &&
Boaz Harrosh7207fea2007-12-13 12:43:22 -0600516 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
517 res_count <= scsi_bufflen(sc)))
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900518 scsi_set_resid(sc, res_count);
Boaz Harrosh7207fea2007-12-13 12:43:22 -0600519 else
Alex Aizman7ba24712005-08-04 19:30:08 -0700520 sc->result = (DID_BAD_TARGET << 16) |
521 rhdr->cmd_status;
Boaz Harrosh7207fea2007-12-13 12:43:22 -0600522 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700523 }
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 **/
541static void
542iscsi_solicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
543 struct iscsi_r2t_info *r2t)
544{
545 struct iscsi_data *hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -0700546 struct scsi_cmnd *sc = ctask->sc;
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900547 int i, sg_count = 0;
548 struct scatterlist *sg;
Alex Aizman7ba24712005-08-04 19:30:08 -0700549
Mike Christieffbfe922006-05-18 20:31:36 -0500550 hdr = &r2t->dtask.hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -0700551 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;
Mike Christie5bb0b552006-04-06 21:26:46 -0500556 memcpy(hdr->lun, ctask->hdr->lun, sizeof(hdr->lun));
557 hdr->itt = ctask->hdr->itt;
Alex Aizman7ba24712005-08-04 19:30:08 -0700558 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
Mike Christie6e458cc2006-05-18 20:31:31 -0500573 iscsi_buf_init_iov(&r2t->headbuf, (char*)hdr,
Mike Christieaf973482005-09-12 21:01:32 -0500574 sizeof(struct iscsi_hdr));
Alex Aizman7ba24712005-08-04 19:30:08 -0700575
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900576 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700582
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900583 /* sg page found! */
Alex Aizman7ba24712005-08-04 19:30:08 -0700584
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900585 /* offset within this page */
586 page_offset = r2t->data_offset - sg_count;
Alex Aizman7ba24712005-08-04 19:30:08 -0700587
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900588 /* 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700592
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900593 /* xmit logic will continue with next one */
594 r2t->sg = sg + 1;
595 break;
Alex Aizman7ba24712005-08-04 19:30:08 -0700596 }
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900597 sg_count += sg->length;
Mike Christie62f38302006-08-31 18:09:27 -0400598 }
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900599 BUG_ON(r2t->sg == NULL);
Alex Aizman7ba24712005-08-04 19:30:08 -0700600}
601
602/**
603 * iscsi_r2t_rsp - iSCSI R2T Response processing
604 * @conn: iscsi connection
605 * @ctask: scsi command task
606 **/
607static int
608iscsi_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;
Mike Christie5bb0b552006-04-06 21:26:46 -0500612 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700615 int r2tsn = be32_to_cpu(rhdr->r2tsn);
616 int rc;
617
Mike Christie98a94162006-08-31 18:09:26 -0400618 if (tcp_conn->in.datalen) {
619 printk(KERN_ERR "iscsi_tcp: invalid R2t with datalen %d\n",
620 tcp_conn->in.datalen);
Alex Aizman7ba24712005-08-04 19:30:08 -0700621 return ISCSI_ERR_DATALEN;
Mike Christie98a94162006-08-31 18:09:26 -0400622 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700623
Mike Christied473cc72007-05-30 12:57:14 -0500624 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);
Alex Aizman7ba24712005-08-04 19:30:08 -0700627 return ISCSI_ERR_R2TSN;
Mike Christied473cc72007-05-30 12:57:14 -0500628 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700629
Alex Aizman7ba24712005-08-04 19:30:08 -0700630 /* fill-in new R2T associated with the task */
631 spin_lock(&session->lock);
Mike Christie77a23c22007-05-30 12:57:18 -0500632 iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
633
Mike Christie843c0a82007-12-13 12:43:20 -0600634 if (!ctask->sc || session->state != ISCSI_STATE_LOGGED_IN) {
Alex Aizman7ba24712005-08-04 19:30:08 -0700635 printk(KERN_INFO "iscsi_tcp: dropping R2T itt %d in "
636 "recovery...\n", ctask->itt);
637 spin_unlock(&session->lock);
638 return 0;
639 }
Mike Christieb6c395e2006-07-24 15:47:15 -0500640
Mike Christie5bb0b552006-04-06 21:26:46 -0500641 rc = __kfifo_get(tcp_ctask->r2tpool.queue, (void*)&r2t, sizeof(void*));
Alex Aizman7ba24712005-08-04 19:30:08 -0700642 BUG_ON(!rc);
643
644 r2t->exp_statsn = rhdr->statsn;
645 r2t->data_length = be32_to_cpu(rhdr->data_length);
Mike Christie98a94162006-08-31 18:09:26 -0400646 if (r2t->data_length == 0) {
647 printk(KERN_ERR "iscsi_tcp: invalid R2T with zero data len\n");
Alex Aizman7ba24712005-08-04 19:30:08 -0700648 spin_unlock(&session->lock);
649 return ISCSI_ERR_DATALEN;
650 }
651
Mike Christie98a94162006-08-31 18:09:26 -0400652 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
Alex Aizman7ba24712005-08-04 19:30:08 -0700657 r2t->data_offset = be32_to_cpu(rhdr->data_offset);
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900658 if (r2t->data_offset + r2t->data_length > scsi_bufflen(ctask->sc)) {
Alex Aizman7ba24712005-08-04 19:30:08 -0700659 spin_unlock(&session->lock);
Mike Christie98a94162006-08-31 18:09:26 -0400660 printk(KERN_ERR "iscsi_tcp: invalid R2T with data len %u at "
661 "offset %u and total length %d\n", r2t->data_length,
FUJITA Tomonori1c138992007-06-14 22:13:17 +0900662 r2t->data_offset, scsi_bufflen(ctask->sc));
Alex Aizman7ba24712005-08-04 19:30:08 -0700663 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
Mike Christied473cc72007-05-30 12:57:14 -0500671 tcp_ctask->exp_datasn = r2tsn + 1;
Mike Christie5bb0b552006-04-06 21:26:46 -0500672 __kfifo_put(tcp_ctask->r2tqueue, (void*)&r2t, sizeof(void*));
Mike Christie843c0a82007-12-13 12:43:20 -0600673 tcp_ctask->xmstate |= XMSTATE_SOL_HDR_INIT;
Alex Aizman7ba24712005-08-04 19:30:08 -0700674 conn->r2t_pdus_cnt++;
Mike Christie843c0a82007-12-13 12:43:20 -0600675
676 iscsi_requeue_ctask(ctask);
Alex Aizman7ba24712005-08-04 19:30:08 -0700677 spin_unlock(&session->lock);
678
679 return 0;
680}
681
Olaf Kirchda32dd62007-12-13 12:43:21 -0600682/*
683 * Handle incoming reply to DataIn command
684 */
Alex Aizman7ba24712005-08-04 19:30:08 -0700685static int
Olaf Kirchda32dd62007-12-13 12:43:21 -0600686iscsi_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 */
717static int
718iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
Alex Aizman7ba24712005-08-04 19:30:08 -0700719{
Mike Christie5bb0b552006-04-06 21:26:46 -0500720 int rc = 0, opcode, ahslen;
Alex Aizman7ba24712005-08-04 19:30:08 -0700721 struct iscsi_session *session = conn->session;
Mike Christie5bb0b552006-04-06 21:26:46 -0500722 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600723 struct iscsi_cmd_task *ctask;
724 uint32_t itt;
Alex Aizman7ba24712005-08-04 19:30:08 -0700725
726 /* verify PDU length */
Mike Christie5bb0b552006-04-06 21:26:46 -0500727 tcp_conn->in.datalen = ntoh24(hdr->dlength);
728 if (tcp_conn->in.datalen > conn->max_recv_dlength) {
Alex Aizman7ba24712005-08-04 19:30:08 -0700729 printk(KERN_ERR "iscsi_tcp: datalen %d > %d\n",
Mike Christie5bb0b552006-04-06 21:26:46 -0500730 tcp_conn->in.datalen, conn->max_recv_dlength);
Alex Aizman7ba24712005-08-04 19:30:08 -0700731 return ISCSI_ERR_DATALEN;
732 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700733
Olaf Kirchda32dd62007-12-13 12:43:21 -0600734 /* Additional header segments. So far, we don't
735 * process additional headers.
736 */
Mike Christie5bb0b552006-04-06 21:26:46 -0500737 ahslen = hdr->hlength << 2;
Alex Aizman7ba24712005-08-04 19:30:08 -0700738
Mike Christie5bb0b552006-04-06 21:26:46 -0500739 opcode = hdr->opcode & ISCSI_OPCODE_MASK;
Alex Aizman7ba24712005-08-04 19:30:08 -0700740 /* verify itt (itt encoding: age+cid+itt) */
Mike Christie5bb0b552006-04-06 21:26:46 -0500741 rc = iscsi_verify_itt(conn, hdr, &itt);
742 if (rc == ISCSI_ERR_NO_SCSI_CMD) {
Olaf Kirchda32dd62007-12-13 12:43:21 -0600743 /* XXX: what does this do? */
Mike Christie5bb0b552006-04-06 21:26:46 -0500744 tcp_conn->in.datalen = 0; /* force drop */
745 return 0;
746 } else if (rc)
747 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -0700748
Olaf Kirchda32dd62007-12-13 12:43:21 -0600749 debug_tcp("opcode 0x%x ahslen %d datalen %d\n",
750 opcode, ahslen, tcp_conn->in.datalen);
Alex Aizman7ba24712005-08-04 19:30:08 -0700751
Mike Christie5bb0b552006-04-06 21:26:46 -0500752 switch(opcode) {
753 case ISCSI_OP_SCSI_DATA_IN:
Olaf Kirchda32dd62007-12-13 12:43:21 -0600754 ctask = session->cmds[itt];
755 rc = iscsi_data_rsp(conn, ctask);
Mike Christie275fd7d2006-07-24 15:47:17 -0500756 if (rc)
757 return rc;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600758 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 }
Mike Christie5bb0b552006-04-06 21:26:46 -0500785 /* fall through */
786 case ISCSI_OP_SCSI_CMD_RSP:
Olaf Kirchda32dd62007-12-13 12:43:21 -0600787 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);
Mike Christie5bb0b552006-04-06 21:26:46 -0500792 break;
793 case ISCSI_OP_R2T:
Olaf Kirchda32dd62007-12-13 12:43:21 -0600794 ctask = session->cmds[itt];
Mike Christie5bb0b552006-04-06 21:26:46 -0500795 if (ahslen)
796 rc = ISCSI_ERR_AHSLEN;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600797 else if (ctask->sc->sc_data_direction == DMA_TO_DEVICE)
798 rc = iscsi_r2t_rsp(conn, ctask);
Mike Christie5bb0b552006-04-06 21:26:46 -0500799 else
800 rc = ISCSI_ERR_PROTO;
801 break;
802 case ISCSI_OP_LOGIN_RSP:
803 case ISCSI_OP_TEXT_RSP:
Mike Christie5bb0b552006-04-06 21:26:46 -0500804 case ISCSI_OP_REJECT:
805 case ISCSI_OP_ASYNC_EVENT:
Mike Christiec8dc1e52006-07-24 15:47:39 -0500806 /*
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 */
Olaf Kirchda32dd62007-12-13 12:43:21 -0600811 if (ISCSI_DEF_MAX_RECV_SEG_LEN < tcp_conn->in.datalen) {
Mike Christiec8dc1e52006-07-24 15:47:39 -0500812 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,
Mike Christiebf32ed32007-02-28 17:32:17 -0600815 ISCSI_DEF_MAX_RECV_SEG_LEN, opcode);
Mike Christiec8dc1e52006-07-24 15:47:39 -0500816 rc = ISCSI_ERR_PROTO;
817 break;
818 }
819
Olaf Kirchda32dd62007-12-13 12:43:21 -0600820 /* 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 }
Mike Christie5bb0b552006-04-06 21:26:46 -0500827 /* fall through */
Mike Christiec8dc1e52006-07-24 15:47:39 -0500828 case ISCSI_OP_LOGOUT_RSP:
829 case ISCSI_OP_NOOP_IN:
Mike Christie5bb0b552006-04-06 21:26:46 -0500830 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 }
Alex Aizman7ba24712005-08-04 19:30:08 -0700837
Olaf Kirchda32dd62007-12-13 12:43:21 -0600838 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
Alex Aizman7ba24712005-08-04 19:30:08 -0700846 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -0700847}
848
849static inline void
James Bottomleyc9802cd2006-09-23 15:33:43 -0500850partial_sg_digest_update(struct hash_desc *desc, struct scatterlist *sg,
Mike Christie62f38302006-08-31 18:09:27 -0400851 int offset, int length)
Alex Aizman7ba24712005-08-04 19:30:08 -0700852{
853 struct scatterlist temp;
854
Herbert Xu68e3f5d2007-10-27 00:52:07 -0700855 sg_init_table(&temp, 1);
856 sg_set_page(&temp, sg_page(sg), length, offset);
James Bottomleyc9802cd2006-09-23 15:33:43 -0500857 crypto_hash_update(desc, &temp, length);
Alex Aizman7ba24712005-08-04 19:30:08 -0700858}
859
Olaf Kirchda32dd62007-12-13 12:43:21 -0600860/**
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 */
Alex Aizman7ba24712005-08-04 19:30:08 -0700867static int
Olaf Kirchda32dd62007-12-13 12:43:21 -0600868iscsi_tcp_hdr_recv_done(struct iscsi_tcp_conn *tcp_conn,
869 struct iscsi_chunk *chunk)
Alex Aizman7ba24712005-08-04 19:30:08 -0700870{
Olaf Kirchda32dd62007-12-13 12:43:21 -0600871 struct iscsi_conn *conn = tcp_conn->iscsi_conn;
872 struct iscsi_hdr *hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -0700873
Olaf Kirchda32dd62007-12-13 12:43:21 -0600874 /* 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700884
Olaf Kirchda32dd62007-12-13 12:43:21 -0600885 /* 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;
Alex Aizman7ba24712005-08-04 19:30:08 -0700892 }
Olaf Kirchda32dd62007-12-13 12:43:21 -0600893
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);
Alex Aizman7ba24712005-08-04 19:30:08 -0700913}
914
915/**
Olaf Kirchda32dd62007-12-13 12:43:21 -0600916 * iscsi_tcp_recv - TCP receive in sendfile fashion
Alex Aizman7ba24712005-08-04 19:30:08 -0700917 * @rd_desc: read descriptor
918 * @skb: socket buffer
919 * @offset: offset in skb
920 * @len: skb->len - offset
921 **/
922static int
Olaf Kirchda32dd62007-12-13 12:43:21 -0600923iscsi_tcp_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
924 unsigned int offset, size_t len)
Alex Aizman7ba24712005-08-04 19:30:08 -0700925{
Alex Aizman7ba24712005-08-04 19:30:08 -0700926 struct iscsi_conn *conn = rd_desc->arg.data;
Mike Christie5bb0b552006-04-06 21:26:46 -0500927 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600928 struct iscsi_chunk *chunk = &tcp_conn->in.chunk;
929 struct skb_seq_state seq;
930 unsigned int consumed = 0;
931 int rc = 0;
Alex Aizman7ba24712005-08-04 19:30:08 -0700932
Olaf Kirchda32dd62007-12-13 12:43:21 -0600933 debug_tcp("in %d bytes\n", skb->len - offset);
Alex Aizman7ba24712005-08-04 19:30:08 -0700934
935 if (unlikely(conn->suspend_rx)) {
936 debug_tcp("conn %d Rx suspended!\n", conn->id);
937 return 0;
938 }
939
Olaf Kirchda32dd62007-12-13 12:43:21 -0600940 skb_prepare_seq_read(skb, offset, skb->len, &seq);
941 while (1) {
942 unsigned int avail;
943 const u8 *ptr;
Alex Aizman7ba24712005-08-04 19:30:08 -0700944
Olaf Kirchda32dd62007-12-13 12:43:21 -0600945 avail = skb_seq_read(consumed, &ptr, &seq);
946 if (avail == 0)
947 break;
948 BUG_ON(chunk->copied >= chunk->size);
Alex Aizman7ba24712005-08-04 19:30:08 -0700949
Olaf Kirchda32dd62007-12-13 12:43:21 -0600950 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;
Mike Christie5bb0b552006-04-06 21:26:46 -0500954
Olaf Kirchda32dd62007-12-13 12:43:21 -0600955 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;
Mike Christiedbdb0162007-05-30 12:57:20 -0500960 }
Mike Christiedbdb0162007-05-30 12:57:20 -0500961
Olaf Kirchda32dd62007-12-13 12:43:21 -0600962 /* The done() functions sets up the
963 * next chunk. */
Alex Aizman7ba24712005-08-04 19:30:08 -0700964 }
965 }
966
Olaf Kirchda32dd62007-12-13 12:43:21 -0600967 conn->rxdata_octets += consumed;
968 return consumed;
Alex Aizman7ba24712005-08-04 19:30:08 -0700969
Olaf Kirchda32dd62007-12-13 12:43:21 -0600970error:
971 debug_tcp("Error receiving PDU, errno=%d\n", rc);
972 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
973 return 0;
Alex Aizman7ba24712005-08-04 19:30:08 -0700974}
975
976static void
977iscsi_tcp_data_ready(struct sock *sk, int flag)
978{
979 struct iscsi_conn *conn = sk->sk_user_data;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600980 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -0700981 read_descriptor_t rd_desc;
982
983 read_lock(&sk->sk_callback_lock);
984
Mike Christie665b44a2006-05-02 19:46:49 -0500985 /*
Olaf Kirchda32dd62007-12-13 12:43:21 -0600986 * Use rd_desc to pass 'conn' to iscsi_tcp_recv.
Mike Christie665b44a2006-05-02 19:46:49 -0500987 * We set count to 1 because we want the network layer to
Olaf Kirchda32dd62007-12-13 12:43:21 -0600988 * hand us all the skbs that are available. iscsi_tcp_recv
Mike Christie665b44a2006-05-02 19:46:49 -0500989 * handled pdus that cross buffers or pdus that still need data.
990 */
Alex Aizman7ba24712005-08-04 19:30:08 -0700991 rd_desc.arg.data = conn;
Mike Christie665b44a2006-05-02 19:46:49 -0500992 rd_desc.count = 1;
Olaf Kirchda32dd62007-12-13 12:43:21 -0600993 tcp_read_sock(sk, &rd_desc, iscsi_tcp_recv);
Alex Aizman7ba24712005-08-04 19:30:08 -0700994
995 read_unlock(&sk->sk_callback_lock);
Olaf Kirchda32dd62007-12-13 12:43:21 -0600996
997 /* If we had to (atomically) map a highmem page,
998 * unmap it now. */
999 iscsi_tcp_chunk_unmap(&tcp_conn->in.chunk);
Alex Aizman7ba24712005-08-04 19:30:08 -07001000}
1001
1002static void
1003iscsi_tcp_state_change(struct sock *sk)
1004{
Mike Christie5bb0b552006-04-06 21:26:46 -05001005 struct iscsi_tcp_conn *tcp_conn;
Alex Aizman7ba24712005-08-04 19:30:08 -07001006 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
Mike Christiee6273992005-11-29 23:12:49 -06001015 if ((sk->sk_state == TCP_CLOSE_WAIT ||
1016 sk->sk_state == TCP_CLOSE) &&
1017 !atomic_read(&sk->sk_rmem_alloc)) {
Alex Aizman7ba24712005-08-04 19:30:08 -07001018 debug_tcp("iscsi_tcp_state_change: TCP_CLOSE|TCP_CLOSE_WAIT\n");
1019 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1020 }
1021
Mike Christie5bb0b552006-04-06 21:26:46 -05001022 tcp_conn = conn->dd_data;
1023 old_state_change = tcp_conn->old_state_change;
Alex Aizman7ba24712005-08-04 19:30:08 -07001024
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 **/
1034static void
1035iscsi_write_space(struct sock *sk)
1036{
1037 struct iscsi_conn *conn = (struct iscsi_conn*)sk->sk_user_data;
Mike Christie5bb0b552006-04-06 21:26:46 -05001038 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1039
1040 tcp_conn->old_write_space(sk);
Alex Aizman7ba24712005-08-04 19:30:08 -07001041 debug_tcp("iscsi_write_space: cid %d\n", conn->id);
Mike Christie55e32992006-01-13 18:05:53 -06001042 scsi_queue_work(conn->session->host, &conn->xmitwork);
Alex Aizman7ba24712005-08-04 19:30:08 -07001043}
1044
1045static void
1046iscsi_conn_set_callbacks(struct iscsi_conn *conn)
1047{
Mike Christie5bb0b552006-04-06 21:26:46 -05001048 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1049 struct sock *sk = tcp_conn->sock->sk;
Alex Aizman7ba24712005-08-04 19:30:08 -07001050
1051 /* assign new callbacks */
1052 write_lock_bh(&sk->sk_callback_lock);
1053 sk->sk_user_data = conn;
Mike Christie5bb0b552006-04-06 21:26:46 -05001054 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;
Alex Aizman7ba24712005-08-04 19:30:08 -07001057 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
1063static void
Mike Christie1c834692006-07-24 15:47:26 -05001064iscsi_conn_restore_callbacks(struct iscsi_tcp_conn *tcp_conn)
Alex Aizman7ba24712005-08-04 19:30:08 -07001065{
Mike Christie5bb0b552006-04-06 21:26:46 -05001066 struct sock *sk = tcp_conn->sock->sk;
Alex Aizman7ba24712005-08-04 19:30:08 -07001067
1068 /* restore socket callbacks, see also: iscsi_conn_set_callbacks() */
1069 write_lock_bh(&sk->sk_callback_lock);
1070 sk->sk_user_data = NULL;
Mike Christie5bb0b552006-04-06 21:26:46 -05001071 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;
Alex Aizman7ba24712005-08-04 19:30:08 -07001074 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
Alex Aizman7ba24712005-08-04 19:30:08 -07001084 */
1085static inline int
FUJITA Tomonori56851692006-01-13 18:05:44 -06001086iscsi_send(struct iscsi_conn *conn, struct iscsi_buf *buf, int size, int flags)
Alex Aizman7ba24712005-08-04 19:30:08 -07001087{
Mike Christie5bb0b552006-04-06 21:26:46 -05001088 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1089 struct socket *sk = tcp_conn->sock;
Mike Christie3219e522006-05-30 00:37:28 -05001090 int offset = buf->sg.offset + buf->sent, res;
Alex Aizman7ba24712005-08-04 19:30:08 -07001091
Mike Christie7cae5152006-01-13 18:05:47 -06001092 /*
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)
Olaf Kirchda32dd62007-12-13 12:43:21 -06001101 res = sock_no_sendpage(sk, buf->sg.page, offset, size, flags);
Mike Christie7cae5152006-01-13 18:05:47 -06001102 else
Olaf Kirchda32dd62007-12-13 12:43:21 -06001103 res = tcp_conn->sendpage(sk, buf->sg.page, offset, size, flags);
Mike Christie3219e522006-05-30 00:37:28 -05001104
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;
Alex Aizman7ba24712005-08-04 19:30:08 -07001117}
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 **/
1128static inline int
1129iscsi_sendhdr(struct iscsi_conn *conn, struct iscsi_buf *buf, int datalen)
1130{
Alex Aizman7ba24712005-08-04 19:30:08 -07001131 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
FUJITA Tomonori56851692006-01-13 18:05:44 -06001139 res = iscsi_send(conn, buf, size, flags);
Alex Aizman7ba24712005-08-04 19:30:08 -07001140 debug_tcp("sendhdr %d bytes, sent %d res %d\n", size, buf->sent, res);
1141 if (res >= 0) {
Alex Aizman7ba24712005-08-04 19:30:08 -07001142 if (size != res)
1143 return -EAGAIN;
1144 return 0;
Mike Christie3219e522006-05-30 00:37:28 -05001145 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001146
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 **/
1160static inline int
1161iscsi_sendpage(struct iscsi_conn *conn, struct iscsi_buf *buf,
1162 int *count, int *sent)
1163{
Alex Aizman7ba24712005-08-04 19:30:08 -07001164 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;
Mike Christieb13941f2005-09-12 21:01:28 -05001171 if (buf->sent + size != buf->sg.length || *count != size)
Alex Aizman7ba24712005-08-04 19:30:08 -07001172 flags |= MSG_MORE;
1173
FUJITA Tomonori56851692006-01-13 18:05:44 -06001174 res = iscsi_send(conn, buf, size, flags);
Alex Aizman7ba24712005-08-04 19:30:08 -07001175 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) {
Alex Aizman7ba24712005-08-04 19:30:08 -07001178 *count -= res;
1179 *sent += res;
1180 if (size != res)
1181 return -EAGAIN;
1182 return 0;
Mike Christie3219e522006-05-30 00:37:28 -05001183 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001184
1185 return res;
1186}
1187
1188static inline void
Mike Christie5bb0b552006-04-06 21:26:46 -05001189iscsi_data_digest_init(struct iscsi_tcp_conn *tcp_conn,
Mike Christie62f38302006-08-31 18:09:27 -04001190 struct iscsi_tcp_cmd_task *tcp_ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001191{
James Bottomleyc9802cd2006-09-23 15:33:43 -05001192 crypto_hash_init(&tcp_conn->tx_hash);
Mike Christie5bb0b552006-04-06 21:26:46 -05001193 tcp_ctask->digest_count = 4;
Alex Aizman7ba24712005-08-04 19:30:08 -07001194}
1195
Alex Aizman7ba24712005-08-04 19:30:08 -07001196/**
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 **/
1209static void
1210iscsi_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;
Alex Aizman7ba24712005-08-04 19:30:08 -07001214 int new_offset;
1215
Mike Christieffbfe922006-05-18 20:31:36 -05001216 hdr = &r2t->dtask.hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -07001217 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;
Mike Christie5bb0b552006-04-06 21:26:46 -05001222 memcpy(hdr->lun, ctask->hdr->lun, sizeof(hdr->lun));
1223 hdr->itt = ctask->hdr->itt;
Alex Aizman7ba24712005-08-04 19:30:08 -07001224 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
Mike Christie6e458cc2006-05-18 20:31:31 -05001237 iscsi_buf_init_iov(&r2t->headbuf, (char*)hdr,
Mike Christieaf973482005-09-12 21:01:32 -05001238 sizeof(struct iscsi_hdr));
Alex Aizman7ba24712005-08-04 19:30:08 -07001239
Mike Christie62f38302006-08-31 18:09:27 -04001240 if (iscsi_buf_left(&r2t->sendbuf))
1241 return;
1242
FUJITA Tomonori1c138992007-06-14 22:13:17 +09001243 iscsi_buf_init_sg(&r2t->sendbuf, r2t->sg);
1244 r2t->sg += 1;
Alex Aizman7ba24712005-08-04 19:30:08 -07001245}
1246
Mike Christie62f38302006-08-31 18:09:27 -04001247static void iscsi_set_padding(struct iscsi_tcp_cmd_task *tcp_ctask,
1248 unsigned long len)
Alex Aizman7ba24712005-08-04 19:30:08 -07001249{
Mike Christie62f38302006-08-31 18:09:27 -04001250 tcp_ctask->pad_count = len & (ISCSI_PAD_LEN - 1);
1251 if (!tcp_ctask->pad_count)
1252 return;
Alex Aizman7ba24712005-08-04 19:30:08 -07001253
Mike Christie62f38302006-08-31 18:09:27 -04001254 tcp_ctask->pad_count = ISCSI_PAD_LEN - tcp_ctask->pad_count;
1255 debug_scsi("write padding %d bytes\n", tcp_ctask->pad_count);
Mike Christie843c0a82007-12-13 12:43:20 -06001256 tcp_ctask->xmstate |= XMSTATE_W_PAD;
Alex Aizman7ba24712005-08-04 19:30:08 -07001257}
1258
1259/**
Mike Christie5bb0b552006-04-06 21:26:46 -05001260 * iscsi_tcp_cmd_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands
Alex Aizman7ba24712005-08-04 19:30:08 -07001261 * @conn: iscsi connection
1262 * @ctask: scsi command task
1263 * @sc: scsi command
1264 **/
1265static void
Mike Christie5bb0b552006-04-06 21:26:46 -05001266iscsi_tcp_cmd_init(struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001267{
Mike Christie5bb0b552006-04-06 21:26:46 -05001268 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001269
Mike Christie5bb0b552006-04-06 21:26:46 -05001270 BUG_ON(__kfifo_len(tcp_ctask->r2tqueue));
Mike Christie843c0a82007-12-13 12:43:20 -06001271 tcp_ctask->xmstate = XMSTATE_CMD_HDR_INIT;
Alex Aizman7ba24712005-08-04 19:30:08 -07001272}
1273
1274/**
Mike Christie5bb0b552006-04-06 21:26:46 -05001275 * iscsi_tcp_mtask_xmit - xmit management(immediate) task
Alex Aizman7ba24712005-08-04 19:30:08 -07001276 * @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 *
Mike Christie218432c2007-05-30 12:57:17 -05001284 * Management xmit state machine consists of these states:
Mike Christie843c0a82007-12-13 12:43:20 -06001285 * 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
Alex Aizman7ba24712005-08-04 19:30:08 -07001289 **/
1290static int
Mike Christie5bb0b552006-04-06 21:26:46 -05001291iscsi_tcp_mtask_xmit(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001292{
Mike Christie5bb0b552006-04-06 21:26:46 -05001293 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
Mike Christie3219e522006-05-30 00:37:28 -05001294 int rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001295
1296 debug_scsi("mtask deq [cid %d state %x itt 0x%x]\n",
Mike Christie5bb0b552006-04-06 21:26:46 -05001297 conn->id, tcp_mtask->xmstate, mtask->itt);
Alex Aizman7ba24712005-08-04 19:30:08 -07001298
Mike Christie843c0a82007-12-13 12:43:20 -06001299 if (tcp_mtask->xmstate & XMSTATE_IMM_HDR_INIT) {
Mike Christie218432c2007-05-30 12:57:17 -05001300 iscsi_buf_init_iov(&tcp_mtask->headbuf, (char*)mtask->hdr,
1301 sizeof(struct iscsi_hdr));
1302
1303 if (mtask->data_count) {
Mike Christie843c0a82007-12-13 12:43:20 -06001304 tcp_mtask->xmstate |= XMSTATE_IMM_DATA;
Mike Christie218432c2007-05-30 12:57:17 -05001305 iscsi_buf_init_iov(&tcp_mtask->sendbuf,
1306 (char*)mtask->data,
1307 mtask->data_count);
1308 }
1309
Mike Christieaf973482005-09-12 21:01:32 -05001310 if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE &&
Mike Christie30a6c652006-04-06 21:13:39 -05001311 conn->stop_stage != STOP_CONN_RECOVER &&
Mike Christieaf973482005-09-12 21:01:32 -05001312 conn->hdrdgst_en)
Mike Christie5bb0b552006-04-06 21:26:46 -05001313 iscsi_hdr_digest(conn, &tcp_mtask->headbuf,
1314 (u8*)tcp_mtask->hdrext);
Mike Christie218432c2007-05-30 12:57:17 -05001315
1316 tcp_mtask->sent = 0;
Mike Christie843c0a82007-12-13 12:43:20 -06001317 tcp_mtask->xmstate &= ~XMSTATE_IMM_HDR_INIT;
1318 tcp_mtask->xmstate |= XMSTATE_IMM_HDR;
Mike Christie218432c2007-05-30 12:57:17 -05001319 }
1320
Mike Christie843c0a82007-12-13 12:43:20 -06001321 if (tcp_mtask->xmstate & XMSTATE_IMM_HDR) {
Mike Christie3219e522006-05-30 00:37:28 -05001322 rc = iscsi_sendhdr(conn, &tcp_mtask->headbuf,
1323 mtask->data_count);
Mike Christie218432c2007-05-30 12:57:17 -05001324 if (rc)
Mike Christie3219e522006-05-30 00:37:28 -05001325 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001326 tcp_mtask->xmstate &= ~XMSTATE_IMM_HDR;
Alex Aizman7ba24712005-08-04 19:30:08 -07001327 }
1328
Mike Christie843c0a82007-12-13 12:43:20 -06001329 if (tcp_mtask->xmstate & XMSTATE_IMM_DATA) {
Alex Aizman7ba24712005-08-04 19:30:08 -07001330 BUG_ON(!mtask->data_count);
Mike Christie843c0a82007-12-13 12:43:20 -06001331 tcp_mtask->xmstate &= ~XMSTATE_IMM_DATA;
Alex Aizman7ba24712005-08-04 19:30:08 -07001332 /* FIXME: implement.
1333 * Virtual buffer could be spreaded across multiple pages...
1334 */
1335 do {
Mike Christie3219e522006-05-30 00:37:28 -05001336 int rc;
1337
1338 rc = iscsi_sendpage(conn, &tcp_mtask->sendbuf,
1339 &mtask->data_count, &tcp_mtask->sent);
1340 if (rc) {
Mike Christie843c0a82007-12-13 12:43:20 -06001341 tcp_mtask->xmstate |= XMSTATE_IMM_DATA;
Mike Christie3219e522006-05-30 00:37:28 -05001342 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001343 }
1344 } while (mtask->data_count);
1345 }
1346
Mike Christie843c0a82007-12-13 12:43:20 -06001347 BUG_ON(tcp_mtask->xmstate != XMSTATE_IDLE);
Al Virob4377352007-02-09 16:39:40 +00001348 if (mtask->hdr->itt == RESERVED_ITT) {
Mike Christie5bb0b552006-04-06 21:26:46 -05001349 struct iscsi_session *session = conn->session;
1350
1351 spin_lock_bh(&session->lock);
1352 list_del(&conn->mtask->running);
1353 __kfifo_put(session->mgmtpool.queue, (void*)&conn->mtask,
1354 sizeof(void*));
1355 spin_unlock_bh(&session->lock);
1356 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001357 return 0;
1358}
1359
Mike Christie218432c2007-05-30 12:57:17 -05001360static int
1361iscsi_send_cmd_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001362{
Mike Christie218432c2007-05-30 12:57:17 -05001363 struct scsi_cmnd *sc = ctask->sc;
Mike Christie5bb0b552006-04-06 21:26:46 -05001364 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Mike Christie218432c2007-05-30 12:57:17 -05001365 int rc = 0;
Mike Christie5bb0b552006-04-06 21:26:46 -05001366
Mike Christie843c0a82007-12-13 12:43:20 -06001367 if (tcp_ctask->xmstate & XMSTATE_CMD_HDR_INIT) {
Mike Christie218432c2007-05-30 12:57:17 -05001368 tcp_ctask->sent = 0;
1369 tcp_ctask->sg_count = 0;
1370 tcp_ctask->exp_datasn = 0;
Mike Christie3219e522006-05-30 00:37:28 -05001371
Mike Christie218432c2007-05-30 12:57:17 -05001372 if (sc->sc_data_direction == DMA_TO_DEVICE) {
FUJITA Tomonori1c138992007-06-14 22:13:17 +09001373 struct scatterlist *sg = scsi_sglist(sc);
Alex Aizman7ba24712005-08-04 19:30:08 -07001374
FUJITA Tomonori1c138992007-06-14 22:13:17 +09001375 iscsi_buf_init_sg(&tcp_ctask->sendbuf, sg);
1376 tcp_ctask->sg = sg + 1;
1377 tcp_ctask->bad_sg = sg + scsi_sg_count(sc);
Mike Christie218432c2007-05-30 12:57:17 -05001378
1379 debug_scsi("cmd [itt 0x%x total %d imm_data %d "
1380 "unsol count %d, unsol offset %d]\n",
FUJITA Tomonori1c138992007-06-14 22:13:17 +09001381 ctask->itt, scsi_bufflen(sc),
Mike Christie218432c2007-05-30 12:57:17 -05001382 ctask->imm_count, ctask->unsol_count,
1383 ctask->unsol_offset);
Alex Aizman7ba24712005-08-04 19:30:08 -07001384 }
Mike Christie218432c2007-05-30 12:57:17 -05001385
1386 iscsi_buf_init_iov(&tcp_ctask->headbuf, (char*)ctask->hdr,
Boaz Harrosh004d6532007-12-13 12:43:23 -06001387 ctask->hdr_len);
Mike Christie218432c2007-05-30 12:57:17 -05001388
1389 if (conn->hdrdgst_en)
1390 iscsi_hdr_digest(conn, &tcp_ctask->headbuf,
Boaz Harrosh004d6532007-12-13 12:43:23 -06001391 iscsi_next_hdr(ctask));
Mike Christie843c0a82007-12-13 12:43:20 -06001392 tcp_ctask->xmstate &= ~XMSTATE_CMD_HDR_INIT;
1393 tcp_ctask->xmstate |= XMSTATE_CMD_HDR_XMIT;
Alex Aizman7ba24712005-08-04 19:30:08 -07001394 }
1395
Mike Christie843c0a82007-12-13 12:43:20 -06001396 if (tcp_ctask->xmstate & XMSTATE_CMD_HDR_XMIT) {
Mike Christie218432c2007-05-30 12:57:17 -05001397 rc = iscsi_sendhdr(conn, &tcp_ctask->headbuf, ctask->imm_count);
1398 if (rc)
1399 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001400 tcp_ctask->xmstate &= ~XMSTATE_CMD_HDR_XMIT;
Mike Christie218432c2007-05-30 12:57:17 -05001401
1402 if (sc->sc_data_direction != DMA_TO_DEVICE)
1403 return 0;
1404
1405 if (ctask->imm_count) {
Mike Christie843c0a82007-12-13 12:43:20 -06001406 tcp_ctask->xmstate |= XMSTATE_IMM_DATA;
Mike Christie218432c2007-05-30 12:57:17 -05001407 iscsi_set_padding(tcp_ctask, ctask->imm_count);
1408
1409 if (ctask->conn->datadgst_en) {
1410 iscsi_data_digest_init(ctask->conn->dd_data,
1411 tcp_ctask);
1412 tcp_ctask->immdigest = 0;
1413 }
1414 }
1415
Mike Christie843c0a82007-12-13 12:43:20 -06001416 if (ctask->unsol_count)
1417 tcp_ctask->xmstate |=
1418 XMSTATE_UNS_HDR | XMSTATE_UNS_INIT;
Mike Christie218432c2007-05-30 12:57:17 -05001419 }
1420 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001421}
1422
Mike Christie62f38302006-08-31 18:09:27 -04001423static int
1424iscsi_send_padding(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
1425{
1426 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1427 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1428 int sent = 0, rc;
1429
Mike Christie843c0a82007-12-13 12:43:20 -06001430 if (tcp_ctask->xmstate & XMSTATE_W_PAD) {
Mike Christie62f38302006-08-31 18:09:27 -04001431 iscsi_buf_init_iov(&tcp_ctask->sendbuf, (char*)&tcp_ctask->pad,
1432 tcp_ctask->pad_count);
1433 if (conn->datadgst_en)
James Bottomleyc9802cd2006-09-23 15:33:43 -05001434 crypto_hash_update(&tcp_conn->tx_hash,
1435 &tcp_ctask->sendbuf.sg,
1436 tcp_ctask->sendbuf.sg.length);
Mike Christie843c0a82007-12-13 12:43:20 -06001437 } else if (!(tcp_ctask->xmstate & XMSTATE_W_RESEND_PAD))
Mike Christie62f38302006-08-31 18:09:27 -04001438 return 0;
1439
Mike Christie843c0a82007-12-13 12:43:20 -06001440 tcp_ctask->xmstate &= ~XMSTATE_W_PAD;
1441 tcp_ctask->xmstate &= ~XMSTATE_W_RESEND_PAD;
Mike Christie62f38302006-08-31 18:09:27 -04001442 debug_scsi("sending %d pad bytes for itt 0x%x\n",
1443 tcp_ctask->pad_count, ctask->itt);
1444 rc = iscsi_sendpage(conn, &tcp_ctask->sendbuf, &tcp_ctask->pad_count,
1445 &sent);
1446 if (rc) {
1447 debug_scsi("padding send failed %d\n", rc);
Mike Christie843c0a82007-12-13 12:43:20 -06001448 tcp_ctask->xmstate |= XMSTATE_W_RESEND_PAD;
Mike Christie62f38302006-08-31 18:09:27 -04001449 }
1450 return rc;
1451}
1452
1453static int
1454iscsi_send_digest(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
1455 struct iscsi_buf *buf, uint32_t *digest)
1456{
1457 struct iscsi_tcp_cmd_task *tcp_ctask;
1458 struct iscsi_tcp_conn *tcp_conn;
1459 int rc, sent = 0;
1460
1461 if (!conn->datadgst_en)
1462 return 0;
1463
1464 tcp_ctask = ctask->dd_data;
1465 tcp_conn = conn->dd_data;
1466
Mike Christie843c0a82007-12-13 12:43:20 -06001467 if (!(tcp_ctask->xmstate & XMSTATE_W_RESEND_DATA_DIGEST)) {
James Bottomleyc9802cd2006-09-23 15:33:43 -05001468 crypto_hash_final(&tcp_conn->tx_hash, (u8*)digest);
Mike Christie62f38302006-08-31 18:09:27 -04001469 iscsi_buf_init_iov(buf, (char*)digest, 4);
1470 }
Mike Christie843c0a82007-12-13 12:43:20 -06001471 tcp_ctask->xmstate &= ~XMSTATE_W_RESEND_DATA_DIGEST;
Mike Christie62f38302006-08-31 18:09:27 -04001472
1473 rc = iscsi_sendpage(conn, buf, &tcp_ctask->digest_count, &sent);
1474 if (!rc)
1475 debug_scsi("sent digest 0x%x for itt 0x%x\n", *digest,
1476 ctask->itt);
1477 else {
1478 debug_scsi("sending digest 0x%x failed for itt 0x%x!\n",
1479 *digest, ctask->itt);
Mike Christie843c0a82007-12-13 12:43:20 -06001480 tcp_ctask->xmstate |= XMSTATE_W_RESEND_DATA_DIGEST;
Mike Christie62f38302006-08-31 18:09:27 -04001481 }
1482 return rc;
1483}
1484
1485static int
1486iscsi_send_data(struct iscsi_cmd_task *ctask, struct iscsi_buf *sendbuf,
1487 struct scatterlist **sg, int *sent, int *count,
1488 struct iscsi_buf *digestbuf, uint32_t *digest)
1489{
1490 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
1491 struct iscsi_conn *conn = ctask->conn;
1492 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
1493 int rc, buf_sent, offset;
1494
1495 while (*count) {
1496 buf_sent = 0;
1497 offset = sendbuf->sent;
1498
1499 rc = iscsi_sendpage(conn, sendbuf, count, &buf_sent);
1500 *sent = *sent + buf_sent;
1501 if (buf_sent && conn->datadgst_en)
James Bottomleyc9802cd2006-09-23 15:33:43 -05001502 partial_sg_digest_update(&tcp_conn->tx_hash,
Mike Christie62f38302006-08-31 18:09:27 -04001503 &sendbuf->sg, sendbuf->sg.offset + offset,
1504 buf_sent);
1505 if (!iscsi_buf_left(sendbuf) && *sg != tcp_ctask->bad_sg) {
1506 iscsi_buf_init_sg(sendbuf, *sg);
1507 *sg = *sg + 1;
1508 }
1509
1510 if (rc)
1511 return rc;
1512 }
1513
1514 rc = iscsi_send_padding(conn, ctask);
1515 if (rc)
1516 return rc;
1517
1518 return iscsi_send_digest(conn, ctask, digestbuf, digest);
1519}
1520
1521static int
1522iscsi_send_unsol_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001523{
Mike Christie5bb0b552006-04-06 21:26:46 -05001524 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001525 struct iscsi_data_task *dtask;
Mike Christie3219e522006-05-30 00:37:28 -05001526 int rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001527
Mike Christie843c0a82007-12-13 12:43:20 -06001528 tcp_ctask->xmstate |= XMSTATE_UNS_DATA;
1529 if (tcp_ctask->xmstate & XMSTATE_UNS_INIT) {
Mike Christie62f38302006-08-31 18:09:27 -04001530 dtask = &tcp_ctask->unsol_dtask;
1531
Mike Christieffd04362006-08-31 18:09:24 -04001532 iscsi_prep_unsolicit_data_pdu(ctask, &dtask->hdr);
1533 iscsi_buf_init_iov(&tcp_ctask->headbuf, (char*)&dtask->hdr,
1534 sizeof(struct iscsi_hdr));
Mike Christieaf973482005-09-12 21:01:32 -05001535 if (conn->hdrdgst_en)
Mike Christie5bb0b552006-04-06 21:26:46 -05001536 iscsi_hdr_digest(conn, &tcp_ctask->headbuf,
Mike Christieaf973482005-09-12 21:01:32 -05001537 (u8*)dtask->hdrext);
Mike Christie62f38302006-08-31 18:09:27 -04001538
Mike Christie843c0a82007-12-13 12:43:20 -06001539 tcp_ctask->xmstate &= ~XMSTATE_UNS_INIT;
Mike Christie62f38302006-08-31 18:09:27 -04001540 iscsi_set_padding(tcp_ctask, ctask->data_count);
Alex Aizman7ba24712005-08-04 19:30:08 -07001541 }
Mike Christie3219e522006-05-30 00:37:28 -05001542
1543 rc = iscsi_sendhdr(conn, &tcp_ctask->headbuf, ctask->data_count);
1544 if (rc) {
Mike Christie843c0a82007-12-13 12:43:20 -06001545 tcp_ctask->xmstate &= ~XMSTATE_UNS_DATA;
1546 tcp_ctask->xmstate |= XMSTATE_UNS_HDR;
Mike Christie3219e522006-05-30 00:37:28 -05001547 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001548 }
1549
Mike Christiedd8c0d92006-08-31 18:09:28 -04001550 if (conn->datadgst_en) {
1551 dtask = &tcp_ctask->unsol_dtask;
1552 iscsi_data_digest_init(ctask->conn->dd_data, tcp_ctask);
1553 dtask->digest = 0;
1554 }
1555
Alex Aizman7ba24712005-08-04 19:30:08 -07001556 debug_scsi("uns dout [itt 0x%x dlen %d sent %d]\n",
Mike Christie5bb0b552006-04-06 21:26:46 -05001557 ctask->itt, ctask->unsol_count, tcp_ctask->sent);
Alex Aizman7ba24712005-08-04 19:30:08 -07001558 return 0;
1559}
1560
Mike Christie62f38302006-08-31 18:09:27 -04001561static int
1562iscsi_send_unsol_pdu(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001563{
Mike Christie5bb0b552006-04-06 21:26:46 -05001564 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Mike Christie3219e522006-05-30 00:37:28 -05001565 int rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001566
Mike Christie843c0a82007-12-13 12:43:20 -06001567 if (tcp_ctask->xmstate & XMSTATE_UNS_HDR) {
Mike Christie62f38302006-08-31 18:09:27 -04001568 BUG_ON(!ctask->unsol_count);
Mike Christie843c0a82007-12-13 12:43:20 -06001569 tcp_ctask->xmstate &= ~XMSTATE_UNS_HDR;
Mike Christie62f38302006-08-31 18:09:27 -04001570send_hdr:
1571 rc = iscsi_send_unsol_hdr(conn, ctask);
1572 if (rc)
1573 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001574 }
1575
Mike Christie843c0a82007-12-13 12:43:20 -06001576 if (tcp_ctask->xmstate & XMSTATE_UNS_DATA) {
Mike Christie62f38302006-08-31 18:09:27 -04001577 struct iscsi_data_task *dtask = &tcp_ctask->unsol_dtask;
Mike Christie5bb0b552006-04-06 21:26:46 -05001578 int start = tcp_ctask->sent;
Alex Aizman7ba24712005-08-04 19:30:08 -07001579
Mike Christie62f38302006-08-31 18:09:27 -04001580 rc = iscsi_send_data(ctask, &tcp_ctask->sendbuf, &tcp_ctask->sg,
1581 &tcp_ctask->sent, &ctask->data_count,
1582 &dtask->digestbuf, &dtask->digest);
Mike Christie5bb0b552006-04-06 21:26:46 -05001583 ctask->unsol_count -= tcp_ctask->sent - start;
Mike Christie62f38302006-08-31 18:09:27 -04001584 if (rc)
Mike Christie3219e522006-05-30 00:37:28 -05001585 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001586 tcp_ctask->xmstate &= ~XMSTATE_UNS_DATA;
Mike Christie62f38302006-08-31 18:09:27 -04001587 /*
1588 * Done with the Data-Out. Next, check if we need
1589 * to send another unsolicited Data-Out.
1590 */
1591 if (ctask->unsol_count) {
1592 debug_scsi("sending more uns\n");
Mike Christie843c0a82007-12-13 12:43:20 -06001593 tcp_ctask->xmstate |= XMSTATE_UNS_INIT;
Mike Christie62f38302006-08-31 18:09:27 -04001594 goto send_hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -07001595 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001596 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001597 return 0;
1598}
1599
Mike Christie62f38302006-08-31 18:09:27 -04001600static int iscsi_send_sol_pdu(struct iscsi_conn *conn,
1601 struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001602{
Mike Christie5bb0b552006-04-06 21:26:46 -05001603 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Mike Christie62f38302006-08-31 18:09:27 -04001604 struct iscsi_session *session = conn->session;
1605 struct iscsi_r2t_info *r2t;
1606 struct iscsi_data_task *dtask;
Mike Christie3219e522006-05-30 00:37:28 -05001607 int left, rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001608
Mike Christie843c0a82007-12-13 12:43:20 -06001609 if (tcp_ctask->xmstate & XMSTATE_SOL_HDR_INIT) {
Mike Christiedb37c502006-11-08 15:58:33 -06001610 if (!tcp_ctask->r2t) {
1611 spin_lock_bh(&session->lock);
Mike Christie62f38302006-08-31 18:09:27 -04001612 __kfifo_get(tcp_ctask->r2tqueue, (void*)&tcp_ctask->r2t,
1613 sizeof(void*));
Mike Christiedb37c502006-11-08 15:58:33 -06001614 spin_unlock_bh(&session->lock);
1615 }
Mike Christie62f38302006-08-31 18:09:27 -04001616send_hdr:
1617 r2t = tcp_ctask->r2t;
1618 dtask = &r2t->dtask;
Alex Aizman7ba24712005-08-04 19:30:08 -07001619
Mike Christie62f38302006-08-31 18:09:27 -04001620 if (conn->hdrdgst_en)
1621 iscsi_hdr_digest(conn, &r2t->headbuf,
1622 (u8*)dtask->hdrext);
Mike Christie843c0a82007-12-13 12:43:20 -06001623 tcp_ctask->xmstate &= ~XMSTATE_SOL_HDR_INIT;
1624 tcp_ctask->xmstate |= XMSTATE_SOL_HDR;
Mike Christie218432c2007-05-30 12:57:17 -05001625 }
1626
Mike Christie843c0a82007-12-13 12:43:20 -06001627 if (tcp_ctask->xmstate & XMSTATE_SOL_HDR) {
Mike Christie218432c2007-05-30 12:57:17 -05001628 r2t = tcp_ctask->r2t;
1629 dtask = &r2t->dtask;
1630
Mike Christie62f38302006-08-31 18:09:27 -04001631 rc = iscsi_sendhdr(conn, &r2t->headbuf, r2t->data_count);
Mike Christie218432c2007-05-30 12:57:17 -05001632 if (rc)
Mike Christie3219e522006-05-30 00:37:28 -05001633 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001634 tcp_ctask->xmstate &= ~XMSTATE_SOL_HDR;
1635 tcp_ctask->xmstate |= XMSTATE_SOL_DATA;
Alex Aizman7ba24712005-08-04 19:30:08 -07001636
Mike Christiedd8c0d92006-08-31 18:09:28 -04001637 if (conn->datadgst_en) {
1638 iscsi_data_digest_init(conn->dd_data, tcp_ctask);
1639 dtask->digest = 0;
Alex Aizman7ba24712005-08-04 19:30:08 -07001640 }
Mike Christiedd8c0d92006-08-31 18:09:28 -04001641
Mike Christie62f38302006-08-31 18:09:27 -04001642 iscsi_set_padding(tcp_ctask, r2t->data_count);
1643 debug_scsi("sol dout [dsn %d itt 0x%x dlen %d sent %d]\n",
1644 r2t->solicit_datasn - 1, ctask->itt, r2t->data_count,
1645 r2t->sent);
Alex Aizman7ba24712005-08-04 19:30:08 -07001646 }
1647
Mike Christie843c0a82007-12-13 12:43:20 -06001648 if (tcp_ctask->xmstate & XMSTATE_SOL_DATA) {
Mike Christie62f38302006-08-31 18:09:27 -04001649 r2t = tcp_ctask->r2t;
1650 dtask = &r2t->dtask;
Alex Aizman7ba24712005-08-04 19:30:08 -07001651
Mike Christie62f38302006-08-31 18:09:27 -04001652 rc = iscsi_send_data(ctask, &r2t->sendbuf, &r2t->sg,
1653 &r2t->sent, &r2t->data_count,
1654 &dtask->digestbuf, &dtask->digest);
1655 if (rc)
1656 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001657 tcp_ctask->xmstate &= ~XMSTATE_SOL_DATA;
Alex Aizman7ba24712005-08-04 19:30:08 -07001658
Mike Christie62f38302006-08-31 18:09:27 -04001659 /*
1660 * Done with this Data-Out. Next, check if we have
1661 * to send another Data-Out for this R2T.
1662 */
1663 BUG_ON(r2t->data_length - r2t->sent < 0);
1664 left = r2t->data_length - r2t->sent;
1665 if (left) {
1666 iscsi_solicit_data_cont(conn, ctask, r2t, left);
Mike Christie62f38302006-08-31 18:09:27 -04001667 goto send_hdr;
Alex Aizman7ba24712005-08-04 19:30:08 -07001668 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001669
Mike Christie62f38302006-08-31 18:09:27 -04001670 /*
1671 * Done with this R2T. Check if there are more
1672 * outstanding R2Ts ready to be processed.
1673 */
1674 spin_lock_bh(&session->lock);
1675 tcp_ctask->r2t = NULL;
1676 __kfifo_put(tcp_ctask->r2tpool.queue, (void*)&r2t,
1677 sizeof(void*));
1678 if (__kfifo_get(tcp_ctask->r2tqueue, (void*)&r2t,
1679 sizeof(void*))) {
1680 tcp_ctask->r2t = r2t;
Mike Christie62f38302006-08-31 18:09:27 -04001681 spin_unlock_bh(&session->lock);
1682 goto send_hdr;
1683 }
1684 spin_unlock_bh(&session->lock);
1685 }
Alex Aizman7ba24712005-08-04 19:30:08 -07001686 return 0;
1687}
1688
Mike Christie218432c2007-05-30 12:57:17 -05001689/**
1690 * iscsi_tcp_ctask_xmit - xmit normal PDU task
1691 * @conn: iscsi connection
1692 * @ctask: iscsi command task
1693 *
1694 * Notes:
1695 * The function can return -EAGAIN in which case caller must
1696 * call it again later, or recover. '0' return code means successful
1697 * xmit.
1698 * The function is devided to logical helpers (above) for the different
1699 * xmit stages.
1700 *
1701 *iscsi_send_cmd_hdr()
Mike Christie843c0a82007-12-13 12:43:20 -06001702 * XMSTATE_CMD_HDR_INIT - prepare Header and Data buffers Calculate
1703 * Header Digest
1704 * XMSTATE_CMD_HDR_XMIT - Transmit header in progress
Mike Christie218432c2007-05-30 12:57:17 -05001705 *
1706 *iscsi_send_padding
Mike Christie843c0a82007-12-13 12:43:20 -06001707 * XMSTATE_W_PAD - Prepare and send pading
1708 * XMSTATE_W_RESEND_PAD - retry send pading
Mike Christie218432c2007-05-30 12:57:17 -05001709 *
1710 *iscsi_send_digest
Mike Christie843c0a82007-12-13 12:43:20 -06001711 * XMSTATE_W_RESEND_DATA_DIGEST - Finalize and send Data Digest
1712 * XMSTATE_W_RESEND_DATA_DIGEST - retry sending digest
Mike Christie218432c2007-05-30 12:57:17 -05001713 *
1714 *iscsi_send_unsol_hdr
Mike Christie843c0a82007-12-13 12:43:20 -06001715 * XMSTATE_UNS_INIT - prepare un-solicit data header and digest
1716 * XMSTATE_UNS_HDR - send un-solicit header
Mike Christie218432c2007-05-30 12:57:17 -05001717 *
1718 *iscsi_send_unsol_pdu
Mike Christie843c0a82007-12-13 12:43:20 -06001719 * XMSTATE_UNS_DATA - send un-solicit data in progress
Mike Christie218432c2007-05-30 12:57:17 -05001720 *
1721 *iscsi_send_sol_pdu
Mike Christie843c0a82007-12-13 12:43:20 -06001722 * XMSTATE_SOL_HDR_INIT - solicit data header and digest initialize
1723 * XMSTATE_SOL_HDR - send solicit header
1724 * XMSTATE_SOL_DATA - send solicit data
Mike Christie218432c2007-05-30 12:57:17 -05001725 *
1726 *iscsi_tcp_ctask_xmit
Mike Christie843c0a82007-12-13 12:43:20 -06001727 * XMSTATE_IMM_DATA - xmit managment data (??)
Mike Christie218432c2007-05-30 12:57:17 -05001728 **/
Alex Aizman7ba24712005-08-04 19:30:08 -07001729static int
Mike Christie5bb0b552006-04-06 21:26:46 -05001730iscsi_tcp_ctask_xmit(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
Alex Aizman7ba24712005-08-04 19:30:08 -07001731{
Mike Christie5bb0b552006-04-06 21:26:46 -05001732 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001733 int rc = 0;
1734
1735 debug_scsi("ctask deq [cid %d xmstate %x itt 0x%x]\n",
Mike Christie5bb0b552006-04-06 21:26:46 -05001736 conn->id, tcp_ctask->xmstate, ctask->itt);
Alex Aizman7ba24712005-08-04 19:30:08 -07001737
Mike Christie218432c2007-05-30 12:57:17 -05001738 rc = iscsi_send_cmd_hdr(conn, ctask);
1739 if (rc)
1740 return rc;
1741 if (ctask->sc->sc_data_direction != DMA_TO_DEVICE)
1742 return 0;
Alex Aizman7ba24712005-08-04 19:30:08 -07001743
Mike Christie843c0a82007-12-13 12:43:20 -06001744 if (tcp_ctask->xmstate & XMSTATE_IMM_DATA) {
Mike Christie62f38302006-08-31 18:09:27 -04001745 rc = iscsi_send_data(ctask, &tcp_ctask->sendbuf, &tcp_ctask->sg,
1746 &tcp_ctask->sent, &ctask->imm_count,
1747 &tcp_ctask->immbuf, &tcp_ctask->immdigest);
Alex Aizman7ba24712005-08-04 19:30:08 -07001748 if (rc)
1749 return rc;
Mike Christie843c0a82007-12-13 12:43:20 -06001750 tcp_ctask->xmstate &= ~XMSTATE_IMM_DATA;
Alex Aizman7ba24712005-08-04 19:30:08 -07001751 }
1752
Mike Christie62f38302006-08-31 18:09:27 -04001753 rc = iscsi_send_unsol_pdu(conn, ctask);
1754 if (rc)
1755 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001756
Mike Christie62f38302006-08-31 18:09:27 -04001757 rc = iscsi_send_sol_pdu(conn, ctask);
1758 if (rc)
1759 return rc;
Alex Aizman7ba24712005-08-04 19:30:08 -07001760
1761 return rc;
1762}
1763
Mike Christie7b8631b2006-01-13 18:05:50 -06001764static struct iscsi_cls_conn *
Mike Christie5bb0b552006-04-06 21:26:46 -05001765iscsi_tcp_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx)
Alex Aizman7ba24712005-08-04 19:30:08 -07001766{
Mike Christie7b8631b2006-01-13 18:05:50 -06001767 struct iscsi_conn *conn;
1768 struct iscsi_cls_conn *cls_conn;
Mike Christie5bb0b552006-04-06 21:26:46 -05001769 struct iscsi_tcp_conn *tcp_conn;
Alex Aizman7ba24712005-08-04 19:30:08 -07001770
Mike Christie5bb0b552006-04-06 21:26:46 -05001771 cls_conn = iscsi_conn_setup(cls_session, conn_idx);
Mike Christie7b8631b2006-01-13 18:05:50 -06001772 if (!cls_conn)
1773 return NULL;
1774 conn = cls_conn->dd_data;
Mike Christie5bb0b552006-04-06 21:26:46 -05001775 /*
1776 * due to strange issues with iser these are not set
1777 * in iscsi_conn_setup
1778 */
Mike Christiebf32ed32007-02-28 17:32:17 -06001779 conn->max_recv_dlength = ISCSI_DEF_MAX_RECV_SEG_LEN;
Alex Aizman7ba24712005-08-04 19:30:08 -07001780
Mike Christie5bb0b552006-04-06 21:26:46 -05001781 tcp_conn = kzalloc(sizeof(*tcp_conn), GFP_KERNEL);
1782 if (!tcp_conn)
1783 goto tcp_conn_alloc_fail;
Alex Aizman7ba24712005-08-04 19:30:08 -07001784
Mike Christie5bb0b552006-04-06 21:26:46 -05001785 conn->dd_data = tcp_conn;
1786 tcp_conn->iscsi_conn = conn;
Alex Aizman7ba24712005-08-04 19:30:08 -07001787
James Bottomleyc9802cd2006-09-23 15:33:43 -05001788 tcp_conn->tx_hash.tfm = crypto_alloc_hash("crc32c", 0,
1789 CRYPTO_ALG_ASYNC);
1790 tcp_conn->tx_hash.flags = 0;
Mike Christie0f238412007-02-28 17:32:21 -06001791 if (IS_ERR(tcp_conn->tx_hash.tfm)) {
1792 printk(KERN_ERR "Could not create connection due to crc32c "
1793 "loading error %ld. Make sure the crc32c module is "
1794 "built as a module or into the kernel\n",
1795 PTR_ERR(tcp_conn->tx_hash.tfm));
Mike Christiedd8c0d92006-08-31 18:09:28 -04001796 goto free_tcp_conn;
Mike Christie0f238412007-02-28 17:32:21 -06001797 }
Mike Christiedd8c0d92006-08-31 18:09:28 -04001798
James Bottomleyc9802cd2006-09-23 15:33:43 -05001799 tcp_conn->rx_hash.tfm = crypto_alloc_hash("crc32c", 0,
1800 CRYPTO_ALG_ASYNC);
1801 tcp_conn->rx_hash.flags = 0;
Mike Christie0f238412007-02-28 17:32:21 -06001802 if (IS_ERR(tcp_conn->rx_hash.tfm)) {
1803 printk(KERN_ERR "Could not create connection due to crc32c "
1804 "loading error %ld. Make sure the crc32c module is "
1805 "built as a module or into the kernel\n",
1806 PTR_ERR(tcp_conn->rx_hash.tfm));
Mike Christiedd8c0d92006-08-31 18:09:28 -04001807 goto free_tx_tfm;
Mike Christie0f238412007-02-28 17:32:21 -06001808 }
Mike Christiedd8c0d92006-08-31 18:09:28 -04001809
Mike Christie7b8631b2006-01-13 18:05:50 -06001810 return cls_conn;
Alex Aizman7ba24712005-08-04 19:30:08 -07001811
Mike Christiedd8c0d92006-08-31 18:09:28 -04001812free_tx_tfm:
James Bottomleyc9802cd2006-09-23 15:33:43 -05001813 crypto_free_hash(tcp_conn->tx_hash.tfm);
Mike Christiedd8c0d92006-08-31 18:09:28 -04001814free_tcp_conn:
1815 kfree(tcp_conn);
Mike Christie5bb0b552006-04-06 21:26:46 -05001816tcp_conn_alloc_fail:
1817 iscsi_conn_teardown(cls_conn);
Mike Christie7b8631b2006-01-13 18:05:50 -06001818 return NULL;
Alex Aizman7ba24712005-08-04 19:30:08 -07001819}
1820
1821static void
Mike Christie1c834692006-07-24 15:47:26 -05001822iscsi_tcp_release_conn(struct iscsi_conn *conn)
1823{
Mike Christie22236962007-05-30 12:57:24 -05001824 struct iscsi_session *session = conn->session;
Mike Christie1c834692006-07-24 15:47:26 -05001825 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Mike Christie22236962007-05-30 12:57:24 -05001826 struct socket *sock = tcp_conn->sock;
Mike Christie1c834692006-07-24 15:47:26 -05001827
Mike Christie22236962007-05-30 12:57:24 -05001828 if (!sock)
Mike Christie1c834692006-07-24 15:47:26 -05001829 return;
1830
Mike Christie22236962007-05-30 12:57:24 -05001831 sock_hold(sock->sk);
Mike Christie1c834692006-07-24 15:47:26 -05001832 iscsi_conn_restore_callbacks(tcp_conn);
Mike Christie22236962007-05-30 12:57:24 -05001833 sock_put(sock->sk);
Mike Christie1c834692006-07-24 15:47:26 -05001834
Mike Christie22236962007-05-30 12:57:24 -05001835 spin_lock_bh(&session->lock);
Mike Christie1c834692006-07-24 15:47:26 -05001836 tcp_conn->sock = NULL;
1837 conn->recv_lock = NULL;
Mike Christie22236962007-05-30 12:57:24 -05001838 spin_unlock_bh(&session->lock);
1839 sockfd_put(sock);
Mike Christie1c834692006-07-24 15:47:26 -05001840}
1841
1842static void
Mike Christie5bb0b552006-04-06 21:26:46 -05001843iscsi_tcp_conn_destroy(struct iscsi_cls_conn *cls_conn)
Alex Aizman7ba24712005-08-04 19:30:08 -07001844{
Mike Christie7b8631b2006-01-13 18:05:50 -06001845 struct iscsi_conn *conn = cls_conn->dd_data;
Mike Christie5bb0b552006-04-06 21:26:46 -05001846 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001847
Mike Christie1c834692006-07-24 15:47:26 -05001848 iscsi_tcp_release_conn(conn);
Mike Christie5bb0b552006-04-06 21:26:46 -05001849 iscsi_conn_teardown(cls_conn);
Alex Aizman7ba24712005-08-04 19:30:08 -07001850
Pete Wyckoff534284a2006-11-08 15:58:31 -06001851 if (tcp_conn->tx_hash.tfm)
1852 crypto_free_hash(tcp_conn->tx_hash.tfm);
1853 if (tcp_conn->rx_hash.tfm)
1854 crypto_free_hash(tcp_conn->rx_hash.tfm);
Alex Aizman7ba24712005-08-04 19:30:08 -07001855
Mike Christie5bb0b552006-04-06 21:26:46 -05001856 kfree(tcp_conn);
Alex Aizman7ba24712005-08-04 19:30:08 -07001857}
1858
Mike Christie1c834692006-07-24 15:47:26 -05001859static void
1860iscsi_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
1861{
1862 struct iscsi_conn *conn = cls_conn->dd_data;
1863
1864 iscsi_conn_stop(cls_conn, flag);
1865 iscsi_tcp_release_conn(conn);
1866}
1867
Mike Christie22236962007-05-30 12:57:24 -05001868static int iscsi_tcp_get_addr(struct iscsi_conn *conn, struct socket *sock,
1869 char *buf, int *port,
1870 int (*getname)(struct socket *, struct sockaddr *,
1871 int *addrlen))
1872{
1873 struct sockaddr_storage *addr;
1874 struct sockaddr_in6 *sin6;
1875 struct sockaddr_in *sin;
1876 int rc = 0, len;
1877
Al Viroa9204872007-07-20 16:03:40 +01001878 addr = kmalloc(sizeof(*addr), GFP_KERNEL);
Mike Christie22236962007-05-30 12:57:24 -05001879 if (!addr)
1880 return -ENOMEM;
1881
1882 if (getname(sock, (struct sockaddr *) addr, &len)) {
1883 rc = -ENODEV;
1884 goto free_addr;
1885 }
1886
1887 switch (addr->ss_family) {
1888 case AF_INET:
1889 sin = (struct sockaddr_in *)addr;
1890 spin_lock_bh(&conn->session->lock);
1891 sprintf(buf, NIPQUAD_FMT, NIPQUAD(sin->sin_addr.s_addr));
1892 *port = be16_to_cpu(sin->sin_port);
1893 spin_unlock_bh(&conn->session->lock);
1894 break;
1895 case AF_INET6:
1896 sin6 = (struct sockaddr_in6 *)addr;
1897 spin_lock_bh(&conn->session->lock);
1898 sprintf(buf, NIP6_FMT, NIP6(sin6->sin6_addr));
1899 *port = be16_to_cpu(sin6->sin6_port);
1900 spin_unlock_bh(&conn->session->lock);
1901 break;
1902 }
1903free_addr:
1904 kfree(addr);
1905 return rc;
1906}
1907
Alex Aizman7ba24712005-08-04 19:30:08 -07001908static int
Mike Christie5bb0b552006-04-06 21:26:46 -05001909iscsi_tcp_conn_bind(struct iscsi_cls_session *cls_session,
Or Gerlitz264faaa2006-05-02 19:46:36 -05001910 struct iscsi_cls_conn *cls_conn, uint64_t transport_eph,
Mike Christie5bb0b552006-04-06 21:26:46 -05001911 int is_leading)
Alex Aizman7ba24712005-08-04 19:30:08 -07001912{
Mike Christie5bb0b552006-04-06 21:26:46 -05001913 struct iscsi_conn *conn = cls_conn->dd_data;
1914 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001915 struct sock *sk;
1916 struct socket *sock;
1917 int err;
1918
1919 /* lookup for existing socket */
Or Gerlitz264faaa2006-05-02 19:46:36 -05001920 sock = sockfd_lookup((int)transport_eph, &err);
Alex Aizman7ba24712005-08-04 19:30:08 -07001921 if (!sock) {
1922 printk(KERN_ERR "iscsi_tcp: sockfd_lookup failed %d\n", err);
1923 return -EEXIST;
1924 }
Mike Christie22236962007-05-30 12:57:24 -05001925 /*
1926 * copy these values now because if we drop the session
1927 * userspace may still want to query the values since we will
1928 * be using them for the reconnect
1929 */
1930 err = iscsi_tcp_get_addr(conn, sock, conn->portal_address,
1931 &conn->portal_port, kernel_getpeername);
1932 if (err)
1933 goto free_socket;
1934
1935 err = iscsi_tcp_get_addr(conn, sock, conn->local_address,
1936 &conn->local_port, kernel_getsockname);
1937 if (err)
1938 goto free_socket;
Alex Aizman7ba24712005-08-04 19:30:08 -07001939
Mike Christie5bb0b552006-04-06 21:26:46 -05001940 err = iscsi_conn_bind(cls_session, cls_conn, is_leading);
1941 if (err)
Mike Christie22236962007-05-30 12:57:24 -05001942 goto free_socket;
Alex Aizman7ba24712005-08-04 19:30:08 -07001943
Mike Christie67a61112006-05-30 00:37:20 -05001944 /* bind iSCSI connection and socket */
1945 tcp_conn->sock = sock;
Alex Aizman7ba24712005-08-04 19:30:08 -07001946
Mike Christie67a61112006-05-30 00:37:20 -05001947 /* setup Socket parameters */
1948 sk = sock->sk;
1949 sk->sk_reuse = 1;
1950 sk->sk_sndtimeo = 15 * HZ; /* FIXME: make it configurable */
1951 sk->sk_allocation = GFP_ATOMIC;
Alex Aizman7ba24712005-08-04 19:30:08 -07001952
Mike Christie67a61112006-05-30 00:37:20 -05001953 /* FIXME: disable Nagle's algorithm */
Alex Aizman7ba24712005-08-04 19:30:08 -07001954
Mike Christie67a61112006-05-30 00:37:20 -05001955 /*
1956 * Intercept TCP callbacks for sendfile like receive
1957 * processing.
1958 */
1959 conn->recv_lock = &sk->sk_callback_lock;
1960 iscsi_conn_set_callbacks(conn);
1961 tcp_conn->sendpage = tcp_conn->sock->ops->sendpage;
1962 /*
1963 * set receive state machine into initial state
1964 */
Olaf Kirchda32dd62007-12-13 12:43:21 -06001965 iscsi_tcp_hdr_recv_prep(tcp_conn);
Alex Aizman7ba24712005-08-04 19:30:08 -07001966 return 0;
Mike Christie22236962007-05-30 12:57:24 -05001967
1968free_socket:
1969 sockfd_put(sock);
1970 return err;
Alex Aizman7ba24712005-08-04 19:30:08 -07001971}
1972
Mike Christie5bb0b552006-04-06 21:26:46 -05001973/* called with host lock */
Mike Christie30a6c652006-04-06 21:13:39 -05001974static void
Mike Christie77a23c22007-05-30 12:57:18 -05001975iscsi_tcp_mgmt_init(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
Mike Christie30a6c652006-04-06 21:13:39 -05001976{
Mike Christie5bb0b552006-04-06 21:26:46 -05001977 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
Mike Christie843c0a82007-12-13 12:43:20 -06001978 tcp_mtask->xmstate = XMSTATE_IMM_HDR_INIT;
Alex Aizman7ba24712005-08-04 19:30:08 -07001979}
1980
1981static int
1982iscsi_r2tpool_alloc(struct iscsi_session *session)
1983{
1984 int i;
1985 int cmd_i;
1986
1987 /*
1988 * initialize per-task: R2T pool and xmit queue
1989 */
1990 for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
1991 struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
Mike Christie5bb0b552006-04-06 21:26:46 -05001992 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07001993
1994 /*
1995 * pre-allocated x4 as much r2ts to handle race when
1996 * target acks DataOut faster than we data_xmit() queues
1997 * could replenish r2tqueue.
1998 */
1999
2000 /* R2T pool */
Mike Christie5bb0b552006-04-06 21:26:46 -05002001 if (iscsi_pool_init(&tcp_ctask->r2tpool, session->max_r2t * 4,
2002 (void***)&tcp_ctask->r2ts,
2003 sizeof(struct iscsi_r2t_info))) {
Alex Aizman7ba24712005-08-04 19:30:08 -07002004 goto r2t_alloc_fail;
2005 }
2006
2007 /* R2T xmit queue */
Mike Christie5bb0b552006-04-06 21:26:46 -05002008 tcp_ctask->r2tqueue = kfifo_alloc(
Alex Aizman7ba24712005-08-04 19:30:08 -07002009 session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
Mike Christie5bb0b552006-04-06 21:26:46 -05002010 if (tcp_ctask->r2tqueue == ERR_PTR(-ENOMEM)) {
2011 iscsi_pool_free(&tcp_ctask->r2tpool,
2012 (void**)tcp_ctask->r2ts);
Alex Aizman7ba24712005-08-04 19:30:08 -07002013 goto r2t_alloc_fail;
2014 }
Alex Aizman7ba24712005-08-04 19:30:08 -07002015 }
2016
2017 return 0;
2018
2019r2t_alloc_fail:
2020 for (i = 0; i < cmd_i; i++) {
Mike Christie5bb0b552006-04-06 21:26:46 -05002021 struct iscsi_cmd_task *ctask = session->cmds[i];
2022 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2023
Mike Christie5bb0b552006-04-06 21:26:46 -05002024 kfifo_free(tcp_ctask->r2tqueue);
2025 iscsi_pool_free(&tcp_ctask->r2tpool,
2026 (void**)tcp_ctask->r2ts);
Alex Aizman7ba24712005-08-04 19:30:08 -07002027 }
2028 return -ENOMEM;
2029}
2030
2031static void
2032iscsi_r2tpool_free(struct iscsi_session *session)
2033{
2034 int i;
2035
2036 for (i = 0; i < session->cmds_max; i++) {
Mike Christie5bb0b552006-04-06 21:26:46 -05002037 struct iscsi_cmd_task *ctask = session->cmds[i];
2038 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2039
Mike Christie5bb0b552006-04-06 21:26:46 -05002040 kfifo_free(tcp_ctask->r2tqueue);
2041 iscsi_pool_free(&tcp_ctask->r2tpool,
2042 (void**)tcp_ctask->r2ts);
Alex Aizman7ba24712005-08-04 19:30:08 -07002043 }
2044}
2045
Alex Aizman7ba24712005-08-04 19:30:08 -07002046static int
Mike Christie7b7232f2006-02-01 21:06:49 -06002047iscsi_conn_set_param(struct iscsi_cls_conn *cls_conn, enum iscsi_param param,
Mike Christie5c75b7f2006-06-28 12:00:26 -05002048 char *buf, int buflen)
Alex Aizman7ba24712005-08-04 19:30:08 -07002049{
Mike Christie7b7232f2006-02-01 21:06:49 -06002050 struct iscsi_conn *conn = cls_conn->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07002051 struct iscsi_session *session = conn->session;
Mike Christie5bb0b552006-04-06 21:26:46 -05002052 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Mike Christie5c75b7f2006-06-28 12:00:26 -05002053 int value;
Alex Aizman7ba24712005-08-04 19:30:08 -07002054
Alex Aizman7ba24712005-08-04 19:30:08 -07002055 switch(param) {
Alex Aizman7ba24712005-08-04 19:30:08 -07002056 case ISCSI_PARAM_HDRDGST_EN:
Mike Christie5c75b7f2006-06-28 12:00:26 -05002057 iscsi_set_param(cls_conn, param, buf, buflen);
Alex Aizman7ba24712005-08-04 19:30:08 -07002058 break;
2059 case ISCSI_PARAM_DATADGST_EN:
Mike Christie5c75b7f2006-06-28 12:00:26 -05002060 iscsi_set_param(cls_conn, param, buf, buflen);
Mike Christie5bb0b552006-04-06 21:26:46 -05002061 tcp_conn->sendpage = conn->datadgst_en ?
2062 sock_no_sendpage : tcp_conn->sock->ops->sendpage;
Alex Aizman7ba24712005-08-04 19:30:08 -07002063 break;
Alex Aizman7ba24712005-08-04 19:30:08 -07002064 case ISCSI_PARAM_MAX_R2T:
Mike Christie5c75b7f2006-06-28 12:00:26 -05002065 sscanf(buf, "%d", &value);
Alex Aizman7ba24712005-08-04 19:30:08 -07002066 if (session->max_r2t == roundup_pow_of_two(value))
2067 break;
2068 iscsi_r2tpool_free(session);
Mike Christie5c75b7f2006-06-28 12:00:26 -05002069 iscsi_set_param(cls_conn, param, buf, buflen);
Alex Aizman7ba24712005-08-04 19:30:08 -07002070 if (session->max_r2t & (session->max_r2t - 1))
2071 session->max_r2t = roundup_pow_of_two(session->max_r2t);
2072 if (iscsi_r2tpool_alloc(session))
2073 return -ENOMEM;
2074 break;
Alex Aizman7ba24712005-08-04 19:30:08 -07002075 default:
Mike Christie5c75b7f2006-06-28 12:00:26 -05002076 return iscsi_set_param(cls_conn, param, buf, buflen);
Alex Aizman7ba24712005-08-04 19:30:08 -07002077 }
2078
2079 return 0;
2080}
2081
2082static int
Mike Christie5c75b7f2006-06-28 12:00:26 -05002083iscsi_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
2084 enum iscsi_param param, char *buf)
Mike Christie7b8631b2006-01-13 18:05:50 -06002085{
Mike Christie7b7232f2006-02-01 21:06:49 -06002086 struct iscsi_conn *conn = cls_conn->dd_data;
Mike Christie5c75b7f2006-06-28 12:00:26 -05002087 int len;
Mike Christie7b8631b2006-01-13 18:05:50 -06002088
2089 switch(param) {
Mike Christiefd7255f2006-04-06 21:13:36 -05002090 case ISCSI_PARAM_CONN_PORT:
Mike Christie22236962007-05-30 12:57:24 -05002091 spin_lock_bh(&conn->session->lock);
2092 len = sprintf(buf, "%hu\n", conn->portal_port);
2093 spin_unlock_bh(&conn->session->lock);
Mike Christie8d2860b2006-05-02 19:46:47 -05002094 break;
Mike Christiefd7255f2006-04-06 21:13:36 -05002095 case ISCSI_PARAM_CONN_ADDRESS:
Mike Christie22236962007-05-30 12:57:24 -05002096 spin_lock_bh(&conn->session->lock);
2097 len = sprintf(buf, "%s\n", conn->portal_address);
2098 spin_unlock_bh(&conn->session->lock);
Mike Christiefd7255f2006-04-06 21:13:36 -05002099 break;
2100 default:
Mike Christie5c75b7f2006-06-28 12:00:26 -05002101 return iscsi_conn_get_param(cls_conn, param, buf);
Mike Christiefd7255f2006-04-06 21:13:36 -05002102 }
2103
2104 return len;
2105}
2106
Mike Christie22236962007-05-30 12:57:24 -05002107static int
2108iscsi_tcp_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
2109 char *buf)
2110{
2111 struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
2112 int len;
2113
2114 switch (param) {
2115 case ISCSI_HOST_PARAM_IPADDRESS:
2116 spin_lock_bh(&session->lock);
2117 if (!session->leadconn)
2118 len = -ENODEV;
2119 else
2120 len = sprintf(buf, "%s\n",
2121 session->leadconn->local_address);
2122 spin_unlock_bh(&session->lock);
2123 break;
2124 default:
2125 return iscsi_host_get_param(shost, param, buf);
2126 }
2127 return len;
2128}
2129
Alex Aizman7ba24712005-08-04 19:30:08 -07002130static void
Mike Christie7b7232f2006-02-01 21:06:49 -06002131iscsi_conn_get_stats(struct iscsi_cls_conn *cls_conn, struct iscsi_stats *stats)
Alex Aizman7ba24712005-08-04 19:30:08 -07002132{
Mike Christie7b7232f2006-02-01 21:06:49 -06002133 struct iscsi_conn *conn = cls_conn->dd_data;
Mike Christie5bb0b552006-04-06 21:26:46 -05002134 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
Alex Aizman7ba24712005-08-04 19:30:08 -07002135
2136 stats->txdata_octets = conn->txdata_octets;
2137 stats->rxdata_octets = conn->rxdata_octets;
2138 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
2139 stats->dataout_pdus = conn->dataout_pdus_cnt;
2140 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
2141 stats->datain_pdus = conn->datain_pdus_cnt;
2142 stats->r2t_pdus = conn->r2t_pdus_cnt;
2143 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
2144 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
2145 stats->custom_length = 3;
2146 strcpy(stats->custom[0].desc, "tx_sendpage_failures");
Mike Christie5bb0b552006-04-06 21:26:46 -05002147 stats->custom[0].value = tcp_conn->sendpage_failures_cnt;
Alex Aizman7ba24712005-08-04 19:30:08 -07002148 strcpy(stats->custom[1].desc, "rx_discontiguous_hdr");
Mike Christie5bb0b552006-04-06 21:26:46 -05002149 stats->custom[1].value = tcp_conn->discontiguous_hdr_cnt;
Alex Aizman7ba24712005-08-04 19:30:08 -07002150 strcpy(stats->custom[2].desc, "eh_abort_cnt");
2151 stats->custom[2].value = conn->eh_abort_cnt;
2152}
2153
Mike Christie5bb0b552006-04-06 21:26:46 -05002154static struct iscsi_cls_session *
2155iscsi_tcp_session_create(struct iscsi_transport *iscsit,
2156 struct scsi_transport_template *scsit,
Mike Christie15482712007-05-30 12:57:19 -05002157 uint16_t cmds_max, uint16_t qdepth,
Mike Christie5bb0b552006-04-06 21:26:46 -05002158 uint32_t initial_cmdsn, uint32_t *hostno)
Alex Aizman7ba24712005-08-04 19:30:08 -07002159{
Mike Christie5bb0b552006-04-06 21:26:46 -05002160 struct iscsi_cls_session *cls_session;
2161 struct iscsi_session *session;
2162 uint32_t hn;
2163 int cmd_i;
Alex Aizman7ba24712005-08-04 19:30:08 -07002164
Mike Christie15482712007-05-30 12:57:19 -05002165 cls_session = iscsi_session_setup(iscsit, scsit, cmds_max, qdepth,
Mike Christie5bb0b552006-04-06 21:26:46 -05002166 sizeof(struct iscsi_tcp_cmd_task),
2167 sizeof(struct iscsi_tcp_mgmt_task),
2168 initial_cmdsn, &hn);
2169 if (!cls_session)
2170 return NULL;
2171 *hostno = hn;
Alex Aizman7ba24712005-08-04 19:30:08 -07002172
Mike Christie5bb0b552006-04-06 21:26:46 -05002173 session = class_to_transport_session(cls_session);
2174 for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
2175 struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
2176 struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
2177
Boaz Harrosh004d6532007-12-13 12:43:23 -06002178 ctask->hdr = &tcp_ctask->hdr.cmd_hdr;
2179 ctask->hdr_max = sizeof(tcp_ctask->hdr) - ISCSI_DIGEST_SIZE;
Mike Christie5bb0b552006-04-06 21:26:46 -05002180 }
2181
2182 for (cmd_i = 0; cmd_i < session->mgmtpool_max; cmd_i++) {
2183 struct iscsi_mgmt_task *mtask = session->mgmt_cmds[cmd_i];
2184 struct iscsi_tcp_mgmt_task *tcp_mtask = mtask->dd_data;
2185
2186 mtask->hdr = &tcp_mtask->hdr;
2187 }
2188
2189 if (iscsi_r2tpool_alloc(class_to_transport_session(cls_session)))
2190 goto r2tpool_alloc_fail;
2191
2192 return cls_session;
2193
2194r2tpool_alloc_fail:
2195 iscsi_session_teardown(cls_session);
2196 return NULL;
Alex Aizman7ba24712005-08-04 19:30:08 -07002197}
2198
Mike Christie5bb0b552006-04-06 21:26:46 -05002199static void iscsi_tcp_session_destroy(struct iscsi_cls_session *cls_session)
2200{
Mike Christie5bb0b552006-04-06 21:26:46 -05002201 iscsi_r2tpool_free(class_to_transport_session(cls_session));
2202 iscsi_session_teardown(cls_session);
2203}
2204
Mike Christied1d81c02007-05-30 12:57:21 -05002205static int iscsi_tcp_slave_configure(struct scsi_device *sdev)
2206{
Mike Christieb6d44fe2007-07-26 12:46:47 -05002207 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_ANY);
Mike Christied1d81c02007-05-30 12:57:21 -05002208 blk_queue_dma_alignment(sdev->request_queue, 0);
2209 return 0;
2210}
2211
Mike Christie5bb0b552006-04-06 21:26:46 -05002212static struct scsi_host_template iscsi_sht = {
Mike Christie79743922007-07-26 12:46:46 -05002213 .module = THIS_MODULE,
Mike Christief4246b32006-07-24 15:47:54 -05002214 .name = "iSCSI Initiator over TCP/IP",
Mike Christie5bb0b552006-04-06 21:26:46 -05002215 .queuecommand = iscsi_queuecommand,
2216 .change_queue_depth = iscsi_change_queue_depth,
Mike Christie15482712007-05-30 12:57:19 -05002217 .can_queue = ISCSI_DEF_XMIT_CMDS_MAX - 1,
Mike Christie5bb0b552006-04-06 21:26:46 -05002218 .sg_tablesize = ISCSI_SG_TABLESIZE,
Mike Christie8231f0e2007-02-28 17:32:20 -06002219 .max_sectors = 0xFFFF,
Mike Christie5bb0b552006-04-06 21:26:46 -05002220 .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN,
2221 .eh_abort_handler = iscsi_eh_abort,
Mike Christie843c0a82007-12-13 12:43:20 -06002222 .eh_device_reset_handler= iscsi_eh_device_reset,
Mike Christie5bb0b552006-04-06 21:26:46 -05002223 .eh_host_reset_handler = iscsi_eh_host_reset,
2224 .use_clustering = DISABLE_CLUSTERING,
Mike Christied1d81c02007-05-30 12:57:21 -05002225 .slave_configure = iscsi_tcp_slave_configure,
Mike Christie5bb0b552006-04-06 21:26:46 -05002226 .proc_name = "iscsi_tcp",
2227 .this_id = -1,
2228};
2229
Alex Aizman7ba24712005-08-04 19:30:08 -07002230static struct iscsi_transport iscsi_tcp_transport = {
2231 .owner = THIS_MODULE,
2232 .name = "tcp",
2233 .caps = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST
2234 | CAP_DATADGST,
Mike Christiefd7255f2006-04-06 21:13:36 -05002235 .param_mask = ISCSI_MAX_RECV_DLENGTH |
2236 ISCSI_MAX_XMIT_DLENGTH |
2237 ISCSI_HDRDGST_EN |
2238 ISCSI_DATADGST_EN |
2239 ISCSI_INITIAL_R2T_EN |
2240 ISCSI_MAX_R2T |
2241 ISCSI_IMM_DATA_EN |
2242 ISCSI_FIRST_BURST |
2243 ISCSI_MAX_BURST |
2244 ISCSI_PDU_INORDER_EN |
2245 ISCSI_DATASEQ_INORDER_EN |
2246 ISCSI_ERL |
2247 ISCSI_CONN_PORT |
Mike Christie8d2860b2006-05-02 19:46:47 -05002248 ISCSI_CONN_ADDRESS |
Mike Christie5c75b7f2006-06-28 12:00:26 -05002249 ISCSI_EXP_STATSN |
2250 ISCSI_PERSISTENT_PORT |
2251 ISCSI_PERSISTENT_ADDRESS |
Mike Christieb2c64162007-05-30 12:57:16 -05002252 ISCSI_TARGET_NAME | ISCSI_TPGT |
2253 ISCSI_USERNAME | ISCSI_PASSWORD |
Mike Christie843c0a82007-12-13 12:43:20 -06002254 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
2255 ISCSI_FAST_ABORT,
Mike Christie22236962007-05-30 12:57:24 -05002256 .host_param_mask = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
Mike Christied8196ed2007-05-30 12:57:25 -05002257 ISCSI_HOST_INITIATOR_NAME |
2258 ISCSI_HOST_NETDEV_NAME,
Alex Aizman7ba24712005-08-04 19:30:08 -07002259 .host_template = &iscsi_sht,
Mike Christie7b8631b2006-01-13 18:05:50 -06002260 .conndata_size = sizeof(struct iscsi_conn),
Alex Aizman7ba24712005-08-04 19:30:08 -07002261 .max_conn = 1,
2262 .max_cmd_len = ISCSI_TCP_MAX_CMD_LEN,
Mike Christie5bb0b552006-04-06 21:26:46 -05002263 /* session management */
2264 .create_session = iscsi_tcp_session_create,
2265 .destroy_session = iscsi_tcp_session_destroy,
2266 /* connection management */
2267 .create_conn = iscsi_tcp_conn_create,
2268 .bind_conn = iscsi_tcp_conn_bind,
2269 .destroy_conn = iscsi_tcp_conn_destroy,
Alex Aizman7ba24712005-08-04 19:30:08 -07002270 .set_param = iscsi_conn_set_param,
Mike Christie5c75b7f2006-06-28 12:00:26 -05002271 .get_conn_param = iscsi_tcp_conn_get_param,
Mike Christie7b8631b2006-01-13 18:05:50 -06002272 .get_session_param = iscsi_session_get_param,
Alex Aizman7ba24712005-08-04 19:30:08 -07002273 .start_conn = iscsi_conn_start,
Mike Christie1c834692006-07-24 15:47:26 -05002274 .stop_conn = iscsi_tcp_conn_stop,
Mike Christie0801c242007-05-30 12:57:12 -05002275 /* iscsi host params */
Mike Christie22236962007-05-30 12:57:24 -05002276 .get_host_param = iscsi_tcp_host_get_param,
Mike Christie0801c242007-05-30 12:57:12 -05002277 .set_host_param = iscsi_host_set_param,
Mike Christie5bb0b552006-04-06 21:26:46 -05002278 /* IO */
Alex Aizman7ba24712005-08-04 19:30:08 -07002279 .send_pdu = iscsi_conn_send_pdu,
2280 .get_stats = iscsi_conn_get_stats,
Mike Christie5bb0b552006-04-06 21:26:46 -05002281 .init_cmd_task = iscsi_tcp_cmd_init,
2282 .init_mgmt_task = iscsi_tcp_mgmt_init,
2283 .xmit_cmd_task = iscsi_tcp_ctask_xmit,
2284 .xmit_mgmt_task = iscsi_tcp_mtask_xmit,
2285 .cleanup_cmd_task = iscsi_tcp_cleanup_ctask,
2286 /* recovery */
Mike Christie30a6c652006-04-06 21:13:39 -05002287 .session_recovery_timedout = iscsi_session_recovery_timedout,
Alex Aizman7ba24712005-08-04 19:30:08 -07002288};
2289
2290static int __init
2291iscsi_tcp_init(void)
2292{
Alex Aizman7ba24712005-08-04 19:30:08 -07002293 if (iscsi_max_lun < 1) {
Or Gerlitzbe2df722006-05-02 19:46:43 -05002294 printk(KERN_ERR "iscsi_tcp: Invalid max_lun value of %u\n",
2295 iscsi_max_lun);
Alex Aizman7ba24712005-08-04 19:30:08 -07002296 return -EINVAL;
2297 }
2298 iscsi_tcp_transport.max_lun = iscsi_max_lun;
2299
Mike Christie7b8631b2006-01-13 18:05:50 -06002300 if (!iscsi_register_transport(&iscsi_tcp_transport))
Mike Christieffbfe922006-05-18 20:31:36 -05002301 return -ENODEV;
Alex Aizman7ba24712005-08-04 19:30:08 -07002302
Mike Christie7b8631b2006-01-13 18:05:50 -06002303 return 0;
Alex Aizman7ba24712005-08-04 19:30:08 -07002304}
2305
2306static void __exit
2307iscsi_tcp_exit(void)
2308{
2309 iscsi_unregister_transport(&iscsi_tcp_transport);
Alex Aizman7ba24712005-08-04 19:30:08 -07002310}
2311
2312module_init(iscsi_tcp_init);
2313module_exit(iscsi_tcp_exit);