Commit 5c9bf363 authored by John Garry's avatar John Garry Committed by Martin K. Petersen
Browse files

scsi: libsas: Add sas_execute_internal_abort_single() 

The internal abort feature is common to hisi_sas and pm8001 HBAs, and the
driver support is similar also, so add a common handler.

Two modes of operation will be supported:

 - single: Abort a single tagged command

 - device: Abort all commands associated with a specific domain device

A new protocol is added, SAS_PROTOCOL_INTERNAL_ABORT, so the common queue
command API may be re-used.

Only add "single" support as a first step.

Link: https://lore.kernel.org/r/1647001432-239276-2-git-send-email-john.garry@huawei.com


Tested-by: default avatarDamien Le Moal <damien.lemoal@opensource.wdc.com>
Acked-by: default avatarJack Wang <jinpu.wang@ionos.com>
Signed-off-by: default avatarJohn Garry <john.garry@huawei.com>
Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parent 2ea3a393

drivers/scsi/libsas/sas_scsi_host.c

+74 −0
Original line number Diff line number Diff line
@@ -920,6 +920,80 @@ void sas_task_internal_timedout(struct timer_list *t) 
#define TASK_TIMEOUT			(20 * HZ)

#define TASK_RETRY			3



static int sas_execute_internal_abort(struct domain_device *device,

				      enum sas_internal_abort type, u16 tag,

				      unsigned int qid, void *data)

{

	struct sas_ha_struct *ha = device->port->ha;

	struct sas_internal *i = to_sas_internal(ha->core.shost->transportt);

	struct sas_task *task = NULL;

	int res, retry;



	for (retry = 0; retry < TASK_RETRY; retry++) {

		task = sas_alloc_slow_task(GFP_KERNEL);

		if (!task)

			return -ENOMEM;



		task->dev = device;

		task->task_proto = SAS_PROTOCOL_INTERNAL_ABORT;

		task->task_done = sas_task_internal_done;

		task->slow_task->timer.function = sas_task_internal_timedout;

		task->slow_task->timer.expires = jiffies + TASK_TIMEOUT;

		add_timer(&task->slow_task->timer);



		task->abort_task.tag = tag;

		task->abort_task.type = type;



		res = i->dft->lldd_execute_task(task, GFP_KERNEL);

		if (res) {

			del_timer_sync(&task->slow_task->timer);

			pr_err("Executing internal abort failed %016llx (%d)\n",

			       SAS_ADDR(device->sas_addr), res);

			break;

		}



		wait_for_completion(&task->slow_task->completion);

		res = TMF_RESP_FUNC_FAILED;



		/* Even if the internal abort timed out, return direct. */

		if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {

			pr_err("Internal abort: timeout %016llx\n",

			       SAS_ADDR(device->sas_addr));

			res = -EIO;

			break;

		}



		if (task->task_status.resp == SAS_TASK_COMPLETE &&

			task->task_status.stat == SAS_SAM_STAT_GOOD) {

			res = TMF_RESP_FUNC_COMPLETE;

			break;

		}



		if (task->task_status.resp == SAS_TASK_COMPLETE &&

			task->task_status.stat == TMF_RESP_FUNC_SUCC) {

			res = TMF_RESP_FUNC_SUCC;

			break;

		}



		pr_err("Internal abort: task to dev %016llx response: 0x%x status 0x%x\n",

		       SAS_ADDR(device->sas_addr), task->task_status.resp,

		       task->task_status.stat);

		sas_free_task(task);

		task = NULL;

	}

	BUG_ON(retry == TASK_RETRY && task != NULL);

	sas_free_task(task);

	return res;

}



int sas_execute_internal_abort_single(struct domain_device *device, u16 tag,

				      unsigned int qid, void *data)

{

	return sas_execute_internal_abort(device, SAS_INTERNAL_ABORT_SINGLE,

					  tag, qid, data);

}

EXPORT_SYMBOL_GPL(sas_execute_internal_abort_single);



int sas_execute_tmf(struct domain_device *device, void *parameter,

		    int para_len, int force_phy_id,

		    struct sas_tmf_task *tmf)

include/scsi/libsas.h

+14 −0
Original line number Diff line number Diff line
@@ -557,6 +557,16 @@ struct sas_ata_task { 
	int    force_phy_id;

};



/* LLDDs rely on these values */

enum sas_internal_abort {

	SAS_INTERNAL_ABORT_SINGLE	= 0,

};



struct sas_internal_abort_task {

	enum sas_internal_abort type;

	u16 tag;

};



struct sas_smp_task {

	struct scatterlist smp_req;

	struct scatterlist smp_resp;
@@ -596,6 +606,7 @@ struct sas_task { 
		struct sas_ata_task ata_task;

		struct sas_smp_task smp_task;

		struct sas_ssp_task ssp_task;

		struct sas_internal_abort_task abort_task;

	};



	struct scatterlist *scatter;
@@ -683,6 +694,9 @@ extern int sas_slave_configure(struct scsi_device *); 
extern int sas_change_queue_depth(struct scsi_device *, int new_depth);

extern int sas_bios_param(struct scsi_device *, struct block_device *,

			  sector_t capacity, int *hsc);

int sas_execute_internal_abort_single(struct domain_device *device,

				      u16 tag, unsigned int qid,

				      void *data);

extern struct scsi_transport_template *

sas_domain_attach_transport(struct sas_domain_function_template *);

extern struct device_attribute dev_attr_phy_event_threshold;

include/scsi/sas.h

+2 −0
Original line number Diff line number Diff line
@@ -95,6 +95,8 @@ enum sas_protocol { 
	SAS_PROTOCOL_SSP		= 0x08,

	SAS_PROTOCOL_ALL		= 0x0E,

	SAS_PROTOCOL_STP_ALL		= SAS_PROTOCOL_STP|SAS_PROTOCOL_SATA,

	/* these are internal to libsas */

	SAS_PROTOCOL_INTERNAL_ABORT	= 0x10,

};



/* From the spec; local phys only */