1 // SPDX-License-Identifier: GPL-2.0-only
3 * SCSI Zoned Block commands
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>
11 #include <linux/blkdev.h>
12 #include <linux/vmalloc.h>
13 #include <linux/sched/mm.h>
15 #include <asm/unaligned.h>
17 #include <scsi/scsi.h>
18 #include <scsi/scsi_cmnd.h>
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
28 * All LBA sized values are converted to 512B sectors unit.
30 static void sd_zbc_parse_report(struct scsi_disk *sdkp, u8 *buf,
31 struct blk_zone *zone)
33 struct scsi_device *sdp = sdkp->device;
35 memset(zone, 0, sizeof(struct blk_zone));
37 zone->type = buf[0] & 0x0f;
38 zone->cond = (buf[1] >> 4) & 0xf;
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;
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
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
66 static int sd_zbc_do_report_zones(struct scsi_disk *sdkp, unsigned char *buf,
67 unsigned int buflen, sector_t lba,
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];
79 cmd[1] = ZI_REPORT_ZONES;
80 put_unaligned_be64(lba, &cmd[2]);
81 put_unaligned_be32(buflen, &cmd[10]);
83 cmd[14] = ZBC_REPORT_ZONE_PARTIAL;
85 result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
87 timeout, SD_MAX_RETRIES, NULL);
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));
96 rep_len = get_unaligned_be32(&buf[0]);
98 sd_printk(KERN_ERR, sdkp,
99 "REPORT ZONES report invalid length %u\n",
108 * Allocate a buffer for report zones reply.
109 * @sdkp: The target disk
110 * @nr_zones: Maximum number of zones to report
111 * @buflen: Size of the buffer allocated
113 * Try to allocate a reply buffer for the number of requested zones.
114 * The size of the buffer allocated may be smaller than requested to
115 * satify the device constraint (max_hw_sectors, max_segments, etc).
117 * Return the address of the allocated buffer and update @buflen with
118 * the size of the allocated buffer.
120 static void *sd_zbc_alloc_report_buffer(struct scsi_disk *sdkp,
121 unsigned int nr_zones, size_t *buflen)
123 struct request_queue *q = sdkp->disk->queue;
128 * Report zone buffer size should be at most 64B times the number of
129 * zones requested plus the 64B reply header, but should be at least
130 * SECTOR_SIZE for ATA devices.
131 * Make sure that this size does not exceed the hardware capabilities.
132 * Furthermore, since the report zone command cannot be split, make
133 * sure that the allocated buffer can always be mapped by limiting the
134 * number of pages allocated to the HBA max segments limit.
136 nr_zones = min(nr_zones, sdkp->nr_zones);
137 bufsize = roundup((nr_zones + 1) * 64, SECTOR_SIZE);
138 bufsize = min_t(size_t, bufsize,
139 queue_max_hw_sectors(q) << SECTOR_SHIFT);
140 bufsize = min_t(size_t, bufsize, queue_max_segments(q) << PAGE_SHIFT);
142 while (bufsize >= SECTOR_SIZE) {
143 buf = __vmalloc(bufsize,
144 GFP_KERNEL | __GFP_ZERO | __GFP_NORETRY,
157 * sd_zbc_report_zones - Disk report zones operation.
158 * @disk: The target disk
159 * @sector: Start 512B sector of the report
160 * @zones: Array of zone descriptors
161 * @nr_zones: Number of descriptors in the array
163 * Execute a report zones command on the target disk.
165 int sd_zbc_report_zones(struct gendisk *disk, sector_t sector,
166 struct blk_zone *zones, unsigned int *nr_zones)
168 struct scsi_disk *sdkp = scsi_disk(disk);
169 unsigned int i, nrz = *nr_zones;
171 size_t buflen = 0, offset = 0;
174 if (!sd_is_zoned(sdkp))
175 /* Not a zoned device */
178 buf = sd_zbc_alloc_report_buffer(sdkp, nrz, &buflen);
182 ret = sd_zbc_do_report_zones(sdkp, buf, buflen,
183 sectors_to_logical(sdkp->device, sector), true);
187 nrz = min(nrz, get_unaligned_be32(&buf[0]) / 64);
188 for (i = 0; i < nrz; i++) {
190 sd_zbc_parse_report(sdkp, buf + offset, zones);
203 * sd_zbc_zone_sectors - Get the device zone size in number of 512B sectors.
204 * @sdkp: The target disk
206 static inline sector_t sd_zbc_zone_sectors(struct scsi_disk *sdkp)
208 return logical_to_sectors(sdkp->device, sdkp->zone_blocks);
212 * sd_zbc_setup_zone_mgmt_cmnd - Prepare a zone ZBC_OUT command. The operations
213 * can be RESET WRITE POINTER, OPEN, CLOSE or FINISH.
214 * @cmd: the command to setup
215 * @op: Operation to be performed
216 * @all: All zones control
218 * Called from sd_init_command() for REQ_OP_ZONE_RESET, REQ_OP_ZONE_RESET_ALL,
219 * REQ_OP_ZONE_OPEN, REQ_OP_ZONE_CLOSE or REQ_OP_ZONE_FINISH requests.
221 blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd,
222 unsigned char op, bool all)
224 struct request *rq = cmd->request;
225 struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
226 sector_t sector = blk_rq_pos(rq);
227 sector_t block = sectors_to_logical(sdkp->device, sector);
229 if (!sd_is_zoned(sdkp))
230 /* Not a zoned device */
231 return BLK_STS_IOERR;
233 if (sdkp->device->changed)
234 return BLK_STS_IOERR;
236 if (sector & (sd_zbc_zone_sectors(sdkp) - 1))
237 /* Unaligned request */
238 return BLK_STS_IOERR;
241 memset(cmd->cmnd, 0, cmd->cmd_len);
242 cmd->cmnd[0] = ZBC_OUT;
247 put_unaligned_be64(block, &cmd->cmnd[2]);
249 rq->timeout = SD_TIMEOUT;
250 cmd->sc_data_direction = DMA_NONE;
251 cmd->transfersize = 0;
258 * sd_zbc_complete - ZBC command post processing.
259 * @cmd: Completed command
260 * @good_bytes: Command reply bytes
261 * @sshdr: command sense header
263 * Called from sd_done(). Process report zones reply and handle reset zone
264 * and write commands errors.
266 void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
267 struct scsi_sense_hdr *sshdr)
269 int result = cmd->result;
270 struct request *rq = cmd->request;
272 if (op_is_zone_mgmt(req_op(rq)) &&
274 sshdr->sense_key == ILLEGAL_REQUEST &&
275 sshdr->asc == 0x24) {
277 * INVALID FIELD IN CDB error: a zone management command was
278 * attempted on a conventional zone. Nothing to worry about,
279 * so be quiet about the error.
281 rq->rq_flags |= RQF_QUIET;
286 * sd_zbc_check_zoned_characteristics - Check zoned block device characteristics
288 * @buf: Buffer where to store the VPD page data
290 * Read VPD page B6, get information and check that reads are unconstrained.
292 static int sd_zbc_check_zoned_characteristics(struct scsi_disk *sdkp,
296 if (scsi_get_vpd_page(sdkp->device, 0xb6, buf, 64)) {
297 sd_printk(KERN_NOTICE, sdkp,
298 "Read zoned characteristics VPD page failed\n");
302 if (sdkp->device->type != TYPE_ZBC) {
305 sdkp->zones_optimal_open = get_unaligned_be32(&buf[8]);
306 sdkp->zones_optimal_nonseq = get_unaligned_be32(&buf[12]);
307 sdkp->zones_max_open = 0;
310 sdkp->urswrz = buf[4] & 1;
311 sdkp->zones_optimal_open = 0;
312 sdkp->zones_optimal_nonseq = 0;
313 sdkp->zones_max_open = get_unaligned_be32(&buf[16]);
317 * Check for unconstrained reads: host-managed devices with
318 * constrained reads (drives failing read after write pointer)
322 if (sdkp->first_scan)
323 sd_printk(KERN_NOTICE, sdkp,
324 "constrained reads devices are not supported\n");
332 * sd_zbc_check_zones - Check the device capacity and zone sizes
335 * Check that the device capacity as reported by READ CAPACITY matches the
336 * max_lba value (plus one)of the report zones command reply. Also check that
337 * all zones of the device have an equal size, only allowing the last zone of
338 * the disk to have a smaller size (runt zone). The zone size must also be a
341 * Returns the zone size in number of blocks upon success or an error code
344 static int sd_zbc_check_zones(struct scsi_disk *sdkp, unsigned char *buf,
353 /* Do a report zone to get max_lba and the size of the first zone */
354 ret = sd_zbc_do_report_zones(sdkp, buf, SD_BUF_SIZE, 0, false);
358 if (sdkp->rc_basis == 0) {
359 /* The max_lba field is the capacity of this device */
360 max_lba = get_unaligned_be64(&buf[8]);
361 if (sdkp->capacity != max_lba + 1) {
362 if (sdkp->first_scan)
363 sd_printk(KERN_WARNING, sdkp,
364 "Changing capacity from %llu to max LBA+1 %llu\n",
365 (unsigned long long)sdkp->capacity,
366 (unsigned long long)max_lba + 1);
367 sdkp->capacity = max_lba + 1;
371 /* Parse REPORT ZONES header */
372 buflen = min_t(size_t, get_unaligned_be32(&buf[0]) + 64, SD_BUF_SIZE);
374 zone_blocks = get_unaligned_be64(&rec[8]);
375 if (!zone_blocks || !is_power_of_2(zone_blocks)) {
376 if (sdkp->first_scan)
377 sd_printk(KERN_NOTICE, sdkp,
378 "Devices with non power of 2 zone "
379 "size are not supported\n");
383 if (logical_to_sectors(sdkp->device, zone_blocks) > UINT_MAX) {
384 if (sdkp->first_scan)
385 sd_printk(KERN_NOTICE, sdkp,
386 "Zone size too large\n");
390 *zblocks = zone_blocks;
395 int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
397 struct gendisk *disk = sdkp->disk;
398 unsigned int nr_zones;
402 if (!sd_is_zoned(sdkp))
404 * Device managed or normal SCSI disk,
405 * no special handling required
409 /* Check zoned block device characteristics (unconstrained reads) */
410 ret = sd_zbc_check_zoned_characteristics(sdkp, buf);
415 * Check zone size: only devices with a constant zone size (except
416 * an eventual last runt zone) that is a power of 2 are supported.
418 ret = sd_zbc_check_zones(sdkp, buf, &zone_blocks);
422 /* The drive satisfies the kernel restrictions: set it up */
423 blk_queue_chunk_sectors(sdkp->disk->queue,
424 logical_to_sectors(sdkp->device, zone_blocks));
425 blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, sdkp->disk->queue);
426 blk_queue_required_elevator_features(sdkp->disk->queue,
427 ELEVATOR_F_ZBD_SEQ_WRITE);
428 nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);
430 /* READ16/WRITE16 is mandatory for ZBC disks */
431 sdkp->device->use_16_for_rw = 1;
432 sdkp->device->use_10_for_rw = 0;
435 * Revalidate the disk zone bitmaps once the block device capacity is
436 * set on the second revalidate execution during disk scan and if
437 * something changed when executing a normal revalidate.
439 if (sdkp->first_scan) {
440 sdkp->zone_blocks = zone_blocks;
441 sdkp->nr_zones = nr_zones;
445 if (sdkp->zone_blocks != zone_blocks ||
446 sdkp->nr_zones != nr_zones ||
447 disk->queue->nr_zones != nr_zones) {
448 ret = blk_revalidate_disk_zones(disk);
451 sdkp->zone_blocks = zone_blocks;
452 sdkp->nr_zones = nr_zones;
463 void sd_zbc_print_zones(struct scsi_disk *sdkp)
465 if (!sd_is_zoned(sdkp) || !sdkp->capacity)
468 if (sdkp->capacity & (sdkp->zone_blocks - 1))
469 sd_printk(KERN_NOTICE, sdkp,
470 "%u zones of %u logical blocks + 1 runt zone\n",
474 sd_printk(KERN_NOTICE, sdkp,
475 "%u zones of %u logical blocks\n",