5d6ff3931632fdbd5aa0f5735d9a53a9a5fa1c91
[sfrench/cifs-2.6.git] / 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 #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  *
213  * Called from sd_init_command() for a REQ_OP_ZONE_RESET request.
214  */
215 blk_status_t sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd)
216 {
217         struct request *rq = cmd->request;
218         struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
219         sector_t sector = blk_rq_pos(rq);
220         sector_t block = sectors_to_logical(sdkp->device, sector);
221
222         if (!sd_is_zoned(sdkp))
223                 /* Not a zoned device */
224                 return BLK_STS_IOERR;
225
226         if (sdkp->device->changed)
227                 return BLK_STS_IOERR;
228
229         if (sector & (sd_zbc_zone_sectors(sdkp) - 1))
230                 /* Unaligned request */
231                 return BLK_STS_IOERR;
232
233         cmd->cmd_len = 16;
234         memset(cmd->cmnd, 0, cmd->cmd_len);
235         cmd->cmnd[0] = ZBC_OUT;
236         cmd->cmnd[1] = ZO_RESET_WRITE_POINTER;
237         put_unaligned_be64(block, &cmd->cmnd[2]);
238
239         rq->timeout = SD_TIMEOUT;
240         cmd->sc_data_direction = DMA_NONE;
241         cmd->transfersize = 0;
242         cmd->allowed = 0;
243
244         return BLK_STS_OK;
245 }
246
247 /**
248  * sd_zbc_complete - ZBC command post processing.
249  * @cmd: Completed command
250  * @good_bytes: Command reply bytes
251  * @sshdr: command sense header
252  *
253  * Called from sd_done(). Process report zones reply and handle reset zone
254  * and write commands errors.
255  */
256 void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
257                      struct scsi_sense_hdr *sshdr)
258 {
259         int result = cmd->result;
260         struct request *rq = cmd->request;
261
262         switch (req_op(rq)) {
263         case REQ_OP_ZONE_RESET:
264
265                 if (result &&
266                     sshdr->sense_key == ILLEGAL_REQUEST &&
267                     sshdr->asc == 0x24)
268                         /*
269                          * INVALID FIELD IN CDB error: reset of a conventional
270                          * zone was attempted. Nothing to worry about, so be
271                          * quiet about the error.
272                          */
273                         rq->rq_flags |= RQF_QUIET;
274                 break;
275
276         case REQ_OP_WRITE:
277         case REQ_OP_WRITE_ZEROES:
278         case REQ_OP_WRITE_SAME:
279                 break;
280         }
281 }
282
283 /**
284  * sd_zbc_check_zoned_characteristics - Check zoned block device characteristics
285  * @sdkp: Target disk
286  * @buf: Buffer where to store the VPD page data
287  *
288  * Read VPD page B6, get information and check that reads are unconstrained.
289  */
290 static int sd_zbc_check_zoned_characteristics(struct scsi_disk *sdkp,
291                                               unsigned char *buf)
292 {
293
294         if (scsi_get_vpd_page(sdkp->device, 0xb6, buf, 64)) {
295                 sd_printk(KERN_NOTICE, sdkp,
296                           "Read zoned characteristics VPD page failed\n");
297                 return -ENODEV;
298         }
299
300         if (sdkp->device->type != TYPE_ZBC) {
301                 /* Host-aware */
302                 sdkp->urswrz = 1;
303                 sdkp->zones_optimal_open = get_unaligned_be32(&buf[8]);
304                 sdkp->zones_optimal_nonseq = get_unaligned_be32(&buf[12]);
305                 sdkp->zones_max_open = 0;
306         } else {
307                 /* Host-managed */
308                 sdkp->urswrz = buf[4] & 1;
309                 sdkp->zones_optimal_open = 0;
310                 sdkp->zones_optimal_nonseq = 0;
311                 sdkp->zones_max_open = get_unaligned_be32(&buf[16]);
312         }
313
314         /*
315          * Check for unconstrained reads: host-managed devices with
316          * constrained reads (drives failing read after write pointer)
317          * are not supported.
318          */
319         if (!sdkp->urswrz) {
320                 if (sdkp->first_scan)
321                         sd_printk(KERN_NOTICE, sdkp,
322                           "constrained reads devices are not supported\n");
323                 return -ENODEV;
324         }
325
326         return 0;
327 }
328
329 /**
330  * sd_zbc_check_zones - Check the device capacity and zone sizes
331  * @sdkp: Target disk
332  *
333  * Check that the device capacity as reported by READ CAPACITY matches the
334  * max_lba value (plus one)of the report zones command reply. Also check that
335  * all zones of the device have an equal size, only allowing the last zone of
336  * the disk to have a smaller size (runt zone). The zone size must also be a
337  * power of two.
338  *
339  * Returns the zone size in number of blocks upon success or an error code
340  * upon failure.
341  */
342 static int sd_zbc_check_zones(struct scsi_disk *sdkp, u32 *zblocks)
343 {
344         size_t bufsize, buflen;
345         unsigned int noio_flag;
346         u64 zone_blocks = 0;
347         sector_t max_lba, block = 0;
348         unsigned char *buf;
349         unsigned char *rec;
350         int ret;
351         u8 same;
352
353         /* Do all memory allocations as if GFP_NOIO was specified */
354         noio_flag = memalloc_noio_save();
355
356         /* Get a buffer */
357         buf = sd_zbc_alloc_report_buffer(sdkp, SD_ZBC_REPORT_MAX_ZONES,
358                                          &bufsize);
359         if (!buf) {
360                 ret = -ENOMEM;
361                 goto out;
362         }
363
364         /* Do a report zone to get max_lba and the same field */
365         ret = sd_zbc_do_report_zones(sdkp, buf, bufsize, 0, false);
366         if (ret)
367                 goto out_free;
368
369         if (sdkp->rc_basis == 0) {
370                 /* The max_lba field is the capacity of this device */
371                 max_lba = get_unaligned_be64(&buf[8]);
372                 if (sdkp->capacity != max_lba + 1) {
373                         if (sdkp->first_scan)
374                                 sd_printk(KERN_WARNING, sdkp,
375                                         "Changing capacity from %llu to max LBA+1 %llu\n",
376                                         (unsigned long long)sdkp->capacity,
377                                         (unsigned long long)max_lba + 1);
378                         sdkp->capacity = max_lba + 1;
379                 }
380         }
381
382         /*
383          * Check same field: for any value other than 0, we know that all zones
384          * have the same size.
385          */
386         same = buf[4] & 0x0f;
387         if (same > 0) {
388                 rec = &buf[64];
389                 zone_blocks = get_unaligned_be64(&rec[8]);
390                 goto out;
391         }
392
393         /*
394          * Check the size of all zones: all zones must be of
395          * equal size, except the last zone which can be smaller
396          * than other zones.
397          */
398         do {
399
400                 /* Parse REPORT ZONES header */
401                 buflen = min_t(size_t, get_unaligned_be32(&buf[0]) + 64,
402                                bufsize);
403                 rec = buf + 64;
404
405                 /* Parse zone descriptors */
406                 while (rec < buf + buflen) {
407                         u64 this_zone_blocks = get_unaligned_be64(&rec[8]);
408
409                         if (zone_blocks == 0) {
410                                 zone_blocks = this_zone_blocks;
411                         } else if (this_zone_blocks != zone_blocks &&
412                                    (block + this_zone_blocks < sdkp->capacity
413                                     || this_zone_blocks > zone_blocks)) {
414                                 zone_blocks = 0;
415                                 goto out;
416                         }
417                         block += this_zone_blocks;
418                         rec += 64;
419                 }
420
421                 if (block < sdkp->capacity) {
422                         ret = sd_zbc_do_report_zones(sdkp, buf, bufsize, block,
423                                                      true);
424                         if (ret)
425                                 goto out_free;
426                 }
427
428         } while (block < sdkp->capacity);
429
430 out:
431         if (!zone_blocks) {
432                 if (sdkp->first_scan)
433                         sd_printk(KERN_NOTICE, sdkp,
434                                   "Devices with non constant zone "
435                                   "size are not supported\n");
436                 ret = -ENODEV;
437         } else if (!is_power_of_2(zone_blocks)) {
438                 if (sdkp->first_scan)
439                         sd_printk(KERN_NOTICE, sdkp,
440                                   "Devices with non power of 2 zone "
441                                   "size are not supported\n");
442                 ret = -ENODEV;
443         } else if (logical_to_sectors(sdkp->device, zone_blocks) > UINT_MAX) {
444                 if (sdkp->first_scan)
445                         sd_printk(KERN_NOTICE, sdkp,
446                                   "Zone size too large\n");
447                 ret = -EFBIG;
448         } else {
449                 *zblocks = zone_blocks;
450                 ret = 0;
451         }
452
453 out_free:
454         memalloc_noio_restore(noio_flag);
455         kvfree(buf);
456
457         return ret;
458 }
459
460 int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
461 {
462         struct gendisk *disk = sdkp->disk;
463         unsigned int nr_zones;
464         u32 zone_blocks = 0;
465         int ret;
466
467         if (!sd_is_zoned(sdkp))
468                 /*
469                  * Device managed or normal SCSI disk,
470                  * no special handling required
471                  */
472                 return 0;
473
474         /* Check zoned block device characteristics (unconstrained reads) */
475         ret = sd_zbc_check_zoned_characteristics(sdkp, buf);
476         if (ret)
477                 goto err;
478
479         /*
480          * Check zone size: only devices with a constant zone size (except
481          * an eventual last runt zone) that is a power of 2 are supported.
482          */
483         ret = sd_zbc_check_zones(sdkp, &zone_blocks);
484         if (ret != 0)
485                 goto err;
486
487         /* The drive satisfies the kernel restrictions: set it up */
488         blk_queue_chunk_sectors(sdkp->disk->queue,
489                         logical_to_sectors(sdkp->device, zone_blocks));
490         nr_zones = round_up(sdkp->capacity, zone_blocks) >> ilog2(zone_blocks);
491
492         /* READ16/WRITE16 is mandatory for ZBC disks */
493         sdkp->device->use_16_for_rw = 1;
494         sdkp->device->use_10_for_rw = 0;
495
496         /*
497          * Revalidate the disk zone bitmaps once the block device capacity is
498          * set on the second revalidate execution during disk scan and if
499          * something changed when executing a normal revalidate.
500          */
501         if (sdkp->first_scan) {
502                 sdkp->zone_blocks = zone_blocks;
503                 sdkp->nr_zones = nr_zones;
504                 return 0;
505         }
506
507         if (sdkp->zone_blocks != zone_blocks ||
508             sdkp->nr_zones != nr_zones ||
509             disk->queue->nr_zones != nr_zones) {
510                 ret = blk_revalidate_disk_zones(disk);
511                 if (ret != 0)
512                         goto err;
513                 sdkp->zone_blocks = zone_blocks;
514                 sdkp->nr_zones = nr_zones;
515         }
516
517         return 0;
518
519 err:
520         sdkp->capacity = 0;
521
522         return ret;
523 }
524
525 void sd_zbc_print_zones(struct scsi_disk *sdkp)
526 {
527         if (!sd_is_zoned(sdkp) || !sdkp->capacity)
528                 return;
529
530         if (sdkp->capacity & (sdkp->zone_blocks - 1))
531                 sd_printk(KERN_NOTICE, sdkp,
532                           "%u zones of %u logical blocks + 1 runt zone\n",
533                           sdkp->nr_zones - 1,
534                           sdkp->zone_blocks);
535         else
536                 sd_printk(KERN_NOTICE, sdkp,
537                           "%u zones of %u logical blocks\n",
538                           sdkp->nr_zones,
539                           sdkp->zone_blocks);
540 }