drivers/scsi/sd_zbc.c

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