1/* 2 * iSCSI Initiator over TCP/IP Data-Path 3 * 4 * Copyright (C) 2004 Dmitry Yusupov 5 * Copyright (C) 2004 Alex Aizman 6 * Copyright (C) 2005 - 2006 Mike Christie 7 * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 8 * maintained by open-iscsi@googlegroups.com 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published 12 * by the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * See the file COPYING included with this distribution for more details. 21 * 22 * Credits: 23 * Christoph Hellwig 24 * FUJITA Tomonori 25 * Arne Redlich 26 * Zhenyu Wang 27 */ 28 29#include <linux/types.h> 30#include <linux/inet.h> 31#include <linux/slab.h> 32#include <linux/file.h> 33#include <linux/blkdev.h> 34#include <linux/crypto.h> 35#include <linux/delay.h> 36#include <linux/kfifo.h> 37#include <linux/scatterlist.h> 38#include <net/tcp.h> 39#include <scsi/scsi_cmnd.h> 40#include <scsi/scsi_device.h> 41#include <scsi/scsi_host.h> 42#include <scsi/scsi.h> 43#include <scsi/scsi_transport_iscsi.h> 44 45#include "iscsi_tcp.h" 46 47MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, " 48 "Dmitry Yusupov <dmitry_yus@yahoo.com>, " 49 "Alex Aizman <itn780@yahoo.com>"); 50MODULE_DESCRIPTION("iSCSI/TCP data-path"); 51MODULE_LICENSE("GPL"); 52 53static struct scsi_transport_template *iscsi_sw_tcp_scsi_transport; 54static struct scsi_host_template iscsi_sw_tcp_sht; 55static struct iscsi_transport iscsi_sw_tcp_transport; 56 57static unsigned int iscsi_max_lun = 512; 58module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO); 59 60static int iscsi_sw_tcp_dbg; 61module_param_named(debug_iscsi_tcp, iscsi_sw_tcp_dbg, int, 62 S_IRUGO | S_IWUSR); 63MODULE_PARM_DESC(debug_iscsi_tcp, "Turn on debugging for iscsi_tcp module " 64 "Set to 1 to turn on, and zero to turn off. Default is off."); 65 66#define ISCSI_SW_TCP_DBG(_conn, dbg_fmt, arg...) \ 67 do { \ 68 if (iscsi_sw_tcp_dbg) \ 69 iscsi_conn_printk(KERN_INFO, _conn, \ 70 "%s " dbg_fmt, \ 71 __func__, ##arg); \ 72 } while (0); 73 74 75/** 76 * iscsi_sw_tcp_recv - TCP receive in sendfile fashion 77 * @rd_desc: read descriptor 78 * @skb: socket buffer 79 * @offset: offset in skb 80 * @len: skb->len - offset 81 */ 82static int iscsi_sw_tcp_recv(read_descriptor_t *rd_desc, struct sk_buff *skb, 83 unsigned int offset, size_t len) 84{ 85 struct iscsi_conn *conn = rd_desc->arg.data; 86 unsigned int consumed, total_consumed = 0; 87 int status; 88 89 ISCSI_SW_TCP_DBG(conn, "in %d bytes\n", skb->len - offset); 90 91 do { 92 status = 0; 93 consumed = iscsi_tcp_recv_skb(conn, skb, offset, 0, &status); 94 offset += consumed; 95 total_consumed += consumed; 96 } while (consumed != 0 && status != ISCSI_TCP_SKB_DONE); 97 98 ISCSI_SW_TCP_DBG(conn, "read %d bytes status %d\n", 99 skb->len - offset, status); 100 return total_consumed; 101} 102 103/** 104 * iscsi_sw_sk_state_check - check socket state 105 * @sk: socket 106 * 107 * If the socket is in CLOSE or CLOSE_WAIT we should 108 * not close the connection if there is still some 109 * data pending. 110 */ 111static inline int iscsi_sw_sk_state_check(struct sock *sk) 112{ 113 struct iscsi_conn *conn = (struct iscsi_conn*)sk->sk_user_data; 114 115 if ((sk->sk_state == TCP_CLOSE_WAIT || sk->sk_state == TCP_CLOSE) && 116 !atomic_read(&sk->sk_rmem_alloc)) { 117 ISCSI_SW_TCP_DBG(conn, "TCP_CLOSE|TCP_CLOSE_WAIT\n"); 118 iscsi_conn_failure(conn, ISCSI_ERR_TCP_CONN_CLOSE); 119 return -ECONNRESET; 120 } 121 return 0; 122} 123 124static void iscsi_sw_tcp_data_ready(struct sock *sk, int flag) 125{ 126 struct iscsi_conn *conn = sk->sk_user_data; 127 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 128 read_descriptor_t rd_desc; 129 130 read_lock(&sk->sk_callback_lock); 131 132 /* 133 * Use rd_desc to pass 'conn' to iscsi_tcp_recv. 134 * We set count to 1 because we want the network layer to 135 * hand us all the skbs that are available. iscsi_tcp_recv 136 * handled pdus that cross buffers or pdus that still need data. 137 */ 138 rd_desc.arg.data = conn; 139 rd_desc.count = 1; 140 tcp_read_sock(sk, &rd_desc, iscsi_sw_tcp_recv); 141 142 iscsi_sw_sk_state_check(sk); 143 144 read_unlock(&sk->sk_callback_lock); 145 146 /* If we had to (atomically) map a highmem page, 147 * unmap it now. */ 148 iscsi_tcp_segment_unmap(&tcp_conn->in.segment); 149} 150 151static void iscsi_sw_tcp_state_change(struct sock *sk) 152{ 153 struct iscsi_tcp_conn *tcp_conn; 154 struct iscsi_sw_tcp_conn *tcp_sw_conn; 155 struct iscsi_conn *conn; 156 struct iscsi_session *session; 157 void (*old_state_change)(struct sock *); 158 159 read_lock(&sk->sk_callback_lock); 160 161 conn = (struct iscsi_conn*)sk->sk_user_data; 162 session = conn->session; 163 164 iscsi_sw_sk_state_check(sk); 165 166 tcp_conn = conn->dd_data; 167 tcp_sw_conn = tcp_conn->dd_data; 168 old_state_change = tcp_sw_conn->old_state_change; 169 170 read_unlock(&sk->sk_callback_lock); 171 172 old_state_change(sk); 173} 174 175/** 176 * iscsi_write_space - Called when more output buffer space is available 177 * @sk: socket space is available for 178 **/ 179static void iscsi_sw_tcp_write_space(struct sock *sk) 180{ 181 struct iscsi_conn *conn = (struct iscsi_conn*)sk->sk_user_data; 182 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 183 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 184 185 tcp_sw_conn->old_write_space(sk); 186 ISCSI_SW_TCP_DBG(conn, "iscsi_write_space\n"); 187 iscsi_conn_queue_work(conn); 188} 189 190static void iscsi_sw_tcp_conn_set_callbacks(struct iscsi_conn *conn) 191{ 192 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 193 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 194 struct sock *sk = tcp_sw_conn->sock->sk; 195 196 /* assign new callbacks */ 197 write_lock_bh(&sk->sk_callback_lock); 198 sk->sk_user_data = conn; 199 tcp_sw_conn->old_data_ready = sk->sk_data_ready; 200 tcp_sw_conn->old_state_change = sk->sk_state_change; 201 tcp_sw_conn->old_write_space = sk->sk_write_space; 202 sk->sk_data_ready = iscsi_sw_tcp_data_ready; 203 sk->sk_state_change = iscsi_sw_tcp_state_change; 204 sk->sk_write_space = iscsi_sw_tcp_write_space; 205 write_unlock_bh(&sk->sk_callback_lock); 206} 207 208static void 209iscsi_sw_tcp_conn_restore_callbacks(struct iscsi_conn *conn) 210{ 211 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 212 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 213 struct sock *sk = tcp_sw_conn->sock->sk; 214 215 /* restore socket callbacks, see also: iscsi_conn_set_callbacks() */ 216 write_lock_bh(&sk->sk_callback_lock); 217 sk->sk_user_data = NULL; 218 sk->sk_data_ready = tcp_sw_conn->old_data_ready; 219 sk->sk_state_change = tcp_sw_conn->old_state_change; 220 sk->sk_write_space = tcp_sw_conn->old_write_space; 221 sk->sk_no_check = 0; 222 write_unlock_bh(&sk->sk_callback_lock); 223} 224 225/** 226 * iscsi_sw_tcp_xmit_segment - transmit segment 227 * @tcp_conn: the iSCSI TCP connection 228 * @segment: the buffer to transmnit 229 * 230 * This function transmits as much of the buffer as 231 * the network layer will accept, and returns the number of 232 * bytes transmitted. 233 * 234 * If CRC hashing is enabled, the function will compute the 235 * hash as it goes. When the entire segment has been transmitted, 236 * it will retrieve the hash value and send it as well. 237 */ 238static int iscsi_sw_tcp_xmit_segment(struct iscsi_tcp_conn *tcp_conn, 239 struct iscsi_segment *segment) 240{ 241 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 242 struct socket *sk = tcp_sw_conn->sock; 243 unsigned int copied = 0; 244 int r = 0; 245 246 while (!iscsi_tcp_segment_done(tcp_conn, segment, 0, r)) { 247 struct scatterlist *sg; 248 unsigned int offset, copy; 249 int flags = 0; 250 251 r = 0; 252 offset = segment->copied; 253 copy = segment->size - offset; 254 255 if (segment->total_copied + segment->size < segment->total_size) 256 flags |= MSG_MORE; 257 258 /* Use sendpage if we can; else fall back to sendmsg */ 259 if (!segment->data) { 260 sg = segment->sg; 261 offset += segment->sg_offset + sg->offset; 262 r = tcp_sw_conn->sendpage(sk, sg_page(sg), offset, 263 copy, flags); 264 } else { 265 struct msghdr msg = { .msg_flags = flags }; 266 struct kvec iov = { 267 .iov_base = segment->data + offset, 268 .iov_len = copy 269 }; 270 271 r = kernel_sendmsg(sk, &msg, &iov, 1, copy); 272 } 273 274 if (r < 0) { 275 iscsi_tcp_segment_unmap(segment); 276 return r; 277 } 278 copied += r; 279 } 280 return copied; 281} 282 283/** 284 * iscsi_sw_tcp_xmit - TCP transmit 285 **/ 286static int iscsi_sw_tcp_xmit(struct iscsi_conn *conn) 287{ 288 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 289 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 290 struct iscsi_segment *segment = &tcp_sw_conn->out.segment; 291 unsigned int consumed = 0; 292 int rc = 0; 293 294 while (1) { 295 rc = iscsi_sw_tcp_xmit_segment(tcp_conn, segment); 296 /* 297 * We may not have been able to send data because the conn 298 * is getting stopped. libiscsi will know so propogate err 299 * for it to do the right thing. 300 */ 301 if (rc == -EAGAIN) 302 return rc; 303 else if (rc < 0) { 304 rc = ISCSI_ERR_XMIT_FAILED; 305 goto error; 306 } else if (rc == 0) 307 break; 308 309 consumed += rc; 310 311 if (segment->total_copied >= segment->total_size) { 312 if (segment->done != NULL) { 313 rc = segment->done(tcp_conn, segment); 314 if (rc != 0) 315 goto error; 316 } 317 } 318 } 319 320 ISCSI_SW_TCP_DBG(conn, "xmit %d bytes\n", consumed); 321 322 conn->txdata_octets += consumed; 323 return consumed; 324 325error: 326 /* Transmit error. We could initiate error recovery 327 * here. */ 328 ISCSI_SW_TCP_DBG(conn, "Error sending PDU, errno=%d\n", rc); 329 iscsi_conn_failure(conn, rc); 330 return -EIO; 331} 332 333/** 334 * iscsi_tcp_xmit_qlen - return the number of bytes queued for xmit 335 */ 336static inline int iscsi_sw_tcp_xmit_qlen(struct iscsi_conn *conn) 337{ 338 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 339 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 340 struct iscsi_segment *segment = &tcp_sw_conn->out.segment; 341 342 return segment->total_copied - segment->total_size; 343} 344 345static int iscsi_sw_tcp_pdu_xmit(struct iscsi_task *task) 346{ 347 struct iscsi_conn *conn = task->conn; 348 int rc; 349 350 while (iscsi_sw_tcp_xmit_qlen(conn)) { 351 rc = iscsi_sw_tcp_xmit(conn); 352 if (rc == 0) 353 return -EAGAIN; 354 if (rc < 0) 355 return rc; 356 } 357 358 return 0; 359} 360 361/* 362 * This is called when we're done sending the header. 363 * Simply copy the data_segment to the send segment, and return. 364 */ 365static int iscsi_sw_tcp_send_hdr_done(struct iscsi_tcp_conn *tcp_conn, 366 struct iscsi_segment *segment) 367{ 368 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 369 370 tcp_sw_conn->out.segment = tcp_sw_conn->out.data_segment; 371 ISCSI_SW_TCP_DBG(tcp_conn->iscsi_conn, 372 "Header done. Next segment size %u total_size %u\n", 373 tcp_sw_conn->out.segment.size, 374 tcp_sw_conn->out.segment.total_size); 375 return 0; 376} 377 378static void iscsi_sw_tcp_send_hdr_prep(struct iscsi_conn *conn, void *hdr, 379 size_t hdrlen) 380{ 381 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 382 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 383 384 ISCSI_SW_TCP_DBG(conn, "%s\n", conn->hdrdgst_en ? 385 "digest enabled" : "digest disabled"); 386 387 /* Clear the data segment - needs to be filled in by the 388 * caller using iscsi_tcp_send_data_prep() */ 389 memset(&tcp_sw_conn->out.data_segment, 0, 390 sizeof(struct iscsi_segment)); 391 392 /* If header digest is enabled, compute the CRC and 393 * place the digest into the same buffer. We make 394 * sure that both iscsi_tcp_task and mtask have 395 * sufficient room. 396 */ 397 if (conn->hdrdgst_en) { 398 iscsi_tcp_dgst_header(&tcp_sw_conn->tx_hash, hdr, hdrlen, 399 hdr + hdrlen); 400 hdrlen += ISCSI_DIGEST_SIZE; 401 } 402 403 /* Remember header pointer for later, when we need 404 * to decide whether there's a payload to go along 405 * with the header. */ 406 tcp_sw_conn->out.hdr = hdr; 407 408 iscsi_segment_init_linear(&tcp_sw_conn->out.segment, hdr, hdrlen, 409 iscsi_sw_tcp_send_hdr_done, NULL); 410} 411 412/* 413 * Prepare the send buffer for the payload data. 414 * Padding and checksumming will all be taken care 415 * of by the iscsi_segment routines. 416 */ 417static int 418iscsi_sw_tcp_send_data_prep(struct iscsi_conn *conn, struct scatterlist *sg, 419 unsigned int count, unsigned int offset, 420 unsigned int len) 421{ 422 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 423 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 424 struct hash_desc *tx_hash = NULL; 425 unsigned int hdr_spec_len; 426 427 ISCSI_SW_TCP_DBG(conn, "offset=%d, datalen=%d %s\n", offset, len, 428 conn->datadgst_en ? 429 "digest enabled" : "digest disabled"); 430 431 /* Make sure the datalen matches what the caller 432 said he would send. */ 433 hdr_spec_len = ntoh24(tcp_sw_conn->out.hdr->dlength); 434 WARN_ON(iscsi_padded(len) != iscsi_padded(hdr_spec_len)); 435 436 if (conn->datadgst_en) 437 tx_hash = &tcp_sw_conn->tx_hash; 438 439 return iscsi_segment_seek_sg(&tcp_sw_conn->out.data_segment, 440 sg, count, offset, len, 441 NULL, tx_hash); 442} 443 444static void 445iscsi_sw_tcp_send_linear_data_prep(struct iscsi_conn *conn, void *data, 446 size_t len) 447{ 448 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 449 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 450 struct hash_desc *tx_hash = NULL; 451 unsigned int hdr_spec_len; 452 453 ISCSI_SW_TCP_DBG(conn, "datalen=%zd %s\n", len, conn->datadgst_en ? 454 "digest enabled" : "digest disabled"); 455 456 /* Make sure the datalen matches what the caller 457 said he would send. */ 458 hdr_spec_len = ntoh24(tcp_sw_conn->out.hdr->dlength); 459 WARN_ON(iscsi_padded(len) != iscsi_padded(hdr_spec_len)); 460 461 if (conn->datadgst_en) 462 tx_hash = &tcp_sw_conn->tx_hash; 463 464 iscsi_segment_init_linear(&tcp_sw_conn->out.data_segment, 465 data, len, NULL, tx_hash); 466} 467 468static int iscsi_sw_tcp_pdu_init(struct iscsi_task *task, 469 unsigned int offset, unsigned int count) 470{ 471 struct iscsi_conn *conn = task->conn; 472 int err = 0; 473 474 iscsi_sw_tcp_send_hdr_prep(conn, task->hdr, task->hdr_len); 475 476 if (!count) 477 return 0; 478 479 if (!task->sc) 480 iscsi_sw_tcp_send_linear_data_prep(conn, task->data, count); 481 else { 482 struct scsi_data_buffer *sdb = scsi_out(task->sc); 483 484 err = iscsi_sw_tcp_send_data_prep(conn, sdb->table.sgl, 485 sdb->table.nents, offset, 486 count); 487 } 488 489 if (err) { 490 /* got invalid offset/len */ 491 return -EIO; 492 } 493 return 0; 494} 495 496static int iscsi_sw_tcp_pdu_alloc(struct iscsi_task *task, uint8_t opcode) 497{ 498 struct iscsi_tcp_task *tcp_task = task->dd_data; 499 500 task->hdr = task->dd_data + sizeof(*tcp_task); 501 task->hdr_max = sizeof(struct iscsi_sw_tcp_hdrbuf) - ISCSI_DIGEST_SIZE; 502 return 0; 503} 504 505static struct iscsi_cls_conn * 506iscsi_sw_tcp_conn_create(struct iscsi_cls_session *cls_session, 507 uint32_t conn_idx) 508{ 509 struct iscsi_conn *conn; 510 struct iscsi_cls_conn *cls_conn; 511 struct iscsi_tcp_conn *tcp_conn; 512 struct iscsi_sw_tcp_conn *tcp_sw_conn; 513 514 cls_conn = iscsi_tcp_conn_setup(cls_session, sizeof(*tcp_sw_conn), 515 conn_idx); 516 if (!cls_conn) 517 return NULL; 518 conn = cls_conn->dd_data; 519 tcp_conn = conn->dd_data; 520 tcp_sw_conn = tcp_conn->dd_data; 521 522 tcp_sw_conn->tx_hash.tfm = crypto_alloc_hash("crc32c", 0, 523 CRYPTO_ALG_ASYNC); 524 tcp_sw_conn->tx_hash.flags = 0; 525 if (IS_ERR(tcp_sw_conn->tx_hash.tfm)) 526 goto free_conn; 527 528 tcp_sw_conn->rx_hash.tfm = crypto_alloc_hash("crc32c", 0, 529 CRYPTO_ALG_ASYNC); 530 tcp_sw_conn->rx_hash.flags = 0; 531 if (IS_ERR(tcp_sw_conn->rx_hash.tfm)) 532 goto free_tx_tfm; 533 tcp_conn->rx_hash = &tcp_sw_conn->rx_hash; 534 535 return cls_conn; 536 537free_tx_tfm: 538 crypto_free_hash(tcp_sw_conn->tx_hash.tfm); 539free_conn: 540 iscsi_conn_printk(KERN_ERR, conn, 541 "Could not create connection due to crc32c " 542 "loading error. Make sure the crc32c " 543 "module is built as a module or into the " 544 "kernel\n"); 545 iscsi_tcp_conn_teardown(cls_conn); 546 return NULL; 547} 548 549static void iscsi_sw_tcp_release_conn(struct iscsi_conn *conn) 550{ 551 struct iscsi_session *session = conn->session; 552 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 553 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 554 struct socket *sock = tcp_sw_conn->sock; 555 556 if (!sock) 557 return; 558 559 sock_hold(sock->sk); 560 iscsi_sw_tcp_conn_restore_callbacks(conn); 561 sock_put(sock->sk); 562 563 spin_lock_bh(&session->lock); 564 tcp_sw_conn->sock = NULL; 565 spin_unlock_bh(&session->lock); 566 sockfd_put(sock); 567} 568 569static void iscsi_sw_tcp_conn_destroy(struct iscsi_cls_conn *cls_conn) 570{ 571 struct iscsi_conn *conn = cls_conn->dd_data; 572 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 573 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 574 575 iscsi_sw_tcp_release_conn(conn); 576 577 if (tcp_sw_conn->tx_hash.tfm) 578 crypto_free_hash(tcp_sw_conn->tx_hash.tfm); 579 if (tcp_sw_conn->rx_hash.tfm) 580 crypto_free_hash(tcp_sw_conn->rx_hash.tfm); 581 582 iscsi_tcp_conn_teardown(cls_conn); 583} 584 585static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 586{ 587 struct iscsi_conn *conn = cls_conn->dd_data; 588 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 589 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 590 struct socket *sock = tcp_sw_conn->sock; 591 592 /* userspace may have goofed up and not bound us */ 593 if (!sock) 594 return; 595 /* 596 * Make sure our recv side is stopped. 597 * Older tools called conn stop before ep_disconnect 598 * so IO could still be coming in. 599 */ 600 write_lock_bh(&tcp_sw_conn->sock->sk->sk_callback_lock); 601 set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 602 write_unlock_bh(&tcp_sw_conn->sock->sk->sk_callback_lock); 603 604 sock->sk->sk_err = EIO; 605 wake_up_interruptible(sk_sleep(sock->sk)); 606 607 iscsi_conn_stop(cls_conn, flag); 608 iscsi_sw_tcp_release_conn(conn); 609} 610 611static int iscsi_sw_tcp_get_addr(struct iscsi_conn *conn, struct socket *sock, 612 char *buf, int *port, 613 int (*getname)(struct socket *, 614 struct sockaddr *, 615 int *addrlen)) 616{ 617 struct sockaddr_storage *addr; 618 struct sockaddr_in6 *sin6; 619 struct sockaddr_in *sin; 620 int rc = 0, len; 621 622 addr = kmalloc(sizeof(*addr), GFP_KERNEL); 623 if (!addr) 624 return -ENOMEM; 625 626 if (getname(sock, (struct sockaddr *) addr, &len)) { 627 rc = -ENODEV; 628 goto free_addr; 629 } 630 631 switch (addr->ss_family) { 632 case AF_INET: 633 sin = (struct sockaddr_in *)addr; 634 spin_lock_bh(&conn->session->lock); 635 sprintf(buf, "%pI4", &sin->sin_addr.s_addr); 636 *port = be16_to_cpu(sin->sin_port); 637 spin_unlock_bh(&conn->session->lock); 638 break; 639 case AF_INET6: 640 sin6 = (struct sockaddr_in6 *)addr; 641 spin_lock_bh(&conn->session->lock); 642 sprintf(buf, "%pI6", &sin6->sin6_addr); 643 *port = be16_to_cpu(sin6->sin6_port); 644 spin_unlock_bh(&conn->session->lock); 645 break; 646 } 647free_addr: 648 kfree(addr); 649 return rc; 650} 651 652static int 653iscsi_sw_tcp_conn_bind(struct iscsi_cls_session *cls_session, 654 struct iscsi_cls_conn *cls_conn, uint64_t transport_eph, 655 int is_leading) 656{ 657 struct Scsi_Host *shost = iscsi_session_to_shost(cls_session); 658 struct iscsi_host *ihost = shost_priv(shost); 659 struct iscsi_conn *conn = cls_conn->dd_data; 660 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 661 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 662 struct sock *sk; 663 struct socket *sock; 664 int err; 665 666 /* lookup for existing socket */ 667 sock = sockfd_lookup((int)transport_eph, &err); 668 if (!sock) { 669 iscsi_conn_printk(KERN_ERR, conn, 670 "sockfd_lookup failed %d\n", err); 671 return -EEXIST; 672 } 673 /* 674 * copy these values now because if we drop the session 675 * userspace may still want to query the values since we will 676 * be using them for the reconnect 677 */ 678 err = iscsi_sw_tcp_get_addr(conn, sock, conn->portal_address, 679 &conn->portal_port, kernel_getpeername); 680 if (err) 681 goto free_socket; 682 683 err = iscsi_sw_tcp_get_addr(conn, sock, ihost->local_address, 684 &ihost->local_port, kernel_getsockname); 685 if (err) 686 goto free_socket; 687 688 err = iscsi_conn_bind(cls_session, cls_conn, is_leading); 689 if (err) 690 goto free_socket; 691 692 /* bind iSCSI connection and socket */ 693 tcp_sw_conn->sock = sock; 694 695 /* setup Socket parameters */ 696 sk = sock->sk; 697 sk->sk_reuse = 1; 698 sk->sk_sndtimeo = 15 * HZ; 699 sk->sk_allocation = GFP_ATOMIC; 700 701 iscsi_sw_tcp_conn_set_callbacks(conn); 702 tcp_sw_conn->sendpage = tcp_sw_conn->sock->ops->sendpage; 703 /* 704 * set receive state machine into initial state 705 */ 706 iscsi_tcp_hdr_recv_prep(tcp_conn); 707 return 0; 708 709free_socket: 710 sockfd_put(sock); 711 return err; 712} 713 714static int iscsi_sw_tcp_conn_set_param(struct iscsi_cls_conn *cls_conn, 715 enum iscsi_param param, char *buf, 716 int buflen) 717{ 718 struct iscsi_conn *conn = cls_conn->dd_data; 719 struct iscsi_session *session = conn->session; 720 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 721 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 722 int value; 723 724 switch(param) { 725 case ISCSI_PARAM_HDRDGST_EN: 726 iscsi_set_param(cls_conn, param, buf, buflen); 727 break; 728 case ISCSI_PARAM_DATADGST_EN: 729 iscsi_set_param(cls_conn, param, buf, buflen); 730 tcp_sw_conn->sendpage = conn->datadgst_en ? 731 sock_no_sendpage : tcp_sw_conn->sock->ops->sendpage; 732 break; 733 case ISCSI_PARAM_MAX_R2T: 734 sscanf(buf, "%d", &value); 735 if (value <= 0 || !is_power_of_2(value)) 736 return -EINVAL; 737 if (session->max_r2t == value) 738 break; 739 iscsi_tcp_r2tpool_free(session); 740 iscsi_set_param(cls_conn, param, buf, buflen); 741 if (iscsi_tcp_r2tpool_alloc(session)) 742 return -ENOMEM; 743 break; 744 default: 745 return iscsi_set_param(cls_conn, param, buf, buflen); 746 } 747 748 return 0; 749} 750 751static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn, 752 enum iscsi_param param, char *buf) 753{ 754 struct iscsi_conn *conn = cls_conn->dd_data; 755 int len; 756 757 switch(param) { 758 case ISCSI_PARAM_CONN_PORT: 759 spin_lock_bh(&conn->session->lock); 760 len = sprintf(buf, "%hu\n", conn->portal_port); 761 spin_unlock_bh(&conn->session->lock); 762 break; 763 case ISCSI_PARAM_CONN_ADDRESS: 764 spin_lock_bh(&conn->session->lock); 765 len = sprintf(buf, "%s\n", conn->portal_address); 766 spin_unlock_bh(&conn->session->lock); 767 break; 768 default: 769 return iscsi_conn_get_param(cls_conn, param, buf); 770 } 771 772 return len; 773} 774 775static void 776iscsi_sw_tcp_conn_get_stats(struct iscsi_cls_conn *cls_conn, 777 struct iscsi_stats *stats) 778{ 779 struct iscsi_conn *conn = cls_conn->dd_data; 780 struct iscsi_tcp_conn *tcp_conn = conn->dd_data; 781 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data; 782 783 stats->custom_length = 3; 784 strcpy(stats->custom[0].desc, "tx_sendpage_failures"); 785 stats->custom[0].value = tcp_sw_conn->sendpage_failures_cnt; 786 strcpy(stats->custom[1].desc, "rx_discontiguous_hdr"); 787 stats->custom[1].value = tcp_sw_conn->discontiguous_hdr_cnt; 788 strcpy(stats->custom[2].desc, "eh_abort_cnt"); 789 stats->custom[2].value = conn->eh_abort_cnt; 790 791 iscsi_tcp_conn_get_stats(cls_conn, stats); 792} 793 794static struct iscsi_cls_session * 795iscsi_sw_tcp_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max, 796 uint16_t qdepth, uint32_t initial_cmdsn) 797{ 798 struct iscsi_cls_session *cls_session; 799 struct iscsi_session *session; 800 struct Scsi_Host *shost; 801 802 if (ep) { 803 printk(KERN_ERR "iscsi_tcp: invalid ep %p.\n", ep); 804 return NULL; 805 } 806 807 shost = iscsi_host_alloc(&iscsi_sw_tcp_sht, 0, 1); 808 if (!shost) 809 return NULL; 810 shost->transportt = iscsi_sw_tcp_scsi_transport; 811 shost->cmd_per_lun = qdepth; 812 shost->max_lun = iscsi_max_lun; 813 shost->max_id = 0; 814 shost->max_channel = 0; 815 shost->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE; 816 817 if (iscsi_host_add(shost, NULL)) 818 goto free_host; 819 820 cls_session = iscsi_session_setup(&iscsi_sw_tcp_transport, shost, 821 cmds_max, 0, 822 sizeof(struct iscsi_tcp_task) + 823 sizeof(struct iscsi_sw_tcp_hdrbuf), 824 initial_cmdsn, 0); 825 if (!cls_session) 826 goto remove_host; 827 session = cls_session->dd_data; 828 829 shost->can_queue = session->scsi_cmds_max; 830 if (iscsi_tcp_r2tpool_alloc(session)) 831 goto remove_session; 832 return cls_session; 833 834remove_session: 835 iscsi_session_teardown(cls_session); 836remove_host: 837 iscsi_host_remove(shost); 838free_host: 839 iscsi_host_free(shost); 840 return NULL; 841} 842 843static void iscsi_sw_tcp_session_destroy(struct iscsi_cls_session *cls_session) 844{ 845 struct Scsi_Host *shost = iscsi_session_to_shost(cls_session); 846 847 iscsi_tcp_r2tpool_free(cls_session->dd_data); 848 iscsi_session_teardown(cls_session); 849 850 iscsi_host_remove(shost); 851 iscsi_host_free(shost); 852} 853 854static int iscsi_sw_tcp_slave_alloc(struct scsi_device *sdev) 855{ 856 set_bit(QUEUE_FLAG_BIDI, &sdev->request_queue->queue_flags); 857 return 0; 858} 859 860static int iscsi_sw_tcp_slave_configure(struct scsi_device *sdev) 861{ 862 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_ANY); 863 blk_queue_dma_alignment(sdev->request_queue, 0); 864 return 0; 865} 866 867static struct scsi_host_template iscsi_sw_tcp_sht = { 868 .module = THIS_MODULE, 869 .name = "iSCSI Initiator over TCP/IP", 870 .queuecommand = iscsi_queuecommand, 871 .change_queue_depth = iscsi_change_queue_depth, 872 .can_queue = ISCSI_DEF_XMIT_CMDS_MAX - 1, 873 .sg_tablesize = 4096, 874 .max_sectors = 0xFFFF, 875 .cmd_per_lun = ISCSI_DEF_CMD_PER_LUN, 876 .eh_abort_handler = iscsi_eh_abort, 877 .eh_device_reset_handler= iscsi_eh_device_reset, 878 .eh_target_reset_handler = iscsi_eh_recover_target, 879 .use_clustering = DISABLE_CLUSTERING, 880 .slave_alloc = iscsi_sw_tcp_slave_alloc, 881 .slave_configure = iscsi_sw_tcp_slave_configure, 882 .target_alloc = iscsi_target_alloc, 883 .proc_name = "iscsi_tcp", 884 .this_id = -1, 885}; 886 887static struct iscsi_transport iscsi_sw_tcp_transport = { 888 .owner = THIS_MODULE, 889 .name = "tcp", 890 .caps = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST 891 | CAP_DATADGST, 892 .param_mask = ISCSI_MAX_RECV_DLENGTH | 893 ISCSI_MAX_XMIT_DLENGTH | 894 ISCSI_HDRDGST_EN | 895 ISCSI_DATADGST_EN | 896 ISCSI_INITIAL_R2T_EN | 897 ISCSI_MAX_R2T | 898 ISCSI_IMM_DATA_EN | 899 ISCSI_FIRST_BURST | 900 ISCSI_MAX_BURST | 901 ISCSI_PDU_INORDER_EN | 902 ISCSI_DATASEQ_INORDER_EN | 903 ISCSI_ERL | 904 ISCSI_CONN_PORT | 905 ISCSI_CONN_ADDRESS | 906 ISCSI_EXP_STATSN | 907 ISCSI_PERSISTENT_PORT | 908 ISCSI_PERSISTENT_ADDRESS | 909 ISCSI_TARGET_NAME | ISCSI_TPGT | 910 ISCSI_USERNAME | ISCSI_PASSWORD | 911 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN | 912 ISCSI_FAST_ABORT | ISCSI_ABORT_TMO | 913 ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO | 914 ISCSI_PING_TMO | ISCSI_RECV_TMO | 915 ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME, 916 .host_param_mask = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS | 917 ISCSI_HOST_INITIATOR_NAME | 918 ISCSI_HOST_NETDEV_NAME, 919 /* session management */ 920 .create_session = iscsi_sw_tcp_session_create, 921 .destroy_session = iscsi_sw_tcp_session_destroy, 922 /* connection management */ 923 .create_conn = iscsi_sw_tcp_conn_create, 924 .bind_conn = iscsi_sw_tcp_conn_bind, 925 .destroy_conn = iscsi_sw_tcp_conn_destroy, 926 .set_param = iscsi_sw_tcp_conn_set_param, 927 .get_conn_param = iscsi_sw_tcp_conn_get_param, 928 .get_session_param = iscsi_session_get_param, 929 .start_conn = iscsi_conn_start, 930 .stop_conn = iscsi_sw_tcp_conn_stop, 931 /* iscsi host params */ 932 .get_host_param = iscsi_host_get_param, 933 .set_host_param = iscsi_host_set_param, 934 /* IO */ 935 .send_pdu = iscsi_conn_send_pdu, 936 .get_stats = iscsi_sw_tcp_conn_get_stats, 937 /* iscsi task/cmd helpers */ 938 .init_task = iscsi_tcp_task_init, 939 .xmit_task = iscsi_tcp_task_xmit, 940 .cleanup_task = iscsi_tcp_cleanup_task, 941 /* low level pdu helpers */ 942 .xmit_pdu = iscsi_sw_tcp_pdu_xmit, 943 .init_pdu = iscsi_sw_tcp_pdu_init, 944 .alloc_pdu = iscsi_sw_tcp_pdu_alloc, 945 /* recovery */ 946 .session_recovery_timedout = iscsi_session_recovery_timedout, 947}; 948 949static int __init iscsi_sw_tcp_init(void) 950{ 951 if (iscsi_max_lun < 1) { 952 printk(KERN_ERR "iscsi_tcp: Invalid max_lun value of %u\n", 953 iscsi_max_lun); 954 return -EINVAL; 955 } 956 957 iscsi_sw_tcp_scsi_transport = iscsi_register_transport( 958 &iscsi_sw_tcp_transport); 959 if (!iscsi_sw_tcp_scsi_transport) 960 return -ENODEV; 961 962 return 0; 963} 964 965static void __exit iscsi_sw_tcp_exit(void) 966{ 967 iscsi_unregister_transport(&iscsi_sw_tcp_transport); 968} 969 970module_init(iscsi_sw_tcp_init); 971module_exit(iscsi_sw_tcp_exit); 972