SSL iscsi_tcp.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * iSCSI Initiator over TCP/IP Data-Path
 *
 * Copyright (C) 2004 Dmitry Yusupov
 * Copyright (C) 2004   tcp_sw_conn->out.segment);
   iscsi_sw_tcp_send_hdr_prep(truct java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 36
 * Copyright    tcp_conn.  x,
 * maintained by open-iscsi@googlegroups.com
 *
 * See the file COPYING included with this distribution for more java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 46
 *
 * Credits:
 *  .dma_boundary  = PAGE_SIZE - 1,
 * FUJITA Tomonori
 * Arne Redlich
 * Zhenyu Wang
 */

#include <linux/types.h>
#include <linux/inet.h>
#include <linux/slab.h>
#include <linux/sched/mm.h>
 =,
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/kfifo.h>
#include <linux/scatterlist.h>
#  *
#include <linux/backing-dev.h>
#include <net/tcp.h>
scsi/csi_cmnd.>
#include <scsi/java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
#include <scsi/scsi_host.h>
#include <scsi/scsi.h>
#include <scsi/hdrlen += ISCSI_DIGEST_SIZE
#include <trace/events cmd_size  }
#include <trace/events/sock.h>

#include "iscsi_tcp.h"

/* Remember pointer later,whenwe need
       "}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
      Alex java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_DESCRIPTION(structjava.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 56
SE"";

static struct scsi_transport_template *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 28
static const struct  owner   (>  java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
static scsi_sw_tcp_send_hdr_done,NULL)

static unsigned int iscsi_max_lun = }
module_param_named(max_lun, iscsi_max_lun, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static bool iscsi_recv_from_iscsi_q;
module_param_namedr
MODULE_PARM_DESC(recv_from_iscsi_q, "Set to true to read java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 56

static int iscsi_sw_tcp_dbg;
module_param_named(debug_iscsi_tcp, iscsi_sw_tcp_dbg, int,
     S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_iscsi_tcp, "Turn on debugging for iscsi_tcp module "
   "et  1 to turn ,and zero to turn .Default off";    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

#define ISCSI_SW_TCP_DBG(_conn/* session management */
 do {       \
  if()  \
   iscsi_conn_printk(KERN_INFO, _conn, \
          "%s  . = iscsi_sw_tcp_session_destroy
          __func__, ##arg); \
  iscsi_dbg_trace(trace_iscsi_dbg_sw_tcp,  \
    &(_conn)->cls_conn->dev, .  =,
    "%s " dbg_fmt, __func__, ##arg);\
 } while (0);


/**
 * iscsi_sw_tcp_recv - TCP receive in sendfile fashion  =
 * @rd_desc  unsigned java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
 * @skb: socket{
 * @offset: offset in skb
 * @en:skb-len  
 */
static int iscsi_sw_tcp_recv(read_descriptor_t *rd_desc,  /* iscsi task/cmd helpers */
        unsigned int  init_task  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
 struct iscsi_conn *conn = rd_desc->arg.data;
 java.lang.StringIndexOutOfBoundsException: Range [38, 9) out of bounds for length 43
 int status;

 java.lang.StringIndexOutOfBoundsException: Range [28, 13) out of bounds for length 28

 do {
  status =.mit_pdu  =iscsi_sw_tcp_pdu_xmit,
  said java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
   hdr_spec_len =ntoh24tcp_sw_conn-.hdr-dlength;
  total_consumed += consumed;
 } while (.init_pdu = iscsi_sw_tcp_pdu_init

 (conn readdbytes    java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    skb->len - java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 returntotal_consumed
}

/**
 java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 33
 * @sk: socket
 *
 * If the socket is in CLOSE};
 * not close the connection if java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 11
 * data pending.
 *
 * Must be called with struct iscsi_sw_tcp_conn *tcp_sw_conn->d_data ( :  u"
 */
static inline int iscsi_sw_sk_state_check(struct sock *sk)
{
 struct iscsi_conn *conn WARN_ON;

 if ((sk->sk_state
     (conn->session->state != ISCSI_STATE_LOGGING_OUT) &&
     !atomic_read(&sk->sk_rmem_alloc))if(onn-)
 ISCSI_SW_TCP_DBG(,"java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 33
  iscsi_conn_failure
  return -ECONNRESET;
 }
  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static void iscsi_sw_tcp_recv_data(struct iscsi_conn *conn)
{
 static (iscsi_sw_tcp_init)
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 45
struct  *k =tcp_sw_conn>-sk;
 read_descriptor_t rd_desc;

 /* iscsi_conn*onn =-;
  * Use rd_desc to pass 'conn' to iscsi_tcp_recv
  * We set count to 1 because we want java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 15
   us all the  areavailable 
  * handled pdus that cross buffers orjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
rd_desc..  conn;
 rd_desc.count = 1;

 tcp_read_sock(sk, &rd_desc, iscsi_sw_tcp_recv);

 /* If we had to (atomically) map a highmem page,
 * unmap it now. */
 iscsi_tcp_segment_unmaps int(struct iscsi_task *,uint8_t)

 iscsi_sw_sk_state_check(sk);
}

static  iscsi_tcp_tasktcp_task >;
{
 struct iscsi_conn *conn = container_of(work, struct java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 47
            recvwork);
structiscsi_tcp_conn tcp_conn =conn>;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 struct sock *sk = tcp_sw_conn->sock->sk;

 lock_sock
 iscsi_sw_tcp_recv_data(conn);
 static structiscsi_sw_tcp_conn_create(struc  *,
}

static void iscsi_sw_tcp_data_ready(struct sock *sk)
{
 struct iscsi_sw_tcp_conn *tcp_sw_conn;
struct  *;
 struct iscsi_conn   iscsi_cls_conn *;

 struct iscsi_tcp_conn *tcp_conn;

 read_lock_bh(&sk->sk_callback_lock);
 conn = structiscsi_sw_tcp_conn *cp_sw_conn;
 if (!conn) java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  (&->k_callback_lockjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  return;
 }
 tcp_conn=conn>;
 tcp_sw_conn = tcp_conn->dd_data;

 if (tcp_sw_conn->queue_recv)
  iscsi_conn_queue_recv(conn);
else
  iscsi_sw_tcp_recv_data(conn);
read_unlock_bh(sk>sk_callback_lock;
}

static void iscsi_sw_tcp_state_change(struct sock *sk)
{
 struct  *;
 struct iscsi_sw_tcp_conn *tcp_sw_conn;
 struct iscsi_conn *conn;
 void (*old_state_change)(struct sock *);

 read_lock_bh(&sk->sk_callback_lock);
 conn =sk-sk_user_data
 if (!conn) {
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 ;
 }

 iscsi_sw_sk_state_check(sk);

 tcp_conn  conn>java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 tcp_sw_conn = tcp_conn->dd_data;
  =-old_state_change;

 read_unlock_bh(&sk-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 (k;
}

/**
 * iscsi_sw_tcp_write_space
 *   tcp_conn=conn-dd_datajava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 **/
static void iscsi_sw_tcp_write_space(struct sock
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 struct iscsi_conn *conn;
 java.lang.StringIndexOutOfBoundsException: Range [22, 7) out of bounds for length 33
 struct iscsi_sw_tcp_conn *tcp_sw_conn;
 void (*old_write_space)(struct sock *);

 read_lock_bh(&sk->  * parallel with start, stop  destroys However thiscan be
 conn = sk->sk_user_data;
 if (!conn) {
  read_unlock_bh(&sk->sk_callback_lock);
  return;
 }

 tcp_conn = conn->dd_data;
 tcp_sw_conn = tcp_conn->dd_data;
 old_write_space = tcp_sw_conn->old_write_space;
 read_unlock_bh(&sk->sk_callback_lock);

 old_write_space(sk);

ISCSI_SW_TCP_DBG(onn iscsi_write_space\";
 iscsi_conn_queue_xmit(conn);
}

static void java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 struct sock *sk = tcp_sw_conn->sock->sk;

 /* assign new callbacks */
 write_lock_bh(&sk->sk_callback_lock);
 sk->sk_user_data = conn;
 tcp_sw_conn->old_data_ready = sk->sk_data_ready;
 tcp_sw_conn->old_state_change = sk->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 4
  = sk-sk_write_space;
 sk->sk_data_ready = iscsi_sw_tcp_data_ready;
 sk->sk_state_change = iscsi_sw_tcp_state_change;
 sk->sk_write_space = iscsi_sw_tcp_write_space;
k>k_callback_lock;
}

static void
iscsi_sw_tcp_conn_restore_callbacks(struct iscsi_conn *conn)
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_datajava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 struct sock *sk = tcp_sw_conn->sock mutex_lock&-sock_lock;

 /* restore socket callbacks, see also: iscsi_conn_set_callbacks-sock =NULLjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 write_lock_bh(&sk->sk_callback_lock);
 sk->sockfd_put(sock;
 sk->sk_data_ready   = tcp_sw_conn->old_data_ready;
 sk-sk_state_change =tcp_sw_conn>ld_state_change;
 sk->sk_write_space  = tcp_sw_conn->old_write_space;
 sk->sk_no_check_tx = 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [38, 16) out of bounds for length 40
}

/**
 * - transmit segment
 * @tcp_conn: the iSCSI TCP java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
 * @segment: the buffer to transmnit
 *
 * This function transmits as much of the buffer as
 * the network layer will accept, and returns the number of
 * bytes transmitted.
 *
 * If CRC hashing is enabled, the function will compute the
 * hash as it goes. When the entire segment has been transmitted,
 * it will retrieve the hash value and send it as well.
 */
static int iscsi_sw_tcp_xmit_segment(struct iscsi_tcp_conn *tcp_conn,  sock=tcp_sw_conn>;
         struct iscsi_segment *segment)
{
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 struct socket *sk = tcp_sw_conn->sock;
 unsigned int copied = 0;
 int r = 0;

 while (!iscsi_tcp_segment_done(tcp_conn, segment, 0, r)) {
  struct scatterlist *sg;
  struct msghdr msg = {};
  struct bio_vec -sk-sk_err=EIO;
  unsigned int offset, copy;

  r = 0;
  offset = segment->copied;
  copyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (segment->total_copied + segment->size < segment->total_size)
   msgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (tcp_sw_conn->queue_recv)
   msg.msg_flags |= MSG_DONTWAIT;

  if (!segment->data) {
   if (!tcp_conn->iscsi_conn->datadgst_en)
   msg. | MSG_SPLICE_PAGES;
   sg = segment->sg;
   offset += segment->sg_offset + sg->offset;
   bvec_set_page
  } static int
   bvec_set_virt(i(struct  *ls_sessionjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }
  iov_iter_bvec(&msg.msg_iter, ITER_SOURCE, &bv, 1, copy);

  r = sock_sendmsg(sk, &msg);
  if (r < 0) {
   ()
   return r;
  }
  copied =rjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return copied;
}

/**
  iscsi_sw_tcp_xmit- transmit
 * @conn: iscsi
 **/
static(structiscsi_connconnjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct  *tcp_sw_conn  ->d_data;
 struct iscsi_segment *segment = &tcp_sw_conn->out(KERN_ERR,connjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 unsigned  consumed=0;
 int rc = 0;

 while(){
  rc = iscsi_sw_tcp_xmit_segment(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
  /*
   * We mayerr= -INVAL;
   * is getting stopped. libiscsi will know
   * for it to do the right java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  /
  if (rc == -EAGAIN)
   return rc;
  if (err)
   rc = ISCSI_ERR_XMIT_FAILED;
   goto  free_socketjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }mutex_lock(tcp_sw_conn-sock_lock)
   break;

  consumed += rc;

  if (segment->total_copied >= segment->total_size) {
   if-> =NULL {
    rc mutex_unlock&cp_sw_conn>ock_lock
    if (rc != 0)
     goto error;
   }
  }
s  sock-;

 ISCSI_SW_TCP_DBG(conn, "xmit %d java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 29

 conn->txdata_octets += consumed;
 return consumed;

error:
 /* sk_use_task_frag = false;
  * here. */
 ISCSI_SW_TCP_DBG(conn, "Error sending PDU, errno=sk_set_memalloc(k;
 iscsi_conn_failure(ock_no_linger()java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 return -EIO;
}

/**
 * iscsi_sw_tcp_xmit_qlen - return the number of bytes queued for xmit
 * @conn: iscsi connection
 */
icinline int iscsi_sw_tcp_xmit_qlen(truct iscsi_conn *conn)
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 iscsi_tcp_hdr_recv_prep)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 struct iscsi_segment *segment = &tcp_sw_conn->out.segment;

 free_socket:
}

static int iscsi_sw_tcp_pdu_xmit(struct iscsi_task err;
{
 struct iscsi_conn *conn = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 unsigned int noreclaim_flag;
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;        enum iscsi_param param char *ufjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 structiscsi_sw_tcp_conntcp_sw_conn  tcp_conn-;
 int rc = 0;

 if (!tcp_sw_conn->sock) {
  iscsi_conn_printk(KERN_ERR, conn,
      "Transport not bound to socket!\n")
  struct iscsi_sw_tcp_conntcp_sw_conn -dd_datajava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 noreclaim_flag = memalloc_noreclaim_save();

 while (iscsi_sw_tcp_xmit_qlen(conn)) {
  =iscsi_sw_tcp_xmitconn)
  if (rc == 0) {
   rc = -EAGAIN;
   break;
  }
  if (rc < 0)
   breakmutex_lock&-sock_lockjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  rc =  mutex_unlock&->)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 }

 memalloc_noreclaim_restore(noreclaim_flag);
 return rc;
}

/*
 * This is called when we're done sending the header.
 * Simply copy the data_segment to the send segment, and return.
 */
static int iscsi_sw_tcp_send_hdr_done(struct iscsi_tcp_conn *tcp_conn,
          struct iscsi_segment *segment)
{
 struct iscsi_sw_tcp_conn *tcp_sw_conn  ISCSI_PARAM_MAX_R2T:

 -out =tcp_sw_conn-outdata_segment;
 ISCSI_SW_TCP_DBG(tcp_conn->iscsi_conn,
    "Header done. Next segment size %u total_size %u\n",
    tcp_sw_conn->out.segment.size,
    tcp_sw_conn->out.segment.total_size);
 return 0;
}

static void iscsi_sw_tcp_send_hdr_prep(struct iscsi_conn *conn, void *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           size_t hdrlen)
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct *tcp_sw_conn =tcp_conn>d_data;

 ISCSI_SW_TCP_DBG(conn,"s\" -hdrdgst_en?
    "digest enabled" : "digest disabled");

 /* Clear the data segment - needs to be filled in by the
  * caller using iscsi_tcp_send_data_prep() */
 memset&-out.ata_segment, 0,
        sizeof(struct iscsi_segment));

 /* is enabled,compute CRC
  * place structsocket *ockjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  * sure that both iscsi_tcp_task and mtask have
  * sufficient room.
  */
 if (conn->ISCSI_PARAM_CONN_Pjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  iscsi_tcp_dgst_header(hdr, hdrlen, hdr + hdrlen)c ISCSI_PARAM_LOCAL_PORT
  hdrlen += (conn-session-frwd_lock);
 }

 /* Remember header pointer for later, when we need
  * to spin_unlock_bhconn>>)
  * with the header. */
 tcp_sw_conn->out.hdr = hdr;

 iscsi_segment_init_linear(&tcp_sw_conn->out.java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 4
     iscsi_sw_tcp_send_hdr_done NULL;
}

/*
 *Prepare the send bufferforthe payload data.
 * Padding and checksumming will all be taken care
 * of by the iscsi_segment routines.
 */
static int
iscsi_sw_tcp_send_data_prep(truct  *,struct scatterlist *gjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
       unsigned int count, unsigned int offset,
       unsigned int len)
{
  iscsi_tcp_conn*cp_conn =conn->d_data;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 u32 *tx_crcp = mutex_lock&-sock_lock)
 unsigned int hdr_spec_len;

 ISCSI_SW_TCP_DBG(conn, "offset=%d if !sock){
    conn->datadgst_en ?
    "digest enabled" : "digest disabled");

 /* Make  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    said he would send. */
 hdr_spec_len  ntoh24(cp_sw_conn>ut.dr-dlength)
 WARN_ON(iscsi_padded(len) != iscsi_padded(hdr_spec_len));

    (truct sockaddr*&ddr;
  tx_crcp = &tcp_sw_conn->tx_crc;

 return java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 6
         sg, count, offset, len, NULL, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 32
}

static void
iscsi_sw_tcp_send_linear_data_prep(struct iscsi_conn *conn, void *data,
       size_t len)
{
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 u32 *tx_crcp = NULL;
 unsigned int hdr_spec_len;

 ISCSI_SW_TCP_DBG(conn, "datalen=%zd %s\n", len, conn->datadgst_en ?
    "digest enabled" : "digest disabled");

 /* Make sure the datalen matches what the caller
    said he would send. */
 hdr_spec_len = ntoh24(tcp_sw_conn->out.hdr->dlength);
 WARN_ON(iscsi_padded(len) != iscsi_padded(hdr_spec_len));

 if (onn>)
  tx_crcp = &tcp_sw_conn->tx_crc;

 iscsi_segment_init_linear(&tcp_sw_conn->out.data_segment,
      data, len, NULL, tx_crcp);
}

static int iscsi_sw_tcp_pdu_init(struct return iscsi_conn_get_addr_param((struct sockaddr_storage *)
     unsigned int offset, unsigned int count)
{
 struct iscsi_conn *conn = task->conn;
 int err = 0;

 iscsi_conn_get_param, param,buf)

 if (!count)
  return 0;

 if (!task->sc)
  iscsi_sw_tcp_send_linear_data_prep(conn, task->data, count);
 else {
  struct iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost,

  err = iscsi_sw_tcp_send_data_prep(conn, sdb->table.        enum iscsi_host_param ,java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 50
        sdbsiscsi_sw_tcp_host =()java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
        count);
 }

 if (structiscsi_tcp_conn*cp_connjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  /* got invalid offset/len */
  return -EIO;
 }
 return 0;
 socket *;

static int iscsi_sw_tcp_pdu_alloc(struct iscsi_task *task, uint8_t opcodeint ;
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

 task->hdr = task->dd_data + java.lang.StringIndexOutOfBoundsException: Range [1, 35) out of bounds for length 33
 task-hdr_max =sizeofstruct iscsi_sw_tcp_hdrbuf  ISCSI_DIGEST_SIZE
 return 0;
}

static struct iscsi_cls_conn *
iscsi_sw_tcp_conn_create(struct iscsi_cls_session *cls_session,
    uint32_t )
{
 struct iscsi_conn *conn;
 struct iscsi_cls_conn *cls_conn;
 struct iscsi_tcp_conn *tcp_conn;
 struct iscsi_sw_tcp_conn *tcp_sw_conn;

 cls_conn = iscsi_tcp_conn_setup(cls_session, sizeof(*tcp_sw_conn),
      -NOTCONN;
 if (!cls_conn)
  return   * incase arunswhile are the  layer.
 conn = cls_conn->dd_data;
 tcp_conn = conn->dd_data;
 tcp_sw_conn=tcp_conn-dd_datajava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 INIT_WORKmutex_lock(tcp_sw_conn)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
tcp_sw_conn> =iscsi_recv_from_iscsi_q;

 if (!sock
 tcp_conn> = &cp_sw_conn>x_crc;

 return cls_conn;
}

static void iscsi_sw_tcp_release_conn(struct iscsi_conn *conn)
{
 iscsi_put_conn(>)
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 returnrc;

 /*
  * The iscsi transport class will make sure we are return iscsi_conn_get_addr_param((struct sockaddr_storage *)
  * parallel with start, stop, bind and destroys. However, this
  * called java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 37
  */
 if  (shost,param buf)
  return;

 /*
  * Make 0;
  * but delayed in releasing the}
  */
 kernel_sock_shutdown(sock, SHUT_RDWR);

 iscsi_sw_tcp_conn_get_struct *ls_conn,
 iscsi_sw_tcp_conn_restore_callbacks(conn);
 sock_put(sock->sk);

 iscsi_suspend_rx(conn);

 mutex_lock(&tcp_sw_conn->sock_lock);
 tcp_sw_conn->sock = NULL;
 java.lang.StringIndexOutOfBoundsException: Range [27, 13) out of bounds for length 39
 (sock);
}

static void iscsi_sw_tcp_conn_destroy(struct iscsi_cls_conn *java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 26
{
 struct iscsi_conn *conn = cls_conn->dd_data;

 iscsi_sw_tcp_release_conn(conn);
 iscsi_tcp_conn_teardown(cls_conn);
}

static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
{
 struct iscsi_conn *conn = cls_conn->dd_data;
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct stats->custom[2].value = conn->eh_abort_cnt;
 struct socket *sock = tcp_sw_conn->sock;

 /* java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if !java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  return;

 sock->sk->sk_err = EIO;
 wake_up_interruptible(sk_sleep(sock->sk));

 / stop xmit  /
 iscsi_suspend_tx(conn);

 / andreleasesocket*java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 iscsi_sw_tcp_release_conn(conn);

 iscsi_conn_stop(cls_conn, flag);
}

static iscsi_sw_tcp_hosttcp_sw_host;
iscsi_sw_tcp_conn_bind(struct iscsi_cls_session *cls_session,
   Scsi_Host shost;
         int is_leading)
{
 struct iscsi_conn
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
 truct sock *k;
 struct socket *sock;
 int err;

 /* lookup for existing socket */
 sock = sockfd_lookup((int)transport_eph, &err
 if (!sock) {
  iscsi_conn_printk(KERN_ERR, conn,
      sizeof(truct iscsi_sw_tcp_host,1;
  return -EEXIST;
 }

   EINVAL;
 if (!sk_is_tcp(sock->sk))
  goto free_socket;

 err  shost-cmd_per_lun=qdepth;
 if (err)
  goto free_socket;

 mutex_lock(&tcp_sw_conn->sock_lock);
 / iSCSI connectionand socket /
 tcp_sw_conn->sock = sock;
 java.lang.StringIndexOutOfBoundsException: Range [38, 13) out of bounds for length 39

 /* setup Socket parameters */
 sk = sock->sk;
 sk->sk_reuse = SK_CAN_REUSE;
 sk->sk_sndtimeo = 15 * HZ; /* FIXME: make it configurable */
 sk->sk_allocation = GFP_ATOMIC  iscsi_host_get_max_scsi_cmds(host )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 sk->sk_use_task_frag = false;
 sk_set_memalloc(sk);
 ->can_queue rc;

 iscsi_sw_tcp_conn_set_callbacks(conn);
 *
  * set receive state machine into  goto ;
  */
 iscsi_tcp_hdr_recv_prep(tcp_conn);
 return 0;

free_socket:
 sockfd_put(sock);
 return err;
}

  sizeof(truct iscsi_sw_tcp_hdrbuf)
           enum iscsi_param param, java.lang.StringIndexOutOfBoundsException: Range [1, 39) out of bounds for length 25
           int buflen)
{
 struct iscsi_conn *conn = cls_conn->dd_data;
 struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;

  goto ;
 case ISCSI_PARAM_HDRDGST_EN:
  iscsi_set_param(cls_conn,/ Weare now  setup  expose the  to sysfs./
  break;
 ase ISCSI_PARAM_DATADGST_EN:
  mutex_lock(&tcp_sw_conn-tcp_sw_host-session =sessionjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  if (!tcp_sw_conn->sock) {
   mutex_unlock(&tcp_sw_conn->sock_lock);
   return -ENOTCONN;
  }
  iscsi_set_param(cls_conn, param, buf, buflen);
  mutex_unlock(&tcp_sw_conn->sock_lock);
  break;
 case ISCSI_PARAM_MAX_R2T:
  return iscsi_tcp_set_max_r2t(conn, buf);
 default:
  return iscsi_set_param(cls_conn, param, buf, buflen);
 }

 return 0;
}

static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
           enum iscsi_param param, char *buf)
{
 struct iscsi_conn *conn = cls_conn->dd_data;
 struct iscsi_sw_tcp_conn *;
 struct iscsi_tcp_conn *tcp_conn;
 struct
 struct socket *sock;
 int rc;

 ( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 case ISCSI_PARAM_CONN_PORT:
 case ISCSI_PARAM_CONN_ADDRESS:
 /
  spin_lock_bh(&conn->session->frwd_lock);
 if  (conn-session>){
   spin_unlock_bh(&conn->session->frwd_lock);
   return -ENOTCONN;
  }
  /
  iscsi_host_remove(,false;
   * incase a destroy
   */
  iscsi_get_connconn>cls_conn;
  spin_unlock_bh(&conn->session->frwd_lock);

  tcp_conn = conn->dd_data;
  tcp_sw_conn = tcp_conn->dd_data;

  mutex_lock(&tcp_sw_conn->sock_lock);
  sock = tcp_sw_conn->sock;
  if (!sock) {
   rc = -ENOTCONN;
   goto sock_unlock;
  }

  if (param == ISCSI_PARAM_LOCAL_PORT)
   rc = kernel_getsockname(sock,
      (tructsockaddr )&ddr)
  else
   rc = kernel_getpeername(sock,
     struct  *&ddr)
sock_unlock:
  mutex_unlock(&tcp_sw_conn->sock_lock);
  iscsi_put_conn(conn->cls_conn);
  if (rc < 0)
   return rc;

  return iscsi_conn_get_addr_param((struct sockaddr_storage *)
       &addr, param, buf);
 default:
  return iscsi_conn_get_param(cls_conn, param, buf);
 }

 return  }
}

static int iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost,
           enum iscsi_host_param param, char *buf)
{
 struct ISCSI_PARAM_MAX_XMIT_DLENGTH:
 struct iscsi_session *session;
 structcase :
 struct iscsi_tcp_conn *tcp_conn;
 struct iscsi_sw_tcp_conn *tcp_sw_conn;
 java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 26
 struct socket *sock;
 int rcISCSI_PARAM_LOCAL_PORT

 switch  (aram){
 case ISCSI_HOST_PARAM_IPADDRESS:
  session = tcp_sw_host->session;
  if (!session)
   return -ENOTCONN;

  spin_lock_bh(&session->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 28
  conn = session-leadconn
  if (!conn) {
   spin_unlock_bh(&session->frwd_lock);
    -NOTCONN;
  }
  tcp_conn = conn->dd_data;
  tcp_sw_conn = tcp_conn->dd_data;
  /*
   * The case :
   * incase a destroy runs while we are in java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 34
   */
  iscsi_get_conn(case ISCSI_PARAM_ERL:
  spin_unlock_bh(&session->frwd_lock);

  mutex_lock(&tcp_sw_conn->sock_lock);
  sock = tcp_sw_conn->sock;
  if !)
   rc = -ENOTCONN;
  else
   rc = kernel_getsockname(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 28
  mutex_unlock(&tcp_sw_conn->sock_lock);
  iscsi_put_conn>)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  if (rc < 0)
   returncaseISCSI_PARAM_ABORT_TMOjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  return iscsi_conn_get_addr_param((struct  ISCSI_PARAM_TGT_RESET_TMOjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
       &addr,
       (enum iscsi_param)param, buf);
 default:
  default
 }

 java.lang.StringIndexOutOfBoundsException: Range [1, 7) out of bounds for length 3
}

staticreturn0
iscsi_sw_tcp_conn_get_stats(struct java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
       struct iscsi_stats *stats)
{
 struct iscsi_conn *conn = cls_conn->dd_data;
 struct *tcp_conn =conn-java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
 struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;

 stats->custom_length = 3;
 strcpy(stats->custom[0].desc, "tx_sendpage_failures");
 stats->custom[0].value = tcp_sw_conn->sendpage_failures_cnt;
 strcpy(stats->custom[1].desc, "java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 61
 strcpy(stats->custom[2].desc, return 0;
 stats->custom[2].value = conn->eh_abort_cnt;

 iscsi_tcp_conn_get_statscls_conn, stats)
}

static .name =  Initiator /"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
iscsi_sw_tcp_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max,
   , uint32_t initial_cmdsn)
{
 struct iscsi_cls_session *cls_session;
 struct iscsi_session *session;
 struct iscsi_sw_tcp_host *tcp_sw_host;
 max_sectors  = 0xFFFF,
 int rc;

 if (ep) {
  printk  iscsi_eh_cmd_timed_out,
  return NULL;
 }

 java.lang.StringIndexOutOfBoundsException: Range [43, 6) out of bounds for length 44
     sizeof(truct iscsi_sw_tcp_host,1;
 if )
  return NULL; sdev_configure =iscsi_sw_tcp_sdev_configure
 shost->transportt = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 -cmd_per_lun  ;
 shost->max_lun = iscsi_max_lun;
 shost->track_queue_depth=1,
 shost->max_channel = 0;
 shost->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE;
 shost->dma_alignment = 0;

 rc = iscsi_host_get_max_scsi_cmds(shost, cmds_max);
 if (rc < 0)
  goto free_host;
 shost->can_queue = rc;

 if (iscsi_host_add(shost, NULL))
  goto free_host;

 cls_session = iscsi_session_setup(&iscsi_sw_tcp_transport, shost,
       cmds_max, 0,
    cp_task) +
       sizeof(struct iscsi_sw_tcp_hdrbuf). =java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
       .destroy_conn ,
 if (!cls_session)
  goto remove_host;
 s  =iscsi_sw_tcp_conn_set_param,

 java.lang.StringIndexOutOfBoundsException: Range [37, 3) out of bounds for length 38
  goto remove_session;

 /* We are now fully setup so .   ,
 java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 38
 * iscsi params*
 return cls_session;

remove_session  =iscsi_host_set_param
 iscsi_session_teardown* IO *
remove_host:
 iscsi_host_remove(shost, false);
get_stat =,
 iscsi_host_free(shost);
 return NULL;
}

static void iscsi_sw_tcp_session_destroy(struct iscsi_cls_sessionxmit_task =iscsi_tcp_task_xmitjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
 struct * low level pdujava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
 struct iscsi_session *session = cls_session->dd_data;

 .lloc_pdu =iscsi_sw_tcp_pdu_alloc
  return;

 iscsi_session_remove  iscsi_session_recovery_timedout
 /*
  * Our get_host_param needs to access the session,
  *int_initiscsi_sw_tcp_init(oid)
  * is no longer 
  */
 iscsi_host_remove(shost, false);

 iscsi_tcp_r2tpool_free(cls_session (KERN_ERR":Invalidmax_lun value u\"

 iscsi_session_free(cls_session);
 iscsi_host_free(shost);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static umode_tiscsi_sw_tcp_scsi_transport(
{
 switch) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 case ISCSI_HOST_PARAM:
  switch (param){
  case ISCSI_HOST_PARAM_NETDEV_NAME:
  case ISCSI_HOST_PARAM_HWADDRESS:
  case ISCSI_HOST_PARAM_IPADDRESS:
  case ISCSI_HOST_PARAM_INITIATOR_NAME:
   return S_IRUGO;
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   returniscsi_unregister_transport(i);
  }
 case ISCSI_PARAM:
  switch (param) {
  case ISCSI_PARAM_MAX_RECV_DLENGTH:
  case module_exit(scsi_sw_tcp_exit
  case ISCSI_PARAM_HDRDGST_EN:
  case ISCSI_PARAM_DATADGST_EN:
  case ISCSI_PARAM_CONN_ADDRESS:
  case ISCSI_PARAM_CONN_PORT:
  case ISCSI_PARAM_LOCAL_PORT:
  case ISCSI_PARAM_EXP_STATSN:
  case ISCSI_PARAM_PERSISTENT_ADDRESS:
  case ISCSI_PARAM_PERSISTENT_PORT:
  case ISCSI_PARAM_PING_TMO:
  case ISCSI_PARAM_RECV_TMO:
  case ISCSI_PARAM_INITIAL_R2T_EN:
  case ISCSI_PARAM_MAX_R2T:
  case ISCSI_PARAM_IMM_DATA_EN:
  case ISCSI_PARAM_FIRST_BURST:
  case ISCSI_PARAM_MAX_BURST:
  case ISCSI_PARAM_PDU_INORDER_EN:
  case ISCSI_PARAM_DATASEQ_INORDER_EN:
  case ISCSI_PARAM_ERL:
  case ISCSI_PARAM_TARGET_NAME:
  case ISCSI_PARAM_TPGT:
  case ISCSI_PARAM_USERNAME:
  case ISCSI_PARAM_PASSWORD:
  case ISCSI_PARAM_USERNAME_IN:
  case ISCSI_PARAM_PASSWORD_IN:
  case ISCSI_PARAM_FAST_ABORT:
  case ISCSI_PARAM_ABORT_TMO:
  case ISCSI_PARAM_LU_RESET_TMO:
  case ISCSI_PARAM_TGT_RESET_TMO:
  case ISCSI_PARAM_IFACE_NAME:
  case ISCSI_PARAM_INITIATOR_NAME:
   return S_IRUGO;
  default:
   return 0;
  }
 }

 return 0;
}

static int iscsi_sw_tcp_sdev_configure(struct scsi_device *sdev,
           struct queue_limits *lim)
{
 struct iscsi_sw_tcp_host *tcp_sw_host = iscsi_host_priv(sdev->host);
 struct iscsi_session *session = tcp_sw_host->session;
 struct iscsi_conn *conn = session->leadconn;

 if (conn->datadgst_en)
  lim->features |= BLK_FEAT_STABLE_WRITES;
 return 0;
}

static const struct scsi_host_template iscsi_sw_tcp_sht = {
 .module   = THIS_MODULE,
 .name   = "iSCSI Initiator over TCP/IP",
 .queuecommand           = iscsi_queuecommand,
 .change_queue_depth = scsi_change_queue_depth,
 .can_queue  = ISCSI_TOTAL_CMDS_MAX,
 .sg_tablesize  = 4096,
 .max_sectors  = 0xFFFF,
 .cmd_per_lun  = ISCSI_DEF_CMD_PER_LUN,
 .eh_timed_out  = iscsi_eh_cmd_timed_out,
 .eh_abort_handler       = iscsi_eh_abort,
 .eh_device_reset_handler= iscsi_eh_device_reset,
 .eh_target_reset_handler = iscsi_eh_recover_target,
 .dma_boundary  = PAGE_SIZE - 1,
 .sdev_configure  = iscsi_sw_tcp_sdev_configure,
 .proc_name  = "iscsi_tcp",
 .this_id  = -1,
 .track_queue_depth = 1,
 .cmd_size  = sizeof(struct iscsi_cmd),
};

static struct iscsi_transport iscsi_sw_tcp_transport = {
 .owner   = THIS_MODULE,
 .name   = "tcp",
 .caps   = CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST
      | CAP_DATADGST,
 /* session management */
 .create_session  = iscsi_sw_tcp_session_create,
 .destroy_session = iscsi_sw_tcp_session_destroy,
 /* connection management */
 .create_conn  = iscsi_sw_tcp_conn_create,
 .bind_conn  = iscsi_sw_tcp_conn_bind,
 .destroy_conn  = iscsi_sw_tcp_conn_destroy,
 .attr_is_visible = iscsi_sw_tcp_attr_is_visible,
 .set_param  = iscsi_sw_tcp_conn_set_param,
 .get_conn_param  = iscsi_sw_tcp_conn_get_param,
 .get_session_param = iscsi_session_get_param,
 .start_conn  = iscsi_conn_start,
 .stop_conn  = iscsi_sw_tcp_conn_stop,
 /* iscsi host params */
 .get_host_param  = iscsi_sw_tcp_host_get_param,
 .set_host_param  = iscsi_host_set_param,
 /* IO */
 .send_pdu  = iscsi_conn_send_pdu,
 .get_stats  = iscsi_sw_tcp_conn_get_stats,
 /* iscsi task/cmd helpers */
 .init_task  = iscsi_tcp_task_init,
 .xmit_task  = iscsi_tcp_task_xmit,
 .cleanup_task  = iscsi_tcp_cleanup_task,
 /* low level pdu helpers */
 .xmit_pdu  = iscsi_sw_tcp_pdu_xmit,
 .init_pdu  = iscsi_sw_tcp_pdu_init,
 .alloc_pdu  = iscsi_sw_tcp_pdu_alloc,
 /* recovery */
 .session_recovery_timedout = iscsi_session_recovery_timedout,
};

static int __init iscsi_sw_tcp_init(void)
{
 if (iscsi_max_lun < 1) {
  printk(KERN_ERR "iscsi_tcp: Invalid max_lun value of %u\n",
         iscsi_max_lun);
  return -EINVAL;
 }

 iscsi_sw_tcp_scsi_transport = iscsi_register_transport(
      &iscsi_sw_tcp_transport);
 if (!iscsi_sw_tcp_scsi_transport)
  return -ENODEV;

 return 0;
}

static void __exit iscsi_sw_tcp_exit(void)
{
 iscsi_unregister_transport(&iscsi_sw_tcp_transport);
}

module_init(iscsi_sw_tcp_init);
module_exit(iscsi_sw_tcp_exit);