2 * iSCSI Initiator over TCP/IP Data-Path
4 * Copyright (C) 2004 Dmitry Yusupov
5 * Copyright (C) 2004 Alex Aizman
6 * Copyright (C) 2005 - 2006 Mike Christie
7 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
8 * maintained by open-iscsi@googlegroups.com
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.
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.
20 * See the file COPYING included with this distribution for more details.
29 #include <crypto/hash.h>
30 #include <linux/types.h>
31 #include <linux/inet.h>
32 #include <linux/slab.h>
33 #include <linux/sched/mm.h>
34 #include <linux/file.h>
35 #include <linux/blkdev.h>
36 #include <linux/delay.h>
37 #include <linux/kfifo.h>
38 #include <linux/scatterlist.h>
39 #include <linux/module.h>
41 #include <scsi/scsi_cmnd.h>
42 #include <scsi/scsi_device.h>
43 #include <scsi/scsi_host.h>
44 #include <scsi/scsi.h>
45 #include <scsi/scsi_transport_iscsi.h>
47 #include "iscsi_tcp.h"
49 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
50 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
51 "Alex Aizman <itn780@yahoo.com>");
52 MODULE_DESCRIPTION("iSCSI/TCP data-path");
53 MODULE_LICENSE("GPL");
55 static struct scsi_transport_template
*iscsi_sw_tcp_scsi_transport
;
56 static struct scsi_host_template iscsi_sw_tcp_sht
;
57 static struct iscsi_transport iscsi_sw_tcp_transport
;
59 static unsigned int iscsi_max_lun
= ~0;
60 module_param_named(max_lun
, iscsi_max_lun
, uint
, S_IRUGO
);
62 static int iscsi_sw_tcp_dbg
;
63 module_param_named(debug_iscsi_tcp
, iscsi_sw_tcp_dbg
, int,
65 MODULE_PARM_DESC(debug_iscsi_tcp
, "Turn on debugging for iscsi_tcp module "
66 "Set to 1 to turn on, and zero to turn off. Default is off.");
68 #define ISCSI_SW_TCP_DBG(_conn, dbg_fmt, arg...) \
70 if (iscsi_sw_tcp_dbg) \
71 iscsi_conn_printk(KERN_INFO, _conn, \
78 * iscsi_sw_tcp_recv - TCP receive in sendfile fashion
79 * @rd_desc: read descriptor
81 * @offset: offset in skb
82 * @len: skb->len - offset
84 static int iscsi_sw_tcp_recv(read_descriptor_t
*rd_desc
, struct sk_buff
*skb
,
85 unsigned int offset
, size_t len
)
87 struct iscsi_conn
*conn
= rd_desc
->arg
.data
;
88 unsigned int consumed
, total_consumed
= 0;
91 ISCSI_SW_TCP_DBG(conn
, "in %d bytes\n", skb
->len
- offset
);
95 consumed
= iscsi_tcp_recv_skb(conn
, skb
, offset
, 0, &status
);
97 total_consumed
+= consumed
;
98 } while (consumed
!= 0 && status
!= ISCSI_TCP_SKB_DONE
);
100 ISCSI_SW_TCP_DBG(conn
, "read %d bytes status %d\n",
101 skb
->len
- offset
, status
);
102 return total_consumed
;
106 * iscsi_sw_sk_state_check - check socket state
109 * If the socket is in CLOSE or CLOSE_WAIT we should
110 * not close the connection if there is still some
113 * Must be called with sk_callback_lock.
115 static inline int iscsi_sw_sk_state_check(struct sock
*sk
)
117 struct iscsi_conn
*conn
= sk
->sk_user_data
;
119 if ((sk
->sk_state
== TCP_CLOSE_WAIT
|| sk
->sk_state
== TCP_CLOSE
) &&
120 (conn
->session
->state
!= ISCSI_STATE_LOGGING_OUT
) &&
121 !atomic_read(&sk
->sk_rmem_alloc
)) {
122 ISCSI_SW_TCP_DBG(conn
, "TCP_CLOSE|TCP_CLOSE_WAIT\n");
123 iscsi_conn_failure(conn
, ISCSI_ERR_TCP_CONN_CLOSE
);
129 static void iscsi_sw_tcp_data_ready(struct sock
*sk
)
131 struct iscsi_conn
*conn
;
132 struct iscsi_tcp_conn
*tcp_conn
;
133 read_descriptor_t rd_desc
;
135 read_lock_bh(&sk
->sk_callback_lock
);
136 conn
= sk
->sk_user_data
;
138 read_unlock_bh(&sk
->sk_callback_lock
);
141 tcp_conn
= conn
->dd_data
;
144 * Use rd_desc to pass 'conn' to iscsi_tcp_recv.
145 * We set count to 1 because we want the network layer to
146 * hand us all the skbs that are available. iscsi_tcp_recv
147 * handled pdus that cross buffers or pdus that still need data.
149 rd_desc
.arg
.data
= conn
;
151 tcp_read_sock(sk
, &rd_desc
, iscsi_sw_tcp_recv
);
153 iscsi_sw_sk_state_check(sk
);
155 /* If we had to (atomically) map a highmem page,
157 iscsi_tcp_segment_unmap(&tcp_conn
->in
.segment
);
158 read_unlock_bh(&sk
->sk_callback_lock
);
161 static void iscsi_sw_tcp_state_change(struct sock
*sk
)
163 struct iscsi_tcp_conn
*tcp_conn
;
164 struct iscsi_sw_tcp_conn
*tcp_sw_conn
;
165 struct iscsi_conn
*conn
;
166 void (*old_state_change
)(struct sock
*);
168 read_lock_bh(&sk
->sk_callback_lock
);
169 conn
= sk
->sk_user_data
;
171 read_unlock_bh(&sk
->sk_callback_lock
);
175 iscsi_sw_sk_state_check(sk
);
177 tcp_conn
= conn
->dd_data
;
178 tcp_sw_conn
= tcp_conn
->dd_data
;
179 old_state_change
= tcp_sw_conn
->old_state_change
;
181 read_unlock_bh(&sk
->sk_callback_lock
);
183 old_state_change(sk
);
187 * iscsi_write_space - Called when more output buffer space is available
188 * @sk: socket space is available for
190 static void iscsi_sw_tcp_write_space(struct sock
*sk
)
192 struct iscsi_conn
*conn
;
193 struct iscsi_tcp_conn
*tcp_conn
;
194 struct iscsi_sw_tcp_conn
*tcp_sw_conn
;
195 void (*old_write_space
)(struct sock
*);
197 read_lock_bh(&sk
->sk_callback_lock
);
198 conn
= sk
->sk_user_data
;
200 read_unlock_bh(&sk
->sk_callback_lock
);
204 tcp_conn
= conn
->dd_data
;
205 tcp_sw_conn
= tcp_conn
->dd_data
;
206 old_write_space
= tcp_sw_conn
->old_write_space
;
207 read_unlock_bh(&sk
->sk_callback_lock
);
211 ISCSI_SW_TCP_DBG(conn
, "iscsi_write_space\n");
212 iscsi_conn_queue_work(conn
);
215 static void iscsi_sw_tcp_conn_set_callbacks(struct iscsi_conn
*conn
)
217 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
218 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
219 struct sock
*sk
= tcp_sw_conn
->sock
->sk
;
221 /* assign new callbacks */
222 write_lock_bh(&sk
->sk_callback_lock
);
223 sk
->sk_user_data
= conn
;
224 tcp_sw_conn
->old_data_ready
= sk
->sk_data_ready
;
225 tcp_sw_conn
->old_state_change
= sk
->sk_state_change
;
226 tcp_sw_conn
->old_write_space
= sk
->sk_write_space
;
227 sk
->sk_data_ready
= iscsi_sw_tcp_data_ready
;
228 sk
->sk_state_change
= iscsi_sw_tcp_state_change
;
229 sk
->sk_write_space
= iscsi_sw_tcp_write_space
;
230 write_unlock_bh(&sk
->sk_callback_lock
);
234 iscsi_sw_tcp_conn_restore_callbacks(struct iscsi_conn
*conn
)
236 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
237 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
238 struct sock
*sk
= tcp_sw_conn
->sock
->sk
;
240 /* restore socket callbacks, see also: iscsi_conn_set_callbacks() */
241 write_lock_bh(&sk
->sk_callback_lock
);
242 sk
->sk_user_data
= NULL
;
243 sk
->sk_data_ready
= tcp_sw_conn
->old_data_ready
;
244 sk
->sk_state_change
= tcp_sw_conn
->old_state_change
;
245 sk
->sk_write_space
= tcp_sw_conn
->old_write_space
;
246 sk
->sk_no_check_tx
= 0;
247 write_unlock_bh(&sk
->sk_callback_lock
);
251 * iscsi_sw_tcp_xmit_segment - transmit segment
252 * @tcp_conn: the iSCSI TCP connection
253 * @segment: the buffer to transmnit
255 * This function transmits as much of the buffer as
256 * the network layer will accept, and returns the number of
259 * If CRC hashing is enabled, the function will compute the
260 * hash as it goes. When the entire segment has been transmitted,
261 * it will retrieve the hash value and send it as well.
263 static int iscsi_sw_tcp_xmit_segment(struct iscsi_tcp_conn
*tcp_conn
,
264 struct iscsi_segment
*segment
)
266 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
267 struct socket
*sk
= tcp_sw_conn
->sock
;
268 unsigned int copied
= 0;
271 while (!iscsi_tcp_segment_done(tcp_conn
, segment
, 0, r
)) {
272 struct scatterlist
*sg
;
273 unsigned int offset
, copy
;
277 offset
= segment
->copied
;
278 copy
= segment
->size
- offset
;
280 if (segment
->total_copied
+ segment
->size
< segment
->total_size
)
283 /* Use sendpage if we can; else fall back to sendmsg */
284 if (!segment
->data
) {
286 offset
+= segment
->sg_offset
+ sg
->offset
;
287 r
= tcp_sw_conn
->sendpage(sk
, sg_page(sg
), offset
,
290 struct msghdr msg
= { .msg_flags
= flags
};
292 .iov_base
= segment
->data
+ offset
,
296 r
= kernel_sendmsg(sk
, &msg
, &iov
, 1, copy
);
300 iscsi_tcp_segment_unmap(segment
);
309 * iscsi_sw_tcp_xmit - TCP transmit
311 static int iscsi_sw_tcp_xmit(struct iscsi_conn
*conn
)
313 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
314 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
315 struct iscsi_segment
*segment
= &tcp_sw_conn
->out
.segment
;
316 unsigned int consumed
= 0;
320 rc
= iscsi_sw_tcp_xmit_segment(tcp_conn
, segment
);
322 * We may not have been able to send data because the conn
323 * is getting stopped. libiscsi will know so propagate err
324 * for it to do the right thing.
329 rc
= ISCSI_ERR_XMIT_FAILED
;
336 if (segment
->total_copied
>= segment
->total_size
) {
337 if (segment
->done
!= NULL
) {
338 rc
= segment
->done(tcp_conn
, segment
);
345 ISCSI_SW_TCP_DBG(conn
, "xmit %d bytes\n", consumed
);
347 conn
->txdata_octets
+= consumed
;
351 /* Transmit error. We could initiate error recovery
353 ISCSI_SW_TCP_DBG(conn
, "Error sending PDU, errno=%d\n", rc
);
354 iscsi_conn_failure(conn
, rc
);
359 * iscsi_tcp_xmit_qlen - return the number of bytes queued for xmit
361 static inline int iscsi_sw_tcp_xmit_qlen(struct iscsi_conn
*conn
)
363 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
364 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
365 struct iscsi_segment
*segment
= &tcp_sw_conn
->out
.segment
;
367 return segment
->total_copied
- segment
->total_size
;
370 static int iscsi_sw_tcp_pdu_xmit(struct iscsi_task
*task
)
372 struct iscsi_conn
*conn
= task
->conn
;
373 unsigned int noreclaim_flag
;
376 noreclaim_flag
= memalloc_noreclaim_save();
378 while (iscsi_sw_tcp_xmit_qlen(conn
)) {
379 rc
= iscsi_sw_tcp_xmit(conn
);
389 memalloc_noreclaim_restore(noreclaim_flag
);
394 * This is called when we're done sending the header.
395 * Simply copy the data_segment to the send segment, and return.
397 static int iscsi_sw_tcp_send_hdr_done(struct iscsi_tcp_conn
*tcp_conn
,
398 struct iscsi_segment
*segment
)
400 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
402 tcp_sw_conn
->out
.segment
= tcp_sw_conn
->out
.data_segment
;
403 ISCSI_SW_TCP_DBG(tcp_conn
->iscsi_conn
,
404 "Header done. Next segment size %u total_size %u\n",
405 tcp_sw_conn
->out
.segment
.size
,
406 tcp_sw_conn
->out
.segment
.total_size
);
410 static void iscsi_sw_tcp_send_hdr_prep(struct iscsi_conn
*conn
, void *hdr
,
413 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
414 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
416 ISCSI_SW_TCP_DBG(conn
, "%s\n", conn
->hdrdgst_en
?
417 "digest enabled" : "digest disabled");
419 /* Clear the data segment - needs to be filled in by the
420 * caller using iscsi_tcp_send_data_prep() */
421 memset(&tcp_sw_conn
->out
.data_segment
, 0,
422 sizeof(struct iscsi_segment
));
424 /* If header digest is enabled, compute the CRC and
425 * place the digest into the same buffer. We make
426 * sure that both iscsi_tcp_task and mtask have
429 if (conn
->hdrdgst_en
) {
430 iscsi_tcp_dgst_header(tcp_sw_conn
->tx_hash
, hdr
, hdrlen
,
432 hdrlen
+= ISCSI_DIGEST_SIZE
;
435 /* Remember header pointer for later, when we need
436 * to decide whether there's a payload to go along
437 * with the header. */
438 tcp_sw_conn
->out
.hdr
= hdr
;
440 iscsi_segment_init_linear(&tcp_sw_conn
->out
.segment
, hdr
, hdrlen
,
441 iscsi_sw_tcp_send_hdr_done
, NULL
);
445 * Prepare the send buffer for the payload data.
446 * Padding and checksumming will all be taken care
447 * of by the iscsi_segment routines.
450 iscsi_sw_tcp_send_data_prep(struct iscsi_conn
*conn
, struct scatterlist
*sg
,
451 unsigned int count
, unsigned int offset
,
454 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
455 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
456 struct ahash_request
*tx_hash
= NULL
;
457 unsigned int hdr_spec_len
;
459 ISCSI_SW_TCP_DBG(conn
, "offset=%d, datalen=%d %s\n", offset
, len
,
461 "digest enabled" : "digest disabled");
463 /* Make sure the datalen matches what the caller
464 said he would send. */
465 hdr_spec_len
= ntoh24(tcp_sw_conn
->out
.hdr
->dlength
);
466 WARN_ON(iscsi_padded(len
) != iscsi_padded(hdr_spec_len
));
468 if (conn
->datadgst_en
)
469 tx_hash
= tcp_sw_conn
->tx_hash
;
471 return iscsi_segment_seek_sg(&tcp_sw_conn
->out
.data_segment
,
472 sg
, count
, offset
, len
,
477 iscsi_sw_tcp_send_linear_data_prep(struct iscsi_conn
*conn
, void *data
,
480 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
481 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
482 struct ahash_request
*tx_hash
= NULL
;
483 unsigned int hdr_spec_len
;
485 ISCSI_SW_TCP_DBG(conn
, "datalen=%zd %s\n", len
, conn
->datadgst_en
?
486 "digest enabled" : "digest disabled");
488 /* Make sure the datalen matches what the caller
489 said he would send. */
490 hdr_spec_len
= ntoh24(tcp_sw_conn
->out
.hdr
->dlength
);
491 WARN_ON(iscsi_padded(len
) != iscsi_padded(hdr_spec_len
));
493 if (conn
->datadgst_en
)
494 tx_hash
= tcp_sw_conn
->tx_hash
;
496 iscsi_segment_init_linear(&tcp_sw_conn
->out
.data_segment
,
497 data
, len
, NULL
, tx_hash
);
500 static int iscsi_sw_tcp_pdu_init(struct iscsi_task
*task
,
501 unsigned int offset
, unsigned int count
)
503 struct iscsi_conn
*conn
= task
->conn
;
506 iscsi_sw_tcp_send_hdr_prep(conn
, task
->hdr
, task
->hdr_len
);
512 iscsi_sw_tcp_send_linear_data_prep(conn
, task
->data
, count
);
514 struct scsi_data_buffer
*sdb
= scsi_out(task
->sc
);
516 err
= iscsi_sw_tcp_send_data_prep(conn
, sdb
->table
.sgl
,
517 sdb
->table
.nents
, offset
,
522 /* got invalid offset/len */
528 static int iscsi_sw_tcp_pdu_alloc(struct iscsi_task
*task
, uint8_t opcode
)
530 struct iscsi_tcp_task
*tcp_task
= task
->dd_data
;
532 task
->hdr
= task
->dd_data
+ sizeof(*tcp_task
);
533 task
->hdr_max
= sizeof(struct iscsi_sw_tcp_hdrbuf
) - ISCSI_DIGEST_SIZE
;
537 static struct iscsi_cls_conn
*
538 iscsi_sw_tcp_conn_create(struct iscsi_cls_session
*cls_session
,
541 struct iscsi_conn
*conn
;
542 struct iscsi_cls_conn
*cls_conn
;
543 struct iscsi_tcp_conn
*tcp_conn
;
544 struct iscsi_sw_tcp_conn
*tcp_sw_conn
;
545 struct crypto_ahash
*tfm
;
547 cls_conn
= iscsi_tcp_conn_setup(cls_session
, sizeof(*tcp_sw_conn
),
551 conn
= cls_conn
->dd_data
;
552 tcp_conn
= conn
->dd_data
;
553 tcp_sw_conn
= tcp_conn
->dd_data
;
555 tfm
= crypto_alloc_ahash("crc32c", 0, CRYPTO_ALG_ASYNC
);
559 tcp_sw_conn
->tx_hash
= ahash_request_alloc(tfm
, GFP_KERNEL
);
560 if (!tcp_sw_conn
->tx_hash
)
562 ahash_request_set_callback(tcp_sw_conn
->tx_hash
, 0, NULL
, NULL
);
564 tcp_sw_conn
->rx_hash
= ahash_request_alloc(tfm
, GFP_KERNEL
);
565 if (!tcp_sw_conn
->rx_hash
)
567 ahash_request_set_callback(tcp_sw_conn
->rx_hash
, 0, NULL
, NULL
);
569 tcp_conn
->rx_hash
= tcp_sw_conn
->rx_hash
;
574 ahash_request_free(tcp_sw_conn
->tx_hash
);
576 crypto_free_ahash(tfm
);
578 iscsi_conn_printk(KERN_ERR
, conn
,
579 "Could not create connection due to crc32c "
580 "loading error. Make sure the crc32c "
581 "module is built as a module or into the "
583 iscsi_tcp_conn_teardown(cls_conn
);
587 static void iscsi_sw_tcp_release_conn(struct iscsi_conn
*conn
)
589 struct iscsi_session
*session
= conn
->session
;
590 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
591 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
592 struct socket
*sock
= tcp_sw_conn
->sock
;
598 iscsi_sw_tcp_conn_restore_callbacks(conn
);
601 spin_lock_bh(&session
->frwd_lock
);
602 tcp_sw_conn
->sock
= NULL
;
603 spin_unlock_bh(&session
->frwd_lock
);
607 static void iscsi_sw_tcp_conn_destroy(struct iscsi_cls_conn
*cls_conn
)
609 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
610 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
611 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
613 iscsi_sw_tcp_release_conn(conn
);
615 ahash_request_free(tcp_sw_conn
->rx_hash
);
616 if (tcp_sw_conn
->tx_hash
) {
617 struct crypto_ahash
*tfm
;
619 tfm
= crypto_ahash_reqtfm(tcp_sw_conn
->tx_hash
);
620 ahash_request_free(tcp_sw_conn
->tx_hash
);
621 crypto_free_ahash(tfm
);
624 iscsi_tcp_conn_teardown(cls_conn
);
627 static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn
*cls_conn
, int flag
)
629 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
630 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
631 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
632 struct socket
*sock
= tcp_sw_conn
->sock
;
634 /* userspace may have goofed up and not bound us */
638 sock
->sk
->sk_err
= EIO
;
639 wake_up_interruptible(sk_sleep(sock
->sk
));
642 iscsi_suspend_tx(conn
);
644 /* stop recv side and release socket */
645 iscsi_sw_tcp_release_conn(conn
);
647 iscsi_conn_stop(cls_conn
, flag
);
651 iscsi_sw_tcp_conn_bind(struct iscsi_cls_session
*cls_session
,
652 struct iscsi_cls_conn
*cls_conn
, uint64_t transport_eph
,
655 struct iscsi_session
*session
= cls_session
->dd_data
;
656 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
657 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
658 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
663 /* lookup for existing socket */
664 sock
= sockfd_lookup((int)transport_eph
, &err
);
666 iscsi_conn_printk(KERN_ERR
, conn
,
667 "sockfd_lookup failed %d\n", err
);
671 err
= iscsi_conn_bind(cls_session
, cls_conn
, is_leading
);
675 spin_lock_bh(&session
->frwd_lock
);
676 /* bind iSCSI connection and socket */
677 tcp_sw_conn
->sock
= sock
;
678 spin_unlock_bh(&session
->frwd_lock
);
680 /* setup Socket parameters */
682 sk
->sk_reuse
= SK_CAN_REUSE
;
683 sk
->sk_sndtimeo
= 15 * HZ
; /* FIXME: make it configurable */
684 sk
->sk_allocation
= GFP_ATOMIC
;
687 iscsi_sw_tcp_conn_set_callbacks(conn
);
688 tcp_sw_conn
->sendpage
= tcp_sw_conn
->sock
->ops
->sendpage
;
690 * set receive state machine into initial state
692 iscsi_tcp_hdr_recv_prep(tcp_conn
);
700 static int iscsi_sw_tcp_conn_set_param(struct iscsi_cls_conn
*cls_conn
,
701 enum iscsi_param param
, char *buf
,
704 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
705 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
706 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
709 case ISCSI_PARAM_HDRDGST_EN
:
710 iscsi_set_param(cls_conn
, param
, buf
, buflen
);
712 case ISCSI_PARAM_DATADGST_EN
:
713 iscsi_set_param(cls_conn
, param
, buf
, buflen
);
714 tcp_sw_conn
->sendpage
= conn
->datadgst_en
?
715 sock_no_sendpage
: tcp_sw_conn
->sock
->ops
->sendpage
;
717 case ISCSI_PARAM_MAX_R2T
:
718 return iscsi_tcp_set_max_r2t(conn
, buf
);
720 return iscsi_set_param(cls_conn
, param
, buf
, buflen
);
726 static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn
*cls_conn
,
727 enum iscsi_param param
, char *buf
)
729 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
730 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
731 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
732 struct sockaddr_in6 addr
;
736 case ISCSI_PARAM_CONN_PORT
:
737 case ISCSI_PARAM_CONN_ADDRESS
:
738 case ISCSI_PARAM_LOCAL_PORT
:
739 spin_lock_bh(&conn
->session
->frwd_lock
);
740 if (!tcp_sw_conn
|| !tcp_sw_conn
->sock
) {
741 spin_unlock_bh(&conn
->session
->frwd_lock
);
744 if (param
== ISCSI_PARAM_LOCAL_PORT
)
745 rc
= kernel_getsockname(tcp_sw_conn
->sock
,
746 (struct sockaddr
*)&addr
, &len
);
748 rc
= kernel_getpeername(tcp_sw_conn
->sock
,
749 (struct sockaddr
*)&addr
, &len
);
750 spin_unlock_bh(&conn
->session
->frwd_lock
);
754 return iscsi_conn_get_addr_param((struct sockaddr_storage
*)
757 return iscsi_conn_get_param(cls_conn
, param
, buf
);
763 static int iscsi_sw_tcp_host_get_param(struct Scsi_Host
*shost
,
764 enum iscsi_host_param param
, char *buf
)
766 struct iscsi_sw_tcp_host
*tcp_sw_host
= iscsi_host_priv(shost
);
767 struct iscsi_session
*session
= tcp_sw_host
->session
;
768 struct iscsi_conn
*conn
;
769 struct iscsi_tcp_conn
*tcp_conn
;
770 struct iscsi_sw_tcp_conn
*tcp_sw_conn
;
771 struct sockaddr_in6 addr
;
775 case ISCSI_HOST_PARAM_IPADDRESS
:
779 spin_lock_bh(&session
->frwd_lock
);
780 conn
= session
->leadconn
;
782 spin_unlock_bh(&session
->frwd_lock
);
785 tcp_conn
= conn
->dd_data
;
787 tcp_sw_conn
= tcp_conn
->dd_data
;
788 if (!tcp_sw_conn
->sock
) {
789 spin_unlock_bh(&session
->frwd_lock
);
793 rc
= kernel_getsockname(tcp_sw_conn
->sock
,
794 (struct sockaddr
*)&addr
, &len
);
795 spin_unlock_bh(&session
->frwd_lock
);
799 return iscsi_conn_get_addr_param((struct sockaddr_storage
*)
802 return iscsi_host_get_param(shost
, param
, buf
);
809 iscsi_sw_tcp_conn_get_stats(struct iscsi_cls_conn
*cls_conn
,
810 struct iscsi_stats
*stats
)
812 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
813 struct iscsi_tcp_conn
*tcp_conn
= conn
->dd_data
;
814 struct iscsi_sw_tcp_conn
*tcp_sw_conn
= tcp_conn
->dd_data
;
816 stats
->custom_length
= 3;
817 strcpy(stats
->custom
[0].desc
, "tx_sendpage_failures");
818 stats
->custom
[0].value
= tcp_sw_conn
->sendpage_failures_cnt
;
819 strcpy(stats
->custom
[1].desc
, "rx_discontiguous_hdr");
820 stats
->custom
[1].value
= tcp_sw_conn
->discontiguous_hdr_cnt
;
821 strcpy(stats
->custom
[2].desc
, "eh_abort_cnt");
822 stats
->custom
[2].value
= conn
->eh_abort_cnt
;
824 iscsi_tcp_conn_get_stats(cls_conn
, stats
);
827 static struct iscsi_cls_session
*
828 iscsi_sw_tcp_session_create(struct iscsi_endpoint
*ep
, uint16_t cmds_max
,
829 uint16_t qdepth
, uint32_t initial_cmdsn
)
831 struct iscsi_cls_session
*cls_session
;
832 struct iscsi_session
*session
;
833 struct iscsi_sw_tcp_host
*tcp_sw_host
;
834 struct Scsi_Host
*shost
;
837 printk(KERN_ERR
"iscsi_tcp: invalid ep %p.\n", ep
);
841 shost
= iscsi_host_alloc(&iscsi_sw_tcp_sht
,
842 sizeof(struct iscsi_sw_tcp_host
), 1);
845 shost
->transportt
= iscsi_sw_tcp_scsi_transport
;
846 shost
->cmd_per_lun
= qdepth
;
847 shost
->max_lun
= iscsi_max_lun
;
849 shost
->max_channel
= 0;
850 shost
->max_cmd_len
= SCSI_MAX_VARLEN_CDB_SIZE
;
852 if (iscsi_host_add(shost
, NULL
))
855 cls_session
= iscsi_session_setup(&iscsi_sw_tcp_transport
, shost
,
857 sizeof(struct iscsi_tcp_task
) +
858 sizeof(struct iscsi_sw_tcp_hdrbuf
),
862 session
= cls_session
->dd_data
;
863 tcp_sw_host
= iscsi_host_priv(shost
);
864 tcp_sw_host
->session
= session
;
866 shost
->can_queue
= session
->scsi_cmds_max
;
867 if (iscsi_tcp_r2tpool_alloc(session
))
872 iscsi_session_teardown(cls_session
);
874 iscsi_host_remove(shost
);
876 iscsi_host_free(shost
);
880 static void iscsi_sw_tcp_session_destroy(struct iscsi_cls_session
*cls_session
)
882 struct Scsi_Host
*shost
= iscsi_session_to_shost(cls_session
);
884 iscsi_tcp_r2tpool_free(cls_session
->dd_data
);
885 iscsi_session_teardown(cls_session
);
887 iscsi_host_remove(shost
);
888 iscsi_host_free(shost
);
891 static umode_t
iscsi_sw_tcp_attr_is_visible(int param_type
, int param
)
893 switch (param_type
) {
894 case ISCSI_HOST_PARAM
:
896 case ISCSI_HOST_PARAM_NETDEV_NAME
:
897 case ISCSI_HOST_PARAM_HWADDRESS
:
898 case ISCSI_HOST_PARAM_IPADDRESS
:
899 case ISCSI_HOST_PARAM_INITIATOR_NAME
:
906 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
907 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
908 case ISCSI_PARAM_HDRDGST_EN
:
909 case ISCSI_PARAM_DATADGST_EN
:
910 case ISCSI_PARAM_CONN_ADDRESS
:
911 case ISCSI_PARAM_CONN_PORT
:
912 case ISCSI_PARAM_LOCAL_PORT
:
913 case ISCSI_PARAM_EXP_STATSN
:
914 case ISCSI_PARAM_PERSISTENT_ADDRESS
:
915 case ISCSI_PARAM_PERSISTENT_PORT
:
916 case ISCSI_PARAM_PING_TMO
:
917 case ISCSI_PARAM_RECV_TMO
:
918 case ISCSI_PARAM_INITIAL_R2T_EN
:
919 case ISCSI_PARAM_MAX_R2T
:
920 case ISCSI_PARAM_IMM_DATA_EN
:
921 case ISCSI_PARAM_FIRST_BURST
:
922 case ISCSI_PARAM_MAX_BURST
:
923 case ISCSI_PARAM_PDU_INORDER_EN
:
924 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
925 case ISCSI_PARAM_ERL
:
926 case ISCSI_PARAM_TARGET_NAME
:
927 case ISCSI_PARAM_TPGT
:
928 case ISCSI_PARAM_USERNAME
:
929 case ISCSI_PARAM_PASSWORD
:
930 case ISCSI_PARAM_USERNAME_IN
:
931 case ISCSI_PARAM_PASSWORD_IN
:
932 case ISCSI_PARAM_FAST_ABORT
:
933 case ISCSI_PARAM_ABORT_TMO
:
934 case ISCSI_PARAM_LU_RESET_TMO
:
935 case ISCSI_PARAM_TGT_RESET_TMO
:
936 case ISCSI_PARAM_IFACE_NAME
:
937 case ISCSI_PARAM_INITIATOR_NAME
:
947 static int iscsi_sw_tcp_slave_alloc(struct scsi_device
*sdev
)
949 set_bit(QUEUE_FLAG_BIDI
, &sdev
->request_queue
->queue_flags
);
953 static int iscsi_sw_tcp_slave_configure(struct scsi_device
*sdev
)
955 blk_queue_bounce_limit(sdev
->request_queue
, BLK_BOUNCE_ANY
);
956 blk_queue_dma_alignment(sdev
->request_queue
, 0);
960 static struct scsi_host_template iscsi_sw_tcp_sht
= {
961 .module
= THIS_MODULE
,
962 .name
= "iSCSI Initiator over TCP/IP",
963 .queuecommand
= iscsi_queuecommand
,
964 .change_queue_depth
= scsi_change_queue_depth
,
965 .can_queue
= ISCSI_DEF_XMIT_CMDS_MAX
- 1,
966 .sg_tablesize
= 4096,
967 .max_sectors
= 0xFFFF,
968 .cmd_per_lun
= ISCSI_DEF_CMD_PER_LUN
,
969 .eh_timed_out
= iscsi_eh_cmd_timed_out
,
970 .eh_abort_handler
= iscsi_eh_abort
,
971 .eh_device_reset_handler
= iscsi_eh_device_reset
,
972 .eh_target_reset_handler
= iscsi_eh_recover_target
,
973 .use_clustering
= DISABLE_CLUSTERING
,
974 .slave_alloc
= iscsi_sw_tcp_slave_alloc
,
975 .slave_configure
= iscsi_sw_tcp_slave_configure
,
976 .target_alloc
= iscsi_target_alloc
,
977 .proc_name
= "iscsi_tcp",
979 .track_queue_depth
= 1,
982 static struct iscsi_transport iscsi_sw_tcp_transport
= {
983 .owner
= THIS_MODULE
,
985 .caps
= CAP_RECOVERY_L0
| CAP_MULTI_R2T
| CAP_HDRDGST
987 /* session management */
988 .create_session
= iscsi_sw_tcp_session_create
,
989 .destroy_session
= iscsi_sw_tcp_session_destroy
,
990 /* connection management */
991 .create_conn
= iscsi_sw_tcp_conn_create
,
992 .bind_conn
= iscsi_sw_tcp_conn_bind
,
993 .destroy_conn
= iscsi_sw_tcp_conn_destroy
,
994 .attr_is_visible
= iscsi_sw_tcp_attr_is_visible
,
995 .set_param
= iscsi_sw_tcp_conn_set_param
,
996 .get_conn_param
= iscsi_sw_tcp_conn_get_param
,
997 .get_session_param
= iscsi_session_get_param
,
998 .start_conn
= iscsi_conn_start
,
999 .stop_conn
= iscsi_sw_tcp_conn_stop
,
1000 /* iscsi host params */
1001 .get_host_param
= iscsi_sw_tcp_host_get_param
,
1002 .set_host_param
= iscsi_host_set_param
,
1004 .send_pdu
= iscsi_conn_send_pdu
,
1005 .get_stats
= iscsi_sw_tcp_conn_get_stats
,
1006 /* iscsi task/cmd helpers */
1007 .init_task
= iscsi_tcp_task_init
,
1008 .xmit_task
= iscsi_tcp_task_xmit
,
1009 .cleanup_task
= iscsi_tcp_cleanup_task
,
1010 /* low level pdu helpers */
1011 .xmit_pdu
= iscsi_sw_tcp_pdu_xmit
,
1012 .init_pdu
= iscsi_sw_tcp_pdu_init
,
1013 .alloc_pdu
= iscsi_sw_tcp_pdu_alloc
,
1015 .session_recovery_timedout
= iscsi_session_recovery_timedout
,
1018 static int __init
iscsi_sw_tcp_init(void)
1020 if (iscsi_max_lun
< 1) {
1021 printk(KERN_ERR
"iscsi_tcp: Invalid max_lun value of %u\n",
1026 iscsi_sw_tcp_scsi_transport
= iscsi_register_transport(
1027 &iscsi_sw_tcp_transport
);
1028 if (!iscsi_sw_tcp_scsi_transport
)
1034 static void __exit
iscsi_sw_tcp_exit(void)
1036 iscsi_unregister_transport(&iscsi_sw_tcp_transport
);
1039 module_init(iscsi_sw_tcp_init
);
1040 module_exit(iscsi_sw_tcp_exit
);