1e48354ceSNicholas Bellinger /******************************************************************************* 2e48354ceSNicholas Bellinger * This file contains main functions related to the iSCSI Target Core Driver. 3e48354ceSNicholas Bellinger * 4e48354ceSNicholas Bellinger * \u00a9 Copyright 2007-2011 RisingTide Systems LLC. 5e48354ceSNicholas Bellinger * 6e48354ceSNicholas Bellinger * Licensed to the Linux Foundation under the General Public License (GPL) version 2. 7e48354ceSNicholas Bellinger * 8e48354ceSNicholas Bellinger * Author: Nicholas A. Bellinger <nab@linux-iscsi.org> 9e48354ceSNicholas Bellinger * 10e48354ceSNicholas Bellinger * This program is free software; you can redistribute it and/or modify 11e48354ceSNicholas Bellinger * it under the terms of the GNU General Public License as published by 12e48354ceSNicholas Bellinger * the Free Software Foundation; either version 2 of the License, or 13e48354ceSNicholas Bellinger * (at your option) any later version. 14e48354ceSNicholas Bellinger * 15e48354ceSNicholas Bellinger * This program is distributed in the hope that it will be useful, 16e48354ceSNicholas Bellinger * but WITHOUT ANY WARRANTY; without even the implied warranty of 17e48354ceSNicholas Bellinger * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18e48354ceSNicholas Bellinger * GNU General Public License for more details. 19e48354ceSNicholas Bellinger ******************************************************************************/ 20e48354ceSNicholas Bellinger 21e48354ceSNicholas Bellinger #include <linux/string.h> 22e48354ceSNicholas Bellinger #include <linux/kthread.h> 23e48354ceSNicholas Bellinger #include <linux/crypto.h> 24e48354ceSNicholas Bellinger #include <linux/completion.h> 25827509e3SPaul Gortmaker #include <linux/module.h> 26e48354ceSNicholas Bellinger #include <asm/unaligned.h> 27e48354ceSNicholas Bellinger #include <scsi/scsi_device.h> 28e48354ceSNicholas Bellinger #include <scsi/iscsi_proto.h> 29e48354ceSNicholas Bellinger #include <target/target_core_base.h> 30e48354ceSNicholas Bellinger #include <target/target_core_tmr.h> 31e48354ceSNicholas Bellinger #include <target/target_core_transport.h> 32e48354ceSNicholas Bellinger 33e48354ceSNicholas Bellinger #include "iscsi_target_core.h" 34e48354ceSNicholas Bellinger #include "iscsi_target_parameters.h" 35e48354ceSNicholas Bellinger #include "iscsi_target_seq_pdu_list.h" 36e48354ceSNicholas Bellinger #include "iscsi_target_tq.h" 37e48354ceSNicholas Bellinger #include "iscsi_target_configfs.h" 38e48354ceSNicholas Bellinger #include "iscsi_target_datain_values.h" 39e48354ceSNicholas Bellinger #include "iscsi_target_erl0.h" 40e48354ceSNicholas Bellinger #include "iscsi_target_erl1.h" 41e48354ceSNicholas Bellinger #include "iscsi_target_erl2.h" 42e48354ceSNicholas Bellinger #include "iscsi_target_login.h" 43e48354ceSNicholas Bellinger #include "iscsi_target_tmr.h" 44e48354ceSNicholas Bellinger #include "iscsi_target_tpg.h" 45e48354ceSNicholas Bellinger #include "iscsi_target_util.h" 46e48354ceSNicholas Bellinger #include "iscsi_target.h" 47e48354ceSNicholas Bellinger #include "iscsi_target_device.h" 48e48354ceSNicholas Bellinger #include "iscsi_target_stat.h" 49e48354ceSNicholas Bellinger 50e48354ceSNicholas Bellinger static LIST_HEAD(g_tiqn_list); 51e48354ceSNicholas Bellinger static LIST_HEAD(g_np_list); 52e48354ceSNicholas Bellinger static DEFINE_SPINLOCK(tiqn_lock); 53e48354ceSNicholas Bellinger static DEFINE_SPINLOCK(np_lock); 54e48354ceSNicholas Bellinger 55e48354ceSNicholas Bellinger static struct idr tiqn_idr; 56e48354ceSNicholas Bellinger struct idr sess_idr; 57e48354ceSNicholas Bellinger struct mutex auth_id_lock; 58e48354ceSNicholas Bellinger spinlock_t sess_idr_lock; 59e48354ceSNicholas Bellinger 60e48354ceSNicholas Bellinger struct iscsit_global *iscsit_global; 61e48354ceSNicholas Bellinger 62e48354ceSNicholas Bellinger struct kmem_cache *lio_cmd_cache; 63e48354ceSNicholas Bellinger struct kmem_cache *lio_qr_cache; 64e48354ceSNicholas Bellinger struct kmem_cache *lio_dr_cache; 65e48354ceSNicholas Bellinger struct kmem_cache *lio_ooo_cache; 66e48354ceSNicholas Bellinger struct kmem_cache *lio_r2t_cache; 67e48354ceSNicholas Bellinger 68e48354ceSNicholas Bellinger static int iscsit_handle_immediate_data(struct iscsi_cmd *, 69e48354ceSNicholas Bellinger unsigned char *buf, u32); 70e48354ceSNicholas Bellinger static int iscsit_logout_post_handler(struct iscsi_cmd *, struct iscsi_conn *); 71e48354ceSNicholas Bellinger 72e48354ceSNicholas Bellinger struct iscsi_tiqn *iscsit_get_tiqn_for_login(unsigned char *buf) 73e48354ceSNicholas Bellinger { 74e48354ceSNicholas Bellinger struct iscsi_tiqn *tiqn = NULL; 75e48354ceSNicholas Bellinger 76e48354ceSNicholas Bellinger spin_lock(&tiqn_lock); 77e48354ceSNicholas Bellinger list_for_each_entry(tiqn, &g_tiqn_list, tiqn_list) { 78e48354ceSNicholas Bellinger if (!strcmp(tiqn->tiqn, buf)) { 79e48354ceSNicholas Bellinger 80e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_state_lock); 81e48354ceSNicholas Bellinger if (tiqn->tiqn_state == TIQN_STATE_ACTIVE) { 82e48354ceSNicholas Bellinger tiqn->tiqn_access_count++; 83e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 84e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 85e48354ceSNicholas Bellinger return tiqn; 86e48354ceSNicholas Bellinger } 87e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 88e48354ceSNicholas Bellinger } 89e48354ceSNicholas Bellinger } 90e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 91e48354ceSNicholas Bellinger 92e48354ceSNicholas Bellinger return NULL; 93e48354ceSNicholas Bellinger } 94e48354ceSNicholas Bellinger 95e48354ceSNicholas Bellinger static int iscsit_set_tiqn_shutdown(struct iscsi_tiqn *tiqn) 96e48354ceSNicholas Bellinger { 97e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_state_lock); 98e48354ceSNicholas Bellinger if (tiqn->tiqn_state == TIQN_STATE_ACTIVE) { 99e48354ceSNicholas Bellinger tiqn->tiqn_state = TIQN_STATE_SHUTDOWN; 100e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 101e48354ceSNicholas Bellinger return 0; 102e48354ceSNicholas Bellinger } 103e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 104e48354ceSNicholas Bellinger 105e48354ceSNicholas Bellinger return -1; 106e48354ceSNicholas Bellinger } 107e48354ceSNicholas Bellinger 108e48354ceSNicholas Bellinger void iscsit_put_tiqn_for_login(struct iscsi_tiqn *tiqn) 109e48354ceSNicholas Bellinger { 110e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_state_lock); 111e48354ceSNicholas Bellinger tiqn->tiqn_access_count--; 112e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 113e48354ceSNicholas Bellinger } 114e48354ceSNicholas Bellinger 115e48354ceSNicholas Bellinger /* 116e48354ceSNicholas Bellinger * Note that IQN formatting is expected to be done in userspace, and 117e48354ceSNicholas Bellinger * no explict IQN format checks are done here. 118e48354ceSNicholas Bellinger */ 119e48354ceSNicholas Bellinger struct iscsi_tiqn *iscsit_add_tiqn(unsigned char *buf) 120e48354ceSNicholas Bellinger { 121e48354ceSNicholas Bellinger struct iscsi_tiqn *tiqn = NULL; 122e48354ceSNicholas Bellinger int ret; 123e48354ceSNicholas Bellinger 1248f50c7f5SDan Carpenter if (strlen(buf) >= ISCSI_IQN_LEN) { 125e48354ceSNicholas Bellinger pr_err("Target IQN exceeds %d bytes\n", 126e48354ceSNicholas Bellinger ISCSI_IQN_LEN); 127e48354ceSNicholas Bellinger return ERR_PTR(-EINVAL); 128e48354ceSNicholas Bellinger } 129e48354ceSNicholas Bellinger 130e48354ceSNicholas Bellinger tiqn = kzalloc(sizeof(struct iscsi_tiqn), GFP_KERNEL); 131e48354ceSNicholas Bellinger if (!tiqn) { 132e48354ceSNicholas Bellinger pr_err("Unable to allocate struct iscsi_tiqn\n"); 133e48354ceSNicholas Bellinger return ERR_PTR(-ENOMEM); 134e48354ceSNicholas Bellinger } 135e48354ceSNicholas Bellinger 136e48354ceSNicholas Bellinger sprintf(tiqn->tiqn, "%s", buf); 137e48354ceSNicholas Bellinger INIT_LIST_HEAD(&tiqn->tiqn_list); 138e48354ceSNicholas Bellinger INIT_LIST_HEAD(&tiqn->tiqn_tpg_list); 139e48354ceSNicholas Bellinger spin_lock_init(&tiqn->tiqn_state_lock); 140e48354ceSNicholas Bellinger spin_lock_init(&tiqn->tiqn_tpg_lock); 141e48354ceSNicholas Bellinger spin_lock_init(&tiqn->sess_err_stats.lock); 142e48354ceSNicholas Bellinger spin_lock_init(&tiqn->login_stats.lock); 143e48354ceSNicholas Bellinger spin_lock_init(&tiqn->logout_stats.lock); 144e48354ceSNicholas Bellinger 145e48354ceSNicholas Bellinger if (!idr_pre_get(&tiqn_idr, GFP_KERNEL)) { 146e48354ceSNicholas Bellinger pr_err("idr_pre_get() for tiqn_idr failed\n"); 147e48354ceSNicholas Bellinger kfree(tiqn); 148e48354ceSNicholas Bellinger return ERR_PTR(-ENOMEM); 149e48354ceSNicholas Bellinger } 150e48354ceSNicholas Bellinger tiqn->tiqn_state = TIQN_STATE_ACTIVE; 151e48354ceSNicholas Bellinger 152e48354ceSNicholas Bellinger spin_lock(&tiqn_lock); 153e48354ceSNicholas Bellinger ret = idr_get_new(&tiqn_idr, NULL, &tiqn->tiqn_index); 154e48354ceSNicholas Bellinger if (ret < 0) { 155e48354ceSNicholas Bellinger pr_err("idr_get_new() failed for tiqn->tiqn_index\n"); 156e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 157e48354ceSNicholas Bellinger kfree(tiqn); 158e48354ceSNicholas Bellinger return ERR_PTR(ret); 159e48354ceSNicholas Bellinger } 160e48354ceSNicholas Bellinger list_add_tail(&tiqn->tiqn_list, &g_tiqn_list); 161e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 162e48354ceSNicholas Bellinger 163e48354ceSNicholas Bellinger pr_debug("CORE[0] - Added iSCSI Target IQN: %s\n", tiqn->tiqn); 164e48354ceSNicholas Bellinger 165e48354ceSNicholas Bellinger return tiqn; 166e48354ceSNicholas Bellinger 167e48354ceSNicholas Bellinger } 168e48354ceSNicholas Bellinger 169e48354ceSNicholas Bellinger static void iscsit_wait_for_tiqn(struct iscsi_tiqn *tiqn) 170e48354ceSNicholas Bellinger { 171e48354ceSNicholas Bellinger /* 172e48354ceSNicholas Bellinger * Wait for accesses to said struct iscsi_tiqn to end. 173e48354ceSNicholas Bellinger */ 174e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_state_lock); 175e48354ceSNicholas Bellinger while (tiqn->tiqn_access_count != 0) { 176e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 177e48354ceSNicholas Bellinger msleep(10); 178e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_state_lock); 179e48354ceSNicholas Bellinger } 180e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_state_lock); 181e48354ceSNicholas Bellinger } 182e48354ceSNicholas Bellinger 183e48354ceSNicholas Bellinger void iscsit_del_tiqn(struct iscsi_tiqn *tiqn) 184e48354ceSNicholas Bellinger { 185e48354ceSNicholas Bellinger /* 186e48354ceSNicholas Bellinger * iscsit_set_tiqn_shutdown sets tiqn->tiqn_state = TIQN_STATE_SHUTDOWN 187e48354ceSNicholas Bellinger * while holding tiqn->tiqn_state_lock. This means that all subsequent 188e48354ceSNicholas Bellinger * attempts to access this struct iscsi_tiqn will fail from both transport 189e48354ceSNicholas Bellinger * fabric and control code paths. 190e48354ceSNicholas Bellinger */ 191e48354ceSNicholas Bellinger if (iscsit_set_tiqn_shutdown(tiqn) < 0) { 192e48354ceSNicholas Bellinger pr_err("iscsit_set_tiqn_shutdown() failed\n"); 193e48354ceSNicholas Bellinger return; 194e48354ceSNicholas Bellinger } 195e48354ceSNicholas Bellinger 196e48354ceSNicholas Bellinger iscsit_wait_for_tiqn(tiqn); 197e48354ceSNicholas Bellinger 198e48354ceSNicholas Bellinger spin_lock(&tiqn_lock); 199e48354ceSNicholas Bellinger list_del(&tiqn->tiqn_list); 200e48354ceSNicholas Bellinger idr_remove(&tiqn_idr, tiqn->tiqn_index); 201e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 202e48354ceSNicholas Bellinger 203e48354ceSNicholas Bellinger pr_debug("CORE[0] - Deleted iSCSI Target IQN: %s\n", 204e48354ceSNicholas Bellinger tiqn->tiqn); 205e48354ceSNicholas Bellinger kfree(tiqn); 206e48354ceSNicholas Bellinger } 207e48354ceSNicholas Bellinger 208e48354ceSNicholas Bellinger int iscsit_access_np(struct iscsi_np *np, struct iscsi_portal_group *tpg) 209e48354ceSNicholas Bellinger { 210e48354ceSNicholas Bellinger int ret; 211e48354ceSNicholas Bellinger /* 212e48354ceSNicholas Bellinger * Determine if the network portal is accepting storage traffic. 213e48354ceSNicholas Bellinger */ 214e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 215e48354ceSNicholas Bellinger if (np->np_thread_state != ISCSI_NP_THREAD_ACTIVE) { 216e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 217e48354ceSNicholas Bellinger return -1; 218e48354ceSNicholas Bellinger } 219e48354ceSNicholas Bellinger if (np->np_login_tpg) { 220e48354ceSNicholas Bellinger pr_err("np->np_login_tpg() is not NULL!\n"); 221e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 222e48354ceSNicholas Bellinger return -1; 223e48354ceSNicholas Bellinger } 224e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 225e48354ceSNicholas Bellinger /* 226e48354ceSNicholas Bellinger * Determine if the portal group is accepting storage traffic. 227e48354ceSNicholas Bellinger */ 228e48354ceSNicholas Bellinger spin_lock_bh(&tpg->tpg_state_lock); 229e48354ceSNicholas Bellinger if (tpg->tpg_state != TPG_STATE_ACTIVE) { 230e48354ceSNicholas Bellinger spin_unlock_bh(&tpg->tpg_state_lock); 231e48354ceSNicholas Bellinger return -1; 232e48354ceSNicholas Bellinger } 233e48354ceSNicholas Bellinger spin_unlock_bh(&tpg->tpg_state_lock); 234e48354ceSNicholas Bellinger 235e48354ceSNicholas Bellinger /* 236e48354ceSNicholas Bellinger * Here we serialize access across the TIQN+TPG Tuple. 237e48354ceSNicholas Bellinger */ 238e48354ceSNicholas Bellinger ret = mutex_lock_interruptible(&tpg->np_login_lock); 239e48354ceSNicholas Bellinger if ((ret != 0) || signal_pending(current)) 240e48354ceSNicholas Bellinger return -1; 241e48354ceSNicholas Bellinger 242e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 243e48354ceSNicholas Bellinger np->np_login_tpg = tpg; 244e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 245e48354ceSNicholas Bellinger 246e48354ceSNicholas Bellinger return 0; 247e48354ceSNicholas Bellinger } 248e48354ceSNicholas Bellinger 249e48354ceSNicholas Bellinger int iscsit_deaccess_np(struct iscsi_np *np, struct iscsi_portal_group *tpg) 250e48354ceSNicholas Bellinger { 251e48354ceSNicholas Bellinger struct iscsi_tiqn *tiqn = tpg->tpg_tiqn; 252e48354ceSNicholas Bellinger 253e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 254e48354ceSNicholas Bellinger np->np_login_tpg = NULL; 255e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 256e48354ceSNicholas Bellinger 257e48354ceSNicholas Bellinger mutex_unlock(&tpg->np_login_lock); 258e48354ceSNicholas Bellinger 259e48354ceSNicholas Bellinger if (tiqn) 260e48354ceSNicholas Bellinger iscsit_put_tiqn_for_login(tiqn); 261e48354ceSNicholas Bellinger 262e48354ceSNicholas Bellinger return 0; 263e48354ceSNicholas Bellinger } 264e48354ceSNicholas Bellinger 265e48354ceSNicholas Bellinger static struct iscsi_np *iscsit_get_np( 266e48354ceSNicholas Bellinger struct __kernel_sockaddr_storage *sockaddr, 267e48354ceSNicholas Bellinger int network_transport) 268e48354ceSNicholas Bellinger { 269e48354ceSNicholas Bellinger struct sockaddr_in *sock_in, *sock_in_e; 270e48354ceSNicholas Bellinger struct sockaddr_in6 *sock_in6, *sock_in6_e; 271e48354ceSNicholas Bellinger struct iscsi_np *np; 272e48354ceSNicholas Bellinger int ip_match = 0; 273e48354ceSNicholas Bellinger u16 port; 274e48354ceSNicholas Bellinger 275e48354ceSNicholas Bellinger spin_lock_bh(&np_lock); 276e48354ceSNicholas Bellinger list_for_each_entry(np, &g_np_list, np_list) { 277e48354ceSNicholas Bellinger spin_lock(&np->np_thread_lock); 278e48354ceSNicholas Bellinger if (np->np_thread_state != ISCSI_NP_THREAD_ACTIVE) { 279e48354ceSNicholas Bellinger spin_unlock(&np->np_thread_lock); 280e48354ceSNicholas Bellinger continue; 281e48354ceSNicholas Bellinger } 282e48354ceSNicholas Bellinger 283e48354ceSNicholas Bellinger if (sockaddr->ss_family == AF_INET6) { 284e48354ceSNicholas Bellinger sock_in6 = (struct sockaddr_in6 *)sockaddr; 285e48354ceSNicholas Bellinger sock_in6_e = (struct sockaddr_in6 *)&np->np_sockaddr; 286e48354ceSNicholas Bellinger 287e48354ceSNicholas Bellinger if (!memcmp((void *)&sock_in6->sin6_addr.in6_u, 288e48354ceSNicholas Bellinger (void *)&sock_in6_e->sin6_addr.in6_u, 289e48354ceSNicholas Bellinger sizeof(struct in6_addr))) 290e48354ceSNicholas Bellinger ip_match = 1; 291e48354ceSNicholas Bellinger 292e48354ceSNicholas Bellinger port = ntohs(sock_in6->sin6_port); 293e48354ceSNicholas Bellinger } else { 294e48354ceSNicholas Bellinger sock_in = (struct sockaddr_in *)sockaddr; 295e48354ceSNicholas Bellinger sock_in_e = (struct sockaddr_in *)&np->np_sockaddr; 296e48354ceSNicholas Bellinger 297e48354ceSNicholas Bellinger if (sock_in->sin_addr.s_addr == 298e48354ceSNicholas Bellinger sock_in_e->sin_addr.s_addr) 299e48354ceSNicholas Bellinger ip_match = 1; 300e48354ceSNicholas Bellinger 301e48354ceSNicholas Bellinger port = ntohs(sock_in->sin_port); 302e48354ceSNicholas Bellinger } 303e48354ceSNicholas Bellinger 304e48354ceSNicholas Bellinger if ((ip_match == 1) && (np->np_port == port) && 305e48354ceSNicholas Bellinger (np->np_network_transport == network_transport)) { 306e48354ceSNicholas Bellinger /* 307e48354ceSNicholas Bellinger * Increment the np_exports reference count now to 308e48354ceSNicholas Bellinger * prevent iscsit_del_np() below from being called 309e48354ceSNicholas Bellinger * while iscsi_tpg_add_network_portal() is called. 310e48354ceSNicholas Bellinger */ 311e48354ceSNicholas Bellinger np->np_exports++; 312e48354ceSNicholas Bellinger spin_unlock(&np->np_thread_lock); 313e48354ceSNicholas Bellinger spin_unlock_bh(&np_lock); 314e48354ceSNicholas Bellinger return np; 315e48354ceSNicholas Bellinger } 316e48354ceSNicholas Bellinger spin_unlock(&np->np_thread_lock); 317e48354ceSNicholas Bellinger } 318e48354ceSNicholas Bellinger spin_unlock_bh(&np_lock); 319e48354ceSNicholas Bellinger 320e48354ceSNicholas Bellinger return NULL; 321e48354ceSNicholas Bellinger } 322e48354ceSNicholas Bellinger 323e48354ceSNicholas Bellinger struct iscsi_np *iscsit_add_np( 324e48354ceSNicholas Bellinger struct __kernel_sockaddr_storage *sockaddr, 325e48354ceSNicholas Bellinger char *ip_str, 326e48354ceSNicholas Bellinger int network_transport) 327e48354ceSNicholas Bellinger { 328e48354ceSNicholas Bellinger struct sockaddr_in *sock_in; 329e48354ceSNicholas Bellinger struct sockaddr_in6 *sock_in6; 330e48354ceSNicholas Bellinger struct iscsi_np *np; 331e48354ceSNicholas Bellinger int ret; 332e48354ceSNicholas Bellinger /* 333e48354ceSNicholas Bellinger * Locate the existing struct iscsi_np if already active.. 334e48354ceSNicholas Bellinger */ 335e48354ceSNicholas Bellinger np = iscsit_get_np(sockaddr, network_transport); 336e48354ceSNicholas Bellinger if (np) 337e48354ceSNicholas Bellinger return np; 338e48354ceSNicholas Bellinger 339e48354ceSNicholas Bellinger np = kzalloc(sizeof(struct iscsi_np), GFP_KERNEL); 340e48354ceSNicholas Bellinger if (!np) { 341e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for struct iscsi_np\n"); 342e48354ceSNicholas Bellinger return ERR_PTR(-ENOMEM); 343e48354ceSNicholas Bellinger } 344e48354ceSNicholas Bellinger 345e48354ceSNicholas Bellinger np->np_flags |= NPF_IP_NETWORK; 346e48354ceSNicholas Bellinger if (sockaddr->ss_family == AF_INET6) { 347e48354ceSNicholas Bellinger sock_in6 = (struct sockaddr_in6 *)sockaddr; 348e48354ceSNicholas Bellinger snprintf(np->np_ip, IPV6_ADDRESS_SPACE, "%s", ip_str); 349e48354ceSNicholas Bellinger np->np_port = ntohs(sock_in6->sin6_port); 350e48354ceSNicholas Bellinger } else { 351e48354ceSNicholas Bellinger sock_in = (struct sockaddr_in *)sockaddr; 352e48354ceSNicholas Bellinger sprintf(np->np_ip, "%s", ip_str); 353e48354ceSNicholas Bellinger np->np_port = ntohs(sock_in->sin_port); 354e48354ceSNicholas Bellinger } 355e48354ceSNicholas Bellinger 356e48354ceSNicholas Bellinger np->np_network_transport = network_transport; 357e48354ceSNicholas Bellinger spin_lock_init(&np->np_thread_lock); 358e48354ceSNicholas Bellinger init_completion(&np->np_restart_comp); 359e48354ceSNicholas Bellinger INIT_LIST_HEAD(&np->np_list); 360e48354ceSNicholas Bellinger 361e48354ceSNicholas Bellinger ret = iscsi_target_setup_login_socket(np, sockaddr); 362e48354ceSNicholas Bellinger if (ret != 0) { 363e48354ceSNicholas Bellinger kfree(np); 364e48354ceSNicholas Bellinger return ERR_PTR(ret); 365e48354ceSNicholas Bellinger } 366e48354ceSNicholas Bellinger 367e48354ceSNicholas Bellinger np->np_thread = kthread_run(iscsi_target_login_thread, np, "iscsi_np"); 368e48354ceSNicholas Bellinger if (IS_ERR(np->np_thread)) { 369e48354ceSNicholas Bellinger pr_err("Unable to create kthread: iscsi_np\n"); 370e48354ceSNicholas Bellinger ret = PTR_ERR(np->np_thread); 371e48354ceSNicholas Bellinger kfree(np); 372e48354ceSNicholas Bellinger return ERR_PTR(ret); 373e48354ceSNicholas Bellinger } 374e48354ceSNicholas Bellinger /* 375e48354ceSNicholas Bellinger * Increment the np_exports reference count now to prevent 376e48354ceSNicholas Bellinger * iscsit_del_np() below from being run while a new call to 377e48354ceSNicholas Bellinger * iscsi_tpg_add_network_portal() for a matching iscsi_np is 378e48354ceSNicholas Bellinger * active. We don't need to hold np->np_thread_lock at this 379e48354ceSNicholas Bellinger * point because iscsi_np has not been added to g_np_list yet. 380e48354ceSNicholas Bellinger */ 381e48354ceSNicholas Bellinger np->np_exports = 1; 382e48354ceSNicholas Bellinger 383e48354ceSNicholas Bellinger spin_lock_bh(&np_lock); 384e48354ceSNicholas Bellinger list_add_tail(&np->np_list, &g_np_list); 385e48354ceSNicholas Bellinger spin_unlock_bh(&np_lock); 386e48354ceSNicholas Bellinger 387e48354ceSNicholas Bellinger pr_debug("CORE[0] - Added Network Portal: %s:%hu on %s\n", 388e48354ceSNicholas Bellinger np->np_ip, np->np_port, (np->np_network_transport == ISCSI_TCP) ? 389e48354ceSNicholas Bellinger "TCP" : "SCTP"); 390e48354ceSNicholas Bellinger 391e48354ceSNicholas Bellinger return np; 392e48354ceSNicholas Bellinger } 393e48354ceSNicholas Bellinger 394e48354ceSNicholas Bellinger int iscsit_reset_np_thread( 395e48354ceSNicholas Bellinger struct iscsi_np *np, 396e48354ceSNicholas Bellinger struct iscsi_tpg_np *tpg_np, 397e48354ceSNicholas Bellinger struct iscsi_portal_group *tpg) 398e48354ceSNicholas Bellinger { 399e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 400e48354ceSNicholas Bellinger if (tpg && tpg_np) { 401e48354ceSNicholas Bellinger /* 402e48354ceSNicholas Bellinger * The reset operation need only be performed when the 403e48354ceSNicholas Bellinger * passed struct iscsi_portal_group has a login in progress 404e48354ceSNicholas Bellinger * to one of the network portals. 405e48354ceSNicholas Bellinger */ 406e48354ceSNicholas Bellinger if (tpg_np->tpg_np->np_login_tpg != tpg) { 407e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 408e48354ceSNicholas Bellinger return 0; 409e48354ceSNicholas Bellinger } 410e48354ceSNicholas Bellinger } 411e48354ceSNicholas Bellinger if (np->np_thread_state == ISCSI_NP_THREAD_INACTIVE) { 412e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 413e48354ceSNicholas Bellinger return 0; 414e48354ceSNicholas Bellinger } 415e48354ceSNicholas Bellinger np->np_thread_state = ISCSI_NP_THREAD_RESET; 416e48354ceSNicholas Bellinger 417e48354ceSNicholas Bellinger if (np->np_thread) { 418e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 419e48354ceSNicholas Bellinger send_sig(SIGINT, np->np_thread, 1); 420e48354ceSNicholas Bellinger wait_for_completion(&np->np_restart_comp); 421e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 422e48354ceSNicholas Bellinger } 423e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 424e48354ceSNicholas Bellinger 425e48354ceSNicholas Bellinger return 0; 426e48354ceSNicholas Bellinger } 427e48354ceSNicholas Bellinger 428e48354ceSNicholas Bellinger int iscsit_del_np_comm(struct iscsi_np *np) 429e48354ceSNicholas Bellinger { 430e48354ceSNicholas Bellinger if (!np->np_socket) 431e48354ceSNicholas Bellinger return 0; 432e48354ceSNicholas Bellinger 433e48354ceSNicholas Bellinger /* 434e48354ceSNicholas Bellinger * Some network transports allocate their own struct sock->file, 435e48354ceSNicholas Bellinger * see if we need to free any additional allocated resources. 436e48354ceSNicholas Bellinger */ 437e48354ceSNicholas Bellinger if (np->np_flags & NPF_SCTP_STRUCT_FILE) { 438e48354ceSNicholas Bellinger kfree(np->np_socket->file); 439e48354ceSNicholas Bellinger np->np_socket->file = NULL; 440e48354ceSNicholas Bellinger } 441e48354ceSNicholas Bellinger 442e48354ceSNicholas Bellinger sock_release(np->np_socket); 443e48354ceSNicholas Bellinger return 0; 444e48354ceSNicholas Bellinger } 445e48354ceSNicholas Bellinger 446e48354ceSNicholas Bellinger int iscsit_del_np(struct iscsi_np *np) 447e48354ceSNicholas Bellinger { 448e48354ceSNicholas Bellinger spin_lock_bh(&np->np_thread_lock); 449e48354ceSNicholas Bellinger np->np_exports--; 450e48354ceSNicholas Bellinger if (np->np_exports) { 451e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 452e48354ceSNicholas Bellinger return 0; 453e48354ceSNicholas Bellinger } 454e48354ceSNicholas Bellinger np->np_thread_state = ISCSI_NP_THREAD_SHUTDOWN; 455e48354ceSNicholas Bellinger spin_unlock_bh(&np->np_thread_lock); 456e48354ceSNicholas Bellinger 457e48354ceSNicholas Bellinger if (np->np_thread) { 458e48354ceSNicholas Bellinger /* 459e48354ceSNicholas Bellinger * We need to send the signal to wakeup Linux/Net 460e48354ceSNicholas Bellinger * which may be sleeping in sock_accept().. 461e48354ceSNicholas Bellinger */ 462e48354ceSNicholas Bellinger send_sig(SIGINT, np->np_thread, 1); 463e48354ceSNicholas Bellinger kthread_stop(np->np_thread); 464e48354ceSNicholas Bellinger } 465e48354ceSNicholas Bellinger iscsit_del_np_comm(np); 466e48354ceSNicholas Bellinger 467e48354ceSNicholas Bellinger spin_lock_bh(&np_lock); 468e48354ceSNicholas Bellinger list_del(&np->np_list); 469e48354ceSNicholas Bellinger spin_unlock_bh(&np_lock); 470e48354ceSNicholas Bellinger 471e48354ceSNicholas Bellinger pr_debug("CORE[0] - Removed Network Portal: %s:%hu on %s\n", 472e48354ceSNicholas Bellinger np->np_ip, np->np_port, (np->np_network_transport == ISCSI_TCP) ? 473e48354ceSNicholas Bellinger "TCP" : "SCTP"); 474e48354ceSNicholas Bellinger 475e48354ceSNicholas Bellinger kfree(np); 476e48354ceSNicholas Bellinger return 0; 477e48354ceSNicholas Bellinger } 478e48354ceSNicholas Bellinger 479e48354ceSNicholas Bellinger static int __init iscsi_target_init_module(void) 480e48354ceSNicholas Bellinger { 481e48354ceSNicholas Bellinger int ret = 0; 482e48354ceSNicholas Bellinger 483e48354ceSNicholas Bellinger pr_debug("iSCSI-Target "ISCSIT_VERSION"\n"); 484e48354ceSNicholas Bellinger 485e48354ceSNicholas Bellinger iscsit_global = kzalloc(sizeof(struct iscsit_global), GFP_KERNEL); 486e48354ceSNicholas Bellinger if (!iscsit_global) { 487e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for iscsit_global\n"); 488e48354ceSNicholas Bellinger return -1; 489e48354ceSNicholas Bellinger } 490e48354ceSNicholas Bellinger mutex_init(&auth_id_lock); 491e48354ceSNicholas Bellinger spin_lock_init(&sess_idr_lock); 492e48354ceSNicholas Bellinger idr_init(&tiqn_idr); 493e48354ceSNicholas Bellinger idr_init(&sess_idr); 494e48354ceSNicholas Bellinger 495e48354ceSNicholas Bellinger ret = iscsi_target_register_configfs(); 496e48354ceSNicholas Bellinger if (ret < 0) 497e48354ceSNicholas Bellinger goto out; 498e48354ceSNicholas Bellinger 499e48354ceSNicholas Bellinger ret = iscsi_thread_set_init(); 500e48354ceSNicholas Bellinger if (ret < 0) 501e48354ceSNicholas Bellinger goto configfs_out; 502e48354ceSNicholas Bellinger 503e48354ceSNicholas Bellinger if (iscsi_allocate_thread_sets(TARGET_THREAD_SET_COUNT) != 504e48354ceSNicholas Bellinger TARGET_THREAD_SET_COUNT) { 505e48354ceSNicholas Bellinger pr_err("iscsi_allocate_thread_sets() returned" 506e48354ceSNicholas Bellinger " unexpected value!\n"); 507e48354ceSNicholas Bellinger goto ts_out1; 508e48354ceSNicholas Bellinger } 509e48354ceSNicholas Bellinger 510e48354ceSNicholas Bellinger lio_cmd_cache = kmem_cache_create("lio_cmd_cache", 511e48354ceSNicholas Bellinger sizeof(struct iscsi_cmd), __alignof__(struct iscsi_cmd), 512e48354ceSNicholas Bellinger 0, NULL); 513e48354ceSNicholas Bellinger if (!lio_cmd_cache) { 514e48354ceSNicholas Bellinger pr_err("Unable to kmem_cache_create() for" 515e48354ceSNicholas Bellinger " lio_cmd_cache\n"); 516e48354ceSNicholas Bellinger goto ts_out2; 517e48354ceSNicholas Bellinger } 518e48354ceSNicholas Bellinger 519e48354ceSNicholas Bellinger lio_qr_cache = kmem_cache_create("lio_qr_cache", 520e48354ceSNicholas Bellinger sizeof(struct iscsi_queue_req), 521e48354ceSNicholas Bellinger __alignof__(struct iscsi_queue_req), 0, NULL); 522e48354ceSNicholas Bellinger if (!lio_qr_cache) { 523e48354ceSNicholas Bellinger pr_err("nable to kmem_cache_create() for" 524e48354ceSNicholas Bellinger " lio_qr_cache\n"); 525e48354ceSNicholas Bellinger goto cmd_out; 526e48354ceSNicholas Bellinger } 527e48354ceSNicholas Bellinger 528e48354ceSNicholas Bellinger lio_dr_cache = kmem_cache_create("lio_dr_cache", 529e48354ceSNicholas Bellinger sizeof(struct iscsi_datain_req), 530e48354ceSNicholas Bellinger __alignof__(struct iscsi_datain_req), 0, NULL); 531e48354ceSNicholas Bellinger if (!lio_dr_cache) { 532e48354ceSNicholas Bellinger pr_err("Unable to kmem_cache_create() for" 533e48354ceSNicholas Bellinger " lio_dr_cache\n"); 534e48354ceSNicholas Bellinger goto qr_out; 535e48354ceSNicholas Bellinger } 536e48354ceSNicholas Bellinger 537e48354ceSNicholas Bellinger lio_ooo_cache = kmem_cache_create("lio_ooo_cache", 538e48354ceSNicholas Bellinger sizeof(struct iscsi_ooo_cmdsn), 539e48354ceSNicholas Bellinger __alignof__(struct iscsi_ooo_cmdsn), 0, NULL); 540e48354ceSNicholas Bellinger if (!lio_ooo_cache) { 541e48354ceSNicholas Bellinger pr_err("Unable to kmem_cache_create() for" 542e48354ceSNicholas Bellinger " lio_ooo_cache\n"); 543e48354ceSNicholas Bellinger goto dr_out; 544e48354ceSNicholas Bellinger } 545e48354ceSNicholas Bellinger 546e48354ceSNicholas Bellinger lio_r2t_cache = kmem_cache_create("lio_r2t_cache", 547e48354ceSNicholas Bellinger sizeof(struct iscsi_r2t), __alignof__(struct iscsi_r2t), 548e48354ceSNicholas Bellinger 0, NULL); 549e48354ceSNicholas Bellinger if (!lio_r2t_cache) { 550e48354ceSNicholas Bellinger pr_err("Unable to kmem_cache_create() for" 551e48354ceSNicholas Bellinger " lio_r2t_cache\n"); 552e48354ceSNicholas Bellinger goto ooo_out; 553e48354ceSNicholas Bellinger } 554e48354ceSNicholas Bellinger 555e48354ceSNicholas Bellinger if (iscsit_load_discovery_tpg() < 0) 556e48354ceSNicholas Bellinger goto r2t_out; 557e48354ceSNicholas Bellinger 558e48354ceSNicholas Bellinger return ret; 559e48354ceSNicholas Bellinger r2t_out: 560e48354ceSNicholas Bellinger kmem_cache_destroy(lio_r2t_cache); 561e48354ceSNicholas Bellinger ooo_out: 562e48354ceSNicholas Bellinger kmem_cache_destroy(lio_ooo_cache); 563e48354ceSNicholas Bellinger dr_out: 564e48354ceSNicholas Bellinger kmem_cache_destroy(lio_dr_cache); 565e48354ceSNicholas Bellinger qr_out: 566e48354ceSNicholas Bellinger kmem_cache_destroy(lio_qr_cache); 567e48354ceSNicholas Bellinger cmd_out: 568e48354ceSNicholas Bellinger kmem_cache_destroy(lio_cmd_cache); 569e48354ceSNicholas Bellinger ts_out2: 570e48354ceSNicholas Bellinger iscsi_deallocate_thread_sets(); 571e48354ceSNicholas Bellinger ts_out1: 572e48354ceSNicholas Bellinger iscsi_thread_set_free(); 573e48354ceSNicholas Bellinger configfs_out: 574e48354ceSNicholas Bellinger iscsi_target_deregister_configfs(); 575e48354ceSNicholas Bellinger out: 576e48354ceSNicholas Bellinger kfree(iscsit_global); 577e48354ceSNicholas Bellinger return -ENOMEM; 578e48354ceSNicholas Bellinger } 579e48354ceSNicholas Bellinger 580e48354ceSNicholas Bellinger static void __exit iscsi_target_cleanup_module(void) 581e48354ceSNicholas Bellinger { 582e48354ceSNicholas Bellinger iscsi_deallocate_thread_sets(); 583e48354ceSNicholas Bellinger iscsi_thread_set_free(); 584e48354ceSNicholas Bellinger iscsit_release_discovery_tpg(); 585e48354ceSNicholas Bellinger kmem_cache_destroy(lio_cmd_cache); 586e48354ceSNicholas Bellinger kmem_cache_destroy(lio_qr_cache); 587e48354ceSNicholas Bellinger kmem_cache_destroy(lio_dr_cache); 588e48354ceSNicholas Bellinger kmem_cache_destroy(lio_ooo_cache); 589e48354ceSNicholas Bellinger kmem_cache_destroy(lio_r2t_cache); 590e48354ceSNicholas Bellinger 591e48354ceSNicholas Bellinger iscsi_target_deregister_configfs(); 592e48354ceSNicholas Bellinger 593e48354ceSNicholas Bellinger kfree(iscsit_global); 594e48354ceSNicholas Bellinger } 595e48354ceSNicholas Bellinger 596e48354ceSNicholas Bellinger int iscsit_add_reject( 597e48354ceSNicholas Bellinger u8 reason, 598e48354ceSNicholas Bellinger int fail_conn, 599e48354ceSNicholas Bellinger unsigned char *buf, 600e48354ceSNicholas Bellinger struct iscsi_conn *conn) 601e48354ceSNicholas Bellinger { 602e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 603e48354ceSNicholas Bellinger struct iscsi_reject *hdr; 604e48354ceSNicholas Bellinger int ret; 605e48354ceSNicholas Bellinger 606e48354ceSNicholas Bellinger cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 607e48354ceSNicholas Bellinger if (!cmd) 608e48354ceSNicholas Bellinger return -1; 609e48354ceSNicholas Bellinger 610e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_REJECT; 611e48354ceSNicholas Bellinger if (fail_conn) 612e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_REJECT_FAIL_CONN; 613e48354ceSNicholas Bellinger 614e48354ceSNicholas Bellinger hdr = (struct iscsi_reject *) cmd->pdu; 615e48354ceSNicholas Bellinger hdr->reason = reason; 616e48354ceSNicholas Bellinger 617e48354ceSNicholas Bellinger cmd->buf_ptr = kzalloc(ISCSI_HDR_LEN, GFP_KERNEL); 618e48354ceSNicholas Bellinger if (!cmd->buf_ptr) { 619e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for cmd->buf_ptr\n"); 620e48354ceSNicholas Bellinger iscsit_release_cmd(cmd); 621e48354ceSNicholas Bellinger return -1; 622e48354ceSNicholas Bellinger } 623e48354ceSNicholas Bellinger memcpy(cmd->buf_ptr, buf, ISCSI_HDR_LEN); 624e48354ceSNicholas Bellinger 625e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 626e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 627e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 628e48354ceSNicholas Bellinger 629e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_REJECT; 630e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 631e48354ceSNicholas Bellinger 632e48354ceSNicholas Bellinger ret = wait_for_completion_interruptible(&cmd->reject_comp); 633e48354ceSNicholas Bellinger if (ret != 0) 634e48354ceSNicholas Bellinger return -1; 635e48354ceSNicholas Bellinger 636e48354ceSNicholas Bellinger return (!fail_conn) ? 0 : -1; 637e48354ceSNicholas Bellinger } 638e48354ceSNicholas Bellinger 639e48354ceSNicholas Bellinger int iscsit_add_reject_from_cmd( 640e48354ceSNicholas Bellinger u8 reason, 641e48354ceSNicholas Bellinger int fail_conn, 642e48354ceSNicholas Bellinger int add_to_conn, 643e48354ceSNicholas Bellinger unsigned char *buf, 644e48354ceSNicholas Bellinger struct iscsi_cmd *cmd) 645e48354ceSNicholas Bellinger { 646e48354ceSNicholas Bellinger struct iscsi_conn *conn; 647e48354ceSNicholas Bellinger struct iscsi_reject *hdr; 648e48354ceSNicholas Bellinger int ret; 649e48354ceSNicholas Bellinger 650e48354ceSNicholas Bellinger if (!cmd->conn) { 651e48354ceSNicholas Bellinger pr_err("cmd->conn is NULL for ITT: 0x%08x\n", 652e48354ceSNicholas Bellinger cmd->init_task_tag); 653e48354ceSNicholas Bellinger return -1; 654e48354ceSNicholas Bellinger } 655e48354ceSNicholas Bellinger conn = cmd->conn; 656e48354ceSNicholas Bellinger 657e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_REJECT; 658e48354ceSNicholas Bellinger if (fail_conn) 659e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_REJECT_FAIL_CONN; 660e48354ceSNicholas Bellinger 661e48354ceSNicholas Bellinger hdr = (struct iscsi_reject *) cmd->pdu; 662e48354ceSNicholas Bellinger hdr->reason = reason; 663e48354ceSNicholas Bellinger 664e48354ceSNicholas Bellinger cmd->buf_ptr = kzalloc(ISCSI_HDR_LEN, GFP_KERNEL); 665e48354ceSNicholas Bellinger if (!cmd->buf_ptr) { 666e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for cmd->buf_ptr\n"); 667e48354ceSNicholas Bellinger iscsit_release_cmd(cmd); 668e48354ceSNicholas Bellinger return -1; 669e48354ceSNicholas Bellinger } 670e48354ceSNicholas Bellinger memcpy(cmd->buf_ptr, buf, ISCSI_HDR_LEN); 671e48354ceSNicholas Bellinger 672e48354ceSNicholas Bellinger if (add_to_conn) { 673e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 674e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 675e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 676e48354ceSNicholas Bellinger } 677e48354ceSNicholas Bellinger 678e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_REJECT; 679e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 680e48354ceSNicholas Bellinger 681e48354ceSNicholas Bellinger ret = wait_for_completion_interruptible(&cmd->reject_comp); 682e48354ceSNicholas Bellinger if (ret != 0) 683e48354ceSNicholas Bellinger return -1; 684e48354ceSNicholas Bellinger 685e48354ceSNicholas Bellinger return (!fail_conn) ? 0 : -1; 686e48354ceSNicholas Bellinger } 687e48354ceSNicholas Bellinger 688e48354ceSNicholas Bellinger /* 689e48354ceSNicholas Bellinger * Map some portion of the allocated scatterlist to an iovec, suitable for 690e48354ceSNicholas Bellinger * kernel sockets to copy data in/out. This handles both pages and slab-allocated 691e48354ceSNicholas Bellinger * buffers, since we have been tricky and mapped t_mem_sg to the buffer in 692e48354ceSNicholas Bellinger * either case (see iscsit_alloc_buffs) 693e48354ceSNicholas Bellinger */ 694e48354ceSNicholas Bellinger static int iscsit_map_iovec( 695e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 696e48354ceSNicholas Bellinger struct kvec *iov, 697e48354ceSNicholas Bellinger u32 data_offset, 698e48354ceSNicholas Bellinger u32 data_length) 699e48354ceSNicholas Bellinger { 700e48354ceSNicholas Bellinger u32 i = 0; 701e48354ceSNicholas Bellinger struct scatterlist *sg; 702e48354ceSNicholas Bellinger unsigned int page_off; 703e48354ceSNicholas Bellinger 704e48354ceSNicholas Bellinger /* 705e48354ceSNicholas Bellinger * We have a private mapping of the allocated pages in t_mem_sg. 706e48354ceSNicholas Bellinger * At this point, we also know each contains a page. 707e48354ceSNicholas Bellinger */ 708e48354ceSNicholas Bellinger sg = &cmd->t_mem_sg[data_offset / PAGE_SIZE]; 709e48354ceSNicholas Bellinger page_off = (data_offset % PAGE_SIZE); 710e48354ceSNicholas Bellinger 711e48354ceSNicholas Bellinger cmd->first_data_sg = sg; 712e48354ceSNicholas Bellinger cmd->first_data_sg_off = page_off; 713e48354ceSNicholas Bellinger 714e48354ceSNicholas Bellinger while (data_length) { 715e48354ceSNicholas Bellinger u32 cur_len = min_t(u32, data_length, sg->length - page_off); 716e48354ceSNicholas Bellinger 717e48354ceSNicholas Bellinger iov[i].iov_base = kmap(sg_page(sg)) + sg->offset + page_off; 718e48354ceSNicholas Bellinger iov[i].iov_len = cur_len; 719e48354ceSNicholas Bellinger 720e48354ceSNicholas Bellinger data_length -= cur_len; 721e48354ceSNicholas Bellinger page_off = 0; 722e48354ceSNicholas Bellinger sg = sg_next(sg); 723e48354ceSNicholas Bellinger i++; 724e48354ceSNicholas Bellinger } 725e48354ceSNicholas Bellinger 726e48354ceSNicholas Bellinger cmd->kmapped_nents = i; 727e48354ceSNicholas Bellinger 728e48354ceSNicholas Bellinger return i; 729e48354ceSNicholas Bellinger } 730e48354ceSNicholas Bellinger 731e48354ceSNicholas Bellinger static void iscsit_unmap_iovec(struct iscsi_cmd *cmd) 732e48354ceSNicholas Bellinger { 733e48354ceSNicholas Bellinger u32 i; 734e48354ceSNicholas Bellinger struct scatterlist *sg; 735e48354ceSNicholas Bellinger 736e48354ceSNicholas Bellinger sg = cmd->first_data_sg; 737e48354ceSNicholas Bellinger 738e48354ceSNicholas Bellinger for (i = 0; i < cmd->kmapped_nents; i++) 739e48354ceSNicholas Bellinger kunmap(sg_page(&sg[i])); 740e48354ceSNicholas Bellinger } 741e48354ceSNicholas Bellinger 742e48354ceSNicholas Bellinger static void iscsit_ack_from_expstatsn(struct iscsi_conn *conn, u32 exp_statsn) 743e48354ceSNicholas Bellinger { 744e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 745e48354ceSNicholas Bellinger 746e48354ceSNicholas Bellinger conn->exp_statsn = exp_statsn; 747e48354ceSNicholas Bellinger 748e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 749e48354ceSNicholas Bellinger list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 750e48354ceSNicholas Bellinger spin_lock(&cmd->istate_lock); 751e48354ceSNicholas Bellinger if ((cmd->i_state == ISTATE_SENT_STATUS) && 752e48354ceSNicholas Bellinger (cmd->stat_sn < exp_statsn)) { 753e48354ceSNicholas Bellinger cmd->i_state = ISTATE_REMOVE; 754e48354ceSNicholas Bellinger spin_unlock(&cmd->istate_lock); 755e48354ceSNicholas Bellinger iscsit_add_cmd_to_immediate_queue(cmd, conn, 756e48354ceSNicholas Bellinger cmd->i_state); 757e48354ceSNicholas Bellinger continue; 758e48354ceSNicholas Bellinger } 759e48354ceSNicholas Bellinger spin_unlock(&cmd->istate_lock); 760e48354ceSNicholas Bellinger } 761e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 762e48354ceSNicholas Bellinger } 763e48354ceSNicholas Bellinger 764e48354ceSNicholas Bellinger static int iscsit_allocate_iovecs(struct iscsi_cmd *cmd) 765e48354ceSNicholas Bellinger { 766e48354ceSNicholas Bellinger u32 iov_count = (cmd->se_cmd.t_data_nents == 0) ? 1 : 767e48354ceSNicholas Bellinger cmd->se_cmd.t_data_nents; 768e48354ceSNicholas Bellinger 769c0427f15SChristoph Hellwig iov_count += ISCSI_IOV_DATA_BUFFER; 770e48354ceSNicholas Bellinger 771e48354ceSNicholas Bellinger cmd->iov_data = kzalloc(iov_count * sizeof(struct kvec), GFP_KERNEL); 772e48354ceSNicholas Bellinger if (!cmd->iov_data) { 773e48354ceSNicholas Bellinger pr_err("Unable to allocate cmd->iov_data\n"); 774e48354ceSNicholas Bellinger return -ENOMEM; 775e48354ceSNicholas Bellinger } 776e48354ceSNicholas Bellinger 777e48354ceSNicholas Bellinger cmd->orig_iov_data_count = iov_count; 778e48354ceSNicholas Bellinger return 0; 779e48354ceSNicholas Bellinger } 780e48354ceSNicholas Bellinger 781e48354ceSNicholas Bellinger static int iscsit_alloc_buffs(struct iscsi_cmd *cmd) 782e48354ceSNicholas Bellinger { 783e48354ceSNicholas Bellinger struct scatterlist *sgl; 784e48354ceSNicholas Bellinger u32 length = cmd->se_cmd.data_length; 785e48354ceSNicholas Bellinger int nents = DIV_ROUND_UP(length, PAGE_SIZE); 786e48354ceSNicholas Bellinger int i = 0, ret; 787e48354ceSNicholas Bellinger /* 788e48354ceSNicholas Bellinger * If no SCSI payload is present, allocate the default iovecs used for 789e48354ceSNicholas Bellinger * iSCSI PDU Header 790e48354ceSNicholas Bellinger */ 791e48354ceSNicholas Bellinger if (!length) 792e48354ceSNicholas Bellinger return iscsit_allocate_iovecs(cmd); 793e48354ceSNicholas Bellinger 794e48354ceSNicholas Bellinger sgl = kzalloc(sizeof(*sgl) * nents, GFP_KERNEL); 795e48354ceSNicholas Bellinger if (!sgl) 796e48354ceSNicholas Bellinger return -ENOMEM; 797e48354ceSNicholas Bellinger 798e48354ceSNicholas Bellinger sg_init_table(sgl, nents); 799e48354ceSNicholas Bellinger 800e48354ceSNicholas Bellinger while (length) { 801e48354ceSNicholas Bellinger int buf_size = min_t(int, length, PAGE_SIZE); 802e48354ceSNicholas Bellinger struct page *page; 803e48354ceSNicholas Bellinger 804e48354ceSNicholas Bellinger page = alloc_page(GFP_KERNEL | __GFP_ZERO); 805e48354ceSNicholas Bellinger if (!page) 806e48354ceSNicholas Bellinger goto page_alloc_failed; 807e48354ceSNicholas Bellinger 808e48354ceSNicholas Bellinger sg_set_page(&sgl[i], page, buf_size, 0); 809e48354ceSNicholas Bellinger 810e48354ceSNicholas Bellinger length -= buf_size; 811e48354ceSNicholas Bellinger i++; 812e48354ceSNicholas Bellinger } 813e48354ceSNicholas Bellinger 814e48354ceSNicholas Bellinger cmd->t_mem_sg = sgl; 815e48354ceSNicholas Bellinger cmd->t_mem_sg_nents = nents; 816e48354ceSNicholas Bellinger 817e48354ceSNicholas Bellinger /* BIDI ops not supported */ 818e48354ceSNicholas Bellinger 819e48354ceSNicholas Bellinger /* Tell the core about our preallocated memory */ 820e48354ceSNicholas Bellinger transport_generic_map_mem_to_cmd(&cmd->se_cmd, sgl, nents, NULL, 0); 821e48354ceSNicholas Bellinger /* 822e48354ceSNicholas Bellinger * Allocate iovecs for SCSI payload after transport_generic_map_mem_to_cmd 823e48354ceSNicholas Bellinger * so that cmd->se_cmd.t_tasks_se_num has been set. 824e48354ceSNicholas Bellinger */ 825e48354ceSNicholas Bellinger ret = iscsit_allocate_iovecs(cmd); 826e48354ceSNicholas Bellinger if (ret < 0) 827e48354ceSNicholas Bellinger goto page_alloc_failed; 828e48354ceSNicholas Bellinger 829e48354ceSNicholas Bellinger return 0; 830e48354ceSNicholas Bellinger 831e48354ceSNicholas Bellinger page_alloc_failed: 832e48354ceSNicholas Bellinger while (i >= 0) { 833e48354ceSNicholas Bellinger __free_page(sg_page(&sgl[i])); 834e48354ceSNicholas Bellinger i--; 835e48354ceSNicholas Bellinger } 836e48354ceSNicholas Bellinger kfree(cmd->t_mem_sg); 837e48354ceSNicholas Bellinger cmd->t_mem_sg = NULL; 838e48354ceSNicholas Bellinger return -ENOMEM; 839e48354ceSNicholas Bellinger } 840e48354ceSNicholas Bellinger 841e48354ceSNicholas Bellinger static int iscsit_handle_scsi_cmd( 842e48354ceSNicholas Bellinger struct iscsi_conn *conn, 843e48354ceSNicholas Bellinger unsigned char *buf) 844e48354ceSNicholas Bellinger { 845e48354ceSNicholas Bellinger int data_direction, cmdsn_ret = 0, immed_ret, ret, transport_ret; 846e48354ceSNicholas Bellinger int dump_immediate_data = 0, send_check_condition = 0, payload_length; 847e48354ceSNicholas Bellinger struct iscsi_cmd *cmd = NULL; 848e48354ceSNicholas Bellinger struct iscsi_scsi_req *hdr; 849e48354ceSNicholas Bellinger 850e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->session_stats_lock); 851e48354ceSNicholas Bellinger conn->sess->cmd_pdus++; 852e48354ceSNicholas Bellinger if (conn->sess->se_sess->se_node_acl) { 853e48354ceSNicholas Bellinger spin_lock(&conn->sess->se_sess->se_node_acl->stats_lock); 854e48354ceSNicholas Bellinger conn->sess->se_sess->se_node_acl->num_cmds++; 855e48354ceSNicholas Bellinger spin_unlock(&conn->sess->se_sess->se_node_acl->stats_lock); 856e48354ceSNicholas Bellinger } 857e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->session_stats_lock); 858e48354ceSNicholas Bellinger 859e48354ceSNicholas Bellinger hdr = (struct iscsi_scsi_req *) buf; 860e48354ceSNicholas Bellinger payload_length = ntoh24(hdr->dlength); 861e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 862e48354ceSNicholas Bellinger hdr->data_length = be32_to_cpu(hdr->data_length); 863e48354ceSNicholas Bellinger hdr->cmdsn = be32_to_cpu(hdr->cmdsn); 864e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 865e48354ceSNicholas Bellinger 866e48354ceSNicholas Bellinger /* FIXME; Add checks for AdditionalHeaderSegment */ 867e48354ceSNicholas Bellinger 868e48354ceSNicholas Bellinger if (!(hdr->flags & ISCSI_FLAG_CMD_WRITE) && 869e48354ceSNicholas Bellinger !(hdr->flags & ISCSI_FLAG_CMD_FINAL)) { 870e48354ceSNicholas Bellinger pr_err("ISCSI_FLAG_CMD_WRITE & ISCSI_FLAG_CMD_FINAL" 871e48354ceSNicholas Bellinger " not set. Bad iSCSI Initiator.\n"); 872e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 873e48354ceSNicholas Bellinger buf, conn); 874e48354ceSNicholas Bellinger } 875e48354ceSNicholas Bellinger 876e48354ceSNicholas Bellinger if (((hdr->flags & ISCSI_FLAG_CMD_READ) || 877e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_WRITE)) && !hdr->data_length) { 878e48354ceSNicholas Bellinger /* 879e48354ceSNicholas Bellinger * Vmware ESX v3.0 uses a modified Cisco Initiator (v3.4.2) 880e48354ceSNicholas Bellinger * that adds support for RESERVE/RELEASE. There is a bug 881e48354ceSNicholas Bellinger * add with this new functionality that sets R/W bits when 882e48354ceSNicholas Bellinger * neither CDB carries any READ or WRITE datapayloads. 883e48354ceSNicholas Bellinger */ 884e48354ceSNicholas Bellinger if ((hdr->cdb[0] == 0x16) || (hdr->cdb[0] == 0x17)) { 885e48354ceSNicholas Bellinger hdr->flags &= ~ISCSI_FLAG_CMD_READ; 886e48354ceSNicholas Bellinger hdr->flags &= ~ISCSI_FLAG_CMD_WRITE; 887e48354ceSNicholas Bellinger goto done; 888e48354ceSNicholas Bellinger } 889e48354ceSNicholas Bellinger 890e48354ceSNicholas Bellinger pr_err("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE" 891e48354ceSNicholas Bellinger " set when Expected Data Transfer Length is 0 for" 892e48354ceSNicholas Bellinger " CDB: 0x%02x. Bad iSCSI Initiator.\n", hdr->cdb[0]); 893e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 894e48354ceSNicholas Bellinger buf, conn); 895e48354ceSNicholas Bellinger } 896e48354ceSNicholas Bellinger done: 897e48354ceSNicholas Bellinger 898e48354ceSNicholas Bellinger if (!(hdr->flags & ISCSI_FLAG_CMD_READ) && 899e48354ceSNicholas Bellinger !(hdr->flags & ISCSI_FLAG_CMD_WRITE) && (hdr->data_length != 0)) { 900e48354ceSNicholas Bellinger pr_err("ISCSI_FLAG_CMD_READ and/or ISCSI_FLAG_CMD_WRITE" 901e48354ceSNicholas Bellinger " MUST be set if Expected Data Transfer Length is not 0." 902e48354ceSNicholas Bellinger " Bad iSCSI Initiator\n"); 903e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 904e48354ceSNicholas Bellinger buf, conn); 905e48354ceSNicholas Bellinger } 906e48354ceSNicholas Bellinger 907e48354ceSNicholas Bellinger if ((hdr->flags & ISCSI_FLAG_CMD_READ) && 908e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_WRITE)) { 909e48354ceSNicholas Bellinger pr_err("Bidirectional operations not supported!\n"); 910e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 911e48354ceSNicholas Bellinger buf, conn); 912e48354ceSNicholas Bellinger } 913e48354ceSNicholas Bellinger 914e48354ceSNicholas Bellinger if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 915e48354ceSNicholas Bellinger pr_err("Illegally set Immediate Bit in iSCSI Initiator" 916e48354ceSNicholas Bellinger " Scsi Command PDU.\n"); 917e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 918e48354ceSNicholas Bellinger buf, conn); 919e48354ceSNicholas Bellinger } 920e48354ceSNicholas Bellinger 921e48354ceSNicholas Bellinger if (payload_length && !conn->sess->sess_ops->ImmediateData) { 922e48354ceSNicholas Bellinger pr_err("ImmediateData=No but DataSegmentLength=%u," 923e48354ceSNicholas Bellinger " protocol error.\n", payload_length); 924e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 925e48354ceSNicholas Bellinger buf, conn); 926e48354ceSNicholas Bellinger } 927e48354ceSNicholas Bellinger 928e48354ceSNicholas Bellinger if ((hdr->data_length == payload_length) && 929e48354ceSNicholas Bellinger (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))) { 930e48354ceSNicholas Bellinger pr_err("Expected Data Transfer Length and Length of" 931e48354ceSNicholas Bellinger " Immediate Data are the same, but ISCSI_FLAG_CMD_FINAL" 932e48354ceSNicholas Bellinger " bit is not set protocol error\n"); 933e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 934e48354ceSNicholas Bellinger buf, conn); 935e48354ceSNicholas Bellinger } 936e48354ceSNicholas Bellinger 937e48354ceSNicholas Bellinger if (payload_length > hdr->data_length) { 938e48354ceSNicholas Bellinger pr_err("DataSegmentLength: %u is greater than" 939e48354ceSNicholas Bellinger " EDTL: %u, protocol error.\n", payload_length, 940e48354ceSNicholas Bellinger hdr->data_length); 941e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 942e48354ceSNicholas Bellinger buf, conn); 943e48354ceSNicholas Bellinger } 944e48354ceSNicholas Bellinger 945e48354ceSNicholas Bellinger if (payload_length > conn->conn_ops->MaxRecvDataSegmentLength) { 946e48354ceSNicholas Bellinger pr_err("DataSegmentLength: %u is greater than" 947e48354ceSNicholas Bellinger " MaxRecvDataSegmentLength: %u, protocol error.\n", 948e48354ceSNicholas Bellinger payload_length, conn->conn_ops->MaxRecvDataSegmentLength); 949e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 950e48354ceSNicholas Bellinger buf, conn); 951e48354ceSNicholas Bellinger } 952e48354ceSNicholas Bellinger 953e48354ceSNicholas Bellinger if (payload_length > conn->sess->sess_ops->FirstBurstLength) { 954e48354ceSNicholas Bellinger pr_err("DataSegmentLength: %u is greater than" 955e48354ceSNicholas Bellinger " FirstBurstLength: %u, protocol error.\n", 956e48354ceSNicholas Bellinger payload_length, conn->sess->sess_ops->FirstBurstLength); 957e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_INVALID, 1, 958e48354ceSNicholas Bellinger buf, conn); 959e48354ceSNicholas Bellinger } 960e48354ceSNicholas Bellinger 961e48354ceSNicholas Bellinger data_direction = (hdr->flags & ISCSI_FLAG_CMD_WRITE) ? DMA_TO_DEVICE : 962e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_READ) ? DMA_FROM_DEVICE : 963e48354ceSNicholas Bellinger DMA_NONE; 964e48354ceSNicholas Bellinger 965e48354ceSNicholas Bellinger cmd = iscsit_allocate_se_cmd(conn, hdr->data_length, data_direction, 966e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_ATTR_MASK)); 967e48354ceSNicholas Bellinger if (!cmd) 968e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1, 969e48354ceSNicholas Bellinger buf, conn); 970e48354ceSNicholas Bellinger 971e48354ceSNicholas Bellinger pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x," 972e48354ceSNicholas Bellinger " ExpXferLen: %u, Length: %u, CID: %hu\n", hdr->itt, 973e48354ceSNicholas Bellinger hdr->cmdsn, hdr->data_length, payload_length, conn->cid); 974e48354ceSNicholas Bellinger 975e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD; 976e48354ceSNicholas Bellinger cmd->i_state = ISTATE_NEW_CMD; 977e48354ceSNicholas Bellinger cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0); 978e48354ceSNicholas Bellinger cmd->immediate_data = (payload_length) ? 1 : 0; 979e48354ceSNicholas Bellinger cmd->unsolicited_data = ((!(hdr->flags & ISCSI_FLAG_CMD_FINAL) && 980e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_WRITE)) ? 1 : 0); 981e48354ceSNicholas Bellinger if (cmd->unsolicited_data) 982e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_NON_IMMEDIATE_UNSOLICITED_DATA; 983e48354ceSNicholas Bellinger 984e48354ceSNicholas Bellinger conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt; 985e48354ceSNicholas Bellinger if (hdr->flags & ISCSI_FLAG_CMD_READ) { 986e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->ttt_lock); 987e48354ceSNicholas Bellinger cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++; 988e48354ceSNicholas Bellinger if (cmd->targ_xfer_tag == 0xFFFFFFFF) 989e48354ceSNicholas Bellinger cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++; 990e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->ttt_lock); 991e48354ceSNicholas Bellinger } else if (hdr->flags & ISCSI_FLAG_CMD_WRITE) 992e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 993e48354ceSNicholas Bellinger cmd->cmd_sn = hdr->cmdsn; 994e48354ceSNicholas Bellinger cmd->exp_stat_sn = hdr->exp_statsn; 995e48354ceSNicholas Bellinger cmd->first_burst_len = payload_length; 996e48354ceSNicholas Bellinger 997e48354ceSNicholas Bellinger if (cmd->data_direction == DMA_FROM_DEVICE) { 998e48354ceSNicholas Bellinger struct iscsi_datain_req *dr; 999e48354ceSNicholas Bellinger 1000e48354ceSNicholas Bellinger dr = iscsit_allocate_datain_req(); 1001e48354ceSNicholas Bellinger if (!dr) 1002e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1003e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1004e48354ceSNicholas Bellinger 1, 1, buf, cmd); 1005e48354ceSNicholas Bellinger 1006e48354ceSNicholas Bellinger iscsit_attach_datain_req(cmd, dr); 1007e48354ceSNicholas Bellinger } 1008e48354ceSNicholas Bellinger 1009e48354ceSNicholas Bellinger /* 1010e48354ceSNicholas Bellinger * The CDB is going to an se_device_t. 1011e48354ceSNicholas Bellinger */ 1012e48354ceSNicholas Bellinger ret = iscsit_get_lun_for_cmd(cmd, hdr->cdb, 1013e48354ceSNicholas Bellinger get_unaligned_le64(&hdr->lun)); 1014e48354ceSNicholas Bellinger if (ret < 0) { 1015e48354ceSNicholas Bellinger if (cmd->se_cmd.scsi_sense_reason == TCM_NON_EXISTENT_LUN) { 1016e48354ceSNicholas Bellinger pr_debug("Responding to non-acl'ed," 1017e48354ceSNicholas Bellinger " non-existent or non-exported iSCSI LUN:" 1018e48354ceSNicholas Bellinger " 0x%016Lx\n", get_unaligned_le64(&hdr->lun)); 1019e48354ceSNicholas Bellinger } 1020e48354ceSNicholas Bellinger send_check_condition = 1; 1021e48354ceSNicholas Bellinger goto attach_cmd; 1022e48354ceSNicholas Bellinger } 1023e48354ceSNicholas Bellinger /* 1024e48354ceSNicholas Bellinger * The Initiator Node has access to the LUN (the addressing method 1025e48354ceSNicholas Bellinger * is handled inside of iscsit_get_lun_for_cmd()). Now it's time to 1026e48354ceSNicholas Bellinger * allocate 1->N transport tasks (depending on sector count and 1027e48354ceSNicholas Bellinger * maximum request size the physical HBA(s) can handle. 1028e48354ceSNicholas Bellinger */ 1029e48354ceSNicholas Bellinger transport_ret = transport_generic_allocate_tasks(&cmd->se_cmd, hdr->cdb); 1030e48354ceSNicholas Bellinger if (transport_ret == -ENOMEM) { 1031e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1032e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1033e48354ceSNicholas Bellinger 1, 1, buf, cmd); 1034e48354ceSNicholas Bellinger } else if (transport_ret == -EINVAL) { 1035e48354ceSNicholas Bellinger /* 1036e48354ceSNicholas Bellinger * Unsupported SAM Opcode. CHECK_CONDITION will be sent 1037e48354ceSNicholas Bellinger * in iscsit_execute_cmd() during the CmdSN OOO Execution 1038e48354ceSNicholas Bellinger * Mechinism. 1039e48354ceSNicholas Bellinger */ 1040e48354ceSNicholas Bellinger send_check_condition = 1; 1041e48354ceSNicholas Bellinger } else { 10427e46cf02SNicholas Bellinger cmd->data_length = cmd->se_cmd.data_length; 10437e46cf02SNicholas Bellinger 1044e48354ceSNicholas Bellinger if (iscsit_decide_list_to_build(cmd, payload_length) < 0) 1045e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1046e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1047e48354ceSNicholas Bellinger 1, 1, buf, cmd); 1048e48354ceSNicholas Bellinger } 1049e48354ceSNicholas Bellinger 1050e48354ceSNicholas Bellinger attach_cmd: 1051e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 1052e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1053e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 1054e48354ceSNicholas Bellinger /* 1055e48354ceSNicholas Bellinger * Check if we need to delay processing because of ALUA 1056e48354ceSNicholas Bellinger * Active/NonOptimized primary access state.. 1057e48354ceSNicholas Bellinger */ 1058e48354ceSNicholas Bellinger core_alua_check_nonop_delay(&cmd->se_cmd); 1059e48354ceSNicholas Bellinger /* 1060e48354ceSNicholas Bellinger * Allocate and setup SGL used with transport_generic_map_mem_to_cmd(). 1061e48354ceSNicholas Bellinger * also call iscsit_allocate_iovecs() 1062e48354ceSNicholas Bellinger */ 1063e48354ceSNicholas Bellinger ret = iscsit_alloc_buffs(cmd); 1064e48354ceSNicholas Bellinger if (ret < 0) 1065e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1066e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1067e48354ceSNicholas Bellinger 1, 1, buf, cmd); 1068e48354ceSNicholas Bellinger /* 1069e48354ceSNicholas Bellinger * Check the CmdSN against ExpCmdSN/MaxCmdSN here if 1070e48354ceSNicholas Bellinger * the Immediate Bit is not set, and no Immediate 1071e48354ceSNicholas Bellinger * Data is attached. 1072e48354ceSNicholas Bellinger * 1073e48354ceSNicholas Bellinger * A PDU/CmdSN carrying Immediate Data can only 1074e48354ceSNicholas Bellinger * be processed after the DataCRC has passed. 1075e48354ceSNicholas Bellinger * If the DataCRC fails, the CmdSN MUST NOT 1076e48354ceSNicholas Bellinger * be acknowledged. (See below) 1077e48354ceSNicholas Bellinger */ 1078e48354ceSNicholas Bellinger if (!cmd->immediate_data) { 1079e48354ceSNicholas Bellinger cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 10807e32da55SNicholas Bellinger if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) 10817e32da55SNicholas Bellinger return 0; 10827e32da55SNicholas Bellinger else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1083e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1084e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 1085e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1086e48354ceSNicholas Bellinger } 1087e48354ceSNicholas Bellinger 1088e48354ceSNicholas Bellinger iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 1089e48354ceSNicholas Bellinger 1090e48354ceSNicholas Bellinger /* 1091e48354ceSNicholas Bellinger * If no Immediate Data is attached, it's OK to return now. 1092e48354ceSNicholas Bellinger */ 1093e48354ceSNicholas Bellinger if (!cmd->immediate_data) { 1094e48354ceSNicholas Bellinger if (send_check_condition) 1095e48354ceSNicholas Bellinger return 0; 1096e48354ceSNicholas Bellinger 1097e48354ceSNicholas Bellinger if (cmd->unsolicited_data) { 1098e48354ceSNicholas Bellinger iscsit_set_dataout_sequence_values(cmd); 1099e48354ceSNicholas Bellinger 1100e48354ceSNicholas Bellinger spin_lock_bh(&cmd->dataout_timeout_lock); 1101e48354ceSNicholas Bellinger iscsit_start_dataout_timer(cmd, cmd->conn); 1102e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->dataout_timeout_lock); 1103e48354ceSNicholas Bellinger } 1104e48354ceSNicholas Bellinger 1105e48354ceSNicholas Bellinger return 0; 1106e48354ceSNicholas Bellinger } 1107e48354ceSNicholas Bellinger 1108e48354ceSNicholas Bellinger /* 1109e48354ceSNicholas Bellinger * Early CHECK_CONDITIONs never make it to the transport processing 1110e48354ceSNicholas Bellinger * thread. They are processed in CmdSN order by 1111e48354ceSNicholas Bellinger * iscsit_check_received_cmdsn() below. 1112e48354ceSNicholas Bellinger */ 1113e48354ceSNicholas Bellinger if (send_check_condition) { 1114e48354ceSNicholas Bellinger immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION; 1115e48354ceSNicholas Bellinger dump_immediate_data = 1; 1116e48354ceSNicholas Bellinger goto after_immediate_data; 1117e48354ceSNicholas Bellinger } 1118e48354ceSNicholas Bellinger /* 1119e48354ceSNicholas Bellinger * Call directly into transport_generic_new_cmd() to perform 1120e48354ceSNicholas Bellinger * the backend memory allocation. 1121e48354ceSNicholas Bellinger */ 1122e48354ceSNicholas Bellinger ret = transport_generic_new_cmd(&cmd->se_cmd); 112303e98c9eSNicholas Bellinger if (ret < 0) { 1124e48354ceSNicholas Bellinger immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION; 1125e48354ceSNicholas Bellinger dump_immediate_data = 1; 1126e48354ceSNicholas Bellinger goto after_immediate_data; 1127e48354ceSNicholas Bellinger } 1128e48354ceSNicholas Bellinger 1129e48354ceSNicholas Bellinger immed_ret = iscsit_handle_immediate_data(cmd, buf, payload_length); 1130e48354ceSNicholas Bellinger after_immediate_data: 1131e48354ceSNicholas Bellinger if (immed_ret == IMMEDIATE_DATA_NORMAL_OPERATION) { 1132e48354ceSNicholas Bellinger /* 1133e48354ceSNicholas Bellinger * A PDU/CmdSN carrying Immediate Data passed 1134e48354ceSNicholas Bellinger * DataCRC, check against ExpCmdSN/MaxCmdSN if 1135e48354ceSNicholas Bellinger * Immediate Bit is not set. 1136e48354ceSNicholas Bellinger */ 1137e48354ceSNicholas Bellinger cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1138e48354ceSNicholas Bellinger /* 1139e48354ceSNicholas Bellinger * Special case for Unsupported SAM WRITE Opcodes 1140e48354ceSNicholas Bellinger * and ImmediateData=Yes. 1141e48354ceSNicholas Bellinger */ 1142e48354ceSNicholas Bellinger if (dump_immediate_data) { 1143e48354ceSNicholas Bellinger if (iscsit_dump_data_payload(conn, payload_length, 1) < 0) 1144e48354ceSNicholas Bellinger return -1; 1145e48354ceSNicholas Bellinger } else if (cmd->unsolicited_data) { 1146e48354ceSNicholas Bellinger iscsit_set_dataout_sequence_values(cmd); 1147e48354ceSNicholas Bellinger 1148e48354ceSNicholas Bellinger spin_lock_bh(&cmd->dataout_timeout_lock); 1149e48354ceSNicholas Bellinger iscsit_start_dataout_timer(cmd, cmd->conn); 1150e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->dataout_timeout_lock); 1151e48354ceSNicholas Bellinger } 1152e48354ceSNicholas Bellinger 1153e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1154e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1155e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 1156e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1157e48354ceSNicholas Bellinger 1158e48354ceSNicholas Bellinger } else if (immed_ret == IMMEDIATE_DATA_ERL1_CRC_FAILURE) { 1159e48354ceSNicholas Bellinger /* 1160e48354ceSNicholas Bellinger * Immediate Data failed DataCRC and ERL>=1, 1161e48354ceSNicholas Bellinger * silently drop this PDU and let the initiator 1162e48354ceSNicholas Bellinger * plug the CmdSN gap. 1163e48354ceSNicholas Bellinger * 1164e48354ceSNicholas Bellinger * FIXME: Send Unsolicited NOPIN with reserved 1165e48354ceSNicholas Bellinger * TTT here to help the initiator figure out 1166e48354ceSNicholas Bellinger * the missing CmdSN, although they should be 1167e48354ceSNicholas Bellinger * intelligent enough to determine the missing 1168e48354ceSNicholas Bellinger * CmdSN and issue a retry to plug the sequence. 1169e48354ceSNicholas Bellinger */ 1170e48354ceSNicholas Bellinger cmd->i_state = ISTATE_REMOVE; 1171e48354ceSNicholas Bellinger iscsit_add_cmd_to_immediate_queue(cmd, conn, cmd->i_state); 1172e48354ceSNicholas Bellinger } else /* immed_ret == IMMEDIATE_DATA_CANNOT_RECOVER */ 1173e48354ceSNicholas Bellinger return -1; 1174e48354ceSNicholas Bellinger 1175e48354ceSNicholas Bellinger return 0; 1176e48354ceSNicholas Bellinger } 1177e48354ceSNicholas Bellinger 1178e48354ceSNicholas Bellinger static u32 iscsit_do_crypto_hash_sg( 1179e48354ceSNicholas Bellinger struct hash_desc *hash, 1180e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 1181e48354ceSNicholas Bellinger u32 data_offset, 1182e48354ceSNicholas Bellinger u32 data_length, 1183e48354ceSNicholas Bellinger u32 padding, 1184e48354ceSNicholas Bellinger u8 *pad_bytes) 1185e48354ceSNicholas Bellinger { 1186e48354ceSNicholas Bellinger u32 data_crc; 1187e48354ceSNicholas Bellinger u32 i; 1188e48354ceSNicholas Bellinger struct scatterlist *sg; 1189e48354ceSNicholas Bellinger unsigned int page_off; 1190e48354ceSNicholas Bellinger 1191e48354ceSNicholas Bellinger crypto_hash_init(hash); 1192e48354ceSNicholas Bellinger 1193e48354ceSNicholas Bellinger sg = cmd->first_data_sg; 1194e48354ceSNicholas Bellinger page_off = cmd->first_data_sg_off; 1195e48354ceSNicholas Bellinger 1196e48354ceSNicholas Bellinger i = 0; 1197e48354ceSNicholas Bellinger while (data_length) { 1198e48354ceSNicholas Bellinger u32 cur_len = min_t(u32, data_length, (sg[i].length - page_off)); 1199e48354ceSNicholas Bellinger 1200e48354ceSNicholas Bellinger crypto_hash_update(hash, &sg[i], cur_len); 1201e48354ceSNicholas Bellinger 1202e48354ceSNicholas Bellinger data_length -= cur_len; 1203e48354ceSNicholas Bellinger page_off = 0; 1204e48354ceSNicholas Bellinger i++; 1205e48354ceSNicholas Bellinger } 1206e48354ceSNicholas Bellinger 1207e48354ceSNicholas Bellinger if (padding) { 1208e48354ceSNicholas Bellinger struct scatterlist pad_sg; 1209e48354ceSNicholas Bellinger 1210e48354ceSNicholas Bellinger sg_init_one(&pad_sg, pad_bytes, padding); 1211e48354ceSNicholas Bellinger crypto_hash_update(hash, &pad_sg, padding); 1212e48354ceSNicholas Bellinger } 1213e48354ceSNicholas Bellinger crypto_hash_final(hash, (u8 *) &data_crc); 1214e48354ceSNicholas Bellinger 1215e48354ceSNicholas Bellinger return data_crc; 1216e48354ceSNicholas Bellinger } 1217e48354ceSNicholas Bellinger 1218e48354ceSNicholas Bellinger static void iscsit_do_crypto_hash_buf( 1219e48354ceSNicholas Bellinger struct hash_desc *hash, 1220e48354ceSNicholas Bellinger unsigned char *buf, 1221e48354ceSNicholas Bellinger u32 payload_length, 1222e48354ceSNicholas Bellinger u32 padding, 1223e48354ceSNicholas Bellinger u8 *pad_bytes, 1224e48354ceSNicholas Bellinger u8 *data_crc) 1225e48354ceSNicholas Bellinger { 1226e48354ceSNicholas Bellinger struct scatterlist sg; 1227e48354ceSNicholas Bellinger 1228e48354ceSNicholas Bellinger crypto_hash_init(hash); 1229e48354ceSNicholas Bellinger 1230e48354ceSNicholas Bellinger sg_init_one(&sg, (u8 *)buf, payload_length); 1231e48354ceSNicholas Bellinger crypto_hash_update(hash, &sg, payload_length); 1232e48354ceSNicholas Bellinger 1233e48354ceSNicholas Bellinger if (padding) { 1234e48354ceSNicholas Bellinger sg_init_one(&sg, pad_bytes, padding); 1235e48354ceSNicholas Bellinger crypto_hash_update(hash, &sg, padding); 1236e48354ceSNicholas Bellinger } 1237e48354ceSNicholas Bellinger crypto_hash_final(hash, data_crc); 1238e48354ceSNicholas Bellinger } 1239e48354ceSNicholas Bellinger 1240e48354ceSNicholas Bellinger static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf) 1241e48354ceSNicholas Bellinger { 1242e48354ceSNicholas Bellinger int iov_ret, ooo_cmdsn = 0, ret; 1243e48354ceSNicholas Bellinger u8 data_crc_failed = 0; 1244e48354ceSNicholas Bellinger u32 checksum, iov_count = 0, padding = 0, rx_got = 0; 1245e48354ceSNicholas Bellinger u32 rx_size = 0, payload_length; 1246e48354ceSNicholas Bellinger struct iscsi_cmd *cmd = NULL; 1247e48354ceSNicholas Bellinger struct se_cmd *se_cmd; 1248e48354ceSNicholas Bellinger struct iscsi_data *hdr; 1249e48354ceSNicholas Bellinger struct kvec *iov; 1250e48354ceSNicholas Bellinger unsigned long flags; 1251e48354ceSNicholas Bellinger 1252e48354ceSNicholas Bellinger hdr = (struct iscsi_data *) buf; 1253e48354ceSNicholas Bellinger payload_length = ntoh24(hdr->dlength); 1254e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 1255e48354ceSNicholas Bellinger hdr->ttt = be32_to_cpu(hdr->ttt); 1256e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 1257e48354ceSNicholas Bellinger hdr->datasn = be32_to_cpu(hdr->datasn); 1258e48354ceSNicholas Bellinger hdr->offset = be32_to_cpu(hdr->offset); 1259e48354ceSNicholas Bellinger 1260e48354ceSNicholas Bellinger if (!payload_length) { 1261e48354ceSNicholas Bellinger pr_err("DataOUT payload is ZERO, protocol error.\n"); 1262e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1263e48354ceSNicholas Bellinger buf, conn); 1264e48354ceSNicholas Bellinger } 1265e48354ceSNicholas Bellinger 1266e48354ceSNicholas Bellinger /* iSCSI write */ 1267e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->session_stats_lock); 1268e48354ceSNicholas Bellinger conn->sess->rx_data_octets += payload_length; 1269e48354ceSNicholas Bellinger if (conn->sess->se_sess->se_node_acl) { 1270e48354ceSNicholas Bellinger spin_lock(&conn->sess->se_sess->se_node_acl->stats_lock); 1271e48354ceSNicholas Bellinger conn->sess->se_sess->se_node_acl->write_bytes += payload_length; 1272e48354ceSNicholas Bellinger spin_unlock(&conn->sess->se_sess->se_node_acl->stats_lock); 1273e48354ceSNicholas Bellinger } 1274e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->session_stats_lock); 1275e48354ceSNicholas Bellinger 1276e48354ceSNicholas Bellinger if (payload_length > conn->conn_ops->MaxRecvDataSegmentLength) { 1277e48354ceSNicholas Bellinger pr_err("DataSegmentLength: %u is greater than" 1278e48354ceSNicholas Bellinger " MaxRecvDataSegmentLength: %u\n", payload_length, 1279e48354ceSNicholas Bellinger conn->conn_ops->MaxRecvDataSegmentLength); 1280e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1281e48354ceSNicholas Bellinger buf, conn); 1282e48354ceSNicholas Bellinger } 1283e48354ceSNicholas Bellinger 1284e48354ceSNicholas Bellinger cmd = iscsit_find_cmd_from_itt_or_dump(conn, hdr->itt, 1285e48354ceSNicholas Bellinger payload_length); 1286e48354ceSNicholas Bellinger if (!cmd) 1287e48354ceSNicholas Bellinger return 0; 1288e48354ceSNicholas Bellinger 1289e48354ceSNicholas Bellinger pr_debug("Got DataOut ITT: 0x%08x, TTT: 0x%08x," 1290e48354ceSNicholas Bellinger " DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n", 1291e48354ceSNicholas Bellinger hdr->itt, hdr->ttt, hdr->datasn, hdr->offset, 1292e48354ceSNicholas Bellinger payload_length, conn->cid); 1293e48354ceSNicholas Bellinger 1294e48354ceSNicholas Bellinger if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) { 1295e48354ceSNicholas Bellinger pr_err("Command ITT: 0x%08x received DataOUT after" 1296e48354ceSNicholas Bellinger " last DataOUT received, dumping payload\n", 1297e48354ceSNicholas Bellinger cmd->init_task_tag); 1298e48354ceSNicholas Bellinger return iscsit_dump_data_payload(conn, payload_length, 1); 1299e48354ceSNicholas Bellinger } 1300e48354ceSNicholas Bellinger 1301e48354ceSNicholas Bellinger if (cmd->data_direction != DMA_TO_DEVICE) { 1302e48354ceSNicholas Bellinger pr_err("Command ITT: 0x%08x received DataOUT for a" 1303e48354ceSNicholas Bellinger " NON-WRITE command.\n", cmd->init_task_tag); 1304e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 1305e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1306e48354ceSNicholas Bellinger } 1307e48354ceSNicholas Bellinger se_cmd = &cmd->se_cmd; 1308e48354ceSNicholas Bellinger iscsit_mod_dataout_timer(cmd); 1309e48354ceSNicholas Bellinger 1310e48354ceSNicholas Bellinger if ((hdr->offset + payload_length) > cmd->data_length) { 1311e48354ceSNicholas Bellinger pr_err("DataOut Offset: %u, Length %u greater than" 1312e48354ceSNicholas Bellinger " iSCSI Command EDTL %u, protocol error.\n", 1313e48354ceSNicholas Bellinger hdr->offset, payload_length, cmd->data_length); 1314e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 1315e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1316e48354ceSNicholas Bellinger } 1317e48354ceSNicholas Bellinger 1318e48354ceSNicholas Bellinger if (cmd->unsolicited_data) { 1319e48354ceSNicholas Bellinger int dump_unsolicited_data = 0; 1320e48354ceSNicholas Bellinger 1321e48354ceSNicholas Bellinger if (conn->sess->sess_ops->InitialR2T) { 1322e48354ceSNicholas Bellinger pr_err("Received unexpected unsolicited data" 1323e48354ceSNicholas Bellinger " while InitialR2T=Yes, protocol error.\n"); 1324e48354ceSNicholas Bellinger transport_send_check_condition_and_sense(&cmd->se_cmd, 1325e48354ceSNicholas Bellinger TCM_UNEXPECTED_UNSOLICITED_DATA, 0); 1326e48354ceSNicholas Bellinger return -1; 1327e48354ceSNicholas Bellinger } 1328e48354ceSNicholas Bellinger /* 1329e48354ceSNicholas Bellinger * Special case for dealing with Unsolicited DataOUT 1330e48354ceSNicholas Bellinger * and Unsupported SAM WRITE Opcodes and SE resource allocation 1331e48354ceSNicholas Bellinger * failures; 1332e48354ceSNicholas Bellinger */ 1333e48354ceSNicholas Bellinger 1334e48354ceSNicholas Bellinger /* Something's amiss if we're not in WRITE_PENDING state... */ 1335e48354ceSNicholas Bellinger spin_lock_irqsave(&se_cmd->t_state_lock, flags); 1336e48354ceSNicholas Bellinger WARN_ON(se_cmd->t_state != TRANSPORT_WRITE_PENDING); 1337e48354ceSNicholas Bellinger spin_unlock_irqrestore(&se_cmd->t_state_lock, flags); 1338e48354ceSNicholas Bellinger 1339e48354ceSNicholas Bellinger spin_lock_irqsave(&se_cmd->t_state_lock, flags); 1340e48354ceSNicholas Bellinger if (!(se_cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) || 134103e98c9eSNicholas Bellinger (se_cmd->se_cmd_flags & SCF_SCSI_CDB_EXCEPTION)) 1342e48354ceSNicholas Bellinger dump_unsolicited_data = 1; 1343e48354ceSNicholas Bellinger spin_unlock_irqrestore(&se_cmd->t_state_lock, flags); 1344e48354ceSNicholas Bellinger 1345e48354ceSNicholas Bellinger if (dump_unsolicited_data) { 1346e48354ceSNicholas Bellinger /* 1347e48354ceSNicholas Bellinger * Check if a delayed TASK_ABORTED status needs to 1348e48354ceSNicholas Bellinger * be sent now if the ISCSI_FLAG_CMD_FINAL has been 1349e48354ceSNicholas Bellinger * received with the unsolicitied data out. 1350e48354ceSNicholas Bellinger */ 1351e48354ceSNicholas Bellinger if (hdr->flags & ISCSI_FLAG_CMD_FINAL) 1352e48354ceSNicholas Bellinger iscsit_stop_dataout_timer(cmd); 1353e48354ceSNicholas Bellinger 1354e48354ceSNicholas Bellinger transport_check_aborted_status(se_cmd, 1355e48354ceSNicholas Bellinger (hdr->flags & ISCSI_FLAG_CMD_FINAL)); 1356e48354ceSNicholas Bellinger return iscsit_dump_data_payload(conn, payload_length, 1); 1357e48354ceSNicholas Bellinger } 1358e48354ceSNicholas Bellinger } else { 1359e48354ceSNicholas Bellinger /* 1360e48354ceSNicholas Bellinger * For the normal solicited data path: 1361e48354ceSNicholas Bellinger * 1362e48354ceSNicholas Bellinger * Check for a delayed TASK_ABORTED status and dump any 1363e48354ceSNicholas Bellinger * incoming data out payload if one exists. Also, when the 1364e48354ceSNicholas Bellinger * ISCSI_FLAG_CMD_FINAL is set to denote the end of the current 1365e48354ceSNicholas Bellinger * data out sequence, we decrement outstanding_r2ts. Once 1366e48354ceSNicholas Bellinger * outstanding_r2ts reaches zero, go ahead and send the delayed 1367e48354ceSNicholas Bellinger * TASK_ABORTED status. 1368e48354ceSNicholas Bellinger */ 1369e48354ceSNicholas Bellinger if (atomic_read(&se_cmd->t_transport_aborted) != 0) { 1370e48354ceSNicholas Bellinger if (hdr->flags & ISCSI_FLAG_CMD_FINAL) 1371e48354ceSNicholas Bellinger if (--cmd->outstanding_r2ts < 1) { 1372e48354ceSNicholas Bellinger iscsit_stop_dataout_timer(cmd); 1373e48354ceSNicholas Bellinger transport_check_aborted_status( 1374e48354ceSNicholas Bellinger se_cmd, 1); 1375e48354ceSNicholas Bellinger } 1376e48354ceSNicholas Bellinger 1377e48354ceSNicholas Bellinger return iscsit_dump_data_payload(conn, payload_length, 1); 1378e48354ceSNicholas Bellinger } 1379e48354ceSNicholas Bellinger } 1380e48354ceSNicholas Bellinger /* 1381e48354ceSNicholas Bellinger * Preform DataSN, DataSequenceInOrder, DataPDUInOrder, and 1382e48354ceSNicholas Bellinger * within-command recovery checks before receiving the payload. 1383e48354ceSNicholas Bellinger */ 1384e48354ceSNicholas Bellinger ret = iscsit_check_pre_dataout(cmd, buf); 1385e48354ceSNicholas Bellinger if (ret == DATAOUT_WITHIN_COMMAND_RECOVERY) 1386e48354ceSNicholas Bellinger return 0; 1387e48354ceSNicholas Bellinger else if (ret == DATAOUT_CANNOT_RECOVER) 1388e48354ceSNicholas Bellinger return -1; 1389e48354ceSNicholas Bellinger 1390e48354ceSNicholas Bellinger rx_size += payload_length; 1391e48354ceSNicholas Bellinger iov = &cmd->iov_data[0]; 1392e48354ceSNicholas Bellinger 1393e48354ceSNicholas Bellinger iov_ret = iscsit_map_iovec(cmd, iov, hdr->offset, payload_length); 1394e48354ceSNicholas Bellinger if (iov_ret < 0) 1395e48354ceSNicholas Bellinger return -1; 1396e48354ceSNicholas Bellinger 1397e48354ceSNicholas Bellinger iov_count += iov_ret; 1398e48354ceSNicholas Bellinger 1399e48354ceSNicholas Bellinger padding = ((-payload_length) & 3); 1400e48354ceSNicholas Bellinger if (padding != 0) { 1401e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pad_bytes; 1402e48354ceSNicholas Bellinger iov[iov_count++].iov_len = padding; 1403e48354ceSNicholas Bellinger rx_size += padding; 1404e48354ceSNicholas Bellinger pr_debug("Receiving %u padding bytes.\n", padding); 1405e48354ceSNicholas Bellinger } 1406e48354ceSNicholas Bellinger 1407e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1408e48354ceSNicholas Bellinger iov[iov_count].iov_base = &checksum; 1409e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 1410e48354ceSNicholas Bellinger rx_size += ISCSI_CRC_LEN; 1411e48354ceSNicholas Bellinger } 1412e48354ceSNicholas Bellinger 1413e48354ceSNicholas Bellinger rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size); 1414e48354ceSNicholas Bellinger 1415e48354ceSNicholas Bellinger iscsit_unmap_iovec(cmd); 1416e48354ceSNicholas Bellinger 1417e48354ceSNicholas Bellinger if (rx_got != rx_size) 1418e48354ceSNicholas Bellinger return -1; 1419e48354ceSNicholas Bellinger 1420e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1421e48354ceSNicholas Bellinger u32 data_crc; 1422e48354ceSNicholas Bellinger 1423e48354ceSNicholas Bellinger data_crc = iscsit_do_crypto_hash_sg(&conn->conn_rx_hash, cmd, 1424e48354ceSNicholas Bellinger hdr->offset, payload_length, padding, 1425e48354ceSNicholas Bellinger cmd->pad_bytes); 1426e48354ceSNicholas Bellinger 1427e48354ceSNicholas Bellinger if (checksum != data_crc) { 1428e48354ceSNicholas Bellinger pr_err("ITT: 0x%08x, Offset: %u, Length: %u," 1429e48354ceSNicholas Bellinger " DataSN: 0x%08x, CRC32C DataDigest 0x%08x" 1430e48354ceSNicholas Bellinger " does not match computed 0x%08x\n", 1431e48354ceSNicholas Bellinger hdr->itt, hdr->offset, payload_length, 1432e48354ceSNicholas Bellinger hdr->datasn, checksum, data_crc); 1433e48354ceSNicholas Bellinger data_crc_failed = 1; 1434e48354ceSNicholas Bellinger } else { 1435e48354ceSNicholas Bellinger pr_debug("Got CRC32C DataDigest 0x%08x for" 1436e48354ceSNicholas Bellinger " %u bytes of Data Out\n", checksum, 1437e48354ceSNicholas Bellinger payload_length); 1438e48354ceSNicholas Bellinger } 1439e48354ceSNicholas Bellinger } 1440e48354ceSNicholas Bellinger /* 1441e48354ceSNicholas Bellinger * Increment post receive data and CRC values or perform 1442e48354ceSNicholas Bellinger * within-command recovery. 1443e48354ceSNicholas Bellinger */ 1444e48354ceSNicholas Bellinger ret = iscsit_check_post_dataout(cmd, buf, data_crc_failed); 1445e48354ceSNicholas Bellinger if ((ret == DATAOUT_NORMAL) || (ret == DATAOUT_WITHIN_COMMAND_RECOVERY)) 1446e48354ceSNicholas Bellinger return 0; 1447e48354ceSNicholas Bellinger else if (ret == DATAOUT_SEND_R2T) { 1448e48354ceSNicholas Bellinger iscsit_set_dataout_sequence_values(cmd); 1449e48354ceSNicholas Bellinger iscsit_build_r2ts_for_cmd(cmd, conn, 0); 1450e48354ceSNicholas Bellinger } else if (ret == DATAOUT_SEND_TO_TRANSPORT) { 1451e48354ceSNicholas Bellinger /* 1452e48354ceSNicholas Bellinger * Handle extra special case for out of order 1453e48354ceSNicholas Bellinger * Unsolicited Data Out. 1454e48354ceSNicholas Bellinger */ 1455e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 1456e48354ceSNicholas Bellinger ooo_cmdsn = (cmd->cmd_flags & ICF_OOO_CMDSN); 1457e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT; 1458e48354ceSNicholas Bellinger cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT; 1459e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 1460e48354ceSNicholas Bellinger 1461e48354ceSNicholas Bellinger iscsit_stop_dataout_timer(cmd); 1462e48354ceSNicholas Bellinger return (!ooo_cmdsn) ? transport_generic_handle_data( 1463e48354ceSNicholas Bellinger &cmd->se_cmd) : 0; 1464e48354ceSNicholas Bellinger } else /* DATAOUT_CANNOT_RECOVER */ 1465e48354ceSNicholas Bellinger return -1; 1466e48354ceSNicholas Bellinger 1467e48354ceSNicholas Bellinger return 0; 1468e48354ceSNicholas Bellinger } 1469e48354ceSNicholas Bellinger 1470e48354ceSNicholas Bellinger static int iscsit_handle_nop_out( 1471e48354ceSNicholas Bellinger struct iscsi_conn *conn, 1472e48354ceSNicholas Bellinger unsigned char *buf) 1473e48354ceSNicholas Bellinger { 1474e48354ceSNicholas Bellinger unsigned char *ping_data = NULL; 1475e48354ceSNicholas Bellinger int cmdsn_ret, niov = 0, ret = 0, rx_got, rx_size; 1476e48354ceSNicholas Bellinger u32 checksum, data_crc, padding = 0, payload_length; 1477e48354ceSNicholas Bellinger u64 lun; 1478e48354ceSNicholas Bellinger struct iscsi_cmd *cmd = NULL; 1479e48354ceSNicholas Bellinger struct kvec *iov = NULL; 1480e48354ceSNicholas Bellinger struct iscsi_nopout *hdr; 1481e48354ceSNicholas Bellinger 1482e48354ceSNicholas Bellinger hdr = (struct iscsi_nopout *) buf; 1483e48354ceSNicholas Bellinger payload_length = ntoh24(hdr->dlength); 1484e48354ceSNicholas Bellinger lun = get_unaligned_le64(&hdr->lun); 1485e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 1486e48354ceSNicholas Bellinger hdr->ttt = be32_to_cpu(hdr->ttt); 1487e48354ceSNicholas Bellinger hdr->cmdsn = be32_to_cpu(hdr->cmdsn); 1488e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 1489e48354ceSNicholas Bellinger 1490e48354ceSNicholas Bellinger if ((hdr->itt == 0xFFFFFFFF) && !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1491e48354ceSNicholas Bellinger pr_err("NOPOUT ITT is reserved, but Immediate Bit is" 1492e48354ceSNicholas Bellinger " not set, protocol error.\n"); 1493e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1494e48354ceSNicholas Bellinger buf, conn); 1495e48354ceSNicholas Bellinger } 1496e48354ceSNicholas Bellinger 1497e48354ceSNicholas Bellinger if (payload_length > conn->conn_ops->MaxRecvDataSegmentLength) { 1498e48354ceSNicholas Bellinger pr_err("NOPOUT Ping Data DataSegmentLength: %u is" 1499e48354ceSNicholas Bellinger " greater than MaxRecvDataSegmentLength: %u, protocol" 1500e48354ceSNicholas Bellinger " error.\n", payload_length, 1501e48354ceSNicholas Bellinger conn->conn_ops->MaxRecvDataSegmentLength); 1502e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1503e48354ceSNicholas Bellinger buf, conn); 1504e48354ceSNicholas Bellinger } 1505e48354ceSNicholas Bellinger 1506e48354ceSNicholas Bellinger pr_debug("Got NOPOUT Ping %s ITT: 0x%08x, TTT: 0x%09x," 1507e48354ceSNicholas Bellinger " CmdSN: 0x%08x, ExpStatSN: 0x%08x, Length: %u\n", 1508e48354ceSNicholas Bellinger (hdr->itt == 0xFFFFFFFF) ? "Response" : "Request", 1509e48354ceSNicholas Bellinger hdr->itt, hdr->ttt, hdr->cmdsn, hdr->exp_statsn, 1510e48354ceSNicholas Bellinger payload_length); 1511e48354ceSNicholas Bellinger /* 1512e48354ceSNicholas Bellinger * This is not a response to a Unsolicited NopIN, which means 1513e48354ceSNicholas Bellinger * it can either be a NOPOUT ping request (with a valid ITT), 1514e48354ceSNicholas Bellinger * or a NOPOUT not requesting a NOPIN (with a reserved ITT). 1515e48354ceSNicholas Bellinger * Either way, make sure we allocate an struct iscsi_cmd, as both 1516e48354ceSNicholas Bellinger * can contain ping data. 1517e48354ceSNicholas Bellinger */ 1518e48354ceSNicholas Bellinger if (hdr->ttt == 0xFFFFFFFF) { 1519e48354ceSNicholas Bellinger cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 1520e48354ceSNicholas Bellinger if (!cmd) 1521e48354ceSNicholas Bellinger return iscsit_add_reject( 1522e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1523e48354ceSNicholas Bellinger 1, buf, conn); 1524e48354ceSNicholas Bellinger 1525e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_NOOP_OUT; 1526e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_NOPIN; 1527e48354ceSNicholas Bellinger cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1528e48354ceSNicholas Bellinger 1 : 0); 1529e48354ceSNicholas Bellinger conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt; 1530e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 1531e48354ceSNicholas Bellinger cmd->cmd_sn = hdr->cmdsn; 1532e48354ceSNicholas Bellinger cmd->exp_stat_sn = hdr->exp_statsn; 1533e48354ceSNicholas Bellinger cmd->data_direction = DMA_NONE; 1534e48354ceSNicholas Bellinger } 1535e48354ceSNicholas Bellinger 1536e48354ceSNicholas Bellinger if (payload_length && (hdr->ttt == 0xFFFFFFFF)) { 1537e48354ceSNicholas Bellinger rx_size = payload_length; 1538e48354ceSNicholas Bellinger ping_data = kzalloc(payload_length + 1, GFP_KERNEL); 1539e48354ceSNicholas Bellinger if (!ping_data) { 1540e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for" 1541e48354ceSNicholas Bellinger " NOPOUT ping data.\n"); 1542e48354ceSNicholas Bellinger ret = -1; 1543e48354ceSNicholas Bellinger goto out; 1544e48354ceSNicholas Bellinger } 1545e48354ceSNicholas Bellinger 1546e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 1547e48354ceSNicholas Bellinger iov[niov].iov_base = ping_data; 1548e48354ceSNicholas Bellinger iov[niov++].iov_len = payload_length; 1549e48354ceSNicholas Bellinger 1550e48354ceSNicholas Bellinger padding = ((-payload_length) & 3); 1551e48354ceSNicholas Bellinger if (padding != 0) { 1552e48354ceSNicholas Bellinger pr_debug("Receiving %u additional bytes" 1553e48354ceSNicholas Bellinger " for padding.\n", padding); 1554e48354ceSNicholas Bellinger iov[niov].iov_base = &cmd->pad_bytes; 1555e48354ceSNicholas Bellinger iov[niov++].iov_len = padding; 1556e48354ceSNicholas Bellinger rx_size += padding; 1557e48354ceSNicholas Bellinger } 1558e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1559e48354ceSNicholas Bellinger iov[niov].iov_base = &checksum; 1560e48354ceSNicholas Bellinger iov[niov++].iov_len = ISCSI_CRC_LEN; 1561e48354ceSNicholas Bellinger rx_size += ISCSI_CRC_LEN; 1562e48354ceSNicholas Bellinger } 1563e48354ceSNicholas Bellinger 1564e48354ceSNicholas Bellinger rx_got = rx_data(conn, &cmd->iov_misc[0], niov, rx_size); 1565e48354ceSNicholas Bellinger if (rx_got != rx_size) { 1566e48354ceSNicholas Bellinger ret = -1; 1567e48354ceSNicholas Bellinger goto out; 1568e48354ceSNicholas Bellinger } 1569e48354ceSNicholas Bellinger 1570e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1571e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_rx_hash, 1572e48354ceSNicholas Bellinger ping_data, payload_length, 1573e48354ceSNicholas Bellinger padding, cmd->pad_bytes, 1574e48354ceSNicholas Bellinger (u8 *)&data_crc); 1575e48354ceSNicholas Bellinger 1576e48354ceSNicholas Bellinger if (checksum != data_crc) { 1577e48354ceSNicholas Bellinger pr_err("Ping data CRC32C DataDigest" 1578e48354ceSNicholas Bellinger " 0x%08x does not match computed 0x%08x\n", 1579e48354ceSNicholas Bellinger checksum, data_crc); 1580e48354ceSNicholas Bellinger if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 1581e48354ceSNicholas Bellinger pr_err("Unable to recover from" 1582e48354ceSNicholas Bellinger " NOPOUT Ping DataCRC failure while in" 1583e48354ceSNicholas Bellinger " ERL=0.\n"); 1584e48354ceSNicholas Bellinger ret = -1; 1585e48354ceSNicholas Bellinger goto out; 1586e48354ceSNicholas Bellinger } else { 1587e48354ceSNicholas Bellinger /* 1588e48354ceSNicholas Bellinger * Silently drop this PDU and let the 1589e48354ceSNicholas Bellinger * initiator plug the CmdSN gap. 1590e48354ceSNicholas Bellinger */ 1591e48354ceSNicholas Bellinger pr_debug("Dropping NOPOUT" 1592e48354ceSNicholas Bellinger " Command CmdSN: 0x%08x due to" 1593e48354ceSNicholas Bellinger " DataCRC error.\n", hdr->cmdsn); 1594e48354ceSNicholas Bellinger ret = 0; 1595e48354ceSNicholas Bellinger goto out; 1596e48354ceSNicholas Bellinger } 1597e48354ceSNicholas Bellinger } else { 1598e48354ceSNicholas Bellinger pr_debug("Got CRC32C DataDigest" 1599e48354ceSNicholas Bellinger " 0x%08x for %u bytes of ping data.\n", 1600e48354ceSNicholas Bellinger checksum, payload_length); 1601e48354ceSNicholas Bellinger } 1602e48354ceSNicholas Bellinger } 1603e48354ceSNicholas Bellinger 1604e48354ceSNicholas Bellinger ping_data[payload_length] = '\0'; 1605e48354ceSNicholas Bellinger /* 1606e48354ceSNicholas Bellinger * Attach ping data to struct iscsi_cmd->buf_ptr. 1607e48354ceSNicholas Bellinger */ 1608e48354ceSNicholas Bellinger cmd->buf_ptr = (void *)ping_data; 1609e48354ceSNicholas Bellinger cmd->buf_ptr_size = payload_length; 1610e48354ceSNicholas Bellinger 1611e48354ceSNicholas Bellinger pr_debug("Got %u bytes of NOPOUT ping" 1612e48354ceSNicholas Bellinger " data.\n", payload_length); 1613e48354ceSNicholas Bellinger pr_debug("Ping Data: \"%s\"\n", ping_data); 1614e48354ceSNicholas Bellinger } 1615e48354ceSNicholas Bellinger 1616e48354ceSNicholas Bellinger if (hdr->itt != 0xFFFFFFFF) { 1617e48354ceSNicholas Bellinger if (!cmd) { 1618e48354ceSNicholas Bellinger pr_err("Checking CmdSN for NOPOUT," 1619e48354ceSNicholas Bellinger " but cmd is NULL!\n"); 1620e48354ceSNicholas Bellinger return -1; 1621e48354ceSNicholas Bellinger } 1622e48354ceSNicholas Bellinger /* 1623e48354ceSNicholas Bellinger * Initiator is expecting a NopIN ping reply, 1624e48354ceSNicholas Bellinger */ 1625e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 1626e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1627e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 1628e48354ceSNicholas Bellinger 1629e48354ceSNicholas Bellinger iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 1630e48354ceSNicholas Bellinger 1631e48354ceSNicholas Bellinger if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 1632e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, 1633e48354ceSNicholas Bellinger cmd->i_state); 1634e48354ceSNicholas Bellinger return 0; 1635e48354ceSNicholas Bellinger } 1636e48354ceSNicholas Bellinger 1637e48354ceSNicholas Bellinger cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1638e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) { 1639e48354ceSNicholas Bellinger ret = 0; 1640e48354ceSNicholas Bellinger goto ping_out; 1641e48354ceSNicholas Bellinger } 1642e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1643e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1644e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 1645e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1646e48354ceSNicholas Bellinger 1647e48354ceSNicholas Bellinger return 0; 1648e48354ceSNicholas Bellinger } 1649e48354ceSNicholas Bellinger 1650e48354ceSNicholas Bellinger if (hdr->ttt != 0xFFFFFFFF) { 1651e48354ceSNicholas Bellinger /* 1652e48354ceSNicholas Bellinger * This was a response to a unsolicited NOPIN ping. 1653e48354ceSNicholas Bellinger */ 1654e48354ceSNicholas Bellinger cmd = iscsit_find_cmd_from_ttt(conn, hdr->ttt); 1655e48354ceSNicholas Bellinger if (!cmd) 1656e48354ceSNicholas Bellinger return -1; 1657e48354ceSNicholas Bellinger 1658e48354ceSNicholas Bellinger iscsit_stop_nopin_response_timer(conn); 1659e48354ceSNicholas Bellinger 1660e48354ceSNicholas Bellinger cmd->i_state = ISTATE_REMOVE; 1661e48354ceSNicholas Bellinger iscsit_add_cmd_to_immediate_queue(cmd, conn, cmd->i_state); 1662e48354ceSNicholas Bellinger iscsit_start_nopin_timer(conn); 1663e48354ceSNicholas Bellinger } else { 1664e48354ceSNicholas Bellinger /* 1665e48354ceSNicholas Bellinger * Initiator is not expecting a NOPIN is response. 1666e48354ceSNicholas Bellinger * Just ignore for now. 1667e48354ceSNicholas Bellinger * 1668e48354ceSNicholas Bellinger * iSCSI v19-91 10.18 1669e48354ceSNicholas Bellinger * "A NOP-OUT may also be used to confirm a changed 1670e48354ceSNicholas Bellinger * ExpStatSN if another PDU will not be available 1671e48354ceSNicholas Bellinger * for a long time." 1672e48354ceSNicholas Bellinger */ 1673e48354ceSNicholas Bellinger ret = 0; 1674e48354ceSNicholas Bellinger goto out; 1675e48354ceSNicholas Bellinger } 1676e48354ceSNicholas Bellinger 1677e48354ceSNicholas Bellinger return 0; 1678e48354ceSNicholas Bellinger out: 1679e48354ceSNicholas Bellinger if (cmd) 1680e48354ceSNicholas Bellinger iscsit_release_cmd(cmd); 1681e48354ceSNicholas Bellinger ping_out: 1682e48354ceSNicholas Bellinger kfree(ping_data); 1683e48354ceSNicholas Bellinger return ret; 1684e48354ceSNicholas Bellinger } 1685e48354ceSNicholas Bellinger 1686e48354ceSNicholas Bellinger static int iscsit_handle_task_mgt_cmd( 1687e48354ceSNicholas Bellinger struct iscsi_conn *conn, 1688e48354ceSNicholas Bellinger unsigned char *buf) 1689e48354ceSNicholas Bellinger { 1690e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 1691e48354ceSNicholas Bellinger struct se_tmr_req *se_tmr; 1692e48354ceSNicholas Bellinger struct iscsi_tmr_req *tmr_req; 1693e48354ceSNicholas Bellinger struct iscsi_tm *hdr; 1694e48354ceSNicholas Bellinger u32 payload_length; 1695e48354ceSNicholas Bellinger int out_of_order_cmdsn = 0; 1696e48354ceSNicholas Bellinger int ret; 1697e48354ceSNicholas Bellinger u8 function; 1698e48354ceSNicholas Bellinger 1699e48354ceSNicholas Bellinger hdr = (struct iscsi_tm *) buf; 1700e48354ceSNicholas Bellinger payload_length = ntoh24(hdr->dlength); 1701e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 1702e48354ceSNicholas Bellinger hdr->rtt = be32_to_cpu(hdr->rtt); 1703e48354ceSNicholas Bellinger hdr->cmdsn = be32_to_cpu(hdr->cmdsn); 1704e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 1705e48354ceSNicholas Bellinger hdr->refcmdsn = be32_to_cpu(hdr->refcmdsn); 1706e48354ceSNicholas Bellinger hdr->exp_datasn = be32_to_cpu(hdr->exp_datasn); 1707e48354ceSNicholas Bellinger hdr->flags &= ~ISCSI_FLAG_CMD_FINAL; 1708e48354ceSNicholas Bellinger function = hdr->flags; 1709e48354ceSNicholas Bellinger 1710e48354ceSNicholas Bellinger pr_debug("Got Task Management Request ITT: 0x%08x, CmdSN:" 1711e48354ceSNicholas Bellinger " 0x%08x, Function: 0x%02x, RefTaskTag: 0x%08x, RefCmdSN:" 1712e48354ceSNicholas Bellinger " 0x%08x, CID: %hu\n", hdr->itt, hdr->cmdsn, function, 1713e48354ceSNicholas Bellinger hdr->rtt, hdr->refcmdsn, conn->cid); 1714e48354ceSNicholas Bellinger 1715e48354ceSNicholas Bellinger if ((function != ISCSI_TM_FUNC_ABORT_TASK) && 1716e48354ceSNicholas Bellinger ((function != ISCSI_TM_FUNC_TASK_REASSIGN) && 1717e48354ceSNicholas Bellinger (hdr->rtt != ISCSI_RESERVED_TAG))) { 1718e48354ceSNicholas Bellinger pr_err("RefTaskTag should be set to 0xFFFFFFFF.\n"); 1719e48354ceSNicholas Bellinger hdr->rtt = ISCSI_RESERVED_TAG; 1720e48354ceSNicholas Bellinger } 1721e48354ceSNicholas Bellinger 1722e48354ceSNicholas Bellinger if ((function == ISCSI_TM_FUNC_TASK_REASSIGN) && 1723e48354ceSNicholas Bellinger !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1724e48354ceSNicholas Bellinger pr_err("Task Management Request TASK_REASSIGN not" 1725e48354ceSNicholas Bellinger " issued as immediate command, bad iSCSI Initiator" 1726e48354ceSNicholas Bellinger "implementation\n"); 1727e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1728e48354ceSNicholas Bellinger buf, conn); 1729e48354ceSNicholas Bellinger } 1730e48354ceSNicholas Bellinger if ((function != ISCSI_TM_FUNC_ABORT_TASK) && 1731e48354ceSNicholas Bellinger (hdr->refcmdsn != ISCSI_RESERVED_TAG)) 1732e48354ceSNicholas Bellinger hdr->refcmdsn = ISCSI_RESERVED_TAG; 1733e48354ceSNicholas Bellinger 1734e48354ceSNicholas Bellinger cmd = iscsit_allocate_se_cmd_for_tmr(conn, function); 1735e48354ceSNicholas Bellinger if (!cmd) 1736e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1737e48354ceSNicholas Bellinger 1, buf, conn); 1738e48354ceSNicholas Bellinger 1739e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_SCSI_TMFUNC; 1740e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_TASKMGTRSP; 1741e48354ceSNicholas Bellinger cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0); 1742e48354ceSNicholas Bellinger cmd->init_task_tag = hdr->itt; 1743e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 1744e48354ceSNicholas Bellinger cmd->cmd_sn = hdr->cmdsn; 1745e48354ceSNicholas Bellinger cmd->exp_stat_sn = hdr->exp_statsn; 1746e48354ceSNicholas Bellinger se_tmr = cmd->se_cmd.se_tmr_req; 1747e48354ceSNicholas Bellinger tmr_req = cmd->tmr_req; 1748e48354ceSNicholas Bellinger /* 1749e48354ceSNicholas Bellinger * Locate the struct se_lun for all TMRs not related to ERL=2 TASK_REASSIGN 1750e48354ceSNicholas Bellinger */ 1751e48354ceSNicholas Bellinger if (function != ISCSI_TM_FUNC_TASK_REASSIGN) { 1752e48354ceSNicholas Bellinger ret = iscsit_get_lun_for_tmr(cmd, 1753e48354ceSNicholas Bellinger get_unaligned_le64(&hdr->lun)); 1754e48354ceSNicholas Bellinger if (ret < 0) { 1755e48354ceSNicholas Bellinger cmd->se_cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1756e48354ceSNicholas Bellinger se_tmr->response = ISCSI_TMF_RSP_NO_LUN; 1757e48354ceSNicholas Bellinger goto attach; 1758e48354ceSNicholas Bellinger } 1759e48354ceSNicholas Bellinger } 1760e48354ceSNicholas Bellinger 1761e48354ceSNicholas Bellinger switch (function) { 1762e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_ABORT_TASK: 1763e48354ceSNicholas Bellinger se_tmr->response = iscsit_tmr_abort_task(cmd, buf); 1764e48354ceSNicholas Bellinger if (se_tmr->response != ISCSI_TMF_RSP_COMPLETE) { 1765e48354ceSNicholas Bellinger cmd->se_cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1766e48354ceSNicholas Bellinger goto attach; 1767e48354ceSNicholas Bellinger } 1768e48354ceSNicholas Bellinger break; 1769e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_ABORT_TASK_SET: 1770e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_CLEAR_ACA: 1771e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_CLEAR_TASK_SET: 1772e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 1773e48354ceSNicholas Bellinger break; 1774e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_TARGET_WARM_RESET: 1775e48354ceSNicholas Bellinger if (iscsit_tmr_task_warm_reset(conn, tmr_req, buf) < 0) { 1776e48354ceSNicholas Bellinger cmd->se_cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1777e48354ceSNicholas Bellinger se_tmr->response = ISCSI_TMF_RSP_AUTH_FAILED; 1778e48354ceSNicholas Bellinger goto attach; 1779e48354ceSNicholas Bellinger } 1780e48354ceSNicholas Bellinger break; 1781e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_TARGET_COLD_RESET: 1782e48354ceSNicholas Bellinger if (iscsit_tmr_task_cold_reset(conn, tmr_req, buf) < 0) { 1783e48354ceSNicholas Bellinger cmd->se_cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1784e48354ceSNicholas Bellinger se_tmr->response = ISCSI_TMF_RSP_AUTH_FAILED; 1785e48354ceSNicholas Bellinger goto attach; 1786e48354ceSNicholas Bellinger } 1787e48354ceSNicholas Bellinger break; 1788e48354ceSNicholas Bellinger case ISCSI_TM_FUNC_TASK_REASSIGN: 1789e48354ceSNicholas Bellinger se_tmr->response = iscsit_tmr_task_reassign(cmd, buf); 1790e48354ceSNicholas Bellinger /* 1791e48354ceSNicholas Bellinger * Perform sanity checks on the ExpDataSN only if the 1792e48354ceSNicholas Bellinger * TASK_REASSIGN was successful. 1793e48354ceSNicholas Bellinger */ 1794e48354ceSNicholas Bellinger if (se_tmr->response != ISCSI_TMF_RSP_COMPLETE) 1795e48354ceSNicholas Bellinger break; 1796e48354ceSNicholas Bellinger 1797e48354ceSNicholas Bellinger if (iscsit_check_task_reassign_expdatasn(tmr_req, conn) < 0) 1798e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1799e48354ceSNicholas Bellinger ISCSI_REASON_BOOKMARK_INVALID, 1, 1, 1800e48354ceSNicholas Bellinger buf, cmd); 1801e48354ceSNicholas Bellinger break; 1802e48354ceSNicholas Bellinger default: 1803e48354ceSNicholas Bellinger pr_err("Unknown TMR function: 0x%02x, protocol" 1804e48354ceSNicholas Bellinger " error.\n", function); 1805e48354ceSNicholas Bellinger cmd->se_cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 1806e48354ceSNicholas Bellinger se_tmr->response = ISCSI_TMF_RSP_NOT_SUPPORTED; 1807e48354ceSNicholas Bellinger goto attach; 1808e48354ceSNicholas Bellinger } 1809e48354ceSNicholas Bellinger 1810e48354ceSNicholas Bellinger if ((function != ISCSI_TM_FUNC_TASK_REASSIGN) && 1811e48354ceSNicholas Bellinger (se_tmr->response == ISCSI_TMF_RSP_COMPLETE)) 1812e48354ceSNicholas Bellinger se_tmr->call_transport = 1; 1813e48354ceSNicholas Bellinger attach: 1814e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 1815e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1816e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 1817e48354ceSNicholas Bellinger 1818e48354ceSNicholas Bellinger if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1819e48354ceSNicholas Bellinger int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1820e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_HIGHER_THAN_EXP) 1821e48354ceSNicholas Bellinger out_of_order_cmdsn = 1; 18225a4c8666SNicholas Bellinger else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) 1823e48354ceSNicholas Bellinger return 0; 18245a4c8666SNicholas Bellinger else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1825e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 1826e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 1827e48354ceSNicholas Bellinger 1, 0, buf, cmd); 1828e48354ceSNicholas Bellinger } 1829e48354ceSNicholas Bellinger iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 1830e48354ceSNicholas Bellinger 18315a4c8666SNicholas Bellinger if (out_of_order_cmdsn || !(hdr->opcode & ISCSI_OP_IMMEDIATE)) 1832e48354ceSNicholas Bellinger return 0; 1833e48354ceSNicholas Bellinger /* 1834e48354ceSNicholas Bellinger * Found the referenced task, send to transport for processing. 1835e48354ceSNicholas Bellinger */ 1836e48354ceSNicholas Bellinger if (se_tmr->call_transport) 1837e48354ceSNicholas Bellinger return transport_generic_handle_tmr(&cmd->se_cmd); 1838e48354ceSNicholas Bellinger 1839e48354ceSNicholas Bellinger /* 1840e48354ceSNicholas Bellinger * Could not find the referenced LUN, task, or Task Management 1841e48354ceSNicholas Bellinger * command not authorized or supported. Change state and 1842e48354ceSNicholas Bellinger * let the tx_thread send the response. 1843e48354ceSNicholas Bellinger * 1844e48354ceSNicholas Bellinger * For connection recovery, this is also the default action for 1845e48354ceSNicholas Bellinger * TMR TASK_REASSIGN. 1846e48354ceSNicholas Bellinger */ 1847e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 1848e48354ceSNicholas Bellinger return 0; 1849e48354ceSNicholas Bellinger } 1850e48354ceSNicholas Bellinger 1851e48354ceSNicholas Bellinger /* #warning FIXME: Support Text Command parameters besides SendTargets */ 1852e48354ceSNicholas Bellinger static int iscsit_handle_text_cmd( 1853e48354ceSNicholas Bellinger struct iscsi_conn *conn, 1854e48354ceSNicholas Bellinger unsigned char *buf) 1855e48354ceSNicholas Bellinger { 1856e48354ceSNicholas Bellinger char *text_ptr, *text_in; 1857e48354ceSNicholas Bellinger int cmdsn_ret, niov = 0, rx_got, rx_size; 1858e48354ceSNicholas Bellinger u32 checksum = 0, data_crc = 0, payload_length; 185976f1928eSNicholas Bellinger u32 padding = 0, pad_bytes = 0, text_length = 0; 1860e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 1861e48354ceSNicholas Bellinger struct kvec iov[3]; 1862e48354ceSNicholas Bellinger struct iscsi_text *hdr; 1863e48354ceSNicholas Bellinger 1864e48354ceSNicholas Bellinger hdr = (struct iscsi_text *) buf; 1865e48354ceSNicholas Bellinger payload_length = ntoh24(hdr->dlength); 1866e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 1867e48354ceSNicholas Bellinger hdr->ttt = be32_to_cpu(hdr->ttt); 1868e48354ceSNicholas Bellinger hdr->cmdsn = be32_to_cpu(hdr->cmdsn); 1869e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 1870e48354ceSNicholas Bellinger 1871e48354ceSNicholas Bellinger if (payload_length > conn->conn_ops->MaxRecvDataSegmentLength) { 1872e48354ceSNicholas Bellinger pr_err("Unable to accept text parameter length: %u" 1873e48354ceSNicholas Bellinger "greater than MaxRecvDataSegmentLength %u.\n", 1874e48354ceSNicholas Bellinger payload_length, conn->conn_ops->MaxRecvDataSegmentLength); 1875e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1876e48354ceSNicholas Bellinger buf, conn); 1877e48354ceSNicholas Bellinger } 1878e48354ceSNicholas Bellinger 1879e48354ceSNicholas Bellinger pr_debug("Got Text Request: ITT: 0x%08x, CmdSN: 0x%08x," 1880e48354ceSNicholas Bellinger " ExpStatSN: 0x%08x, Length: %u\n", hdr->itt, hdr->cmdsn, 1881e48354ceSNicholas Bellinger hdr->exp_statsn, payload_length); 1882e48354ceSNicholas Bellinger 1883e48354ceSNicholas Bellinger rx_size = text_length = payload_length; 1884e48354ceSNicholas Bellinger if (text_length) { 1885e48354ceSNicholas Bellinger text_in = kzalloc(text_length, GFP_KERNEL); 1886e48354ceSNicholas Bellinger if (!text_in) { 1887e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for" 1888e48354ceSNicholas Bellinger " incoming text parameters\n"); 1889e48354ceSNicholas Bellinger return -1; 1890e48354ceSNicholas Bellinger } 1891e48354ceSNicholas Bellinger 1892e48354ceSNicholas Bellinger memset(iov, 0, 3 * sizeof(struct kvec)); 1893e48354ceSNicholas Bellinger iov[niov].iov_base = text_in; 1894e48354ceSNicholas Bellinger iov[niov++].iov_len = text_length; 1895e48354ceSNicholas Bellinger 1896e48354ceSNicholas Bellinger padding = ((-payload_length) & 3); 1897e48354ceSNicholas Bellinger if (padding != 0) { 189876f1928eSNicholas Bellinger iov[niov].iov_base = &pad_bytes; 1899e48354ceSNicholas Bellinger iov[niov++].iov_len = padding; 1900e48354ceSNicholas Bellinger rx_size += padding; 1901e48354ceSNicholas Bellinger pr_debug("Receiving %u additional bytes" 1902e48354ceSNicholas Bellinger " for padding.\n", padding); 1903e48354ceSNicholas Bellinger } 1904e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1905e48354ceSNicholas Bellinger iov[niov].iov_base = &checksum; 1906e48354ceSNicholas Bellinger iov[niov++].iov_len = ISCSI_CRC_LEN; 1907e48354ceSNicholas Bellinger rx_size += ISCSI_CRC_LEN; 1908e48354ceSNicholas Bellinger } 1909e48354ceSNicholas Bellinger 1910e48354ceSNicholas Bellinger rx_got = rx_data(conn, &iov[0], niov, rx_size); 1911e48354ceSNicholas Bellinger if (rx_got != rx_size) { 1912e48354ceSNicholas Bellinger kfree(text_in); 1913e48354ceSNicholas Bellinger return -1; 1914e48354ceSNicholas Bellinger } 1915e48354ceSNicholas Bellinger 1916e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 1917e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_rx_hash, 1918e48354ceSNicholas Bellinger text_in, text_length, 191976f1928eSNicholas Bellinger padding, (u8 *)&pad_bytes, 1920e48354ceSNicholas Bellinger (u8 *)&data_crc); 1921e48354ceSNicholas Bellinger 1922e48354ceSNicholas Bellinger if (checksum != data_crc) { 1923e48354ceSNicholas Bellinger pr_err("Text data CRC32C DataDigest" 1924e48354ceSNicholas Bellinger " 0x%08x does not match computed" 1925e48354ceSNicholas Bellinger " 0x%08x\n", checksum, data_crc); 1926e48354ceSNicholas Bellinger if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 1927e48354ceSNicholas Bellinger pr_err("Unable to recover from" 1928e48354ceSNicholas Bellinger " Text Data digest failure while in" 1929e48354ceSNicholas Bellinger " ERL=0.\n"); 1930e48354ceSNicholas Bellinger kfree(text_in); 1931e48354ceSNicholas Bellinger return -1; 1932e48354ceSNicholas Bellinger } else { 1933e48354ceSNicholas Bellinger /* 1934e48354ceSNicholas Bellinger * Silently drop this PDU and let the 1935e48354ceSNicholas Bellinger * initiator plug the CmdSN gap. 1936e48354ceSNicholas Bellinger */ 1937e48354ceSNicholas Bellinger pr_debug("Dropping Text" 1938e48354ceSNicholas Bellinger " Command CmdSN: 0x%08x due to" 1939e48354ceSNicholas Bellinger " DataCRC error.\n", hdr->cmdsn); 1940e48354ceSNicholas Bellinger kfree(text_in); 1941e48354ceSNicholas Bellinger return 0; 1942e48354ceSNicholas Bellinger } 1943e48354ceSNicholas Bellinger } else { 1944e48354ceSNicholas Bellinger pr_debug("Got CRC32C DataDigest" 1945e48354ceSNicholas Bellinger " 0x%08x for %u bytes of text data.\n", 1946e48354ceSNicholas Bellinger checksum, text_length); 1947e48354ceSNicholas Bellinger } 1948e48354ceSNicholas Bellinger } 1949e48354ceSNicholas Bellinger text_in[text_length - 1] = '\0'; 1950e48354ceSNicholas Bellinger pr_debug("Successfully read %d bytes of text" 1951e48354ceSNicholas Bellinger " data.\n", text_length); 1952e48354ceSNicholas Bellinger 1953e48354ceSNicholas Bellinger if (strncmp("SendTargets", text_in, 11) != 0) { 1954e48354ceSNicholas Bellinger pr_err("Received Text Data that is not" 1955e48354ceSNicholas Bellinger " SendTargets, cannot continue.\n"); 1956e48354ceSNicholas Bellinger kfree(text_in); 1957e48354ceSNicholas Bellinger return -1; 1958e48354ceSNicholas Bellinger } 1959e48354ceSNicholas Bellinger text_ptr = strchr(text_in, '='); 1960e48354ceSNicholas Bellinger if (!text_ptr) { 1961e48354ceSNicholas Bellinger pr_err("No \"=\" separator found in Text Data," 1962e48354ceSNicholas Bellinger " cannot continue.\n"); 1963e48354ceSNicholas Bellinger kfree(text_in); 1964e48354ceSNicholas Bellinger return -1; 1965e48354ceSNicholas Bellinger } 1966e48354ceSNicholas Bellinger if (strncmp("=All", text_ptr, 4) != 0) { 1967e48354ceSNicholas Bellinger pr_err("Unable to locate All value for" 1968e48354ceSNicholas Bellinger " SendTargets key, cannot continue.\n"); 1969e48354ceSNicholas Bellinger kfree(text_in); 1970e48354ceSNicholas Bellinger return -1; 1971e48354ceSNicholas Bellinger } 1972e48354ceSNicholas Bellinger /*#warning Support SendTargets=(iSCSI Target Name/Nothing) values. */ 1973e48354ceSNicholas Bellinger kfree(text_in); 1974e48354ceSNicholas Bellinger } 1975e48354ceSNicholas Bellinger 1976e48354ceSNicholas Bellinger cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 1977e48354ceSNicholas Bellinger if (!cmd) 1978e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1979e48354ceSNicholas Bellinger 1, buf, conn); 1980e48354ceSNicholas Bellinger 1981e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_TEXT; 1982e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_TEXTRSP; 1983e48354ceSNicholas Bellinger cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0); 1984e48354ceSNicholas Bellinger conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt; 1985e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 1986e48354ceSNicholas Bellinger cmd->cmd_sn = hdr->cmdsn; 1987e48354ceSNicholas Bellinger cmd->exp_stat_sn = hdr->exp_statsn; 1988e48354ceSNicholas Bellinger cmd->data_direction = DMA_NONE; 1989e48354ceSNicholas Bellinger 1990e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 1991e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1992e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 1993e48354ceSNicholas Bellinger 1994e48354ceSNicholas Bellinger iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 1995e48354ceSNicholas Bellinger 1996e48354ceSNicholas Bellinger if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1997e48354ceSNicholas Bellinger cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1998e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1999e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 2000e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 2001e48354ceSNicholas Bellinger 1, 0, buf, cmd); 2002e48354ceSNicholas Bellinger 2003e48354ceSNicholas Bellinger return 0; 2004e48354ceSNicholas Bellinger } 2005e48354ceSNicholas Bellinger 2006e48354ceSNicholas Bellinger return iscsit_execute_cmd(cmd, 0); 2007e48354ceSNicholas Bellinger } 2008e48354ceSNicholas Bellinger 2009e48354ceSNicholas Bellinger int iscsit_logout_closesession(struct iscsi_cmd *cmd, struct iscsi_conn *conn) 2010e48354ceSNicholas Bellinger { 2011e48354ceSNicholas Bellinger struct iscsi_conn *conn_p; 2012e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 2013e48354ceSNicholas Bellinger 2014e48354ceSNicholas Bellinger pr_debug("Received logout request CLOSESESSION on CID: %hu" 2015e48354ceSNicholas Bellinger " for SID: %u.\n", conn->cid, conn->sess->sid); 2016e48354ceSNicholas Bellinger 2017e48354ceSNicholas Bellinger atomic_set(&sess->session_logout, 1); 2018e48354ceSNicholas Bellinger atomic_set(&conn->conn_logout_remove, 1); 2019e48354ceSNicholas Bellinger conn->conn_logout_reason = ISCSI_LOGOUT_REASON_CLOSE_SESSION; 2020e48354ceSNicholas Bellinger 2021e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn); 2022e48354ceSNicholas Bellinger iscsit_inc_session_usage_count(sess); 2023e48354ceSNicholas Bellinger 2024e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 2025e48354ceSNicholas Bellinger list_for_each_entry(conn_p, &sess->sess_conn_list, conn_list) { 2026e48354ceSNicholas Bellinger if (conn_p->conn_state != TARG_CONN_STATE_LOGGED_IN) 2027e48354ceSNicholas Bellinger continue; 2028e48354ceSNicholas Bellinger 2029e48354ceSNicholas Bellinger pr_debug("Moving to TARG_CONN_STATE_IN_LOGOUT.\n"); 2030e48354ceSNicholas Bellinger conn_p->conn_state = TARG_CONN_STATE_IN_LOGOUT; 2031e48354ceSNicholas Bellinger } 2032e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 2033e48354ceSNicholas Bellinger 2034e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 2035e48354ceSNicholas Bellinger 2036e48354ceSNicholas Bellinger return 0; 2037e48354ceSNicholas Bellinger } 2038e48354ceSNicholas Bellinger 2039e48354ceSNicholas Bellinger int iscsit_logout_closeconnection(struct iscsi_cmd *cmd, struct iscsi_conn *conn) 2040e48354ceSNicholas Bellinger { 2041e48354ceSNicholas Bellinger struct iscsi_conn *l_conn; 2042e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 2043e48354ceSNicholas Bellinger 2044e48354ceSNicholas Bellinger pr_debug("Received logout request CLOSECONNECTION for CID:" 2045e48354ceSNicholas Bellinger " %hu on CID: %hu.\n", cmd->logout_cid, conn->cid); 2046e48354ceSNicholas Bellinger 2047e48354ceSNicholas Bellinger /* 2048e48354ceSNicholas Bellinger * A Logout Request with a CLOSECONNECTION reason code for a CID 2049e48354ceSNicholas Bellinger * can arrive on a connection with a differing CID. 2050e48354ceSNicholas Bellinger */ 2051e48354ceSNicholas Bellinger if (conn->cid == cmd->logout_cid) { 2052e48354ceSNicholas Bellinger spin_lock_bh(&conn->state_lock); 2053e48354ceSNicholas Bellinger pr_debug("Moving to TARG_CONN_STATE_IN_LOGOUT.\n"); 2054e48354ceSNicholas Bellinger conn->conn_state = TARG_CONN_STATE_IN_LOGOUT; 2055e48354ceSNicholas Bellinger 2056e48354ceSNicholas Bellinger atomic_set(&conn->conn_logout_remove, 1); 2057e48354ceSNicholas Bellinger conn->conn_logout_reason = ISCSI_LOGOUT_REASON_CLOSE_CONNECTION; 2058e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn); 2059e48354ceSNicholas Bellinger 2060e48354ceSNicholas Bellinger spin_unlock_bh(&conn->state_lock); 2061e48354ceSNicholas Bellinger } else { 2062e48354ceSNicholas Bellinger /* 2063e48354ceSNicholas Bellinger * Handle all different cid CLOSECONNECTION requests in 2064e48354ceSNicholas Bellinger * iscsit_logout_post_handler_diffcid() as to give enough 2065e48354ceSNicholas Bellinger * time for any non immediate command's CmdSN to be 2066e48354ceSNicholas Bellinger * acknowledged on the connection in question. 2067e48354ceSNicholas Bellinger * 2068e48354ceSNicholas Bellinger * Here we simply make sure the CID is still around. 2069e48354ceSNicholas Bellinger */ 2070e48354ceSNicholas Bellinger l_conn = iscsit_get_conn_from_cid(sess, 2071e48354ceSNicholas Bellinger cmd->logout_cid); 2072e48354ceSNicholas Bellinger if (!l_conn) { 2073e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND; 2074e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, 2075e48354ceSNicholas Bellinger cmd->i_state); 2076e48354ceSNicholas Bellinger return 0; 2077e48354ceSNicholas Bellinger } 2078e48354ceSNicholas Bellinger 2079e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(l_conn); 2080e48354ceSNicholas Bellinger } 2081e48354ceSNicholas Bellinger 2082e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 2083e48354ceSNicholas Bellinger 2084e48354ceSNicholas Bellinger return 0; 2085e48354ceSNicholas Bellinger } 2086e48354ceSNicholas Bellinger 2087e48354ceSNicholas Bellinger int iscsit_logout_removeconnforrecovery(struct iscsi_cmd *cmd, struct iscsi_conn *conn) 2088e48354ceSNicholas Bellinger { 2089e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 2090e48354ceSNicholas Bellinger 2091e48354ceSNicholas Bellinger pr_debug("Received explicit REMOVECONNFORRECOVERY logout for" 2092e48354ceSNicholas Bellinger " CID: %hu on CID: %hu.\n", cmd->logout_cid, conn->cid); 2093e48354ceSNicholas Bellinger 2094e48354ceSNicholas Bellinger if (sess->sess_ops->ErrorRecoveryLevel != 2) { 2095e48354ceSNicholas Bellinger pr_err("Received Logout Request REMOVECONNFORRECOVERY" 2096e48354ceSNicholas Bellinger " while ERL!=2.\n"); 2097e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED; 2098e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 2099e48354ceSNicholas Bellinger return 0; 2100e48354ceSNicholas Bellinger } 2101e48354ceSNicholas Bellinger 2102e48354ceSNicholas Bellinger if (conn->cid == cmd->logout_cid) { 2103e48354ceSNicholas Bellinger pr_err("Received Logout Request REMOVECONNFORRECOVERY" 2104e48354ceSNicholas Bellinger " with CID: %hu on CID: %hu, implementation error.\n", 2105e48354ceSNicholas Bellinger cmd->logout_cid, conn->cid); 2106e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_CLEANUP_FAILED; 2107e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 2108e48354ceSNicholas Bellinger return 0; 2109e48354ceSNicholas Bellinger } 2110e48354ceSNicholas Bellinger 2111e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 2112e48354ceSNicholas Bellinger 2113e48354ceSNicholas Bellinger return 0; 2114e48354ceSNicholas Bellinger } 2115e48354ceSNicholas Bellinger 2116e48354ceSNicholas Bellinger static int iscsit_handle_logout_cmd( 2117e48354ceSNicholas Bellinger struct iscsi_conn *conn, 2118e48354ceSNicholas Bellinger unsigned char *buf) 2119e48354ceSNicholas Bellinger { 2120e48354ceSNicholas Bellinger int cmdsn_ret, logout_remove = 0; 2121e48354ceSNicholas Bellinger u8 reason_code = 0; 2122e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 2123e48354ceSNicholas Bellinger struct iscsi_logout *hdr; 2124e48354ceSNicholas Bellinger struct iscsi_tiqn *tiqn = iscsit_snmp_get_tiqn(conn); 2125e48354ceSNicholas Bellinger 2126e48354ceSNicholas Bellinger hdr = (struct iscsi_logout *) buf; 2127e48354ceSNicholas Bellinger reason_code = (hdr->flags & 0x7f); 2128e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 2129e48354ceSNicholas Bellinger hdr->cid = be16_to_cpu(hdr->cid); 2130e48354ceSNicholas Bellinger hdr->cmdsn = be32_to_cpu(hdr->cmdsn); 2131e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 2132e48354ceSNicholas Bellinger 2133e48354ceSNicholas Bellinger if (tiqn) { 2134e48354ceSNicholas Bellinger spin_lock(&tiqn->logout_stats.lock); 2135e48354ceSNicholas Bellinger if (reason_code == ISCSI_LOGOUT_REASON_CLOSE_SESSION) 2136e48354ceSNicholas Bellinger tiqn->logout_stats.normal_logouts++; 2137e48354ceSNicholas Bellinger else 2138e48354ceSNicholas Bellinger tiqn->logout_stats.abnormal_logouts++; 2139e48354ceSNicholas Bellinger spin_unlock(&tiqn->logout_stats.lock); 2140e48354ceSNicholas Bellinger } 2141e48354ceSNicholas Bellinger 2142e48354ceSNicholas Bellinger pr_debug("Got Logout Request ITT: 0x%08x CmdSN: 0x%08x" 2143e48354ceSNicholas Bellinger " ExpStatSN: 0x%08x Reason: 0x%02x CID: %hu on CID: %hu\n", 2144e48354ceSNicholas Bellinger hdr->itt, hdr->cmdsn, hdr->exp_statsn, reason_code, 2145e48354ceSNicholas Bellinger hdr->cid, conn->cid); 2146e48354ceSNicholas Bellinger 2147e48354ceSNicholas Bellinger if (conn->conn_state != TARG_CONN_STATE_LOGGED_IN) { 2148e48354ceSNicholas Bellinger pr_err("Received logout request on connection that" 2149e48354ceSNicholas Bellinger " is not in logged in state, ignoring request.\n"); 2150e48354ceSNicholas Bellinger return 0; 2151e48354ceSNicholas Bellinger } 2152e48354ceSNicholas Bellinger 2153e48354ceSNicholas Bellinger cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 2154e48354ceSNicholas Bellinger if (!cmd) 2155e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1, 2156e48354ceSNicholas Bellinger buf, conn); 2157e48354ceSNicholas Bellinger 2158e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_LOGOUT; 2159e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_LOGOUTRSP; 2160e48354ceSNicholas Bellinger cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0); 2161e48354ceSNicholas Bellinger conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt; 2162e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 2163e48354ceSNicholas Bellinger cmd->cmd_sn = hdr->cmdsn; 2164e48354ceSNicholas Bellinger cmd->exp_stat_sn = hdr->exp_statsn; 2165e48354ceSNicholas Bellinger cmd->logout_cid = hdr->cid; 2166e48354ceSNicholas Bellinger cmd->logout_reason = reason_code; 2167e48354ceSNicholas Bellinger cmd->data_direction = DMA_NONE; 2168e48354ceSNicholas Bellinger 2169e48354ceSNicholas Bellinger /* 2170e48354ceSNicholas Bellinger * We need to sleep in these cases (by returning 1) until the Logout 2171e48354ceSNicholas Bellinger * Response gets sent in the tx thread. 2172e48354ceSNicholas Bellinger */ 2173e48354ceSNicholas Bellinger if ((reason_code == ISCSI_LOGOUT_REASON_CLOSE_SESSION) || 2174e48354ceSNicholas Bellinger ((reason_code == ISCSI_LOGOUT_REASON_CLOSE_CONNECTION) && 2175e48354ceSNicholas Bellinger (hdr->cid == conn->cid))) 2176e48354ceSNicholas Bellinger logout_remove = 1; 2177e48354ceSNicholas Bellinger 2178e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 2179e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 2180e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 2181e48354ceSNicholas Bellinger 2182e48354ceSNicholas Bellinger if (reason_code != ISCSI_LOGOUT_REASON_RECOVERY) 2183e48354ceSNicholas Bellinger iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 2184e48354ceSNicholas Bellinger 2185e48354ceSNicholas Bellinger /* 2186e48354ceSNicholas Bellinger * Immediate commands are executed, well, immediately. 2187e48354ceSNicholas Bellinger * Non-Immediate Logout Commands are executed in CmdSN order. 2188e48354ceSNicholas Bellinger */ 2189e48354ceSNicholas Bellinger if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 2190e48354ceSNicholas Bellinger int ret = iscsit_execute_cmd(cmd, 0); 2191e48354ceSNicholas Bellinger 2192e48354ceSNicholas Bellinger if (ret < 0) 2193e48354ceSNicholas Bellinger return ret; 2194e48354ceSNicholas Bellinger } else { 2195e48354ceSNicholas Bellinger cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 2196e48354ceSNicholas Bellinger if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) { 2197e48354ceSNicholas Bellinger logout_remove = 0; 2198e48354ceSNicholas Bellinger } else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) { 2199e48354ceSNicholas Bellinger return iscsit_add_reject_from_cmd( 2200e48354ceSNicholas Bellinger ISCSI_REASON_PROTOCOL_ERROR, 2201e48354ceSNicholas Bellinger 1, 0, buf, cmd); 2202e48354ceSNicholas Bellinger } 2203e48354ceSNicholas Bellinger } 2204e48354ceSNicholas Bellinger 2205e48354ceSNicholas Bellinger return logout_remove; 2206e48354ceSNicholas Bellinger } 2207e48354ceSNicholas Bellinger 2208e48354ceSNicholas Bellinger static int iscsit_handle_snack( 2209e48354ceSNicholas Bellinger struct iscsi_conn *conn, 2210e48354ceSNicholas Bellinger unsigned char *buf) 2211e48354ceSNicholas Bellinger { 2212e48354ceSNicholas Bellinger u32 unpacked_lun; 2213e48354ceSNicholas Bellinger u64 lun; 2214e48354ceSNicholas Bellinger struct iscsi_snack *hdr; 2215e48354ceSNicholas Bellinger 2216e48354ceSNicholas Bellinger hdr = (struct iscsi_snack *) buf; 2217e48354ceSNicholas Bellinger hdr->flags &= ~ISCSI_FLAG_CMD_FINAL; 2218e48354ceSNicholas Bellinger lun = get_unaligned_le64(&hdr->lun); 2219e48354ceSNicholas Bellinger unpacked_lun = scsilun_to_int((struct scsi_lun *)&lun); 2220e48354ceSNicholas Bellinger hdr->itt = be32_to_cpu(hdr->itt); 2221e48354ceSNicholas Bellinger hdr->ttt = be32_to_cpu(hdr->ttt); 2222e48354ceSNicholas Bellinger hdr->exp_statsn = be32_to_cpu(hdr->exp_statsn); 2223e48354ceSNicholas Bellinger hdr->begrun = be32_to_cpu(hdr->begrun); 2224e48354ceSNicholas Bellinger hdr->runlength = be32_to_cpu(hdr->runlength); 2225e48354ceSNicholas Bellinger 2226e48354ceSNicholas Bellinger pr_debug("Got ISCSI_INIT_SNACK, ITT: 0x%08x, ExpStatSN:" 2227e48354ceSNicholas Bellinger " 0x%08x, Type: 0x%02x, BegRun: 0x%08x, RunLength: 0x%08x," 2228e48354ceSNicholas Bellinger " CID: %hu\n", hdr->itt, hdr->exp_statsn, hdr->flags, 2229e48354ceSNicholas Bellinger hdr->begrun, hdr->runlength, conn->cid); 2230e48354ceSNicholas Bellinger 2231e48354ceSNicholas Bellinger if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 2232e48354ceSNicholas Bellinger pr_err("Initiator sent SNACK request while in" 2233e48354ceSNicholas Bellinger " ErrorRecoveryLevel=0.\n"); 2234e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2235e48354ceSNicholas Bellinger buf, conn); 2236e48354ceSNicholas Bellinger } 2237e48354ceSNicholas Bellinger /* 2238e48354ceSNicholas Bellinger * SNACK_DATA and SNACK_R2T are both 0, so check which function to 2239e48354ceSNicholas Bellinger * call from inside iscsi_send_recovery_datain_or_r2t(). 2240e48354ceSNicholas Bellinger */ 2241e48354ceSNicholas Bellinger switch (hdr->flags & ISCSI_FLAG_SNACK_TYPE_MASK) { 2242e48354ceSNicholas Bellinger case 0: 2243e48354ceSNicholas Bellinger return iscsit_handle_recovery_datain_or_r2t(conn, buf, 2244e48354ceSNicholas Bellinger hdr->itt, hdr->ttt, hdr->begrun, hdr->runlength); 2245e48354ceSNicholas Bellinger case ISCSI_FLAG_SNACK_TYPE_STATUS: 2246e48354ceSNicholas Bellinger return iscsit_handle_status_snack(conn, hdr->itt, hdr->ttt, 2247e48354ceSNicholas Bellinger hdr->begrun, hdr->runlength); 2248e48354ceSNicholas Bellinger case ISCSI_FLAG_SNACK_TYPE_DATA_ACK: 2249e48354ceSNicholas Bellinger return iscsit_handle_data_ack(conn, hdr->ttt, hdr->begrun, 2250e48354ceSNicholas Bellinger hdr->runlength); 2251e48354ceSNicholas Bellinger case ISCSI_FLAG_SNACK_TYPE_RDATA: 2252e48354ceSNicholas Bellinger /* FIXME: Support R-Data SNACK */ 2253e48354ceSNicholas Bellinger pr_err("R-Data SNACK Not Supported.\n"); 2254e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2255e48354ceSNicholas Bellinger buf, conn); 2256e48354ceSNicholas Bellinger default: 2257e48354ceSNicholas Bellinger pr_err("Unknown SNACK type 0x%02x, protocol" 2258e48354ceSNicholas Bellinger " error.\n", hdr->flags & 0x0f); 2259e48354ceSNicholas Bellinger return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2260e48354ceSNicholas Bellinger buf, conn); 2261e48354ceSNicholas Bellinger } 2262e48354ceSNicholas Bellinger 2263e48354ceSNicholas Bellinger return 0; 2264e48354ceSNicholas Bellinger } 2265e48354ceSNicholas Bellinger 2266e48354ceSNicholas Bellinger static void iscsit_rx_thread_wait_for_tcp(struct iscsi_conn *conn) 2267e48354ceSNicholas Bellinger { 2268e48354ceSNicholas Bellinger if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) || 2269e48354ceSNicholas Bellinger (conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) { 2270e48354ceSNicholas Bellinger wait_for_completion_interruptible_timeout( 2271e48354ceSNicholas Bellinger &conn->rx_half_close_comp, 2272e48354ceSNicholas Bellinger ISCSI_RX_THREAD_TCP_TIMEOUT * HZ); 2273e48354ceSNicholas Bellinger } 2274e48354ceSNicholas Bellinger } 2275e48354ceSNicholas Bellinger 2276e48354ceSNicholas Bellinger static int iscsit_handle_immediate_data( 2277e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2278e48354ceSNicholas Bellinger unsigned char *buf, 2279e48354ceSNicholas Bellinger u32 length) 2280e48354ceSNicholas Bellinger { 2281e48354ceSNicholas Bellinger int iov_ret, rx_got = 0, rx_size = 0; 2282e48354ceSNicholas Bellinger u32 checksum, iov_count = 0, padding = 0; 2283e48354ceSNicholas Bellinger struct iscsi_conn *conn = cmd->conn; 2284e48354ceSNicholas Bellinger struct kvec *iov; 2285e48354ceSNicholas Bellinger 2286e48354ceSNicholas Bellinger iov_ret = iscsit_map_iovec(cmd, cmd->iov_data, cmd->write_data_done, length); 2287e48354ceSNicholas Bellinger if (iov_ret < 0) 2288e48354ceSNicholas Bellinger return IMMEDIATE_DATA_CANNOT_RECOVER; 2289e48354ceSNicholas Bellinger 2290e48354ceSNicholas Bellinger rx_size = length; 2291e48354ceSNicholas Bellinger iov_count = iov_ret; 2292e48354ceSNicholas Bellinger iov = &cmd->iov_data[0]; 2293e48354ceSNicholas Bellinger 2294e48354ceSNicholas Bellinger padding = ((-length) & 3); 2295e48354ceSNicholas Bellinger if (padding != 0) { 2296e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pad_bytes; 2297e48354ceSNicholas Bellinger iov[iov_count++].iov_len = padding; 2298e48354ceSNicholas Bellinger rx_size += padding; 2299e48354ceSNicholas Bellinger } 2300e48354ceSNicholas Bellinger 2301e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 2302e48354ceSNicholas Bellinger iov[iov_count].iov_base = &checksum; 2303e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 2304e48354ceSNicholas Bellinger rx_size += ISCSI_CRC_LEN; 2305e48354ceSNicholas Bellinger } 2306e48354ceSNicholas Bellinger 2307e48354ceSNicholas Bellinger rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size); 2308e48354ceSNicholas Bellinger 2309e48354ceSNicholas Bellinger iscsit_unmap_iovec(cmd); 2310e48354ceSNicholas Bellinger 2311e48354ceSNicholas Bellinger if (rx_got != rx_size) { 2312e48354ceSNicholas Bellinger iscsit_rx_thread_wait_for_tcp(conn); 2313e48354ceSNicholas Bellinger return IMMEDIATE_DATA_CANNOT_RECOVER; 2314e48354ceSNicholas Bellinger } 2315e48354ceSNicholas Bellinger 2316e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 2317e48354ceSNicholas Bellinger u32 data_crc; 2318e48354ceSNicholas Bellinger 2319e48354ceSNicholas Bellinger data_crc = iscsit_do_crypto_hash_sg(&conn->conn_rx_hash, cmd, 2320e48354ceSNicholas Bellinger cmd->write_data_done, length, padding, 2321e48354ceSNicholas Bellinger cmd->pad_bytes); 2322e48354ceSNicholas Bellinger 2323e48354ceSNicholas Bellinger if (checksum != data_crc) { 2324e48354ceSNicholas Bellinger pr_err("ImmediateData CRC32C DataDigest 0x%08x" 2325e48354ceSNicholas Bellinger " does not match computed 0x%08x\n", checksum, 2326e48354ceSNicholas Bellinger data_crc); 2327e48354ceSNicholas Bellinger 2328e48354ceSNicholas Bellinger if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 2329e48354ceSNicholas Bellinger pr_err("Unable to recover from" 2330e48354ceSNicholas Bellinger " Immediate Data digest failure while" 2331e48354ceSNicholas Bellinger " in ERL=0.\n"); 2332e48354ceSNicholas Bellinger iscsit_add_reject_from_cmd( 2333e48354ceSNicholas Bellinger ISCSI_REASON_DATA_DIGEST_ERROR, 2334e48354ceSNicholas Bellinger 1, 0, buf, cmd); 2335e48354ceSNicholas Bellinger return IMMEDIATE_DATA_CANNOT_RECOVER; 2336e48354ceSNicholas Bellinger } else { 2337e48354ceSNicholas Bellinger iscsit_add_reject_from_cmd( 2338e48354ceSNicholas Bellinger ISCSI_REASON_DATA_DIGEST_ERROR, 2339e48354ceSNicholas Bellinger 0, 0, buf, cmd); 2340e48354ceSNicholas Bellinger return IMMEDIATE_DATA_ERL1_CRC_FAILURE; 2341e48354ceSNicholas Bellinger } 2342e48354ceSNicholas Bellinger } else { 2343e48354ceSNicholas Bellinger pr_debug("Got CRC32C DataDigest 0x%08x for" 2344e48354ceSNicholas Bellinger " %u bytes of Immediate Data\n", checksum, 2345e48354ceSNicholas Bellinger length); 2346e48354ceSNicholas Bellinger } 2347e48354ceSNicholas Bellinger } 2348e48354ceSNicholas Bellinger 2349e48354ceSNicholas Bellinger cmd->write_data_done += length; 2350e48354ceSNicholas Bellinger 2351e48354ceSNicholas Bellinger if (cmd->write_data_done == cmd->data_length) { 2352e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 2353e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT; 2354e48354ceSNicholas Bellinger cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT; 2355e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 2356e48354ceSNicholas Bellinger } 2357e48354ceSNicholas Bellinger 2358e48354ceSNicholas Bellinger return IMMEDIATE_DATA_NORMAL_OPERATION; 2359e48354ceSNicholas Bellinger } 2360e48354ceSNicholas Bellinger 2361e48354ceSNicholas Bellinger /* 2362e48354ceSNicholas Bellinger * Called with sess->conn_lock held. 2363e48354ceSNicholas Bellinger */ 2364e48354ceSNicholas Bellinger /* #warning iscsi_build_conn_drop_async_message() only sends out on connections 2365e48354ceSNicholas Bellinger with active network interface */ 2366e48354ceSNicholas Bellinger static void iscsit_build_conn_drop_async_message(struct iscsi_conn *conn) 2367e48354ceSNicholas Bellinger { 2368e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 2369e48354ceSNicholas Bellinger struct iscsi_conn *conn_p; 2370e48354ceSNicholas Bellinger 2371e48354ceSNicholas Bellinger /* 2372e48354ceSNicholas Bellinger * Only send a Asynchronous Message on connections whos network 2373e48354ceSNicholas Bellinger * interface is still functional. 2374e48354ceSNicholas Bellinger */ 2375e48354ceSNicholas Bellinger list_for_each_entry(conn_p, &conn->sess->sess_conn_list, conn_list) { 2376e48354ceSNicholas Bellinger if (conn_p->conn_state == TARG_CONN_STATE_LOGGED_IN) { 2377e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn_p); 2378e48354ceSNicholas Bellinger break; 2379e48354ceSNicholas Bellinger } 2380e48354ceSNicholas Bellinger } 2381e48354ceSNicholas Bellinger 2382e48354ceSNicholas Bellinger if (!conn_p) 2383e48354ceSNicholas Bellinger return; 2384e48354ceSNicholas Bellinger 2385e48354ceSNicholas Bellinger cmd = iscsit_allocate_cmd(conn_p, GFP_KERNEL); 2386e48354ceSNicholas Bellinger if (!cmd) { 2387e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn_p); 2388e48354ceSNicholas Bellinger return; 2389e48354ceSNicholas Bellinger } 2390e48354ceSNicholas Bellinger 2391e48354ceSNicholas Bellinger cmd->logout_cid = conn->cid; 2392e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT; 2393e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SEND_ASYNCMSG; 2394e48354ceSNicholas Bellinger 2395e48354ceSNicholas Bellinger spin_lock_bh(&conn_p->cmd_lock); 2396e48354ceSNicholas Bellinger list_add_tail(&cmd->i_list, &conn_p->conn_cmd_list); 2397e48354ceSNicholas Bellinger spin_unlock_bh(&conn_p->cmd_lock); 2398e48354ceSNicholas Bellinger 2399e48354ceSNicholas Bellinger iscsit_add_cmd_to_response_queue(cmd, conn_p, cmd->i_state); 2400e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn_p); 2401e48354ceSNicholas Bellinger } 2402e48354ceSNicholas Bellinger 2403e48354ceSNicholas Bellinger static int iscsit_send_conn_drop_async_message( 2404e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2405e48354ceSNicholas Bellinger struct iscsi_conn *conn) 2406e48354ceSNicholas Bellinger { 2407e48354ceSNicholas Bellinger struct iscsi_async *hdr; 2408e48354ceSNicholas Bellinger 2409e48354ceSNicholas Bellinger cmd->tx_size = ISCSI_HDR_LEN; 2410e48354ceSNicholas Bellinger cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT; 2411e48354ceSNicholas Bellinger 2412e48354ceSNicholas Bellinger hdr = (struct iscsi_async *) cmd->pdu; 2413e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_ASYNC_EVENT; 2414e48354ceSNicholas Bellinger hdr->flags = ISCSI_FLAG_CMD_FINAL; 2415e48354ceSNicholas Bellinger cmd->init_task_tag = 0xFFFFFFFF; 2416e48354ceSNicholas Bellinger cmd->targ_xfer_tag = 0xFFFFFFFF; 2417e48354ceSNicholas Bellinger put_unaligned_be64(0xFFFFFFFFFFFFFFFFULL, &hdr->rsvd4[0]); 2418e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 2419e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 2420e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2421e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2422e48354ceSNicholas Bellinger hdr->async_event = ISCSI_ASYNC_MSG_DROPPING_CONNECTION; 2423e48354ceSNicholas Bellinger hdr->param1 = cpu_to_be16(cmd->logout_cid); 2424e48354ceSNicholas Bellinger hdr->param2 = cpu_to_be16(conn->sess->sess_ops->DefaultTime2Wait); 2425e48354ceSNicholas Bellinger hdr->param3 = cpu_to_be16(conn->sess->sess_ops->DefaultTime2Retain); 2426e48354ceSNicholas Bellinger 2427e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2428e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2429e48354ceSNicholas Bellinger 2430e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2431e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2432e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2433e48354ceSNicholas Bellinger 2434e48354ceSNicholas Bellinger cmd->tx_size += ISCSI_CRC_LEN; 2435e48354ceSNicholas Bellinger pr_debug("Attaching CRC32C HeaderDigest to" 2436e48354ceSNicholas Bellinger " Async Message 0x%08x\n", *header_digest); 2437e48354ceSNicholas Bellinger } 2438e48354ceSNicholas Bellinger 2439e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_base = cmd->pdu; 2440e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len = cmd->tx_size; 2441e48354ceSNicholas Bellinger cmd->iov_misc_count = 1; 2442e48354ceSNicholas Bellinger 2443e48354ceSNicholas Bellinger pr_debug("Sending Connection Dropped Async Message StatSN:" 2444e48354ceSNicholas Bellinger " 0x%08x, for CID: %hu on CID: %hu\n", cmd->stat_sn, 2445e48354ceSNicholas Bellinger cmd->logout_cid, conn->cid); 2446e48354ceSNicholas Bellinger return 0; 2447e48354ceSNicholas Bellinger } 2448e48354ceSNicholas Bellinger 2449e48354ceSNicholas Bellinger static int iscsit_send_data_in( 2450e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2451e48354ceSNicholas Bellinger struct iscsi_conn *conn, 2452e48354ceSNicholas Bellinger int *eodr) 2453e48354ceSNicholas Bellinger { 2454e48354ceSNicholas Bellinger int iov_ret = 0, set_statsn = 0; 2455e48354ceSNicholas Bellinger u32 iov_count = 0, tx_size = 0; 2456e48354ceSNicholas Bellinger struct iscsi_datain datain; 2457e48354ceSNicholas Bellinger struct iscsi_datain_req *dr; 2458e48354ceSNicholas Bellinger struct iscsi_data_rsp *hdr; 2459e48354ceSNicholas Bellinger struct kvec *iov; 2460e48354ceSNicholas Bellinger 2461e48354ceSNicholas Bellinger memset(&datain, 0, sizeof(struct iscsi_datain)); 2462e48354ceSNicholas Bellinger dr = iscsit_get_datain_values(cmd, &datain); 2463e48354ceSNicholas Bellinger if (!dr) { 2464e48354ceSNicholas Bellinger pr_err("iscsit_get_datain_values failed for ITT: 0x%08x\n", 2465e48354ceSNicholas Bellinger cmd->init_task_tag); 2466e48354ceSNicholas Bellinger return -1; 2467e48354ceSNicholas Bellinger } 2468e48354ceSNicholas Bellinger 2469e48354ceSNicholas Bellinger /* 2470e48354ceSNicholas Bellinger * Be paranoid and double check the logic for now. 2471e48354ceSNicholas Bellinger */ 2472e48354ceSNicholas Bellinger if ((datain.offset + datain.length) > cmd->data_length) { 2473e48354ceSNicholas Bellinger pr_err("Command ITT: 0x%08x, datain.offset: %u and" 2474e48354ceSNicholas Bellinger " datain.length: %u exceeds cmd->data_length: %u\n", 2475e48354ceSNicholas Bellinger cmd->init_task_tag, datain.offset, datain.length, 2476e48354ceSNicholas Bellinger cmd->data_length); 2477e48354ceSNicholas Bellinger return -1; 2478e48354ceSNicholas Bellinger } 2479e48354ceSNicholas Bellinger 2480e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->session_stats_lock); 2481e48354ceSNicholas Bellinger conn->sess->tx_data_octets += datain.length; 2482e48354ceSNicholas Bellinger if (conn->sess->se_sess->se_node_acl) { 2483e48354ceSNicholas Bellinger spin_lock(&conn->sess->se_sess->se_node_acl->stats_lock); 2484e48354ceSNicholas Bellinger conn->sess->se_sess->se_node_acl->read_bytes += datain.length; 2485e48354ceSNicholas Bellinger spin_unlock(&conn->sess->se_sess->se_node_acl->stats_lock); 2486e48354ceSNicholas Bellinger } 2487e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->session_stats_lock); 2488e48354ceSNicholas Bellinger /* 2489e48354ceSNicholas Bellinger * Special case for successfully execution w/ both DATAIN 2490e48354ceSNicholas Bellinger * and Sense Data. 2491e48354ceSNicholas Bellinger */ 2492e48354ceSNicholas Bellinger if ((datain.flags & ISCSI_FLAG_DATA_STATUS) && 2493e48354ceSNicholas Bellinger (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE)) 2494e48354ceSNicholas Bellinger datain.flags &= ~ISCSI_FLAG_DATA_STATUS; 2495e48354ceSNicholas Bellinger else { 2496e48354ceSNicholas Bellinger if ((dr->dr_complete == DATAIN_COMPLETE_NORMAL) || 2497e48354ceSNicholas Bellinger (dr->dr_complete == DATAIN_COMPLETE_CONNECTION_RECOVERY)) { 2498e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 2499e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 2500e48354ceSNicholas Bellinger set_statsn = 1; 2501e48354ceSNicholas Bellinger } else if (dr->dr_complete == 2502e48354ceSNicholas Bellinger DATAIN_COMPLETE_WITHIN_COMMAND_RECOVERY) 2503e48354ceSNicholas Bellinger set_statsn = 1; 2504e48354ceSNicholas Bellinger } 2505e48354ceSNicholas Bellinger 2506e48354ceSNicholas Bellinger hdr = (struct iscsi_data_rsp *) cmd->pdu; 2507e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 2508e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_SCSI_DATA_IN; 2509e48354ceSNicholas Bellinger hdr->flags = datain.flags; 2510e48354ceSNicholas Bellinger if (hdr->flags & ISCSI_FLAG_DATA_STATUS) { 2511e48354ceSNicholas Bellinger if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) { 2512e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_DATA_OVERFLOW; 25137e46cf02SNicholas Bellinger hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); 2514e48354ceSNicholas Bellinger } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) { 2515e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_DATA_UNDERFLOW; 25167e46cf02SNicholas Bellinger hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); 2517e48354ceSNicholas Bellinger } 2518e48354ceSNicholas Bellinger } 2519e48354ceSNicholas Bellinger hton24(hdr->dlength, datain.length); 2520e48354ceSNicholas Bellinger if (hdr->flags & ISCSI_FLAG_DATA_ACK) 2521e48354ceSNicholas Bellinger int_to_scsilun(cmd->se_cmd.orig_fe_lun, 2522e48354ceSNicholas Bellinger (struct scsi_lun *)&hdr->lun); 2523e48354ceSNicholas Bellinger else 2524e48354ceSNicholas Bellinger put_unaligned_le64(0xFFFFFFFFFFFFFFFFULL, &hdr->lun); 2525e48354ceSNicholas Bellinger 2526e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 2527e48354ceSNicholas Bellinger hdr->ttt = (hdr->flags & ISCSI_FLAG_DATA_ACK) ? 2528e48354ceSNicholas Bellinger cpu_to_be32(cmd->targ_xfer_tag) : 2529e48354ceSNicholas Bellinger 0xFFFFFFFF; 2530e48354ceSNicholas Bellinger hdr->statsn = (set_statsn) ? cpu_to_be32(cmd->stat_sn) : 2531e48354ceSNicholas Bellinger 0xFFFFFFFF; 2532e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2533e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2534e48354ceSNicholas Bellinger hdr->datasn = cpu_to_be32(datain.data_sn); 2535e48354ceSNicholas Bellinger hdr->offset = cpu_to_be32(datain.offset); 2536e48354ceSNicholas Bellinger 2537e48354ceSNicholas Bellinger iov = &cmd->iov_data[0]; 2538e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pdu; 2539e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_HDR_LEN; 2540e48354ceSNicholas Bellinger tx_size += ISCSI_HDR_LEN; 2541e48354ceSNicholas Bellinger 2542e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2543e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2544e48354ceSNicholas Bellinger 2545e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2546e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2547e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2548e48354ceSNicholas Bellinger 2549e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 2550e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2551e48354ceSNicholas Bellinger 2552e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest" 2553e48354ceSNicholas Bellinger " for DataIN PDU 0x%08x\n", *header_digest); 2554e48354ceSNicholas Bellinger } 2555e48354ceSNicholas Bellinger 2556e48354ceSNicholas Bellinger iov_ret = iscsit_map_iovec(cmd, &cmd->iov_data[1], datain.offset, datain.length); 2557e48354ceSNicholas Bellinger if (iov_ret < 0) 2558e48354ceSNicholas Bellinger return -1; 2559e48354ceSNicholas Bellinger 2560e48354ceSNicholas Bellinger iov_count += iov_ret; 2561e48354ceSNicholas Bellinger tx_size += datain.length; 2562e48354ceSNicholas Bellinger 2563e48354ceSNicholas Bellinger cmd->padding = ((-datain.length) & 3); 2564e48354ceSNicholas Bellinger if (cmd->padding) { 2565e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pad_bytes; 2566e48354ceSNicholas Bellinger iov[iov_count++].iov_len = cmd->padding; 2567e48354ceSNicholas Bellinger tx_size += cmd->padding; 2568e48354ceSNicholas Bellinger 2569e48354ceSNicholas Bellinger pr_debug("Attaching %u padding bytes\n", 2570e48354ceSNicholas Bellinger cmd->padding); 2571e48354ceSNicholas Bellinger } 2572e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 2573e48354ceSNicholas Bellinger cmd->data_crc = iscsit_do_crypto_hash_sg(&conn->conn_tx_hash, cmd, 2574e48354ceSNicholas Bellinger datain.offset, datain.length, cmd->padding, cmd->pad_bytes); 2575e48354ceSNicholas Bellinger 2576e48354ceSNicholas Bellinger iov[iov_count].iov_base = &cmd->data_crc; 2577e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 2578e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2579e48354ceSNicholas Bellinger 2580e48354ceSNicholas Bellinger pr_debug("Attached CRC32C DataDigest %d bytes, crc" 2581e48354ceSNicholas Bellinger " 0x%08x\n", datain.length+cmd->padding, cmd->data_crc); 2582e48354ceSNicholas Bellinger } 2583e48354ceSNicholas Bellinger 2584e48354ceSNicholas Bellinger cmd->iov_data_count = iov_count; 2585e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 2586e48354ceSNicholas Bellinger 2587e48354ceSNicholas Bellinger pr_debug("Built DataIN ITT: 0x%08x, StatSN: 0x%08x," 2588e48354ceSNicholas Bellinger " DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n", 2589e48354ceSNicholas Bellinger cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn), 2590e48354ceSNicholas Bellinger ntohl(hdr->offset), datain.length, conn->cid); 2591e48354ceSNicholas Bellinger 2592e48354ceSNicholas Bellinger if (dr->dr_complete) { 2593e48354ceSNicholas Bellinger *eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ? 2594e48354ceSNicholas Bellinger 2 : 1; 2595e48354ceSNicholas Bellinger iscsit_free_datain_req(cmd, dr); 2596e48354ceSNicholas Bellinger } 2597e48354ceSNicholas Bellinger 2598e48354ceSNicholas Bellinger return 0; 2599e48354ceSNicholas Bellinger } 2600e48354ceSNicholas Bellinger 2601e48354ceSNicholas Bellinger static int iscsit_send_logout_response( 2602e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2603e48354ceSNicholas Bellinger struct iscsi_conn *conn) 2604e48354ceSNicholas Bellinger { 2605e48354ceSNicholas Bellinger int niov = 0, tx_size; 2606e48354ceSNicholas Bellinger struct iscsi_conn *logout_conn = NULL; 2607e48354ceSNicholas Bellinger struct iscsi_conn_recovery *cr = NULL; 2608e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 2609e48354ceSNicholas Bellinger struct kvec *iov; 2610e48354ceSNicholas Bellinger struct iscsi_logout_rsp *hdr; 2611e48354ceSNicholas Bellinger /* 2612e48354ceSNicholas Bellinger * The actual shutting down of Sessions and/or Connections 2613e48354ceSNicholas Bellinger * for CLOSESESSION and CLOSECONNECTION Logout Requests 2614e48354ceSNicholas Bellinger * is done in scsi_logout_post_handler(). 2615e48354ceSNicholas Bellinger */ 2616e48354ceSNicholas Bellinger switch (cmd->logout_reason) { 2617e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_CLOSE_SESSION: 2618e48354ceSNicholas Bellinger pr_debug("iSCSI session logout successful, setting" 2619e48354ceSNicholas Bellinger " logout response to ISCSI_LOGOUT_SUCCESS.\n"); 2620e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_SUCCESS; 2621e48354ceSNicholas Bellinger break; 2622e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_CLOSE_CONNECTION: 2623e48354ceSNicholas Bellinger if (cmd->logout_response == ISCSI_LOGOUT_CID_NOT_FOUND) 2624e48354ceSNicholas Bellinger break; 2625e48354ceSNicholas Bellinger /* 2626e48354ceSNicholas Bellinger * For CLOSECONNECTION logout requests carrying 2627e48354ceSNicholas Bellinger * a matching logout CID -> local CID, the reference 2628e48354ceSNicholas Bellinger * for the local CID will have been incremented in 2629e48354ceSNicholas Bellinger * iscsi_logout_closeconnection(). 2630e48354ceSNicholas Bellinger * 2631e48354ceSNicholas Bellinger * For CLOSECONNECTION logout requests carrying 2632e48354ceSNicholas Bellinger * a different CID than the connection it arrived 2633e48354ceSNicholas Bellinger * on, the connection responding to cmd->logout_cid 2634e48354ceSNicholas Bellinger * is stopped in iscsit_logout_post_handler_diffcid(). 2635e48354ceSNicholas Bellinger */ 2636e48354ceSNicholas Bellinger 2637e48354ceSNicholas Bellinger pr_debug("iSCSI CID: %hu logout on CID: %hu" 2638e48354ceSNicholas Bellinger " successful.\n", cmd->logout_cid, conn->cid); 2639e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_SUCCESS; 2640e48354ceSNicholas Bellinger break; 2641e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_RECOVERY: 2642e48354ceSNicholas Bellinger if ((cmd->logout_response == ISCSI_LOGOUT_RECOVERY_UNSUPPORTED) || 2643e48354ceSNicholas Bellinger (cmd->logout_response == ISCSI_LOGOUT_CLEANUP_FAILED)) 2644e48354ceSNicholas Bellinger break; 2645e48354ceSNicholas Bellinger /* 2646e48354ceSNicholas Bellinger * If the connection is still active from our point of view 2647e48354ceSNicholas Bellinger * force connection recovery to occur. 2648e48354ceSNicholas Bellinger */ 2649e48354ceSNicholas Bellinger logout_conn = iscsit_get_conn_from_cid_rcfr(sess, 2650e48354ceSNicholas Bellinger cmd->logout_cid); 2651e48354ceSNicholas Bellinger if ((logout_conn)) { 2652e48354ceSNicholas Bellinger iscsit_connection_reinstatement_rcfr(logout_conn); 2653e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(logout_conn); 2654e48354ceSNicholas Bellinger } 2655e48354ceSNicholas Bellinger 2656e48354ceSNicholas Bellinger cr = iscsit_get_inactive_connection_recovery_entry( 2657e48354ceSNicholas Bellinger conn->sess, cmd->logout_cid); 2658e48354ceSNicholas Bellinger if (!cr) { 2659e48354ceSNicholas Bellinger pr_err("Unable to locate CID: %hu for" 2660e48354ceSNicholas Bellinger " REMOVECONNFORRECOVERY Logout Request.\n", 2661e48354ceSNicholas Bellinger cmd->logout_cid); 2662e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND; 2663e48354ceSNicholas Bellinger break; 2664e48354ceSNicholas Bellinger } 2665e48354ceSNicholas Bellinger 2666e48354ceSNicholas Bellinger iscsit_discard_cr_cmds_by_expstatsn(cr, cmd->exp_stat_sn); 2667e48354ceSNicholas Bellinger 2668e48354ceSNicholas Bellinger pr_debug("iSCSI REMOVECONNFORRECOVERY logout" 2669e48354ceSNicholas Bellinger " for recovery for CID: %hu on CID: %hu successful.\n", 2670e48354ceSNicholas Bellinger cmd->logout_cid, conn->cid); 2671e48354ceSNicholas Bellinger cmd->logout_response = ISCSI_LOGOUT_SUCCESS; 2672e48354ceSNicholas Bellinger break; 2673e48354ceSNicholas Bellinger default: 2674e48354ceSNicholas Bellinger pr_err("Unknown cmd->logout_reason: 0x%02x\n", 2675e48354ceSNicholas Bellinger cmd->logout_reason); 2676e48354ceSNicholas Bellinger return -1; 2677e48354ceSNicholas Bellinger } 2678e48354ceSNicholas Bellinger 2679e48354ceSNicholas Bellinger tx_size = ISCSI_HDR_LEN; 2680e48354ceSNicholas Bellinger hdr = (struct iscsi_logout_rsp *)cmd->pdu; 2681e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 2682e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_LOGOUT_RSP; 2683e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2684e48354ceSNicholas Bellinger hdr->response = cmd->logout_response; 2685e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 2686e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 2687e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 2688e48354ceSNicholas Bellinger 2689e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 2690e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2691e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2692e48354ceSNicholas Bellinger 2693e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 2694e48354ceSNicholas Bellinger iov[niov].iov_base = cmd->pdu; 2695e48354ceSNicholas Bellinger iov[niov++].iov_len = ISCSI_HDR_LEN; 2696e48354ceSNicholas Bellinger 2697e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2698e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2699e48354ceSNicholas Bellinger 2700e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2701e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2702e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2703e48354ceSNicholas Bellinger 2704e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 2705e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2706e48354ceSNicholas Bellinger pr_debug("Attaching CRC32C HeaderDigest to" 2707e48354ceSNicholas Bellinger " Logout Response 0x%08x\n", *header_digest); 2708e48354ceSNicholas Bellinger } 2709e48354ceSNicholas Bellinger cmd->iov_misc_count = niov; 2710e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 2711e48354ceSNicholas Bellinger 2712e48354ceSNicholas Bellinger pr_debug("Sending Logout Response ITT: 0x%08x StatSN:" 2713e48354ceSNicholas Bellinger " 0x%08x Response: 0x%02x CID: %hu on CID: %hu\n", 2714e48354ceSNicholas Bellinger cmd->init_task_tag, cmd->stat_sn, hdr->response, 2715e48354ceSNicholas Bellinger cmd->logout_cid, conn->cid); 2716e48354ceSNicholas Bellinger 2717e48354ceSNicholas Bellinger return 0; 2718e48354ceSNicholas Bellinger } 2719e48354ceSNicholas Bellinger 2720e48354ceSNicholas Bellinger /* 2721e48354ceSNicholas Bellinger * Unsolicited NOPIN, either requesting a response or not. 2722e48354ceSNicholas Bellinger */ 2723e48354ceSNicholas Bellinger static int iscsit_send_unsolicited_nopin( 2724e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2725e48354ceSNicholas Bellinger struct iscsi_conn *conn, 2726e48354ceSNicholas Bellinger int want_response) 2727e48354ceSNicholas Bellinger { 2728e48354ceSNicholas Bellinger int tx_size = ISCSI_HDR_LEN; 2729e48354ceSNicholas Bellinger struct iscsi_nopin *hdr; 2730e48354ceSNicholas Bellinger 2731e48354ceSNicholas Bellinger hdr = (struct iscsi_nopin *) cmd->pdu; 2732e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 2733e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_NOOP_IN; 2734e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2735e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 2736e48354ceSNicholas Bellinger hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); 2737e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn; 2738e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 2739e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2740e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2741e48354ceSNicholas Bellinger 2742e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2743e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2744e48354ceSNicholas Bellinger 2745e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2746e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2747e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2748e48354ceSNicholas Bellinger 2749e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2750e48354ceSNicholas Bellinger pr_debug("Attaching CRC32C HeaderDigest to" 2751e48354ceSNicholas Bellinger " NopIN 0x%08x\n", *header_digest); 2752e48354ceSNicholas Bellinger } 2753e48354ceSNicholas Bellinger 2754e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_base = cmd->pdu; 2755e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len = tx_size; 2756e48354ceSNicholas Bellinger cmd->iov_misc_count = 1; 2757e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 2758e48354ceSNicholas Bellinger 2759e48354ceSNicholas Bellinger pr_debug("Sending Unsolicited NOPIN TTT: 0x%08x StatSN:" 2760e48354ceSNicholas Bellinger " 0x%08x CID: %hu\n", hdr->ttt, cmd->stat_sn, conn->cid); 2761e48354ceSNicholas Bellinger 2762e48354ceSNicholas Bellinger return 0; 2763e48354ceSNicholas Bellinger } 2764e48354ceSNicholas Bellinger 2765e48354ceSNicholas Bellinger static int iscsit_send_nopin_response( 2766e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2767e48354ceSNicholas Bellinger struct iscsi_conn *conn) 2768e48354ceSNicholas Bellinger { 2769e48354ceSNicholas Bellinger int niov = 0, tx_size; 2770e48354ceSNicholas Bellinger u32 padding = 0; 2771e48354ceSNicholas Bellinger struct kvec *iov; 2772e48354ceSNicholas Bellinger struct iscsi_nopin *hdr; 2773e48354ceSNicholas Bellinger 2774e48354ceSNicholas Bellinger tx_size = ISCSI_HDR_LEN; 2775e48354ceSNicholas Bellinger hdr = (struct iscsi_nopin *) cmd->pdu; 2776e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 2777e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_NOOP_IN; 2778e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2779e48354ceSNicholas Bellinger hton24(hdr->dlength, cmd->buf_ptr_size); 2780e48354ceSNicholas Bellinger put_unaligned_le64(0xFFFFFFFFFFFFFFFFULL, &hdr->lun); 2781e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 2782e48354ceSNicholas Bellinger hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); 2783e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 2784e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 2785e48354ceSNicholas Bellinger 2786e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 2787e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2788e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2789e48354ceSNicholas Bellinger 2790e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 2791e48354ceSNicholas Bellinger iov[niov].iov_base = cmd->pdu; 2792e48354ceSNicholas Bellinger iov[niov++].iov_len = ISCSI_HDR_LEN; 2793e48354ceSNicholas Bellinger 2794e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2795e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2796e48354ceSNicholas Bellinger 2797e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2798e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2799e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2800e48354ceSNicholas Bellinger 2801e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 2802e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2803e48354ceSNicholas Bellinger pr_debug("Attaching CRC32C HeaderDigest" 2804e48354ceSNicholas Bellinger " to NopIn 0x%08x\n", *header_digest); 2805e48354ceSNicholas Bellinger } 2806e48354ceSNicholas Bellinger 2807e48354ceSNicholas Bellinger /* 2808e48354ceSNicholas Bellinger * NOPOUT Ping Data is attached to struct iscsi_cmd->buf_ptr. 2809e48354ceSNicholas Bellinger * NOPOUT DataSegmentLength is at struct iscsi_cmd->buf_ptr_size. 2810e48354ceSNicholas Bellinger */ 2811e48354ceSNicholas Bellinger if (cmd->buf_ptr_size) { 2812e48354ceSNicholas Bellinger iov[niov].iov_base = cmd->buf_ptr; 2813e48354ceSNicholas Bellinger iov[niov++].iov_len = cmd->buf_ptr_size; 2814e48354ceSNicholas Bellinger tx_size += cmd->buf_ptr_size; 2815e48354ceSNicholas Bellinger 2816e48354ceSNicholas Bellinger pr_debug("Echoing back %u bytes of ping" 2817e48354ceSNicholas Bellinger " data.\n", cmd->buf_ptr_size); 2818e48354ceSNicholas Bellinger 2819e48354ceSNicholas Bellinger padding = ((-cmd->buf_ptr_size) & 3); 2820e48354ceSNicholas Bellinger if (padding != 0) { 2821e48354ceSNicholas Bellinger iov[niov].iov_base = &cmd->pad_bytes; 2822e48354ceSNicholas Bellinger iov[niov++].iov_len = padding; 2823e48354ceSNicholas Bellinger tx_size += padding; 2824e48354ceSNicholas Bellinger pr_debug("Attaching %u additional" 2825e48354ceSNicholas Bellinger " padding bytes.\n", padding); 2826e48354ceSNicholas Bellinger } 2827e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 2828e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2829e48354ceSNicholas Bellinger cmd->buf_ptr, cmd->buf_ptr_size, 2830e48354ceSNicholas Bellinger padding, (u8 *)&cmd->pad_bytes, 2831e48354ceSNicholas Bellinger (u8 *)&cmd->data_crc); 2832e48354ceSNicholas Bellinger 2833e48354ceSNicholas Bellinger iov[niov].iov_base = &cmd->data_crc; 2834e48354ceSNicholas Bellinger iov[niov++].iov_len = ISCSI_CRC_LEN; 2835e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2836e48354ceSNicholas Bellinger pr_debug("Attached DataDigest for %u" 2837e48354ceSNicholas Bellinger " bytes of ping data, CRC 0x%08x\n", 2838e48354ceSNicholas Bellinger cmd->buf_ptr_size, cmd->data_crc); 2839e48354ceSNicholas Bellinger } 2840e48354ceSNicholas Bellinger } 2841e48354ceSNicholas Bellinger 2842e48354ceSNicholas Bellinger cmd->iov_misc_count = niov; 2843e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 2844e48354ceSNicholas Bellinger 2845e48354ceSNicholas Bellinger pr_debug("Sending NOPIN Response ITT: 0x%08x, TTT:" 2846e48354ceSNicholas Bellinger " 0x%08x, StatSN: 0x%08x, Length %u\n", cmd->init_task_tag, 2847e48354ceSNicholas Bellinger cmd->targ_xfer_tag, cmd->stat_sn, cmd->buf_ptr_size); 2848e48354ceSNicholas Bellinger 2849e48354ceSNicholas Bellinger return 0; 2850e48354ceSNicholas Bellinger } 2851e48354ceSNicholas Bellinger 2852e48354ceSNicholas Bellinger int iscsit_send_r2t( 2853e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2854e48354ceSNicholas Bellinger struct iscsi_conn *conn) 2855e48354ceSNicholas Bellinger { 2856e48354ceSNicholas Bellinger int tx_size = 0; 2857e48354ceSNicholas Bellinger struct iscsi_r2t *r2t; 2858e48354ceSNicholas Bellinger struct iscsi_r2t_rsp *hdr; 2859e48354ceSNicholas Bellinger 2860e48354ceSNicholas Bellinger r2t = iscsit_get_r2t_from_list(cmd); 2861e48354ceSNicholas Bellinger if (!r2t) 2862e48354ceSNicholas Bellinger return -1; 2863e48354ceSNicholas Bellinger 2864e48354ceSNicholas Bellinger hdr = (struct iscsi_r2t_rsp *) cmd->pdu; 2865e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 2866e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_R2T; 2867e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2868e48354ceSNicholas Bellinger int_to_scsilun(cmd->se_cmd.orig_fe_lun, 2869e48354ceSNicholas Bellinger (struct scsi_lun *)&hdr->lun); 2870e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 2871e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->ttt_lock); 2872e48354ceSNicholas Bellinger r2t->targ_xfer_tag = conn->sess->targ_xfer_tag++; 2873e48354ceSNicholas Bellinger if (r2t->targ_xfer_tag == 0xFFFFFFFF) 2874e48354ceSNicholas Bellinger r2t->targ_xfer_tag = conn->sess->targ_xfer_tag++; 2875e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->ttt_lock); 2876e48354ceSNicholas Bellinger hdr->ttt = cpu_to_be32(r2t->targ_xfer_tag); 2877e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(conn->stat_sn); 2878e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2879e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2880e48354ceSNicholas Bellinger hdr->r2tsn = cpu_to_be32(r2t->r2t_sn); 2881e48354ceSNicholas Bellinger hdr->data_offset = cpu_to_be32(r2t->offset); 2882e48354ceSNicholas Bellinger hdr->data_length = cpu_to_be32(r2t->xfer_len); 2883e48354ceSNicholas Bellinger 2884e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_base = cmd->pdu; 2885e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len = ISCSI_HDR_LEN; 2886e48354ceSNicholas Bellinger tx_size += ISCSI_HDR_LEN; 2887e48354ceSNicholas Bellinger 2888e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 2889e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 2890e48354ceSNicholas Bellinger 2891e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 2892e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 2893e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 2894e48354ceSNicholas Bellinger 2895e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len += ISCSI_CRC_LEN; 2896e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 2897e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest for R2T" 2898e48354ceSNicholas Bellinger " PDU 0x%08x\n", *header_digest); 2899e48354ceSNicholas Bellinger } 2900e48354ceSNicholas Bellinger 2901e48354ceSNicholas Bellinger pr_debug("Built %sR2T, ITT: 0x%08x, TTT: 0x%08x, StatSN:" 2902e48354ceSNicholas Bellinger " 0x%08x, R2TSN: 0x%08x, Offset: %u, DDTL: %u, CID: %hu\n", 2903e48354ceSNicholas Bellinger (!r2t->recovery_r2t) ? "" : "Recovery ", cmd->init_task_tag, 2904e48354ceSNicholas Bellinger r2t->targ_xfer_tag, ntohl(hdr->statsn), r2t->r2t_sn, 2905e48354ceSNicholas Bellinger r2t->offset, r2t->xfer_len, conn->cid); 2906e48354ceSNicholas Bellinger 2907e48354ceSNicholas Bellinger cmd->iov_misc_count = 1; 2908e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 2909e48354ceSNicholas Bellinger 2910e48354ceSNicholas Bellinger spin_lock_bh(&cmd->r2t_lock); 2911e48354ceSNicholas Bellinger r2t->sent_r2t = 1; 2912e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->r2t_lock); 2913e48354ceSNicholas Bellinger 2914e48354ceSNicholas Bellinger return 0; 2915e48354ceSNicholas Bellinger } 2916e48354ceSNicholas Bellinger 2917e48354ceSNicholas Bellinger /* 2918e48354ceSNicholas Bellinger * type 0: Normal Operation. 2919e48354ceSNicholas Bellinger * type 1: Called from Storage Transport. 2920e48354ceSNicholas Bellinger * type 2: Called from iscsi_task_reassign_complete_write() for 2921e48354ceSNicholas Bellinger * connection recovery. 2922e48354ceSNicholas Bellinger */ 2923e48354ceSNicholas Bellinger int iscsit_build_r2ts_for_cmd( 2924e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2925e48354ceSNicholas Bellinger struct iscsi_conn *conn, 2926e48354ceSNicholas Bellinger int type) 2927e48354ceSNicholas Bellinger { 2928e48354ceSNicholas Bellinger int first_r2t = 1; 2929e48354ceSNicholas Bellinger u32 offset = 0, xfer_len = 0; 2930e48354ceSNicholas Bellinger 2931e48354ceSNicholas Bellinger spin_lock_bh(&cmd->r2t_lock); 2932e48354ceSNicholas Bellinger if (cmd->cmd_flags & ICF_SENT_LAST_R2T) { 2933e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->r2t_lock); 2934e48354ceSNicholas Bellinger return 0; 2935e48354ceSNicholas Bellinger } 2936e48354ceSNicholas Bellinger 2937e48354ceSNicholas Bellinger if (conn->sess->sess_ops->DataSequenceInOrder && (type != 2)) 2938e48354ceSNicholas Bellinger if (cmd->r2t_offset < cmd->write_data_done) 2939e48354ceSNicholas Bellinger cmd->r2t_offset = cmd->write_data_done; 2940e48354ceSNicholas Bellinger 2941e48354ceSNicholas Bellinger while (cmd->outstanding_r2ts < conn->sess->sess_ops->MaxOutstandingR2T) { 2942e48354ceSNicholas Bellinger if (conn->sess->sess_ops->DataSequenceInOrder) { 2943e48354ceSNicholas Bellinger offset = cmd->r2t_offset; 2944e48354ceSNicholas Bellinger 2945e48354ceSNicholas Bellinger if (first_r2t && (type == 2)) { 2946e48354ceSNicholas Bellinger xfer_len = ((offset + 2947e48354ceSNicholas Bellinger (conn->sess->sess_ops->MaxBurstLength - 2948e48354ceSNicholas Bellinger cmd->next_burst_len) > 2949e48354ceSNicholas Bellinger cmd->data_length) ? 2950e48354ceSNicholas Bellinger (cmd->data_length - offset) : 2951e48354ceSNicholas Bellinger (conn->sess->sess_ops->MaxBurstLength - 2952e48354ceSNicholas Bellinger cmd->next_burst_len)); 2953e48354ceSNicholas Bellinger } else { 2954e48354ceSNicholas Bellinger xfer_len = ((offset + 2955e48354ceSNicholas Bellinger conn->sess->sess_ops->MaxBurstLength) > 2956e48354ceSNicholas Bellinger cmd->data_length) ? 2957e48354ceSNicholas Bellinger (cmd->data_length - offset) : 2958e48354ceSNicholas Bellinger conn->sess->sess_ops->MaxBurstLength; 2959e48354ceSNicholas Bellinger } 2960e48354ceSNicholas Bellinger cmd->r2t_offset += xfer_len; 2961e48354ceSNicholas Bellinger 2962e48354ceSNicholas Bellinger if (cmd->r2t_offset == cmd->data_length) 2963e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_SENT_LAST_R2T; 2964e48354ceSNicholas Bellinger } else { 2965e48354ceSNicholas Bellinger struct iscsi_seq *seq; 2966e48354ceSNicholas Bellinger 2967e48354ceSNicholas Bellinger seq = iscsit_get_seq_holder_for_r2t(cmd); 2968e48354ceSNicholas Bellinger if (!seq) { 2969e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->r2t_lock); 2970e48354ceSNicholas Bellinger return -1; 2971e48354ceSNicholas Bellinger } 2972e48354ceSNicholas Bellinger 2973e48354ceSNicholas Bellinger offset = seq->offset; 2974e48354ceSNicholas Bellinger xfer_len = seq->xfer_len; 2975e48354ceSNicholas Bellinger 2976e48354ceSNicholas Bellinger if (cmd->seq_send_order == cmd->seq_count) 2977e48354ceSNicholas Bellinger cmd->cmd_flags |= ICF_SENT_LAST_R2T; 2978e48354ceSNicholas Bellinger } 2979e48354ceSNicholas Bellinger cmd->outstanding_r2ts++; 2980e48354ceSNicholas Bellinger first_r2t = 0; 2981e48354ceSNicholas Bellinger 2982e48354ceSNicholas Bellinger if (iscsit_add_r2t_to_list(cmd, offset, xfer_len, 0, 0) < 0) { 2983e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->r2t_lock); 2984e48354ceSNicholas Bellinger return -1; 2985e48354ceSNicholas Bellinger } 2986e48354ceSNicholas Bellinger 2987e48354ceSNicholas Bellinger if (cmd->cmd_flags & ICF_SENT_LAST_R2T) 2988e48354ceSNicholas Bellinger break; 2989e48354ceSNicholas Bellinger } 2990e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->r2t_lock); 2991e48354ceSNicholas Bellinger 2992e48354ceSNicholas Bellinger return 0; 2993e48354ceSNicholas Bellinger } 2994e48354ceSNicholas Bellinger 2995e48354ceSNicholas Bellinger static int iscsit_send_status( 2996e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 2997e48354ceSNicholas Bellinger struct iscsi_conn *conn) 2998e48354ceSNicholas Bellinger { 2999e48354ceSNicholas Bellinger u8 iov_count = 0, recovery; 3000e48354ceSNicholas Bellinger u32 padding = 0, tx_size = 0; 3001e48354ceSNicholas Bellinger struct iscsi_scsi_rsp *hdr; 3002e48354ceSNicholas Bellinger struct kvec *iov; 3003e48354ceSNicholas Bellinger 3004e48354ceSNicholas Bellinger recovery = (cmd->i_state != ISTATE_SEND_STATUS); 3005e48354ceSNicholas Bellinger if (!recovery) 3006e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 3007e48354ceSNicholas Bellinger 3008e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->session_stats_lock); 3009e48354ceSNicholas Bellinger conn->sess->rsp_pdus++; 3010e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->session_stats_lock); 3011e48354ceSNicholas Bellinger 3012e48354ceSNicholas Bellinger hdr = (struct iscsi_scsi_rsp *) cmd->pdu; 3013e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 3014e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_SCSI_CMD_RSP; 3015e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3016e48354ceSNicholas Bellinger if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) { 3017e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_OVERFLOW; 30187e46cf02SNicholas Bellinger hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); 3019e48354ceSNicholas Bellinger } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) { 3020e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 30217e46cf02SNicholas Bellinger hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count); 3022e48354ceSNicholas Bellinger } 3023e48354ceSNicholas Bellinger hdr->response = cmd->iscsi_response; 3024e48354ceSNicholas Bellinger hdr->cmd_status = cmd->se_cmd.scsi_status; 3025e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 3026e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 3027e48354ceSNicholas Bellinger 3028e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 3029e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3030e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3031e48354ceSNicholas Bellinger 3032e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 3033e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pdu; 3034e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_HDR_LEN; 3035e48354ceSNicholas Bellinger tx_size += ISCSI_HDR_LEN; 3036e48354ceSNicholas Bellinger 3037e48354ceSNicholas Bellinger /* 3038e48354ceSNicholas Bellinger * Attach SENSE DATA payload to iSCSI Response PDU 3039e48354ceSNicholas Bellinger */ 3040e48354ceSNicholas Bellinger if (cmd->se_cmd.sense_buffer && 3041e48354ceSNicholas Bellinger ((cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) || 3042e48354ceSNicholas Bellinger (cmd->se_cmd.se_cmd_flags & SCF_EMULATED_TASK_SENSE))) { 3043e48354ceSNicholas Bellinger padding = -(cmd->se_cmd.scsi_sense_length) & 3; 3044e48354ceSNicholas Bellinger hton24(hdr->dlength, cmd->se_cmd.scsi_sense_length); 3045e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->se_cmd.sense_buffer; 3046e48354ceSNicholas Bellinger iov[iov_count++].iov_len = 3047e48354ceSNicholas Bellinger (cmd->se_cmd.scsi_sense_length + padding); 3048e48354ceSNicholas Bellinger tx_size += cmd->se_cmd.scsi_sense_length; 3049e48354ceSNicholas Bellinger 3050e48354ceSNicholas Bellinger if (padding) { 3051e48354ceSNicholas Bellinger memset(cmd->se_cmd.sense_buffer + 3052e48354ceSNicholas Bellinger cmd->se_cmd.scsi_sense_length, 0, padding); 3053e48354ceSNicholas Bellinger tx_size += padding; 3054e48354ceSNicholas Bellinger pr_debug("Adding %u bytes of padding to" 3055e48354ceSNicholas Bellinger " SENSE.\n", padding); 3056e48354ceSNicholas Bellinger } 3057e48354ceSNicholas Bellinger 3058e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 3059e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3060e48354ceSNicholas Bellinger cmd->se_cmd.sense_buffer, 3061e48354ceSNicholas Bellinger (cmd->se_cmd.scsi_sense_length + padding), 3062e48354ceSNicholas Bellinger 0, NULL, (u8 *)&cmd->data_crc); 3063e48354ceSNicholas Bellinger 3064e48354ceSNicholas Bellinger iov[iov_count].iov_base = &cmd->data_crc; 3065e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 3066e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3067e48354ceSNicholas Bellinger 3068e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 DataDigest for" 3069e48354ceSNicholas Bellinger " SENSE, %u bytes CRC 0x%08x\n", 3070e48354ceSNicholas Bellinger (cmd->se_cmd.scsi_sense_length + padding), 3071e48354ceSNicholas Bellinger cmd->data_crc); 3072e48354ceSNicholas Bellinger } 3073e48354ceSNicholas Bellinger 3074e48354ceSNicholas Bellinger pr_debug("Attaching SENSE DATA: %u bytes to iSCSI" 3075e48354ceSNicholas Bellinger " Response PDU\n", 3076e48354ceSNicholas Bellinger cmd->se_cmd.scsi_sense_length); 3077e48354ceSNicholas Bellinger } 3078e48354ceSNicholas Bellinger 3079e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 3080e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 3081e48354ceSNicholas Bellinger 3082e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3083e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 3084e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 3085e48354ceSNicholas Bellinger 3086e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 3087e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3088e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest for Response" 3089e48354ceSNicholas Bellinger " PDU 0x%08x\n", *header_digest); 3090e48354ceSNicholas Bellinger } 3091e48354ceSNicholas Bellinger 3092e48354ceSNicholas Bellinger cmd->iov_misc_count = iov_count; 3093e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 3094e48354ceSNicholas Bellinger 3095e48354ceSNicholas Bellinger pr_debug("Built %sSCSI Response, ITT: 0x%08x, StatSN: 0x%08x," 3096e48354ceSNicholas Bellinger " Response: 0x%02x, SAM Status: 0x%02x, CID: %hu\n", 3097e48354ceSNicholas Bellinger (!recovery) ? "" : "Recovery ", cmd->init_task_tag, 3098e48354ceSNicholas Bellinger cmd->stat_sn, 0x00, cmd->se_cmd.scsi_status, conn->cid); 3099e48354ceSNicholas Bellinger 3100e48354ceSNicholas Bellinger return 0; 3101e48354ceSNicholas Bellinger } 3102e48354ceSNicholas Bellinger 3103e48354ceSNicholas Bellinger static u8 iscsit_convert_tcm_tmr_rsp(struct se_tmr_req *se_tmr) 3104e48354ceSNicholas Bellinger { 3105e48354ceSNicholas Bellinger switch (se_tmr->response) { 3106e48354ceSNicholas Bellinger case TMR_FUNCTION_COMPLETE: 3107e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_COMPLETE; 3108e48354ceSNicholas Bellinger case TMR_TASK_DOES_NOT_EXIST: 3109e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_NO_TASK; 3110e48354ceSNicholas Bellinger case TMR_LUN_DOES_NOT_EXIST: 3111e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_NO_LUN; 3112e48354ceSNicholas Bellinger case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 3113e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_NOT_SUPPORTED; 3114e48354ceSNicholas Bellinger case TMR_FUNCTION_AUTHORIZATION_FAILED: 3115e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_AUTH_FAILED; 3116e48354ceSNicholas Bellinger case TMR_FUNCTION_REJECTED: 3117e48354ceSNicholas Bellinger default: 3118e48354ceSNicholas Bellinger return ISCSI_TMF_RSP_REJECTED; 3119e48354ceSNicholas Bellinger } 3120e48354ceSNicholas Bellinger } 3121e48354ceSNicholas Bellinger 3122e48354ceSNicholas Bellinger static int iscsit_send_task_mgt_rsp( 3123e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 3124e48354ceSNicholas Bellinger struct iscsi_conn *conn) 3125e48354ceSNicholas Bellinger { 3126e48354ceSNicholas Bellinger struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req; 3127e48354ceSNicholas Bellinger struct iscsi_tm_rsp *hdr; 3128e48354ceSNicholas Bellinger u32 tx_size = 0; 3129e48354ceSNicholas Bellinger 3130e48354ceSNicholas Bellinger hdr = (struct iscsi_tm_rsp *) cmd->pdu; 3131e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 3132e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_SCSI_TMFUNC_RSP; 31337ae0b103SNicholas Bellinger hdr->flags = ISCSI_FLAG_CMD_FINAL; 3134e48354ceSNicholas Bellinger hdr->response = iscsit_convert_tcm_tmr_rsp(se_tmr); 3135e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 3136e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 3137e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 3138e48354ceSNicholas Bellinger 3139e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 3140e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3141e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3142e48354ceSNicholas Bellinger 3143e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_base = cmd->pdu; 3144e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len = ISCSI_HDR_LEN; 3145e48354ceSNicholas Bellinger tx_size += ISCSI_HDR_LEN; 3146e48354ceSNicholas Bellinger 3147e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 3148e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 3149e48354ceSNicholas Bellinger 3150e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3151e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 3152e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 3153e48354ceSNicholas Bellinger 3154e48354ceSNicholas Bellinger cmd->iov_misc[0].iov_len += ISCSI_CRC_LEN; 3155e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3156e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest for Task" 3157e48354ceSNicholas Bellinger " Mgmt Response PDU 0x%08x\n", *header_digest); 3158e48354ceSNicholas Bellinger } 3159e48354ceSNicholas Bellinger 3160e48354ceSNicholas Bellinger cmd->iov_misc_count = 1; 3161e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 3162e48354ceSNicholas Bellinger 3163e48354ceSNicholas Bellinger pr_debug("Built Task Management Response ITT: 0x%08x," 3164e48354ceSNicholas Bellinger " StatSN: 0x%08x, Response: 0x%02x, CID: %hu\n", 3165e48354ceSNicholas Bellinger cmd->init_task_tag, cmd->stat_sn, hdr->response, conn->cid); 3166e48354ceSNicholas Bellinger 3167e48354ceSNicholas Bellinger return 0; 3168e48354ceSNicholas Bellinger } 3169e48354ceSNicholas Bellinger 3170e48354ceSNicholas Bellinger static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd) 3171e48354ceSNicholas Bellinger { 3172e48354ceSNicholas Bellinger char *payload = NULL; 3173e48354ceSNicholas Bellinger struct iscsi_conn *conn = cmd->conn; 3174e48354ceSNicholas Bellinger struct iscsi_portal_group *tpg; 3175e48354ceSNicholas Bellinger struct iscsi_tiqn *tiqn; 3176e48354ceSNicholas Bellinger struct iscsi_tpg_np *tpg_np; 3177e48354ceSNicholas Bellinger int buffer_len, end_of_buf = 0, len = 0, payload_len = 0; 3178e48354ceSNicholas Bellinger unsigned char buf[256]; 3179e48354ceSNicholas Bellinger 3180e48354ceSNicholas Bellinger buffer_len = (conn->conn_ops->MaxRecvDataSegmentLength > 32768) ? 3181e48354ceSNicholas Bellinger 32768 : conn->conn_ops->MaxRecvDataSegmentLength; 3182e48354ceSNicholas Bellinger 3183e48354ceSNicholas Bellinger memset(buf, 0, 256); 3184e48354ceSNicholas Bellinger 3185e48354ceSNicholas Bellinger payload = kzalloc(buffer_len, GFP_KERNEL); 3186e48354ceSNicholas Bellinger if (!payload) { 3187e48354ceSNicholas Bellinger pr_err("Unable to allocate memory for sendtargets" 3188e48354ceSNicholas Bellinger " response.\n"); 3189e48354ceSNicholas Bellinger return -ENOMEM; 3190e48354ceSNicholas Bellinger } 3191e48354ceSNicholas Bellinger 3192e48354ceSNicholas Bellinger spin_lock(&tiqn_lock); 3193e48354ceSNicholas Bellinger list_for_each_entry(tiqn, &g_tiqn_list, tiqn_list) { 3194e48354ceSNicholas Bellinger len = sprintf(buf, "TargetName=%s", tiqn->tiqn); 3195e48354ceSNicholas Bellinger len += 1; 3196e48354ceSNicholas Bellinger 3197e48354ceSNicholas Bellinger if ((len + payload_len) > buffer_len) { 3198e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_tpg_lock); 3199e48354ceSNicholas Bellinger end_of_buf = 1; 3200e48354ceSNicholas Bellinger goto eob; 3201e48354ceSNicholas Bellinger } 3202e48354ceSNicholas Bellinger memcpy((void *)payload + payload_len, buf, len); 3203e48354ceSNicholas Bellinger payload_len += len; 3204e48354ceSNicholas Bellinger 3205e48354ceSNicholas Bellinger spin_lock(&tiqn->tiqn_tpg_lock); 3206e48354ceSNicholas Bellinger list_for_each_entry(tpg, &tiqn->tiqn_tpg_list, tpg_list) { 3207e48354ceSNicholas Bellinger 3208e48354ceSNicholas Bellinger spin_lock(&tpg->tpg_state_lock); 3209e48354ceSNicholas Bellinger if ((tpg->tpg_state == TPG_STATE_FREE) || 3210e48354ceSNicholas Bellinger (tpg->tpg_state == TPG_STATE_INACTIVE)) { 3211e48354ceSNicholas Bellinger spin_unlock(&tpg->tpg_state_lock); 3212e48354ceSNicholas Bellinger continue; 3213e48354ceSNicholas Bellinger } 3214e48354ceSNicholas Bellinger spin_unlock(&tpg->tpg_state_lock); 3215e48354ceSNicholas Bellinger 3216e48354ceSNicholas Bellinger spin_lock(&tpg->tpg_np_lock); 3217e48354ceSNicholas Bellinger list_for_each_entry(tpg_np, &tpg->tpg_gnp_list, 3218e48354ceSNicholas Bellinger tpg_np_list) { 3219e48354ceSNicholas Bellinger len = sprintf(buf, "TargetAddress=" 3220e48354ceSNicholas Bellinger "%s%s%s:%hu,%hu", 3221e48354ceSNicholas Bellinger (tpg_np->tpg_np->np_sockaddr.ss_family == AF_INET6) ? 3222e48354ceSNicholas Bellinger "[" : "", tpg_np->tpg_np->np_ip, 3223e48354ceSNicholas Bellinger (tpg_np->tpg_np->np_sockaddr.ss_family == AF_INET6) ? 3224e48354ceSNicholas Bellinger "]" : "", tpg_np->tpg_np->np_port, 3225e48354ceSNicholas Bellinger tpg->tpgt); 3226e48354ceSNicholas Bellinger len += 1; 3227e48354ceSNicholas Bellinger 3228e48354ceSNicholas Bellinger if ((len + payload_len) > buffer_len) { 3229e48354ceSNicholas Bellinger spin_unlock(&tpg->tpg_np_lock); 3230e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_tpg_lock); 3231e48354ceSNicholas Bellinger end_of_buf = 1; 3232e48354ceSNicholas Bellinger goto eob; 3233e48354ceSNicholas Bellinger } 3234e48354ceSNicholas Bellinger memcpy((void *)payload + payload_len, buf, len); 3235e48354ceSNicholas Bellinger payload_len += len; 3236e48354ceSNicholas Bellinger } 3237e48354ceSNicholas Bellinger spin_unlock(&tpg->tpg_np_lock); 3238e48354ceSNicholas Bellinger } 3239e48354ceSNicholas Bellinger spin_unlock(&tiqn->tiqn_tpg_lock); 3240e48354ceSNicholas Bellinger eob: 3241e48354ceSNicholas Bellinger if (end_of_buf) 3242e48354ceSNicholas Bellinger break; 3243e48354ceSNicholas Bellinger } 3244e48354ceSNicholas Bellinger spin_unlock(&tiqn_lock); 3245e48354ceSNicholas Bellinger 3246e48354ceSNicholas Bellinger cmd->buf_ptr = payload; 3247e48354ceSNicholas Bellinger 3248e48354ceSNicholas Bellinger return payload_len; 3249e48354ceSNicholas Bellinger } 3250e48354ceSNicholas Bellinger 3251e48354ceSNicholas Bellinger /* 3252e48354ceSNicholas Bellinger * FIXME: Add support for F_BIT and C_BIT when the length is longer than 3253e48354ceSNicholas Bellinger * MaxRecvDataSegmentLength. 3254e48354ceSNicholas Bellinger */ 3255e48354ceSNicholas Bellinger static int iscsit_send_text_rsp( 3256e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 3257e48354ceSNicholas Bellinger struct iscsi_conn *conn) 3258e48354ceSNicholas Bellinger { 3259e48354ceSNicholas Bellinger struct iscsi_text_rsp *hdr; 3260e48354ceSNicholas Bellinger struct kvec *iov; 3261e48354ceSNicholas Bellinger u32 padding = 0, tx_size = 0; 3262e48354ceSNicholas Bellinger int text_length, iov_count = 0; 3263e48354ceSNicholas Bellinger 3264e48354ceSNicholas Bellinger text_length = iscsit_build_sendtargets_response(cmd); 3265e48354ceSNicholas Bellinger if (text_length < 0) 3266e48354ceSNicholas Bellinger return text_length; 3267e48354ceSNicholas Bellinger 3268e48354ceSNicholas Bellinger padding = ((-text_length) & 3); 3269e48354ceSNicholas Bellinger if (padding != 0) { 3270e48354ceSNicholas Bellinger memset(cmd->buf_ptr + text_length, 0, padding); 3271e48354ceSNicholas Bellinger pr_debug("Attaching %u additional bytes for" 3272e48354ceSNicholas Bellinger " padding.\n", padding); 3273e48354ceSNicholas Bellinger } 3274e48354ceSNicholas Bellinger 3275e48354ceSNicholas Bellinger hdr = (struct iscsi_text_rsp *) cmd->pdu; 3276e48354ceSNicholas Bellinger memset(hdr, 0, ISCSI_HDR_LEN); 3277e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_TEXT_RSP; 3278e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3279e48354ceSNicholas Bellinger hton24(hdr->dlength, text_length); 3280e48354ceSNicholas Bellinger hdr->itt = cpu_to_be32(cmd->init_task_tag); 3281e48354ceSNicholas Bellinger hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); 3282e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 3283e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 3284e48354ceSNicholas Bellinger 3285e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, conn->sess); 3286e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3287e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3288e48354ceSNicholas Bellinger 3289e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 3290e48354ceSNicholas Bellinger 3291e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pdu; 3292e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_HDR_LEN; 3293e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->buf_ptr; 3294e48354ceSNicholas Bellinger iov[iov_count++].iov_len = text_length + padding; 3295e48354ceSNicholas Bellinger 3296e48354ceSNicholas Bellinger tx_size += (ISCSI_HDR_LEN + text_length + padding); 3297e48354ceSNicholas Bellinger 3298e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 3299e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 3300e48354ceSNicholas Bellinger 3301e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3302e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 3303e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 3304e48354ceSNicholas Bellinger 3305e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 3306e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3307e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest for" 3308e48354ceSNicholas Bellinger " Text Response PDU 0x%08x\n", *header_digest); 3309e48354ceSNicholas Bellinger } 3310e48354ceSNicholas Bellinger 3311e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 3312e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3313e48354ceSNicholas Bellinger cmd->buf_ptr, (text_length + padding), 3314e48354ceSNicholas Bellinger 0, NULL, (u8 *)&cmd->data_crc); 3315e48354ceSNicholas Bellinger 3316e48354ceSNicholas Bellinger iov[iov_count].iov_base = &cmd->data_crc; 3317e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 3318e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3319e48354ceSNicholas Bellinger 3320e48354ceSNicholas Bellinger pr_debug("Attaching DataDigest for %u bytes of text" 3321e48354ceSNicholas Bellinger " data, CRC 0x%08x\n", (text_length + padding), 3322e48354ceSNicholas Bellinger cmd->data_crc); 3323e48354ceSNicholas Bellinger } 3324e48354ceSNicholas Bellinger 3325e48354ceSNicholas Bellinger cmd->iov_misc_count = iov_count; 3326e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 3327e48354ceSNicholas Bellinger 3328e48354ceSNicholas Bellinger pr_debug("Built Text Response: ITT: 0x%08x, StatSN: 0x%08x," 3329e48354ceSNicholas Bellinger " Length: %u, CID: %hu\n", cmd->init_task_tag, cmd->stat_sn, 3330e48354ceSNicholas Bellinger text_length, conn->cid); 3331e48354ceSNicholas Bellinger return 0; 3332e48354ceSNicholas Bellinger } 3333e48354ceSNicholas Bellinger 3334e48354ceSNicholas Bellinger static int iscsit_send_reject( 3335e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 3336e48354ceSNicholas Bellinger struct iscsi_conn *conn) 3337e48354ceSNicholas Bellinger { 3338e48354ceSNicholas Bellinger u32 iov_count = 0, tx_size = 0; 3339e48354ceSNicholas Bellinger struct iscsi_reject *hdr; 3340e48354ceSNicholas Bellinger struct kvec *iov; 3341e48354ceSNicholas Bellinger 3342e48354ceSNicholas Bellinger hdr = (struct iscsi_reject *) cmd->pdu; 3343e48354ceSNicholas Bellinger hdr->opcode = ISCSI_OP_REJECT; 3344e48354ceSNicholas Bellinger hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3345e48354ceSNicholas Bellinger hton24(hdr->dlength, ISCSI_HDR_LEN); 3346e48354ceSNicholas Bellinger cmd->stat_sn = conn->stat_sn++; 3347e48354ceSNicholas Bellinger hdr->statsn = cpu_to_be32(cmd->stat_sn); 3348e48354ceSNicholas Bellinger hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3349e48354ceSNicholas Bellinger hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3350e48354ceSNicholas Bellinger 3351e48354ceSNicholas Bellinger iov = &cmd->iov_misc[0]; 3352e48354ceSNicholas Bellinger 3353e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->pdu; 3354e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_HDR_LEN; 3355e48354ceSNicholas Bellinger iov[iov_count].iov_base = cmd->buf_ptr; 3356e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_HDR_LEN; 3357e48354ceSNicholas Bellinger 3358e48354ceSNicholas Bellinger tx_size = (ISCSI_HDR_LEN + ISCSI_HDR_LEN); 3359e48354ceSNicholas Bellinger 3360e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 3361e48354ceSNicholas Bellinger u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 3362e48354ceSNicholas Bellinger 3363e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3364e48354ceSNicholas Bellinger (unsigned char *)hdr, ISCSI_HDR_LEN, 3365e48354ceSNicholas Bellinger 0, NULL, (u8 *)header_digest); 3366e48354ceSNicholas Bellinger 3367e48354ceSNicholas Bellinger iov[0].iov_len += ISCSI_CRC_LEN; 3368e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3369e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 HeaderDigest for" 3370e48354ceSNicholas Bellinger " REJECT PDU 0x%08x\n", *header_digest); 3371e48354ceSNicholas Bellinger } 3372e48354ceSNicholas Bellinger 3373e48354ceSNicholas Bellinger if (conn->conn_ops->DataDigest) { 3374e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3375e48354ceSNicholas Bellinger (unsigned char *)cmd->buf_ptr, ISCSI_HDR_LEN, 3376e48354ceSNicholas Bellinger 0, NULL, (u8 *)&cmd->data_crc); 3377e48354ceSNicholas Bellinger 3378e48354ceSNicholas Bellinger iov[iov_count].iov_base = &cmd->data_crc; 3379e48354ceSNicholas Bellinger iov[iov_count++].iov_len = ISCSI_CRC_LEN; 3380e48354ceSNicholas Bellinger tx_size += ISCSI_CRC_LEN; 3381e48354ceSNicholas Bellinger pr_debug("Attaching CRC32 DataDigest for REJECT" 3382e48354ceSNicholas Bellinger " PDU 0x%08x\n", cmd->data_crc); 3383e48354ceSNicholas Bellinger } 3384e48354ceSNicholas Bellinger 3385e48354ceSNicholas Bellinger cmd->iov_misc_count = iov_count; 3386e48354ceSNicholas Bellinger cmd->tx_size = tx_size; 3387e48354ceSNicholas Bellinger 3388e48354ceSNicholas Bellinger pr_debug("Built Reject PDU StatSN: 0x%08x, Reason: 0x%02x," 3389e48354ceSNicholas Bellinger " CID: %hu\n", ntohl(hdr->statsn), hdr->reason, conn->cid); 3390e48354ceSNicholas Bellinger 3391e48354ceSNicholas Bellinger return 0; 3392e48354ceSNicholas Bellinger } 3393e48354ceSNicholas Bellinger 3394e48354ceSNicholas Bellinger static void iscsit_tx_thread_wait_for_tcp(struct iscsi_conn *conn) 3395e48354ceSNicholas Bellinger { 3396e48354ceSNicholas Bellinger if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) || 3397e48354ceSNicholas Bellinger (conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) { 3398e48354ceSNicholas Bellinger wait_for_completion_interruptible_timeout( 3399e48354ceSNicholas Bellinger &conn->tx_half_close_comp, 3400e48354ceSNicholas Bellinger ISCSI_TX_THREAD_TCP_TIMEOUT * HZ); 3401e48354ceSNicholas Bellinger } 3402e48354ceSNicholas Bellinger } 3403e48354ceSNicholas Bellinger 3404e48354ceSNicholas Bellinger #ifdef CONFIG_SMP 3405e48354ceSNicholas Bellinger 3406e48354ceSNicholas Bellinger void iscsit_thread_get_cpumask(struct iscsi_conn *conn) 3407e48354ceSNicholas Bellinger { 3408e48354ceSNicholas Bellinger struct iscsi_thread_set *ts = conn->thread_set; 3409e48354ceSNicholas Bellinger int ord, cpu; 3410e48354ceSNicholas Bellinger /* 3411e48354ceSNicholas Bellinger * thread_id is assigned from iscsit_global->ts_bitmap from 3412e48354ceSNicholas Bellinger * within iscsi_thread_set.c:iscsi_allocate_thread_sets() 3413e48354ceSNicholas Bellinger * 3414e48354ceSNicholas Bellinger * Here we use thread_id to determine which CPU that this 3415e48354ceSNicholas Bellinger * iSCSI connection's iscsi_thread_set will be scheduled to 3416e48354ceSNicholas Bellinger * execute upon. 3417e48354ceSNicholas Bellinger */ 3418e48354ceSNicholas Bellinger ord = ts->thread_id % cpumask_weight(cpu_online_mask); 3419e48354ceSNicholas Bellinger #if 0 3420e48354ceSNicholas Bellinger pr_debug(">>>>>>>>>>>>>>>>>>>> Generated ord: %d from" 3421e48354ceSNicholas Bellinger " thread_id: %d\n", ord, ts->thread_id); 3422e48354ceSNicholas Bellinger #endif 3423e48354ceSNicholas Bellinger for_each_online_cpu(cpu) { 3424e48354ceSNicholas Bellinger if (ord-- == 0) { 3425e48354ceSNicholas Bellinger cpumask_set_cpu(cpu, conn->conn_cpumask); 3426e48354ceSNicholas Bellinger return; 3427e48354ceSNicholas Bellinger } 3428e48354ceSNicholas Bellinger } 3429e48354ceSNicholas Bellinger /* 3430e48354ceSNicholas Bellinger * This should never be reached.. 3431e48354ceSNicholas Bellinger */ 3432e48354ceSNicholas Bellinger dump_stack(); 3433e48354ceSNicholas Bellinger cpumask_setall(conn->conn_cpumask); 3434e48354ceSNicholas Bellinger } 3435e48354ceSNicholas Bellinger 3436e48354ceSNicholas Bellinger static inline void iscsit_thread_check_cpumask( 3437e48354ceSNicholas Bellinger struct iscsi_conn *conn, 3438e48354ceSNicholas Bellinger struct task_struct *p, 3439e48354ceSNicholas Bellinger int mode) 3440e48354ceSNicholas Bellinger { 3441e48354ceSNicholas Bellinger char buf[128]; 3442e48354ceSNicholas Bellinger /* 3443e48354ceSNicholas Bellinger * mode == 1 signals iscsi_target_tx_thread() usage. 3444e48354ceSNicholas Bellinger * mode == 0 signals iscsi_target_rx_thread() usage. 3445e48354ceSNicholas Bellinger */ 3446e48354ceSNicholas Bellinger if (mode == 1) { 3447e48354ceSNicholas Bellinger if (!conn->conn_tx_reset_cpumask) 3448e48354ceSNicholas Bellinger return; 3449e48354ceSNicholas Bellinger conn->conn_tx_reset_cpumask = 0; 3450e48354ceSNicholas Bellinger } else { 3451e48354ceSNicholas Bellinger if (!conn->conn_rx_reset_cpumask) 3452e48354ceSNicholas Bellinger return; 3453e48354ceSNicholas Bellinger conn->conn_rx_reset_cpumask = 0; 3454e48354ceSNicholas Bellinger } 3455e48354ceSNicholas Bellinger /* 3456e48354ceSNicholas Bellinger * Update the CPU mask for this single kthread so that 3457e48354ceSNicholas Bellinger * both TX and RX kthreads are scheduled to run on the 3458e48354ceSNicholas Bellinger * same CPU. 3459e48354ceSNicholas Bellinger */ 3460e48354ceSNicholas Bellinger memset(buf, 0, 128); 3461e48354ceSNicholas Bellinger cpumask_scnprintf(buf, 128, conn->conn_cpumask); 3462e48354ceSNicholas Bellinger #if 0 3463e48354ceSNicholas Bellinger pr_debug(">>>>>>>>>>>>>> Calling set_cpus_allowed_ptr():" 3464e48354ceSNicholas Bellinger " %s for %s\n", buf, p->comm); 3465e48354ceSNicholas Bellinger #endif 3466e48354ceSNicholas Bellinger set_cpus_allowed_ptr(p, conn->conn_cpumask); 3467e48354ceSNicholas Bellinger } 3468e48354ceSNicholas Bellinger 3469e48354ceSNicholas Bellinger #else 3470aadcec01SNicholas Bellinger 3471aadcec01SNicholas Bellinger void iscsit_thread_get_cpumask(struct iscsi_conn *conn) 3472aadcec01SNicholas Bellinger { 3473aadcec01SNicholas Bellinger return; 3474aadcec01SNicholas Bellinger } 3475aadcec01SNicholas Bellinger 3476e48354ceSNicholas Bellinger #define iscsit_thread_check_cpumask(X, Y, Z) ({}) 3477e48354ceSNicholas Bellinger #endif /* CONFIG_SMP */ 3478e48354ceSNicholas Bellinger 3479e48354ceSNicholas Bellinger int iscsi_target_tx_thread(void *arg) 3480e48354ceSNicholas Bellinger { 3481e48354ceSNicholas Bellinger u8 state; 3482e48354ceSNicholas Bellinger int eodr = 0; 3483e48354ceSNicholas Bellinger int ret = 0; 3484e48354ceSNicholas Bellinger int sent_status = 0; 3485e48354ceSNicholas Bellinger int use_misc = 0; 3486e48354ceSNicholas Bellinger int map_sg = 0; 3487e48354ceSNicholas Bellinger struct iscsi_cmd *cmd = NULL; 3488e48354ceSNicholas Bellinger struct iscsi_conn *conn; 3489e48354ceSNicholas Bellinger struct iscsi_queue_req *qr = NULL; 3490e48354ceSNicholas Bellinger struct se_cmd *se_cmd; 3491e48354ceSNicholas Bellinger struct iscsi_thread_set *ts = (struct iscsi_thread_set *)arg; 3492e48354ceSNicholas Bellinger /* 3493e48354ceSNicholas Bellinger * Allow ourselves to be interrupted by SIGINT so that a 3494e48354ceSNicholas Bellinger * connection recovery / failure event can be triggered externally. 3495e48354ceSNicholas Bellinger */ 3496e48354ceSNicholas Bellinger allow_signal(SIGINT); 3497e48354ceSNicholas Bellinger 3498e48354ceSNicholas Bellinger restart: 3499e48354ceSNicholas Bellinger conn = iscsi_tx_thread_pre_handler(ts); 3500e48354ceSNicholas Bellinger if (!conn) 3501e48354ceSNicholas Bellinger goto out; 3502e48354ceSNicholas Bellinger 3503e48354ceSNicholas Bellinger eodr = map_sg = ret = sent_status = use_misc = 0; 3504e48354ceSNicholas Bellinger 3505e48354ceSNicholas Bellinger while (!kthread_should_stop()) { 3506e48354ceSNicholas Bellinger /* 3507e48354ceSNicholas Bellinger * Ensure that both TX and RX per connection kthreads 3508e48354ceSNicholas Bellinger * are scheduled to run on the same CPU. 3509e48354ceSNicholas Bellinger */ 3510e48354ceSNicholas Bellinger iscsit_thread_check_cpumask(conn, current, 1); 3511e48354ceSNicholas Bellinger 3512e48354ceSNicholas Bellinger schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT); 3513e48354ceSNicholas Bellinger 3514e48354ceSNicholas Bellinger if ((ts->status == ISCSI_THREAD_SET_RESET) || 3515e48354ceSNicholas Bellinger signal_pending(current)) 3516e48354ceSNicholas Bellinger goto transport_err; 3517e48354ceSNicholas Bellinger 3518e48354ceSNicholas Bellinger get_immediate: 3519e48354ceSNicholas Bellinger qr = iscsit_get_cmd_from_immediate_queue(conn); 3520e48354ceSNicholas Bellinger if (qr) { 3521e48354ceSNicholas Bellinger atomic_set(&conn->check_immediate_queue, 0); 3522e48354ceSNicholas Bellinger cmd = qr->cmd; 3523e48354ceSNicholas Bellinger state = qr->state; 3524e48354ceSNicholas Bellinger kmem_cache_free(lio_qr_cache, qr); 3525e48354ceSNicholas Bellinger 3526e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 3527e48354ceSNicholas Bellinger switch (state) { 3528e48354ceSNicholas Bellinger case ISTATE_SEND_R2T: 3529e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3530e48354ceSNicholas Bellinger ret = iscsit_send_r2t(cmd, conn); 3531e48354ceSNicholas Bellinger break; 3532e48354ceSNicholas Bellinger case ISTATE_REMOVE: 3533e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3534e48354ceSNicholas Bellinger 3535e48354ceSNicholas Bellinger if (cmd->data_direction == DMA_TO_DEVICE) 3536e48354ceSNicholas Bellinger iscsit_stop_dataout_timer(cmd); 3537e48354ceSNicholas Bellinger 3538e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 3539e48354ceSNicholas Bellinger list_del(&cmd->i_list); 3540e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 3541d270190aSNicholas Bellinger 3542d270190aSNicholas Bellinger iscsit_free_cmd(cmd); 3543e48354ceSNicholas Bellinger goto get_immediate; 3544e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN_WANT_RESPONSE: 3545e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3546e48354ceSNicholas Bellinger iscsit_mod_nopin_response_timer(conn); 3547e48354ceSNicholas Bellinger ret = iscsit_send_unsolicited_nopin(cmd, 3548e48354ceSNicholas Bellinger conn, 1); 3549e48354ceSNicholas Bellinger break; 3550e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN_NO_RESPONSE: 3551e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3552e48354ceSNicholas Bellinger ret = iscsit_send_unsolicited_nopin(cmd, 3553e48354ceSNicholas Bellinger conn, 0); 3554e48354ceSNicholas Bellinger break; 3555e48354ceSNicholas Bellinger default: 3556e48354ceSNicholas Bellinger pr_err("Unknown Opcode: 0x%02x ITT:" 3557e48354ceSNicholas Bellinger " 0x%08x, i_state: %d on CID: %hu\n", 3558e48354ceSNicholas Bellinger cmd->iscsi_opcode, cmd->init_task_tag, state, 3559e48354ceSNicholas Bellinger conn->cid); 3560e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3561e48354ceSNicholas Bellinger goto transport_err; 3562e48354ceSNicholas Bellinger } 3563e48354ceSNicholas Bellinger if (ret < 0) { 3564e48354ceSNicholas Bellinger conn->tx_immediate_queue = 0; 3565e48354ceSNicholas Bellinger goto transport_err; 3566e48354ceSNicholas Bellinger } 3567e48354ceSNicholas Bellinger 3568e48354ceSNicholas Bellinger if (iscsit_send_tx_data(cmd, conn, 1) < 0) { 3569e48354ceSNicholas Bellinger conn->tx_immediate_queue = 0; 3570e48354ceSNicholas Bellinger iscsit_tx_thread_wait_for_tcp(conn); 3571e48354ceSNicholas Bellinger goto transport_err; 3572e48354ceSNicholas Bellinger } 3573e48354ceSNicholas Bellinger 3574e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 3575e48354ceSNicholas Bellinger switch (state) { 3576e48354ceSNicholas Bellinger case ISTATE_SEND_R2T: 3577e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3578e48354ceSNicholas Bellinger spin_lock_bh(&cmd->dataout_timeout_lock); 3579e48354ceSNicholas Bellinger iscsit_start_dataout_timer(cmd, conn); 3580e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->dataout_timeout_lock); 3581e48354ceSNicholas Bellinger break; 3582e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN_WANT_RESPONSE: 3583e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SENT_NOPIN_WANT_RESPONSE; 3584e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3585e48354ceSNicholas Bellinger break; 3586e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN_NO_RESPONSE: 3587e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SENT_STATUS; 3588e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3589e48354ceSNicholas Bellinger break; 3590e48354ceSNicholas Bellinger default: 3591e48354ceSNicholas Bellinger pr_err("Unknown Opcode: 0x%02x ITT:" 3592e48354ceSNicholas Bellinger " 0x%08x, i_state: %d on CID: %hu\n", 3593e48354ceSNicholas Bellinger cmd->iscsi_opcode, cmd->init_task_tag, 3594e48354ceSNicholas Bellinger state, conn->cid); 3595e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3596e48354ceSNicholas Bellinger goto transport_err; 3597e48354ceSNicholas Bellinger } 3598e48354ceSNicholas Bellinger goto get_immediate; 3599e48354ceSNicholas Bellinger } else 3600e48354ceSNicholas Bellinger conn->tx_immediate_queue = 0; 3601e48354ceSNicholas Bellinger 3602e48354ceSNicholas Bellinger get_response: 3603e48354ceSNicholas Bellinger qr = iscsit_get_cmd_from_response_queue(conn); 3604e48354ceSNicholas Bellinger if (qr) { 3605e48354ceSNicholas Bellinger cmd = qr->cmd; 3606e48354ceSNicholas Bellinger state = qr->state; 3607e48354ceSNicholas Bellinger kmem_cache_free(lio_qr_cache, qr); 3608e48354ceSNicholas Bellinger 3609e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 3610e48354ceSNicholas Bellinger check_rsp_state: 3611e48354ceSNicholas Bellinger switch (state) { 3612e48354ceSNicholas Bellinger case ISTATE_SEND_DATAIN: 3613e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3614e48354ceSNicholas Bellinger ret = iscsit_send_data_in(cmd, conn, 3615e48354ceSNicholas Bellinger &eodr); 3616e48354ceSNicholas Bellinger map_sg = 1; 3617e48354ceSNicholas Bellinger break; 3618e48354ceSNicholas Bellinger case ISTATE_SEND_STATUS: 3619e48354ceSNicholas Bellinger case ISTATE_SEND_STATUS_RECOVERY: 3620e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3621e48354ceSNicholas Bellinger use_misc = 1; 3622e48354ceSNicholas Bellinger ret = iscsit_send_status(cmd, conn); 3623e48354ceSNicholas Bellinger break; 3624e48354ceSNicholas Bellinger case ISTATE_SEND_LOGOUTRSP: 3625e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3626e48354ceSNicholas Bellinger use_misc = 1; 3627e48354ceSNicholas Bellinger ret = iscsit_send_logout_response(cmd, conn); 3628e48354ceSNicholas Bellinger break; 3629e48354ceSNicholas Bellinger case ISTATE_SEND_ASYNCMSG: 3630e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3631e48354ceSNicholas Bellinger use_misc = 1; 3632e48354ceSNicholas Bellinger ret = iscsit_send_conn_drop_async_message( 3633e48354ceSNicholas Bellinger cmd, conn); 3634e48354ceSNicholas Bellinger break; 3635e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN: 3636e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3637e48354ceSNicholas Bellinger use_misc = 1; 3638e48354ceSNicholas Bellinger ret = iscsit_send_nopin_response(cmd, conn); 3639e48354ceSNicholas Bellinger break; 3640e48354ceSNicholas Bellinger case ISTATE_SEND_REJECT: 3641e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3642e48354ceSNicholas Bellinger use_misc = 1; 3643e48354ceSNicholas Bellinger ret = iscsit_send_reject(cmd, conn); 3644e48354ceSNicholas Bellinger break; 3645e48354ceSNicholas Bellinger case ISTATE_SEND_TASKMGTRSP: 3646e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3647e48354ceSNicholas Bellinger use_misc = 1; 3648e48354ceSNicholas Bellinger ret = iscsit_send_task_mgt_rsp(cmd, conn); 3649e48354ceSNicholas Bellinger if (ret != 0) 3650e48354ceSNicholas Bellinger break; 3651e48354ceSNicholas Bellinger ret = iscsit_tmr_post_handler(cmd, conn); 3652e48354ceSNicholas Bellinger if (ret != 0) 3653e48354ceSNicholas Bellinger iscsit_fall_back_to_erl0(conn->sess); 3654e48354ceSNicholas Bellinger break; 3655e48354ceSNicholas Bellinger case ISTATE_SEND_TEXTRSP: 3656e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3657e48354ceSNicholas Bellinger use_misc = 1; 3658e48354ceSNicholas Bellinger ret = iscsit_send_text_rsp(cmd, conn); 3659e48354ceSNicholas Bellinger break; 3660e48354ceSNicholas Bellinger default: 3661e48354ceSNicholas Bellinger pr_err("Unknown Opcode: 0x%02x ITT:" 3662e48354ceSNicholas Bellinger " 0x%08x, i_state: %d on CID: %hu\n", 3663e48354ceSNicholas Bellinger cmd->iscsi_opcode, cmd->init_task_tag, 3664e48354ceSNicholas Bellinger state, conn->cid); 3665e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3666e48354ceSNicholas Bellinger goto transport_err; 3667e48354ceSNicholas Bellinger } 3668e48354ceSNicholas Bellinger if (ret < 0) { 3669e48354ceSNicholas Bellinger conn->tx_response_queue = 0; 3670e48354ceSNicholas Bellinger goto transport_err; 3671e48354ceSNicholas Bellinger } 3672e48354ceSNicholas Bellinger 3673e48354ceSNicholas Bellinger se_cmd = &cmd->se_cmd; 3674e48354ceSNicholas Bellinger 3675e48354ceSNicholas Bellinger if (map_sg && !conn->conn_ops->IFMarker) { 3676e48354ceSNicholas Bellinger if (iscsit_fe_sendpage_sg(cmd, conn) < 0) { 3677e48354ceSNicholas Bellinger conn->tx_response_queue = 0; 3678e48354ceSNicholas Bellinger iscsit_tx_thread_wait_for_tcp(conn); 3679e48354ceSNicholas Bellinger iscsit_unmap_iovec(cmd); 3680e48354ceSNicholas Bellinger goto transport_err; 3681e48354ceSNicholas Bellinger } 3682e48354ceSNicholas Bellinger } else { 3683e48354ceSNicholas Bellinger if (iscsit_send_tx_data(cmd, conn, use_misc) < 0) { 3684e48354ceSNicholas Bellinger conn->tx_response_queue = 0; 3685e48354ceSNicholas Bellinger iscsit_tx_thread_wait_for_tcp(conn); 3686e48354ceSNicholas Bellinger iscsit_unmap_iovec(cmd); 3687e48354ceSNicholas Bellinger goto transport_err; 3688e48354ceSNicholas Bellinger } 3689e48354ceSNicholas Bellinger } 3690e48354ceSNicholas Bellinger map_sg = 0; 3691e48354ceSNicholas Bellinger iscsit_unmap_iovec(cmd); 3692e48354ceSNicholas Bellinger 3693e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 3694e48354ceSNicholas Bellinger switch (state) { 3695e48354ceSNicholas Bellinger case ISTATE_SEND_DATAIN: 3696e48354ceSNicholas Bellinger if (!eodr) 3697e48354ceSNicholas Bellinger goto check_rsp_state; 3698e48354ceSNicholas Bellinger 3699e48354ceSNicholas Bellinger if (eodr == 1) { 3700e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SENT_LAST_DATAIN; 3701e48354ceSNicholas Bellinger sent_status = 1; 3702e48354ceSNicholas Bellinger eodr = use_misc = 0; 3703e48354ceSNicholas Bellinger } else if (eodr == 2) { 3704e48354ceSNicholas Bellinger cmd->i_state = state = 3705e48354ceSNicholas Bellinger ISTATE_SEND_STATUS; 3706e48354ceSNicholas Bellinger sent_status = 0; 3707e48354ceSNicholas Bellinger eodr = use_misc = 0; 3708e48354ceSNicholas Bellinger goto check_rsp_state; 3709e48354ceSNicholas Bellinger } 3710e48354ceSNicholas Bellinger break; 3711e48354ceSNicholas Bellinger case ISTATE_SEND_STATUS: 3712e48354ceSNicholas Bellinger use_misc = 0; 3713e48354ceSNicholas Bellinger sent_status = 1; 3714e48354ceSNicholas Bellinger break; 3715e48354ceSNicholas Bellinger case ISTATE_SEND_ASYNCMSG: 3716e48354ceSNicholas Bellinger case ISTATE_SEND_NOPIN: 3717e48354ceSNicholas Bellinger case ISTATE_SEND_STATUS_RECOVERY: 3718e48354ceSNicholas Bellinger case ISTATE_SEND_TEXTRSP: 3719e48354ceSNicholas Bellinger use_misc = 0; 3720e48354ceSNicholas Bellinger sent_status = 1; 3721e48354ceSNicholas Bellinger break; 3722e48354ceSNicholas Bellinger case ISTATE_SEND_REJECT: 3723e48354ceSNicholas Bellinger use_misc = 0; 3724e48354ceSNicholas Bellinger if (cmd->cmd_flags & ICF_REJECT_FAIL_CONN) { 3725e48354ceSNicholas Bellinger cmd->cmd_flags &= ~ICF_REJECT_FAIL_CONN; 3726e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3727e48354ceSNicholas Bellinger complete(&cmd->reject_comp); 3728e48354ceSNicholas Bellinger goto transport_err; 3729e48354ceSNicholas Bellinger } 3730e48354ceSNicholas Bellinger complete(&cmd->reject_comp); 3731e48354ceSNicholas Bellinger break; 3732e48354ceSNicholas Bellinger case ISTATE_SEND_TASKMGTRSP: 3733e48354ceSNicholas Bellinger use_misc = 0; 3734e48354ceSNicholas Bellinger sent_status = 1; 3735e48354ceSNicholas Bellinger break; 3736e48354ceSNicholas Bellinger case ISTATE_SEND_LOGOUTRSP: 3737e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3738e48354ceSNicholas Bellinger if (!iscsit_logout_post_handler(cmd, conn)) 3739e48354ceSNicholas Bellinger goto restart; 3740e48354ceSNicholas Bellinger spin_lock_bh(&cmd->istate_lock); 3741e48354ceSNicholas Bellinger use_misc = 0; 3742e48354ceSNicholas Bellinger sent_status = 1; 3743e48354ceSNicholas Bellinger break; 3744e48354ceSNicholas Bellinger default: 3745e48354ceSNicholas Bellinger pr_err("Unknown Opcode: 0x%02x ITT:" 3746e48354ceSNicholas Bellinger " 0x%08x, i_state: %d on CID: %hu\n", 3747e48354ceSNicholas Bellinger cmd->iscsi_opcode, cmd->init_task_tag, 3748e48354ceSNicholas Bellinger cmd->i_state, conn->cid); 3749e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3750e48354ceSNicholas Bellinger goto transport_err; 3751e48354ceSNicholas Bellinger } 3752e48354ceSNicholas Bellinger 3753e48354ceSNicholas Bellinger if (sent_status) { 3754e48354ceSNicholas Bellinger cmd->i_state = ISTATE_SENT_STATUS; 3755e48354ceSNicholas Bellinger sent_status = 0; 3756e48354ceSNicholas Bellinger } 3757e48354ceSNicholas Bellinger spin_unlock_bh(&cmd->istate_lock); 3758e48354ceSNicholas Bellinger 3759e48354ceSNicholas Bellinger if (atomic_read(&conn->check_immediate_queue)) 3760e48354ceSNicholas Bellinger goto get_immediate; 3761e48354ceSNicholas Bellinger 3762e48354ceSNicholas Bellinger goto get_response; 3763e48354ceSNicholas Bellinger } else 3764e48354ceSNicholas Bellinger conn->tx_response_queue = 0; 3765e48354ceSNicholas Bellinger } 3766e48354ceSNicholas Bellinger 3767e48354ceSNicholas Bellinger transport_err: 3768e48354ceSNicholas Bellinger iscsit_take_action_for_connection_exit(conn); 3769e48354ceSNicholas Bellinger goto restart; 3770e48354ceSNicholas Bellinger out: 3771e48354ceSNicholas Bellinger return 0; 3772e48354ceSNicholas Bellinger } 3773e48354ceSNicholas Bellinger 3774e48354ceSNicholas Bellinger int iscsi_target_rx_thread(void *arg) 3775e48354ceSNicholas Bellinger { 3776e48354ceSNicholas Bellinger int ret; 3777e48354ceSNicholas Bellinger u8 buffer[ISCSI_HDR_LEN], opcode; 3778e48354ceSNicholas Bellinger u32 checksum = 0, digest = 0; 3779e48354ceSNicholas Bellinger struct iscsi_conn *conn = NULL; 3780e48354ceSNicholas Bellinger struct iscsi_thread_set *ts = (struct iscsi_thread_set *)arg; 3781e48354ceSNicholas Bellinger struct kvec iov; 3782e48354ceSNicholas Bellinger /* 3783e48354ceSNicholas Bellinger * Allow ourselves to be interrupted by SIGINT so that a 3784e48354ceSNicholas Bellinger * connection recovery / failure event can be triggered externally. 3785e48354ceSNicholas Bellinger */ 3786e48354ceSNicholas Bellinger allow_signal(SIGINT); 3787e48354ceSNicholas Bellinger 3788e48354ceSNicholas Bellinger restart: 3789e48354ceSNicholas Bellinger conn = iscsi_rx_thread_pre_handler(ts); 3790e48354ceSNicholas Bellinger if (!conn) 3791e48354ceSNicholas Bellinger goto out; 3792e48354ceSNicholas Bellinger 3793e48354ceSNicholas Bellinger while (!kthread_should_stop()) { 3794e48354ceSNicholas Bellinger /* 3795e48354ceSNicholas Bellinger * Ensure that both TX and RX per connection kthreads 3796e48354ceSNicholas Bellinger * are scheduled to run on the same CPU. 3797e48354ceSNicholas Bellinger */ 3798e48354ceSNicholas Bellinger iscsit_thread_check_cpumask(conn, current, 0); 3799e48354ceSNicholas Bellinger 3800e48354ceSNicholas Bellinger memset(buffer, 0, ISCSI_HDR_LEN); 3801e48354ceSNicholas Bellinger memset(&iov, 0, sizeof(struct kvec)); 3802e48354ceSNicholas Bellinger 3803e48354ceSNicholas Bellinger iov.iov_base = buffer; 3804e48354ceSNicholas Bellinger iov.iov_len = ISCSI_HDR_LEN; 3805e48354ceSNicholas Bellinger 3806e48354ceSNicholas Bellinger ret = rx_data(conn, &iov, 1, ISCSI_HDR_LEN); 3807e48354ceSNicholas Bellinger if (ret != ISCSI_HDR_LEN) { 3808e48354ceSNicholas Bellinger iscsit_rx_thread_wait_for_tcp(conn); 3809e48354ceSNicholas Bellinger goto transport_err; 3810e48354ceSNicholas Bellinger } 3811e48354ceSNicholas Bellinger 3812e48354ceSNicholas Bellinger /* 3813e48354ceSNicholas Bellinger * Set conn->bad_hdr for use with REJECT PDUs. 3814e48354ceSNicholas Bellinger */ 3815e48354ceSNicholas Bellinger memcpy(&conn->bad_hdr, &buffer, ISCSI_HDR_LEN); 3816e48354ceSNicholas Bellinger 3817e48354ceSNicholas Bellinger if (conn->conn_ops->HeaderDigest) { 3818e48354ceSNicholas Bellinger iov.iov_base = &digest; 3819e48354ceSNicholas Bellinger iov.iov_len = ISCSI_CRC_LEN; 3820e48354ceSNicholas Bellinger 3821e48354ceSNicholas Bellinger ret = rx_data(conn, &iov, 1, ISCSI_CRC_LEN); 3822e48354ceSNicholas Bellinger if (ret != ISCSI_CRC_LEN) { 3823e48354ceSNicholas Bellinger iscsit_rx_thread_wait_for_tcp(conn); 3824e48354ceSNicholas Bellinger goto transport_err; 3825e48354ceSNicholas Bellinger } 3826e48354ceSNicholas Bellinger 3827e48354ceSNicholas Bellinger iscsit_do_crypto_hash_buf(&conn->conn_rx_hash, 3828e48354ceSNicholas Bellinger buffer, ISCSI_HDR_LEN, 3829e48354ceSNicholas Bellinger 0, NULL, (u8 *)&checksum); 3830e48354ceSNicholas Bellinger 3831e48354ceSNicholas Bellinger if (digest != checksum) { 3832e48354ceSNicholas Bellinger pr_err("HeaderDigest CRC32C failed," 3833e48354ceSNicholas Bellinger " received 0x%08x, computed 0x%08x\n", 3834e48354ceSNicholas Bellinger digest, checksum); 3835e48354ceSNicholas Bellinger /* 3836e48354ceSNicholas Bellinger * Set the PDU to 0xff so it will intentionally 3837e48354ceSNicholas Bellinger * hit default in the switch below. 3838e48354ceSNicholas Bellinger */ 3839e48354ceSNicholas Bellinger memset(buffer, 0xff, ISCSI_HDR_LEN); 3840e48354ceSNicholas Bellinger spin_lock_bh(&conn->sess->session_stats_lock); 3841e48354ceSNicholas Bellinger conn->sess->conn_digest_errors++; 3842e48354ceSNicholas Bellinger spin_unlock_bh(&conn->sess->session_stats_lock); 3843e48354ceSNicholas Bellinger } else { 3844e48354ceSNicholas Bellinger pr_debug("Got HeaderDigest CRC32C" 3845e48354ceSNicholas Bellinger " 0x%08x\n", checksum); 3846e48354ceSNicholas Bellinger } 3847e48354ceSNicholas Bellinger } 3848e48354ceSNicholas Bellinger 3849e48354ceSNicholas Bellinger if (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT) 3850e48354ceSNicholas Bellinger goto transport_err; 3851e48354ceSNicholas Bellinger 3852e48354ceSNicholas Bellinger opcode = buffer[0] & ISCSI_OPCODE_MASK; 3853e48354ceSNicholas Bellinger 3854e48354ceSNicholas Bellinger if (conn->sess->sess_ops->SessionType && 3855e48354ceSNicholas Bellinger ((!(opcode & ISCSI_OP_TEXT)) || 3856e48354ceSNicholas Bellinger (!(opcode & ISCSI_OP_LOGOUT)))) { 3857e48354ceSNicholas Bellinger pr_err("Received illegal iSCSI Opcode: 0x%02x" 3858e48354ceSNicholas Bellinger " while in Discovery Session, rejecting.\n", opcode); 3859e48354ceSNicholas Bellinger iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 3860e48354ceSNicholas Bellinger buffer, conn); 3861e48354ceSNicholas Bellinger goto transport_err; 3862e48354ceSNicholas Bellinger } 3863e48354ceSNicholas Bellinger 3864e48354ceSNicholas Bellinger switch (opcode) { 3865e48354ceSNicholas Bellinger case ISCSI_OP_SCSI_CMD: 3866e48354ceSNicholas Bellinger if (iscsit_handle_scsi_cmd(conn, buffer) < 0) 3867e48354ceSNicholas Bellinger goto transport_err; 3868e48354ceSNicholas Bellinger break; 3869e48354ceSNicholas Bellinger case ISCSI_OP_SCSI_DATA_OUT: 3870e48354ceSNicholas Bellinger if (iscsit_handle_data_out(conn, buffer) < 0) 3871e48354ceSNicholas Bellinger goto transport_err; 3872e48354ceSNicholas Bellinger break; 3873e48354ceSNicholas Bellinger case ISCSI_OP_NOOP_OUT: 3874e48354ceSNicholas Bellinger if (iscsit_handle_nop_out(conn, buffer) < 0) 3875e48354ceSNicholas Bellinger goto transport_err; 3876e48354ceSNicholas Bellinger break; 3877e48354ceSNicholas Bellinger case ISCSI_OP_SCSI_TMFUNC: 3878e48354ceSNicholas Bellinger if (iscsit_handle_task_mgt_cmd(conn, buffer) < 0) 3879e48354ceSNicholas Bellinger goto transport_err; 3880e48354ceSNicholas Bellinger break; 3881e48354ceSNicholas Bellinger case ISCSI_OP_TEXT: 3882e48354ceSNicholas Bellinger if (iscsit_handle_text_cmd(conn, buffer) < 0) 3883e48354ceSNicholas Bellinger goto transport_err; 3884e48354ceSNicholas Bellinger break; 3885e48354ceSNicholas Bellinger case ISCSI_OP_LOGOUT: 3886e48354ceSNicholas Bellinger ret = iscsit_handle_logout_cmd(conn, buffer); 3887e48354ceSNicholas Bellinger if (ret > 0) { 3888e48354ceSNicholas Bellinger wait_for_completion_timeout(&conn->conn_logout_comp, 3889e48354ceSNicholas Bellinger SECONDS_FOR_LOGOUT_COMP * HZ); 3890e48354ceSNicholas Bellinger goto transport_err; 3891e48354ceSNicholas Bellinger } else if (ret < 0) 3892e48354ceSNicholas Bellinger goto transport_err; 3893e48354ceSNicholas Bellinger break; 3894e48354ceSNicholas Bellinger case ISCSI_OP_SNACK: 3895e48354ceSNicholas Bellinger if (iscsit_handle_snack(conn, buffer) < 0) 3896e48354ceSNicholas Bellinger goto transport_err; 3897e48354ceSNicholas Bellinger break; 3898e48354ceSNicholas Bellinger default: 3899e48354ceSNicholas Bellinger pr_err("Got unknown iSCSI OpCode: 0x%02x\n", 3900e48354ceSNicholas Bellinger opcode); 3901e48354ceSNicholas Bellinger if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 3902e48354ceSNicholas Bellinger pr_err("Cannot recover from unknown" 3903e48354ceSNicholas Bellinger " opcode while ERL=0, closing iSCSI connection" 3904e48354ceSNicholas Bellinger ".\n"); 3905e48354ceSNicholas Bellinger goto transport_err; 3906e48354ceSNicholas Bellinger } 3907e48354ceSNicholas Bellinger if (!conn->conn_ops->OFMarker) { 3908e48354ceSNicholas Bellinger pr_err("Unable to recover from unknown" 3909e48354ceSNicholas Bellinger " opcode while OFMarker=No, closing iSCSI" 3910e48354ceSNicholas Bellinger " connection.\n"); 3911e48354ceSNicholas Bellinger goto transport_err; 3912e48354ceSNicholas Bellinger } 3913e48354ceSNicholas Bellinger if (iscsit_recover_from_unknown_opcode(conn) < 0) { 3914e48354ceSNicholas Bellinger pr_err("Unable to recover from unknown" 3915e48354ceSNicholas Bellinger " opcode, closing iSCSI connection.\n"); 3916e48354ceSNicholas Bellinger goto transport_err; 3917e48354ceSNicholas Bellinger } 3918e48354ceSNicholas Bellinger break; 3919e48354ceSNicholas Bellinger } 3920e48354ceSNicholas Bellinger } 3921e48354ceSNicholas Bellinger 3922e48354ceSNicholas Bellinger transport_err: 3923e48354ceSNicholas Bellinger if (!signal_pending(current)) 3924e48354ceSNicholas Bellinger atomic_set(&conn->transport_failed, 1); 3925e48354ceSNicholas Bellinger iscsit_take_action_for_connection_exit(conn); 3926e48354ceSNicholas Bellinger goto restart; 3927e48354ceSNicholas Bellinger out: 3928e48354ceSNicholas Bellinger return 0; 3929e48354ceSNicholas Bellinger } 3930e48354ceSNicholas Bellinger 3931e48354ceSNicholas Bellinger static void iscsit_release_commands_from_conn(struct iscsi_conn *conn) 3932e48354ceSNicholas Bellinger { 3933e48354ceSNicholas Bellinger struct iscsi_cmd *cmd = NULL, *cmd_tmp = NULL; 3934e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 3935e48354ceSNicholas Bellinger /* 3936e48354ceSNicholas Bellinger * We expect this function to only ever be called from either RX or TX 3937e48354ceSNicholas Bellinger * thread context via iscsit_close_connection() once the other context 3938e48354ceSNicholas Bellinger * has been reset -> returned sleeping pre-handler state. 3939e48354ceSNicholas Bellinger */ 3940e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 3941e48354ceSNicholas Bellinger list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) { 3942e48354ceSNicholas Bellinger 3943e48354ceSNicholas Bellinger list_del(&cmd->i_list); 3944e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 3945e48354ceSNicholas Bellinger 3946e48354ceSNicholas Bellinger iscsit_increment_maxcmdsn(cmd, sess); 3947e48354ceSNicholas Bellinger 3948d270190aSNicholas Bellinger iscsit_free_cmd(cmd); 3949e48354ceSNicholas Bellinger 3950e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 3951e48354ceSNicholas Bellinger } 3952e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 3953e48354ceSNicholas Bellinger } 3954e48354ceSNicholas Bellinger 3955e48354ceSNicholas Bellinger static void iscsit_stop_timers_for_cmds( 3956e48354ceSNicholas Bellinger struct iscsi_conn *conn) 3957e48354ceSNicholas Bellinger { 3958e48354ceSNicholas Bellinger struct iscsi_cmd *cmd; 3959e48354ceSNicholas Bellinger 3960e48354ceSNicholas Bellinger spin_lock_bh(&conn->cmd_lock); 3961e48354ceSNicholas Bellinger list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 3962e48354ceSNicholas Bellinger if (cmd->data_direction == DMA_TO_DEVICE) 3963e48354ceSNicholas Bellinger iscsit_stop_dataout_timer(cmd); 3964e48354ceSNicholas Bellinger } 3965e48354ceSNicholas Bellinger spin_unlock_bh(&conn->cmd_lock); 3966e48354ceSNicholas Bellinger } 3967e48354ceSNicholas Bellinger 3968e48354ceSNicholas Bellinger int iscsit_close_connection( 3969e48354ceSNicholas Bellinger struct iscsi_conn *conn) 3970e48354ceSNicholas Bellinger { 3971e48354ceSNicholas Bellinger int conn_logout = (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT); 3972e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 3973e48354ceSNicholas Bellinger 3974e48354ceSNicholas Bellinger pr_debug("Closing iSCSI connection CID %hu on SID:" 3975e48354ceSNicholas Bellinger " %u\n", conn->cid, sess->sid); 3976e48354ceSNicholas Bellinger /* 3977e48354ceSNicholas Bellinger * Always up conn_logout_comp just in case the RX Thread is sleeping 3978e48354ceSNicholas Bellinger * and the logout response never got sent because the connection 3979e48354ceSNicholas Bellinger * failed. 3980e48354ceSNicholas Bellinger */ 3981e48354ceSNicholas Bellinger complete(&conn->conn_logout_comp); 3982e48354ceSNicholas Bellinger 3983e48354ceSNicholas Bellinger iscsi_release_thread_set(conn); 3984e48354ceSNicholas Bellinger 3985e48354ceSNicholas Bellinger iscsit_stop_timers_for_cmds(conn); 3986e48354ceSNicholas Bellinger iscsit_stop_nopin_response_timer(conn); 3987e48354ceSNicholas Bellinger iscsit_stop_nopin_timer(conn); 3988e48354ceSNicholas Bellinger iscsit_free_queue_reqs_for_conn(conn); 3989e48354ceSNicholas Bellinger 3990e48354ceSNicholas Bellinger /* 3991e48354ceSNicholas Bellinger * During Connection recovery drop unacknowledged out of order 3992e48354ceSNicholas Bellinger * commands for this connection, and prepare the other commands 3993e48354ceSNicholas Bellinger * for realligence. 3994e48354ceSNicholas Bellinger * 3995e48354ceSNicholas Bellinger * During normal operation clear the out of order commands (but 3996e48354ceSNicholas Bellinger * do not free the struct iscsi_ooo_cmdsn's) and release all 3997e48354ceSNicholas Bellinger * struct iscsi_cmds. 3998e48354ceSNicholas Bellinger */ 3999e48354ceSNicholas Bellinger if (atomic_read(&conn->connection_recovery)) { 4000e48354ceSNicholas Bellinger iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(conn); 4001e48354ceSNicholas Bellinger iscsit_prepare_cmds_for_realligance(conn); 4002e48354ceSNicholas Bellinger } else { 4003e48354ceSNicholas Bellinger iscsit_clear_ooo_cmdsns_for_conn(conn); 4004e48354ceSNicholas Bellinger iscsit_release_commands_from_conn(conn); 4005e48354ceSNicholas Bellinger } 4006e48354ceSNicholas Bellinger 4007e48354ceSNicholas Bellinger /* 4008e48354ceSNicholas Bellinger * Handle decrementing session or connection usage count if 4009e48354ceSNicholas Bellinger * a logout response was not able to be sent because the 4010e48354ceSNicholas Bellinger * connection failed. Fall back to Session Recovery here. 4011e48354ceSNicholas Bellinger */ 4012e48354ceSNicholas Bellinger if (atomic_read(&conn->conn_logout_remove)) { 4013e48354ceSNicholas Bellinger if (conn->conn_logout_reason == ISCSI_LOGOUT_REASON_CLOSE_SESSION) { 4014e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4015e48354ceSNicholas Bellinger iscsit_dec_session_usage_count(sess); 4016e48354ceSNicholas Bellinger } 4017e48354ceSNicholas Bellinger if (conn->conn_logout_reason == ISCSI_LOGOUT_REASON_CLOSE_CONNECTION) 4018e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4019e48354ceSNicholas Bellinger 4020e48354ceSNicholas Bellinger atomic_set(&conn->conn_logout_remove, 0); 4021e48354ceSNicholas Bellinger atomic_set(&sess->session_reinstatement, 0); 4022e48354ceSNicholas Bellinger atomic_set(&sess->session_fall_back_to_erl0, 1); 4023e48354ceSNicholas Bellinger } 4024e48354ceSNicholas Bellinger 4025e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4026e48354ceSNicholas Bellinger list_del(&conn->conn_list); 4027e48354ceSNicholas Bellinger 4028e48354ceSNicholas Bellinger /* 4029e48354ceSNicholas Bellinger * Attempt to let the Initiator know this connection failed by 4030e48354ceSNicholas Bellinger * sending an Connection Dropped Async Message on another 4031e48354ceSNicholas Bellinger * active connection. 4032e48354ceSNicholas Bellinger */ 4033e48354ceSNicholas Bellinger if (atomic_read(&conn->connection_recovery)) 4034e48354ceSNicholas Bellinger iscsit_build_conn_drop_async_message(conn); 4035e48354ceSNicholas Bellinger 4036e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4037e48354ceSNicholas Bellinger 4038e48354ceSNicholas Bellinger /* 4039e48354ceSNicholas Bellinger * If connection reinstatement is being performed on this connection, 4040e48354ceSNicholas Bellinger * up the connection reinstatement semaphore that is being blocked on 4041e48354ceSNicholas Bellinger * in iscsit_cause_connection_reinstatement(). 4042e48354ceSNicholas Bellinger */ 4043e48354ceSNicholas Bellinger spin_lock_bh(&conn->state_lock); 4044e48354ceSNicholas Bellinger if (atomic_read(&conn->sleep_on_conn_wait_comp)) { 4045e48354ceSNicholas Bellinger spin_unlock_bh(&conn->state_lock); 4046e48354ceSNicholas Bellinger complete(&conn->conn_wait_comp); 4047e48354ceSNicholas Bellinger wait_for_completion(&conn->conn_post_wait_comp); 4048e48354ceSNicholas Bellinger spin_lock_bh(&conn->state_lock); 4049e48354ceSNicholas Bellinger } 4050e48354ceSNicholas Bellinger 4051e48354ceSNicholas Bellinger /* 4052e48354ceSNicholas Bellinger * If connection reinstatement is being performed on this connection 4053e48354ceSNicholas Bellinger * by receiving a REMOVECONNFORRECOVERY logout request, up the 4054e48354ceSNicholas Bellinger * connection wait rcfr semaphore that is being blocked on 4055e48354ceSNicholas Bellinger * an iscsit_connection_reinstatement_rcfr(). 4056e48354ceSNicholas Bellinger */ 4057e48354ceSNicholas Bellinger if (atomic_read(&conn->connection_wait_rcfr)) { 4058e48354ceSNicholas Bellinger spin_unlock_bh(&conn->state_lock); 4059e48354ceSNicholas Bellinger complete(&conn->conn_wait_rcfr_comp); 4060e48354ceSNicholas Bellinger wait_for_completion(&conn->conn_post_wait_comp); 4061e48354ceSNicholas Bellinger spin_lock_bh(&conn->state_lock); 4062e48354ceSNicholas Bellinger } 4063e48354ceSNicholas Bellinger atomic_set(&conn->connection_reinstatement, 1); 4064e48354ceSNicholas Bellinger spin_unlock_bh(&conn->state_lock); 4065e48354ceSNicholas Bellinger 4066e48354ceSNicholas Bellinger /* 4067e48354ceSNicholas Bellinger * If any other processes are accessing this connection pointer we 4068e48354ceSNicholas Bellinger * must wait until they have completed. 4069e48354ceSNicholas Bellinger */ 4070e48354ceSNicholas Bellinger iscsit_check_conn_usage_count(conn); 4071e48354ceSNicholas Bellinger 4072e48354ceSNicholas Bellinger if (conn->conn_rx_hash.tfm) 4073e48354ceSNicholas Bellinger crypto_free_hash(conn->conn_rx_hash.tfm); 4074e48354ceSNicholas Bellinger if (conn->conn_tx_hash.tfm) 4075e48354ceSNicholas Bellinger crypto_free_hash(conn->conn_tx_hash.tfm); 4076e48354ceSNicholas Bellinger 4077e48354ceSNicholas Bellinger if (conn->conn_cpumask) 4078e48354ceSNicholas Bellinger free_cpumask_var(conn->conn_cpumask); 4079e48354ceSNicholas Bellinger 4080e48354ceSNicholas Bellinger kfree(conn->conn_ops); 4081e48354ceSNicholas Bellinger conn->conn_ops = NULL; 4082e48354ceSNicholas Bellinger 4083e48354ceSNicholas Bellinger if (conn->sock) { 4084e48354ceSNicholas Bellinger if (conn->conn_flags & CONNFLAG_SCTP_STRUCT_FILE) { 4085e48354ceSNicholas Bellinger kfree(conn->sock->file); 4086e48354ceSNicholas Bellinger conn->sock->file = NULL; 4087e48354ceSNicholas Bellinger } 4088e48354ceSNicholas Bellinger sock_release(conn->sock); 4089e48354ceSNicholas Bellinger } 4090e48354ceSNicholas Bellinger conn->thread_set = NULL; 4091e48354ceSNicholas Bellinger 4092e48354ceSNicholas Bellinger pr_debug("Moving to TARG_CONN_STATE_FREE.\n"); 4093e48354ceSNicholas Bellinger conn->conn_state = TARG_CONN_STATE_FREE; 4094e48354ceSNicholas Bellinger kfree(conn); 4095e48354ceSNicholas Bellinger 4096e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4097e48354ceSNicholas Bellinger atomic_dec(&sess->nconn); 4098e48354ceSNicholas Bellinger pr_debug("Decremented iSCSI connection count to %hu from node:" 4099e48354ceSNicholas Bellinger " %s\n", atomic_read(&sess->nconn), 4100e48354ceSNicholas Bellinger sess->sess_ops->InitiatorName); 4101e48354ceSNicholas Bellinger /* 4102e48354ceSNicholas Bellinger * Make sure that if one connection fails in an non ERL=2 iSCSI 4103e48354ceSNicholas Bellinger * Session that they all fail. 4104e48354ceSNicholas Bellinger */ 4105e48354ceSNicholas Bellinger if ((sess->sess_ops->ErrorRecoveryLevel != 2) && !conn_logout && 4106e48354ceSNicholas Bellinger !atomic_read(&sess->session_logout)) 4107e48354ceSNicholas Bellinger atomic_set(&sess->session_fall_back_to_erl0, 1); 4108e48354ceSNicholas Bellinger 4109e48354ceSNicholas Bellinger /* 4110e48354ceSNicholas Bellinger * If this was not the last connection in the session, and we are 4111e48354ceSNicholas Bellinger * performing session reinstatement or falling back to ERL=0, call 4112e48354ceSNicholas Bellinger * iscsit_stop_session() without sleeping to shutdown the other 4113e48354ceSNicholas Bellinger * active connections. 4114e48354ceSNicholas Bellinger */ 4115e48354ceSNicholas Bellinger if (atomic_read(&sess->nconn)) { 4116e48354ceSNicholas Bellinger if (!atomic_read(&sess->session_reinstatement) && 4117e48354ceSNicholas Bellinger !atomic_read(&sess->session_fall_back_to_erl0)) { 4118e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4119e48354ceSNicholas Bellinger return 0; 4120e48354ceSNicholas Bellinger } 4121e48354ceSNicholas Bellinger if (!atomic_read(&sess->session_stop_active)) { 4122e48354ceSNicholas Bellinger atomic_set(&sess->session_stop_active, 1); 4123e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4124e48354ceSNicholas Bellinger iscsit_stop_session(sess, 0, 0); 4125e48354ceSNicholas Bellinger return 0; 4126e48354ceSNicholas Bellinger } 4127e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4128e48354ceSNicholas Bellinger return 0; 4129e48354ceSNicholas Bellinger } 4130e48354ceSNicholas Bellinger 4131e48354ceSNicholas Bellinger /* 4132e48354ceSNicholas Bellinger * If this was the last connection in the session and one of the 4133e48354ceSNicholas Bellinger * following is occurring: 4134e48354ceSNicholas Bellinger * 4135e48354ceSNicholas Bellinger * Session Reinstatement is not being performed, and are falling back 4136e48354ceSNicholas Bellinger * to ERL=0 call iscsit_close_session(). 4137e48354ceSNicholas Bellinger * 4138e48354ceSNicholas Bellinger * Session Logout was requested. iscsit_close_session() will be called 4139e48354ceSNicholas Bellinger * elsewhere. 4140e48354ceSNicholas Bellinger * 4141e48354ceSNicholas Bellinger * Session Continuation is not being performed, start the Time2Retain 4142e48354ceSNicholas Bellinger * handler and check if sleep_on_sess_wait_sem is active. 4143e48354ceSNicholas Bellinger */ 4144e48354ceSNicholas Bellinger if (!atomic_read(&sess->session_reinstatement) && 4145e48354ceSNicholas Bellinger atomic_read(&sess->session_fall_back_to_erl0)) { 4146e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4147e48354ceSNicholas Bellinger iscsit_close_session(sess); 4148e48354ceSNicholas Bellinger 4149e48354ceSNicholas Bellinger return 0; 4150e48354ceSNicholas Bellinger } else if (atomic_read(&sess->session_logout)) { 4151e48354ceSNicholas Bellinger pr_debug("Moving to TARG_SESS_STATE_FREE.\n"); 4152e48354ceSNicholas Bellinger sess->session_state = TARG_SESS_STATE_FREE; 4153e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4154e48354ceSNicholas Bellinger 4155e48354ceSNicholas Bellinger if (atomic_read(&sess->sleep_on_sess_wait_comp)) 4156e48354ceSNicholas Bellinger complete(&sess->session_wait_comp); 4157e48354ceSNicholas Bellinger 4158e48354ceSNicholas Bellinger return 0; 4159e48354ceSNicholas Bellinger } else { 4160e48354ceSNicholas Bellinger pr_debug("Moving to TARG_SESS_STATE_FAILED.\n"); 4161e48354ceSNicholas Bellinger sess->session_state = TARG_SESS_STATE_FAILED; 4162e48354ceSNicholas Bellinger 4163e48354ceSNicholas Bellinger if (!atomic_read(&sess->session_continuation)) { 4164e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4165e48354ceSNicholas Bellinger iscsit_start_time2retain_handler(sess); 4166e48354ceSNicholas Bellinger } else 4167e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4168e48354ceSNicholas Bellinger 4169e48354ceSNicholas Bellinger if (atomic_read(&sess->sleep_on_sess_wait_comp)) 4170e48354ceSNicholas Bellinger complete(&sess->session_wait_comp); 4171e48354ceSNicholas Bellinger 4172e48354ceSNicholas Bellinger return 0; 4173e48354ceSNicholas Bellinger } 4174e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4175e48354ceSNicholas Bellinger 4176e48354ceSNicholas Bellinger return 0; 4177e48354ceSNicholas Bellinger } 4178e48354ceSNicholas Bellinger 4179e48354ceSNicholas Bellinger int iscsit_close_session(struct iscsi_session *sess) 4180e48354ceSNicholas Bellinger { 4181e48354ceSNicholas Bellinger struct iscsi_portal_group *tpg = ISCSI_TPG_S(sess); 4182e48354ceSNicholas Bellinger struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 4183e48354ceSNicholas Bellinger 4184e48354ceSNicholas Bellinger if (atomic_read(&sess->nconn)) { 4185e48354ceSNicholas Bellinger pr_err("%d connection(s) still exist for iSCSI session" 4186e48354ceSNicholas Bellinger " to %s\n", atomic_read(&sess->nconn), 4187e48354ceSNicholas Bellinger sess->sess_ops->InitiatorName); 4188e48354ceSNicholas Bellinger BUG(); 4189e48354ceSNicholas Bellinger } 4190e48354ceSNicholas Bellinger 4191e48354ceSNicholas Bellinger spin_lock_bh(&se_tpg->session_lock); 4192e48354ceSNicholas Bellinger atomic_set(&sess->session_logout, 1); 4193e48354ceSNicholas Bellinger atomic_set(&sess->session_reinstatement, 1); 4194e48354ceSNicholas Bellinger iscsit_stop_time2retain_timer(sess); 4195e48354ceSNicholas Bellinger spin_unlock_bh(&se_tpg->session_lock); 4196e48354ceSNicholas Bellinger 4197e48354ceSNicholas Bellinger /* 4198e48354ceSNicholas Bellinger * transport_deregister_session_configfs() will clear the 4199e48354ceSNicholas Bellinger * struct se_node_acl->nacl_sess pointer now as a iscsi_np process context 4200e48354ceSNicholas Bellinger * can be setting it again with __transport_register_session() in 4201e48354ceSNicholas Bellinger * iscsi_post_login_handler() again after the iscsit_stop_session() 4202e48354ceSNicholas Bellinger * completes in iscsi_np context. 4203e48354ceSNicholas Bellinger */ 4204e48354ceSNicholas Bellinger transport_deregister_session_configfs(sess->se_sess); 4205e48354ceSNicholas Bellinger 4206e48354ceSNicholas Bellinger /* 4207e48354ceSNicholas Bellinger * If any other processes are accessing this session pointer we must 4208e48354ceSNicholas Bellinger * wait until they have completed. If we are in an interrupt (the 4209e48354ceSNicholas Bellinger * time2retain handler) and contain and active session usage count we 4210e48354ceSNicholas Bellinger * restart the timer and exit. 4211e48354ceSNicholas Bellinger */ 4212e48354ceSNicholas Bellinger if (!in_interrupt()) { 4213e48354ceSNicholas Bellinger if (iscsit_check_session_usage_count(sess) == 1) 4214e48354ceSNicholas Bellinger iscsit_stop_session(sess, 1, 1); 4215e48354ceSNicholas Bellinger } else { 4216e48354ceSNicholas Bellinger if (iscsit_check_session_usage_count(sess) == 2) { 4217e48354ceSNicholas Bellinger atomic_set(&sess->session_logout, 0); 4218e48354ceSNicholas Bellinger iscsit_start_time2retain_handler(sess); 4219e48354ceSNicholas Bellinger return 0; 4220e48354ceSNicholas Bellinger } 4221e48354ceSNicholas Bellinger } 4222e48354ceSNicholas Bellinger 4223e48354ceSNicholas Bellinger transport_deregister_session(sess->se_sess); 4224e48354ceSNicholas Bellinger 4225e48354ceSNicholas Bellinger if (sess->sess_ops->ErrorRecoveryLevel == 2) 4226e48354ceSNicholas Bellinger iscsit_free_connection_recovery_entires(sess); 4227e48354ceSNicholas Bellinger 4228e48354ceSNicholas Bellinger iscsit_free_all_ooo_cmdsns(sess); 4229e48354ceSNicholas Bellinger 4230e48354ceSNicholas Bellinger spin_lock_bh(&se_tpg->session_lock); 4231e48354ceSNicholas Bellinger pr_debug("Moving to TARG_SESS_STATE_FREE.\n"); 4232e48354ceSNicholas Bellinger sess->session_state = TARG_SESS_STATE_FREE; 4233e48354ceSNicholas Bellinger pr_debug("Released iSCSI session from node: %s\n", 4234e48354ceSNicholas Bellinger sess->sess_ops->InitiatorName); 4235e48354ceSNicholas Bellinger tpg->nsessions--; 4236e48354ceSNicholas Bellinger if (tpg->tpg_tiqn) 4237e48354ceSNicholas Bellinger tpg->tpg_tiqn->tiqn_nsessions--; 4238e48354ceSNicholas Bellinger 4239e48354ceSNicholas Bellinger pr_debug("Decremented number of active iSCSI Sessions on" 4240e48354ceSNicholas Bellinger " iSCSI TPG: %hu to %u\n", tpg->tpgt, tpg->nsessions); 4241e48354ceSNicholas Bellinger 4242e48354ceSNicholas Bellinger spin_lock(&sess_idr_lock); 4243e48354ceSNicholas Bellinger idr_remove(&sess_idr, sess->session_index); 4244e48354ceSNicholas Bellinger spin_unlock(&sess_idr_lock); 4245e48354ceSNicholas Bellinger 4246e48354ceSNicholas Bellinger kfree(sess->sess_ops); 4247e48354ceSNicholas Bellinger sess->sess_ops = NULL; 4248e48354ceSNicholas Bellinger spin_unlock_bh(&se_tpg->session_lock); 4249e48354ceSNicholas Bellinger 4250e48354ceSNicholas Bellinger kfree(sess); 4251e48354ceSNicholas Bellinger return 0; 4252e48354ceSNicholas Bellinger } 4253e48354ceSNicholas Bellinger 4254e48354ceSNicholas Bellinger static void iscsit_logout_post_handler_closesession( 4255e48354ceSNicholas Bellinger struct iscsi_conn *conn) 4256e48354ceSNicholas Bellinger { 4257e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 4258e48354ceSNicholas Bellinger 4259e48354ceSNicholas Bellinger iscsi_set_thread_clear(conn, ISCSI_CLEAR_TX_THREAD); 4260e48354ceSNicholas Bellinger iscsi_set_thread_set_signal(conn, ISCSI_SIGNAL_TX_THREAD); 4261e48354ceSNicholas Bellinger 4262e48354ceSNicholas Bellinger atomic_set(&conn->conn_logout_remove, 0); 4263e48354ceSNicholas Bellinger complete(&conn->conn_logout_comp); 4264e48354ceSNicholas Bellinger 4265e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4266e48354ceSNicholas Bellinger iscsit_stop_session(sess, 1, 1); 4267e48354ceSNicholas Bellinger iscsit_dec_session_usage_count(sess); 4268e48354ceSNicholas Bellinger iscsit_close_session(sess); 4269e48354ceSNicholas Bellinger } 4270e48354ceSNicholas Bellinger 4271e48354ceSNicholas Bellinger static void iscsit_logout_post_handler_samecid( 4272e48354ceSNicholas Bellinger struct iscsi_conn *conn) 4273e48354ceSNicholas Bellinger { 4274e48354ceSNicholas Bellinger iscsi_set_thread_clear(conn, ISCSI_CLEAR_TX_THREAD); 4275e48354ceSNicholas Bellinger iscsi_set_thread_set_signal(conn, ISCSI_SIGNAL_TX_THREAD); 4276e48354ceSNicholas Bellinger 4277e48354ceSNicholas Bellinger atomic_set(&conn->conn_logout_remove, 0); 4278e48354ceSNicholas Bellinger complete(&conn->conn_logout_comp); 4279e48354ceSNicholas Bellinger 4280e48354ceSNicholas Bellinger iscsit_cause_connection_reinstatement(conn, 1); 4281e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4282e48354ceSNicholas Bellinger } 4283e48354ceSNicholas Bellinger 4284e48354ceSNicholas Bellinger static void iscsit_logout_post_handler_diffcid( 4285e48354ceSNicholas Bellinger struct iscsi_conn *conn, 4286e48354ceSNicholas Bellinger u16 cid) 4287e48354ceSNicholas Bellinger { 4288e48354ceSNicholas Bellinger struct iscsi_conn *l_conn; 4289e48354ceSNicholas Bellinger struct iscsi_session *sess = conn->sess; 4290e48354ceSNicholas Bellinger 4291e48354ceSNicholas Bellinger if (!sess) 4292e48354ceSNicholas Bellinger return; 4293e48354ceSNicholas Bellinger 4294e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4295e48354ceSNicholas Bellinger list_for_each_entry(l_conn, &sess->sess_conn_list, conn_list) { 4296e48354ceSNicholas Bellinger if (l_conn->cid == cid) { 4297e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(l_conn); 4298e48354ceSNicholas Bellinger break; 4299e48354ceSNicholas Bellinger } 4300e48354ceSNicholas Bellinger } 4301e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4302e48354ceSNicholas Bellinger 4303e48354ceSNicholas Bellinger if (!l_conn) 4304e48354ceSNicholas Bellinger return; 4305e48354ceSNicholas Bellinger 4306e48354ceSNicholas Bellinger if (l_conn->sock) 4307e48354ceSNicholas Bellinger l_conn->sock->ops->shutdown(l_conn->sock, RCV_SHUTDOWN); 4308e48354ceSNicholas Bellinger 4309e48354ceSNicholas Bellinger spin_lock_bh(&l_conn->state_lock); 4310e48354ceSNicholas Bellinger pr_debug("Moving to TARG_CONN_STATE_IN_LOGOUT.\n"); 4311e48354ceSNicholas Bellinger l_conn->conn_state = TARG_CONN_STATE_IN_LOGOUT; 4312e48354ceSNicholas Bellinger spin_unlock_bh(&l_conn->state_lock); 4313e48354ceSNicholas Bellinger 4314e48354ceSNicholas Bellinger iscsit_cause_connection_reinstatement(l_conn, 1); 4315e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(l_conn); 4316e48354ceSNicholas Bellinger } 4317e48354ceSNicholas Bellinger 4318e48354ceSNicholas Bellinger /* 4319e48354ceSNicholas Bellinger * Return of 0 causes the TX thread to restart. 4320e48354ceSNicholas Bellinger */ 4321e48354ceSNicholas Bellinger static int iscsit_logout_post_handler( 4322e48354ceSNicholas Bellinger struct iscsi_cmd *cmd, 4323e48354ceSNicholas Bellinger struct iscsi_conn *conn) 4324e48354ceSNicholas Bellinger { 4325e48354ceSNicholas Bellinger int ret = 0; 4326e48354ceSNicholas Bellinger 4327e48354ceSNicholas Bellinger switch (cmd->logout_reason) { 4328e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_CLOSE_SESSION: 4329e48354ceSNicholas Bellinger switch (cmd->logout_response) { 4330e48354ceSNicholas Bellinger case ISCSI_LOGOUT_SUCCESS: 4331e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CLEANUP_FAILED: 4332e48354ceSNicholas Bellinger default: 4333e48354ceSNicholas Bellinger iscsit_logout_post_handler_closesession(conn); 4334e48354ceSNicholas Bellinger break; 4335e48354ceSNicholas Bellinger } 4336e48354ceSNicholas Bellinger ret = 0; 4337e48354ceSNicholas Bellinger break; 4338e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_CLOSE_CONNECTION: 4339e48354ceSNicholas Bellinger if (conn->cid == cmd->logout_cid) { 4340e48354ceSNicholas Bellinger switch (cmd->logout_response) { 4341e48354ceSNicholas Bellinger case ISCSI_LOGOUT_SUCCESS: 4342e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CLEANUP_FAILED: 4343e48354ceSNicholas Bellinger default: 4344e48354ceSNicholas Bellinger iscsit_logout_post_handler_samecid(conn); 4345e48354ceSNicholas Bellinger break; 4346e48354ceSNicholas Bellinger } 4347e48354ceSNicholas Bellinger ret = 0; 4348e48354ceSNicholas Bellinger } else { 4349e48354ceSNicholas Bellinger switch (cmd->logout_response) { 4350e48354ceSNicholas Bellinger case ISCSI_LOGOUT_SUCCESS: 4351e48354ceSNicholas Bellinger iscsit_logout_post_handler_diffcid(conn, 4352e48354ceSNicholas Bellinger cmd->logout_cid); 4353e48354ceSNicholas Bellinger break; 4354e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CID_NOT_FOUND: 4355e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CLEANUP_FAILED: 4356e48354ceSNicholas Bellinger default: 4357e48354ceSNicholas Bellinger break; 4358e48354ceSNicholas Bellinger } 4359e48354ceSNicholas Bellinger ret = 1; 4360e48354ceSNicholas Bellinger } 4361e48354ceSNicholas Bellinger break; 4362e48354ceSNicholas Bellinger case ISCSI_LOGOUT_REASON_RECOVERY: 4363e48354ceSNicholas Bellinger switch (cmd->logout_response) { 4364e48354ceSNicholas Bellinger case ISCSI_LOGOUT_SUCCESS: 4365e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CID_NOT_FOUND: 4366e48354ceSNicholas Bellinger case ISCSI_LOGOUT_RECOVERY_UNSUPPORTED: 4367e48354ceSNicholas Bellinger case ISCSI_LOGOUT_CLEANUP_FAILED: 4368e48354ceSNicholas Bellinger default: 4369e48354ceSNicholas Bellinger break; 4370e48354ceSNicholas Bellinger } 4371e48354ceSNicholas Bellinger ret = 1; 4372e48354ceSNicholas Bellinger break; 4373e48354ceSNicholas Bellinger default: 4374e48354ceSNicholas Bellinger break; 4375e48354ceSNicholas Bellinger 4376e48354ceSNicholas Bellinger } 4377e48354ceSNicholas Bellinger return ret; 4378e48354ceSNicholas Bellinger } 4379e48354ceSNicholas Bellinger 4380e48354ceSNicholas Bellinger void iscsit_fail_session(struct iscsi_session *sess) 4381e48354ceSNicholas Bellinger { 4382e48354ceSNicholas Bellinger struct iscsi_conn *conn; 4383e48354ceSNicholas Bellinger 4384e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4385e48354ceSNicholas Bellinger list_for_each_entry(conn, &sess->sess_conn_list, conn_list) { 4386e48354ceSNicholas Bellinger pr_debug("Moving to TARG_CONN_STATE_CLEANUP_WAIT.\n"); 4387e48354ceSNicholas Bellinger conn->conn_state = TARG_CONN_STATE_CLEANUP_WAIT; 4388e48354ceSNicholas Bellinger } 4389e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4390e48354ceSNicholas Bellinger 4391e48354ceSNicholas Bellinger pr_debug("Moving to TARG_SESS_STATE_FAILED.\n"); 4392e48354ceSNicholas Bellinger sess->session_state = TARG_SESS_STATE_FAILED; 4393e48354ceSNicholas Bellinger } 4394e48354ceSNicholas Bellinger 4395e48354ceSNicholas Bellinger int iscsit_free_session(struct iscsi_session *sess) 4396e48354ceSNicholas Bellinger { 4397e48354ceSNicholas Bellinger u16 conn_count = atomic_read(&sess->nconn); 4398e48354ceSNicholas Bellinger struct iscsi_conn *conn, *conn_tmp = NULL; 4399e48354ceSNicholas Bellinger int is_last; 4400e48354ceSNicholas Bellinger 4401e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4402e48354ceSNicholas Bellinger atomic_set(&sess->sleep_on_sess_wait_comp, 1); 4403e48354ceSNicholas Bellinger 4404e48354ceSNicholas Bellinger list_for_each_entry_safe(conn, conn_tmp, &sess->sess_conn_list, 4405e48354ceSNicholas Bellinger conn_list) { 4406e48354ceSNicholas Bellinger if (conn_count == 0) 4407e48354ceSNicholas Bellinger break; 4408e48354ceSNicholas Bellinger 4409e48354ceSNicholas Bellinger if (list_is_last(&conn->conn_list, &sess->sess_conn_list)) { 4410e48354ceSNicholas Bellinger is_last = 1; 4411e48354ceSNicholas Bellinger } else { 4412e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn_tmp); 4413e48354ceSNicholas Bellinger is_last = 0; 4414e48354ceSNicholas Bellinger } 4415e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn); 4416e48354ceSNicholas Bellinger 4417e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4418e48354ceSNicholas Bellinger iscsit_cause_connection_reinstatement(conn, 1); 4419e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4420e48354ceSNicholas Bellinger 4421e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4422e48354ceSNicholas Bellinger if (is_last == 0) 4423e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn_tmp); 4424e48354ceSNicholas Bellinger 4425e48354ceSNicholas Bellinger conn_count--; 4426e48354ceSNicholas Bellinger } 4427e48354ceSNicholas Bellinger 4428e48354ceSNicholas Bellinger if (atomic_read(&sess->nconn)) { 4429e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4430e48354ceSNicholas Bellinger wait_for_completion(&sess->session_wait_comp); 4431e48354ceSNicholas Bellinger } else 4432e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4433e48354ceSNicholas Bellinger 4434e48354ceSNicholas Bellinger iscsit_close_session(sess); 4435e48354ceSNicholas Bellinger return 0; 4436e48354ceSNicholas Bellinger } 4437e48354ceSNicholas Bellinger 4438e48354ceSNicholas Bellinger void iscsit_stop_session( 4439e48354ceSNicholas Bellinger struct iscsi_session *sess, 4440e48354ceSNicholas Bellinger int session_sleep, 4441e48354ceSNicholas Bellinger int connection_sleep) 4442e48354ceSNicholas Bellinger { 4443e48354ceSNicholas Bellinger u16 conn_count = atomic_read(&sess->nconn); 4444e48354ceSNicholas Bellinger struct iscsi_conn *conn, *conn_tmp = NULL; 4445e48354ceSNicholas Bellinger int is_last; 4446e48354ceSNicholas Bellinger 4447e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4448e48354ceSNicholas Bellinger if (session_sleep) 4449e48354ceSNicholas Bellinger atomic_set(&sess->sleep_on_sess_wait_comp, 1); 4450e48354ceSNicholas Bellinger 4451e48354ceSNicholas Bellinger if (connection_sleep) { 4452e48354ceSNicholas Bellinger list_for_each_entry_safe(conn, conn_tmp, &sess->sess_conn_list, 4453e48354ceSNicholas Bellinger conn_list) { 4454e48354ceSNicholas Bellinger if (conn_count == 0) 4455e48354ceSNicholas Bellinger break; 4456e48354ceSNicholas Bellinger 4457e48354ceSNicholas Bellinger if (list_is_last(&conn->conn_list, &sess->sess_conn_list)) { 4458e48354ceSNicholas Bellinger is_last = 1; 4459e48354ceSNicholas Bellinger } else { 4460e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn_tmp); 4461e48354ceSNicholas Bellinger is_last = 0; 4462e48354ceSNicholas Bellinger } 4463e48354ceSNicholas Bellinger iscsit_inc_conn_usage_count(conn); 4464e48354ceSNicholas Bellinger 4465e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4466e48354ceSNicholas Bellinger iscsit_cause_connection_reinstatement(conn, 1); 4467e48354ceSNicholas Bellinger spin_lock_bh(&sess->conn_lock); 4468e48354ceSNicholas Bellinger 4469e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn); 4470e48354ceSNicholas Bellinger if (is_last == 0) 4471e48354ceSNicholas Bellinger iscsit_dec_conn_usage_count(conn_tmp); 4472e48354ceSNicholas Bellinger conn_count--; 4473e48354ceSNicholas Bellinger } 4474e48354ceSNicholas Bellinger } else { 4475e48354ceSNicholas Bellinger list_for_each_entry(conn, &sess->sess_conn_list, conn_list) 4476e48354ceSNicholas Bellinger iscsit_cause_connection_reinstatement(conn, 0); 4477e48354ceSNicholas Bellinger } 4478e48354ceSNicholas Bellinger 4479e48354ceSNicholas Bellinger if (session_sleep && atomic_read(&sess->nconn)) { 4480e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4481e48354ceSNicholas Bellinger wait_for_completion(&sess->session_wait_comp); 4482e48354ceSNicholas Bellinger } else 4483e48354ceSNicholas Bellinger spin_unlock_bh(&sess->conn_lock); 4484e48354ceSNicholas Bellinger } 4485e48354ceSNicholas Bellinger 4486e48354ceSNicholas Bellinger int iscsit_release_sessions_for_tpg(struct iscsi_portal_group *tpg, int force) 4487e48354ceSNicholas Bellinger { 4488e48354ceSNicholas Bellinger struct iscsi_session *sess; 4489e48354ceSNicholas Bellinger struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 4490e48354ceSNicholas Bellinger struct se_session *se_sess, *se_sess_tmp; 4491e48354ceSNicholas Bellinger int session_count = 0; 4492e48354ceSNicholas Bellinger 4493e48354ceSNicholas Bellinger spin_lock_bh(&se_tpg->session_lock); 4494e48354ceSNicholas Bellinger if (tpg->nsessions && !force) { 4495e48354ceSNicholas Bellinger spin_unlock_bh(&se_tpg->session_lock); 4496e48354ceSNicholas Bellinger return -1; 4497e48354ceSNicholas Bellinger } 4498e48354ceSNicholas Bellinger 4499e48354ceSNicholas Bellinger list_for_each_entry_safe(se_sess, se_sess_tmp, &se_tpg->tpg_sess_list, 4500e48354ceSNicholas Bellinger sess_list) { 4501e48354ceSNicholas Bellinger sess = (struct iscsi_session *)se_sess->fabric_sess_ptr; 4502e48354ceSNicholas Bellinger 4503e48354ceSNicholas Bellinger spin_lock(&sess->conn_lock); 4504e48354ceSNicholas Bellinger if (atomic_read(&sess->session_fall_back_to_erl0) || 4505e48354ceSNicholas Bellinger atomic_read(&sess->session_logout) || 4506e48354ceSNicholas Bellinger (sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)) { 4507e48354ceSNicholas Bellinger spin_unlock(&sess->conn_lock); 4508e48354ceSNicholas Bellinger continue; 4509e48354ceSNicholas Bellinger } 4510e48354ceSNicholas Bellinger atomic_set(&sess->session_reinstatement, 1); 4511e48354ceSNicholas Bellinger spin_unlock(&sess->conn_lock); 4512e48354ceSNicholas Bellinger spin_unlock_bh(&se_tpg->session_lock); 4513e48354ceSNicholas Bellinger 4514e48354ceSNicholas Bellinger iscsit_free_session(sess); 4515e48354ceSNicholas Bellinger spin_lock_bh(&se_tpg->session_lock); 4516e48354ceSNicholas Bellinger 4517e48354ceSNicholas Bellinger session_count++; 4518e48354ceSNicholas Bellinger } 4519e48354ceSNicholas Bellinger spin_unlock_bh(&se_tpg->session_lock); 4520e48354ceSNicholas Bellinger 4521e48354ceSNicholas Bellinger pr_debug("Released %d iSCSI Session(s) from Target Portal" 4522e48354ceSNicholas Bellinger " Group: %hu\n", session_count, tpg->tpgt); 4523e48354ceSNicholas Bellinger return 0; 4524e48354ceSNicholas Bellinger } 4525e48354ceSNicholas Bellinger 4526e48354ceSNicholas Bellinger MODULE_DESCRIPTION("iSCSI-Target Driver for mainline target infrastructure"); 4527e48354ceSNicholas Bellinger MODULE_VERSION("4.1.x"); 4528e48354ceSNicholas Bellinger MODULE_AUTHOR("nab@Linux-iSCSI.org"); 4529e48354ceSNicholas Bellinger MODULE_LICENSE("GPL"); 4530e48354ceSNicholas Bellinger 4531e48354ceSNicholas Bellinger module_init(iscsi_target_init_module); 4532e48354ceSNicholas Bellinger module_exit(iscsi_target_cleanup_module); 4533