drivers/scsi/sd_zbc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * SCSI Zoned Block commands
   4  *
   5  * Copyright (C) 2014-2015 SUSE Linux GmbH
   6  * Written by: Hannes Reinecke <hare@suse.de>
   7  * Modified by: Damien Le Moal <damien.lemoal@hgst.com>
   8  * Modified by: Shaun Tancheff <shaun.tancheff@seagate.com>
   9  */
  10
  11 #include <linux/blkdev.h>
  12
  13 #include <asm/unaligned.h>
  14
  15 #include <scsi/scsi.h>
  16 #include <scsi/scsi_cmnd.h>
  17
  18 #include "sd.h"
  19
  20 /**
  21  * sd_zbc_parse_report - Convert a zone descriptor to a struct blk_zone,
  22  * @sdkp: The disk the report originated from
  23  * @buf: Address of the report zone descriptor
  24  * @zone: the destination zone structure
  25  *
  26  * All LBA sized values are converted to 512B sectors unit.
  27  */
  28 static void sd_zbc_parse_report(struct scsi_disk *sdkp, u8 *buf,
  29                                 struct blk_zone *zone)
  30 {
  31         struct scsi_device *sdp = sdkp->device;
  32
  33         memset(zone, 0, sizeof(struct blk_zone));
  34
  35         zone->type = buf[0] & 0x0f;
  36         zone->cond = (buf[1] >> 4) & 0xf;
  37         if (buf[1] & 0x01)
  38                 zone->reset = 1;
  39         if (buf[1] & 0x02)
  40                 zone->non_seq = 1;
  41
  42         zone->len = logical_to_sectors(sdp, get_unaligned_be64(&buf[8]));
  43         zone->start = logical_to_sectors(sdp, get_unaligned_be64(&buf[16]));
  44         zone->wp = logical_to_sectors(sdp, get_unaligned_be64(&buf[24]));
  45         if (zone->type != ZBC_ZONE_TYPE_CONV &&
  46             zone->cond == ZBC_ZONE_COND_FULL)
  47                 zone->wp = zone->start + zone->len;
  48 }
  49
  50 /**
  51  * sd_zbc_do_report_zones - Issue a REPORT ZONES scsi command.
  52  * @sdkp: The target disk
  53  * @buf: Buffer to use for the reply
  54  * @buflen: the buffer size
  55  * @lba: Start LBA of the report
  56  * @partial: Do partial report
  57  *
  58  * For internal use during device validation.
  59  * Using partial=true can significantly speed up execution of a report zones
  60  * command because the disk does not have to count all possible report matching
  61  * zones and will only report the count of zones fitting in the command reply
  62  * buffer.
  63  */
  64 static int sd_zbc_do_report_zones(struct scsi_disk *sdkp, unsigned char *buf,
  65                                   unsigned int buflen, sector_t lba,
  66                                   bool partial)
  67 {
  68         struct scsi_device *sdp = sdkp->device;
  69         const int timeout = sdp->request_queue->rq_timeout;
  70         struct scsi_sense_hdr sshdr;
  71         unsigned char cmd[16];
  72         unsigned int rep_len;
  73         int result;
  74
  75         memset(cmd, 0, 16);
  76         cmd[0] = ZBC_IN;
  77         cmd[1] = ZI_REPORT_ZONES;
  78         put_unaligned_be64(lba, &cmd[2]);
  79         put_unaligned_be32(buflen, &cmd[10]);
  80         if (partial)
  81                 cmd[14] = ZBC_REPORT_ZONE_PARTIAL;
  82         memset(buf, 0, buflen);
  83
  84         result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
  85                                   buf, buflen, &sshdr,
  86                                   timeout, SD_MAX_RETRIES, NULL);
  87         if (result) {
  88                 sd_printk(KERN_ERR, sdkp,
  89                           "REPORT ZONES lba %llu failed with %d/%d\n",
  90                           (unsigned long long)lba,
  91                           host_byte(result), driver_byte(result));
  92                 return -EIO;
  93         }
  94
  95         rep_len = get_unaligned_be32(&buf[0]);
  96         if (rep_len < 64) {
  97                 sd_printk(KERN_ERR, sdkp,
  98                           "REPORT ZONES report invalid length %u\n",
  99                           rep_len);
 100                 return -EIO;
 101         }
 102
 103         return 0;
 104 }
 105
 106 /**
 107  * sd_zbc_report_zones - Disk report zones operation.
 108  * @disk: The target disk
 109  * @sector: Start 512B sector of the report
 110  * @zones: Array of zone descriptors
 111  * @nr_zones: Number of descriptors in the array
 112  * @gfp_mask: Memory allocation mask
 113  *
 114  * Execute a report zones command on the target disk.
 115  */
 116 int sd_zbc_report_zones(struct gendisk *disk, sector_t sector,
 117                         struct blk_zone *zones, unsigned int *nr_zones,
 118                         gfp_t gfp_mask)
 119 {
 120         struct scsi_disk *sdkp = scsi_disk(disk);
 121         unsigned int i, buflen, nrz = *nr_zones;
 122         unsigned char *buf;
 123         size_t offset = 0;
 124         int ret = 0;
 125
 126         if (!sd_is_zoned(sdkp))
 127                 /* Not a zoned device */
 128                 return -EOPNOTSUPP;
 129
 130         /*
 131          * Get a reply buffer for the number of requested zones plus a header,
 132          * without exceeding the device maximum command size. For ATA disks,
 133          * buffers must be aligned to 512B.
 134          */
 135         buflen = min(queue_max_hw_sectors(disk->queue) << 9,
 136                      roundup((nrz + 1) * 64, 512));
 137         buf = kmalloc(buflen, gfp_mask);
 138         if (!buf)
 139                 return -ENOMEM;
 140
 141         ret = sd_zbc_do_report_zones(sdkp, buf, buflen,
 142                         sectors_to_logical(sdkp->device, sector), true);
 143         if (ret)
 144                 goto out_free_buf;
 145
 146         nrz = min(nrz, get_unaligned_be32(&buf[0]) / 64);
 147         for (i = 0; i < nrz; i++) {
 148                 offset += 64;
 149                 sd_zbc_parse_report(sdkp, buf + offset, zones);
 150                 zones++;
 151         }
 152
 153         *nr_zones = nrz;
 154
 155 out_free_buf:
 156         kfree(buf);
 157
 158         return ret;
 159 }
 160
 161 /**
 162  * sd_zbc_zone_sectors - Get the device zone size in number of 512B sectors.
 163  * @sdkp: The target disk
 164  */
 165 static inline sector_t sd_zbc_zone_sectors(struct scsi_disk *sdkp)
 166 {
 167         return logical_to_sectors(sdkp->device, sdkp->zone_blocks);
 168 }
 169
 170 /**
 171  * sd_zbc_setup_reset_cmnd - Prepare a RESET WRITE POINTER scsi command.
 172  * @cmd: the command to setup
 173  *
 174  * Called from sd_init_command() for a REQ_OP_ZONE_RESET request.
 175  */
 176 blk_status_t sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd)
 177 {
 178         struct request *rq = cmd->request;
 179         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 180         sector_t sector = blk_rq_pos(rq);
 181         sector_t block = sectors_to_logical(sdkp->device, sector);
 182
 183         if (!sd_is_zoned(sdkp))
 184                 /* Not a zoned device */
 185                 return BLK_STS_IOERR;
 186
 187         if (sdkp->device->changed)
 188                 return BLK_STS_IOERR;
 189
 190         if (sector & (sd_zbc_zone_sectors(sdkp) - 1))
 191                 /* Unaligned request */
 192                 return BLK_STS_IOERR;
 193
 194         cmd->cmd_len = 16;
 195         memset(cmd->cmnd, 0, cmd->cmd_len);
 196         cmd->cmnd[0] = ZBC_OUT;
 197         cmd->cmnd[1] = ZO_RESET_WRITE_POINTER;
 198         put_unaligned_be64(block, &cmd->cmnd[2]);
 199
 200         rq->timeout = SD_TIMEOUT;
 201         cmd->sc_data_direction = DMA_NONE;
 202         cmd->transfersize = 0;
 203         cmd->allowed = 0;
 204
 205         return BLK_STS_OK;
 206 }
 207
 208 /**
 209  * sd_zbc_complete - ZBC command post processing.
 210  * @cmd: Completed command
 211  * @good_bytes: Command reply bytes
 212  * @sshdr: command sense header
 213  *
 214  * Called from sd_done(). Process report zones reply and handle reset zone
 215  * and write commands errors.
 216  */
 217 void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
 218                      struct scsi_sense_hdr *sshdr)
 219 {
 220         int result = cmd->result;
 221         struct request *rq = cmd->request;
 222
 223         switch (req_op(rq)) {
 224         case REQ_OP_ZONE_RESET:
 225
 226                 if (result &&
 227                     sshdr->sense_key == ILLEGAL_REQUEST &&
 228                     sshdr->asc == 0x24)
 229                         /*
 230                          * INVALID FIELD IN CDB error: reset of a conventional
 231                          * zone was attempted. Nothing to worry about, so be
 232                          * quiet about the error.
 233                          */
 234                         rq->rq_flags |= RQF_QUIET;
 235                 break;
 236
 237         case REQ_OP_WRITE:
 238         case REQ_OP_WRITE_ZEROES:
 239         case REQ_OP_WRITE_SAME:
 240                 break;
 241         }
 242 }
 243
 244 /**
 245  * sd_zbc_check_zoned_characteristics - Check zoned block device characteristics
 246  * @sdkp: Target disk
 247  * @buf: Buffer where to store the VPD page data
 248  *
 249  * Read VPD page B6, get information and check that reads are unconstrained.
 250  */
 251 static int sd_zbc_check_zoned_characteristics(struct scsi_disk *sdkp,
 252                                               unsigned char *buf)
 253 {
 254
 255         if (scsi_get_vpd_page(sdkp->device, 0xb6, buf, 64)) {
 256                 sd_printk(KERN_NOTICE, sdkp,
 257                           "Read zoned characteristics VPD page failed\n");
 258                 return -ENODEV;
 259         }
 260
 261         if (sdkp->device->type != TYPE_ZBC) {
 262                 /* Host-aware */
 263                 sdkp->urswrz = 1;
 264                 sdkp->zones_optimal_open = get_unaligned_be32(&buf[8]);
 265                 sdkp->zones_optimal_nonseq = get_unaligned_be32(&buf[12]);
 266                 sdkp->zones_max_open = 0;
 267         } else {
 268                 /* Host-managed */
 269                 sdkp->urswrz = buf[4] & 1;
 270                 sdkp->zones_optimal_open = 0;
 271                 sdkp->zones_optimal_nonseq = 0;
 272                 sdkp->zones_max_open = get_unaligned_be32(&buf[16]);
 273         }
 274
 275         /*
 276          * Check for unconstrained reads: host-managed devices with
 277          * constrained reads (drives failing read after write pointer)
 278          * are not supported.
 279          */
 280         if (!sdkp->urswrz) {
 281                 if (sdkp->first_scan)
 282                         sd_printk(KERN_NOTICE, sdkp,
 283                           "constrained reads devices are not supported\n");
 284                 return -ENODEV;
 285         }
 286
 287         return 0;
 288 }
 289
 290 #define SD_ZBC_BUF_SIZE 131072U
 291
 292 /**
 293  * sd_zbc_check_zones - Check the device capacity and zone sizes
 294  * @sdkp: Target disk
 295  *
 296  * Check that the device capacity as reported by READ CAPACITY matches the
 297  * max_lba value (plus one)of the report zones command reply. Also check that
 298  * all zones of the device have an equal size, only allowing the last zone of
 299  * the disk to have a smaller size (runt zone). The zone size must also be a
 300  * power of two.
 301  *
 302  * Returns the zone size in number of blocks upon success or an error code
 303  * upon failure.
 304  */
 305 static int sd_zbc_check_zones(struct scsi_disk *sdkp, u32 *zblocks)
 306 {
 307         u64 zone_blocks = 0;
 308         sector_t max_lba, block = 0;
 309         unsigned char *buf;
 310         unsigned char *rec;
 311         unsigned int buf_len;
 312         unsigned int list_length;
 313         int ret;
 314         u8 same;
 315
 316         /* Get a buffer */
 317         buf = kmalloc(SD_ZBC_BUF_SIZE, GFP_KERNEL);
 318         if (!buf)
 319                 return -ENOMEM;
 320
 321         /* Do a report zone to get max_lba and the same field */
 322         ret = sd_zbc_do_report_zones(sdkp, buf, SD_ZBC_BUF_SIZE, 0, false);
 323         if (ret)
 324                 goto out_free;
 325
 326         if (sdkp->rc_basis == 0) {
 327                 /* The max_lba field is the capacity of this device */
 328                 max_lba = get_unaligned_be64(&buf[8]);
 329                 if (sdkp->capacity != max_lba + 1) {
 330                         if (sdkp->first_scan)
 331                                 sd_printk(KERN_WARNING, sdkp,
 332                                         "Changing capacity from %llu to max LBA+1 %llu\n",
 333                                         (unsigned long long)sdkp->capacity,
 334                                         (unsigned long long)max_lba + 1);
 335                         sdkp->capacity = max_lba + 1;
 336                 }
 337         }
 338
 339         /*
 340          * Check same field: for any value other than 0, we know that all zones
 341          * have the same size.
 342          */
 343         same = buf[4] & 0x0f;
 344         if (same > 0) {
 345                 rec = &buf[64];
 346                 zone_blocks = get_unaligned_be64(&rec[8]);
 347                 goto out;
 348         }
 349
 350         /*
 351          * Check the size of all zones: all zones must be of
 352          * equal size, except the last zone which can be smaller
 353          * than other zones.
 354          */
 355         do {
 356
 357                 /* Parse REPORT ZONES header */
 358                 list_length = get_unaligned_be32(&buf[0]) + 64;
 359                 rec = buf + 64;
 360                 buf_len = min(list_length, SD_ZBC_BUF_SIZE);
 361
 362                 /* Parse zone descriptors */
 363                 while (rec < buf + buf_len) {
 364                         u64 this_zone_blocks = get_unaligned_be64(&rec[8]);
 365
 366                         if (zone_blocks == 0) {
 367                                 zone_blocks = this_zone_blocks;
 368                         } else if (this_zone_blocks != zone_blocks &&
 369                                    (block + this_zone_blocks < sdkp->capacity
 370                                     || this_zone_blocks > zone_blocks)) {
 371                                 zone_blocks = 0;
 372                                 goto out;
 373                         }
 374                         block += this_zone_blocks;
 375                         rec += 64;
 376                 }
 377
 378                 if (block < sdkp->capacity) {
 379                         ret = sd_zbc_do_report_zones(sdkp, buf, SD_ZBC_BUF_SIZE,
 380                                                      block, true);
 381                         if (ret)
 382                                 goto out_free;
 383                 }
 384
 385         } while (block < sdkp->capacity);
 386
 387 out:
 388         if (!zone_blocks) {
 389                 if (sdkp->first_scan)
 390                         sd_printk(KERN_NOTICE, sdkp,
 391                                   "Devices with non constant zone "
 392                                   "size are not supported\n");
 393                 ret = -ENODEV;
 394         } else if (!is_power_of_2(zone_blocks)) {
 395                 if (sdkp->first_scan)
 396                         sd_printk(KERN_NOTICE, sdkp,
 397                                   "Devices with non power of 2 zone "
 398                                   "size are not supported\n");
 399                 ret = -ENODEV;
 400         } else if (logical_to_sectors(sdkp->device, zone_blocks) > UINT_MAX) {
 401                 if (sdkp->first_scan)
 402                         sd_printk(KERN_NOTICE, sdkp,
 403                                   "Zone size too large\n");
 404                 ret = -EFBIG;
 405         } else {
 406                 *zblocks = zone_blocks;
 407                 ret = 0;
 408         }
 409
 410 out_free:
 411         kfree(buf);
 412
 413         return ret;
 414 }
 415
 416 int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
 417 {
 418         struct gendisk *disk = sdkp->disk;
 419         unsigned int nr_zones;
 420         u32 zone_blocks;
 421         int ret;
 422
 423         if (!sd_is_zoned(sdkp))
 424                 /*
 425                  * Device managed or normal SCSI disk,
 426                  * no special handling required
 427                  */
 428                 return 0;
 429
 430         /* Check zoned block device characteristics (unconstrained reads) */
 431         ret = sd_zbc_check_zoned_characteristics(sdkp, buf);
 432         if (ret)
 433                 goto err;
 434
 435         /*
 436          * Check zone size: only devices with a constant zone size (except
 437          * an eventual last runt zone) that is a power of 2 are supported.
 438          */
 439         ret = sd_zbc_check_zones(sdkp, &zone_blocks);
 440         if (ret != 0)
 441                 goto err;
 442
 443         /* The drive satisfies the kernel restrictions: set it up */
 444         blk_queue_chunk_sectors(sdkp->disk->queue,
 445                         logical_to_sectors(sdkp->device, zone_blocks));
 446         nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);
 447
 448         /* READ16/WRITE16 is mandatory for ZBC disks */
 449         sdkp->device->use_16_for_rw = 1;
 450         sdkp->device->use_10_for_rw = 0;
 451
 452         /*
 453          * Revalidate the disk zone bitmaps once the block device capacity is
 454          * set on the second revalidate execution during disk scan and if
 455          * something changed when executing a normal revalidate.
 456          */
 457         if (sdkp->first_scan) {
 458                 sdkp->zone_blocks = zone_blocks;
 459                 sdkp->nr_zones = nr_zones;
 460                 return 0;
 461         }
 462
 463         if (sdkp->zone_blocks != zone_blocks ||
 464             sdkp->nr_zones != nr_zones ||
 465             disk->queue->nr_zones != nr_zones) {
 466                 ret = blk_revalidate_disk_zones(disk);
 467                 if (ret != 0)
 468                         goto err;
 469                 sdkp->zone_blocks = zone_blocks;
 470                 sdkp->nr_zones = nr_zones;
 471         }
 472
 473         return 0;
 474
 475 err:
 476         sdkp->capacity = 0;
 477
 478         return ret;
 479 }
 480
 481 void sd_zbc_print_zones(struct scsi_disk *sdkp)
 482 {
 483         if (!sd_is_zoned(sdkp) || !sdkp->capacity)
 484                 return;
 485
 486         if (sdkp->capacity & (sdkp->zone_blocks - 1))
 487                 sd_printk(KERN_NOTICE, sdkp,
 488                           "%u zones of %u logical blocks + 1 runt zone\n",
 489                           sdkp->nr_zones - 1,
 490                           sdkp->zone_blocks);
 491         else
 492                 sd_printk(KERN_NOTICE, sdkp,
 493                           "%u zones of %u logical blocks\n",
 494                           sdkp->nr_zones,
 495                           sdkp->zone_blocks);
 496 }