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