Target_Core_Mod Generic Transport Core
Subsystems (2)
RFC PATCH 16/19 Target_Core_Mod Generic Transport Core
[RFC PATCH 16/19] Target_Core_Mod Generic Transport Core
The patch adds the core generic target engine functionality including processing of se_cmd_t, generation of se_task_ts, control patch CDB emulation, sense data, memory allocation, and memory mapping from fabric module allocated memory using linked list struct scatterlist style memory based on underlying storage object hardware.
The Generic Target Core layer is above the Linux/SCSI, Linux/BLOCK and Linux/VFS subsystems, and communicates with these subsystems (and local RAMDISK plugins) using an API of function pointers in se_subsystem_api_t. It provides processing capabilties and emulation for SCSI logic and CDBs in a generic manner to storage object LUNs provided from Linux storage subsystems backend storage devices.
drivers/target/target_core_transport.c new file +8001 -0
@@ -0,0 +1,8001 @@ +/******************************************************************************* +* Filename: target_core_transport.c +* +* This file contains the Generic Target Engine Core. +* +* Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc. +* Copyright (c) 2005, 2006, 2007 SBE, Inc. +* Copyright (c) 2007-2009 Rising Tide Software, Inc. +* Copyright (c) 2008-2009 Linux-iSCSI.org +* +* Nicholas A. Bellinger <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +******************************************************************************/ + + +#define TARGET_CORE_TRANSPORT_C + +#include <linux/version.h> +#include <linux/net.h> +#include <linux/delay.h> +#include <linux/string.h> +#include <linux/timer.h> +#include <linux/slab.h> +#include <linux/blkdev.h> +#include <linux/spinlock.h> +#include <linux/smp_lock.h> +#include <linux/kthread.h> +#include <linux/in.h> +#include <linux/cdrom.h> +#include <net/sock.h> +#include <net/tcp.h> +#include <scsi/scsi.h> +#include <scsi/scsi_cmnd.h> +#include <scsi/libsas.h> /* For TASK_ATTR_* */ + +#include <target/target_core_base.h> +#include <target/target_core_device.h> +#include <target/target_core_hba.h> +#include <target/target_core_scdb.h> +#include <target/target_core_pr.h> +#include <target/target_core_alua.h> +#include <target/target_core_tmr.h> +#include <target/target_core_ua.h> +#include <target/target_core_transport.h> +#include <target/target_core_plugin.h> +#include <target/target_core_seobj.h> +#include <target/target_core_transport_plugin.h> +#include <target/target_core_fabric_ops.h> +#include <target/target_core_configfs.h> + +#undef TARGET_CORE_TRANSPORT_C + +/* #define DEBUG_CDB_HANDLER */ +#ifdef DEBUG_CDB_HANDLER +#define DEBUG_CDB_H(x...) printk(KERN_INFO x) +#else +#define DEBUG_CDB_H(x...) +#endif + +/* #define DEBUG_CMD_MAP */ +#ifdef DEBUG_CMD_MAP +#define DEBUG_CMD_M(x...) printk(KERN_INFO x) +#else +#define DEBUG_CMD_M(x...) +#endif + +/* #define DEBUG_MEM_ALLOC */ +#ifdef DEBUG_MEM_ALLOC +#define DEBUG_MEM(x...) printk(KERN_INFO x) +#else +#define DEBUG_MEM(x...) +#endif + +/* #define DEBUG_MEM2_ALLOC */ +#ifdef DEBUG_MEM2_ALLOC +#define DEBUG_MEM2(x...) printk(KERN_INFO x) +#else +#define DEBUG_MEM2(x...) +#endif + +/* #define DEBUG_SG_CALC */ +#ifdef DEBUG_SG_CALC +#define DEBUG_SC(x...) printk(KERN_INFO x) +#else +#define DEBUG_SC(x...) +#endif + +/* #define DEBUG_SE_OBJ */ +#ifdef DEBUG_SE_OBJ +#define DEBUG_SO(x...) printk(KERN_INFO x) +#else +#define DEBUG_SO(x...) +#endif + +/* #define DEBUG_CMD_VOL */ +#ifdef DEBUG_CMD_VOL +#define DEBUG_VOL(x...) printk(KERN_INFO x) +#else +#define DEBUG_VOL(x...) +#endif + +/* #define DEBUG_CMD_STOP */ +#ifdef DEBUG_CMD_STOP +#define DEBUG_CS(x...) printk(KERN_INFO x) +#else +#define DEBUG_CS(x...) +#endif + +/* #define DEBUG_PASSTHROUGH */ +#ifdef DEBUG_PASSTHROUGH +#define DEBUG_PT(x...) printk(KERN_INFO x) +#else +#define DEBUG_PT(x...) +#endif + +/* #define DEBUG_TASK_STOP */ +#ifdef DEBUG_TASK_STOP +#define DEBUG_TS(x...) printk(KERN_INFO x) +#else +#define DEBUG_TS(x...) +#endif + +/* #define DEBUG_TRANSPORT_STOP */ +#ifdef DEBUG_TRANSPORT_STOP +#define DEBUG_TRANSPORT_S(x...) printk(KERN_INFO x) +#else +#define DEBUG_TRANSPORT_S(x...) +#endif + +/* #define DEBUG_TASK_FAILURE */ +#ifdef DEBUG_TASK_FAILURE +#define DEBUG_TF(x...) printk(KERN_INFO x) +#else +#define DEBUG_TF(x...) +#endif + +/* #define DEBUG_DEV_OFFLINE */ +#ifdef DEBUG_DEV_OFFLINE +#define DEBUG_DO(x...) printk(KERN_INFO x) +#else +#define DEBUG_DO(x...) +#endif + +/* #define DEBUG_TASK_STATE */ +#ifdef DEBUG_TASK_STATE +#define DEBUG_TSTATE(x...) printk(KERN_INFO x) +#else +#define DEBUG_TSTATE(x...) +#endif + +/* #define DEBUG_STATUS_THR */ +#ifdef DEBUG_STATUS_THR +#define DEBUG_ST(x...) printk(KERN_INFO x) +#else +#define DEBUG_ST(x...) +#endif + +/* #define DEBUG_TASK_TIMEOUT */ +#ifdef DEBUG_TASK_TIMEOUT +#define DEBUG_TT(x...) printk(KERN_INFO x) +#else +#define DEBUG_TT(x...) +#endif + +/* #define DEBUG_GENERIC_REQUEST_FAILURE */ +#ifdef DEBUG_GENERIC_REQUEST_FAILURE +#define DEBUG_GRF(x...) printk(KERN_INFO x) +#else +#define DEBUG_GRF(x...) +#endif + +/* #define DEBUG_SAM_TASK_ATTRS */ +#ifdef DEBUG_SAM_TASK_ATTRS +#define DEBUG_STA(x...) printk(KERN_INFO x) +#else +#define DEBUG_STA(x...) +#endif + +se_global_t *se_global; +EXPORT_SYMBOL (se_global); + +struct kmem_cache *se_cmd_cache; +struct kmem_cache *se_task_cache; +struct kmem_cache *se_tmr_req_cache; +struct kmem_cache *se_sess_cache; +struct kmem_cache *se_hba_cache; +struct kmem_cache *se_ua_cache; +struct kmem_cache *t10_pr_reg_cache; +struct kmem_cache *t10_alua_lu_gp_cache; +struct kmem_cache *t10_alua_lu_gp_mem_cache; +struct kmem_cache *t10_alua_tg_pt_gp_cache; +struct kmem_cache *t10_alua_tg_pt_gp_mem_cache; + +static int transport_generic_write_pending (se_cmd_t *); +static int transport_processing_thread (void *); + +static char *transport_passthrough_get_fabric_name (void ) +{ +return "PT" ; +} + +static u32 transport_passthrough_get_task_tag (se_cmd_t *cmd) +{ +return 0 ; +} + +static int transport_passthrough_get_cmd_state (se_cmd_t *cmd) +{ +return 0 ; +} + +static void transport_passthrough_release_cmd_direct (se_cmd_t *cmd) +{ +return ; +} + +static u16 transport_passthrough_set_fabric_sense_len ( +se_cmd_t *cmd, +u32 sense_len) +{ +return 0 ; +} + +static u16 transport_passthrough_get_fabric_sense_len (void ) +{ +return 0 ; +} + +struct target_core_fabric_ops passthrough_fabric_ops = { + .release_cmd_direct = transport_passthrough_release_cmd_direct, + .get_fabric_name = transport_passthrough_get_fabric_name, + .get_task_tag = transport_passthrough_get_task_tag, + .get_cmd_state = transport_passthrough_get_cmd_state, + .set_fabric_sense_len = transport_passthrough_set_fabric_sense_len, + .get_fabric_sense_len = transport_passthrough_get_fabric_sense_len, +}; + +int init_se_global (void ) +{ +se_global_t *global; + + global =kzalloc (sizeof (se_global_t),GFP_KERNEL ); +if (!(global)) { +printk (KERN_ERR "Unable to allocate memory for se_global_t\n" ); +return -1 ; + } + +INIT_LIST_HEAD (&global->g_lu_gps_list); +INIT_LIST_HEAD (&global->g_se_tpg_list); +INIT_LIST_HEAD (&global->g_hba_list); +INIT_LIST_HEAD (&global->g_se_dev_list); +spin_lock_init (&global->g_device_lock); +spin_lock_init (&global->hba_lock); +spin_lock_init (&global->se_tpg_lock); +spin_lock_init (&global->lu_gps_lock); +spin_lock_init (&global->plugin_class_lock); + + se_cmd_cache =kmem_cache_create ("se_cmd_cache" , +sizeof (se_cmd_t), __alignof__(se_cmd_t ),0 ,NULL ); +if (!(se_cmd_cache)) { +printk (KERN_ERR "kmem_cache_create for se_cmd_t failed\n" ); + goto out; + } + se_task_cache =kmem_cache_create ("se_task_cache" , +sizeof (se_task_t), __alignof__(se_task_t ),0 ,NULL ); +if (!(se_task_cache)) { +printk (KERN_ERR "kmem_cache_create for se_task_t failed\n" ); + goto out; + } + se_tmr_req_cache =kmem_cache_create ("se_tmr_cache" , +sizeof (se_tmr_req_t), __alignof__(se_tmr_req_t ), +0 ,NULL ); +if (!(se_tmr_req_cache)) { +printk (KERN_ERR "kmem_cache_create() for se_tmr_req_t" +" failed\n" ); + goto out; + } + se_sess_cache =kmem_cache_create ("se_sess_cache" , +sizeof (se_session_t), __alignof__(se_session_t ), +0 ,NULL ); +if (!(se_sess_cache)) { +printk (KERN_ERR "kmem_cache_create() for se_session_t" +" failed\n" ); + goto out; + } + se_hba_cache =kmem_cache_create ("se_hba_cache" , +sizeof (se_hba_t), __alignof__(se_hba_t ), +0 ,NULL ); +if (!(se_hba_cache)) { +printk (KERN_ERR "kmem_cache_create() for se_hba_t" +" failed\n" ); + goto out; + } + se_ua_cache =kmem_cache_create ("se_ua_cache" , +sizeof (se_ua_t), __alignof__(se_ua_t ),0 ,NULL ); +if (!(se_ua_cache)) { +printk (KERN_ERR "kmem_cache_create() for se_ua_t failed\n" ); + goto out; + } + t10_pr_reg_cache =kmem_cache_create ("t10_pr_reg_cache" , +sizeof (t10_pr_registration_t), + __alignof__(t10_pr_registration_t ),0 ,NULL ); +if (!(t10_pr_reg_cache)) { +printk (KERN_ERR "kmem_cache_create() for t10_pr_registration_t" +" failed\n" ); + goto out; + } + t10_alua_lu_gp_cache =kmem_cache_create ("t10_alua_lu_gp_cache" , +sizeof (t10_alua_lu_gp_t), __alignof__(t10_alua_lu_gp_t ), +0 ,NULL ); +if (!(t10_alua_lu_gp_cache)) { +printk (KERN_ERR "kmem_cache_create() for t10_alua_lu_gp_cache" +" failed\n" ); + goto out; + } + t10_alua_lu_gp_mem_cache =kmem_cache_create ("t10_alua_lu_gp_mem_cache" , +sizeof (t10_alua_lu_gp_member_t), + __alignof__(t10_alua_lu_gp_member_t ),0 ,NULL ); +if (!(t10_alua_lu_gp_mem_cache)) { +printk (KERN_ERR "kmem_cache_create() for t10_alua_lu_gp_mem_" +"cache failed\n" ); + goto out; + } + t10_alua_tg_pt_gp_cache =kmem_cache_create ("t10_alua_tg_pt_gp_cache" , +sizeof (t10_alua_tg_pt_gp_t), + __alignof__(t10_alua_tg_pt_gp_t ),0 ,NULL ); +if (!(t10_alua_tg_pt_gp_cache)) { +printk (KERN_ERR "kmem_cache_create() for t10_alua_tg_pt_gp_" +"cache failed\n" ); + goto out; + } + t10_alua_tg_pt_gp_mem_cache =kmem_cache_create ( +"t10_alua_tg_pt_gp_mem_cache" , +sizeof (t10_alua_tg_pt_gp_member_t), + __alignof__(t10_alua_tg_pt_gp_member_t ), +0 ,NULL ); +if (!(t10_alua_tg_pt_gp_mem_cache)) { +printk (KERN_ERR "kmem_cache_create() for t10_alua_tg_pt_gp_" +"mem_t failed\n" ); + goto out; + } + + global->plugin_class_list =kzalloc ((sizeof (se_plugin_class_t) * +MAX_PLUGIN_CLASSES ),GFP_KERNEL ); +if (!(global->plugin_class_list)) { +printk (KERN_ERR "Unable to allocate global->" +"plugin_class_list\n" ); + goto out; + } + + se_global = global; + +return 0 ; +out: +kfree (global->plugin_class_list); +if (se_cmd_cache) +kmem_cache_destroy (se_cmd_cache); +if (se_task_cache) +kmem_cache_destroy (se_task_cache); +if (se_tmr_req_cache) +kmem_cache_destroy (se_tmr_req_cache); +if (se_sess_cache) +kmem_cache_destroy (se_sess_cache); +if (se_hba_cache) +kmem_cache_destroy (se_hba_cache); +if (se_ua_cache) +kmem_cache_destroy (se_ua_cache); +if (t10_pr_reg_cache) +kmem_cache_destroy (t10_pr_reg_cache); +if (t10_alua_lu_gp_cache) +kmem_cache_destroy (t10_alua_lu_gp_cache); +if (t10_alua_lu_gp_mem_cache) +kmem_cache_destroy (t10_alua_lu_gp_mem_cache); +if (t10_alua_tg_pt_gp_cache) +kmem_cache_destroy (t10_alua_tg_pt_gp_cache); +if (t10_alua_tg_pt_gp_mem_cache) +kmem_cache_destroy (t10_alua_tg_pt_gp_mem_cache); +kfree (global); +return -1 ; +} + +void release_se_global (void ) +{ +se_global_t *global; + + global = se_global; +if (!(global)) +return ; + +kfree (global->plugin_class_list); +kmem_cache_destroy (se_cmd_cache); +kmem_cache_destroy (se_task_cache); +kmem_cache_destroy (se_tmr_req_cache); +kmem_cache_destroy (se_sess_cache); +kmem_cache_destroy (se_hba_cache); +kmem_cache_destroy (se_ua_cache); +kmem_cache_destroy (t10_pr_reg_cache); +kmem_cache_destroy (t10_alua_lu_gp_cache); +kmem_cache_destroy (t10_alua_lu_gp_mem_cache); +kmem_cache_destroy (t10_alua_tg_pt_gp_cache); +kmem_cache_destroy (t10_alua_tg_pt_gp_mem_cache); +kfree (global); + + se_global =NULL ; +} + +#ifdef DEBUG_DEV + +/* warning FIXME: PLUGIN API TODO */ +int __iscsi_debug_dev (se_device_t *dev) +{ +int fail_task =0 ; +fd_dev_t *fd_dev; +iblock_dev_t *ib_dev; +rd_dev_t *rd_dev; +struct scsi_device *sd; + +spin_lock (&se_global->debug_dev_lock); +switch (dev->se_hba->type) { +case PSCSI : + sd = (struct scsi_device *) dev->dev_ptr; +if (dev->dev_flags &DF_DEV_DEBUG ) { +printk (KERN_INFO "HBA[%u] - Failing PSCSI Task for" +" %d/%d/%d\n" , dev->se_hba->hba_id, + sd->channel, sd->id, sd->lun); + fail_task =1 ; + } +break ; +case IBLOCK : + ib_dev = (iblock_dev_t *) dev->dev_ptr; +if (dev->dev_flags &DF_DEV_DEBUG ) { +printk (KERN_INFO "HBA[%u] - Failing IBLOCK Task for" +" %u/%u\n" , dev->se_hba->hba_id, + ib_dev->ibd_major, ib_dev->ibd_minor); + fail_task =1 ; + } +break ; +case FILEIO : + fd_dev = (fd_dev_t *) dev->dev_ptr; +if (dev->dev_flags &DF_DEV_DEBUG ) { +printk (KERN_INFO "HBA[%u] - Failing FILEIO Task for" +" %u\n" , dev->se_hba->hba_id, + fd_dev->fd_dev_id); + fail_task =1 ; + } +break ; +case RAMDISK_DR : +case RAMDISK_MCP : + rd_dev = (rd_dev_t *) dev->dev_ptr; +if (dev->dev_flags &DF_DEV_DEBUG ) { +printk (KERN_INFO "HBA[%u] - Failing RAMDISK Task for" +" %u\n" , dev->se_hba->hba_id, + rd_dev->rd_dev_id); + fail_task =1 ; + } +break ; +default : +if (dev->dev_flags &DF_DEV_DEBUG ) { +printk (KERN_INFO "HBA[%u] - Failing unknown Task\n" , + dev->se_hba->hba_id); + fail_task =1 ; + } +break ; + } +spin_unlock (&se_global->debug_dev_lock); + +return fail_task; +} + +#endif /* DEBUG_DEV */ + +/* #warning FIXME: transport_get_iqn_sn() for se_global_t */ +unsigned char *transport_get_iqn_sn (void ) +{ +/* +* Assume that for production WWN information will come through +* ConfigFS at /sys/kernel/config/target/core/$HBA/$DEV/vpd_unit_serial +*/ +return "1234567890" ; +} + +void transport_init_queue_obj (se_queue_obj_t *qobj) +{ +atomic_set (&qobj->queue_cnt,0 ); +INIT_LIST_HEAD (&qobj->qobj_list); +init_waitqueue_head (&qobj->thread_wq); +init_completion (&qobj->thread_create_comp); +init_completion (&qobj->thread_done_comp); +spin_lock_init (&qobj->cmd_queue_lock); +} + +void transport_load_plugins (void ) +{ +int ret =0 ; + +#ifdef PARALLEL_SCSI +plugin_register ((void *)&pscsi_template, pscsi_template.type, + pscsi_template.name,PLUGIN_TYPE_TRANSPORT , + pscsi_template.get_plugin_info,NULL ,NULL , &ret); +#endif +#ifdef STGT_PLUGIN +plugin_register ((void *)&stgt_template, stgt_template.type, + stgt_template.name,PLUGIN_TYPE_TRANSPORT , + stgt_template.get_plugin_info, + stgt_template.plugin_init, + stgt_template.plugin_free, &ret); +#endif +#ifdef PYX_IBLOCK +plugin_register ((void *)&iblock_template, iblock_template.type, + iblock_template.name,PLUGIN_TYPE_TRANSPORT , + iblock_template.get_plugin_info,NULL ,NULL , &ret); +#endif +#ifdef PYX_RAMDISK +plugin_register ((void *)&rd_dr_template, rd_dr_template.type, + rd_dr_template.name,PLUGIN_TYPE_TRANSPORT , + rd_dr_template.get_plugin_info,NULL ,NULL , &ret); +plugin_register ((void *)&rd_mcp_template, rd_mcp_template.type, + rd_mcp_template.name,PLUGIN_TYPE_TRANSPORT , + rd_mcp_template.get_plugin_info,NULL ,NULL , &ret); +#endif +#ifdef PYX_FILEIO +plugin_register ((void *)&fileio_template, fileio_template.type, + fileio_template.name,PLUGIN_TYPE_TRANSPORT , + fileio_template.get_plugin_info,NULL ,NULL , &ret); +#endif +} + +se_plugin_t *transport_core_get_plugin_by_name (const char *name) +{ +se_plugin_class_t *pc; +se_plugin_t *p; +int i; + + pc =plugin_get_class (PLUGIN_TYPE_TRANSPORT ); +if (!(pc)) +return NULL ; + +for (i =0 ; i <MAX_PLUGINS ; i++) { + p = &pc->plugin_array[i]; + +if (!p->plugin_obj) +continue ; + +if (!(strncmp (name, p->plugin_name,strlen (p->plugin_name)))) +return p; + } + +return NULL ; +} + +void transport_check_dev_params_delim (char *ptr,char **cur) +{ +char *ptr2; + +if (ptr) { + ptr2 =strstr (ptr,"," ); +if ((ptr2)) { + *ptr2 ='\0' ; + *cur = (ptr2 +1 );/* Skip over comma */ + }else + *cur =NULL ; + } +} + +se_session_t *transport_init_session (void ) +{ +se_session_t *se_sess; + + se_sess =kmem_cache_zalloc (se_sess_cache,GFP_KERNEL ); +if (!(se_sess)) { +printk (KERN_ERR "Unable to allocate se_session_t from" +" se_sess_cache\n" ); +return ERR_PTR (-ENOMEM ); + } +INIT_LIST_HEAD (&se_sess->sess_list); + +return se_sess; +} +EXPORT_SYMBOL (transport_init_session); + +/* +* Called with spin_lock_bh(&se_portal_group_t->session_lock called. +*/ +void __transport_register_session ( +se_portal_group_t *se_tpg, +se_node_acl_t *se_nacl, +se_session_t *se_sess, +void *fabric_sess_ptr) +{ + se_sess->se_tpg = se_tpg; + se_sess->fabric_sess_ptr = fabric_sess_ptr; +/* +* Used by se_node_acl_t's under ConfigFS to locate active se_session-t +* +* Only set for se_session_t's that will actually be moving I/O. +* eg: *NOT* discovery sessions. +*/ +if (se_nacl) { +spin_lock_bh (&se_nacl->nacl_sess_lock); + se_nacl->nacl_sess = se_sess; +spin_unlock_bh (&se_nacl->nacl_sess_lock); + } +list_add_tail (&se_sess->sess_list, &se_tpg->tpg_sess_list); + +printk (KERN_INFO "TARGET_CORE[%s]: Registered fabric_sess_ptr: %p\n" , +TPG_TFO (se_tpg)->get_fabric_name (), se_sess->fabric_sess_ptr); +} +EXPORT_SYMBOL (__transport_register_session); + +void transport_register_session ( +se_portal_group_t *se_tpg, +se_node_acl_t *se_nacl, +se_session_t *se_sess, +void *fabric_sess_ptr) +{ +spin_lock_bh (&se_tpg->session_lock); +__transport_register_session (se_tpg, se_nacl, se_sess, fabric_sess_ptr); +spin_unlock_bh (&se_tpg->session_lock); +} +EXPORT_SYMBOL (transport_register_session); + +void transport_deregister_session_configfs (se_session_t *se_sess) +{ +se_node_acl_t *se_nacl; + +/* +* Used by se_node_acl_t's under ConfigFS to locate active se_session_t +*/ + se_nacl = se_sess->se_node_acl; +if ((se_nacl)) { +spin_lock_bh (&se_nacl->nacl_sess_lock); + se_nacl->nacl_sess =NULL ; +spin_unlock_bh (&se_nacl->nacl_sess_lock); + } +} +EXPORT_SYMBOL (transport_deregister_session_configfs); + +void transport_free_session (se_session_t *se_sess) +{ +kmem_cache_free (se_sess_cache, se_sess); +} +EXPORT_SYMBOL (transport_free_session); + +void transport_deregister_session (se_session_t *se_sess) +{ +se_portal_group_t *se_tpg = se_sess->se_tpg; +se_node_acl_t *se_nacl; + +if (!(se_tpg)) { +transport_free_session (se_sess); +return ; + } + +spin_lock_bh (&se_tpg->session_lock); +list_del (&se_sess->sess_list); + se_sess->se_tpg =NULL ; + se_sess->fabric_sess_ptr =NULL ; +spin_unlock_bh (&se_tpg->session_lock); + +/* +* Determine if we need to do extra work for this initiator node's +* se_node_acl_t if it had been previously dynamically generated. +*/ + se_nacl = se_sess->se_node_acl; +if ((se_nacl)) { +spin_lock_bh (&se_tpg->acl_node_lock); +if (se_nacl->nodeacl_flags &NAF_DYNAMIC_NODE_ACL ) { +if (!(TPG_TFO (se_tpg)->tpg_check_demo_mode_cache ( + se_tpg))) { +list_del (&se_nacl->acl_list); + se_tpg->num_node_acls--; +spin_unlock_bh (&se_tpg->acl_node_lock); +core_free_device_list_for_node (se_nacl, se_tpg); +TPG_TFO (se_tpg)->tpg_release_fabric_acl (se_tpg, + se_nacl); +kfree (se_nacl); +spin_lock_bh (&se_tpg->acl_node_lock); + } + } +spin_unlock_bh (&se_tpg->acl_node_lock); + } + +transport_free_session (se_sess); + +printk (KERN_INFO "TARGET_CORE[%s]: Deregistered fabric_sess\n" , +TPG_TFO (se_tpg)->get_fabric_name ()); +} +EXPORT_SYMBOL (transport_deregister_session); + +/* +* Called with T_TASK(cmd)->t_state_lock held. +*/ +static void transport_all_task_dev_remove_state (se_cmd_t *cmd) +{ +se_device_t *dev; +se_task_t *task; +unsigned long flags; + +if (!T_TASK (cmd)) +return ; + +list_for_each_entry (task, &T_TASK (cmd)->t_task_list, t_list) { + dev = task->se_dev; +if (!(dev)) +continue ; + +if (atomic_read (&task->task_active)) +continue ; + +if (!(atomic_read (&task->task_state_active))) +continue ; + +spin_lock_irqsave (&dev->execute_task_lock, flags); +list_del (&task->t_state_list); +DEBUG_TSTATE ("Removed ITT: 0x%08x dev: %p task[%p]\n" , +CMD_TFO (cmd)->tfo_get_task_tag (cmd), dev, task); +spin_unlock_irqrestore (&dev->execute_task_lock, flags); + +atomic_set (&task->task_state_active,0 ); +atomic_dec (&T_TASK (cmd)->t_task_cdbs_ex_left); + } +} + +/* +* Called with T_TASK(cmd)->t_state_lock held. +*/ +void transport_task_dev_remove_state (se_task_t *task,se_device_t *dev) +{ +se_cmd_t *cmd = task->task_se_cmd; +unsigned long flags; + +/* +* We cannot remove the task from the state list while said task is +* still active and probably timed out. +*/ +if (atomic_read (&task->task_active)) { +#if 0 +printk (KERN_ERR "Skipping Removal of state for ITT: 0x%08x" +" dev: %p task[%p]\n" +CMD_TFO (task->task_se_cmd)->tfo_get_task_tag ( + task->task_se_cmd), dev, task); +#endif +return ; + } + +if (atomic_read (&task->task_state_active)) { +spin_lock_irqsave (&dev->execute_task_lock, flags); +list_del (&task->t_state_list); +DEBUG_TSTATE ("Removed ITT: 0x%08x dev: %p task[%p]\n" , +CMD_TFO (task->task_se_cmd)->tfo_get_task_tag ( + task->task_se_cmd), dev, task); +spin_unlock_irqrestore (&dev->execute_task_lock, flags); + +atomic_set (&task->task_state_active,0 ); +atomic_dec (&T_TASK (cmd)->t_task_cdbs_ex_left); + } +} + +static void transport_passthrough_check_stop (se_cmd_t *cmd) +{ +if (!(cmd->se_cmd_flags &SCF_CMD_PASSTHROUGH )) +return ; + +if (!cmd->transport_passthrough_done) { +if (cmd->callback) { + cmd->callback (cmd, cmd->callback_arg, +transport_passthrough_complete (cmd)); + }else +complete (&T_TASK (cmd)->t_transport_passthrough_comp); + +return ; + } + + cmd->transport_passthrough_done (cmd); +} + +/* transport_cmd_check_stop(): +* +* 'transport_off = 1' determines if t_transport_active should be cleared. +* 'transport_off = 2' determines if task_dev_state should be removed. +* +* A non-zero u8 t_state sets cmd->t_state. +* Returns 1 when command is stopped, else 0. +*/ +static int transport_cmd_check_stop ( +se_cmd_t *cmd, +int transport_off, +u8 t_state) +{ +unsigned long flags; + +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); +/* +* Determine if IOCTL context caller in requesting the stopping of this +* command for LUN shutdown purposes. +*/ +if (atomic_read (&T_TASK (cmd)->transport_lun_stop)) { +DEBUG_CS ("%s:%d atomic_read(&T_TASK(cmd)->transport_lun_stop)" +" == TRUE for ITT: 0x%08x\n" , __func__, __LINE__, +CMD_TFO (cmd)->get_task_tag (cmd)); + + cmd->deferred_t_state = cmd->t_state; + cmd->t_state =TRANSPORT_DEFERRED_CMD ; +atomic_set (&T_TASK (cmd)->t_transport_active,0 ); +if (transport_off ==2 ) +transport_all_task_dev_remove_state (cmd); +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + +complete (&T_TASK (cmd)->transport_lun_stop_comp); +return 1 ; + } +/* +* Determine if frontend context caller is requesting the stopping of +* this command for frontend excpections. +*/ +if (atomic_read (&T_TASK (cmd)->t_transport_stop)) { +DEBUG_CS ("%s:%d atomic_read(&T_TASK(cmd)->t_transport_stop) ==" +" TRUE for ITT: 0x%08x\n" , __func__, __LINE__, +CMD_TFO (cmd)->get_task_tag (cmd)); + + cmd->deferred_t_state = cmd->t_state; + cmd->t_state =TRANSPORT_DEFERRED_CMD ; +if (transport_off ==2 ) +transport_all_task_dev_remove_state (cmd); + +/* +* Clear se_cmd_t->se_lun before the transport_off == 2 handoff +* to FE. +*/ +if ((transport_off ==2 ) && !(cmd->se_cmd_flags & +SCF_CMD_PASSTHROUGH )) + cmd->se_lun =NULL ; +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + +complete (&T_TASK (cmd)->t_transport_stop_comp); +return 1 ; + } +if (transport_off) { +atomic_set (&T_TASK (cmd)->t_transport_active,0 ); +if (transport_off ==2 ) +transport_all_task_dev_remove_state (cmd); + +/* +* Clear se_cmd_t->se_lun before the transport_off == 2 handoff +* to FE. +*/ +if ((transport_off ==2 ) && !(cmd->se_cmd_flags & +SCF_CMD_PASSTHROUGH )) + cmd->se_lun =NULL ; +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + +return 0 ; + }else if (t_state) + cmd->t_state = t_state; +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + +return 0 ; +} + +static void transport_lun_remove_cmd (se_cmd_t *cmd) +{ +se_lun_t *lun =SE_LUN (cmd); +unsigned long flags; + +if (!lun) +return ; +/* +* Do not track passthrough se_cmd_t for now.. +*/ +if (cmd->se_cmd_flags &SCF_CMD_PASSTHROUGH ) +return ; + +spin_lock_irqsave (&lun->lun_cmd_lock, flags); +if (atomic_read (&T_TASK (cmd)->transport_lun_active)) { +list_del (&cmd->se_lun_list); +atomic_set (&T_TASK (cmd)->transport_lun_active,0 ); +#if 0 +printk (KERN_INFO "Removed ITT: 0x%08x from LUN LIST[%d]\n" +CMD_TFO (cmd)->get_task_tag (cmd), lun->unpacked_lun); +#endif + } +spin_unlock_irqrestore (&lun->lun_cmd_lock, flags); +} + +void transport_cmd_finish_abort (se_cmd_t *cmd,int remove) +{ +transport_remove_cmd_from_queue (cmd, +CMD_ORIG_OBJ_API (cmd)->get_queue_obj ( + cmd->se_orig_obj_ptr)); + +transport_lun_remove_cmd (cmd); + +if (!(transport_cmd_check_stop (cmd,1 ,0 ))) { +transport_passthrough_check_stop (cmd); +return ; + } +if (remove) +transport_generic_remove (cmd,0 ,0 ); +} + +void transport_cmd_finish_abort_tmr (se_cmd_t *cmd) +{ +transport_remove_cmd_from_queue (cmd, +CMD_ORIG_OBJ_API (cmd)->get_queue_obj ( + cmd->se_orig_obj_ptr)); + +if (!(transport_cmd_check_stop (cmd,1 ,0 ))) { +transport_passthrough_check_stop (cmd); +return ; + } +transport_generic_remove (cmd,0 ,0 ); +} + +int transport_add_cmd_to_queue ( +se_cmd_t *cmd, +se_queue_obj_t *qobj, +u8 t_state) +{ +se_queue_req_t *qr; +unsigned long flags; + + qr =kzalloc (sizeof (se_queue_req_t),GFP_ATOMIC ); +if (!(qr)) { +printk (KERN_ERR "Unable to allocate memory for" +" se_queue_req_t\n" ); +return -1 ; + } +INIT_LIST_HEAD (&qr->qr_list); + + qr->cmd = (void *)cmd; + qr->state = t_state; + +if (t_state) { +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); + cmd->t_state = t_state; +atomic_set (&T_TASK (cmd)->t_transport_active,1 ); +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + } + +spin_lock_irqsave (&qobj->cmd_queue_lock, flags); +list_add_tail (&qr->qr_list, &qobj->qobj_list); +atomic_inc (&T_TASK (cmd)->t_transport_queue_active); +spin_unlock_irqrestore (&qobj->cmd_queue_lock, flags); + +atomic_inc (&qobj->queue_cnt); +wake_up_interruptible (&qobj->thread_wq); +return 0 ; +} + +static int transport_add_cmd_to_dev_queue (se_cmd_t *cmd,u8 t_state) +{ +se_device_t *dev = cmd->se_dev; + +return transport_add_cmd_to_queue (cmd, dev->dev_queue_obj, t_state); +} + +/* +* Called with se_queue_obj_t->cmd_queue_lock held. +*/ +se_queue_req_t *__transport_get_qr_from_queue (se_queue_obj_t *qobj) +{ +se_cmd_t *cmd; +se_queue_req_t *qr =NULL ; + +if (list_empty (&qobj->qobj_list)) +return NULL ; + +list_for_each_entry (qr, &qobj->qobj_list, qr_list) +break ; + +if (qr->cmd) { + cmd = (se_cmd_t *)qr->cmd; +atomic_dec (&T_TASK (cmd)->t_transport_queue_active); + } +list_del (&qr->qr_list); +atomic_dec (&qobj->queue_cnt); + +return qr; +} + +se_queue_req_t *transport_get_qr_from_queue (se_queue_obj_t *qobj) +{ +se_cmd_t *cmd; +se_queue_req_t *qr; +unsigned long flags; + +spin_lock_irqsave (&qobj->cmd_queue_lock, flags); +if (list_empty (&qobj->qobj_list)) { +spin_unlock_irqrestore (&qobj->cmd_queue_lock, flags); +return NULL ; + } + +list_for_each_entry (qr, &qobj->qobj_list, qr_list) +break ; + +if (qr->cmd) { + cmd = (se_cmd_t *)qr->cmd; +atomic_dec (&T_TASK (cmd)->t_transport_queue_active); + } +list_del (&qr->qr_list); +atomic_dec (&qobj->queue_cnt); +spin_unlock_irqrestore (&qobj->cmd_queue_lock, flags); + +return qr; +} + +void transport_remove_cmd_from_queue (se_cmd_t *cmd,se_queue_obj_t *qobj) +{ +se_cmd_t *q_cmd; +se_queue_req_t *qr =NULL , *qr_p =NULL ; +unsigned long flags; + +spin_lock_irqsave (&qobj->cmd_queue_lock, flags); +if (!(atomic_read (&T_TASK (cmd)->t_transport_queue_active))) { +spin_unlock_irqrestore (&qobj->cmd_queue_lock, flags); +return ; + } + +list_for_each_entry_safe (qr, qr_p, &qobj->qobj_list, qr_list) { + q_cmd = (se_cmd_t *)qr->cmd; +if (q_cmd != cmd) +continue ; + +atomic_dec (&T_TASK (q_cmd)->t_transport_queue_active); +atomic_dec (&qobj->queue_cnt); +list_del (&qr->qr_list); +kfree (qr); + } +spin_unlock_irqrestore (&qobj->cmd_queue_lock, flags); + +if (atomic_read (&T_TASK (cmd)->t_transport_queue_active)) { +printk (KERN_ERR "ITT: 0x%08x t_transport_queue_active: %d\n" , +CMD_TFO (cmd)->get_task_tag (cmd), +atomic_read (&T_TASK (cmd)->t_transport_queue_active)); + } +} + +void transport_complete_cmd (se_cmd_t *cmd,int success) +{ +int t_state; +unsigned long flags; + +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); +if (!success) { + cmd->transport_error_status =PYX_TRANSPORT_LU_COMM_FAILURE ; + t_state =TRANSPORT_COMPLETE_FAILURE ; + }else { + t_state =TRANSPORT_COMPLETE_OK ; + } +atomic_set (&T_TASK (cmd)->t_transport_complete,1 ); +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + + cmd->transport_add_cmd_to_queue (cmd, t_state); +} + +/* transport_complete_task(): +* +* Called from interrupt and non interrupt context depending +* on the transport plugin. +*/ +void transport_complete_task (se_task_t *task,int success) +{ +se_cmd_t *cmd =TASK_CMD (task); +se_device_t *dev = task->se_dev; +int t_state; +unsigned long flags; +#if 0 +printk (KERN_INFO "task: %p CDB: 0x%02x obj_ptr: %p\n" , task, +T_TASK (cmd)->t_task_cdb[0 ], dev); +#endif +if (dev) { +spin_lock_irqsave (&SE_HBA (dev)->hba_queue_lock, flags); +atomic_inc (&dev->depth_left); +atomic_inc (&SE_HBA (dev)->left_queue_depth); +spin_unlock_irqrestore (&SE_HBA (dev)->hba_queue_lock, flags); + } + +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); +atomic_set (&task->task_active,0 ); + +/* +* See if any sense data exists, if so set the TASK_SENSE flag. +* Also check for any other post completion work that needs to be +* done by the plugins. +*/ +if (!dev) + goto check_task_stop; + +if (TRANSPORT (dev)->transport_complete (task) !=0 ) { + cmd->se_cmd_flags |=SCF_TRANSPORT_TASK_SENSE ; + task->task_sense =1 ; + success =1 ; + } + +/* +* See if we are waiting for outstanding se_task_t +* to complete for an exception condition +*/ +check_task_stop: +if (atomic_read (&task->task_stop)) { +/* +* Decrement T_TASK(cmd)->t_se_count if this task had +* previously thrown its timeout exception handler. +*/ +if (atomic_read (&task->task_timeout)) { +atomic_dec (&T_TASK (cmd)->t_se_count); +atomic_set (&task->task_timeout,0 ); + } +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + +complete (&task->task_stop_comp); +return ; + } +/* +* If the task's timeout handler has fired, use the t_task_cdbs_timeout +* left counter to determine when the se_cmd_t is ready to be queued to +* the processing thread. +*/ +if (atomic_read (&task->task_timeout)) { +if (!(atomic_dec_and_test ( + &T_TASK (cmd)->t_task_cdbs_timeout_left))) { +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, + flags); +return ; + } + t_state =TRANSPORT_COMPLETE_TIMEOUT ; +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + + cmd->transport_add_cmd_to_queue (cmd, t_state); +return ; + } +atomic_dec (&T_TASK (cmd)->t_task_cdbs_timeout_left); + +#ifdef DEBUG_DEV +if (dev) { +if (__iscsi_debug_dev (dev) !=0 ) { + success =0 ; + task->task_scsi_status =1 ; + cmd->transport_error_status = +PYX_TRANSPORT_LU_COMM_FAILURE ; + } + } +#endif /* DEBUG_DEV */ + +/* +* Decrement the outstanding t_task_cdbs_left count. The last +* se_task_t from se_cmd_t will complete itself into the +* device queue depending upon int success. +*/ +if (!(atomic_dec_and_test (&T_TASK (cmd)->t_task_cdbs_left))) { +if (!success) +T_TASK (cmd)->t_tasks_failed =1 ; + +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); +return ; + } + +if (!success ||T_TASK (cmd)->t_tasks_failed) { + t_state =TRANSPORT_COMPLETE_FAILURE ; +if (!task->task_error_status) { + task->task_error_status = +PYX_TRANSPORT_UNKNOWN_SAM_OPCODE ; + cmd->transport_error_status = +PYX_TRANSPORT_UNKNOWN_SAM_OPCODE ; + } + }else { +atomic_set (&T_TASK (cmd)->t_transport_complete,1 ); + t_state =TRANSPORT_COMPLETE_OK ; + } +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + + cmd->transport_add_cmd_to_queue (cmd, t_state); +} + +/* +* Called by transport_add_tasks_from_cmd() once a se_cmd_t's +* se_task_t list are ready to be added to the active execution list +* se_device_t + +* Called with se_dev_t->execute_task_lock called. +*/ +static inline int transport_add_task_check_sam_attr ( +se_task_t *task, +se_task_t *task_prev, +se_device_t *dev) +{ +/* +* No SAM Task attribute emulation enabled, add to tail of +* execution queue +*/ +if (dev->dev_task_attr_type !=SAM_TASK_ATTR_EMULATED ) { +list_add_tail (&task->t_execute_list, &dev->execute_task_list); +return 0 ; + } +/* +* HEAD_OF_QUEUE attribute for received CDB, which means +* the first task that is associated with a se_cmd_t goes to +* head of the se_device_t->execute_task_list, and task_prev +* after that for each subsequent task +*/ +if (task->task_se_cmd->sam_task_attr ==TASK_ATTR_HOQ ) { +list_add (&task->t_execute_list, + (task_prev !=NULL ) ? + &task_prev->t_execute_list : + &dev->execute_task_list); + +DEBUG_STA ("Set HEAD_OF_QUEUE for task CDB: 0x%02x" +" in execution queue\n" , +T_TASK (task->task_se_cmd)->t_task_cdb[0 ]); +return 1 ; + } +/* +* For ORDERED, SIMPLE or UNTAGGED attribute tasks once they have been +* transitioned from Dermant -> Active state, and are added to the end +* of the se_device_t->execute_task_list +*/ +list_add_tail (&task->t_execute_list, &dev->execute_task_list); +return 0 ; +} + +/* __transport_add_task_to_execute_queue(): +* +* Called with se_dev_t->execute_task_lock called. +*/ +static void __transport_add_task_to_execute_queue ( +se_task_t *task, +se_task_t *task_prev, +se_device_t *dev) +{ +int head_of_queue; + + head_of_queue =transport_add_task_check_sam_attr (task, task_prev, dev); +atomic_inc (&dev->execute_tasks); + +if (atomic_read (&task->task_state_active)) +return ; +/* +* Determine if this task needs to go to HEAD_OF_QUEUE for the +* state list as well. Running with SAM Task Attribute emulation +* will always return head_of_queue == 0 here +*/ +if (head_of_queue) +list_add (&task->t_state_list, (task_prev) ? + &task_prev->t_state_list : + &dev->state_task_list); +else +list_add_tail (&task->t_state_list, &dev->state_task_list); + +atomic_set (&task->task_state_active,1 ); + +DEBUG_TSTATE ("Added ITT: 0x%08x task[%p] to dev: %p\n" , +CMD_TFO (task->task_se_cmd)->get_task_tag (task->task_se_cmd), + task, dev); +} + +static void transport_add_tasks_to_state_queue (se_cmd_t *cmd) +{ +se_device_t *dev; +se_task_t *task; +unsigned long flags; + +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); +list_for_each_entry (task, &T_TASK (cmd)->t_task_list, t_list) { + dev = task->se_dev; + +if (atomic_read (&task->task_state_active)) +continue ; + +spin_lock (&dev->execute_task_lock); +list_add_tail (&task->t_state_list, &dev->state_task_list); +atomic_set (&task->task_state_active,1 ); + +DEBUG_TSTATE ("Added ITT: 0x%08x task[%p] to dev: %p\n" , +CMD_TFO (task->task_se_cmd)->get_task_tag ( + task->task_se_cmd), task, dev); + +spin_unlock (&dev->execute_task_lock); + } +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); +} + +/* transport_add_tasks_from_cmd(): +* +* +*/ +void transport_add_tasks_from_cmd (se_cmd_t *cmd) +{ +se_device_t *dev =SE_DEV (cmd); +se_task_t *task, *task_prev =NULL ; +unsigned long flags; + +spin_lock_irqsave (&dev->execute_task_lock, flags); +list_for_each_entry (task, &T_TASK (cmd)->t_task_list, t_list) { +if (atomic_read (&task->task_execute_queue)) +continue ; +/* +* __transport_add_task_to_execute_queue() handles the +* SAM Task Attribute emulation if enabled +*/ +__transport_add_task_to_execute_queue (task, task_prev, dev); +atomic_set (&task->task_execute_queue,1 ); + task_prev = task; + } +spin_unlock_irqrestore (&dev->execute_task_lock, flags); + +return ; +} + +/* transport_get_task_from_execute_queue(): +* +* Called with dev->execute_task_lock held. +*/ +se_task_t *transport_get_task_from_execute_queue (se_device_t *dev) +{ +se_task_t *task; + +if (list_empty (&dev->execute_task_list)) +return NULL ; + +list_for_each_entry (task, &dev->execute_task_list, t_execute_list) +break ; + +list_del (&task->t_execute_list); +atomic_dec (&dev->execute_tasks); + +return task; +} + +/* transport_remove_task_from_execute_queue(): +* +* +*/ +static void transport_remove_task_from_execute_queue ( +se_task_t *task, +se_device_t *dev) +{ +unsigned long flags; + +spin_lock_irqsave (&dev->execute_task_lock, flags); +list_del (&task->t_execute_list); +atomic_dec (&dev->execute_tasks); +spin_unlock_irqrestore (&dev->execute_task_lock, flags); +} + +/* transport_check_device_tcq(): +* +* +*/ +int transport_check_device_tcq ( +se_device_t *dev, +u32 unpacked_lun, +u32 device_tcq) +{ +if (device_tcq > dev->queue_depth) { +printk (KERN_ERR "Attempting to set storage device queue depth" +" to %d while transport maximum is %d on LUN: %u," +" ignoring request\n" , device_tcq, dev->queue_depth, + unpacked_lun); +return -1 ; + }else if (!device_tcq) { +printk (KERN_ERR "Attempting to set storage device queue depth" +" to 0 on LUN: %u, ignoring request\n" , unpacked_lun); +return -1 ; + } + + dev->queue_depth = device_tcq; +atomic_set (&dev->depth_left, dev->queue_depth); +printk (KERN_INFO "Reset Device Queue Depth to %u for Logical Unit" +" Number: %u\n" , dev->queue_depth, unpacked_lun); + +return 0 ; +} +EXPORT_SYMBOL (transport_check_device_tcq); + +unsigned char *transport_dump_cmd_direction (se_cmd_t *cmd) +{ +switch (cmd->data_direction) { +case SE_DIRECTION_NONE : +return "NONE" ; +case SE_DIRECTION_READ : +return "READ" ; +case SE_DIRECTION_WRITE : +return "WRITE" ; +case SE_DIRECTION_BIDI : +return "BIDI" ; +default : +break ; + } + +return "UNKNOWN" ; +} + +void transport_dump_dev_state ( +se_device_t *dev, +char *b, +int *bl) +{ + *bl +=sprintf (b + *bl,"Status: " ); +switch (dev->dev_status) { +case TRANSPORT_DEVICE_ACTIVATED : + *bl +=sprintf (b + *bl,"ACTIVATED" ); +break ; +case TRANSPORT_DEVICE_DEACTIVATED : + *bl +=sprintf (b + *bl,"DEACTIVATED" ); +break ; +case TRANSPORT_DEVICE_SHUTDOWN : + *bl +=sprintf (b + *bl,"SHUTDOWN" ); +break ; +case TRANSPORT_DEVICE_OFFLINE_ACTIVATED : +case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED : + *bl +=sprintf (b + *bl,"OFFLINE" ); +break ; +default : + *bl +=sprintf (b + *bl,"UNKNOWN=%d" , dev->dev_status); +break ; + } + + *bl +=sprintf (b + *bl," Execute/Left/Max Queue Depth: %d/%d/%d" , +atomic_read (&dev->execute_tasks),atomic_read (&dev->depth_left), + dev->queue_depth); + *bl +=sprintf (b + *bl," SectorSize: %u MaxSectors: %u\n" , +DEV_ATTRIB (dev)->block_size,DEV_ATTRIB (dev)->max_sectors); + *bl +=sprintf (b + *bl," " ); +} + +void transport_dump_dev_info ( +se_device_t *dev, +se_lun_t *lun, +unsigned long long total_bytes, +char *b,/* Pointer to info buffer */ +int *bl) +{ +se_subsystem_api_t *t; +int ret =0 ; + + t = (se_subsystem_api_t *)plugin_get_obj (PLUGIN_TYPE_TRANSPORT , + dev->type, &ret); +if (!t || (ret !=0 )) +return ; + + t->get_dev_info (dev, b, bl); + *bl +=sprintf (b + *bl," " ); + *bl +=sprintf (b + *bl,"Type: %s " , +scsi_device_type (TRANSPORT (dev)->get_device_type (dev))); + *bl +=sprintf (b + *bl,"ANSI SCSI revision: %02x " , +TRANSPORT (dev)->get_device_rev (dev)); + +if (DEV_OBJ_API (dev)->get_t10_wwn) { +t10_wwn_t *wwn =DEV_OBJ_API (dev)->get_t10_wwn ((void *)dev); + + *bl +=sprintf (b + *bl,"Unit Serial: %s " , + ((strlen (wwn->unit_serial) !=0 ) ? + (char *)wwn->unit_serial :"None" )); + } + *bl +=sprintf (b + *bl,"%s" ,"DIRECT" ); + +if ((DEV_OBJ_API (dev)->check_count (&dev->dev_access_obj)) || + (DEV_OBJ_API (dev)->check_count (&dev->dev_feature_obj))) + *bl +=sprintf (b + *bl," ACCESSED\n" ); +else if (DEV_OBJ_API (dev)->check_count (&dev->dev_export_obj)) + *bl +=sprintf (b + *bl," EXPORTED\n" ); +else + *bl +=sprintf (b + *bl," FREE\n" ); + +if (lun) { + *bl +=sprintf (b + *bl," Core Host ID: %u LUN: %u" , + dev->se_hba->hba_id, lun->unpacked_lun); +if (!(TRANSPORT (dev)->get_device_type (dev))) { + *bl +=sprintf (b + *bl," Active Cmds: %d Total Bytes" +": %llu\n" ,atomic_read (&dev->active_cmds), + total_bytes); + }else { + *bl +=sprintf (b + *bl," Active Cmds: %d\n" , +atomic_read (&dev->active_cmds)); + } + }else { +if (!(TRANSPORT (dev)->get_device_type (dev))) { + *bl +=sprintf (b + *bl," Core Host ID: %u" +" Active Cmds: %d Total Bytes: %llu\n" , + dev->se_hba->hba_id, +atomic_read (&dev->active_cmds), total_bytes); + }else { + *bl +=sprintf (b + *bl," CoreI Host ID: %u" +" Active Cmds: %d\n" , dev->se_hba->hba_id, +atomic_read (&dev->active_cmds)); + } + } +} + +/* transport_release_all_cmds(): +* +* +*/ +static void transport_release_all_cmds (se_device_t *dev) +{ +se_cmd_t *cmd =NULL ; +se_queue_req_t *qr =NULL , *qr_p =NULL ; +int bug_out =0 , t_state; +unsigned long flags; + +spin_lock_irqsave (&dev->dev_queue_obj->cmd_queue_lock, flags); +list_for_each_entry_safe (qr, qr_p, &dev->dev_queue_obj->qobj_list, + qr_list) { + + cmd = (se_cmd_t *)qr->cmd; + t_state = qr->state; +list_del (&qr->qr_list); +kfree (qr); +spin_unlock_irqrestore (&dev->dev_queue_obj->cmd_queue_lock, + flags); + +printk (KERN_ERR "Releasing %s ITT: 0x%08x, i_state: %u," +" t_state: %u directly\n" , + (cmd->se_cmd_flags &SCF_CMD_PASSTHROUGH ) ? +"Passthrough" :"Normal" , +CMD_TFO (cmd)->get_task_tag (cmd), +CMD_TFO (cmd)->get_cmd_state (cmd), t_state); + +transport_release_fe_cmd (cmd); + bug_out =1 ; + +spin_lock_irqsave (&dev->dev_queue_obj->cmd_queue_lock, flags); + } +spin_unlock_irqrestore (&dev->dev_queue_obj->cmd_queue_lock, flags); +#if 0 +if (bug_out) +BUG (); +#endif +} + +/* transport_dev_write_pending_nop(): +* +* +*/ +static int transport_dev_write_pending_nop (se_task_t *task) +{ +return 0 ; +} + +static int transport_get_inquiry ( +se_obj_lun_type_t *obj_api, +t10_wwn_t *wwn, +void *obj_ptr) +{ +se_cmd_t *cmd; +unsigned char *buf; +int i; +unsigned char cdb[SCSI_CDB_SIZE ]; + +memset (cdb,0 ,SCSI_CDB_SIZE ); + cdb[0 ] =INQUIRY ; + cdb[3 ] = (INQUIRY_LEN >>8 ) &0xff ; + cdb[4 ] = (INQUIRY_LEN &0xff ); + + cmd =transport_allocate_passthrough (&cdb[0 ],SE_DIRECTION_READ , +0 ,NULL ,0 ,INQUIRY_LEN , obj_api, obj_ptr); +if (!(cmd)) +return -1 ; + +if (transport_generic_passthrough (cmd) <0 ) { +transport_passthrough_release (cmd); +return -1 ; + } + + buf = (unsigned char *)T_TASK (cmd)->t_task_buf; +/* +* Save the basic Vendor, Model and Revision in passed t10_wwn_t. +* We will obtain the VPD in a seperate passthrough operation. +*/ +memcpy ((void *)&wwn->vendor[0 ], (void *)&buf[8 ], +sizeof (wwn->vendor)); +memcpy ((void *)&wwn->model[0 ], (void *)&buf[16 ], +sizeof (wwn->model)); +memcpy ((void *)&wwn->revision[0 ], (void *)&buf[32 ], +sizeof (wwn->revision)); + +printk (" Vendor: " ); +for (i =8 ; i <16 ; i++) +if (buf[i] >=0x20 && i < buf[4 ] +5 ) +printk ("%c" , buf[i]); +else +printk (" " ); + +printk (" Model: " ); +for (i =16 ; i <32 ; i++) +if (buf[i] >=0x20 && i < buf[4 ] +5 ) +printk ("%c" , buf[i]); +else +printk (" " ); + +printk (" Revision: " ); +for (i =32 ; i <36 ; i++) +if (buf[i] >=0x20 && i < buf[4 ] +5 ) +printk ("%c" , buf[i]); +else +printk (" " ); + +printk ("\n" ); + + i = buf[0 ] &0x1f ; + +printk (" Type: %s " ,scsi_device_type (i)); +printk (" ANSI SCSI revision: %02x" , + buf[2 ] &0x07 ); +if ((buf[2 ] &0x07 ) ==1 && (buf[3 ] &0x0f ) ==1 ) +printk (" CCS\n" ); +else +printk ("\n" ); + +transport_passthrough_release (cmd); +return 0 ; +} + +static int transport_get_inquiry_vpd_serial ( +se_obj_lun_type_t *obj_api, +t10_wwn_t *wwn, +void *obj_ptr) +{ +unsigned char *buf; +se_cmd_t *cmd; +unsigned char cdb[SCSI_CDB_SIZE ]; + +memset (cdb,0 ,SCSI_CDB_SIZE ); + cdb[0 ] =INQUIRY ; + cdb[1 ] =0x01 ;/* Query VPD */ + cdb[2 ] =0x80 ;/* Unit Serial Number */ + cdb[3 ] = (INQUIRY_VPD_SERIAL_LEN >>8 ) &0xff ; + cdb[4 ] = (INQUIRY_VPD_SERIAL_LEN &0xff ); + + cmd =transport_allocate_passthrough (&cdb[0 ],SE_DIRECTION_READ , +0 ,NULL ,0 ,INQUIRY_VPD_SERIAL_LEN , obj_api, obj_ptr); +if (!(cmd)) +return -1 ; + +if (transport_generic_passthrough (cmd) <0 ) { +transport_passthrough_release (cmd); +return -1 ; + } + + buf = (unsigned char *)T_TASK (cmd)->t_task_buf; + +printk (KERN_INFO "T10 VPD Unit Serial Number: %s\n" , &buf[4 ]); +snprintf (&wwn->unit_serial[0 ],INQUIRY_VPD_SERIAL_LEN ,"%s" , &buf[4 ]); + +transport_passthrough_release (cmd); +return 0 ; +} + +static const char hex_str[] ="0123456789abcdef" ; + +void transport_dump_vpd_proto_id ( +t10_vpd_t *vpd, +unsigned char *p_buf, +int p_buf_len) +{ +unsigned char buf[VPD_TMP_BUF_SIZE ]; +int len; + +memset (buf,0 ,VPD_TMP_BUF_SIZE ); + len =sprintf (buf,"T10 VPD Protocol Identifier: " ); + +switch (vpd->protocol_identifier) { +case 0x00 : +sprintf (buf+len,"Fibre Channel\n" ); +break ; +case 0x10 : +sprintf (buf+len,"Parallel SCSI\n" ); +break ; +case 0x20 : +sprintf (buf+len,"SSA\n" ); +break ; +case 0x30 : +sprintf (buf+len,"IEEE 1394\n" ); +break ; +case 0x40 : +sprintf (buf+len,"SCSI Remote Direct Memory Access" +" Protocol\n" ); +break ; +case 0x50 : +sprintf (buf+len,"Internet SCSI (iSCSI)\n" ); +break ; +case 0x60 : +sprintf (buf+len,"SAS Serial SCSI Protocol\n" ); +break ; +case 0x70 : +sprintf (buf+len,"Automation/Drive Interface Transport" +" Protocol\n" ); +break ; +case 0x80 : +sprintf (buf+len,"AT Attachment Interface ATA/ATAPI\n" ); +break ; +default : +sprintf (buf+len,"Unknown 0x%02x\n" , + vpd->protocol_identifier); +break ; + } + +if (p_buf) +strncpy (p_buf, buf, p_buf_len); +else +printk (KERN_INFO "%s" , buf); +} + +void transport_set_vpd_proto_id (t10_vpd_t *vpd,unsigned char *page_83) +{ +/* +* Check if the Protocol Identifier Valid (PIV) bit is set.. +* +* from spc3r23.pdf section 7.5.1 +*/ +if (page_83[1 ] &0x80 ) { + vpd->protocol_identifier = (page_83[0 ] &0xf0 ); + vpd->protocol_identifier_set =1 ; +transport_dump_vpd_proto_id (vpd,NULL ,0 ); + } +} + +int transport_dump_vpd_assoc ( +t10_vpd_t *vpd, +unsigned char *p_buf, +int p_buf_len) +{ +unsigned char buf[VPD_TMP_BUF_SIZE ]; +int ret =0 , len; + +memset (buf,0 ,VPD_TMP_BUF_SIZE ); + len =sprintf (buf,"T10 VPD Identifier Association: " ); + +switch (vpd->association) { +case 0x00 : +sprintf (buf+len,"addressed logical unit\n" ); +break ; +case 0x10 : +sprintf (buf+len,"target port\n" ); +break ; +case 0x20 : +sprintf (buf+len,"SCSI target device\n" ); +break ; +default : +sprintf (buf+len,"Unknown 0x%02x\n" , vpd->association); + ret =-1 ; +break ; + } + +if (p_buf) +strncpy (p_buf, buf, p_buf_len); +else +printk ("%s" , buf); + +return ret; +} + +static int transport_set_vpd_assoc (t10_vpd_t *vpd,unsigned char *page_83) +{ +/* +* The VPD identification association.. +* +* from spc3r23.pdf Section 7.6.3.1 Table 297 +*/ + vpd->association = (page_83[1 ] &0x30 ); +return transport_dump_vpd_assoc (vpd,NULL ,0 ); +} + +int transport_dump_vpd_ident_type ( +t10_vpd_t *vpd, +unsigned char *p_buf, +int p_buf_len) +{ +unsigned char buf[VPD_TMP_BUF_SIZE ]; +int ret =0 , len; + +memset (buf,0 ,VPD_TMP_BUF_SIZE ); + len =sprintf (buf,"T10 VPD Identifier Type: " ); + +switch (vpd->device_identifier_type) { +case 0x00 : +sprintf (buf+len,"Vendor specific\n" ); +break ; +case 0x01 : +sprintf (buf+len,"T10 Vendor ID based\n" ); +break ; +case 0x02 : +sprintf (buf+len,"EUI-64 based\n" ); +break ; +case 0x03 : +sprintf (buf+len,"NAA\n" ); +break ; +case 0x04 : +sprintf (buf+len,"Relative target port identifier\n" ); +break ; +case 0x08 : +sprintf (buf+len,"SCSI name string\n" ); +break ; +default : +sprintf (buf+len,"Unsupported: 0x%02x\n" , + vpd->device_identifier_type); + ret =-1 ; +break ; + } + +if (p_buf) +strncpy (p_buf, buf, p_buf_len); +else +printk ("%s" , buf); + +return ret; +} + +int transport_set_vpd_ident_type (t10_vpd_t *vpd,unsigned char *page_83) +{ +/* +* The VPD identifier type.. +* +* from spc3r23.pdf Section 7.6.3.1 Table 298 +*/ + vpd->device_identifier_type = (page_83[1 ] &0x0f ); +return transport_dump_vpd_ident_type (vpd,NULL ,0 ); +} + +int transport_dump_vpd_ident ( +t10_vpd_t *vpd, +unsigned char *p_buf, +int p_buf_len) +{ +unsigned char buf[VPD_TMP_BUF_SIZE ]; +int ret =0 ; + +memset (buf,0 ,VPD_TMP_BUF_SIZE ); + +switch (vpd->device_identifier_code_set) { +case 0x01 :/* Binary */ +sprintf (buf,"T10 VPD Binary Device Identifier: %s\n" , + &vpd->device_identifier[0 ]); +break ; +case 0x02 :/* ASCII */ +sprintf (buf,"T10 VPD ASCII Device Identifier: %s\n" , + &vpd->device_identifier[0 ]); +break ; +case 0x03 :/* UTF-8 */ +sprintf (buf,"T10 VPD UTF-8 Device Identifier: %s\n" , + &vpd->device_identifier[0 ]); +break ; +default : +sprintf (buf,"T10 VPD Device Identifier encoding unsupported:" +" 0x%02x" , vpd->device_identifier_code_set); + ret =-1 ; +break ; + } + +if (p_buf) +strncpy (p_buf, buf, p_buf_len); +else +printk ("%s" , buf); + +return ret; +} + +int transport_set_vpd_ident (t10_vpd_t *vpd,unsigned char *page_83) +{ +int j =0 , i =4 ;/* offset to start of the identifer */ + +/* +* The VPD Code Set (encoding) +* +* from spc3r23.pdf Section 7.6.3.1 Table 296 +*/ + vpd->device_identifier_code_set = (page_83[0 ] &0x0f ); +switch (vpd->device_identifier_code_set) { +case 0x01 :/* Binary */ + vpd->device_identifier[j++] = + hex_str[vpd->device_identifier_type]; +while (i < (4 + page_83[3 ])) { + vpd->device_identifier[j++] = + hex_str[(page_83[i] &0xf0 ) >>4 ]; + vpd->device_identifier[j++] = + hex_str[page_83[i] &0x0f ]; + i++; + } +break ; +case 0x02 :/* ASCII */ +case 0x03 :/* UTF-8 */ +while (i < (4 + page_83[3 ])) + vpd->device_identifier[j++] = page_83[i++]; + +break ; +default : +break ; + } + +return transport_dump_vpd_ident (vpd,NULL ,0 ); +} + +static int transport_get_inquiry_vpd_device_ident ( +se_obj_lun_type_t *obj_api, +t10_wwn_t *wwn, +void *obj_ptr) +{ +unsigned char *buf, *page_83; +se_cmd_t *cmd; +t10_vpd_t *vpd; +unsigned char cdb[SCSI_CDB_SIZE ]; +int ident_len, page_len, off =4 , ret =0 ; + +memset (cdb,0 ,SCSI_CDB_SIZE ); + cdb[0 ] =INQUIRY ; + cdb[1 ] =0x01 ;/* Query VPD */ + cdb[2 ] =0x83 ;/* Device Identifier */ + cdb[3 ] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN >>8 ) &0xff ; + cdb[4 ] = (INQUIRY_VPD_DEVICE_IDENTIFIER_LEN &0xff ); + + cmd =transport_allocate_passthrough (&cdb[0 ],SE_DIRECTION_READ , +0 ,NULL ,0 ,INQUIRY_VPD_DEVICE_IDENTIFIER_LEN , + obj_api, obj_ptr); +if (!(cmd)) +return -1 ; + +if (transport_generic_passthrough (cmd) <0 ) { +transport_passthrough_release (cmd); +return -1 ; + } + + buf = (unsigned char *)T_TASK (cmd)->t_task_buf; + page_len = (buf[2 ] <<8 ) | buf[3 ]; +printk ("T10 VPD Page Length: %d\n" , page_len); + +while (page_len >0 ) { +/* Grab a pointer to the Identification descriptor */ + page_83 = &buf[off]; + ident_len = page_83[3 ]; +if (!(ident_len)) { +printk (KERN_ERR "page_83[3]: identifier" +" length zero!\n" ); +break ; + } +printk (KERN_INFO "T10 VPD Identifer Length: %d\n" , ident_len); + + vpd =kzalloc (sizeof (t10_vpd_t),GFP_KERNEL ); +if (!(vpd)) { +printk (KERN_ERR "Unable to allocate memory for" +" t10_vpd_t\n" ); + ret =-1 ; + goto out; + } +INIT_LIST_HEAD (&vpd->vpd_list); + +transport_set_vpd_proto_id (vpd, page_83); +transport_set_vpd_assoc (vpd, page_83); + +if (transport_set_vpd_ident_type (vpd, page_83) <0 ) { + off += (ident_len +4 ); + page_len -= (ident_len +4 ); +kfree (vpd); +continue ; + } +if (transport_set_vpd_ident (vpd, page_83) <0 ) { + off += (ident_len +4 ); + page_len -= (ident_len +4 ); +kfree (vpd); +continue ; + } + +list_add_tail (&vpd->vpd_list, &wwn->t10_vpd_list); + off += (ident_len +4 ); + page_len -= (ident_len +4 ); + } +out: +transport_passthrough_release (cmd); +return 0 ; +} + +int transport_rescan_evpd_device_ident ( +se_device_t *dev) +{ +se_release_vpd_for_dev (dev); +transport_get_inquiry_vpd_device_ident (DEV_OBJ_API (dev), +DEV_T10_WWN (dev), (void *)dev); +return 0 ; +} + +static int transport_get_read_capacity (se_device_t *dev) +{ +unsigned char cdb[SCSI_CDB_SIZE ], *buf; +u32 blocks, v1, v2; +se_cmd_t *cmd; +unsigned long long blocks_long; + +memset (cdb,0 ,SCSI_CDB_SIZE ); + cdb[0 ] =0x25 ;/* READ_CAPACITY */ + + cmd =transport_allocate_passthrough (&cdb[0 ],SE_DIRECTION_READ , +0 ,NULL ,0 ,READ_CAP_LEN ,DEV_OBJ_API (dev), + (void *)dev); +if (!(cmd)) +return -1 ; + +if (transport_generic_passthrough (cmd) <0 ) { +transport_passthrough_release (cmd); +return -1 ; + } + + buf = (unsigned char *)T_TASK (cmd)->t_task_buf; + blocks = (buf[0 ] <<24 ) | (buf[1 ] <<16 ) | (buf[2 ] <<8 ) | buf[3 ]; + +transport_passthrough_release (cmd); + +if (blocks !=0xFFFFFFFF ) { + dev->dev_sectors_total = blocks; + dev->dev_generate_cdb = &split_cdb_RW_10; +return 0 ; + } + +printk (KERN_INFO "READ_CAPACITY returned 0xFFFFFFFF, issuing" +" SAI_READ_CAPACITY_16\n" ); + +memset (cdb,0 ,SCSI_CDB_SIZE ); + cdb[0 ] =0x9e ;/* SERVICE_ACTION_IN */ + cdb[1 ] =0x10 ;/* SAI_READ_CAPACITY_16 */ + cdb[13 ] =12 ; + + cmd =transport_allocate_passthrough (&cdb[0 ],SE_DIRECTION_READ , +0 ,NULL ,0 ,12 ,DEV_OBJ_API (dev), (void *)dev); +if (!(cmd)) +return -1 ; + +if (transport_generic_passthrough (cmd) <0 ) { +transport_passthrough_release (cmd); +return -1 ; + } + + buf = (unsigned char *)T_TASK (cmd)->t_task_buf; + v1 = (buf[0 ] <<24 ) | (buf[1 ] <<16 ) | (buf[2 ] <<8 ) | buf[3 ]; + v2 = (buf[4 ] <<24 ) | (buf[5 ] <<16 ) | (buf[6 ] <<8 ) | buf[7 ]; + blocks_long = ((unsigned long long )v2 | (unsigned long long )v1 <<32 ); + +transport_passthrough_release (cmd); + + dev->dev_sectors_total = blocks_long; + dev->dev_generate_cdb = &split_cdb_RW_16; + +return 0 ; +} + +static void core_setup_task_attr_emulation (se_device_t *dev) +{ +/* +* If this device is from Target_Core_Mod/pSCSI, disable the +* SAM Task Attribute emulation. +* +* This is currently not available in upsream Linux/SCSI Target +* mode code, and is assumed to be disabled while using TCM/pSCSI. +*/ +if (TRANSPORT (dev)->transport_type ==TRANSPORT_PLUGIN_PHBA_PDEV ) { + dev->dev_task_attr_type =SAM_TASK_ATTR_PASSTHROUGH ; +return ; + } + + dev->dev_task_attr_type =SAM_TASK_ATTR_EMULATED ; +DEBUG_STA ("%s: Using SAM_TASK_ATTR_EMULATED for SPC: 0x%02x" +" device\n" ,TRANSPORT (dev)->name, +TRANSPORT (dev)->get_device_rev (dev)); +} + +/* transport_add_device_to_core_hba(): +* +* Note that some plugins (IBLOCK) will pass device_flags == +* DF_CLAIMED_BLOCKDEV signifying OS that a dependent block_device +* has been claimed. In exception cases we will release said +* block_device ourselves. +*/ +se_device_t *transport_add_device_to_core_hba ( +se_hba_t *hba, +se_subsystem_api_t *transport, +se_subsystem_dev_t *se_dev, +u32 device_flags, +void *transport_dev) +{ +int ret =0 ; +se_device_t *dev; + + dev =kzalloc (sizeof (se_device_t),GFP_KERNEL ); +if (!(dev)) { +printk (KERN_ERR "Unable to allocate memory for se_dev_t\n" ); +return NULL ; + } + dev->dev_queue_obj =kzalloc (sizeof (se_queue_obj_t),GFP_KERNEL ); +if (!(dev->dev_queue_obj)) { +printk (KERN_ERR "Unable to allocate memory for" +" dev->dev_queue_obj\n" ); +kfree (dev); +return NULL ; + } +transport_init_queue_obj (dev->dev_queue_obj); + + dev->dev_status_queue_obj =kzalloc (sizeof (se_queue_obj_t), +GFP_KERNEL ); +if (!(dev->dev_status_queue_obj)) { +printk (KERN_ERR "Unable to allocate memory for" +" dev->dev_status_queue_obj\n" ); +kfree (dev->dev_queue_obj); +kfree (dev); +return NULL ; + } +transport_init_queue_obj (dev->dev_status_queue_obj); + + dev->dev_flags = device_flags; + dev->dev_status |=TRANSPORT_DEVICE_DEACTIVATED ; + dev->type = transport->type; + dev->dev_ptr = (void *) transport_dev; + dev->se_hba = hba; + dev->se_sub_dev = se_dev; + dev->transport = transport; +atomic_set (&dev->active_cmds,0 ); +INIT_LIST_HEAD (&dev->dev_list); +INIT_LIST_HEAD (&dev->dev_sep_list); +INIT_LIST_HEAD (&dev->dev_tmr_list); +INIT_LIST_HEAD (&dev->execute_task_list); +INIT_LIST_HEAD (&dev->delayed_cmd_list); +INIT_LIST_HEAD (&dev->ordered_cmd_list); +INIT_LIST_HEAD (&dev->state_task_list); +spin_lock_init (&dev->execute_task_lock); +spin_lock_init (&dev->delayed_cmd_lock); +spin_lock_init (&dev->ordered_cmd_lock); +spin_lock_init (&dev->state_task_lock); +spin_lock_init (&dev->dev_alua_lock); +spin_lock_init (&dev->dev_reservation_lock); +spin_lock_init (&dev->dev_status_lock); +spin_lock_init (&dev->dev_status_thr_lock); +spin_lock_init (&dev->se_port_lock); +spin_lock_init (&dev->se_tmr_lock); + + dev->queue_depth =TRANSPORT (dev)->get_queue_depth (dev); +atomic_set (&dev->depth_left, dev->queue_depth); +atomic_set (&dev->dev_ordered_id,0 ); + +se_dev_set_default_attribs (dev); + + dev->write_pending = (transport->write_pending) ? + transport->write_pending : &transport_dev_write_pending_nop; + +#ifdef SNMP_SUPPORT + dev->dev_index =scsi_get_new_index (SCSI_DEVICE_INDEX ); + dev->creation_time =get_jiffies_64 (); +spin_lock_init (&dev->stats_lock); +#endif /* SNMP_SUPPORT */ + +spin_lock (&hba->device_lock); +list_add_tail (&dev->dev_list, &hba->hba_dev_list); + hba->dev_count++; +spin_unlock (&hba->device_lock); + +/* +* Get this se_device_t's API from the device object plugin. +*/ + dev->dev_obj_api =se_obj_get_api (TRANSPORT_LUN_TYPE_DEVICE ); +if (!(dev->dev_obj_api)) + goto out; +/* +* Setup the SAM Task Attribute emulation for se_device_t +*/ +core_setup_task_attr_emulation (dev); +/* +* Setup the Reservations infrastructure for se_device_t +*/ +core_setup_reservations (dev); +/* +* Setup the Asymmetric Logical Unit Assignment for se_device_t +*/ +if (core_setup_alua (dev) <0 ) + goto out; +/* +* Startup the se_device_t processing thread +*/ +if (transport_generic_activate_device (dev) <0 ) + goto out; +/* +* This HBA is reserved for internal storage engine / feature plugin use +*/ +if (hba->hba_flags &HBA_FLAGS_INTERNAL_USE ) { + ret =transport_get_read_capacity (dev); +if (ret <0 ) + goto out; + +return dev; + } + + ret =transport_get_inquiry (DEV_OBJ_API (dev), +DEV_T10_WWN (dev), (void *)dev); +if (ret <0 ) + goto out; +/* +* Locate VPD WWN Information used for various purposes within +* the Storage Engine. +*/ +if (!(transport_get_inquiry_vpd_serial (DEV_OBJ_API (dev), +DEV_T10_WWN (dev), (void *)dev))) { +/* +* If VPD Unit Serial returned GOOD status, try +* VPD Device Identification page (0x83). +*/ +transport_get_inquiry_vpd_device_ident (DEV_OBJ_API (dev), +DEV_T10_WWN (dev), (void *)dev); + } + +/* +* Only perform the volume scan for peripheral type TYPE_DISK +*/ +if (TRANSPORT (dev)->get_device_type (dev) !=0 ) +return dev; + +/* +* Get the sector count via READ_CAPACITY +*/ + ret =transport_get_read_capacity (dev); +if (ret <0 ) + goto out; +out: +if (!ret) +return dev; + +/* +* Release claim to OS dependant block_device that may have been +* set by plugin with passed dev_flags. +*/ +transport_generic_release_phydevice (dev,0 ); + +/* +* Release newly allocated state for se_device_t +*/ +transport_generic_deactivate_device (dev); + +spin_lock (&hba->device_lock); +list_del (&dev->dev_list); + hba->dev_count--; +spin_unlock (&hba->device_lock); + +se_release_vpd_for_dev (dev); + +kfree (dev->dev_status_queue_obj); +kfree (dev->dev_queue_obj); +kfree (dev); + +return NULL ; +} + +/* transport_generic_activate_device(): +* +* +*/ +int transport_generic_activate_device (se_device_t *dev) +{ +char name[16 ]; + +if (TRANSPORT (dev)->activate_device) +TRANSPORT (dev)->activate_device (dev); + +memset (name,0 ,16 ); +snprintf (name,16 ,"LIO_%s" ,TRANSPORT (dev)->name); + + dev->process_thread =kthread_run (transport_processing_thread, + (void *)dev, name); +if (IS_ERR (dev->process_thread)) { +printk (KERN_ERR "Unable to create kthread: %s\n" , name); +return -1 ; + } + +wait_for_completion (&dev->dev_queue_obj->thread_create_comp); + +return 0 ; +} + +/* transport_generic_deactivate_device(): +* +* +*/ +void transport_generic_deactivate_device (se_device_t *dev) +{ +if (TRANSPORT (dev)->deactivate_device) +TRANSPORT (dev)->deactivate_device (dev); + +kthread_stop (dev->process_thread); + +wait_for_completion (&dev->dev_queue_obj->thread_done_comp); +} + +/* transport_generic_claim_phydevice() +* +* Obtain exclusive access to OS dependant block-device via +* Storage Transport Plugin API. +* +* In Linux v2.6 this means calling fs/block_dev.c:bd_claim() +* that is called in an plugin dependent method for claiming +* struct block_device. +* +* Returns 0 - Already claimed or not able to claim +* Returns 1 - Successfuly claimed +* Returns < 0 - Error +*/ +int transport_generic_claim_phydevice (se_device_t *dev) +{ +int ret; +se_hba_t *hba; + +/* +* This function pointer is present when handling access +* control to a OS dependant block subsystem. +*/ +if (!TRANSPORT (dev)->claim_phydevice) +return 0 ; + +if (dev->dev_flags &DF_READ_ONLY ) +return 0 ; + +if (dev->dev_flags &DF_CLAIMED_BLOCKDEV ) +return 0 ; + + hba = dev->se_hba; +if (!(hba)) { +printk (KERN_ERR "se_device_t->se_hba is NULL!\n" ); +return -1 ; + } + + ret =TRANSPORT (dev)->claim_phydevice (hba, dev); +if (ret <0 ) +return ret; + + dev->dev_flags |=DF_CLAIMED_BLOCKDEV ; + +return 1 ; +} +EXPORT_SYMBOL (transport_generic_claim_phydevice); + +/* transport_generic_release_phydevice(): +* +* Release exclusive access from OS dependant block-device via +* Storage Transport Plugin API. +* +* In Linux v2.6 this means calling fs/block_dev.c:bd_release() +* see iscsi_target_pscsi.c and iscsi_target_iblock.c functions for +* se_subsystem_api_t->[claim,release]_phydevice() +*/ +void transport_generic_release_phydevice (se_device_t *dev,int check_pscsi) +{ +if (!TRANSPORT (dev)->release_phydevice) +return ; + +if (dev->dev_flags &DF_READ_ONLY ) { +if (check_pscsi && + (TRANSPORT (dev)->transport_type != +TRANSPORT_PLUGIN_PHBA_PDEV )) +return ; + +TRANSPORT (dev)->release_phydevice (dev); +return ; + } + +if (!(dev->dev_flags &DF_CLAIMED_BLOCKDEV )) +return ; + +if (!dev->dev_ptr) { +printk (KERN_ERR "se_device_t->dev_ptr is NULL!\n" ); +BUG (); + } + +if (check_pscsi) { +if (TRANSPORT (dev)->transport_type != +TRANSPORT_PLUGIN_PHBA_PDEV ) +return ; + +if (dev->dev_flags &DF_PERSISTENT_CLAIMED_BLOCKDEV ) +return ; + } + +TRANSPORT (dev)->release_phydevice (dev); + dev->dev_flags &= ~DF_CLAIMED_BLOCKDEV ; +} + +/* transport_generic_free_device(): +* +* +*/ +void transport_generic_free_device (se_device_t *dev) +{ +if (!(dev->dev_ptr)) +return ; + +transport_generic_deactivate_device (dev); + +transport_generic_release_phydevice (dev,0 ); + +if (TRANSPORT (dev)->free_device) +TRANSPORT (dev)->free_device (dev->dev_ptr); +} +EXPORT_SYMBOL (transport_generic_free_device); + +int transport_allocate_iovecs_for_cmd ( +se_cmd_t *cmd, +u32 iov_count) +{ + cmd->iov_data =kzalloc (iov_count *sizeof (struct iovec ),GFP_ATOMIC ); +if (!(cmd->iov_data)) { +printk (KERN_ERR "Unable to allocate memory for" +" iscsi_cmd_t->iov_data.\n" ); +return -1 ; + } + cmd->orig_iov_data_count = iov_count; + +return 0 ; +} +EXPORT_SYMBOL (transport_allocate_iovecs_for_cmd); + +/* transport_generic_allocate_iovecs(): +* +* Called from transport_generic_new_cmd() in Transport Processing Thread. +*/ +static int transport_generic_allocate_iovecs ( +se_cmd_t *cmd) +{ +u32 iov_count; + + iov_count =T_TASK (cmd)->t_task_se_num; +if (!(iov_count)) + iov_count =1 ; +#if 0 +printk (KERN_INFO "Allocated %d iovecs for ITT: 0x%08x t_task_se_num:" +" %u\n" , iov_count,CMD_TFO (cmd)->get_task_tag (cmd), +T_TASK (cmd)->t_task_se_num); +#endif + iov_count +=TRANSPORT_IOV_DATA_BUFFER ; + +if (transport_allocate_iovecs_for_cmd (cmd, iov_count)) +return -1 ; + +return 0 ; +} + +/* transport_generic_prepare_cdb(): +* +* Since the Initiator sees iSCSI devices as LUNs, the SCSI CDB will +* contain the iSCSI LUN in bits 7-5 of byte 1 as per SAM-2. +* The point of this is since we are mapping iSCSI LUNs to +* SCSI Target IDs having a non-zero LUN in the CDB will throw the +* devices and HBAs for a loop. +*/ +static inline void transport_generic_prepare_cdb ( +unsigned char *cdb) +{ +switch (cdb[0 ]) { +case READ_10 :/* SBC - RDProtect */ +case READ_12 :/* SBC - RDProtect */ +case READ_16 :/* SBC - RDProtect */ +case SEND_DIAGNOSTIC :/* SPC - SELF-TEST Code */ +case VERIFY :/* SBC - VRProtect */ +case VERIFY_16 :/* SBC - VRProtect */ +case WRITE_VERIFY :/* SBC - VRProtect */ +case WRITE_VERIFY_12 :/* SBC - VRProtect */ +break ; +default : + cdb[1 ] &=0x1f ;/* clear logical unit number */ +break ; + } +} + +/* transport_check_device_cdb_sector_count(): +* +* returns: +* 0 on supported request sector count. +* 1 on unsupported request sector count. +*/ +static inline int transport_check_device_cdb_sector_count ( +se_obj_lun_type_t *se_obj_api, +void *se_obj_ptr, +u32 sectors) +{ +u32 max_sectors; + + max_sectors = se_obj_api->max_sectors (se_obj_ptr); +if (!(max_sectors)) { +printk (KERN_ERR "TRANSPORT->get_max_sectors returned zero!\n" ); +return 1 ; + } + +if (sectors > max_sectors) +return -1 ; + +return 0 ; +} + +/* transport_generic_get_task(): +* +* +*/ +static se_task_t *transport_generic_get_task ( +se_transform_info_t *ti, +se_cmd_t *cmd, +void *se_obj_ptr, +se_obj_lun_type_t *se_obj_api) +{ +se_task_t *task; +unsigned long flags; + + task =kmem_cache_zalloc (se_task_cache,GFP_KERNEL ); +if (!(task)) { +printk (KERN_ERR "Unable to allocate se_task_t\n" ); +return NULL ; + } + +INIT_LIST_HEAD (&task->t_list); +INIT_LIST_HEAD (&task->t_execute_list); +INIT_LIST_HEAD (&task->t_state_list); +init_completion (&task->task_stop_comp); + task->task_no =T_TASK (cmd)->t_task_no++; + task->task_se_cmd = cmd; + +DEBUG_SO ("se_obj_ptr: %p\n" , se_obj_ptr); +DEBUG_SO ("se_obj_api: %p\n" , se_obj_api); +DEBUG_SO ("Plugin: %s\n" , se_obj_api->obj_plugin->plugin_name); + + task->transport_req = se_obj_api->get_transport_req (se_obj_ptr, task); +if (!(task->transport_req)) +return NULL ; + +spin_lock_irqsave (&T_TASK (cmd)->t_state_lock, flags); +list_add_tail (&task->t_list, &T_TASK (cmd)->t_task_list); +spin_unlock_irqrestore (&T_TASK (cmd)->t_state_lock, flags); + + task->se_obj_api = se_obj_api; + task->se_obj_ptr = se_obj_ptr; + +return task; +} + +int transport_generic_obj_start ( +se_transform_info_t *ti, +se_obj_lun_type_t *obj_api, +void *p, +unsigned long long starting_lba) +{ + ti->ti_lba = starting_lba; + ti->ti_obj_api = obj_api; + ti->ti_obj_ptr = p; + +return 0 ; +} + +static int transport_process_data_sg_transform ( +se_cmd_t *cmd, +se_transform_info_t *ti) +{ +/* +* Already handled in transport_generic_get_cdb_count() +*/ +return 0 ; +} + +/* transport_process_control_sg_transform(): +* +* +*/ +static int transport_process_control_sg_transform ( +se_cmd_t *cmd, +se_transform_info_t *ti) +{ +unsigned char *cdb; +se_task_t *task; +se_mem_t *se_mem, *se_mem_lout =NULL ; +int ret; +u32 se_mem_cnt =0 , task_offset =0 ; + +list_for_each_entry (se_mem,T_TASK (cmd)->t_mem_list, se_list) +break ; + +if (!se_mem) { +printk (KERN_ERR "se_mem is NULL!\n" ); +return -1 ; + } + + task = cmd->transport_get_task (ti, cmd, ti->se_obj_ptr, + ti->se_obj_api); +if (!(task)) +return -1 ; + + task->transport_map_task = ti->se_obj_api->get_map_SG ( + ti->se_obj_ptr, cmd->data_direction); + + cdb = ti->se_obj_api->get_cdb (ti->se_obj_ptr, task); +if (cdb) +memcpy (cdb,T_TASK (cmd)->t_task_cdb,SCSI_CDB_SIZE ); + + task->task_size = cmd->data_length; + task->task_sg_num =1 ; + +atomic_inc (&T_TASK (cmd)->t_fe_count); +atomic_inc (&T_TASK (cmd)->t_se_count); + + ret = ti->se_obj_api->do_se_mem_map (ti->se_obj_ptr, task, +T_TASK (cmd)->t_mem_list,NULL , se_mem, &se_mem_lout, + &se_mem_cnt, &task_offset); +if (ret <0 ) +return ret; + +DEBUG_CDB_H ("task_no[%u]: SCF_SCSI_CONTROL_SG_IO_CDB task_size: %d\n" , + task->task_no, task->task_size); +return 0 ; +} + +/* transport_process_control_nonsg_transform(): +* +* +*/ +static int transport_process_control_nonsg_transform ( +se_cmd_t *cmd, +se_transform_info_t *ti) +{ +unsigned char *cdb; +se_task_t *task; + + task = cmd->transport_get_task (ti, cmd, ti->se_obj_ptr, + ti->se_obj_api); +if (!(task)) +return -1 ; + + task->transport_map_task = ti->se_obj_api->get_map_non_SG ( + ti->se_obj_ptr, cmd->data_direction); + + cdb = ti->se_obj_api->get_cdb (ti->se_obj_ptr, task); +if (cdb) +memcpy (cdb,T_TASK (cmd)->t_task_cdb,SCSI_CDB_SIZE ); + + task->task_size = cmd->data_length; + task->task_sg_num =0 ; + +atomic_inc (&T_TASK (cmd)->t_fe_count); +atomic_inc (&T_TASK (cmd)->t_se_count); + +DEBUG_CDB_H ("task_no[%u]: SCF_SCSI_CONTROL_NONSG_IO_CDB task_size:" +" %d\n" , task->task_no, task->task_size); +return 0 ; +} + +/* transport_process_non_data_transform(): +* +* +*/ +static int transport_process_non_data_transform ( +se_cmd_t *cmd, +se_transform_info_t *ti) +{ +unsigned char *cdb; +se_task_t *task; + + task = cmd->transport_get_task (ti, cmd, ti->se_obj_ptr, + ti->se_obj_api); +if (!(task)) +return -1 ; + + task->transport_map_task = ti->se_obj_api->get_map_none (ti->se_obj_ptr); + + cdb = ti->se_obj_api->get_cdb (ti->se_obj_ptr, task); +if (cdb) +memcpy (cdb,T_TASK (cmd)->t_task_cdb,SCSI_CDB_SIZE ); + + task->task_size = cmd->data_length; + task->task_sg_num =0 ; + +atomic_inc (&T_TASK (cmd)->t_fe_count); +atomic_inc (&T_TASK (cmd)->t_se_count); + +DEBUG_CDB_H ("task_no[%u]: SCF_SCSI_NON_DATA_CDB task_size: %d\n" , + task->task_no, task->task_size); +return 0 ; +} + +static int transport_generic_cmd_sequencer (se_cmd_t *,unsigned char *); + +void transport_device_setup_cmd (se_cmd_t *cmd) +{ + cmd->transport_add_cmd_to_queue = &transport_add_cmd_to_dev_queue; + cmd->se_dev =SE_LUN (cmd)->se_dev; +} + +se_cmd_t *__transport_alloc_se_cmd ( +struct target_core_fabric_ops *tfo, +se_session_t *se_sess, +void *fabric_cmd_ptr, +u32 data_length, +int data_direction, +int task_attr) +{ +se_cmd_t *cmd; + +if (data_direction ==SE_DIRECTION_BIDI ) { +printk (KERN_ERR "SCSI BiDirectional mode not supported yet\n" ); +return ERR_PTR (-ENOSYS ); + } + + cmd =kmem_cache_zalloc (se_cmd_cache,GFP_KERNEL ); +if (!(cmd)) { +printk (KERN_ERR "kmem_cache_alloc() failed for se_cmd_cache\n" ); +return ERR_PTR (-ENOMEM ); + } +INIT_LIST_HEAD (&cmd->se_lun_list); +INIT_LIST_HEAD (&cmd->se_delayed_list); +INIT_LIST_HEAD (&cmd->se_ordered_list); + + cmd->t_task =kzalloc (sizeof (se_transport_task_t),GFP_KERNEL ); +if (!(cmd->t_task)) { +printk (KERN_ERR "Unable to allocate cmd->t_task\n" ); +kmem_cache_free (se_cmd_cache, cmd); +return NULL ; + } + + cmd->sense_buffer =kzalloc ( +TRANSPORT_SENSE_BUFFER + tfo->get_fabric_sense_len (), +GFP_KERNEL ); +if (!(cmd->sense_buffer)) { +printk (KERN_ERR "Unable to allocate memory for" +" cmd->sense_buffer\n" ); +kfree (cmd->t_task); +kmem_cache_free (se_cmd_cache, cmd); +return NULL ; + } +INIT_LIST_HEAD (&T_TASK (cmd)->t_task_list); +init_completion (&T_TASK (cmd)->transport_lun_fe_stop_comp); +init_completion (&T_TASK (cmd)->transport_lun_stop_comp); +init_completion (&T_TASK (cmd)->t_transport_stop_comp); +init_completion (&T_TASK (cmd)->t_transport_passthrough_comp); +init_completion (&T_TASK (cmd)->t_transport_passthrough_wcomp); +spin_lock_init (&T_TASK (cmd)->t_state_lock); + + cmd->se_tfo = tfo; + cmd->se_sess = se_sess; + cmd->se_fabric_cmd_ptr = fabric_cmd_ptr; + cmd->data_length = data_length; + cmd->data_direction = data_direction; + cmd->sam_task_attr = task_attr; + +return cmd; +} + +int transport_check_alloc_task_attr (se_cmd_t *cmd) +{ +/* +* Check if SAM Task Attribute emulation is enabled for this +* se_device_t storage object +*/ +if (SE_DEV (cmd)->dev_task_attr_type !=SAM_TASK_ATTR_EMULATED ) +return 0 ; + +if (cmd->sam_task_attr ==TASK_ATTR_ACA ) { +DEBUG_STA ("SAM Task Attribute ACA" +" emulation is not supported\n" ); +return -1 ; + } +/* +* Used to determine when ORDERED commands should go from +* Dormant to Active status. +*/ + cmd->se_ordered_id =atomic_inc_return (&SE_DEV (cmd)->dev_ordered_id); +smp_mb__after_atomic_inc (); +DEBUG_STA ("Allocated se_ordered_id: %u for Task Attr: 0x%02x on %s\n" , + cmd->se_ordered_id, cmd->sam_task_attr, +TRANSPORT (cmd->se_dev)->name); +return 0 ; +} + +se_cmd_t *transport_alloc_se_cmd ( +struct target_core_fabric_ops *tfo_api, +se_session_t *se_sess, +void *fabric_cmd_ptr, +u32 data_length, +int data_direction, +int task_attr) +{ +return __transport_alloc_se_cmd (tfo_api, se_sess, fabric_cmd_ptr, + data_length, data_direction, task_attr); +} +EXPORT_SYMBOL (transport_alloc_se_cmd); + +void transport_free_se_cmd ( +se_cmd_t *se_cmd) +{ +if (se_cmd->se_tmr_req) +core_tmr_release_req (se_cmd->se_tmr_req); + +kfree (se_cmd->iov_data); +kfree (se_cmd->sense_buffer); +kfree (se_cmd->t_task); +kmem_cache_free (se_cmd_cache, se_cmd); +} +EXPORT_SYMBOL (transport_free_se_cmd); + +static void transport_generic_wait_for_tasks (se_cmd_t *,int ,int ); + +/* transport_generic_allocate_tasks(): +* +* Called from fabric RX Thread. +*/ +int transport_generic_allocate_tasks ( +se_cmd_t *cmd, +unsigned char *cdb) +{ +int non_data_cdb; + +transport_generic_prepare_cdb (cdb); + +/* +* This is needed for early exceptions. +*/ + cmd->transport_wait_for_tasks = &transport_generic_wait_for_tasks; + +CMD_ORIG_OBJ_API (cmd)->transport_setup_cmd (cmd->se_orig_obj_ptr, cmd); +/* +* See if this is a CDB which follows SAM, also grab a function +* pointer to see if we need to do extra work. +*/ + non_data_cdb =transport_generic_cmd_sequencer (cmd, cdb); +if (non_data_cdb <0 ) +return -1 ; +/* +* Copy the original CDB into T_TASK(cmd). +*/ +memcpy (T_TASK (cmd)->t_task_cdb, cdb,SCSI_CDB_SIZE ); +/* +* Check for SAM Task Attribute Emulation +*/ +if (transport_check_alloc_task_attr (cmd) <0 ) { + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =INVALID_CDB_FIELD ; +return -2 ; + } +#ifdef SNMP_SUPPORT +spin_lock (&cmd->se_lun->lun_sep_lock); +if (cmd->se_lun->lun_sep) + cmd->se_lun->lun_sep->sep_stats.cmd_pdus++; +spin_unlock (&cmd->se_lun->lun_sep_lock); +#endif /* SNMP_SUPPORT */ + +switch (non_data_cdb) { +case 0 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to " +"SCF_SCSI_DATA_SG_IO_CDB\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_DATA_SG_IO_CDB ; + +/* +* Get the initial Logical Block Address from the Original +* Command Descriptor Block that arrived on the iSCSI wire. +*/ +T_TASK (cmd)->t_task_lba = (cmd->transport_get_long_lba) ? + cmd->transport_get_long_lba (cdb) : + cmd->transport_get_lba (cdb); + +break ; +case 1 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to" +" SCF_SCSI_CONTROL_SG_IO_CDB\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_CONTROL_SG_IO_CDB ; + cmd->transport_cdb_transform = + &transport_process_control_sg_transform; +break ; +case 2 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to " +"SCF_SCSI_CONTROL_NONSG_IO_CDB\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_CONTROL_NONSG_IO_CDB ; + cmd->transport_cdb_transform = + &transport_process_control_nonsg_transform; +break ; +case 3 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to " +"SCF_SCSI_NON_DATA_CDB\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_NON_DATA_CDB ; + cmd->transport_cdb_transform = + &transport_process_non_data_transform; +break ; +case 4 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to" +" SCF_SCSI_UNSUPPORTED_CDB\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =UNSUPPORTED_SCSI_OPCODE ; +return -2 ; +case 5 : +DEBUG_CDB_H ("Set cdb[0]: 0x%02x to" +" SCF_SCSI_RESERVATION_CONFLICT\n" , cdb[0 ]); + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->se_cmd_flags |=SCF_SCSI_RESERVATION_CONFLICT ; + cmd->scsi_status =SAM_STAT_RESERVATION_CONFLICT ; +/* +* For UA Interlock Code 11b, a RESERVATION CONFLICT will +* establish a UNIT ATTENTION with PREVIOUS RESERVATION +* CONFLICT STATUS. +* +* See spc4r17, section 7.4.6 Control Mode Page, Table 349 +*/ +if (SE_SESS (cmd) && +DEV_ATTRIB (cmd->se_dev)->emulate_ua_intlck_ctrl ==2 ) +core_scsi3_ua_allocate (SE_SESS (cmd)->se_node_acl, + cmd->orig_fe_lun,0x2C , +ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS ); +return -2 ; +case 6 : + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =INVALID_CDB_FIELD ; +return -2 ; +case 7 : + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =ILLEGAL_REQUEST ; +return -2 ; +case 8 : + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =CHECK_CONDITION_UNIT_ATTENTION ; +return -2 ; +case 9 : + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =CHECK_CONDITION_NOT_READY ; +return -2 ; +default : + cmd->se_cmd_flags |=SCF_SCSI_CDB_EXCEPTION ; + cmd->scsi_sense_reason =UNSUPPORTED_SCSI_OPCODE ; +return -2 ; + } + +return 0 ; +} +EXPORT_SYMBOL (transport_generic_allocate_tasks); + +/* transport_generic_handle_cdb(): +* +* +*/ +int transport_generic_handle_cdb ( +se_cmd_t *cmd) +{ +if (!SE_LUN (cmd)) { +printk (KERN_ERR "SE_LUN(cmd) is NULL\n" ); +return -1 ; + } + + cmd->transport_add_cmd_to_queue (cmd,TRANSPORT_NEW_CMD ); +return 0 ; +} +EXPORT_SYMBOL (transport_generic_handle_cdb); + +/* transport_generic_handle_data(): +* +* +*/ +int transport_generic_handle_data ( +se_cmd_t *cmd) +{ +/* +* Make sure that the transport has been disabled by +* transport_write_pending() before readding this se_cmd_t to the +* processing queue. If it has not yet been reset to zero by the +* processing thread in cmd->transport_add_cmd_to_queue(), let other +* processes run. If a signal was received, then we assume the +* connection is being failed/shutdown, so we return a failure. +*/ +while (atomic_read (&T_TASK (cmd)->t_transport_active)) { +msleep_interruptible (10 ); +if (signal_pending (current)) +return -1 ; + } +/* +* If the received CDB has aleady been ABORTED by the generic +* target engine, we now call transport_check_aborted_status() +* to queue any delated TASK_ABORTED status for the received CDB to the +* fabric module as we are expecting no futher incoming DATA OUT +* sequences at this point. +*/ +if (transport_check_aborted_status (cmd,1 ) !=0 ) +return 0 ; + + cmd->transport_add_cmd_to_queue (cmd,TRANSPORT_PROCESS_WRITE ); +return 0 ; +} +EXPORT_SYMBOL (transport_generic_handle_data); + +/* transport_generic_handle_tmr(): +* +* +*/ +int transport_generic_handle_tmr ( +se_cmd_t *cmd) +{ +/* +* This is needed for early exceptions. +*/
Lines of this file are not shown. View the raw message.
include/target/target_core_transport.h new file +529 -0
529 lines not on this page · raw message
include/target/target_core_transport_plugin.h new file +67 -0
67 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Part of the diff is not shown here. View the raw message.