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

Commit abbbd021 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'scsi-postmerge' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi 

Pull second set of SCSI updates from James Bottomley:
 "This is a set of three patches that depended on mq and zone changes in
  the block tree (now upstream)"

* tag 'scsi-postmerge' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
  scsi: sd: Remove zone write locking
  scsi: sd_zbc: Initialize device request queue zoned data
  scsi: scsi-mq-debugfs: Show more information
parents 6cb7903e 39051dd8

drivers/scsi/scsi_debugfs.c

+37 −3
Original line number Diff line number Diff line
@@ -4,15 +4,49 @@ 
#include <scsi/scsi_dbg.h>

#include "scsi_debugfs.h"



#define SCSI_CMD_FLAG_NAME(name) [ilog2(SCMD_##name)] = #name

static const char *const scsi_cmd_flags[] = {

	SCSI_CMD_FLAG_NAME(TAGGED),

	SCSI_CMD_FLAG_NAME(UNCHECKED_ISA_DMA),

	SCSI_CMD_FLAG_NAME(INITIALIZED),

};

#undef SCSI_CMD_FLAG_NAME



static int scsi_flags_show(struct seq_file *m, const unsigned long flags,

			   const char *const *flag_name, int flag_name_count)

{

	bool sep = false;

	int i;



	for (i = 0; i < sizeof(flags) * BITS_PER_BYTE; i++) {

		if (!(flags & BIT(i)))

			continue;

		if (sep)

			seq_puts(m, "|");

		sep = true;

		if (i < flag_name_count && flag_name[i])

			seq_puts(m, flag_name[i]);

		else

			seq_printf(m, "%d", i);

	}

	return 0;

}



void scsi_show_rq(struct seq_file *m, struct request *rq)

{

	struct scsi_cmnd *cmd = container_of(scsi_req(rq), typeof(*cmd), req);

	int msecs = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);

	int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);

	int timeout_ms = jiffies_to_msecs(rq->timeout);

	const u8 *const cdb = READ_ONCE(cmd->cmnd);

	char buf[80] = "(?)";



	if (cdb)

		__scsi_format_command(buf, sizeof(buf), cdb, cmd->cmd_len);

	seq_printf(m, ", .cmd=%s, .retries=%d, allocated %d.%03d s ago", buf,

		   cmd->retries, msecs / 1000, msecs % 1000);

	seq_printf(m, ", .cmd=%s, .retries=%d, .result = %#x, .flags=", buf,

		   cmd->retries, cmd->result);

	scsi_flags_show(m, cmd->flags, scsi_cmd_flags,

			ARRAY_SIZE(scsi_cmd_flags));

	seq_printf(m, ", .timeout=%d.%03d, allocated %d.%03d s ago",

		   timeout_ms / 1000, timeout_ms % 1000,

		   alloc_ms / 1000, alloc_ms % 1000);

}

drivers/scsi/sd.c

+5 −36
Original line number Diff line number Diff line
@@ -851,16 +851,13 @@ static int sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd) 
	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);

	u64 sector = blk_rq_pos(rq) >> (ilog2(sdp->sector_size) - 9);

	u32 nr_sectors = blk_rq_sectors(rq) >> (ilog2(sdp->sector_size) - 9);

	int ret;



	if (!(rq->cmd_flags & REQ_NOUNMAP)) {

		switch (sdkp->zeroing_mode) {

		case SD_ZERO_WS16_UNMAP:

			ret = sd_setup_write_same16_cmnd(cmd, true);

			goto out;

			return sd_setup_write_same16_cmnd(cmd, true);

		case SD_ZERO_WS10_UNMAP:

			ret = sd_setup_write_same10_cmnd(cmd, true);

			goto out;

			return sd_setup_write_same10_cmnd(cmd, true);

		}

	}
@@ -868,15 +865,9 @@ static int sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd) 
		return BLKPREP_INVALID;



	if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff)

		ret = sd_setup_write_same16_cmnd(cmd, false);

	else

		ret = sd_setup_write_same10_cmnd(cmd, false);

		return sd_setup_write_same16_cmnd(cmd, false);



out:

	if (sd_is_zoned(sdkp) && ret == BLKPREP_OK)

		return sd_zbc_write_lock_zone(cmd);



	return ret;

	return sd_setup_write_same10_cmnd(cmd, false);

}



static void sd_config_write_same(struct scsi_disk *sdkp)
@@ -964,12 +955,6 @@ static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd) 


	BUG_ON(bio_offset(bio) || bio_iovec(bio).bv_len != sdp->sector_size);



	if (sd_is_zoned(sdkp)) {

		ret = sd_zbc_write_lock_zone(cmd);

		if (ret != BLKPREP_OK)

			return ret;

	}



	sector >>= ilog2(sdp->sector_size) - 9;

	nr_sectors >>= ilog2(sdp->sector_size) - 9;
@@ -1004,9 +989,6 @@ static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd) 
	ret = scsi_init_io(cmd);

	rq->__data_len = nr_bytes;



	if (sd_is_zoned(sdkp) && ret != BLKPREP_OK)

		sd_zbc_write_unlock_zone(cmd);



	return ret;

}
@@ -1036,19 +1018,12 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt) 
	sector_t threshold;

	unsigned int this_count = blk_rq_sectors(rq);

	unsigned int dif, dix;

	bool zoned_write = sd_is_zoned(sdkp) && rq_data_dir(rq) == WRITE;

	int ret;

	unsigned char protect;



	if (zoned_write) {

		ret = sd_zbc_write_lock_zone(SCpnt);

		if (ret != BLKPREP_OK)

			return ret;

	}



	ret = scsi_init_io(SCpnt);

	if (ret != BLKPREP_OK)

		goto out;

		return ret;

	WARN_ON_ONCE(SCpnt != rq->special);



	/* from here on until we're complete, any goto out
@@ -1267,9 +1242,6 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt) 
	 */

	ret = BLKPREP_OK;

 out:

	if (zoned_write && ret != BLKPREP_OK)

		sd_zbc_write_unlock_zone(SCpnt);



	return ret;

}
@@ -1314,9 +1286,6 @@ static void sd_uninit_command(struct scsi_cmnd *SCpnt) 
	struct request *rq = SCpnt->request;

	u8 *cmnd;



	if (SCpnt->flags & SCMD_ZONE_WRITE_LOCK)

		sd_zbc_write_unlock_zone(SCpnt);



	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)

		__free_page(rq->special_vec.bv_page);

drivers/scsi/sd.h

+0 −11
Original line number Diff line number Diff line
@@ -77,7 +77,6 @@ struct scsi_disk { 
	unsigned int	nr_zones;

	unsigned int	zone_blocks;

	unsigned int	zone_shift;

	unsigned long	*zones_wlock;

	unsigned int	zones_optimal_open;

	unsigned int	zones_optimal_nonseq;

	unsigned int	zones_max_open;
@@ -283,8 +282,6 @@ static inline int sd_is_zoned(struct scsi_disk *sdkp) 
extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer);

extern void sd_zbc_remove(struct scsi_disk *sdkp);

extern void sd_zbc_print_zones(struct scsi_disk *sdkp);

extern int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd);

extern void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd);

extern int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd);

extern int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd);

extern void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
@@ -302,14 +299,6 @@ static inline void sd_zbc_remove(struct scsi_disk *sdkp) {} 


static inline void sd_zbc_print_zones(struct scsi_disk *sdkp) {}



static inline int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd)

{

	/* Let the drive fail requests */

	return BLKPREP_OK;

}



static inline void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd) {}



static inline int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd)

{

	return BLKPREP_INVALID;

drivers/scsi/sd_zbc.c

+144 −91
Original line number Diff line number Diff line
@@ -229,17 +229,6 @@ static inline sector_t sd_zbc_zone_sectors(struct scsi_disk *sdkp) 
	return logical_to_sectors(sdkp->device, sdkp->zone_blocks);

}



/**

 * sd_zbc_zone_no - Get the number of the zone conataining a sector.

 * @sdkp: The target disk

 * @sector: 512B sector address contained in the zone

 */

static inline unsigned int sd_zbc_zone_no(struct scsi_disk *sdkp,

					  sector_t sector)

{

	return sectors_to_logical(sdkp->device, sector) >> sdkp->zone_shift;

}



/**

 * sd_zbc_setup_reset_cmnd - Prepare a RESET WRITE POINTER scsi command.

 * @cmd: the command to setup
@@ -278,78 +267,6 @@ int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd) 
	return BLKPREP_OK;

}



/**

 * sd_zbc_write_lock_zone - Write lock a sequential zone.

 * @cmd: write command

 *

 * Called from sd_init_cmd() for write requests (standard write, write same or

 * write zeroes operations). If the request target zone is not already locked,

 * the zone is locked and BLKPREP_OK returned, allowing the request to proceed

 * through dispatch in scsi_request_fn(). Otherwise, BLKPREP_DEFER is returned,

 * forcing the request to wait for the zone to be unlocked, that is, for the

 * previously issued write request targeting the same zone to complete.

 *

 * This is called from blk_peek_request() context with the queue lock held and

 * before the request is removed from the scheduler. As a result, multiple

 * contexts executing concurrently scsi_request_fn() cannot result in write

 * sequence reordering as only a single write request per zone is allowed to

 * proceed.

 */

int sd_zbc_write_lock_zone(struct scsi_cmnd *cmd)

{

	struct request *rq = cmd->request;

	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);

	sector_t sector = blk_rq_pos(rq);

	sector_t zone_sectors = sd_zbc_zone_sectors(sdkp);

	unsigned int zno = sd_zbc_zone_no(sdkp, sector);



	/*

	 * Note: Checks of the alignment of the write command on

	 * logical blocks is done in sd.c

	 */



	/* Do not allow zone boundaries crossing on host-managed drives */

	if (blk_queue_zoned_model(sdkp->disk->queue) == BLK_ZONED_HM &&

	    (sector & (zone_sectors - 1)) + blk_rq_sectors(rq) > zone_sectors)

		return BLKPREP_KILL;



	/*

	 * Do not issue more than one write at a time per

	 * zone. This solves write ordering problems due to

	 * the unlocking of the request queue in the dispatch

	 * path in the non scsi-mq case.

	 */

	if (sdkp->zones_wlock &&

	    test_and_set_bit(zno, sdkp->zones_wlock))

		return BLKPREP_DEFER;



	WARN_ON_ONCE(cmd->flags & SCMD_ZONE_WRITE_LOCK);

	cmd->flags |= SCMD_ZONE_WRITE_LOCK;



	return BLKPREP_OK;

}



/**

 * sd_zbc_write_unlock_zone - Write unlock a sequential zone.

 * @cmd: write command

 *

 * Called from sd_uninit_cmd(). Unlocking the request target zone will allow

 * dispatching the next write request for the zone.

 */

void sd_zbc_write_unlock_zone(struct scsi_cmnd *cmd)

{

	struct request *rq = cmd->request;

	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);



	if (sdkp->zones_wlock && cmd->flags & SCMD_ZONE_WRITE_LOCK) {

		unsigned int zno = sd_zbc_zone_no(sdkp, blk_rq_pos(rq));

		WARN_ON_ONCE(!test_bit(zno, sdkp->zones_wlock));

		cmd->flags &= ~SCMD_ZONE_WRITE_LOCK;

		clear_bit_unlock(zno, sdkp->zones_wlock);

		smp_mb__after_atomic();

	}

}



/**

 * sd_zbc_complete - ZBC command post processing.

 * @cmd: Completed command
@@ -586,8 +503,123 @@ static int sd_zbc_check_zone_size(struct scsi_disk *sdkp) 
	return 0;

}



/**

 * sd_zbc_alloc_zone_bitmap - Allocate a zone bitmap (one bit per zone).

 * @sdkp: The disk of the bitmap

 */

static inline unsigned long *sd_zbc_alloc_zone_bitmap(struct scsi_disk *sdkp)

{

	struct request_queue *q = sdkp->disk->queue;



	return kzalloc_node(BITS_TO_LONGS(sdkp->nr_zones)

			    * sizeof(unsigned long),

			    GFP_KERNEL, q->node);

}



/**

 * sd_zbc_get_seq_zones - Parse report zones reply to identify sequential zones

 * @sdkp: disk used

 * @buf: report reply buffer

 * @seq_zone_bitamp: bitmap of sequential zones to set

 *

 * Parse reported zone descriptors in @buf to identify sequential zones and

 * set the reported zone bit in @seq_zones_bitmap accordingly.

 * Since read-only and offline zones cannot be written, do not

 * mark them as sequential in the bitmap.

 * Return the LBA after the last zone reported.

 */

static sector_t sd_zbc_get_seq_zones(struct scsi_disk *sdkp, unsigned char *buf,

				     unsigned int buflen,

				     unsigned long *seq_zones_bitmap)

{

	sector_t lba, next_lba = sdkp->capacity;

	unsigned int buf_len, list_length;

	unsigned char *rec;

	u8 type, cond;



	list_length = get_unaligned_be32(&buf[0]) + 64;

	buf_len = min(list_length, buflen);

	rec = buf + 64;



	while (rec < buf + buf_len) {

		type = rec[0] & 0x0f;

		cond = (rec[1] >> 4) & 0xf;

		lba = get_unaligned_be64(&rec[16]);

		if (type != ZBC_ZONE_TYPE_CONV &&

		    cond != ZBC_ZONE_COND_READONLY &&

		    cond != ZBC_ZONE_COND_OFFLINE)

			set_bit(lba >> sdkp->zone_shift, seq_zones_bitmap);

		next_lba = lba + get_unaligned_be64(&rec[8]);

		rec += 64;

	}



	return next_lba;

}



/**

 * sd_zbc_setup_seq_zones_bitmap - Initialize the disk seq zone bitmap.

 * @sdkp: target disk

 *

 * Allocate a zone bitmap and initialize it by identifying sequential zones.

 */

static int sd_zbc_setup_seq_zones_bitmap(struct scsi_disk *sdkp)

{

	struct request_queue *q = sdkp->disk->queue;

	unsigned long *seq_zones_bitmap;

	sector_t lba = 0;

	unsigned char *buf;

	int ret = -ENOMEM;



	seq_zones_bitmap = sd_zbc_alloc_zone_bitmap(sdkp);

	if (!seq_zones_bitmap)

		return -ENOMEM;



	buf = kmalloc(SD_ZBC_BUF_SIZE, GFP_KERNEL);

	if (!buf)

		goto out;



	while (lba < sdkp->capacity) {

		ret = sd_zbc_report_zones(sdkp, buf, SD_ZBC_BUF_SIZE, lba);

		if (ret)

			goto out;

		lba = sd_zbc_get_seq_zones(sdkp, buf, SD_ZBC_BUF_SIZE,

					   seq_zones_bitmap);

	}



	if (lba != sdkp->capacity) {

		/* Something went wrong */

		ret = -EIO;

	}



out:

	kfree(buf);

	if (ret) {

		kfree(seq_zones_bitmap);

		return ret;

	}



	q->seq_zones_bitmap = seq_zones_bitmap;



	return 0;

}



static void sd_zbc_cleanup(struct scsi_disk *sdkp)

{

	struct request_queue *q = sdkp->disk->queue;



	kfree(q->seq_zones_bitmap);

	q->seq_zones_bitmap = NULL;



	kfree(q->seq_zones_wlock);

	q->seq_zones_wlock = NULL;



	q->nr_zones = 0;

}



static int sd_zbc_setup(struct scsi_disk *sdkp)

{

	struct request_queue *q = sdkp->disk->queue;

	int ret;



	/* READ16/WRITE16 is mandatory for ZBC disks */

	sdkp->device->use_16_for_rw = 1;
@@ -599,15 +631,36 @@ static int sd_zbc_setup(struct scsi_disk *sdkp) 
	sdkp->nr_zones =

		round_up(sdkp->capacity, sdkp->zone_blocks) >> sdkp->zone_shift;



	if (!sdkp->zones_wlock) {

		sdkp->zones_wlock = kcalloc(BITS_TO_LONGS(sdkp->nr_zones),

					    sizeof(unsigned long),

					    GFP_KERNEL);

		if (!sdkp->zones_wlock)

			return -ENOMEM;

	/*

	 * Initialize the device request queue information if the number

	 * of zones changed.

	 */

	if (sdkp->nr_zones != q->nr_zones) {



		sd_zbc_cleanup(sdkp);



		q->nr_zones = sdkp->nr_zones;

		if (sdkp->nr_zones) {

			q->seq_zones_wlock = sd_zbc_alloc_zone_bitmap(sdkp);

			if (!q->seq_zones_wlock) {

				ret = -ENOMEM;

				goto err;

			}



			ret = sd_zbc_setup_seq_zones_bitmap(sdkp);

			if (ret) {

				sd_zbc_cleanup(sdkp);

				goto err;

			}

		}



	}



	return 0;



err:

	sd_zbc_cleanup(sdkp);

	return ret;

}



int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
@@ -661,14 +714,14 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf) 


err:

	sdkp->capacity = 0;

	sd_zbc_cleanup(sdkp);



	return ret;

}



void sd_zbc_remove(struct scsi_disk *sdkp)

{

	kfree(sdkp->zones_wlock);

	sdkp->zones_wlock = NULL;

	sd_zbc_cleanup(sdkp);

}



void sd_zbc_print_zones(struct scsi_disk *sdkp)

include/scsi/scsi_cmnd.h

+1 −2
Original line number Diff line number Diff line
@@ -58,8 +58,7 @@ struct scsi_pointer { 
/* for scmd->flags */

#define SCMD_TAGGED		(1 << 0)

#define SCMD_UNCHECKED_ISA_DMA	(1 << 1)

#define SCMD_ZONE_WRITE_LOCK	(1 << 2)

#define SCMD_INITIALIZED	(1 << 3)

#define SCMD_INITIALIZED	(1 << 2)

/* flags preserved across unprep / reprep */

#define SCMD_PRESERVED_FLAGS	(SCMD_UNCHECKED_ISA_DMA | SCMD_INITIALIZED)