f08bb1e0db
During revalidate we check whether device capacity has changed before we decide whether to output disk information or not. The check for old capacity failed to take into account that we scaled sdkp->capacity based on the reported logical block size. And therefore the capacity test would always fail for devices with sectors bigger than 512 bytes and we would print several copies of the same discovery information. Avoid scaling sdkp->capacity and instead adjust the value on the fly when setting the block device capacity and generating fake C/H/S geometry. Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com> Cc: <stable@vger.kernel.org> Reported-by: Hannes Reinecke <hare@suse.de> Reviewed-by: Hannes Reinicke <hare@suse.de> Reviewed-by: Ewan Milne <emilne@redhat.com> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
267 lines
6.7 KiB
C
267 lines
6.7 KiB
C
#ifndef _SCSI_DISK_H
|
|
#define _SCSI_DISK_H
|
|
|
|
/*
|
|
* More than enough for everybody ;) The huge number of majors
|
|
* is a leftover from 16bit dev_t days, we don't really need that
|
|
* much numberspace.
|
|
*/
|
|
#define SD_MAJORS 16
|
|
|
|
/*
|
|
* Time out in seconds for disks and Magneto-opticals (which are slower).
|
|
*/
|
|
#define SD_TIMEOUT (30 * HZ)
|
|
#define SD_MOD_TIMEOUT (75 * HZ)
|
|
/*
|
|
* Flush timeout is a multiplier over the standard device timeout which is
|
|
* user modifiable via sysfs but initially set to SD_TIMEOUT
|
|
*/
|
|
#define SD_FLUSH_TIMEOUT_MULTIPLIER 2
|
|
#define SD_WRITE_SAME_TIMEOUT (120 * HZ)
|
|
|
|
/*
|
|
* Number of allowed retries
|
|
*/
|
|
#define SD_MAX_RETRIES 5
|
|
#define SD_PASSTHROUGH_RETRIES 1
|
|
#define SD_MAX_MEDIUM_TIMEOUTS 2
|
|
|
|
/*
|
|
* Size of the initial data buffer for mode and read capacity data
|
|
*/
|
|
#define SD_BUF_SIZE 512
|
|
|
|
/*
|
|
* Number of sectors at the end of the device to avoid multi-sector
|
|
* accesses to in the case of last_sector_bug
|
|
*/
|
|
#define SD_LAST_BUGGY_SECTORS 8
|
|
|
|
enum {
|
|
SD_EXT_CDB_SIZE = 32, /* Extended CDB size */
|
|
SD_MEMPOOL_SIZE = 2, /* CDB pool size */
|
|
};
|
|
|
|
enum {
|
|
SD_DEF_XFER_BLOCKS = 0xffff,
|
|
SD_MAX_XFER_BLOCKS = 0xffffffff,
|
|
SD_MAX_WS10_BLOCKS = 0xffff,
|
|
SD_MAX_WS16_BLOCKS = 0x7fffff,
|
|
};
|
|
|
|
enum {
|
|
SD_LBP_FULL = 0, /* Full logical block provisioning */
|
|
SD_LBP_UNMAP, /* Use UNMAP command */
|
|
SD_LBP_WS16, /* Use WRITE SAME(16) with UNMAP bit */
|
|
SD_LBP_WS10, /* Use WRITE SAME(10) with UNMAP bit */
|
|
SD_LBP_ZERO, /* Use WRITE SAME(10) with zero payload */
|
|
SD_LBP_DISABLE, /* Discard disabled due to failed cmd */
|
|
};
|
|
|
|
struct scsi_disk {
|
|
struct scsi_driver *driver; /* always &sd_template */
|
|
struct scsi_device *device;
|
|
struct device dev;
|
|
struct gendisk *disk;
|
|
atomic_t openers;
|
|
sector_t capacity; /* size in logical blocks */
|
|
u32 max_xfer_blocks;
|
|
u32 opt_xfer_blocks;
|
|
u32 max_ws_blocks;
|
|
u32 max_unmap_blocks;
|
|
u32 unmap_granularity;
|
|
u32 unmap_alignment;
|
|
u32 index;
|
|
unsigned int physical_block_size;
|
|
unsigned int max_medium_access_timeouts;
|
|
unsigned int medium_access_timed_out;
|
|
u8 media_present;
|
|
u8 write_prot;
|
|
u8 protection_type;/* Data Integrity Field */
|
|
u8 provisioning_mode;
|
|
unsigned ATO : 1; /* state of disk ATO bit */
|
|
unsigned cache_override : 1; /* temp override of WCE,RCD */
|
|
unsigned WCE : 1; /* state of disk WCE bit */
|
|
unsigned RCD : 1; /* state of disk RCD bit, unused */
|
|
unsigned DPOFUA : 1; /* state of disk DPOFUA bit */
|
|
unsigned first_scan : 1;
|
|
unsigned lbpme : 1;
|
|
unsigned lbprz : 1;
|
|
unsigned lbpu : 1;
|
|
unsigned lbpws : 1;
|
|
unsigned lbpws10 : 1;
|
|
unsigned lbpvpd : 1;
|
|
unsigned ws10 : 1;
|
|
unsigned ws16 : 1;
|
|
};
|
|
#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
|
|
|
|
static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
|
|
{
|
|
return container_of(disk->private_data, struct scsi_disk, driver);
|
|
}
|
|
|
|
#define sd_printk(prefix, sdsk, fmt, a...) \
|
|
(sdsk)->disk ? \
|
|
sdev_prefix_printk(prefix, (sdsk)->device, \
|
|
(sdsk)->disk->disk_name, fmt, ##a) : \
|
|
sdev_printk(prefix, (sdsk)->device, fmt, ##a)
|
|
|
|
#define sd_first_printk(prefix, sdsk, fmt, a...) \
|
|
do { \
|
|
if ((sdkp)->first_scan) \
|
|
sd_printk(prefix, sdsk, fmt, ##a); \
|
|
} while (0)
|
|
|
|
static inline int scsi_medium_access_command(struct scsi_cmnd *scmd)
|
|
{
|
|
switch (scmd->cmnd[0]) {
|
|
case READ_6:
|
|
case READ_10:
|
|
case READ_12:
|
|
case READ_16:
|
|
case SYNCHRONIZE_CACHE:
|
|
case VERIFY:
|
|
case VERIFY_12:
|
|
case VERIFY_16:
|
|
case WRITE_6:
|
|
case WRITE_10:
|
|
case WRITE_12:
|
|
case WRITE_16:
|
|
case WRITE_SAME:
|
|
case WRITE_SAME_16:
|
|
case UNMAP:
|
|
return 1;
|
|
case VARIABLE_LENGTH_CMD:
|
|
switch (scmd->cmnd[9]) {
|
|
case READ_32:
|
|
case VERIFY_32:
|
|
case WRITE_32:
|
|
case WRITE_SAME_32:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks)
|
|
{
|
|
return blocks << (ilog2(sdev->sector_size) - 9);
|
|
}
|
|
|
|
/*
|
|
* A DIF-capable target device can be formatted with different
|
|
* protection schemes. Currently 0 through 3 are defined:
|
|
*
|
|
* Type 0 is regular (unprotected) I/O
|
|
*
|
|
* Type 1 defines the contents of the guard and reference tags
|
|
*
|
|
* Type 2 defines the contents of the guard and reference tags and
|
|
* uses 32-byte commands to seed the latter
|
|
*
|
|
* Type 3 defines the contents of the guard tag only
|
|
*/
|
|
|
|
enum sd_dif_target_protection_types {
|
|
SD_DIF_TYPE0_PROTECTION = 0x0,
|
|
SD_DIF_TYPE1_PROTECTION = 0x1,
|
|
SD_DIF_TYPE2_PROTECTION = 0x2,
|
|
SD_DIF_TYPE3_PROTECTION = 0x3,
|
|
};
|
|
|
|
/*
|
|
* Look up the DIX operation based on whether the command is read or
|
|
* write and whether dix and dif are enabled.
|
|
*/
|
|
static inline unsigned int sd_prot_op(bool write, bool dix, bool dif)
|
|
{
|
|
/* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
|
|
const unsigned int ops[] = { /* wrt dix dif */
|
|
SCSI_PROT_NORMAL, /* 0 0 0 */
|
|
SCSI_PROT_READ_STRIP, /* 0 0 1 */
|
|
SCSI_PROT_READ_INSERT, /* 0 1 0 */
|
|
SCSI_PROT_READ_PASS, /* 0 1 1 */
|
|
SCSI_PROT_NORMAL, /* 1 0 0 */
|
|
SCSI_PROT_WRITE_INSERT, /* 1 0 1 */
|
|
SCSI_PROT_WRITE_STRIP, /* 1 1 0 */
|
|
SCSI_PROT_WRITE_PASS, /* 1 1 1 */
|
|
};
|
|
|
|
return ops[write << 2 | dix << 1 | dif];
|
|
}
|
|
|
|
/*
|
|
* Returns a mask of the protection flags that are valid for a given DIX
|
|
* operation.
|
|
*/
|
|
static inline unsigned int sd_prot_flag_mask(unsigned int prot_op)
|
|
{
|
|
const unsigned int flag_mask[] = {
|
|
[SCSI_PROT_NORMAL] = 0,
|
|
|
|
[SCSI_PROT_READ_STRIP] = SCSI_PROT_TRANSFER_PI |
|
|
SCSI_PROT_GUARD_CHECK |
|
|
SCSI_PROT_REF_CHECK |
|
|
SCSI_PROT_REF_INCREMENT,
|
|
|
|
[SCSI_PROT_READ_INSERT] = SCSI_PROT_REF_INCREMENT |
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
[SCSI_PROT_READ_PASS] = SCSI_PROT_TRANSFER_PI |
|
|
SCSI_PROT_GUARD_CHECK |
|
|
SCSI_PROT_REF_CHECK |
|
|
SCSI_PROT_REF_INCREMENT |
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
[SCSI_PROT_WRITE_INSERT] = SCSI_PROT_TRANSFER_PI |
|
|
SCSI_PROT_REF_INCREMENT,
|
|
|
|
[SCSI_PROT_WRITE_STRIP] = SCSI_PROT_GUARD_CHECK |
|
|
SCSI_PROT_REF_CHECK |
|
|
SCSI_PROT_REF_INCREMENT |
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
[SCSI_PROT_WRITE_PASS] = SCSI_PROT_TRANSFER_PI |
|
|
SCSI_PROT_GUARD_CHECK |
|
|
SCSI_PROT_REF_CHECK |
|
|
SCSI_PROT_REF_INCREMENT |
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
};
|
|
|
|
return flag_mask[prot_op];
|
|
}
|
|
|
|
/*
|
|
* Data Integrity Field tuple.
|
|
*/
|
|
struct sd_dif_tuple {
|
|
__be16 guard_tag; /* Checksum */
|
|
__be16 app_tag; /* Opaque storage */
|
|
__be32 ref_tag; /* Target LBA or indirect LBA */
|
|
};
|
|
|
|
#ifdef CONFIG_BLK_DEV_INTEGRITY
|
|
|
|
extern void sd_dif_config_host(struct scsi_disk *);
|
|
extern void sd_dif_prepare(struct scsi_cmnd *scmd);
|
|
extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
|
|
|
|
#else /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
static inline void sd_dif_config_host(struct scsi_disk *disk)
|
|
{
|
|
}
|
|
static inline int sd_dif_prepare(struct scsi_cmnd *scmd)
|
|
{
|
|
return 0;
|
|
}
|
|
static inline void sd_dif_complete(struct scsi_cmnd *cmd, unsigned int a)
|
|
{
|
|
}
|
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
#endif /* _SCSI_DISK_H */
|