dt-bindings: pinctrl: qcom,sm8450-pinctrl: fix indentation in example
[platform/kernel/linux-starfive.git] / block / blk-zoned.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Zoned block device handling
4  *
5  * Copyright (c) 2015, Hannes Reinecke
6  * Copyright (c) 2015, SUSE Linux GmbH
7  *
8  * Copyright (c) 2016, Damien Le Moal
9  * Copyright (c) 2016, Western Digital
10  */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/rbtree.h>
15 #include <linux/blkdev.h>
16 #include <linux/blk-mq.h>
17 #include <linux/mm.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched/mm.h>
20
21 #include "blk.h"
22
23 #define ZONE_COND_NAME(name) [BLK_ZONE_COND_##name] = #name
24 static const char *const zone_cond_name[] = {
25         ZONE_COND_NAME(NOT_WP),
26         ZONE_COND_NAME(EMPTY),
27         ZONE_COND_NAME(IMP_OPEN),
28         ZONE_COND_NAME(EXP_OPEN),
29         ZONE_COND_NAME(CLOSED),
30         ZONE_COND_NAME(READONLY),
31         ZONE_COND_NAME(FULL),
32         ZONE_COND_NAME(OFFLINE),
33 };
34 #undef ZONE_COND_NAME
35
36 /**
37  * blk_zone_cond_str - Return string XXX in BLK_ZONE_COND_XXX.
38  * @zone_cond: BLK_ZONE_COND_XXX.
39  *
40  * Description: Centralize block layer function to convert BLK_ZONE_COND_XXX
41  * into string format. Useful in the debugging and tracing zone conditions. For
42  * invalid BLK_ZONE_COND_XXX it returns string "UNKNOWN".
43  */
44 const char *blk_zone_cond_str(enum blk_zone_cond zone_cond)
45 {
46         static const char *zone_cond_str = "UNKNOWN";
47
48         if (zone_cond < ARRAY_SIZE(zone_cond_name) && zone_cond_name[zone_cond])
49                 zone_cond_str = zone_cond_name[zone_cond];
50
51         return zone_cond_str;
52 }
53 EXPORT_SYMBOL_GPL(blk_zone_cond_str);
54
55 /*
56  * Return true if a request is a write requests that needs zone write locking.
57  */
58 bool blk_req_needs_zone_write_lock(struct request *rq)
59 {
60         if (blk_rq_is_passthrough(rq))
61                 return false;
62
63         if (!rq->q->disk->seq_zones_wlock)
64                 return false;
65
66         switch (req_op(rq)) {
67         case REQ_OP_WRITE_ZEROES:
68         case REQ_OP_WRITE:
69                 return blk_rq_zone_is_seq(rq);
70         default:
71                 return false;
72         }
73 }
74 EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock);
75
76 bool blk_req_zone_write_trylock(struct request *rq)
77 {
78         unsigned int zno = blk_rq_zone_no(rq);
79
80         if (test_and_set_bit(zno, rq->q->disk->seq_zones_wlock))
81                 return false;
82
83         WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
84         rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
85
86         return true;
87 }
88 EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock);
89
90 void __blk_req_zone_write_lock(struct request *rq)
91 {
92         if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
93                                           rq->q->disk->seq_zones_wlock)))
94                 return;
95
96         WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
97         rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
98 }
99 EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock);
100
101 void __blk_req_zone_write_unlock(struct request *rq)
102 {
103         rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
104         if (rq->q->disk->seq_zones_wlock)
105                 WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
106                                                  rq->q->disk->seq_zones_wlock));
107 }
108 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
109
110 /**
111  * bdev_nr_zones - Get number of zones
112  * @bdev:       Target device
113  *
114  * Return the total number of zones of a zoned block device.  For a block
115  * device without zone capabilities, the number of zones is always 0.
116  */
117 unsigned int bdev_nr_zones(struct block_device *bdev)
118 {
119         sector_t zone_sectors = bdev_zone_sectors(bdev);
120
121         if (!bdev_is_zoned(bdev))
122                 return 0;
123         return (bdev_nr_sectors(bdev) + zone_sectors - 1) >>
124                 ilog2(zone_sectors);
125 }
126 EXPORT_SYMBOL_GPL(bdev_nr_zones);
127
128 /**
129  * blkdev_report_zones - Get zones information
130  * @bdev:       Target block device
131  * @sector:     Sector from which to report zones
132  * @nr_zones:   Maximum number of zones to report
133  * @cb:         Callback function called for each reported zone
134  * @data:       Private data for the callback
135  *
136  * Description:
137  *    Get zone information starting from the zone containing @sector for at most
138  *    @nr_zones, and call @cb for each zone reported by the device.
139  *    To report all zones in a device starting from @sector, the BLK_ALL_ZONES
140  *    constant can be passed to @nr_zones.
141  *    Returns the number of zones reported by the device, or a negative errno
142  *    value in case of failure.
143  *
144  *    Note: The caller must use memalloc_noXX_save/restore() calls to control
145  *    memory allocations done within this function.
146  */
147 int blkdev_report_zones(struct block_device *bdev, sector_t sector,
148                         unsigned int nr_zones, report_zones_cb cb, void *data)
149 {
150         struct gendisk *disk = bdev->bd_disk;
151         sector_t capacity = get_capacity(disk);
152
153         if (!bdev_is_zoned(bdev) || WARN_ON_ONCE(!disk->fops->report_zones))
154                 return -EOPNOTSUPP;
155
156         if (!nr_zones || sector >= capacity)
157                 return 0;
158
159         return disk->fops->report_zones(disk, sector, nr_zones, cb, data);
160 }
161 EXPORT_SYMBOL_GPL(blkdev_report_zones);
162
163 static inline unsigned long *blk_alloc_zone_bitmap(int node,
164                                                    unsigned int nr_zones)
165 {
166         return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long),
167                             GFP_NOIO, node);
168 }
169
170 static int blk_zone_need_reset_cb(struct blk_zone *zone, unsigned int idx,
171                                   void *data)
172 {
173         /*
174          * For an all-zones reset, ignore conventional, empty, read-only
175          * and offline zones.
176          */
177         switch (zone->cond) {
178         case BLK_ZONE_COND_NOT_WP:
179         case BLK_ZONE_COND_EMPTY:
180         case BLK_ZONE_COND_READONLY:
181         case BLK_ZONE_COND_OFFLINE:
182                 return 0;
183         default:
184                 set_bit(idx, (unsigned long *)data);
185                 return 0;
186         }
187 }
188
189 static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
190                                           gfp_t gfp_mask)
191 {
192         struct gendisk *disk = bdev->bd_disk;
193         sector_t capacity = bdev_nr_sectors(bdev);
194         sector_t zone_sectors = bdev_zone_sectors(bdev);
195         unsigned long *need_reset;
196         struct bio *bio = NULL;
197         sector_t sector = 0;
198         int ret;
199
200         need_reset = blk_alloc_zone_bitmap(disk->queue->node, disk->nr_zones);
201         if (!need_reset)
202                 return -ENOMEM;
203
204         ret = disk->fops->report_zones(disk, 0, disk->nr_zones,
205                                        blk_zone_need_reset_cb, need_reset);
206         if (ret < 0)
207                 goto out_free_need_reset;
208
209         ret = 0;
210         while (sector < capacity) {
211                 if (!test_bit(disk_zone_no(disk, sector), need_reset)) {
212                         sector += zone_sectors;
213                         continue;
214                 }
215
216                 bio = blk_next_bio(bio, bdev, 0, REQ_OP_ZONE_RESET | REQ_SYNC,
217                                    gfp_mask);
218                 bio->bi_iter.bi_sector = sector;
219                 sector += zone_sectors;
220
221                 /* This may take a while, so be nice to others */
222                 cond_resched();
223         }
224
225         if (bio) {
226                 ret = submit_bio_wait(bio);
227                 bio_put(bio);
228         }
229
230 out_free_need_reset:
231         kfree(need_reset);
232         return ret;
233 }
234
235 static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
236 {
237         struct bio bio;
238
239         bio_init(&bio, bdev, NULL, 0, REQ_OP_ZONE_RESET_ALL | REQ_SYNC);
240         return submit_bio_wait(&bio);
241 }
242
243 /**
244  * blkdev_zone_mgmt - Execute a zone management operation on a range of zones
245  * @bdev:       Target block device
246  * @op:         Operation to be performed on the zones
247  * @sector:     Start sector of the first zone to operate on
248  * @nr_sectors: Number of sectors, should be at least the length of one zone and
249  *              must be zone size aligned.
250  * @gfp_mask:   Memory allocation flags (for bio_alloc)
251  *
252  * Description:
253  *    Perform the specified operation on the range of zones specified by
254  *    @sector..@sector+@nr_sectors. Specifying the entire disk sector range
255  *    is valid, but the specified range should not contain conventional zones.
256  *    The operation to execute on each zone can be a zone reset, open, close
257  *    or finish request.
258  */
259 int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
260                      sector_t sector, sector_t nr_sectors, gfp_t gfp_mask)
261 {
262         struct request_queue *q = bdev_get_queue(bdev);
263         sector_t zone_sectors = bdev_zone_sectors(bdev);
264         sector_t capacity = bdev_nr_sectors(bdev);
265         sector_t end_sector = sector + nr_sectors;
266         struct bio *bio = NULL;
267         int ret = 0;
268
269         if (!bdev_is_zoned(bdev))
270                 return -EOPNOTSUPP;
271
272         if (bdev_read_only(bdev))
273                 return -EPERM;
274
275         if (!op_is_zone_mgmt(op))
276                 return -EOPNOTSUPP;
277
278         if (end_sector <= sector || end_sector > capacity)
279                 /* Out of range */
280                 return -EINVAL;
281
282         /* Check alignment (handle eventual smaller last zone) */
283         if (sector & (zone_sectors - 1))
284                 return -EINVAL;
285
286         if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity)
287                 return -EINVAL;
288
289         /*
290          * In the case of a zone reset operation over all zones,
291          * REQ_OP_ZONE_RESET_ALL can be used with devices supporting this
292          * command. For other devices, we emulate this command behavior by
293          * identifying the zones needing a reset.
294          */
295         if (op == REQ_OP_ZONE_RESET && sector == 0 && nr_sectors == capacity) {
296                 if (!blk_queue_zone_resetall(q))
297                         return blkdev_zone_reset_all_emulated(bdev, gfp_mask);
298                 return blkdev_zone_reset_all(bdev, gfp_mask);
299         }
300
301         while (sector < end_sector) {
302                 bio = blk_next_bio(bio, bdev, 0, op | REQ_SYNC, gfp_mask);
303                 bio->bi_iter.bi_sector = sector;
304                 sector += zone_sectors;
305
306                 /* This may take a while, so be nice to others */
307                 cond_resched();
308         }
309
310         ret = submit_bio_wait(bio);
311         bio_put(bio);
312
313         return ret;
314 }
315 EXPORT_SYMBOL_GPL(blkdev_zone_mgmt);
316
317 struct zone_report_args {
318         struct blk_zone __user *zones;
319 };
320
321 static int blkdev_copy_zone_to_user(struct blk_zone *zone, unsigned int idx,
322                                     void *data)
323 {
324         struct zone_report_args *args = data;
325
326         if (copy_to_user(&args->zones[idx], zone, sizeof(struct blk_zone)))
327                 return -EFAULT;
328         return 0;
329 }
330
331 /*
332  * BLKREPORTZONE ioctl processing.
333  * Called from blkdev_ioctl.
334  */
335 int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
336                               unsigned int cmd, unsigned long arg)
337 {
338         void __user *argp = (void __user *)arg;
339         struct zone_report_args args;
340         struct request_queue *q;
341         struct blk_zone_report rep;
342         int ret;
343
344         if (!argp)
345                 return -EINVAL;
346
347         q = bdev_get_queue(bdev);
348         if (!q)
349                 return -ENXIO;
350
351         if (!bdev_is_zoned(bdev))
352                 return -ENOTTY;
353
354         if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
355                 return -EFAULT;
356
357         if (!rep.nr_zones)
358                 return -EINVAL;
359
360         args.zones = argp + sizeof(struct blk_zone_report);
361         ret = blkdev_report_zones(bdev, rep.sector, rep.nr_zones,
362                                   blkdev_copy_zone_to_user, &args);
363         if (ret < 0)
364                 return ret;
365
366         rep.nr_zones = ret;
367         rep.flags = BLK_ZONE_REP_CAPACITY;
368         if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report)))
369                 return -EFAULT;
370         return 0;
371 }
372
373 static int blkdev_truncate_zone_range(struct block_device *bdev, fmode_t mode,
374                                       const struct blk_zone_range *zrange)
375 {
376         loff_t start, end;
377
378         if (zrange->sector + zrange->nr_sectors <= zrange->sector ||
379             zrange->sector + zrange->nr_sectors > get_capacity(bdev->bd_disk))
380                 /* Out of range */
381                 return -EINVAL;
382
383         start = zrange->sector << SECTOR_SHIFT;
384         end = ((zrange->sector + zrange->nr_sectors) << SECTOR_SHIFT) - 1;
385
386         return truncate_bdev_range(bdev, mode, start, end);
387 }
388
389 /*
390  * BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
391  * Called from blkdev_ioctl.
392  */
393 int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
394                            unsigned int cmd, unsigned long arg)
395 {
396         void __user *argp = (void __user *)arg;
397         struct request_queue *q;
398         struct blk_zone_range zrange;
399         enum req_op op;
400         int ret;
401
402         if (!argp)
403                 return -EINVAL;
404
405         q = bdev_get_queue(bdev);
406         if (!q)
407                 return -ENXIO;
408
409         if (!bdev_is_zoned(bdev))
410                 return -ENOTTY;
411
412         if (!(mode & FMODE_WRITE))
413                 return -EBADF;
414
415         if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
416                 return -EFAULT;
417
418         switch (cmd) {
419         case BLKRESETZONE:
420                 op = REQ_OP_ZONE_RESET;
421
422                 /* Invalidate the page cache, including dirty pages. */
423                 filemap_invalidate_lock(bdev->bd_inode->i_mapping);
424                 ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
425                 if (ret)
426                         goto fail;
427                 break;
428         case BLKOPENZONE:
429                 op = REQ_OP_ZONE_OPEN;
430                 break;
431         case BLKCLOSEZONE:
432                 op = REQ_OP_ZONE_CLOSE;
433                 break;
434         case BLKFINISHZONE:
435                 op = REQ_OP_ZONE_FINISH;
436                 break;
437         default:
438                 return -ENOTTY;
439         }
440
441         ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
442                                GFP_KERNEL);
443
444 fail:
445         if (cmd == BLKRESETZONE)
446                 filemap_invalidate_unlock(bdev->bd_inode->i_mapping);
447
448         return ret;
449 }
450
451 void disk_free_zone_bitmaps(struct gendisk *disk)
452 {
453         kfree(disk->conv_zones_bitmap);
454         disk->conv_zones_bitmap = NULL;
455         kfree(disk->seq_zones_wlock);
456         disk->seq_zones_wlock = NULL;
457 }
458
459 struct blk_revalidate_zone_args {
460         struct gendisk  *disk;
461         unsigned long   *conv_zones_bitmap;
462         unsigned long   *seq_zones_wlock;
463         unsigned int    nr_zones;
464         sector_t        zone_sectors;
465         sector_t        sector;
466 };
467
468 /*
469  * Helper function to check the validity of zones of a zoned block device.
470  */
471 static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx,
472                                   void *data)
473 {
474         struct blk_revalidate_zone_args *args = data;
475         struct gendisk *disk = args->disk;
476         struct request_queue *q = disk->queue;
477         sector_t capacity = get_capacity(disk);
478
479         /*
480          * All zones must have the same size, with the exception on an eventual
481          * smaller last zone.
482          */
483         if (zone->start == 0) {
484                 if (zone->len == 0 || !is_power_of_2(zone->len)) {
485                         pr_warn("%s: Invalid zoned device with non power of two zone size (%llu)\n",
486                                 disk->disk_name, zone->len);
487                         return -ENODEV;
488                 }
489
490                 args->zone_sectors = zone->len;
491                 args->nr_zones = (capacity + zone->len - 1) >> ilog2(zone->len);
492         } else if (zone->start + args->zone_sectors < capacity) {
493                 if (zone->len != args->zone_sectors) {
494                         pr_warn("%s: Invalid zoned device with non constant zone size\n",
495                                 disk->disk_name);
496                         return -ENODEV;
497                 }
498         } else {
499                 if (zone->len > args->zone_sectors) {
500                         pr_warn("%s: Invalid zoned device with larger last zone size\n",
501                                 disk->disk_name);
502                         return -ENODEV;
503                 }
504         }
505
506         /* Check for holes in the zone report */
507         if (zone->start != args->sector) {
508                 pr_warn("%s: Zone gap at sectors %llu..%llu\n",
509                         disk->disk_name, args->sector, zone->start);
510                 return -ENODEV;
511         }
512
513         /* Check zone type */
514         switch (zone->type) {
515         case BLK_ZONE_TYPE_CONVENTIONAL:
516                 if (!args->conv_zones_bitmap) {
517                         args->conv_zones_bitmap =
518                                 blk_alloc_zone_bitmap(q->node, args->nr_zones);
519                         if (!args->conv_zones_bitmap)
520                                 return -ENOMEM;
521                 }
522                 set_bit(idx, args->conv_zones_bitmap);
523                 break;
524         case BLK_ZONE_TYPE_SEQWRITE_REQ:
525         case BLK_ZONE_TYPE_SEQWRITE_PREF:
526                 if (!args->seq_zones_wlock) {
527                         args->seq_zones_wlock =
528                                 blk_alloc_zone_bitmap(q->node, args->nr_zones);
529                         if (!args->seq_zones_wlock)
530                                 return -ENOMEM;
531                 }
532                 break;
533         default:
534                 pr_warn("%s: Invalid zone type 0x%x at sectors %llu\n",
535                         disk->disk_name, (int)zone->type, zone->start);
536                 return -ENODEV;
537         }
538
539         args->sector += zone->len;
540         return 0;
541 }
542
543 /**
544  * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
545  * @disk:       Target disk
546  * @update_driver_data: Callback to update driver data on the frozen disk
547  *
548  * Helper function for low-level device drivers to (re) allocate and initialize
549  * a disk request queue zone bitmaps. This functions should normally be called
550  * within the disk ->revalidate method for blk-mq based drivers.  For BIO based
551  * drivers only q->nr_zones needs to be updated so that the sysfs exposed value
552  * is correct.
553  * If the @update_driver_data callback function is not NULL, the callback is
554  * executed with the device request queue frozen after all zones have been
555  * checked.
556  */
557 int blk_revalidate_disk_zones(struct gendisk *disk,
558                               void (*update_driver_data)(struct gendisk *disk))
559 {
560         struct request_queue *q = disk->queue;
561         struct blk_revalidate_zone_args args = {
562                 .disk           = disk,
563         };
564         unsigned int noio_flag;
565         int ret;
566
567         if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
568                 return -EIO;
569         if (WARN_ON_ONCE(!queue_is_mq(q)))
570                 return -EIO;
571
572         if (!get_capacity(disk))
573                 return -EIO;
574
575         /*
576          * Ensure that all memory allocations in this context are done as if
577          * GFP_NOIO was specified.
578          */
579         noio_flag = memalloc_noio_save();
580         ret = disk->fops->report_zones(disk, 0, UINT_MAX,
581                                        blk_revalidate_zone_cb, &args);
582         if (!ret) {
583                 pr_warn("%s: No zones reported\n", disk->disk_name);
584                 ret = -ENODEV;
585         }
586         memalloc_noio_restore(noio_flag);
587
588         /*
589          * If zones where reported, make sure that the entire disk capacity
590          * has been checked.
591          */
592         if (ret > 0 && args.sector != get_capacity(disk)) {
593                 pr_warn("%s: Missing zones from sector %llu\n",
594                         disk->disk_name, args.sector);
595                 ret = -ENODEV;
596         }
597
598         /*
599          * Install the new bitmaps and update nr_zones only once the queue is
600          * stopped and all I/Os are completed (i.e. a scheduler is not
601          * referencing the bitmaps).
602          */
603         blk_mq_freeze_queue(q);
604         if (ret > 0) {
605                 blk_queue_chunk_sectors(q, args.zone_sectors);
606                 disk->nr_zones = args.nr_zones;
607                 swap(disk->seq_zones_wlock, args.seq_zones_wlock);
608                 swap(disk->conv_zones_bitmap, args.conv_zones_bitmap);
609                 if (update_driver_data)
610                         update_driver_data(disk);
611                 ret = 0;
612         } else {
613                 pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
614                 disk_free_zone_bitmaps(disk);
615         }
616         blk_mq_unfreeze_queue(q);
617
618         kfree(args.seq_zones_wlock);
619         kfree(args.conv_zones_bitmap);
620         return ret;
621 }
622 EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);
623
624 void disk_clear_zone_settings(struct gendisk *disk)
625 {
626         struct request_queue *q = disk->queue;
627
628         blk_mq_freeze_queue(q);
629
630         disk_free_zone_bitmaps(disk);
631         blk_queue_flag_clear(QUEUE_FLAG_ZONE_RESETALL, q);
632         q->required_elevator_features &= ~ELEVATOR_F_ZBD_SEQ_WRITE;
633         disk->nr_zones = 0;
634         disk->max_open_zones = 0;
635         disk->max_active_zones = 0;
636         q->limits.chunk_sectors = 0;
637         q->limits.zone_write_granularity = 0;
638         q->limits.max_zone_append_sectors = 0;
639
640         blk_mq_unfreeze_queue(q);
641 }