locking: export contention tracepoints for bcachefs six locks
[linux-2.6-block.git] / drivers / md / dm-zone.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2021 Western Digital Corporation or its affiliates.
4  */
5
6 #include <linux/blkdev.h>
7 #include <linux/mm.h>
8 #include <linux/sched/mm.h>
9 #include <linux/slab.h>
10 #include <linux/bitmap.h>
11
12 #include "dm-core.h"
13
14 #define DM_MSG_PREFIX "zone"
15
16 #define DM_ZONE_INVALID_WP_OFST         UINT_MAX
17
18 /*
19  * For internal zone reports bypassing the top BIO submission path.
20  */
21 static int dm_blk_do_report_zones(struct mapped_device *md, struct dm_table *t,
22                                   sector_t sector, unsigned int nr_zones,
23                                   report_zones_cb cb, void *data)
24 {
25         struct gendisk *disk = md->disk;
26         int ret;
27         struct dm_report_zones_args args = {
28                 .next_sector = sector,
29                 .orig_data = data,
30                 .orig_cb = cb,
31         };
32
33         do {
34                 struct dm_target *tgt;
35
36                 tgt = dm_table_find_target(t, args.next_sector);
37                 if (WARN_ON_ONCE(!tgt->type->report_zones))
38                         return -EIO;
39
40                 args.tgt = tgt;
41                 ret = tgt->type->report_zones(tgt, &args,
42                                               nr_zones - args.zone_idx);
43                 if (ret < 0)
44                         return ret;
45         } while (args.zone_idx < nr_zones &&
46                  args.next_sector < get_capacity(disk));
47
48         return args.zone_idx;
49 }
50
51 /*
52  * User facing dm device block device report zone operation. This calls the
53  * report_zones operation for each target of a device table. This operation is
54  * generally implemented by targets using dm_report_zones().
55  */
56 int dm_blk_report_zones(struct gendisk *disk, sector_t sector,
57                         unsigned int nr_zones, report_zones_cb cb, void *data)
58 {
59         struct mapped_device *md = disk->private_data;
60         struct dm_table *map;
61         int srcu_idx, ret;
62
63         if (dm_suspended_md(md))
64                 return -EAGAIN;
65
66         map = dm_get_live_table(md, &srcu_idx);
67         if (!map)
68                 return -EIO;
69
70         ret = dm_blk_do_report_zones(md, map, sector, nr_zones, cb, data);
71
72         dm_put_live_table(md, srcu_idx);
73
74         return ret;
75 }
76
77 static int dm_report_zones_cb(struct blk_zone *zone, unsigned int idx,
78                               void *data)
79 {
80         struct dm_report_zones_args *args = data;
81         sector_t sector_diff = args->tgt->begin - args->start;
82
83         /*
84          * Ignore zones beyond the target range.
85          */
86         if (zone->start >= args->start + args->tgt->len)
87                 return 0;
88
89         /*
90          * Remap the start sector and write pointer position of the zone
91          * to match its position in the target range.
92          */
93         zone->start += sector_diff;
94         if (zone->type != BLK_ZONE_TYPE_CONVENTIONAL) {
95                 if (zone->cond == BLK_ZONE_COND_FULL)
96                         zone->wp = zone->start + zone->len;
97                 else if (zone->cond == BLK_ZONE_COND_EMPTY)
98                         zone->wp = zone->start;
99                 else
100                         zone->wp += sector_diff;
101         }
102
103         args->next_sector = zone->start + zone->len;
104         return args->orig_cb(zone, args->zone_idx++, args->orig_data);
105 }
106
107 /*
108  * Helper for drivers of zoned targets to implement struct target_type
109  * report_zones operation.
110  */
111 int dm_report_zones(struct block_device *bdev, sector_t start, sector_t sector,
112                     struct dm_report_zones_args *args, unsigned int nr_zones)
113 {
114         /*
115          * Set the target mapping start sector first so that
116          * dm_report_zones_cb() can correctly remap zone information.
117          */
118         args->start = start;
119
120         return blkdev_report_zones(bdev, sector, nr_zones,
121                                    dm_report_zones_cb, args);
122 }
123 EXPORT_SYMBOL_GPL(dm_report_zones);
124
125 bool dm_is_zone_write(struct mapped_device *md, struct bio *bio)
126 {
127         struct request_queue *q = md->queue;
128
129         if (!blk_queue_is_zoned(q))
130                 return false;
131
132         switch (bio_op(bio)) {
133         case REQ_OP_WRITE_ZEROES:
134         case REQ_OP_WRITE:
135                 return !op_is_flush(bio->bi_opf) && bio_sectors(bio);
136         default:
137                 return false;
138         }
139 }
140
141 void dm_cleanup_zoned_dev(struct mapped_device *md)
142 {
143         if (md->disk) {
144                 bitmap_free(md->disk->conv_zones_bitmap);
145                 md->disk->conv_zones_bitmap = NULL;
146                 bitmap_free(md->disk->seq_zones_wlock);
147                 md->disk->seq_zones_wlock = NULL;
148         }
149
150         kvfree(md->zwp_offset);
151         md->zwp_offset = NULL;
152         md->nr_zones = 0;
153 }
154
155 static unsigned int dm_get_zone_wp_offset(struct blk_zone *zone)
156 {
157         switch (zone->cond) {
158         case BLK_ZONE_COND_IMP_OPEN:
159         case BLK_ZONE_COND_EXP_OPEN:
160         case BLK_ZONE_COND_CLOSED:
161                 return zone->wp - zone->start;
162         case BLK_ZONE_COND_FULL:
163                 return zone->len;
164         case BLK_ZONE_COND_EMPTY:
165         case BLK_ZONE_COND_NOT_WP:
166         case BLK_ZONE_COND_OFFLINE:
167         case BLK_ZONE_COND_READONLY:
168         default:
169                 /*
170                  * Conventional, offline and read-only zones do not have a valid
171                  * write pointer. Use 0 as for an empty zone.
172                  */
173                 return 0;
174         }
175 }
176
177 static int dm_zone_revalidate_cb(struct blk_zone *zone, unsigned int idx,
178                                  void *data)
179 {
180         struct mapped_device *md = data;
181         struct gendisk *disk = md->disk;
182
183         switch (zone->type) {
184         case BLK_ZONE_TYPE_CONVENTIONAL:
185                 if (!disk->conv_zones_bitmap) {
186                         disk->conv_zones_bitmap = bitmap_zalloc(disk->nr_zones,
187                                                                 GFP_NOIO);
188                         if (!disk->conv_zones_bitmap)
189                                 return -ENOMEM;
190                 }
191                 set_bit(idx, disk->conv_zones_bitmap);
192                 break;
193         case BLK_ZONE_TYPE_SEQWRITE_REQ:
194         case BLK_ZONE_TYPE_SEQWRITE_PREF:
195                 if (!disk->seq_zones_wlock) {
196                         disk->seq_zones_wlock = bitmap_zalloc(disk->nr_zones,
197                                                               GFP_NOIO);
198                         if (!disk->seq_zones_wlock)
199                                 return -ENOMEM;
200                 }
201                 if (!md->zwp_offset) {
202                         md->zwp_offset =
203                                 kvcalloc(disk->nr_zones, sizeof(unsigned int),
204                                          GFP_KERNEL);
205                         if (!md->zwp_offset)
206                                 return -ENOMEM;
207                 }
208                 md->zwp_offset[idx] = dm_get_zone_wp_offset(zone);
209
210                 break;
211         default:
212                 DMERR("Invalid zone type 0x%x at sectors %llu",
213                       (int)zone->type, zone->start);
214                 return -ENODEV;
215         }
216
217         return 0;
218 }
219
220 /*
221  * Revalidate the zones of a mapped device to initialize resource necessary
222  * for zone append emulation. Note that we cannot simply use the block layer
223  * blk_revalidate_disk_zones() function here as the mapped device is suspended
224  * (this is called from __bind() context).
225  */
226 static int dm_revalidate_zones(struct mapped_device *md, struct dm_table *t)
227 {
228         struct gendisk *disk = md->disk;
229         unsigned int noio_flag;
230         int ret;
231
232         /*
233          * Check if something changed. If yes, cleanup the current resources
234          * and reallocate everything.
235          */
236         if (!disk->nr_zones || disk->nr_zones != md->nr_zones)
237                 dm_cleanup_zoned_dev(md);
238         if (md->nr_zones)
239                 return 0;
240
241         /*
242          * Scan all zones to initialize everything. Ensure that all vmalloc
243          * operations in this context are done as if GFP_NOIO was specified.
244          */
245         noio_flag = memalloc_noio_save();
246         ret = dm_blk_do_report_zones(md, t, 0, disk->nr_zones,
247                                      dm_zone_revalidate_cb, md);
248         memalloc_noio_restore(noio_flag);
249         if (ret < 0)
250                 goto err;
251         if (ret != disk->nr_zones) {
252                 ret = -EIO;
253                 goto err;
254         }
255
256         md->nr_zones = disk->nr_zones;
257
258         return 0;
259
260 err:
261         DMERR("Revalidate zones failed %d", ret);
262         dm_cleanup_zoned_dev(md);
263         return ret;
264 }
265
266 static int device_not_zone_append_capable(struct dm_target *ti,
267                                           struct dm_dev *dev, sector_t start,
268                                           sector_t len, void *data)
269 {
270         return !bdev_is_zoned(dev->bdev);
271 }
272
273 static bool dm_table_supports_zone_append(struct dm_table *t)
274 {
275         for (unsigned int i = 0; i < t->num_targets; i++) {
276                 struct dm_target *ti = dm_table_get_target(t, i);
277
278                 if (ti->emulate_zone_append)
279                         return false;
280
281                 if (!ti->type->iterate_devices ||
282                     ti->type->iterate_devices(ti, device_not_zone_append_capable, NULL))
283                         return false;
284         }
285
286         return true;
287 }
288
289 int dm_set_zones_restrictions(struct dm_table *t, struct request_queue *q)
290 {
291         struct mapped_device *md = t->md;
292
293         /*
294          * For a zoned target, the number of zones should be updated for the
295          * correct value to be exposed in sysfs queue/nr_zones.
296          */
297         WARN_ON_ONCE(queue_is_mq(q));
298         md->disk->nr_zones = bdev_nr_zones(md->disk->part0);
299
300         /* Check if zone append is natively supported */
301         if (dm_table_supports_zone_append(t)) {
302                 clear_bit(DMF_EMULATE_ZONE_APPEND, &md->flags);
303                 dm_cleanup_zoned_dev(md);
304                 return 0;
305         }
306
307         /*
308          * Mark the mapped device as needing zone append emulation and
309          * initialize the emulation resources once the capacity is set.
310          */
311         set_bit(DMF_EMULATE_ZONE_APPEND, &md->flags);
312         if (!get_capacity(md->disk))
313                 return 0;
314
315         return dm_revalidate_zones(md, t);
316 }
317
318 static int dm_update_zone_wp_offset_cb(struct blk_zone *zone, unsigned int idx,
319                                        void *data)
320 {
321         unsigned int *wp_offset = data;
322
323         *wp_offset = dm_get_zone_wp_offset(zone);
324
325         return 0;
326 }
327
328 static int dm_update_zone_wp_offset(struct mapped_device *md, unsigned int zno,
329                                     unsigned int *wp_ofst)
330 {
331         sector_t sector = zno * bdev_zone_sectors(md->disk->part0);
332         unsigned int noio_flag;
333         struct dm_table *t;
334         int srcu_idx, ret;
335
336         t = dm_get_live_table(md, &srcu_idx);
337         if (!t)
338                 return -EIO;
339
340         /*
341          * Ensure that all memory allocations in this context are done as if
342          * GFP_NOIO was specified.
343          */
344         noio_flag = memalloc_noio_save();
345         ret = dm_blk_do_report_zones(md, t, sector, 1,
346                                      dm_update_zone_wp_offset_cb, wp_ofst);
347         memalloc_noio_restore(noio_flag);
348
349         dm_put_live_table(md, srcu_idx);
350
351         if (ret != 1)
352                 return -EIO;
353
354         return 0;
355 }
356
357 struct orig_bio_details {
358         enum req_op op;
359         unsigned int nr_sectors;
360 };
361
362 /*
363  * First phase of BIO mapping for targets with zone append emulation:
364  * check all BIO that change a zone writer pointer and change zone
365  * append operations into regular write operations.
366  */
367 static bool dm_zone_map_bio_begin(struct mapped_device *md,
368                                   unsigned int zno, struct bio *clone)
369 {
370         sector_t zsectors = bdev_zone_sectors(md->disk->part0);
371         unsigned int zwp_offset = READ_ONCE(md->zwp_offset[zno]);
372
373         /*
374          * If the target zone is in an error state, recover by inspecting the
375          * zone to get its current write pointer position. Note that since the
376          * target zone is already locked, a BIO issuing context should never
377          * see the zone write in the DM_ZONE_UPDATING_WP_OFST state.
378          */
379         if (zwp_offset == DM_ZONE_INVALID_WP_OFST) {
380                 if (dm_update_zone_wp_offset(md, zno, &zwp_offset))
381                         return false;
382                 WRITE_ONCE(md->zwp_offset[zno], zwp_offset);
383         }
384
385         switch (bio_op(clone)) {
386         case REQ_OP_ZONE_RESET:
387         case REQ_OP_ZONE_FINISH:
388                 return true;
389         case REQ_OP_WRITE_ZEROES:
390         case REQ_OP_WRITE:
391                 /* Writes must be aligned to the zone write pointer */
392                 if ((clone->bi_iter.bi_sector & (zsectors - 1)) != zwp_offset)
393                         return false;
394                 break;
395         case REQ_OP_ZONE_APPEND:
396                 /*
397                  * Change zone append operations into a non-mergeable regular
398                  * writes directed at the current write pointer position of the
399                  * target zone.
400                  */
401                 clone->bi_opf = REQ_OP_WRITE | REQ_NOMERGE |
402                         (clone->bi_opf & (~REQ_OP_MASK));
403                 clone->bi_iter.bi_sector += zwp_offset;
404                 break;
405         default:
406                 DMWARN_LIMIT("Invalid BIO operation");
407                 return false;
408         }
409
410         /* Cannot write to a full zone */
411         if (zwp_offset >= zsectors)
412                 return false;
413
414         return true;
415 }
416
417 /*
418  * Second phase of BIO mapping for targets with zone append emulation:
419  * update the zone write pointer offset array to account for the additional
420  * data written to a zone. Note that at this point, the remapped clone BIO
421  * may already have completed, so we do not touch it.
422  */
423 static blk_status_t dm_zone_map_bio_end(struct mapped_device *md, unsigned int zno,
424                                         struct orig_bio_details *orig_bio_details,
425                                         unsigned int nr_sectors)
426 {
427         unsigned int zwp_offset = READ_ONCE(md->zwp_offset[zno]);
428
429         /* The clone BIO may already have been completed and failed */
430         if (zwp_offset == DM_ZONE_INVALID_WP_OFST)
431                 return BLK_STS_IOERR;
432
433         /* Update the zone wp offset */
434         switch (orig_bio_details->op) {
435         case REQ_OP_ZONE_RESET:
436                 WRITE_ONCE(md->zwp_offset[zno], 0);
437                 return BLK_STS_OK;
438         case REQ_OP_ZONE_FINISH:
439                 WRITE_ONCE(md->zwp_offset[zno],
440                            bdev_zone_sectors(md->disk->part0));
441                 return BLK_STS_OK;
442         case REQ_OP_WRITE_ZEROES:
443         case REQ_OP_WRITE:
444                 WRITE_ONCE(md->zwp_offset[zno], zwp_offset + nr_sectors);
445                 return BLK_STS_OK;
446         case REQ_OP_ZONE_APPEND:
447                 /*
448                  * Check that the target did not truncate the write operation
449                  * emulating a zone append.
450                  */
451                 if (nr_sectors != orig_bio_details->nr_sectors) {
452                         DMWARN_LIMIT("Truncated write for zone append");
453                         return BLK_STS_IOERR;
454                 }
455                 WRITE_ONCE(md->zwp_offset[zno], zwp_offset + nr_sectors);
456                 return BLK_STS_OK;
457         default:
458                 DMWARN_LIMIT("Invalid BIO operation");
459                 return BLK_STS_IOERR;
460         }
461 }
462
463 static inline void dm_zone_lock(struct gendisk *disk, unsigned int zno,
464                                 struct bio *clone)
465 {
466         if (WARN_ON_ONCE(bio_flagged(clone, BIO_ZONE_WRITE_LOCKED)))
467                 return;
468
469         wait_on_bit_lock_io(disk->seq_zones_wlock, zno, TASK_UNINTERRUPTIBLE);
470         bio_set_flag(clone, BIO_ZONE_WRITE_LOCKED);
471 }
472
473 static inline void dm_zone_unlock(struct gendisk *disk, unsigned int zno,
474                                   struct bio *clone)
475 {
476         if (!bio_flagged(clone, BIO_ZONE_WRITE_LOCKED))
477                 return;
478
479         WARN_ON_ONCE(!test_bit(zno, disk->seq_zones_wlock));
480         clear_bit_unlock(zno, disk->seq_zones_wlock);
481         smp_mb__after_atomic();
482         wake_up_bit(disk->seq_zones_wlock, zno);
483
484         bio_clear_flag(clone, BIO_ZONE_WRITE_LOCKED);
485 }
486
487 static bool dm_need_zone_wp_tracking(struct bio *bio)
488 {
489         /*
490          * Special processing is not needed for operations that do not need the
491          * zone write lock, that is, all operations that target conventional
492          * zones and all operations that do not modify directly a sequential
493          * zone write pointer.
494          */
495         if (op_is_flush(bio->bi_opf) && !bio_sectors(bio))
496                 return false;
497         switch (bio_op(bio)) {
498         case REQ_OP_WRITE_ZEROES:
499         case REQ_OP_WRITE:
500         case REQ_OP_ZONE_RESET:
501         case REQ_OP_ZONE_FINISH:
502         case REQ_OP_ZONE_APPEND:
503                 return bio_zone_is_seq(bio);
504         default:
505                 return false;
506         }
507 }
508
509 /*
510  * Special IO mapping for targets needing zone append emulation.
511  */
512 int dm_zone_map_bio(struct dm_target_io *tio)
513 {
514         struct dm_io *io = tio->io;
515         struct dm_target *ti = tio->ti;
516         struct mapped_device *md = io->md;
517         struct bio *clone = &tio->clone;
518         struct orig_bio_details orig_bio_details;
519         unsigned int zno;
520         blk_status_t sts;
521         int r;
522
523         /*
524          * IOs that do not change a zone write pointer do not need
525          * any additional special processing.
526          */
527         if (!dm_need_zone_wp_tracking(clone))
528                 return ti->type->map(ti, clone);
529
530         /* Lock the target zone */
531         zno = bio_zone_no(clone);
532         dm_zone_lock(md->disk, zno, clone);
533
534         orig_bio_details.nr_sectors = bio_sectors(clone);
535         orig_bio_details.op = bio_op(clone);
536
537         /*
538          * Check that the bio and the target zone write pointer offset are
539          * both valid, and if the bio is a zone append, remap it to a write.
540          */
541         if (!dm_zone_map_bio_begin(md, zno, clone)) {
542                 dm_zone_unlock(md->disk, zno, clone);
543                 return DM_MAPIO_KILL;
544         }
545
546         /* Let the target do its work */
547         r = ti->type->map(ti, clone);
548         switch (r) {
549         case DM_MAPIO_SUBMITTED:
550                 /*
551                  * The target submitted the clone BIO. The target zone will
552                  * be unlocked on completion of the clone.
553                  */
554                 sts = dm_zone_map_bio_end(md, zno, &orig_bio_details,
555                                           *tio->len_ptr);
556                 break;
557         case DM_MAPIO_REMAPPED:
558                 /*
559                  * The target only remapped the clone BIO. In case of error,
560                  * unlock the target zone here as the clone will not be
561                  * submitted.
562                  */
563                 sts = dm_zone_map_bio_end(md, zno, &orig_bio_details,
564                                           *tio->len_ptr);
565                 if (sts != BLK_STS_OK)
566                         dm_zone_unlock(md->disk, zno, clone);
567                 break;
568         case DM_MAPIO_REQUEUE:
569         case DM_MAPIO_KILL:
570         default:
571                 dm_zone_unlock(md->disk, zno, clone);
572                 sts = BLK_STS_IOERR;
573                 break;
574         }
575
576         if (sts != BLK_STS_OK)
577                 return DM_MAPIO_KILL;
578
579         return r;
580 }
581
582 /*
583  * IO completion callback called from clone_endio().
584  */
585 void dm_zone_endio(struct dm_io *io, struct bio *clone)
586 {
587         struct mapped_device *md = io->md;
588         struct gendisk *disk = md->disk;
589         struct bio *orig_bio = io->orig_bio;
590         unsigned int zwp_offset;
591         unsigned int zno;
592
593         /*
594          * For targets that do not emulate zone append, we only need to
595          * handle native zone-append bios.
596          */
597         if (!dm_emulate_zone_append(md)) {
598                 /*
599                  * Get the offset within the zone of the written sector
600                  * and add that to the original bio sector position.
601                  */
602                 if (clone->bi_status == BLK_STS_OK &&
603                     bio_op(clone) == REQ_OP_ZONE_APPEND) {
604                         sector_t mask =
605                                 (sector_t)bdev_zone_sectors(disk->part0) - 1;
606
607                         orig_bio->bi_iter.bi_sector +=
608                                 clone->bi_iter.bi_sector & mask;
609                 }
610
611                 return;
612         }
613
614         /*
615          * For targets that do emulate zone append, if the clone BIO does not
616          * own the target zone write lock, we have nothing to do.
617          */
618         if (!bio_flagged(clone, BIO_ZONE_WRITE_LOCKED))
619                 return;
620
621         zno = bio_zone_no(orig_bio);
622
623         if (clone->bi_status != BLK_STS_OK) {
624                 /*
625                  * BIOs that modify a zone write pointer may leave the zone
626                  * in an unknown state in case of failure (e.g. the write
627                  * pointer was only partially advanced). In this case, set
628                  * the target zone write pointer as invalid unless it is
629                  * already being updated.
630                  */
631                 WRITE_ONCE(md->zwp_offset[zno], DM_ZONE_INVALID_WP_OFST);
632         } else if (bio_op(orig_bio) == REQ_OP_ZONE_APPEND) {
633                 /*
634                  * Get the written sector for zone append operation that were
635                  * emulated using regular write operations.
636                  */
637                 zwp_offset = READ_ONCE(md->zwp_offset[zno]);
638                 if (WARN_ON_ONCE(zwp_offset < bio_sectors(orig_bio)))
639                         WRITE_ONCE(md->zwp_offset[zno],
640                                    DM_ZONE_INVALID_WP_OFST);
641                 else
642                         orig_bio->bi_iter.bi_sector +=
643                                 zwp_offset - bio_sectors(orig_bio);
644         }
645
646         dm_zone_unlock(disk, zno, clone);
647 }