[mirror_ubuntu-artful-kernel.git] / drivers / target / target_core_tmr.c

/*******************************************************************************
 * Filename:  target_core_tmr.c
 *
 * This file contains SPC-3 task management infrastructure
 *
 * (c) Copyright 2009-2013 Datera, Inc.
 *
 * Nicholas A. Bellinger <nab@kernel.org>
 *
 * 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.
 *
 ******************************************************************************/

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/export.h>

#include <target/target_core_base.h>
#include <target/target_core_backend.h>
#include <target/target_core_fabric.h>

#include "target_core_internal.h"
#include "target_core_alua.h"
#include "target_core_pr.h"

int core_tmr_alloc_req(
	struct se_cmd *se_cmd,
	void *fabric_tmr_ptr,
	u8 function,
	gfp_t gfp_flags)
{
	struct se_tmr_req *tmr;

	tmr = kzalloc(sizeof(struct se_tmr_req), gfp_flags);
	if (!tmr) {
		pr_err("Unable to allocate struct se_tmr_req\n");
		return -ENOMEM;
	}

	se_cmd->se_cmd_flags |= SCF_SCSI_TMR_CDB;
	se_cmd->se_tmr_req = tmr;
	tmr->task_cmd = se_cmd;
	tmr->fabric_tmr_ptr = fabric_tmr_ptr;
	tmr->function = function;
	INIT_LIST_HEAD(&tmr->tmr_list);

	return 0;
}
EXPORT_SYMBOL(core_tmr_alloc_req);

void core_tmr_release_req(struct se_tmr_req *tmr)
{
	struct se_device *dev = tmr->tmr_dev;
	unsigned long flags;

	if (dev) {
		spin_lock_irqsave(&dev->se_tmr_lock, flags);
		list_del_init(&tmr->tmr_list);
		spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
	}

	kfree(tmr);
}

static int core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas)
{
	unsigned long flags;
	bool remove = true, send_tas;
	/*
	 * TASK ABORTED status (TAS) bit support
	 */
	spin_lock_irqsave(&cmd->t_state_lock, flags);
	send_tas = (cmd->transport_state & CMD_T_TAS);
	spin_unlock_irqrestore(&cmd->t_state_lock, flags);

	if (send_tas) {
		remove = false;
		transport_send_task_abort(cmd);
	}

	return transport_cmd_finish_abort(cmd, remove);
}

static int target_check_cdb_and_preempt(struct list_head *list,
		struct se_cmd *cmd)
{
	struct t10_pr_registration *reg;

	if (!list)
		return 0;
	list_for_each_entry(reg, list, pr_reg_abort_list) {
		if (reg->pr_res_key == cmd->pr_res_key)
			return 0;
	}

	return 1;
}

static bool __target_check_io_state(struct se_cmd *se_cmd,
				    struct se_session *tmr_sess, int tas)
{
	struct se_session *sess = se_cmd->se_sess;

	assert_spin_locked(&sess->sess_cmd_lock);
	WARN_ON_ONCE(!irqs_disabled());
	/*
	 * If command already reached CMD_T_COMPLETE state within
	 * target_complete_cmd() or CMD_T_FABRIC_STOP due to shutdown,
	 * this se_cmd has been passed to fabric driver and will
	 * not be aborted.
	 *
	 * Otherwise, obtain a local se_cmd->cmd_kref now for TMR
	 * ABORT_TASK + LUN_RESET for CMD_T_ABORTED processing as
	 * long as se_cmd->cmd_kref is still active unless zero.
	 */
	spin_lock(&se_cmd->t_state_lock);
	if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
		pr_debug("Attempted to abort io tag: %llu already complete or"
			" fabric stop, skipping\n", se_cmd->tag);
		spin_unlock(&se_cmd->t_state_lock);
		return false;
	}
	if (sess->sess_tearing_down || se_cmd->cmd_wait_set) {
		pr_debug("Attempted to abort io tag: %llu already shutdown,"
			" skipping\n", se_cmd->tag);
		spin_unlock(&se_cmd->t_state_lock);
		return false;
	}
	se_cmd->transport_state |= CMD_T_ABORTED;

	if ((tmr_sess != se_cmd->se_sess) && tas)
		se_cmd->transport_state |= CMD_T_TAS;

	spin_unlock(&se_cmd->t_state_lock);

	return kref_get_unless_zero(&se_cmd->cmd_kref);
}

void core_tmr_abort_task(
	struct se_device *dev,
	struct se_tmr_req *tmr,
	struct se_session *se_sess)
{
	struct se_cmd *se_cmd;
	unsigned long flags;
	u64 ref_tag;

	spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
	list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {

		if (dev != se_cmd->se_dev)
			continue;

		/* skip task management functions, including tmr->task_cmd */
		if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
			continue;

		ref_tag = se_cmd->tag;
		if (tmr->ref_task_tag != ref_tag)
			continue;

		printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
			se_cmd->se_tfo->get_fabric_name(), ref_tag);

		if (!__target_check_io_state(se_cmd, se_sess, 0))
			continue;

		list_del_init(&se_cmd->se_cmd_list);
		spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);

		cancel_work_sync(&se_cmd->work);
		transport_wait_for_tasks(se_cmd);

		if (!transport_cmd_finish_abort(se_cmd, true))
			target_put_sess_cmd(se_cmd);

		printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
				" ref_tag: %llu\n", ref_tag);
		tmr->response = TMR_FUNCTION_COMPLETE;
		atomic_long_inc(&dev->aborts_complete);
		return;
	}
	spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);

	printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
			tmr->ref_task_tag);
	tmr->response = TMR_TASK_DOES_NOT_EXIST;
	atomic_long_inc(&dev->aborts_no_task);
}

static void core_tmr_drain_tmr_list(
	struct se_device *dev,
	struct se_tmr_req *tmr,
	struct list_head *preempt_and_abort_list)
{
	LIST_HEAD(drain_tmr_list);
	struct se_session *sess;
	struct se_tmr_req *tmr_p, *tmr_pp;
	struct se_cmd *cmd;
	unsigned long flags;
	bool rc;
	/*
	 * Release all pending and outgoing TMRs aside from the received
	 * LUN_RESET tmr..
	 */
	spin_lock_irqsave(&dev->se_tmr_lock, flags);
	list_del_init(&tmr->tmr_list);
	list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) {
		cmd = tmr_p->task_cmd;
		if (!cmd) {
			pr_err("Unable to locate struct se_cmd for TMR\n");
			continue;
		}
		/*
		 * If this function was called with a valid pr_res_key
		 * parameter (eg: for PROUT PREEMPT_AND_ABORT service action
		 * skip non registration key matching TMRs.
		 */
		if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
			continue;

		sess = cmd->se_sess;
		if (WARN_ON_ONCE(!sess))
			continue;

		spin_lock(&sess->sess_cmd_lock);
		spin_lock(&cmd->t_state_lock);
		if (!(cmd->transport_state & CMD_T_ACTIVE) ||
		     (cmd->transport_state & CMD_T_FABRIC_STOP)) {
			spin_unlock(&cmd->t_state_lock);
			spin_unlock(&sess->sess_cmd_lock);
			continue;
		}
		if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) {
			spin_unlock(&cmd->t_state_lock);
			spin_unlock(&sess->sess_cmd_lock);
			continue;
		}
		if (sess->sess_tearing_down || cmd->cmd_wait_set) {
			spin_unlock(&cmd->t_state_lock);
			spin_unlock(&sess->sess_cmd_lock);
			continue;
		}
		cmd->transport_state |= CMD_T_ABORTED;
		spin_unlock(&cmd->t_state_lock);

		rc = kref_get_unless_zero(&cmd->cmd_kref);
		if (!rc) {
			printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n");
			spin_unlock(&sess->sess_cmd_lock);
			continue;
		}
		spin_unlock(&sess->sess_cmd_lock);

		list_move_tail(&tmr_p->tmr_list, &drain_tmr_list);
	}
	spin_unlock_irqrestore(&dev->se_tmr_lock, flags);

	list_for_each_entry_safe(tmr_p, tmr_pp, &drain_tmr_list, tmr_list) {
		list_del_init(&tmr_p->tmr_list);
		cmd = tmr_p->task_cmd;

		pr_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
			" Response: 0x%02x, t_state: %d\n",
			(preempt_and_abort_list) ? "Preempt" : "", tmr_p,
			tmr_p->function, tmr_p->response, cmd->t_state);

		cancel_work_sync(&cmd->work);
		transport_wait_for_tasks(cmd);

		if (!transport_cmd_finish_abort(cmd, 1))
			target_put_sess_cmd(cmd);
	}
}

static void core_tmr_drain_state_list(
	struct se_device *dev,
	struct se_cmd *prout_cmd,
	struct se_session *tmr_sess,
	int tas,
	struct list_head *preempt_and_abort_list)
{
	LIST_HEAD(drain_task_list);
	struct se_session *sess;
	struct se_cmd *cmd, *next;
	unsigned long flags;
	int rc;

	/*
	 * Complete outstanding commands with TASK_ABORTED SAM status.
	 *
	 * This is following sam4r17, section 5.6 Aborting commands, Table 38
	 * for TMR LUN_RESET:
	 *
	 * a) "Yes" indicates that each command that is aborted on an I_T nexus
	 * other than the one that caused the SCSI device condition is
	 * completed with TASK ABORTED status, if the TAS bit is set to one in
	 * the Control mode page (see SPC-4). "No" indicates that no status is
	 * returned for aborted commands.
	 *
	 * d) If the logical unit reset is caused by a particular I_T nexus
	 * (e.g., by a LOGICAL UNIT RESET task management function), then "yes"
	 * (TASK_ABORTED status) applies.
	 *
	 * Otherwise (e.g., if triggered by a hard reset), "no"
	 * (no TASK_ABORTED SAM status) applies.
	 *
	 * Note that this seems to be independent of TAS (Task Aborted Status)
	 * in the Control Mode Page.
	 */
	spin_lock_irqsave(&dev->execute_task_lock, flags);
	list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
		/*
		 * For PREEMPT_AND_ABORT usage, only process commands
		 * with a matching reservation key.
		 */
		if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
			continue;

		/*
		 * Not aborting PROUT PREEMPT_AND_ABORT CDB..
		 */
		if (prout_cmd == cmd)
			continue;

		sess = cmd->se_sess;
		if (WARN_ON_ONCE(!sess))
			continue;

		spin_lock(&sess->sess_cmd_lock);
		rc = __target_check_io_state(cmd, tmr_sess, tas);
		spin_unlock(&sess->sess_cmd_lock);
		if (!rc)
			continue;

		list_move_tail(&cmd->state_list, &drain_task_list);
		cmd->state_active = false;
	}
	spin_unlock_irqrestore(&dev->execute_task_lock, flags);

	while (!list_empty(&drain_task_list)) {
		cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
		list_del_init(&cmd->state_list);

		pr_debug("LUN_RESET: %s cmd: %p"
			" ITT/CmdSN: 0x%08llx/0x%08x, i_state: %d, t_state: %d"
			"cdb: 0x%02x\n",
			(preempt_and_abort_list) ? "Preempt" : "", cmd,
			cmd->tag, 0,
			cmd->se_tfo->get_cmd_state(cmd), cmd->t_state,
			cmd->t_task_cdb[0]);
		pr_debug("LUN_RESET: ITT[0x%08llx] - pr_res_key: 0x%016Lx"
			" -- CMD_T_ACTIVE: %d"
			" CMD_T_STOP: %d CMD_T_SENT: %d\n",
			cmd->tag, cmd->pr_res_key,
			(cmd->transport_state & CMD_T_ACTIVE) != 0,
			(cmd->transport_state & CMD_T_STOP) != 0,
			(cmd->transport_state & CMD_T_SENT) != 0);

		/*
		 * If the command may be queued onto a workqueue cancel it now.
		 *
		 * This is equivalent to removal from the execute queue in the
		 * loop above, but we do it down here given that
		 * cancel_work_sync may block.
		 */
		cancel_work_sync(&cmd->work);
		transport_wait_for_tasks(cmd);

		if (!core_tmr_handle_tas_abort(cmd, tas))
			target_put_sess_cmd(cmd);
	}
}

int core_tmr_lun_reset(
        struct se_device *dev,
        struct se_tmr_req *tmr,
        struct list_head *preempt_and_abort_list,
        struct se_cmd *prout_cmd)
{
	struct se_node_acl *tmr_nacl = NULL;
	struct se_portal_group *tmr_tpg = NULL;
	struct se_session *tmr_sess = NULL;
	int tas;
        /*
	 * TASK_ABORTED status bit, this is configurable via ConfigFS
	 * struct se_device attributes.  spc4r17 section 7.4.6 Control mode page
	 *
	 * A task aborted status (TAS) bit set to zero specifies that aborted
	 * tasks shall be terminated by the device server without any response
	 * to the application client. A TAS bit set to one specifies that tasks
	 * aborted by the actions of an I_T nexus other than the I_T nexus on
	 * which the command was received shall be completed with TASK ABORTED
	 * status (see SAM-4).
	 */
	tas = dev->dev_attrib.emulate_tas;
	/*
	 * Determine if this se_tmr is coming from a $FABRIC_MOD
	 * or struct se_device passthrough..
	 */
	if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) {
		tmr_sess = tmr->task_cmd->se_sess;
		tmr_nacl = tmr_sess->se_node_acl;
		tmr_tpg = tmr_sess->se_tpg;
		if (tmr_nacl && tmr_tpg) {
			pr_debug("LUN_RESET: TMR caller fabric: %s"
				" initiator port %s\n",
				tmr_tpg->se_tpg_tfo->get_fabric_name(),
				tmr_nacl->initiatorname);
		}
	}
	pr_debug("LUN_RESET: %s starting for [%s], tas: %d\n",
		(preempt_and_abort_list) ? "Preempt" : "TMR",
		dev->transport->name, tas);

	core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
	core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas,
				preempt_and_abort_list);

	/*
	 * Clear any legacy SPC-2 reservation when called during
	 * LOGICAL UNIT RESET
	 */
	if (!preempt_and_abort_list &&
	     (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)) {
		spin_lock(&dev->dev_reservation_lock);
		dev->dev_reserved_node_acl = NULL;
		dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
		spin_unlock(&dev->dev_reservation_lock);
		pr_debug("LUN_RESET: SCSI-2 Released reservation\n");
	}

	atomic_long_inc(&dev->num_resets);

	pr_debug("LUN_RESET: %s for [%s] Complete\n",
			(preempt_and_abort_list) ? "Preempt" : "TMR",
			dev->transport->name);
	return 0;
}
Commit	Line	Data
c66ac9db NB	1	/*******************************************************************************
	2	* Filename: target_core_tmr.c
	3	*
	4	* This file contains SPC-3 task management infrastructure
	5	*
4c76251e	6	* (c) Copyright 2009-2013 Datera, Inc.
c66ac9db NB	7	*
	8	* Nicholas A. Bellinger <nab@kernel.org>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23	*
	24	******************************************************************************/
	25
c66ac9db NB	26	#include <linux/slab.h>
	27	#include <linux/spinlock.h>
	28	#include <linux/list.h>
c53181af	29	#include <linux/export.h>
c66ac9db NB	30
c66ac9db NB	31	#include <target/target_core_base.h>
c4795fb2 CH	32	#include <target/target_core_backend.h>
c4795fb2 CH	33	#include <target/target_core_fabric.h>
c66ac9db	34
e26d99ae	35	#include "target_core_internal.h"
c66ac9db NB	36	#include "target_core_alua.h"
	37	#include "target_core_pr.h"
	38
c8e31f26	39	int core_tmr_alloc_req(
c66ac9db NB	40	struct se_cmd *se_cmd,
c66ac9db NB	41	void *fabric_tmr_ptr,
dd503a5f RD	42	u8 function,
dd503a5f RD	43	gfp_t gfp_flags)
c66ac9db NB	44	{
	45	struct se_tmr_req *tmr;
	46
c8e31f26	47	tmr = kzalloc(sizeof(struct se_tmr_req), gfp_flags);
6708bb27 AG	48	if (!tmr) {
6708bb27 AG	49	pr_err("Unable to allocate struct se_tmr_req\n");
c8e31f26	50	return -ENOMEM;
c66ac9db	51	}
c8e31f26 AG	52
	53	se_cmd->se_cmd_flags \|= SCF_SCSI_TMR_CDB;
	54	se_cmd->se_tmr_req = tmr;
c66ac9db NB	55	tmr->task_cmd = se_cmd;
	56	tmr->fabric_tmr_ptr = fabric_tmr_ptr;
	57	tmr->function = function;
	58	INIT_LIST_HEAD(&tmr->tmr_list);
	59
c8e31f26	60	return 0;
c66ac9db NB	61	}
	62	EXPORT_SYMBOL(core_tmr_alloc_req);
	63
8f832690	64	void core_tmr_release_req(struct se_tmr_req *tmr)
c66ac9db NB	65	{
c66ac9db NB	66	struct se_device *dev = tmr->tmr_dev;
d050ffb9	67	unsigned long flags;
c66ac9db	68
8f832690 JE	69	if (dev) {
8f832690 JE	70	spin_lock_irqsave(&dev->se_tmr_lock, flags);
a6d9bb1c	71	list_del_init(&tmr->tmr_list);
8f832690	72	spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
7fd29aa9 NB	73	}
7fd29aa9 NB	74
c8e31f26	75	kfree(tmr);
c66ac9db NB	76	}
c66ac9db NB	77
73d4e580	78	static int core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas)
c66ac9db	79	{
0f4a9431 NB	80	unsigned long flags;
0f4a9431 NB	81	bool remove = true, send_tas;
c66ac9db NB	82	/*
c66ac9db NB	83	* TASK ABORTED status (TAS) bit support
8f832690	84	*/
0f4a9431 NB	85	spin_lock_irqsave(&cmd->t_state_lock, flags);
	86	send_tas = (cmd->transport_state & CMD_T_TAS);
	87	spin_unlock_irqrestore(&cmd->t_state_lock, flags);
	88
	89	if (send_tas) {
68259b5a	90	remove = false;
c66ac9db	91	transport_send_task_abort(cmd);
68259b5a	92	}
c66ac9db	93
73d4e580	94	return transport_cmd_finish_abort(cmd, remove);
c66ac9db NB	95	}
c66ac9db NB	96
feae8564 JE	97	static int target_check_cdb_and_preempt(struct list_head *list,
feae8564 JE	98	struct se_cmd *cmd)
c165f69c	99	{
feae8564	100	struct t10_pr_registration *reg;
c165f69c	101
feae8564 JE	102	if (!list)
	103	return 0;
	104	list_for_each_entry(reg, list, pr_reg_abort_list) {
	105	if (reg->pr_res_key == cmd->pr_res_key)
c165f69c JE	106	return 0;
	107	}
	108
	109	return 1;
	110	}
	111
0f4a9431 NB	112	static bool __target_check_io_state(struct se_cmd *se_cmd,
0f4a9431 NB	113	struct se_session *tmr_sess, int tas)
febe562c NB	114	{
	115	struct se_session *sess = se_cmd->se_sess;
	116
	117	assert_spin_locked(&sess->sess_cmd_lock);
	118	WARN_ON_ONCE(!irqs_disabled());
	119	/*
	120	* If command already reached CMD_T_COMPLETE state within
0f4a9431 NB	121	* target_complete_cmd() or CMD_T_FABRIC_STOP due to shutdown,
	122	* this se_cmd has been passed to fabric driver and will
	123	* not be aborted.
febe562c NB	124	*
	125	* Otherwise, obtain a local se_cmd->cmd_kref now for TMR
	126	* ABORT_TASK + LUN_RESET for CMD_T_ABORTED processing as
	127	* long as se_cmd->cmd_kref is still active unless zero.
	128	*/
	129	spin_lock(&se_cmd->t_state_lock);
0f4a9431 NB	130	if (se_cmd->transport_state & (CMD_T_COMPLETE \| CMD_T_FABRIC_STOP)) {
	131	pr_debug("Attempted to abort io tag: %llu already complete or"
	132	" fabric stop, skipping\n", se_cmd->tag);
	133	spin_unlock(&se_cmd->t_state_lock);
	134	return false;
	135	}
	136	if (sess->sess_tearing_down \|\| se_cmd->cmd_wait_set) {
	137	pr_debug("Attempted to abort io tag: %llu already shutdown,"
febe562c NB	138	" skipping\n", se_cmd->tag);
	139	spin_unlock(&se_cmd->t_state_lock);
	140	return false;
	141	}
	142	se_cmd->transport_state \|= CMD_T_ABORTED;
0f4a9431 NB	143
	144	if ((tmr_sess != se_cmd->se_sess) && tas)
	145	se_cmd->transport_state \|= CMD_T_TAS;
	146
febe562c NB	147	spin_unlock(&se_cmd->t_state_lock);
	148
	149	return kref_get_unless_zero(&se_cmd->cmd_kref);
	150	}
	151
3d28934a NB	152	void core_tmr_abort_task(
	153	struct se_device *dev,
	154	struct se_tmr_req *tmr,
	155	struct se_session *se_sess)
	156	{
f81ccb48	157	struct se_cmd *se_cmd;
3d28934a	158	unsigned long flags;
649ee054	159	u64 ref_tag;
3d28934a NB	160
3d28934a NB	161	spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
f81ccb48	162	list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
3d28934a NB	163
	164	if (dev != se_cmd->se_dev)
	165	continue;
47b1584c	166
dc0fafda BVA	167	/* skip task management functions, including tmr->task_cmd */
dc0fafda BVA	168	if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
47b1584c AL	169	continue;
47b1584c AL	170
649ee054	171	ref_tag = se_cmd->tag;
3d28934a NB	172	if (tmr->ref_task_tag != ref_tag)
	173	continue;
	174
649ee054	175	printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
3d28934a NB	176	se_cmd->se_tfo->get_fabric_name(), ref_tag);
3d28934a NB	177
3a1e7ca6 BVA	178	if (!__target_check_io_state(se_cmd, se_sess, 0))
	179	continue;
	180
3d28934a	181	list_del_init(&se_cmd->se_cmd_list);
3d28934a NB	182	spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
	183
	184	cancel_work_sync(&se_cmd->work);
	185	transport_wait_for_tasks(se_cmd);
3d28934a	186
73d4e580 NB	187	if (!transport_cmd_finish_abort(se_cmd, true))
73d4e580 NB	188	target_put_sess_cmd(se_cmd);
3d28934a NB	189
3d28934a NB	190	printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
649ee054	191	" ref_tag: %llu\n", ref_tag);
3d28934a	192	tmr->response = TMR_FUNCTION_COMPLETE;
c87ba9c4	193	atomic_long_inc(&dev->aborts_complete);
3d28934a NB	194	return;
	195	}
	196	spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
	197
649ee054	198	printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
3d28934a NB	199	tmr->ref_task_tag);
3d28934a NB	200	tmr->response = TMR_TASK_DOES_NOT_EXIST;
c87ba9c4	201	atomic_long_inc(&dev->aborts_no_task);
3d28934a NB	202	}
3d28934a NB	203
d050ffb9	204	static void core_tmr_drain_tmr_list(
c66ac9db NB	205	struct se_device *dev,
c66ac9db NB	206	struct se_tmr_req *tmr,
d050ffb9	207	struct list_head *preempt_and_abort_list)
c66ac9db	208	{
d050ffb9	209	LIST_HEAD(drain_tmr_list);
a6d9bb1c	210	struct se_session *sess;
c66ac9db	211	struct se_tmr_req tmr_p, tmr_pp;
d050ffb9	212	struct se_cmd *cmd;
c66ac9db	213	unsigned long flags;
a6d9bb1c	214	bool rc;
c66ac9db NB	215	/*
	216	* Release all pending and outgoing TMRs aside from the received
	217	* LUN_RESET tmr..
	218	*/
d050ffb9	219	spin_lock_irqsave(&dev->se_tmr_lock, flags);
51ec502a	220	list_del_init(&tmr->tmr_list);
c66ac9db	221	list_for_each_entry_safe(tmr_p, tmr_pp, &dev->dev_tmr_list, tmr_list) {
c66ac9db	222	cmd = tmr_p->task_cmd;
6708bb27 AG	223	if (!cmd) {
6708bb27 AG	224	pr_err("Unable to locate struct se_cmd for TMR\n");
c66ac9db NB	225	continue;
	226	}
	227	/*
	228	* If this function was called with a valid pr_res_key
	229	* parameter (eg: for PROUT PREEMPT_AND_ABORT service action
ac75d8be	230	* skip non registration key matching TMRs.
c66ac9db	231	*/
feae8564	232	if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
c66ac9db	233	continue;
c66ac9db	234
a6d9bb1c NB	235	sess = cmd->se_sess;
	236	if (WARN_ON_ONCE(!sess))
	237	continue;
	238
	239	spin_lock(&sess->sess_cmd_lock);
d050ffb9	240	spin_lock(&cmd->t_state_lock);
0f4a9431 NB	241	if (!(cmd->transport_state & CMD_T_ACTIVE) \|\|
0f4a9431 NB	242	(cmd->transport_state & CMD_T_FABRIC_STOP)) {
d050ffb9	243	spin_unlock(&cmd->t_state_lock);
a6d9bb1c	244	spin_unlock(&sess->sess_cmd_lock);
c66ac9db NB	245	continue;
	246	}
	247	if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) {
d050ffb9	248	spin_unlock(&cmd->t_state_lock);
a6d9bb1c	249	spin_unlock(&sess->sess_cmd_lock);
c66ac9db NB	250	continue;
c66ac9db NB	251	}
0f4a9431 NB	252	if (sess->sess_tearing_down \|\| cmd->cmd_wait_set) {
	253	spin_unlock(&cmd->t_state_lock);
	254	spin_unlock(&sess->sess_cmd_lock);
	255	continue;
	256	}
a6d9bb1c	257	cmd->transport_state \|= CMD_T_ABORTED;
d050ffb9 NB	258	spin_unlock(&cmd->t_state_lock);
d050ffb9 NB	259
a6d9bb1c	260	rc = kref_get_unless_zero(&cmd->cmd_kref);
a6d9bb1c NB	261	if (!rc) {
a6d9bb1c NB	262	printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n");
0f4a9431	263	spin_unlock(&sess->sess_cmd_lock);
a6d9bb1c NB	264	continue;
a6d9bb1c NB	265	}
0f4a9431 NB	266	spin_unlock(&sess->sess_cmd_lock);
0f4a9431 NB	267
6eb40b2a	268	list_move_tail(&tmr_p->tmr_list, &drain_tmr_list);
d050ffb9 NB	269	}
	270	spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
	271
abc1fd4f	272	list_for_each_entry_safe(tmr_p, tmr_pp, &drain_tmr_list, tmr_list) {
b8a11d73	273	list_del_init(&tmr_p->tmr_list);
abc1fd4f	274	cmd = tmr_p->task_cmd;
d050ffb9	275
6708bb27	276	pr_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
c66ac9db	277	" Response: 0x%02x, t_state: %d\n",
abc1fd4f JE	278	(preempt_and_abort_list) ? "Preempt" : "", tmr_p,
abc1fd4f JE	279	tmr_p->function, tmr_p->response, cmd->t_state);
c66ac9db	280
a6d9bb1c NB	281	cancel_work_sync(&cmd->work);
	282	transport_wait_for_tasks(cmd);
	283
73d4e580 NB	284	if (!transport_cmd_finish_abort(cmd, 1))
73d4e580 NB	285	target_put_sess_cmd(cmd);
c66ac9db	286	}
d050ffb9 NB	287	}
d050ffb9 NB	288
cf572a96	289	static void core_tmr_drain_state_list(
d050ffb9 NB	290	struct se_device *dev,
d050ffb9 NB	291	struct se_cmd *prout_cmd,
ebde1ca5	292	struct se_session *tmr_sess,
d050ffb9 NB	293	int tas,
	294	struct list_head *preempt_and_abort_list)
	295	{
	296	LIST_HEAD(drain_task_list);
febe562c	297	struct se_session *sess;
cf572a96	298	struct se_cmd cmd, next;
d050ffb9	299	unsigned long flags;
febe562c	300	int rc;
cf572a96	301
c66ac9db	302	/*
cf572a96 CH	303	* Complete outstanding commands with TASK_ABORTED SAM status.
cf572a96 CH	304	*
c66ac9db NB	305	* This is following sam4r17, section 5.6 Aborting commands, Table 38
	306	* for TMR LUN_RESET:
	307	*
	308	* a) "Yes" indicates that each command that is aborted on an I_T nexus
	309	* other than the one that caused the SCSI device condition is
	310	* completed with TASK ABORTED status, if the TAS bit is set to one in
	311	* the Control mode page (see SPC-4). "No" indicates that no status is
	312	* returned for aborted commands.
	313	*
	314	* d) If the logical unit reset is caused by a particular I_T nexus
	315	* (e.g., by a LOGICAL UNIT RESET task management function), then "yes"
	316	* (TASK_ABORTED status) applies.
	317	*
	318	* Otherwise (e.g., if triggered by a hard reset), "no"
	319	* (no TASK_ABORTED SAM status) applies.
	320	*
	321	* Note that this seems to be independent of TAS (Task Aborted Status)
	322	* in the Control Mode Page.
	323	*/
	324	spin_lock_irqsave(&dev->execute_task_lock, flags);
cf572a96	325	list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
c66ac9db NB	326	/*
	327	* For PREEMPT_AND_ABORT usage, only process commands
	328	* with a matching reservation key.
	329	*/
feae8564	330	if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
c66ac9db	331	continue;
cf572a96	332
c66ac9db NB	333	/*
	334	* Not aborting PROUT PREEMPT_AND_ABORT CDB..
	335	*/
	336	if (prout_cmd == cmd)
	337	continue;
	338
febe562c NB	339	sess = cmd->se_sess;
	340	if (WARN_ON_ONCE(!sess))
	341	continue;
	342
	343	spin_lock(&sess->sess_cmd_lock);
0f4a9431	344	rc = __target_check_io_state(cmd, tmr_sess, tas);
febe562c NB	345	spin_unlock(&sess->sess_cmd_lock);
	346	if (!rc)
	347	continue;
	348
cf572a96 CH	349	list_move_tail(&cmd->state_list, &drain_task_list);
cf572a96 CH	350	cmd->state_active = false;
d050ffb9 NB	351	}
	352	spin_unlock_irqrestore(&dev->execute_task_lock, flags);
	353
	354	while (!list_empty(&drain_task_list)) {
cf572a96	355	cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
febe562c	356	list_del_init(&cmd->state_list);
c66ac9db	357
cf572a96	358	pr_debug("LUN_RESET: %s cmd: %p"
649ee054	359	" ITT/CmdSN: 0x%08llx/0x%08x, i_state: %d, t_state: %d"
f2da9dbd	360	"cdb: 0x%02x\n",
cf572a96	361	(preempt_and_abort_list) ? "Preempt" : "", cmd,
649ee054	362	cmd->tag, 0,
e3d6f909	363	cmd->se_tfo->get_cmd_state(cmd), cmd->t_state,
f2da9dbd	364	cmd->t_task_cdb[0]);
649ee054	365	pr_debug("LUN_RESET: ITT[0x%08llx] - pr_res_key: 0x%016Lx"
785fdf70	366	" -- CMD_T_ACTIVE: %d"
7d680f3b	367	" CMD_T_STOP: %d CMD_T_SENT: %d\n",
649ee054	368	cmd->tag, cmd->pr_res_key,
7d680f3b CH	369	(cmd->transport_state & CMD_T_ACTIVE) != 0,
	370	(cmd->transport_state & CMD_T_STOP) != 0,
	371	(cmd->transport_state & CMD_T_SENT) != 0);
c66ac9db	372
35e0e757 CH	373	/*
	374	* If the command may be queued onto a workqueue cancel it now.
	375	*
	376	* This is equivalent to removal from the execute queue in the
	377	* loop above, but we do it down here given that
	378	* cancel_work_sync may block.
	379	*/
febe562c NB	380	cancel_work_sync(&cmd->work);
febe562c NB	381	transport_wait_for_tasks(cmd);
c66ac9db	382
73d4e580 NB	383	if (!core_tmr_handle_tas_abort(cmd, tas))
73d4e580 NB	384	target_put_sess_cmd(cmd);
c66ac9db	385	}
d050ffb9 NB	386	}
d050ffb9 NB	387
d050ffb9 NB	388	int core_tmr_lun_reset(
	389	struct se_device *dev,
	390	struct se_tmr_req *tmr,
	391	struct list_head *preempt_and_abort_list,
	392	struct se_cmd *prout_cmd)
	393	{
	394	struct se_node_acl *tmr_nacl = NULL;
	395	struct se_portal_group *tmr_tpg = NULL;
ebde1ca5	396	struct se_session *tmr_sess = NULL;
d050ffb9 NB	397	int tas;
	398	/*
	399	* TASK_ABORTED status bit, this is configurable via ConfigFS
	400	* struct se_device attributes. spc4r17 section 7.4.6 Control mode page
	401	*
	402	* A task aborted status (TAS) bit set to zero specifies that aborted
	403	* tasks shall be terminated by the device server without any response
	404	* to the application client. A TAS bit set to one specifies that tasks
	405	* aborted by the actions of an I_T nexus other than the I_T nexus on
	406	* which the command was received shall be completed with TASK ABORTED
	407	* status (see SAM-4).
	408	*/
0fd97ccf	409	tas = dev->dev_attrib.emulate_tas;
d050ffb9 NB	410	/*
	411	* Determine if this se_tmr is coming from a $FABRIC_MOD
	412	* or struct se_device passthrough..
	413	*/
	414	if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) {
ebde1ca5 NB	415	tmr_sess = tmr->task_cmd->se_sess;
	416	tmr_nacl = tmr_sess->se_node_acl;
	417	tmr_tpg = tmr_sess->se_tpg;
d050ffb9 NB	418	if (tmr_nacl && tmr_tpg) {
	419	pr_debug("LUN_RESET: TMR caller fabric: %s"
	420	" initiator port %s\n",
	421	tmr_tpg->se_tpg_tfo->get_fabric_name(),
	422	tmr_nacl->initiatorname);
	423	}
	424	}
	425	pr_debug("LUN_RESET: %s starting for [%s], tas: %d\n",
	426	(preempt_and_abort_list) ? "Preempt" : "TMR",
	427	dev->transport->name, tas);
	428
	429	core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
ebde1ca5	430	core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas,
d050ffb9	431	preempt_and_abort_list);
af877292	432
c66ac9db NB	433	/*
	434	* Clear any legacy SPC-2 reservation when called during
	435	* LOGICAL UNIT RESET
	436	*/
6708bb27	437	if (!preempt_and_abort_list &&
0fd97ccf	438	(dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)) {
c66ac9db NB	439	spin_lock(&dev->dev_reservation_lock);
c66ac9db NB	440	dev->dev_reserved_node_acl = NULL;
0fd97ccf	441	dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
c66ac9db	442	spin_unlock(&dev->dev_reservation_lock);
6708bb27	443	pr_debug("LUN_RESET: SCSI-2 Released reservation\n");
c66ac9db NB	444	}
c66ac9db NB	445
ee480683	446	atomic_long_inc(&dev->num_resets);
c66ac9db	447
6708bb27	448	pr_debug("LUN_RESET: %s for [%s] Complete\n",
c66ac9db	449	(preempt_and_abort_list) ? "Preempt" : "TMR",
e3d6f909	450	dev->transport->name);
c66ac9db NB	451	return 0;
c66ac9db NB	452	}
d050ffb9	453