Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a1b73fc1 authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

scsi: reintroduce scsi_driver.init_command 



Instead of letting the ULD play games with the prep_fn move back to
the model of a central prep_fn with a callback to the ULD.  This
already cleans up and shortens the code by itself, and will be required
to properly support blk-mq in the SCSI midlayer.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarNicholas Bellinger <nab@linux-iscsi.org>
Reviewed-by: default avatarMike Christie <michaelc@cs.wisc.edu>
Reviewed-by: default avatarHannes Reinecke <hare@suse.de>
parent bc85dc50

drivers/scsi/scsi_lib.c

+39 −27
Original line number Original line Diff line number Diff line
@@ -1073,15 +1073,7 @@ static struct scsi_cmnd *scsi_get_cmd_from_req(struct scsi_device *sdev, 




int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)

int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)

{

{

	struct scsi_cmnd *cmd;

	struct scsi_cmnd *cmd = req->special;

	int ret = scsi_prep_state_check(sdev, req);



	if (ret != BLKPREP_OK)

		return ret;



	cmd = scsi_get_cmd_from_req(sdev, req);

	if (unlikely(!cmd))

		return BLKPREP_DEFER;





	/*

	/*

	 * BLOCK_PC requests may transfer data, in which case they must

	 * BLOCK_PC requests may transfer data, in which case they must
@@ -1125,15 +1117,11 @@ EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd); 
 */

 */

int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)

int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)

{

{

	struct scsi_cmnd *cmd;

	struct scsi_cmnd *cmd = req->special;

	int ret = scsi_prep_state_check(sdev, req);



	if (ret != BLKPREP_OK)

		return ret;





	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh

	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh

			 && sdev->scsi_dh_data->scsi_dh->prep_fn)) {

			 && sdev->scsi_dh_data->scsi_dh->prep_fn)) {

		ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);

		int ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);

		if (ret != BLKPREP_OK)

		if (ret != BLKPREP_OK)

			return ret;

			return ret;

	}

	}
@@ -1143,16 +1131,13 @@ int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req) 
	 */

	 */

	BUG_ON(!req->nr_phys_segments);

	BUG_ON(!req->nr_phys_segments);





	cmd = scsi_get_cmd_from_req(sdev, req);

	if (unlikely(!cmd))

		return BLKPREP_DEFER;



	memset(cmd->cmnd, 0, BLK_MAX_CDB);

	memset(cmd->cmnd, 0, BLK_MAX_CDB);

	return scsi_init_io(cmd, GFP_ATOMIC);

	return scsi_init_io(cmd, GFP_ATOMIC);

}

}

EXPORT_SYMBOL(scsi_setup_fs_cmnd);

EXPORT_SYMBOL(scsi_setup_fs_cmnd);





int scsi_prep_state_check(struct scsi_device *sdev, struct request *req)

static int

scsi_prep_state_check(struct scsi_device *sdev, struct request *req)

{

{

	int ret = BLKPREP_OK;

	int ret = BLKPREP_OK;
@@ -1204,9 +1189,9 @@ int scsi_prep_state_check(struct scsi_device *sdev, struct request *req) 
	}

	}

	return ret;

	return ret;

}

}

EXPORT_SYMBOL(scsi_prep_state_check);





int scsi_prep_return(struct request_queue *q, struct request *req, int ret)

static int

scsi_prep_return(struct request_queue *q, struct request *req, int ret)

{

{

	struct scsi_device *sdev = q->queuedata;

	struct scsi_device *sdev = q->queuedata;
@@ -1237,18 +1222,44 @@ int scsi_prep_return(struct request_queue *q, struct request *req, int ret) 




	return ret;

	return ret;

}

}

EXPORT_SYMBOL(scsi_prep_return);





int scsi_prep_fn(struct request_queue *q, struct request *req)

static int scsi_prep_fn(struct request_queue *q, struct request *req)

{

{

	struct scsi_device *sdev = q->queuedata;

	struct scsi_device *sdev = q->queuedata;

	int ret = BLKPREP_KILL;

	struct scsi_cmnd *cmd;

	int ret;





	if (req->cmd_type == REQ_TYPE_BLOCK_PC)

	ret = scsi_prep_state_check(sdev, req);

	if (ret != BLKPREP_OK)

		goto out;



	cmd = scsi_get_cmd_from_req(sdev, req);

	if (unlikely(!cmd)) {

		ret = BLKPREP_DEFER;

		goto out;

	}



	if (req->cmd_type == REQ_TYPE_FS)

		ret = scsi_cmd_to_driver(cmd)->init_command(cmd);

	else if (req->cmd_type == REQ_TYPE_BLOCK_PC)

		ret = scsi_setup_blk_pc_cmnd(sdev, req);

		ret = scsi_setup_blk_pc_cmnd(sdev, req);

	else

		ret = BLKPREP_KILL;



out:

	return scsi_prep_return(q, req, ret);

	return scsi_prep_return(q, req, ret);

}

}

EXPORT_SYMBOL(scsi_prep_fn);



static void scsi_unprep_fn(struct request_queue *q, struct request *req)

{

	if (req->cmd_type == REQ_TYPE_FS) {

		struct scsi_cmnd *cmd = req->special;

		struct scsi_driver *drv = scsi_cmd_to_driver(cmd);



		if (drv->uninit_command)

			drv->uninit_command(cmd);

	}

}





/*

/*

 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else

 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
@@ -1669,6 +1680,7 @@ struct request_queue *scsi_alloc_queue(struct scsi_device *sdev) 
		return NULL;

		return NULL;





	blk_queue_prep_rq(q, scsi_prep_fn);

	blk_queue_prep_rq(q, scsi_prep_fn);

	blk_queue_unprep_rq(q, scsi_unprep_fn);

	blk_queue_softirq_done(q, scsi_softirq_done);

	blk_queue_softirq_done(q, scsi_softirq_done);

	blk_queue_rq_timed_out(q, scsi_times_out);

	blk_queue_rq_timed_out(q, scsi_times_out);

	blk_queue_lld_busy(q, scsi_lld_busy);

	blk_queue_lld_busy(q, scsi_lld_busy);

drivers/scsi/sd.c

+14 −30
Original line number Original line Diff line number Diff line
@@ -109,6 +109,8 @@ static int sd_suspend_system(struct device *); 
static int sd_suspend_runtime(struct device *);

static int sd_suspend_runtime(struct device *);

static int sd_resume(struct device *);

static int sd_resume(struct device *);

static void sd_rescan(struct device *);

static void sd_rescan(struct device *);

static int sd_init_command(struct scsi_cmnd *SCpnt);

static void sd_uninit_command(struct scsi_cmnd *SCpnt);

static int sd_done(struct scsi_cmnd *);

static int sd_done(struct scsi_cmnd *);

static int sd_eh_action(struct scsi_cmnd *, int);

static int sd_eh_action(struct scsi_cmnd *, int);

static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);

static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
@@ -503,6 +505,8 @@ static struct scsi_driver sd_template = { 
		.pm		= &sd_pm_ops,

		.pm		= &sd_pm_ops,

	},

	},

	.rescan			= sd_rescan,

	.rescan			= sd_rescan,

	.init_command		= sd_init_command,

	.uninit_command		= sd_uninit_command,

	.done			= sd_done,

	.done			= sd_done,

	.eh_action		= sd_eh_action,

	.eh_action		= sd_eh_action,

};

};
@@ -838,9 +842,9 @@ static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq) 
	return scsi_setup_blk_pc_cmnd(sdp, rq);

	return scsi_setup_blk_pc_cmnd(sdp, rq);

}

}





static void sd_unprep_fn(struct request_queue *q, struct request *rq)

static void sd_uninit_command(struct scsi_cmnd *SCpnt)

{

{

	struct scsi_cmnd *SCpnt = rq->special;

	struct request *rq = SCpnt->request;





	if (rq->cmd_flags & REQ_DISCARD) {

	if (rq->cmd_flags & REQ_DISCARD) {

		free_page((unsigned long)rq->buffer);

		free_page((unsigned long)rq->buffer);
@@ -853,18 +857,10 @@ static void sd_unprep_fn(struct request_queue *q, struct request *rq) 
	}

	}

}

}





/**

static int sd_init_command(struct scsi_cmnd *SCpnt)

 *	sd_prep_fn - build a scsi (read or write) command from

 *	information in the request structure.

 *	@SCpnt: pointer to mid-level's per scsi command structure that

 *	contains request and into which the scsi command is written

 *

 *	Returns 1 if successful and 0 if error (or cannot be done now).

 **/

static int sd_prep_fn(struct request_queue *q, struct request *rq)

{

{

	struct scsi_cmnd *SCpnt;

	struct request *rq = SCpnt->request;

	struct scsi_device *sdp = q->queuedata;

	struct scsi_device *sdp = SCpnt->device;

	struct gendisk *disk = rq->rq_disk;

	struct gendisk *disk = rq->rq_disk;

	struct scsi_disk *sdkp;

	struct scsi_disk *sdkp;

	sector_t block = blk_rq_pos(rq);

	sector_t block = blk_rq_pos(rq);
@@ -886,12 +882,6 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq) 
	} else if (rq->cmd_flags & REQ_FLUSH) {

	} else if (rq->cmd_flags & REQ_FLUSH) {

		ret = scsi_setup_flush_cmnd(sdp, rq);

		ret = scsi_setup_flush_cmnd(sdp, rq);

		goto out;

		goto out;

	} else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {

		ret = scsi_setup_blk_pc_cmnd(sdp, rq);

		goto out;

	} else if (rq->cmd_type != REQ_TYPE_FS) {

		ret = BLKPREP_KILL;

		goto out;

	}

	}

	ret = scsi_setup_fs_cmnd(sdp, rq);

	ret = scsi_setup_fs_cmnd(sdp, rq);

	if (ret != BLKPREP_OK)

	if (ret != BLKPREP_OK)
@@ -903,11 +893,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq) 
	 * is used for a killable error condition */

	 * is used for a killable error condition */

	ret = BLKPREP_KILL;

	ret = BLKPREP_KILL;





	SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,

	SCSI_LOG_HLQUEUE(1,

					"sd_prep_fn: block=%llu, "

		scmd_printk(KERN_INFO, SCpnt,

					"count=%d\n",

			"%s: block=%llu, count=%d\n",

					(unsigned long long)block,

			__func__, (unsigned long long)block, this_count));

					this_count));





	if (!sdp || !scsi_device_online(sdp) ||

	if (!sdp || !scsi_device_online(sdp) ||

	    block + blk_rq_sectors(rq) > get_capacity(disk)) {

	    block + blk_rq_sectors(rq) > get_capacity(disk)) {
@@ -1127,7 +1116,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq) 
	 */

	 */

	ret = BLKPREP_OK;

	ret = BLKPREP_OK;

 out:

 out:

	return scsi_prep_return(q, rq, ret);

	return ret;

}

}





/**

/**
@@ -2878,9 +2867,6 @@ static void sd_probe_async(void *data, async_cookie_t cookie) 




	sd_revalidate_disk(gd);

	sd_revalidate_disk(gd);





	blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);

	blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);



	gd->driverfs_dev = &sdp->sdev_gendev;

	gd->driverfs_dev = &sdp->sdev_gendev;

	gd->flags = GENHD_FL_EXT_DEVT;

	gd->flags = GENHD_FL_EXT_DEVT;

	if (sdp->removable) {

	if (sdp->removable) {
@@ -3028,8 +3014,6 @@ static int sd_remove(struct device *dev) 




	async_synchronize_full_domain(&scsi_sd_pm_domain);

	async_synchronize_full_domain(&scsi_sd_pm_domain);

	async_synchronize_full_domain(&scsi_sd_probe_domain);

	async_synchronize_full_domain(&scsi_sd_probe_domain);

	blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);

	blk_queue_unprep_rq(sdkp->device->request_queue, NULL);

	device_del(&sdkp->dev);

	device_del(&sdkp->dev);

	del_gendisk(sdkp->disk);

	del_gendisk(sdkp->disk);

	sd_shutdown(dev);

	sd_shutdown(dev);

drivers/scsi/sr.c

+6 −13
Original line number Original line Diff line number Diff line
@@ -79,6 +79,7 @@ MODULE_ALIAS_SCSI_DEVICE(TYPE_WORM); 
static DEFINE_MUTEX(sr_mutex);

static DEFINE_MUTEX(sr_mutex);

static int sr_probe(struct device *);

static int sr_probe(struct device *);

static int sr_remove(struct device *);

static int sr_remove(struct device *);

static int sr_init_command(struct scsi_cmnd *SCpnt);

static int sr_done(struct scsi_cmnd *);

static int sr_done(struct scsi_cmnd *);

static int sr_runtime_suspend(struct device *dev);

static int sr_runtime_suspend(struct device *dev);
@@ -94,6 +95,7 @@ static struct scsi_driver sr_template = { 
		.remove		= sr_remove,

		.remove		= sr_remove,

		.pm		= &sr_pm_ops,

		.pm		= &sr_pm_ops,

	},

	},

	.init_command		= sr_init_command,

	.done			= sr_done,

	.done			= sr_done,

};

};
@@ -378,21 +380,14 @@ static int sr_done(struct scsi_cmnd *SCpnt) 
	return good_bytes;

	return good_bytes;

}

}





static int sr_prep_fn(struct request_queue *q, struct request *rq)

static int sr_init_command(struct scsi_cmnd *SCpnt)

{

{

	int block = 0, this_count, s_size;

	int block = 0, this_count, s_size;

	struct scsi_cd *cd;

	struct scsi_cd *cd;

	struct scsi_cmnd *SCpnt;

	struct request *rq = SCpnt->request;

	struct scsi_device *sdp = q->queuedata;

	struct scsi_device *sdp = SCpnt->device;

	int ret;

	int ret;





	if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {

		ret = scsi_setup_blk_pc_cmnd(sdp, rq);

		goto out;

	} else if (rq->cmd_type != REQ_TYPE_FS) {

		ret = BLKPREP_KILL;

		goto out;

	}

	ret = scsi_setup_fs_cmnd(sdp, rq);

	ret = scsi_setup_fs_cmnd(sdp, rq);

	if (ret != BLKPREP_OK)

	if (ret != BLKPREP_OK)

		goto out;

		goto out;
@@ -517,7 +512,7 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq) 
	 */

	 */

	ret = BLKPREP_OK;

	ret = BLKPREP_OK;

 out:

 out:

	return scsi_prep_return(q, rq, ret);

	return ret;

}

}





static int sr_block_open(struct block_device *bdev, fmode_t mode)

static int sr_block_open(struct block_device *bdev, fmode_t mode)
@@ -718,7 +713,6 @@ static int sr_probe(struct device *dev) 




	/* FIXME: need to handle a get_capabilities failure properly ?? */

	/* FIXME: need to handle a get_capabilities failure properly ?? */

	get_capabilities(cd);

	get_capabilities(cd);

	blk_queue_prep_rq(sdev->request_queue, sr_prep_fn);

	sr_vendor_init(cd);

	sr_vendor_init(cd);





	disk->driverfs_dev = &sdev->sdev_gendev;

	disk->driverfs_dev = &sdev->sdev_gendev;
@@ -993,7 +987,6 @@ static int sr_remove(struct device *dev) 




	scsi_autopm_get_device(cd->device);

	scsi_autopm_get_device(cd->device);





	blk_queue_prep_rq(cd->device->request_queue, scsi_prep_fn);

	del_gendisk(cd->disk);

	del_gendisk(cd->disk);





	mutex_lock(&sr_ref_mutex);

	mutex_lock(&sr_ref_mutex);

include/scsi/scsi_driver.h

+3 −6
Original line number Original line Diff line number Diff line
@@ -4,17 +4,17 @@ 
#include <linux/device.h>

#include <linux/device.h>





struct module;

struct module;

struct request;

struct scsi_cmnd;

struct scsi_cmnd;

struct scsi_device;

struct scsi_device;

struct request;

struct request_queue;







struct scsi_driver {

struct scsi_driver {

	struct module		*owner;

	struct module		*owner;

	struct device_driver	gendrv;

	struct device_driver	gendrv;





	void (*rescan)(struct device *);

	void (*rescan)(struct device *);

	int (*init_command)(struct scsi_cmnd *);

	void (*uninit_command)(struct scsi_cmnd *);

	int (*done)(struct scsi_cmnd *);

	int (*done)(struct scsi_cmnd *);

	int (*eh_action)(struct scsi_cmnd *, int);

	int (*eh_action)(struct scsi_cmnd *, int);

};

};
@@ -31,8 +31,5 @@ extern int scsi_register_interface(struct class_interface *); 




int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req);

int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req);

int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req);

int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req);

int scsi_prep_state_check(struct scsi_device *sdev, struct request *req);

int scsi_prep_return(struct request_queue *q, struct request *req, int ret);

int scsi_prep_fn(struct request_queue *, struct request *);





#endif /* _SCSI_SCSI_DRIVER_H */
 
#endif /* _SCSI_SCSI_DRIVER_H */