|
|
@@ -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 @@ out:
|
|
|
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)
|
Linus Torvalds