Re: [PATCH 2/2] Migrate zone cache from RB-Tree to arrays of descriptors

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Sun, Aug 21, 2016 at 11:34 PM, Shaun Tancheff <shaun@xxxxxxxxxxxx> wrote:
> Currently the RB-Tree zone cache is fast and flexible. It does
> use a rather largish amount of ram. This model reduces the ram
> required from 120 bytes per zone to 16 bytes per zone with a
> moderate transformation of the blk_zone_lookup() api.
>
> This model is predicated on the belief that most variations
> on zoned media will follow a pattern of using collections of same
> sized zones on a single device. Similar to the pattern of erase
> blocks on flash devices being progressivly larger 16K, 64K, ...
>
> The goal is to be able to build a descriptor which is both memory
> efficient, performant, and flexible.
>
> Signed-off-by: Shaun Tancheff <shaun.tancheff@xxxxxxxxxxx>
> ---
>  block/blk-core.c       |    2 +-
>  block/blk-sysfs.c      |   31 +-
>  block/blk-zoned.c      |  103 +++--
>  drivers/scsi/sd.c      |    5 +-
>  drivers/scsi/sd.h      |    4 +-
>  drivers/scsi/sd_zbc.c  | 1025 +++++++++++++++++++++++++++---------------------
>  include/linux/blkdev.h |   82 +++-
>  7 files changed, 716 insertions(+), 536 deletions(-)
>
> diff --git a/block/blk-core.c b/block/blk-core.c
> index 3a9caf7..3b084a8 100644
> --- a/block/blk-core.c
> +++ b/block/blk-core.c
> @@ -727,7 +727,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
>         INIT_LIST_HEAD(&q->blkg_list);
>  #endif
>  #ifdef CONFIG_BLK_DEV_ZONED
> -       q->zones = RB_ROOT;
> +       q->zones = NULL;
>  #endif
>         INIT_DELAYED_WORK(&q->delay_work, blk_delay_work);
>
> diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
> index 43f441f..ecbd434 100644
> --- a/block/blk-sysfs.c
> +++ b/block/blk-sysfs.c
> @@ -232,36 +232,7 @@ static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
>  #ifdef CONFIG_BLK_DEV_ZONED
>  static ssize_t queue_zoned_show(struct request_queue *q, char *page)
>  {
> -       struct rb_node *node;
> -       struct blk_zone *zone;
> -       ssize_t offset = 0, end = 0;
> -       size_t size = 0, num = 0;
> -       enum blk_zone_type type = BLK_ZONE_TYPE_UNKNOWN;
> -
> -       for (node = rb_first(&q->zones); node; node = rb_next(node)) {
> -               zone = rb_entry(node, struct blk_zone, node);
> -               if (zone->type != type ||
> -                   zone->len != size ||
> -                   end != zone->start) {
> -                       if (size != 0)
> -                               offset += sprintf(page + offset, "%zu\n", num);
> -                       /* We can only store one page ... */
> -                       if (offset + 42 > PAGE_SIZE) {
> -                               offset += sprintf(page + offset, "...\n");
> -                               return offset;
> -                       }
> -                       size = zone->len;
> -                       type = zone->type;
> -                       offset += sprintf(page + offset, "%zu %zu %d ",
> -                                         zone->start, size, type);
> -                       num = 0;
> -                       end = zone->start + size;
> -               } else
> -                       end += zone->len;
> -               num++;
> -       }
> -       offset += sprintf(page + offset, "%zu\n", num);
> -       return offset;
> +       return sprintf(page, "%u\n", q->zones ? 1 : 0);
>  }
>  #endif
>
> diff --git a/block/blk-zoned.c b/block/blk-zoned.c
> index 975e863..338a1af 100644
> --- a/block/blk-zoned.c
> +++ b/block/blk-zoned.c
> @@ -8,63 +8,84 @@
>  #include <linux/kernel.h>
>  #include <linux/module.h>
>  #include <linux/blkdev.h>
> -#include <linux/rbtree.h>
> +#include <linux/vmalloc.h>
>
> -struct blk_zone *blk_lookup_zone(struct request_queue *q, sector_t lba)
> +/**
> + * blk_lookup_zone() - Lookup zones
> + * @q: Request Queue
> + * @sector: Location to lookup
> + * @start: Pointer to starting location zone (OUT)
> + * @len: Pointer to length of zone (OUT)
> + * @lock: Pointer to spinlock of zones in owning descriptor (OUT)
> + */
> +struct blk_zone *blk_lookup_zone(struct request_queue *q, sector_t sector,
> +                                sector_t *start, sector_t *len,
> +                                spinlock_t **lock)
>  {
> -       struct rb_root *root = &q->zones;
> -       struct rb_node *node = root->rb_node;
> +       int iter;
> +       struct blk_zone *bzone = NULL;
> +       struct zone_wps *zi = q->zones;
> +
> +       *start = 0;
> +       *len = 0;
> +       *lock = NULL;
> +
> +       if (!q->zones)
> +               goto out;
>
> -       while (node) {
> -               struct blk_zone *zone = container_of(node, struct blk_zone,
> -                                                    node);
> +       for (iter = 0; iter < zi->wps_count; iter++) {
> +               if (sector >= zi->wps[iter]->start_lba &&
> +                   sector <  zi->wps[iter]->last_lba) {
> +                       struct contiguous_wps *wp = zi->wps[iter];
> +                       u64 index = (sector - wp->start_lba) / wp->zone_size;
>
> -               if (lba < zone->start)
> -                       node = node->rb_left;
> -               else if (lba >= zone->start + zone->len)
> -                       node = node->rb_right;
> -               else
> -                       return zone;
> +                       if (index >= wp->zone_count) {
> +                               WARN(1, "Impossible index for zone\n");
> +                               goto out;
> +                       }
> +
> +                       bzone = &wp->zones[index];
> +                       *len = wp->zone_size;
> +                       *start = wp->start_lba + (index * wp->zone_size);
> +                       *lock = &wp->lock;
> +               }
>         }
> -       return NULL;
> +
> +out:
> +       return bzone;
>  }
>  EXPORT_SYMBOL_GPL(blk_lookup_zone);
>
> -struct blk_zone *blk_insert_zone(struct request_queue *q, struct blk_zone *data)
> +/**
> + * free_zone_wps() - Free up memory in use by wps
> + * @zi: zone wps array(s).
> + */
> +static void free_zone_wps(struct zone_wps *zi)
>  {
> -       struct rb_root *root = &q->zones;
> -       struct rb_node **new = &(root->rb_node), *parent = NULL;
> +       /* on error free the arrays */
> +       if (zi && zi->wps) {
> +               int ca;
>
> -       /* Figure out where to put new node */
> -       while (*new) {
> -               struct blk_zone *this = container_of(*new, struct blk_zone,
> -                                                    node);
> -               parent = *new;
> -               if (data->start + data->len <= this->start)
> -                       new = &((*new)->rb_left);
> -               else if (data->start >= this->start + this->len)
> -                       new = &((*new)->rb_right);
> -               else {
> -                       /* Return existing zone */
> -                       return this;
> +               for (ca = 0; ca < zi->wps_count; ca++) {
> +                       if (zi->wps[ca]) {
> +                               vfree(zi->wps[ca]);
> +                               zi->wps[ca] = NULL;
> +                       }
>                 }
> +               kfree(zi->wps);
>         }
> -       /* Add new node and rebalance tree. */
> -       rb_link_node(&data->node, parent, new);
> -       rb_insert_color(&data->node, root);
> -
> -       return NULL;
>  }
> -EXPORT_SYMBOL_GPL(blk_insert_zone);
>
> +/**
> + * blk_drop_zones() - Free zones
> + * @q: Request Queue
> + */
>  void blk_drop_zones(struct request_queue *q)
>  {
> -       struct rb_root *root = &q->zones;
> -       struct blk_zone *zone, *next;
> -
> -       rbtree_postorder_for_each_entry_safe(zone, next, root, node) {
> -               kfree(zone);
> +       if (q->zones) {
> +               free_zone_wps(q->zones);
> +               kfree(q->zones);
> +               q->zones = NULL;
>         }
> -       q->zones = RB_ROOT;
>  }
>  EXPORT_SYMBOL_GPL(blk_drop_zones);
> diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
> index f144df4..0f749f5 100644
> --- a/drivers/scsi/sd.c
> +++ b/drivers/scsi/sd.c
> @@ -2549,8 +2549,9 @@ got_data:
>                                       sdkp->physical_block_size);
>         sdkp->device->sector_size = sector_size;
>
> -       if (sd_zbc_config(sdkp, buffer, SD_BUF_SIZE))
> -               sd_config_discard(sdkp, SD_ZBC_RESET_WP);
> +       if (sdkp->first_scan)
> +               if (sd_zbc_config(sdkp, GFP_KERNEL))
> +                       sd_config_discard(sdkp, SD_ZBC_RESET_WP);
>
>         {
>                 char cap_str_2[10], cap_str_10[10];
> diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
> index fc766db..c9c79e9 100644
> --- a/drivers/scsi/sd.h
> +++ b/drivers/scsi/sd.h
> @@ -299,13 +299,13 @@ extern void sd_zbc_uninit_command(struct scsi_cmnd *cmd);
>  extern void sd_zbc_remove(struct scsi_disk *);
>  extern void sd_zbc_reset_zones(struct scsi_disk *);
>  extern void sd_zbc_update_zones(struct scsi_disk *, sector_t, int, int reason);
> -extern bool sd_zbc_config(struct scsi_disk *, void *, size_t);
> +extern bool sd_zbc_config(struct scsi_disk *, gfp_t);
>
>  extern unsigned int sd_zbc_discard_granularity(struct scsi_disk *sdkp);
>
>  #else /* CONFIG_SCSI_ZBC */
>
> -static inline bool sd_zbc_config(struct scsi_disk *sdkp, void *b, size_t sz)
> +static inline bool sd_zbc_config(struct scsi_disk *sdkp, gfp_t gfp)
>  {
>         return false;
>  }
> diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
> index 960af93..c087035 100644
> --- a/drivers/scsi/sd_zbc.c
> +++ b/drivers/scsi/sd_zbc.c
> @@ -22,6 +22,7 @@
>
>  #include <linux/blkdev.h>
>  #include <linux/rbtree.h>
> +#include <linux/vmalloc.h>
>
>  #include <asm/unaligned.h>
>
> @@ -51,11 +52,11 @@
>         } while( 0 )
>
>  struct zbc_update_work {
> -       struct work_struct zone_work;
> -       struct scsi_disk *sdkp;
> -       sector_t        zone_sector;
> -       int             zone_buflen;
> -       char            zone_buf[0];
> +       struct work_struct      zone_work;
> +       struct scsi_disk        *sdkp;
> +       sector_t                zone_sector;
> +       int                     zone_buflen;
> +       struct bdev_zone_report zone_buf[0];
>  };
>
>  /**
> @@ -95,102 +96,19 @@ static inline sector_t get_start_from_desc(struct scsi_disk *sdkp,
>         return logical_to_sectors(sdkp->device, be64_to_cpu(bzde->lba_start));
>  }
>
> -static
> -struct blk_zone *zbc_desc_to_zone(struct scsi_disk *sdkp, unsigned char *rec)
> +static void _fill_zone(struct blk_zone *zone, struct scsi_disk *sdkp,
> +                      struct bdev_zone_descriptor *bzde)
>  {
> -       struct blk_zone *zone;
> -       sector_t wp = (sector_t)-1;
> -
> -       zone = kzalloc(sizeof(struct blk_zone), GFP_KERNEL);
> -       if (!zone)
> -               return NULL;
> -
> -       spin_lock_init(&zone->lock);
> -       zone->type = rec[0] & 0xf;
> -       zone->state = (rec[1] >> 4) & 0xf;
> -       zone->len = logical_to_sectors(sdkp->device,
> -                                      get_unaligned_be64(&rec[8]));
> -       zone->start = logical_to_sectors(sdkp->device,
> -                                        get_unaligned_be64(&rec[16]));
> -
> -       if (blk_zone_is_smr(zone))
> -               wp = logical_to_sectors(sdkp->device,
> -                                       get_unaligned_be64(&rec[24]));
> -       zone->wp = wp;
> -       /*
> -        * Fixup block zone state
> -        */
> -       if (zone->state == BLK_ZONE_EMPTY &&
> -           zone->wp != zone->start) {
> -               sd_zbc_debug(sdkp,
> -                            "zone %zu state EMPTY wp %zu: adjust wp\n",
> -                            zone->start, zone->wp);
> -               zone->wp = zone->start;
> -       }
> -       if (zone->state == BLK_ZONE_FULL &&
> -           zone->wp != zone->start + zone->len) {
> -               sd_zbc_debug(sdkp,
> -                            "zone %zu state FULL wp %zu: adjust wp\n",
> -                            zone->start, zone->wp);
> -               zone->wp = zone->start + zone->len;
> -       }
> -
> -       return zone;
> +       zone->type = bzde->type & 0x0f;
> +       zone->state = (bzde->flags >> 4) & 0x0f;
> +       zone->wp = get_wp_from_desc(sdkp, bzde);
>  }
>
> -static
> -sector_t zbc_parse_zones(struct scsi_disk *sdkp, u64 zlen, unsigned char *buf,
> -                        unsigned int buf_len)
> -{
> -       struct request_queue *q = sdkp->disk->queue;
> -       unsigned char *rec = buf;
> -       int rec_no = 0;
> -       unsigned int list_length;
> -       sector_t next_sector = -1;
> -       u8 same;
> -
> -       /* Parse REPORT ZONES header */
> -       list_length = get_unaligned_be32(&buf[0]);
> -       same = buf[4] & 0xf;
> -       rec = buf + 64;
> -       list_length += 64;
> -
> -       if (list_length < buf_len)
> -               buf_len = list_length;
> -
> -       while (rec < buf + buf_len) {
> -               struct blk_zone *this, *old;
> -               unsigned long flags;
>
> -               this = zbc_desc_to_zone(sdkp, rec);
> -               if (!this)
> -                       break;
> -
> -               if (same == 0 && this->len != zlen) {
> -                       next_sector = this->start + this->len;
> -                       break;
> -               }
> -
> -               next_sector = this->start + this->len;
> -               old = blk_insert_zone(q, this);
> -               if (old) {
> -                       spin_lock_irqsave(&old->lock, flags);
> -                       if (blk_zone_is_smr(old)) {
> -                               old->wp = this->wp;
> -                               old->state = this->state;
> -                       }
> -                       spin_unlock_irqrestore(&old->lock, flags);
> -                       kfree(this);
> -               }
> -               rec += 64;
> -               rec_no++;
> -       }
> -
> -       sd_zbc_debug(sdkp,
> -                    "Inserted %d zones, next sector %zu len %d\n",
> -                    rec_no, next_sector, list_length);
> -
> -       return next_sector;
> +static void fill_zone(struct contiguous_wps *cwps, int z_count,
> +                     struct scsi_disk *sdkp, struct bdev_zone_descriptor *bzde)
> +{
> +       _fill_zone(&cwps->zones[z_count], sdkp, bzde);
>  }
>
>  /**
> @@ -200,12 +118,10 @@ sector_t zbc_parse_zones(struct scsi_disk *sdkp, u64 zlen, unsigned char *buf,
>   * @bufflen: length of @buffer
>   * @start_sector: logical sector for the zone information should be reported
>   * @option: reporting option to be used
> - * @partial: flag to set the 'partial' bit for report zones command
>   */
> -static int sd_zbc_report_zones(struct scsi_disk *sdkp, void *buffer,
> -                              int bufflen, sector_t start_sector,
> -                              enum zbc_zone_reporting_options option,
> -                              bool partial)
> +static int sd_zbc_report_zones(struct scsi_disk *sdkp,
> +                              struct bdev_zone_report *buffer,
> +                              int bufflen, sector_t start_sector, u8 option)
>  {
>         struct scsi_device *sdp = sdkp->device;
>         const int timeout = sdp->request_queue->rq_timeout
> @@ -225,7 +141,7 @@ static int sd_zbc_report_zones(struct scsi_disk *sdkp, void *buffer,
>         cmd[1] = ZI_REPORT_ZONES;
>         put_unaligned_be64(start_lba, &cmd[2]);
>         put_unaligned_be32(bufflen, &cmd[10]);
> -       cmd[14] = (partial ? ZBC_REPORT_ZONE_PARTIAL : 0) | option;
> +       cmd[14] = option;
>         memset(buffer, 0, bufflen);
>
>         result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
> @@ -248,49 +164,38 @@ static void sd_zbc_refresh_zone_work(struct work_struct *work)
>                 container_of(work, struct zbc_update_work, zone_work);
>         struct scsi_disk *sdkp = zbc_work->sdkp;
>         struct request_queue *q = sdkp->disk->queue;
> -       unsigned char *zone_buf = zbc_work->zone_buf;
> +       struct bdev_zone_report *rpt = zbc_work->zone_buf;
>         unsigned int zone_buflen = zbc_work->zone_buflen;
> +       struct bdev_zone_descriptor *bzde;
> +       int iter;
> +       int offmax;
> +       sector_t z_at, z_start, z_len;
> +       spinlock_t *lock;
> +       struct blk_zone *zone;
>         int ret;
> -       u8 same;
> -       u64 zlen = 0;
>         sector_t last_sector;
>         sector_t capacity = logical_to_sectors(sdkp->device, sdkp->capacity);
>
> -       ret = sd_zbc_report_zones(sdkp, zone_buf, zone_buflen,
> +       ret = sd_zbc_report_zones(sdkp, rpt, zone_buflen,
>                                   zbc_work->zone_sector,
> -                                 ZBC_ZONE_REPORTING_OPTION_ALL, true);
> +                                 ZBC_ZONE_REPORTING_OPTION_ALL);
>         if (ret)
>                 goto done_free;
>
> -       /* this whole path is unlikely so extra reports shouldn't be a
> -        * large impact */
> -       same = zone_buf[4] & 0xf;
> -       if (same == 0) {
> -               unsigned char *desc = &zone_buf[64];
> -               unsigned int blen = zone_buflen;
> -
> -               /* just pull the first zone */
> -               if (blen > 512)
> -                       blen = 512;
> -               ret = sd_zbc_report_zones(sdkp, zone_buf, blen, 0,
> -                                         ZBC_ZONE_REPORTING_OPTION_ALL, true);
> -               if (ret)
> -                       goto done_free;
> -
> -               /* Read the zone length from the first zone descriptor */
> -               zlen = logical_to_sectors(sdkp->device,
> -                                         get_unaligned_be64(&desc[8]));
> -
> -               ret = sd_zbc_report_zones(sdkp, zone_buf, zone_buflen,
> -                                         zbc_work->zone_sector,
> -                                         ZBC_ZONE_REPORTING_OPTION_ALL, true);
> -               if (ret)
> -                       goto done_free;
> +       offmax = max_report_entries(zone_buflen);
> +       for (iter = 0; iter < offmax; iter++) {
> +               bzde = &rpt->descriptors[iter];
> +               z_at = get_start_from_desc(sdkp, bzde);
> +               if (!z_at)
> +                       break;
> +               zone = blk_lookup_zone(q, z_at, &z_start, &z_len, &lock);
> +               if (zone) {
> +                       _fill_zone(zone, sdkp, bzde);
> +                       last_sector = z_start + z_len;
> +               }
>         }
>
> -       last_sector = zbc_parse_zones(sdkp, zlen, zone_buf, zone_buflen);
> -       capacity = logical_to_sectors(sdkp->device, sdkp->capacity);
> -       if (last_sector != -1 && last_sector < capacity) {
> +       if (sdkp->zone_work_q && last_sector != -1 && last_sector < capacity) {
>                 if (test_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags)) {
>                         sd_zbc_debug(sdkp,
>                                      "zones in reset, canceling refresh\n");
> @@ -333,10 +238,7 @@ void sd_zbc_update_zones(struct scsi_disk *sdkp, sector_t sector, int bufsize,
>  {
>         struct request_queue *q = sdkp->disk->queue;
>         struct zbc_update_work *zbc_work;
> -       struct blk_zone *zone;
> -       struct rb_node *node;
> -       int zone_num = 0, zone_busy = 0, num_rec;
> -       sector_t next_sector = sector;
> +       int num_rec;
>
>         if (test_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags)) {
>                 sd_zbc_debug(sdkp,
> @@ -346,18 +248,23 @@ void sd_zbc_update_zones(struct scsi_disk *sdkp, sector_t sector, int bufsize,
>
>         if (reason != SD_ZBC_INIT) {
>                 /* lookup sector, is zone pref? then ignore */
> -               struct blk_zone *zone = blk_lookup_zone(q, sector);
> -
> +               sector_t z_start, z_len;
> +               spinlock_t *lck;
> +               struct blk_zone *zone = blk_lookup_zone(q, sector, &z_start,
> +                                                       &z_len, &lck);
> +               /* zone actions on conventional zones are invalid */
> +               if (zone && reason == SD_ZBC_RESET_WP && blk_zone_is_cmr(zone))
> +                       return;
>                 if (reason == SD_ZBC_RESET_WP)
>                         sd_zbc_debug(sdkp, "RESET WP failed %lx\n", sector);
> -
> -               if (zone && blk_zone_is_seq_pref(zone))
> -                       return;
>         }
>
> +       if (!sdkp->zone_work_q)
> +               return;
> +
>  retry:
>         zbc_work = kzalloc(sizeof(struct zbc_update_work) + bufsize,
> -                          reason != SD_ZBC_INIT ? GFP_NOWAIT : GFP_KERNEL);
> +                          reason != SD_ZBC_INIT ? GFP_ATOMIC : GFP_KERNEL);
>         if (!zbc_work) {
>                 if (bufsize > 512) {
>                         sd_zbc_debug(sdkp,
> @@ -381,30 +288,40 @@ retry:
>          * Mark zones under update as BUSY
>          */
>         if (reason != SD_ZBC_INIT) {
> -               for (node = rb_first(&q->zones); node; node = rb_next(node)) {
> -                       unsigned long flags;
> -
> -                       zone = rb_entry(node, struct blk_zone, node);
> -                       if (num_rec == 0)
> +               unsigned long flags;
> +               int iter;
> +               struct zone_wps *zi = q->zones;
> +               struct contiguous_wps *wp = NULL;
> +               u64 index = -1;
> +               int zone_busy = 0;
> +               int z_flgd = 0;
> +
> +               for (iter = 0; iter < zi->wps_count; iter++) {
> +                       if (sector >= zi->wps[iter]->start_lba &&
> +                           sector <  zi->wps[iter]->last_lba) {
> +                               wp = zi->wps[iter];
>                                 break;
> -                       if (zone->start != next_sector)
> -                               continue;
> -                       next_sector += zone->len;
> -                       num_rec--;
> -
> -                       spin_lock_irqsave(&zone->lock, flags);
> -                       if (blk_zone_is_smr(zone)) {
> -                               if (zone->state == BLK_ZONE_BUSY) {
> +                       }
> +               }
> +               if (wp) {
> +                       spin_lock_irqsave(&wp->lock, flags);
> +                       index = (sector - wp->start_lba) / wp->zone_size;
> +                       while (index < wp->zone_count && z_flgd < num_rec) {
> +                               struct blk_zone *bzone = &wp->zones[index];
> +
> +                               index++;
> +                               z_flgd++;
> +                               if (!blk_zone_is_smr(bzone))
> +                                       continue;
> +
> +                               if (bzone->state == BLK_ZONE_BUSY)
>                                         zone_busy++;
> -                               } else {
> -                                       zone->state = BLK_ZONE_BUSY;
> -                                       zone->wp = zone->start;
> -                               }
> -                               zone_num++;
> +                               else
> +                                       bzone->state = BLK_ZONE_BUSY;
>                         }
> -                       spin_unlock_irqrestore(&zone->lock, flags);
> +                       spin_unlock_irqrestore(&wp->lock, flags);
>                 }
> -               if (zone_num && (zone_num == zone_busy)) {
> +               if (z_flgd && (z_flgd == zone_busy)) {
>                         sd_zbc_debug(sdkp,
>                                      "zone update for %zu in progress\n",
>                                      sector);
> @@ -476,43 +393,26 @@ static void discard_or_write_same(struct scsi_cmnd *cmd, sector_t sector,
>  int sd_zbc_setup_discard(struct scsi_cmnd *cmd)
>  {
>         struct request *rq = cmd->request;
> -       struct scsi_device *sdp = cmd->device;
>         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
>         sector_t sector = blk_rq_pos(rq);
>         unsigned int nr_sectors = blk_rq_sectors(rq);
>         int ret = BLKPREP_OK;
>         struct blk_zone *zone;
>         unsigned long flags;
> -       u32 wp_offset;
>         bool use_write_same = false;
> +       sector_t z_start, z_len;
> +       spinlock_t *lck;
>
> -       zone = blk_lookup_zone(rq->q, sector);
> -       if (!zone) {
> -               /* Test for a runt zone before giving up */
> -               if (sdp->type != TYPE_ZBC) {
> -                       struct request_queue *q = rq->q;
> -                       struct rb_node *node;
> -
> -                       node = rb_last(&q->zones);
> -                       if (node)
> -                               zone = rb_entry(node, struct blk_zone, node);
> -                       if (zone) {
> -                               spin_lock_irqsave(&zone->lock, flags);
> -                               if ((zone->start + zone->len) <= sector)
> -                                       goto out;
> -                               spin_unlock_irqrestore(&zone->lock, flags);
> -                               zone = NULL;
> -                       }
> -               }
> +       zone = blk_lookup_zone(rq->q, sector, &z_start, &z_len, &lck);
> +       if (!zone)
>                 return BLKPREP_KILL;
> -       }
>
> -       spin_lock_irqsave(&zone->lock, flags);
> +       spin_lock_irqsave(lck, flags);
>         if (zone->state == BLK_ZONE_UNKNOWN ||
>             zone->state == BLK_ZONE_BUSY) {
>                 sd_zbc_debug_ratelimit(sdkp,
>                                        "Discarding zone %zx state %x, deferring\n",
> -                                      zone->start, zone->state);
> +                                      z_start, zone->state);
>                 ret = BLKPREP_DEFER;
>                 goto out;
>         }
> @@ -520,39 +420,37 @@ int sd_zbc_setup_discard(struct scsi_cmnd *cmd)
>                 /* let the drive fail the command */
>                 sd_zbc_debug_ratelimit(sdkp,
>                                        "Discarding offline zone %zx\n",
> -                                      zone->start);
> +                                      z_start);
>                 goto out;
>         }
>         if (blk_zone_is_cmr(zone)) {
>                 use_write_same = true;
>                 sd_zbc_debug_ratelimit(sdkp,
> -                                      "Discarding CMR zone %zx\n",
> -                                      zone->start);
> +                                      "Discarding CMR zone %zx\n", z_start);
>                 goto out;
>         }
> -       if (zone->start != sector || zone->len < nr_sectors) {
> +       if (z_start != sector || z_len < nr_sectors) {
>                 sd_printk(KERN_ERR, sdkp,
>                           "Misaligned RESET WP %zx/%x on zone %zx/%zx\n",
> -                         sector, nr_sectors, zone->start, zone->len);
> +                         sector, nr_sectors, z_start, z_len);
>                 ret = BLKPREP_KILL;
>                 goto out;
>         }
>         /* Protect against Reset WP when more data had been written to the
>          * zone than is being discarded.
>          */
> -       wp_offset = zone->wp - zone->start;
> -       if (wp_offset > nr_sectors) {
> +       if (zone->wp > nr_sectors) {
>                 sd_printk(KERN_ERR, sdkp,
> -                         "Will Corrupt RESET WP %zx/%x/%x on zone %zx/%zx/%zx\n",
> -                         sector, wp_offset, nr_sectors,
> -                         zone->start, zone->wp, zone->len);
> +                         "Will Corrupt RESET WP %zx/%zx/%x on zone %zx/%zx/%zx\n",
> +                         sector, (sector_t)zone->wp, nr_sectors,
> +                         z_start, z_start + zone->wp, z_len);
>                 ret = BLKPREP_KILL;
>                 goto out;
>         }
>         if (blk_zone_is_empty(zone)) {
>                 sd_zbc_debug_ratelimit(sdkp,
>                                        "Discarding empty zone %zx [WP: %zx]\n",
> -                                      zone->start, zone->wp);
> +                                      z_start, (sector_t)zone->wp);
>                 ret = BLKPREP_DONE;
>                 goto out;
>         }
> @@ -563,8 +461,8 @@ out:
>          * zone update if RESET WRITE POINTER fails.
>          */
>         if (ret == BLKPREP_OK && !use_write_same)
> -               zone->wp = zone->start;
> -       spin_unlock_irqrestore(&zone->lock, flags);
> +               zone->wp = 0;
> +       spin_unlock_irqrestore(lck, flags);
>
>         if (ret == BLKPREP_OK)
>                 discard_or_write_same(cmd, sector, nr_sectors, use_write_same);
> @@ -573,13 +471,14 @@ out:
>  }
>
>
> -static void __set_zone_state(struct blk_zone *zone, int op)
> +static void __set_zone_state(struct blk_zone *zone, sector_t z_len,
> +                            spinlock_t *lck, int op)
>  {
>         unsigned long flags;
>
> -       spin_lock_irqsave(&zone->lock, flags);
> -       if (blk_zone_is_cmr(zone))
> -               goto out_unlock;
> +       spin_lock_irqsave(lck, flags);
> +       if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
> +               goto out;
>
>         switch (op) {
>         case REQ_OP_ZONE_OPEN:
> @@ -587,38 +486,45 @@ static void __set_zone_state(struct blk_zone *zone, int op)
>                 break;
>         case REQ_OP_ZONE_FINISH:
>                 zone->state = BLK_ZONE_FULL;
> -               zone->wp = zone->start + zone->len;
> +               zone->wp = z_len;
>                 break;
>         case REQ_OP_ZONE_CLOSE:
>                 zone->state = BLK_ZONE_CLOSED;
>                 break;
>         case REQ_OP_ZONE_RESET:
> -               zone->wp = zone->start;
> +               zone->wp = 0;
>                 break;
>         default:
>                 WARN_ONCE(1, "%s: invalid op code: %u\n", __func__, op);
>         }
> -out_unlock:
> -       spin_unlock_irqrestore(&zone->lock, flags);
> +out:
> +       spin_unlock_irqrestore(lck, flags);
>  }
>
>  static void update_zone_state(struct request *rq, sector_t lba, unsigned int op)
>  {
> -       struct request_queue *q = rq->q;
> -       struct blk_zone *zone = NULL;
> +       struct blk_zone *zone;
>
>         if (lba == ~0ul) {
> -               struct rb_node *node;
> -
> -               for (node = rb_first(&q->zones); node; node = rb_next(node)) {
> -                       zone = rb_entry(node, struct blk_zone, node);
> -                       __set_zone_state(zone, op);
> +               struct zone_wps *zi = rq->q->zones;
> +               struct contiguous_wps *wp;
> +               u32 iter, entry;
> +
> +               for (iter = 0; iter < zi->wps_count; iter++) {
> +                       wp = zi->wps[iter];
> +                       for (entry = 0; entry < wp->zone_count; entry++) {
> +                               zone = &wp->zones[entry];
> +                               __set_zone_state(zone, wp->zone_size, &wp->lock,
> +                                                op);
> +                       }
>                 }
> -               return;
>         } else {
> -               zone = blk_lookup_zone(q, lba);
> +               sector_t z_start, z_len;
> +               spinlock_t *lck;
> +
> +               zone = blk_lookup_zone(rq->q, lba, &z_start, &z_len, &lck);
>                 if (zone)
> -                       __set_zone_state(zone, op);
> +                       __set_zone_state(zone, z_len, lck, op);
>         }
>  }
>
> @@ -641,6 +547,8 @@ int sd_zbc_setup_zone_action(struct scsi_cmnd *cmd)
>         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
>         sector_t sector = blk_rq_pos(rq);
>         struct blk_zone *zone;
> +       spinlock_t *lck;
> +       sector_t z_start, z_len;
>         unsigned long flags;
>         unsigned int nr_sectors;
>         int ret = BLKPREP_DONE;
> @@ -651,17 +559,17 @@ int sd_zbc_setup_zone_action(struct scsi_cmnd *cmd)
>         if (is_fua || op != REQ_OP_ZONE_RESET)
>                 goto out;
>
> -       zone = blk_lookup_zone(rq->q, sector);
> +       zone = blk_lookup_zone(rq->q, sector, &z_start, &z_len, &lck);
>         if (!zone || sdkp->provisioning_mode != SD_ZBC_RESET_WP)
>                 goto out;
>
>         /* Map a Reset WP w/o FUA to a discard request */
> -       spin_lock_irqsave(&zone->lock, flags);
> -       sector = zone->start;
> -       nr_sectors = zone->len;
> +       spin_lock_irqsave(lck, flags);
> +       sector = z_start;
> +       nr_sectors = z_len;
>         if (blk_zone_is_cmr(zone))
>                 use_write_same = true;
> -       spin_unlock_irqrestore(&zone->lock, flags);
> +       spin_unlock_irqrestore(lck, flags);
>
>         rq->completion_data = NULL;
>         if (use_write_same) {
> @@ -712,137 +620,157 @@ static sector_t bzrpt_fill(struct request *rq,
>                            struct bdev_zone_descriptor *bzd,
>                            size_t sz, sector_t lba, u8 opt)
>  {
> -       struct request_queue *q = rq->q;
>         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
> +       struct scsi_device *sdp = sdkp->device;
> +       struct zone_wps *zi = rq->q->zones;
> +       struct contiguous_wps *wpdscr;
>         struct blk_zone *zone = NULL;
> -       struct rb_node *node = NULL;
>         sector_t progress = lba;
>         sector_t clen = ~0ul;
> +       sector_t z_start, z_len, z_wp_abs;
>         unsigned long flags;
>         u32 max_entries = bzrpt ? max_report_entries(sz) : sz / sizeof(*bzd);
>         u32 entry = 0;
> +       u32 iter, idscr;
>         int len_diffs = 0;
>         int type_diffs = 0;
>         u8 ctype;
>         u8 same = 0;
>
> -       zone = blk_lookup_zone(q, lba);
> -       if (zone)
> -               node = &zone->node;
> -
> -       for (entry = 0; entry < max_entries && node; node = rb_next(node)) {
> -               u64 z_len, z_start, z_wp_abs;
> -               u8 cond = 0;
> -               u8 flgs = 0;
> -
> -               spin_lock_irqsave(&zone->lock, flags);
> -               z_len = zone->len;
> -               z_start = zone->start;
> -               z_wp_abs = zone->wp;
> -               progress = z_start + z_len;
> -               cond = zone->state;
> -               if (blk_zone_is_cmr(zone))
> -                       flgs |= 0x02;
> -               else if (zone->wp != zone->start)
> -                       flgs |= 0x01; /* flag as RWP recommended? */
> -               spin_unlock_irqrestore(&zone->lock, flags);
> -
> -               switch (opt & ZBC_REPORT_OPTION_MASK) {
> -               case ZBC_ZONE_REPORTING_OPTION_EMPTY:
> -                       if (z_wp_abs != z_start)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_IMPLICIT_OPEN:
> -                       if (cond != BLK_ZONE_OPEN)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_EXPLICIT_OPEN:
> -                       if (cond != BLK_ZONE_OPEN_EXPLICIT)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_CLOSED:
> -                       if (cond != BLK_ZONE_CLOSED)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_FULL:
> -                       if (cond != BLK_ZONE_FULL)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_READONLY:
> -                       if (cond == BLK_ZONE_READONLY)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_OFFLINE:
> -                       if (cond == BLK_ZONE_OFFLINE)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_NEED_RESET_WP:
> -                       if (z_wp_abs == z_start)
> -                               continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_NON_WP:
> -                       if (cond == BLK_ZONE_NO_WP)
> +       for (iter = 0; entry < max_entries && iter < zi->wps_count; iter++) {
> +               wpdscr = zi->wps[iter];
> +               if (lba > wpdscr->last_lba)
> +                       continue;
> +
> +               spin_lock_irqsave(&wpdscr->lock, flags);
> +               for (idscr = 0;
> +                    entry < max_entries && idscr < wpdscr->zone_count;
> +                    idscr++) {
> +                       struct bdev_zone_descriptor *dscr;
> +                       u64 zoff = idscr * wpdscr->zone_size;
> +                       u8 cond, flgs = 0;
> +
> +                       z_len = wpdscr->zone_size;
> +                       zoff = idscr * z_len;
> +                       z_start = wpdscr->start_lba + zoff;
> +                       if (lba >= z_start + z_len)
>                                 continue;
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_NON_SEQWRITE:
> -                       /* this can only be reported by the HW */
> -                       break;
> -               case ZBC_ZONE_REPORTING_OPTION_ALL:
> -               default:
> -                       break;
> -               }
>
> -               /* if same code only applies to returned zones */
> -               if (opt & ZBC_REPORT_ZONE_PARTIAL) {
> -                       if (clen != ~0ul) {
> -                               clen = z_len;
> +                       zone = &wpdscr->zones[idscr];
> +                       if (blk_zone_is_cmr(zone))
> +                               z_wp_abs = z_start + wpdscr->zone_size;
> +                       else
> +                               z_wp_abs = z_start + zone->wp;
> +
> +                       switch (opt & ZBC_REPORT_OPTION_MASK) {
> +                       case ZBC_ZONE_REPORTING_OPTION_EMPTY:
> +                               if (z_wp_abs != z_start)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_IMPLICIT_OPEN:
> +                               if (zone->state != BLK_ZONE_OPEN)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_EXPLICIT_OPEN:
> +                               if (zone->state != BLK_ZONE_OPEN_EXPLICIT)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_CLOSED:
> +                               if (zone->state != BLK_ZONE_CLOSED)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_FULL:
> +                               if (zone->state != BLK_ZONE_FULL)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_READONLY:
> +                               if (zone->state == BLK_ZONE_READONLY)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_OFFLINE:
> +                               if (zone->state == BLK_ZONE_OFFLINE)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_NEED_RESET_WP:
> +                               if (z_wp_abs == z_start)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_NON_WP:
> +                               if (zone->state == BLK_ZONE_NO_WP)
> +                                       continue;
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_NON_SEQWRITE:
> +                               /* this can only be reported by the HW */
> +                               break;
> +                       case ZBC_ZONE_REPORTING_OPTION_ALL:
> +                       default:
> +                               break;
> +                       }
> +
> +                       /* if same code only applies to returned zones */
> +                       if (opt & ZBC_REPORT_ZONE_PARTIAL) {
> +                               if (clen != ~0ul) {
> +                                       clen = z_len;
> +                                       ctype = zone->type;
> +                               }
> +                               if (z_len != clen)
> +                                       len_diffs++;
> +                               if (zone->type != ctype)
> +                                       type_diffs++;
>                                 ctype = zone->type;
>                         }
> -                       if (z_len != clen)
> -                               len_diffs++;
> -                       if (zone->type != ctype)
> -                               type_diffs++;
> -                       ctype = zone->type;
> -               }
> +                       progress = z_start + z_len;
>
> -               /* shift to device units */
> -               z_start >>= ilog2(sdkp->device->sector_size) - 9;
> -               z_len >>= ilog2(sdkp->device->sector_size) - 9;
> -               z_wp_abs >>= ilog2(sdkp->device->sector_size) - 9;
> +                       if (!bzd) {
> +                               if (bzrpt)
> +                                       bzrpt->descriptor_count =
> +                                               cpu_to_be32(++entry);
> +                               continue;
> +                       }
>
> -               if (!bzd) {
> +                       /* shift to device units */
> +                       z_start >>= ilog2(sdp->sector_size) - 9;
> +                       z_len >>= ilog2(sdp->sector_size) - 9;
> +                       z_wp_abs >>= ilog2(sdp->sector_size) - 9;
> +
> +                       cond = zone->state;
> +                       if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
> +                               flgs |= 0x02;
> +                       else if (zone->wp)
> +                               flgs |= 0x01; /* flag as RWP recommended? */
> +
> +                       dscr = &bzd[entry];
> +                       dscr->lba_start = cpu_to_be64(z_start);
> +                       dscr->length = cpu_to_be64(z_len);
> +                       dscr->lba_wptr = cpu_to_be64(z_wp_abs);
> +                       dscr->type = zone->type;
> +                       dscr->flags = cond << 4 | flgs;
> +                       entry++;
>                         if (bzrpt)
> -                               bzrpt->descriptor_count =
> -                                       cpu_to_be32(++entry);
> -                       continue;
> +                               bzrpt->descriptor_count = cpu_to_be32(entry);
>                 }
> -
> -               bzd[entry].lba_start = cpu_to_be64(z_start);
> -               bzd[entry].length = cpu_to_be64(z_len);
> -               bzd[entry].lba_wptr = cpu_to_be64(z_wp_abs);
> -               bzd[entry].type = zone->type;
> -               bzd[entry].flags = cond << 4 | flgs;
> -               entry++;
> -               if (bzrpt)
> -                       bzrpt->descriptor_count = cpu_to_be32(entry);
> +               spin_unlock_irqrestore(&wpdscr->lock, flags);
>         }
>
>         /* if same code applies to all zones */
>         if (bzrpt && !(opt & ZBC_REPORT_ZONE_PARTIAL)) {
> -               for (node = rb_first(&q->zones); node; node = rb_next(node)) {
> -                       zone = rb_entry(node, struct blk_zone, node);
> -
> -                       spin_lock_irqsave(&zone->lock, flags);
> -                       if (clen != ~0ul) {
> -                               clen = zone->len;
> +               for (iter = 0; iter < zi->wps_count; iter++) {
> +                       wpdscr = zi->wps[iter];
> +                       spin_lock_irqsave(&wpdscr->lock, flags);
> +                       for (idscr = 0; idscr < wpdscr->zone_count; idscr++) {
> +                               z_len = wpdscr->zone_size;
> +                               zone = &wpdscr->zones[idscr];
> +                               if (clen != ~0ul) {
> +                                       clen = z_len;
> +                                       ctype = zone->type;
> +                               }
> +                               if (z_len != clen)
> +                                       len_diffs++;
> +                               if (zone->type != ctype)
> +                                       type_diffs++;
>                                 ctype = zone->type;
>                         }
> -                       if (zone->len != clen)
> -                               len_diffs++;
> -                       if (zone->type != ctype)
> -                               type_diffs++;
> -                       ctype = zone->type;
> -                       spin_unlock_irqrestore(&zone->lock, flags);
> +                       spin_unlock_irqrestore(&wpdscr->lock, flags);
>                 }
>         }
>
> @@ -985,12 +913,15 @@ out:
>  int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>                             sector_t sector, unsigned int *num_sectors)
>  {
> +       struct request_queue *q = sdkp->disk->queue;
>         struct blk_zone *zone;
> +       sector_t z_start, z_len;
> +       spinlock_t *lck;
>         unsigned int sectors = *num_sectors;
>         int ret = BLKPREP_OK;
>         unsigned long flags;
>
> -       zone = blk_lookup_zone(sdkp->disk->queue, sector);
> +       zone = blk_lookup_zone(q, sector, &z_start, &z_len, &lck);
>         if (!zone) {
>                 /* Might happen during zone initialization */
>                 sd_zbc_debug_ratelimit(sdkp,
> @@ -999,7 +930,7 @@ int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>                 return BLKPREP_OK;
>         }
>
> -       spin_lock_irqsave(&zone->lock, flags);
> +       spin_lock_irqsave(lck, flags);
>
>         if (blk_zone_is_cmr(zone))
>                 goto out;
> @@ -1008,7 +939,7 @@ int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>             zone->state == BLK_ZONE_BUSY) {
>                 sd_zbc_debug_ratelimit(sdkp,
>                                        "zone %zu state %x, deferring\n",
> -                                      zone->start, zone->state);
> +                                      z_start, zone->state);
>                 ret = BLKPREP_DEFER;
>                 goto out;
>         }
> @@ -1017,25 +948,22 @@ int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>                 if (op_is_write(req_op(rq))) {
>                         u64 nwp = sector + sectors;
>
> -                       while (nwp > (zone->start + zone->len)) {
> -                               struct rb_node *node = rb_next(&zone->node);
> +                       while (nwp > (z_start + z_len)) {
> +                               zone->wp = z_len;
> +                               sector = z_start + z_len;
> +                               sectors = nwp - sector;
> +                               spin_unlock_irqrestore(lck, flags);
>
> -                               zone->wp = zone->start + zone->len;
> -                               sector = zone->wp;
> -                               sectors = nwp - zone->wp;
> -                               spin_unlock_irqrestore(&zone->lock, flags);
> -
> -                               if (!node)
> -                                       return BLKPREP_OK;
> -                               zone = rb_entry(node, struct blk_zone, node);
> +                               zone = blk_lookup_zone(q, sector,
> +                                                      &z_start, &z_len, &lck);
>                                 if (!zone)
>                                         return BLKPREP_OK;
>
> -                               spin_lock_irqsave(&zone->lock, flags);
> +                               spin_lock_irqsave(lck, flags);
>                                 nwp = sector + sectors;
>                         }
> -                       if (nwp > zone->wp)
> -                               zone->wp = nwp;
> +                       if (nwp > z_start + zone->wp)
> +                               zone->wp = nwp - z_start;
>                 }
>                 goto out;
>         }
> @@ -1044,37 +972,37 @@ int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>                 /* let the drive fail the command */
>                 sd_zbc_debug_ratelimit(sdkp,
>                                        "zone %zu offline\n",
> -                                      zone->start);
> +                                      z_start);
>                 goto out;
>         }
>
>         if (op_is_write(req_op(rq))) {
>                 if (zone->state == BLK_ZONE_READONLY)
>                         goto out;
> -               if (blk_zone_is_full(zone)) {
> +               if (zone->wp == z_len) {
>                         sd_zbc_debug(sdkp,
> -                                    "Write to full zone %zu/%zu\n",
> -                                    sector, zone->wp);
> +                                    "Write to full zone %zu/%zu/%zu\n",
> +                                    sector, (sector_t)zone->wp, z_len);
>                         ret = BLKPREP_KILL;
>                         goto out;
>                 }
> -               if (zone->wp != sector) {
> +               if (sector != (z_start + zone->wp)) {
>                         sd_zbc_debug(sdkp,
>                                      "Misaligned write %zu/%zu\n",
> -                                    sector, zone->wp);
> +                                    sector, z_start + zone->wp);
>                         ret = BLKPREP_KILL;
>                         goto out;
>                 }
>                 zone->wp += sectors;
> -       } else if (zone->wp <= sector + sectors) {
> -               if (zone->wp <= sector) {
> +       } else if (z_start + zone->wp <= sector + sectors) {
> +               if (z_start + zone->wp <= sector) {
>                         /* Read beyond WP: clear request buffer */
>                         struct req_iterator iter;
>                         struct bio_vec bvec;
>                         void *buf;
>                         sd_zbc_debug(sdkp,
>                                      "Read beyond wp %zu+%u/%zu\n",
> -                                    sector, sectors, zone->wp);
> +                                    sector, sectors, z_start + zone->wp);
>                         rq_for_each_segment(bvec, rq, iter) {
>                                 buf = bvec_kmap_irq(&bvec, &flags);
>                                 memset(buf, 0, bvec.bv_len);
> @@ -1085,15 +1013,15 @@ int sd_zbc_setup_read_write(struct scsi_disk *sdkp, struct request *rq,
>                         goto out;
>                 }
>                 /* Read straddle WP position: limit request size */
> -               *num_sectors = zone->wp - sector;
> +               *num_sectors = z_start + zone->wp - sector;
>                 sd_zbc_debug(sdkp,
>                              "Read straddle wp %zu+%u/%zu => %zu+%u\n",
> -                            sector, sectors, zone->wp,
> +                            sector, sectors, z_start + zone->wp,
>                              sector, *num_sectors);
>         }
>
>  out:
> -       spin_unlock_irqrestore(&zone->lock, flags);
> +       spin_unlock_irqrestore(lck, flags);
>
>         return ret;
>  }
> @@ -1145,21 +1073,22 @@ static void update_zones_from_report(struct scsi_cmnd *cmd, u32 nr_bytes)
>                         struct bdev_zone_descriptor *entry = &bzde[iter];
>                         sector_t s = get_start_from_desc(sdkp, entry);
>                         sector_t z_len = get_len_from_desc(sdkp, entry);
> +                       sector_t z_strt;
> +                       spinlock_t *lck;
>                         unsigned long flags;
>
>                         if (!z_len)
>                                 goto done;
>
> -                       zone = blk_lookup_zone(rq->q, s);
> +                       zone = blk_lookup_zone(rq->q, s, &z_strt, &z_len, &lck);
>                         if (!zone)
>                                 goto done;
>
> -                       spin_lock_irqsave(&zone->lock, flags);
> +                       spin_lock_irqsave(lck, flags);
>                         zone->type = entry->type & 0xF;
>                         zone->state = (entry->flags >> 4) & 0xF;
>                         zone->wp = get_wp_from_desc(sdkp, entry);
> -                       zone->len = z_len;
> -                       spin_unlock_irqrestore(&zone->lock, flags);
> +                       spin_unlock_irqrestore(lck, flags);
>                 }
>                 nread += len;
>                 if (!dmax)
> @@ -1233,113 +1162,314 @@ void sd_zbc_uninit_command(struct scsi_cmnd *cmd)
>  }
>
>  /**
> - * sd_zbc_init - Load zones of matching zlen size into rb tree.
> + * alloc_cpws() - Allocate space for a contiguous set of write pointers
> + * @items: Number of wps needed.
> + * @lba: lba of the start of the next zone.
> + * @z_start: Starting lba of this contiguous set.
> + * @z_size: Size of each zone this contiguous set.
>   *
> + * Return: Allocated wps or NULL on error.
>   */
> -static int sd_zbc_init(struct scsi_disk *sdkp, u64 zlen, char *buf, int buf_len)
> +static struct contiguous_wps *alloc_cpws(int items, u64 lba, u64 z_start,
> +                                        u64 z_size)
>  {
> -       sector_t capacity = logical_to_sectors(sdkp->device, sdkp->capacity);
> -       sector_t last_sector;
> +       struct contiguous_wps *cwps = NULL;
> +       size_t sz;
>
> -       if (test_and_set_bit(SD_ZBC_ZONE_INIT, &sdkp->zone_flags)) {
> -               sdev_printk(KERN_WARNING, sdkp->device,
> -                           "zone initialization already running\n");
> -               return 0;
> +       sz = sizeof(struct contiguous_wps) + (items * sizeof(struct blk_zone));
> +       if (items) {
> +               cwps = vzalloc(sz);
> +               if (!cwps)
> +                       goto out;
> +               spin_lock_init(&cwps->lock);
> +               cwps->start_lba = z_start;
> +               cwps->last_lba = lba - 1;
> +               cwps->zone_size = z_size;
> +               cwps->is_zoned = items > 1 ? 1 : 0;
> +               cwps->zone_count = items;
>         }
>
> -       if (!sdkp->zone_work_q) {
> -               char wq_name[32];
> +out:
> +       return cwps;
> +}
>
> -               sprintf(wq_name, "zbc_wq_%s", sdkp->disk->disk_name);
> -               sdkp->zone_work_q = create_singlethread_workqueue(wq_name);
> -               if (!sdkp->zone_work_q) {
> -                       sdev_printk(KERN_WARNING, sdkp->device,
> -                                   "create zoned disk workqueue failed\n");
> -                       return -ENOMEM;
> +/**
> + * free_zone_wps() - Free up memory in use by wps
> + * @zi: zone wps array(s).
> + */
> +static void free_zone_wps(struct zone_wps *zi)
> +{
> +       /* on error free the arrays */
> +       if (zi && zi->wps) {
> +               int ca;
> +
> +               for (ca = 0; ca < zi->wps_count; ca++) {
> +                       if (zi->wps[ca]) {
> +                               vfree(zi->wps[ca]);
> +                               zi->wps[ca] = NULL;
> +                       }
>                 }
> -       } else if (!test_and_set_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags)) {
> -               drain_workqueue(sdkp->zone_work_q);
> -               clear_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags);
> +               kfree(zi->wps);
>         }
> +}
>
> -       last_sector = zbc_parse_zones(sdkp, zlen, buf, buf_len);
> -       capacity = logical_to_sectors(sdkp->device, sdkp->capacity);
> -       if (last_sector != -1 && last_sector < capacity) {
> -               sd_zbc_update_zones(sdkp, last_sector,
> -                                   SD_ZBC_BUF_SIZE, SD_ZBC_INIT);
> -       } else
> -               clear_bit(SD_ZBC_ZONE_INIT, &sdkp->zone_flags);
> +static int wps_realloc(struct zone_wps *zi, gfp_t gfp_mask)
> +{
> +       int rcode = 0;
> +       struct contiguous_wps **old;
> +       struct contiguous_wps **tmp;
> +       int n = zi->wps_count * 2;
> +
> +       old = zi->wps;
> +       tmp = kzalloc(n, sizeof(*zi->wps), gfp_mask);

Apologies, should be kcalloc() here.

> +       if (!tmp) {
> +               rcode = -ENOMEM;
> +               goto out;
> +       }
> +       memcpy(tmp, zi->wps, zi->wps_count * sizeof(*zi->wps));
> +       zi->wps = tmp;
> +       kfree(old);
>
> -       return 0;
> +out:
> +       return rcode;
>  }
>
> +#define FMT_CHANGING_CAPACITY "Changing capacity from %zu to Max LBA+1 %zu"
> +
>  /**
> - * sd_zbc_config() - Configure a ZBC device (on attach)
> - * @sdkp: SCSI disk being attached.
> - * @buffer: Buffer to working data.
> - * @buf_sz: Size of buffer to use for working data
> + * zbc_init_zones() - Re-Sync expected WP location with drive
> + * @sdkp: scsi_disk
> + * @gfp_mask: Allocation mask.
>   *
> - * Return: true of SD_ZBC_RESET_WP provisioning is supported
> + * Return: 0 on success, otherwise error.
>   */
> -bool sd_zbc_config(struct scsi_disk *sdkp, void *buffer, size_t buf_sz)
> +int zbc_init_zones(struct scsi_disk *sdkp, gfp_t gfp_mask)
>  {
> -       struct bdev_zone_report *bzrpt = buffer;
> -       u64 zone_len, lba;
> -       int retval;
> -       u32 rep_len;
> -       u8 same;
> +       struct request_queue *q = sdkp->disk->queue;
> +       int rcode = 0;
> +       int entry = 0;
> +       int offset;
> +       int offmax;
> +       u64 iter;
> +       u64 z_start = 0ul;
> +       u64 z_size = 0; /* size of zone */
> +       int z_count = 0; /* number of zones of z_size */
> +       int do_fill = 0;
> +       int array_count = 0;
> +       int one_time_setup = 0;
> +       u8 opt = ZBC_ZONE_REPORTING_OPTION_ALL;
> +       size_t bufsz = SD_ZBC_BUF_SIZE;
> +       struct bdev_zone_report *rpt = NULL;
> +       struct zone_wps *zi = NULL;
> +       struct contiguous_wps *cwps = NULL;
> +
> +       if (q->zones)
> +               goto out;
>
> -       if (sdkp->zoned != 1 && sdkp->device->type != TYPE_ZBC)
> -               /*
> -                * Device managed or normal SCSI disk,
> -                * no special handling required
> -                */
> -               return false;
> -
> -       retval = sd_zbc_report_zones(sdkp, bzrpt, buf_sz,
> -                                    0, ZBC_ZONE_REPORTING_OPTION_ALL, false);
> -       if (retval < 0)
> -               return false;
> -
> -       rep_len = be32_to_cpu(bzrpt->descriptor_count);
> -       if (rep_len < 7) {
> -               sd_printk(KERN_WARNING, sdkp,
> -                         "REPORT ZONES report invalid length %u\n",
> -                         rep_len);
> -               return false;
> +       zi = kzalloc(sizeof(*zi), gfp_mask);
> +       if (!zi) {
> +               rcode = -ENOMEM;
> +               goto out;
>         }
>
> -       if (sdkp->rc_basis == 0) {
> -               /* The max_lba field is the capacity of a zoned device */
> -               lba = be64_to_cpu(bzrpt->maximum_lba);
> -               if (lba + 1 > sdkp->capacity) {
> -                       if (sdkp->first_scan)
> -                               sd_printk(KERN_WARNING, sdkp,
> -                                         "Changing capacity from %zu to Max LBA+1 %zu\n",
> -                                         sdkp->capacity, (sector_t) lba + 1);
> -                       sdkp->capacity = lba + 1;
> +       if (sdkp->zoned != 1 && sdkp->device->type != TYPE_ZBC) {
> +               struct gendisk *disk = sdkp->disk;
> +
> +               zi->wps = kzalloc(sizeof(*zi->wps), gfp_mask);
> +               zi->wps[0] = alloc_cpws(1, disk->part0.nr_sects, z_start, 1);
> +               if (!zi->wps[0]) {
> +                       rcode = -ENOMEM;
> +                       goto out;
>                 }
> +               zi->wps_count = 1;
> +               goto out;
> +       }
> +
> +       rpt = kmalloc(bufsz, gfp_mask);
> +       if (!rpt) {
> +               rcode = -ENOMEM;
> +               goto out;
>         }
>
>         /*
> -        * Adjust 'chunk_sectors' to the zone length if the device
> -        * supports equal zone sizes.
> +        * Start by handling upto 32 different zone sizes. 2 will work
> +        * for all the current drives, but maybe something exotic will
> +        * surface.
>          */
> -       same = bzrpt->same_field & 0x0f;
> -       if (same > 3) {
> -               sd_printk(KERN_WARNING, sdkp,
> -                         "REPORT ZONES SAME type %d not supported\n", same);
> -               return false;
> +       zi->wps = kcalloc(32, sizeof(*zi->wps), gfp_mask);
> +       zi->wps_count = 32;
> +       if (!zi->wps) {
> +               rcode = -ENOMEM;
> +               goto out;
>         }
> -       /* Read the zone length from the first zone descriptor */
> -       zone_len = be64_to_cpu(bzrpt->descriptors[0].length);
> -       sdkp->unmap_alignment = zone_len;
> -       sdkp->unmap_granularity = zone_len;
> -       blk_queue_chunk_sectors(sdkp->disk->queue,
> -                               logical_to_sectors(sdkp->device, zone_len));
> -
> -       sd_zbc_init(sdkp, zone_len, buffer, buf_sz);
> -       return true;
> +
> +fill:
> +       offset = 0;
> +       offmax = 0;
> +       for (entry = 0, iter = 0; iter < sdkp->capacity; entry++) {
> +               struct bdev_zone_descriptor *bzde;
> +               int stop_end = 0;
> +               int stop_size = 0;
> +
> +               if (offset == 0) {
> +                       int err;
> +
> +                       err = sd_zbc_report_zones(sdkp, rpt, bufsz, iter, opt);
> +                       if (err) {
> +                               pr_err("report zones-> %d\n", err);
> +                               if (err != -ENOTSUPP)
> +                                       rcode = err;
> +                               goto out;
> +                       }
> +                       if (sdkp->rc_basis == 0) {
> +                               sector_t lba = be64_to_cpu(rpt->maximum_lba);
> +
> +                               if (lba + 1 > sdkp->capacity) {
> +                                       sd_printk(KERN_WARNING, sdkp,
> +                                                 FMT_CHANGING_CAPACITY "\n",
> +                                                 sdkp->capacity, lba + 1);
> +                                       sdkp->capacity = lba + 1;
> +                               }
> +                       }
> +                       offmax = max_report_entries(bufsz);
> +               }
> +               bzde = &rpt->descriptors[offset];
> +               if (z_size == 0)
> +                       z_size = get_len_from_desc(sdkp, bzde);
> +               if (z_size != get_len_from_desc(sdkp, bzde))
> +                       stop_size = 1;
> +               if ((iter + z_size) >= sdkp->capacity)
> +                       stop_end = 1;
> +
> +               if (!one_time_setup) {
> +                       u8 type = bzde->type & 0x0F;
> +
> +                       if (type != BLK_ZONE_TYPE_CONVENTIONAL) {
> +                               one_time_setup = 1;
> +                               blk_queue_chunk_sectors(sdkp->disk->queue,
> +                                                       z_size);
> +                       }
> +               }
> +
> +               if (do_fill == 0) {
> +                       if (stop_end || stop_size) {
> +                               /* include the next/last zone? */
> +                               if (!stop_size) {
> +                                       z_count++;
> +                                       iter += z_size;
> +                               }
> +                               cwps = alloc_cpws(z_count, iter,
> +                                                 z_start, z_size);
> +                               if (!cwps) {
> +                                       rcode = -ENOMEM;
> +                                       goto out;
> +                               }
> +                               if (array_count > 0)
> +                                       cwps->is_zoned = 1;
> +
> +                               zi->wps[array_count] = cwps;
> +                               z_start = iter;
> +                               z_size = 0;
> +                               z_count = 0;
> +                               array_count++;
> +                               if (array_count >= zi->wps_count) {
> +                                       rcode = wps_realloc(zi, gfp_mask);
> +                                       if (rcode)
> +                                               goto out;
> +                               }
> +                               /* add the runt zone */
> +                               if (stop_end && stop_size) {
> +                                       z_count++;
> +                                       z_size = get_len_from_desc(sdkp, bzde);
> +                                       cwps = alloc_cpws(z_count,
> +                                                         iter + z_size,
> +                                                         z_start, z_size);
> +                                       if (!cwps) {
> +                                               rcode = -ENOMEM;
> +                                               goto out;
> +                                       }
> +                                       if (array_count > 0)
> +                                               cwps->is_zoned = 1;
> +                                       zi->wps[array_count] = cwps;
> +                                       array_count++;
> +                               }
> +                               if (stop_end) {
> +                                       do_fill = 1;
> +                                       array_count = 0;
> +                                       z_count = 0;
> +                                       z_size = 0;
> +                                       goto fill;
> +                               }
> +                       }
> +                       z_size = get_len_from_desc(sdkp, bzde);
> +                       iter += z_size;
> +                       z_count++;
> +               } else {
> +                       fill_zone(zi->wps[array_count], z_count, sdkp, bzde);
> +                       z_count++;
> +                       iter += z_size;
> +                       if (zi->wps[array_count]->zone_count == z_count) {
> +                               z_count = 0;
> +                               array_count++;
> +                               zi->wps_count = array_count;
> +                       }
> +               }
> +               offset++;
> +               if (offset >= offmax)
> +                       offset = 0;
> +       }
> +out:
> +       kfree(rpt);
> +
> +       if (rcode) {
> +               if (zi) {
> +                       free_zone_wps(zi);
> +                       kfree(zi);
> +               }
> +       } else {
> +               q->zones = zi;
> +       }
> +
> +       return rcode;
> +}
> +
> +/**
> + * sd_zbc_config() - Configure a ZBC device (on attach)
> + * @sdkp: SCSI disk being attached.
> + * @gfp_mask: Memory allocation strategy
> + *
> + * Return: true of SD_ZBC_RESET_WP provisioning is supported
> + */
> +bool sd_zbc_config(struct scsi_disk *sdkp, gfp_t gfp_mask)
> +{
> +       bool can_reset_wp = false;
> +
> +       if (zbc_init_zones(sdkp, gfp_mask)) {
> +               sdev_printk(KERN_WARNING, sdkp->device,
> +                           "Initialize zone cache failed\n");
> +               goto out;
> +       }
> +
> +       if (sdkp->zoned == 1 || sdkp->device->type == TYPE_ZBC)
> +               can_reset_wp = true;
> +
> +       if (!sdkp->zone_work_q) {
> +               char wq_name[32];
> +
> +               sprintf(wq_name, "zbc_wq_%s", sdkp->disk->disk_name);
> +               sdkp->zone_work_q = create_singlethread_workqueue(wq_name);
> +               if (!sdkp->zone_work_q) {
> +                       sdev_printk(KERN_WARNING, sdkp->device,
> +                                   "create zoned disk workqueue failed\n");
> +                       goto out;
> +               }
> +       } else if (!test_and_set_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags)) {
> +               drain_workqueue(sdkp->zone_work_q);
> +               clear_bit(SD_ZBC_ZONE_RESET, &sdkp->zone_flags);
> +       }
> +
> +out:
> +       return can_reset_wp;
>  }
>
>  /**
> @@ -1365,15 +1495,16 @@ void sd_zbc_remove(struct scsi_disk *sdkp)
>   */
>  unsigned int sd_zbc_discard_granularity(struct scsi_disk *sdkp)
>  {
> -       unsigned int bytes = 1;
>         struct request_queue *q = sdkp->disk->queue;
> -       struct rb_node *node = rb_first(&q->zones);
> +       struct zone_wps *zi = q->zones;
> +       unsigned int bytes = 1;
>
> -       if (node) {
> -               struct blk_zone *zone = rb_entry(node, struct blk_zone, node);
> +       if (zi && zi->wps_count > 0) {
> +               struct contiguous_wps *wp = zi->wps[0];
>
> -               bytes = zone->len;
> +               bytes = wp->zone_size;
>         }
> +
>         bytes <<= ilog2(sdkp->device->sector_size);
>         return bytes;
>  }
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> index d5cdb5d..113c5a8 100644
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -264,27 +264,83 @@ struct blk_queue_tag {
>
>  #ifdef CONFIG_BLK_DEV_ZONED
>
> +/**
> + * struct blk_zone - A single zone type/stats and WP offset.
> + *
> + * @wp:    Holds the wp offset from the start of the zone.
> + * @type:  Holds the zone type nibble.
> + * @state: Holds the zone state nibble + kernel (zone busy)
> + * @private_data: Used to hold whatever the implicit domain owner
> + *                of the zone needs to track.
> + *
> + * Type is left at 4 bits (only 2 are needed currently) to match
> + * the current ZBC/ZAC standards.
> + *
> + * State is using 5 bits to accommodate the ZONE_BUSY. The first 4 bits
> + * match the current ZBC/ZAC spec.
> + * ZONE_BUSY could be mapped to one of the reserved bits. Using it as
> + * mask bit or independent flag my be useful for decoding the zone
> + * state before it transitioned to BUSY.
> + *
> + * A zone sized at order (39+9) is very unlikely (current zones are 16+9)
> + * Even at lba48 equivalent number of sectors we have a large amount
> + * of padding to fill out 8 bytes.
> + *
> + * Getting this to fit in 4 bytes would limit the maximum size of a zone
> + * to 4G [order 23 of 512 byte sectors + 9 bits for flags] which is probably
> + * okay for embedded or 32-bit systems where the private_data pointer
> + * would also shrink to 32 bits. There are also WP tracking schemes
> + * that don't make use of the private_data helper so perhaps that
> + * could be factored out as well.
> + */
>  struct blk_zone {
> -       struct rb_node node;
> -       spinlock_t lock;
> -       sector_t start;
> -       size_t len;
> -       sector_t wp;
> -       enum blk_zone_type type;
> -       enum blk_zone_state state;
> +       unsigned long long wp:39;
> +       unsigned long long type:4;
> +       unsigned long long state:5;
> +       unsigned long long padding:15;
>         void *private_data;
>  };
>
> +/**
> + * struct contiguous_wps - A descriptor of zones of the same size
> + *
> + * @start_lba:  LBA of first zone covered by the descriptor.
> + * @last_lba:   LBA of last zone.
> + * @zone_size:  Size of zones as a number of 512 byte sectors.
> + * @zone_count: Number of zones (last-start/size) for convenience.
> + * @lock:       A spinlock protecting these zones.
> + * @is_zoned:   0 when all zones are conventional no WP zones.
> + * zones:       Array of blk_zone entries.
> + */
> +struct contiguous_wps {
> +       u64 start_lba;
> +       u64 last_lba;
> +       u64 zone_size;
> +       u32 zone_count;
> +       spinlock_t lock;
> +       unsigned is_zoned:1;
> +       struct blk_zone zones[0];
> +};
> +
> +/**
> + * struct zone_wps - A collection of zone descriptors to describe zoned media.
> + *
> + * @wps_count:  Number of descriptors.
> + * @wps:        Array of zone descriptors.
> + */
> +struct zone_wps {
> +       u32 wps_count;
> +       struct contiguous_wps **wps;
> +};
> +
>  #define blk_zone_is_seq_req(z) ((z)->type == BLK_ZONE_TYPE_SEQWRITE_REQ)
>  #define blk_zone_is_seq_pref(z) ((z)->type == BLK_ZONE_TYPE_SEQWRITE_PREF)
>  #define blk_zone_is_smr(z) (blk_zone_is_seq_req(z) || blk_zone_is_seq_pref(z))
>  #define blk_zone_is_cmr(z) ((z)->type == BLK_ZONE_TYPE_CONVENTIONAL)
> -#define blk_zone_is_full(z) ((z)->wp == (z)->start + (z)->len)
> -#define blk_zone_is_empty(z) ((z)->wp == (z)->start)
> +#define blk_zone_is_empty(z) ((z)->wp == 0)
>
> -extern struct blk_zone *blk_lookup_zone(struct request_queue *, sector_t);
> -extern struct blk_zone *blk_insert_zone(struct request_queue *,
> -                                       struct blk_zone *);
> +extern struct blk_zone *blk_lookup_zone(struct request_queue *, sector_t,
> +                                       sector_t *, sector_t *, spinlock_t **);
>  extern void blk_drop_zones(struct request_queue *);
>  #else
>  static inline void blk_drop_zones(struct request_queue *q) { };
> @@ -463,7 +519,7 @@ struct request_queue {
>         struct queue_limits     limits;
>
>  #ifdef CONFIG_BLK_DEV_ZONED
> -       struct rb_root          zones;
> +       struct zone_wps         *zones;
>  #endif
>         /*
>          * sg stuff
> --
> 2.9.3
>



-- 
Shaun Tancheff
--
To unsubscribe from this list: send the line "unsubscribe linux-block" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Linux RAID]     [Linux SCSI]     [Linux ATA RAID]     [IDE]     [Linux Wireless]     [Linux Kernel]     [ATH6KL]     [Linux Bluetooth]     [Linux Netdev]     [Kernel Newbies]     [Security]     [Git]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Device Mapper]

  Powered by Linux