Merge tag 'kvm-s390-next-5.3-1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.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
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 }