Commit bb3a8154 authored by Damien Le Moal's avatar Damien Le Moal
Browse files

ata: libata-scsi: refactor ata_scsi_translate() 



Factor out of ata_scsi_translate() the code handling queued command
deferral using the port qc_defer callback and issuing the queued
command with ata_qc_issue() into the new function ata_scsi_qc_issue(),
and simplify the goto used in ata_scsi_translate().
While at it, also add a lockdep annotation to check that the port lock
is held when ata_scsi_translate() is called.

No functional changes.

Cc: stable@vger.kernel.org
Signed-off-by: default avatarDamien Le Moal <dlemoal@kernel.org>
Reviewed-by: default avatarNiklas Cassel <cassel@kernel.org>
Reviewed-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: default avatarJohn Garry <john.g.garry@oracle.com>
Reviewed-by: default avatarIgor Pylypiv <ipylypiv@google.com>
parent 97e01439

drivers/ata/libata-scsi.c

+50 −31
Original line number Diff line number Diff line
@@ -1691,6 +1691,42 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc) 
	ata_qc_done(qc);

}



static int ata_scsi_qc_issue(struct ata_port *ap, struct ata_queued_cmd *qc)

{

	int ret;



	if (!ap->ops->qc_defer)

		goto issue;



	/* Check if the command needs to be deferred. */

	ret = ap->ops->qc_defer(qc);

	switch (ret) {

	case 0:

		break;

	case ATA_DEFER_LINK:

		ret = SCSI_MLQUEUE_DEVICE_BUSY;

		break;

	case ATA_DEFER_PORT:

		ret = SCSI_MLQUEUE_HOST_BUSY;

		break;

	default:

		WARN_ON_ONCE(1);

		ret = SCSI_MLQUEUE_HOST_BUSY;

		break;

	}



	if (ret) {

		/* Force a requeue of the command to defer its execution. */

		ata_qc_free(qc);

		return ret;

	}



issue:

	ata_qc_issue(qc);



	return 0;

}



/**

 *	ata_scsi_translate - Translate then issue SCSI command to ATA device

 *	@dev: ATA device to which the command is addressed
@@ -1714,66 +1750,49 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc) 
 *	spin_lock_irqsave(host lock)

 *

 *	RETURNS:

 *	0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command

 *	needs to be deferred.

 *	0 on success, SCSI_ML_QUEUE_DEVICE_BUSY or SCSI_MLQUEUE_HOST_BUSY if the

 *	command needs to be deferred.

 */

static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,

			      ata_xlat_func_t xlat_func)

{

	struct ata_port *ap = dev->link->ap;

	struct ata_queued_cmd *qc;

	int rc;



	lockdep_assert_held(ap->lock);



	/*

	 * ata_scsi_qc_new() calls scsi_done(cmd) in case of failure. So we

	 * have nothing further to do when allocating a qc fails.

	 */

	qc = ata_scsi_qc_new(dev, cmd);

	if (!qc)

		goto err_mem;

		return 0;



	/* data is present; dma-map it */

	if (cmd->sc_data_direction == DMA_FROM_DEVICE ||

	    cmd->sc_data_direction == DMA_TO_DEVICE) {

		if (unlikely(scsi_bufflen(cmd) < 1)) {

			ata_dev_warn(dev, "WARNING: zero len r/w req\n");

			goto err_did;

			cmd->result = (DID_ERROR << 16);

			goto done;

		}



		ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));



		qc->dma_dir = cmd->sc_data_direction;

	}



	qc->complete_fn = ata_scsi_qc_complete;



	if (xlat_func(qc))

		goto early_finish;



	if (ap->ops->qc_defer) {

		if ((rc = ap->ops->qc_defer(qc)))

			goto defer;

	}



	/* select device, send command to hardware */

	ata_qc_issue(qc);

		goto done;



	return 0;



early_finish:

	ata_qc_free(qc);

	scsi_done(cmd);

	return 0;

	return ata_scsi_qc_issue(ap, qc);



err_did:

done:

	ata_qc_free(qc);

	cmd->result = (DID_ERROR << 16);

	scsi_done(cmd);

err_mem:

	return 0;



defer:

	ata_qc_free(qc);

	if (rc == ATA_DEFER_LINK)

		return SCSI_MLQUEUE_DEVICE_BUSY;

	else

		return SCSI_MLQUEUE_HOST_BUSY;

}



/**