Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2017 Western Digital Corporation or its affiliates.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm-zoned.h"
9
10#include <linux/module.h>
11
12#define DM_MSG_PREFIX "zoned"
13
14#define DMZ_MIN_BIOS 8192
15
16/*
17 * Zone BIO context.
18 */
19struct dmz_bioctx {
20 struct dmz_dev *dev;
21 struct dm_zone *zone;
22 struct bio *bio;
23 refcount_t ref;
24};
25
26/*
27 * Chunk work descriptor.
28 */
29struct dm_chunk_work {
30 struct work_struct work;
31 refcount_t refcount;
32 struct dmz_target *target;
33 unsigned int chunk;
34 struct bio_list bio_list;
35};
36
37/*
38 * Target descriptor.
39 */
40struct dmz_target {
41 struct dm_dev **ddev;
42 unsigned int nr_ddevs;
43
44 unsigned int flags;
45
46 /* Zoned block device information */
47 struct dmz_dev *dev;
48
49 /* For metadata handling */
50 struct dmz_metadata *metadata;
51
52 /* For chunk work */
53 struct radix_tree_root chunk_rxtree;
54 struct workqueue_struct *chunk_wq;
55 struct mutex chunk_lock;
56
57 /* For cloned BIOs to zones */
58 struct bio_set bio_set;
59
60 /* For flush */
61 spinlock_t flush_lock;
62 struct bio_list flush_list;
63 struct delayed_work flush_work;
64 struct workqueue_struct *flush_wq;
65};
66
67/*
68 * Flush intervals (seconds).
69 */
70#define DMZ_FLUSH_PERIOD (10 * HZ)
71
72/*
73 * Target BIO completion.
74 */
75static inline void dmz_bio_endio(struct bio *bio, blk_status_t status)
76{
77 struct dmz_bioctx *bioctx =
78 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
79
80 if (status != BLK_STS_OK && bio->bi_status == BLK_STS_OK)
81 bio->bi_status = status;
82 if (bioctx->dev && bio->bi_status != BLK_STS_OK)
83 bioctx->dev->flags |= DMZ_CHECK_BDEV;
84
85 if (refcount_dec_and_test(&bioctx->ref)) {
86 struct dm_zone *zone = bioctx->zone;
87
88 if (zone) {
89 if (bio->bi_status != BLK_STS_OK &&
90 bio_op(bio) == REQ_OP_WRITE &&
91 dmz_is_seq(zone))
92 set_bit(DMZ_SEQ_WRITE_ERR, &zone->flags);
93 dmz_deactivate_zone(zone);
94 }
95 bio_endio(bio);
96 }
97}
98
99/*
100 * Completion callback for an internally cloned target BIO. This terminates the
101 * target BIO when there are no more references to its context.
102 */
103static void dmz_clone_endio(struct bio *clone)
104{
105 struct dmz_bioctx *bioctx = clone->bi_private;
106 blk_status_t status = clone->bi_status;
107
108 bio_put(clone);
109 dmz_bio_endio(bioctx->bio, status);
110}
111
112/*
113 * Issue a clone of a target BIO. The clone may only partially process the
114 * original target BIO.
115 */
116static int dmz_submit_bio(struct dmz_target *dmz, struct dm_zone *zone,
117 struct bio *bio, sector_t chunk_block,
118 unsigned int nr_blocks)
119{
120 struct dmz_bioctx *bioctx =
121 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
122 struct dmz_dev *dev = zone->dev;
123 struct bio *clone;
124
125 if (dev->flags & DMZ_BDEV_DYING)
126 return -EIO;
127
128 clone = bio_alloc_clone(dev->bdev, bio, GFP_NOIO, &dmz->bio_set);
129 if (!clone)
130 return -ENOMEM;
131
132 bioctx->dev = dev;
133 clone->bi_iter.bi_sector =
134 dmz_start_sect(dmz->metadata, zone) + dmz_blk2sect(chunk_block);
135 clone->bi_iter.bi_size = dmz_blk2sect(nr_blocks) << SECTOR_SHIFT;
136 clone->bi_end_io = dmz_clone_endio;
137 clone->bi_private = bioctx;
138
139 bio_advance(bio, clone->bi_iter.bi_size);
140
141 refcount_inc(&bioctx->ref);
142 submit_bio_noacct(clone);
143
144 if (bio_op(bio) == REQ_OP_WRITE && dmz_is_seq(zone))
145 zone->wp_block += nr_blocks;
146
147 return 0;
148}
149
150/*
151 * Zero out pages of discarded blocks accessed by a read BIO.
152 */
153static void dmz_handle_read_zero(struct dmz_target *dmz, struct bio *bio,
154 sector_t chunk_block, unsigned int nr_blocks)
155{
156 unsigned int size = nr_blocks << DMZ_BLOCK_SHIFT;
157
158 /* Clear nr_blocks */
159 swap(bio->bi_iter.bi_size, size);
160 zero_fill_bio(bio);
161 swap(bio->bi_iter.bi_size, size);
162
163 bio_advance(bio, size);
164}
165
166/*
167 * Process a read BIO.
168 */
169static int dmz_handle_read(struct dmz_target *dmz, struct dm_zone *zone,
170 struct bio *bio)
171{
172 struct dmz_metadata *zmd = dmz->metadata;
173 sector_t chunk_block = dmz_chunk_block(zmd, dmz_bio_block(bio));
174 unsigned int nr_blocks = dmz_bio_blocks(bio);
175 sector_t end_block = chunk_block + nr_blocks;
176 struct dm_zone *rzone, *bzone;
177 int ret;
178
179 /* Read into unmapped chunks need only zeroing the BIO buffer */
180 if (!zone) {
181 zero_fill_bio(bio);
182 return 0;
183 }
184
185 DMDEBUG("(%s): READ chunk %llu -> %s zone %u, block %llu, %u blocks",
186 dmz_metadata_label(zmd),
187 (unsigned long long)dmz_bio_chunk(zmd, bio),
188 (dmz_is_rnd(zone) ? "RND" :
189 (dmz_is_cache(zone) ? "CACHE" : "SEQ")),
190 zone->id,
191 (unsigned long long)chunk_block, nr_blocks);
192
193 /* Check block validity to determine the read location */
194 bzone = zone->bzone;
195 while (chunk_block < end_block) {
196 nr_blocks = 0;
197 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
198 chunk_block < zone->wp_block) {
199 /* Test block validity in the data zone */
200 ret = dmz_block_valid(zmd, zone, chunk_block);
201 if (ret < 0)
202 return ret;
203 if (ret > 0) {
204 /* Read data zone blocks */
205 nr_blocks = ret;
206 rzone = zone;
207 }
208 }
209
210 /*
211 * No valid blocks found in the data zone.
212 * Check the buffer zone, if there is one.
213 */
214 if (!nr_blocks && bzone) {
215 ret = dmz_block_valid(zmd, bzone, chunk_block);
216 if (ret < 0)
217 return ret;
218 if (ret > 0) {
219 /* Read buffer zone blocks */
220 nr_blocks = ret;
221 rzone = bzone;
222 }
223 }
224
225 if (nr_blocks) {
226 /* Valid blocks found: read them */
227 nr_blocks = min_t(unsigned int, nr_blocks,
228 end_block - chunk_block);
229 ret = dmz_submit_bio(dmz, rzone, bio,
230 chunk_block, nr_blocks);
231 if (ret)
232 return ret;
233 chunk_block += nr_blocks;
234 } else {
235 /* No valid block: zeroout the current BIO block */
236 dmz_handle_read_zero(dmz, bio, chunk_block, 1);
237 chunk_block++;
238 }
239 }
240
241 return 0;
242}
243
244/*
245 * Write blocks directly in a data zone, at the write pointer.
246 * If a buffer zone is assigned, invalidate the blocks written
247 * in place.
248 */
249static int dmz_handle_direct_write(struct dmz_target *dmz,
250 struct dm_zone *zone, struct bio *bio,
251 sector_t chunk_block,
252 unsigned int nr_blocks)
253{
254 struct dmz_metadata *zmd = dmz->metadata;
255 struct dm_zone *bzone = zone->bzone;
256 int ret;
257
258 if (dmz_is_readonly(zone))
259 return -EROFS;
260
261 /* Submit write */
262 ret = dmz_submit_bio(dmz, zone, bio, chunk_block, nr_blocks);
263 if (ret)
264 return ret;
265
266 /*
267 * Validate the blocks in the data zone and invalidate
268 * in the buffer zone, if there is one.
269 */
270 ret = dmz_validate_blocks(zmd, zone, chunk_block, nr_blocks);
271 if (ret == 0 && bzone)
272 ret = dmz_invalidate_blocks(zmd, bzone, chunk_block, nr_blocks);
273
274 return ret;
275}
276
277/*
278 * Write blocks in the buffer zone of @zone.
279 * If no buffer zone is assigned yet, get one.
280 * Called with @zone write locked.
281 */
282static int dmz_handle_buffered_write(struct dmz_target *dmz,
283 struct dm_zone *zone, struct bio *bio,
284 sector_t chunk_block,
285 unsigned int nr_blocks)
286{
287 struct dmz_metadata *zmd = dmz->metadata;
288 struct dm_zone *bzone;
289 int ret;
290
291 /* Get the buffer zone. One will be allocated if needed */
292 bzone = dmz_get_chunk_buffer(zmd, zone);
293 if (IS_ERR(bzone))
294 return PTR_ERR(bzone);
295
296 if (dmz_is_readonly(bzone))
297 return -EROFS;
298
299 /* Submit write */
300 ret = dmz_submit_bio(dmz, bzone, bio, chunk_block, nr_blocks);
301 if (ret)
302 return ret;
303
304 /*
305 * Validate the blocks in the buffer zone
306 * and invalidate in the data zone.
307 */
308 ret = dmz_validate_blocks(zmd, bzone, chunk_block, nr_blocks);
309 if (ret == 0 && chunk_block < zone->wp_block)
310 ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);
311
312 return ret;
313}
314
315/*
316 * Process a write BIO.
317 */
318static int dmz_handle_write(struct dmz_target *dmz, struct dm_zone *zone,
319 struct bio *bio)
320{
321 struct dmz_metadata *zmd = dmz->metadata;
322 sector_t chunk_block = dmz_chunk_block(zmd, dmz_bio_block(bio));
323 unsigned int nr_blocks = dmz_bio_blocks(bio);
324
325 if (!zone)
326 return -ENOSPC;
327
328 DMDEBUG("(%s): WRITE chunk %llu -> %s zone %u, block %llu, %u blocks",
329 dmz_metadata_label(zmd),
330 (unsigned long long)dmz_bio_chunk(zmd, bio),
331 (dmz_is_rnd(zone) ? "RND" :
332 (dmz_is_cache(zone) ? "CACHE" : "SEQ")),
333 zone->id,
334 (unsigned long long)chunk_block, nr_blocks);
335
336 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
337 chunk_block == zone->wp_block) {
338 /*
339 * zone is a random zone or it is a sequential zone
340 * and the BIO is aligned to the zone write pointer:
341 * direct write the zone.
342 */
343 return dmz_handle_direct_write(dmz, zone, bio,
344 chunk_block, nr_blocks);
345 }
346
347 /*
348 * This is an unaligned write in a sequential zone:
349 * use buffered write.
350 */
351 return dmz_handle_buffered_write(dmz, zone, bio, chunk_block, nr_blocks);
352}
353
354/*
355 * Process a discard BIO.
356 */
357static int dmz_handle_discard(struct dmz_target *dmz, struct dm_zone *zone,
358 struct bio *bio)
359{
360 struct dmz_metadata *zmd = dmz->metadata;
361 sector_t block = dmz_bio_block(bio);
362 unsigned int nr_blocks = dmz_bio_blocks(bio);
363 sector_t chunk_block = dmz_chunk_block(zmd, block);
364 int ret = 0;
365
366 /* For unmapped chunks, there is nothing to do */
367 if (!zone)
368 return 0;
369
370 if (dmz_is_readonly(zone))
371 return -EROFS;
372
373 DMDEBUG("(%s): DISCARD chunk %llu -> zone %u, block %llu, %u blocks",
374 dmz_metadata_label(dmz->metadata),
375 (unsigned long long)dmz_bio_chunk(zmd, bio),
376 zone->id,
377 (unsigned long long)chunk_block, nr_blocks);
378
379 /*
380 * Invalidate blocks in the data zone and its
381 * buffer zone if one is mapped.
382 */
383 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
384 chunk_block < zone->wp_block)
385 ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);
386 if (ret == 0 && zone->bzone)
387 ret = dmz_invalidate_blocks(zmd, zone->bzone,
388 chunk_block, nr_blocks);
389 return ret;
390}
391
392/*
393 * Process a BIO.
394 */
395static void dmz_handle_bio(struct dmz_target *dmz, struct dm_chunk_work *cw,
396 struct bio *bio)
397{
398 struct dmz_bioctx *bioctx =
399 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
400 struct dmz_metadata *zmd = dmz->metadata;
401 struct dm_zone *zone;
402 int ret;
403
404 dmz_lock_metadata(zmd);
405
406 /*
407 * Get the data zone mapping the chunk. There may be no
408 * mapping for read and discard. If a mapping is obtained,
409 + the zone returned will be set to active state.
410 */
411 zone = dmz_get_chunk_mapping(zmd, dmz_bio_chunk(zmd, bio),
412 bio_op(bio));
413 if (IS_ERR(zone)) {
414 ret = PTR_ERR(zone);
415 goto out;
416 }
417
418 /* Process the BIO */
419 if (zone) {
420 dmz_activate_zone(zone);
421 bioctx->zone = zone;
422 dmz_reclaim_bio_acc(zone->dev->reclaim);
423 }
424
425 switch (bio_op(bio)) {
426 case REQ_OP_READ:
427 ret = dmz_handle_read(dmz, zone, bio);
428 break;
429 case REQ_OP_WRITE:
430 ret = dmz_handle_write(dmz, zone, bio);
431 break;
432 case REQ_OP_DISCARD:
433 case REQ_OP_WRITE_ZEROES:
434 ret = dmz_handle_discard(dmz, zone, bio);
435 break;
436 default:
437 DMERR("(%s): Unsupported BIO operation 0x%x",
438 dmz_metadata_label(dmz->metadata), bio_op(bio));
439 ret = -EIO;
440 }
441
442 /*
443 * Release the chunk mapping. This will check that the mapping
444 * is still valid, that is, that the zone used still has valid blocks.
445 */
446 if (zone)
447 dmz_put_chunk_mapping(zmd, zone);
448out:
449 dmz_bio_endio(bio, errno_to_blk_status(ret));
450
451 dmz_unlock_metadata(zmd);
452}
453
454/*
455 * Increment a chunk reference counter.
456 */
457static inline void dmz_get_chunk_work(struct dm_chunk_work *cw)
458{
459 refcount_inc(&cw->refcount);
460}
461
462/*
463 * Decrement a chunk work reference count and
464 * free it if it becomes 0.
465 */
466static void dmz_put_chunk_work(struct dm_chunk_work *cw)
467{
468 if (refcount_dec_and_test(&cw->refcount)) {
469 WARN_ON(!bio_list_empty(&cw->bio_list));
470 radix_tree_delete(&cw->target->chunk_rxtree, cw->chunk);
471 kfree(cw);
472 }
473}
474
475/*
476 * Chunk BIO work function.
477 */
478static void dmz_chunk_work(struct work_struct *work)
479{
480 struct dm_chunk_work *cw = container_of(work, struct dm_chunk_work, work);
481 struct dmz_target *dmz = cw->target;
482 struct bio *bio;
483
484 mutex_lock(&dmz->chunk_lock);
485
486 /* Process the chunk BIOs */
487 while ((bio = bio_list_pop(&cw->bio_list))) {
488 mutex_unlock(&dmz->chunk_lock);
489 dmz_handle_bio(dmz, cw, bio);
490 mutex_lock(&dmz->chunk_lock);
491 dmz_put_chunk_work(cw);
492 }
493
494 /* Queueing the work incremented the work refcount */
495 dmz_put_chunk_work(cw);
496
497 mutex_unlock(&dmz->chunk_lock);
498}
499
500/*
501 * Flush work.
502 */
503static void dmz_flush_work(struct work_struct *work)
504{
505 struct dmz_target *dmz = container_of(work, struct dmz_target, flush_work.work);
506 struct bio *bio;
507 int ret;
508
509 /* Flush dirty metadata blocks */
510 ret = dmz_flush_metadata(dmz->metadata);
511 if (ret)
512 DMDEBUG("(%s): Metadata flush failed, rc=%d",
513 dmz_metadata_label(dmz->metadata), ret);
514
515 /* Process queued flush requests */
516 while (1) {
517 spin_lock(&dmz->flush_lock);
518 bio = bio_list_pop(&dmz->flush_list);
519 spin_unlock(&dmz->flush_lock);
520
521 if (!bio)
522 break;
523
524 dmz_bio_endio(bio, errno_to_blk_status(ret));
525 }
526
527 queue_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
528}
529
530/*
531 * Get a chunk work and start it to process a new BIO.
532 * If the BIO chunk has no work yet, create one.
533 */
534static int dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
535{
536 unsigned int chunk = dmz_bio_chunk(dmz->metadata, bio);
537 struct dm_chunk_work *cw;
538 int ret = 0;
539
540 mutex_lock(&dmz->chunk_lock);
541
542 /* Get the BIO chunk work. If one is not active yet, create one */
543 cw = radix_tree_lookup(&dmz->chunk_rxtree, chunk);
544 if (cw) {
545 dmz_get_chunk_work(cw);
546 } else {
547 /* Create a new chunk work */
548 cw = kmalloc(sizeof(struct dm_chunk_work), GFP_NOIO);
549 if (unlikely(!cw)) {
550 ret = -ENOMEM;
551 goto out;
552 }
553
554 INIT_WORK(&cw->work, dmz_chunk_work);
555 refcount_set(&cw->refcount, 1);
556 cw->target = dmz;
557 cw->chunk = chunk;
558 bio_list_init(&cw->bio_list);
559
560 ret = radix_tree_insert(&dmz->chunk_rxtree, chunk, cw);
561 if (unlikely(ret)) {
562 kfree(cw);
563 goto out;
564 }
565 }
566
567 bio_list_add(&cw->bio_list, bio);
568
569 if (queue_work(dmz->chunk_wq, &cw->work))
570 dmz_get_chunk_work(cw);
571out:
572 mutex_unlock(&dmz->chunk_lock);
573 return ret;
574}
575
576/*
577 * Check if the backing device is being removed. If it's on the way out,
578 * start failing I/O. Reclaim and metadata components also call this
579 * function to cleanly abort operation in the event of such failure.
580 */
581bool dmz_bdev_is_dying(struct dmz_dev *dmz_dev)
582{
583 if (dmz_dev->flags & DMZ_BDEV_DYING)
584 return true;
585
586 if (dmz_dev->flags & DMZ_CHECK_BDEV)
587 return !dmz_check_bdev(dmz_dev);
588
589 if (blk_queue_dying(bdev_get_queue(dmz_dev->bdev))) {
590 dmz_dev_warn(dmz_dev, "Backing device queue dying");
591 dmz_dev->flags |= DMZ_BDEV_DYING;
592 }
593
594 return dmz_dev->flags & DMZ_BDEV_DYING;
595}
596
597/*
598 * Check the backing device availability. This detects such events as
599 * backing device going offline due to errors, media removals, etc.
600 * This check is less efficient than dmz_bdev_is_dying() and should
601 * only be performed as a part of error handling.
602 */
603bool dmz_check_bdev(struct dmz_dev *dmz_dev)
604{
605 struct gendisk *disk;
606
607 dmz_dev->flags &= ~DMZ_CHECK_BDEV;
608
609 if (dmz_bdev_is_dying(dmz_dev))
610 return false;
611
612 disk = dmz_dev->bdev->bd_disk;
613 if (disk->fops->check_events &&
614 disk->fops->check_events(disk, 0) & DISK_EVENT_MEDIA_CHANGE) {
615 dmz_dev_warn(dmz_dev, "Backing device offline");
616 dmz_dev->flags |= DMZ_BDEV_DYING;
617 }
618
619 return !(dmz_dev->flags & DMZ_BDEV_DYING);
620}
621
622/*
623 * Process a new BIO.
624 */
625static int dmz_map(struct dm_target *ti, struct bio *bio)
626{
627 struct dmz_target *dmz = ti->private;
628 struct dmz_metadata *zmd = dmz->metadata;
629 struct dmz_bioctx *bioctx = dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
630 sector_t sector = bio->bi_iter.bi_sector;
631 unsigned int nr_sectors = bio_sectors(bio);
632 sector_t chunk_sector;
633 int ret;
634
635 if (dmz_dev_is_dying(zmd))
636 return DM_MAPIO_KILL;
637
638 DMDEBUG("(%s): BIO op %d sector %llu + %u => chunk %llu, block %llu, %u blocks",
639 dmz_metadata_label(zmd),
640 bio_op(bio), (unsigned long long)sector, nr_sectors,
641 (unsigned long long)dmz_bio_chunk(zmd, bio),
642 (unsigned long long)dmz_chunk_block(zmd, dmz_bio_block(bio)),
643 (unsigned int)dmz_bio_blocks(bio));
644
645 if (!nr_sectors && bio_op(bio) != REQ_OP_WRITE)
646 return DM_MAPIO_REMAPPED;
647
648 /* The BIO should be block aligned */
649 if ((nr_sectors & DMZ_BLOCK_SECTORS_MASK) || (sector & DMZ_BLOCK_SECTORS_MASK))
650 return DM_MAPIO_KILL;
651
652 /* Initialize the BIO context */
653 bioctx->dev = NULL;
654 bioctx->zone = NULL;
655 bioctx->bio = bio;
656 refcount_set(&bioctx->ref, 1);
657
658 /* Set the BIO pending in the flush list */
659 if (!nr_sectors && bio_op(bio) == REQ_OP_WRITE) {
660 spin_lock(&dmz->flush_lock);
661 bio_list_add(&dmz->flush_list, bio);
662 spin_unlock(&dmz->flush_lock);
663 mod_delayed_work(dmz->flush_wq, &dmz->flush_work, 0);
664 return DM_MAPIO_SUBMITTED;
665 }
666
667 /* Split zone BIOs to fit entirely into a zone */
668 chunk_sector = sector & (dmz_zone_nr_sectors(zmd) - 1);
669 if (chunk_sector + nr_sectors > dmz_zone_nr_sectors(zmd))
670 dm_accept_partial_bio(bio, dmz_zone_nr_sectors(zmd) - chunk_sector);
671
672 /* Now ready to handle this BIO */
673 ret = dmz_queue_chunk_work(dmz, bio);
674 if (ret) {
675 DMDEBUG("(%s): BIO op %d, can't process chunk %llu, err %i",
676 dmz_metadata_label(zmd),
677 bio_op(bio), (u64)dmz_bio_chunk(zmd, bio),
678 ret);
679 return DM_MAPIO_REQUEUE;
680 }
681
682 return DM_MAPIO_SUBMITTED;
683}
684
685/*
686 * Get zoned device information.
687 */
688static int dmz_get_zoned_device(struct dm_target *ti, char *path,
689 int idx, int nr_devs)
690{
691 struct dmz_target *dmz = ti->private;
692 struct dm_dev *ddev;
693 struct dmz_dev *dev;
694 int ret;
695 struct block_device *bdev;
696
697 /* Get the target device */
698 ret = dm_get_device(ti, path, dm_table_get_mode(ti->table), &ddev);
699 if (ret) {
700 ti->error = "Get target device failed";
701 return ret;
702 }
703
704 bdev = ddev->bdev;
705 if (bdev_zoned_model(bdev) == BLK_ZONED_NONE) {
706 if (nr_devs == 1) {
707 ti->error = "Invalid regular device";
708 goto err;
709 }
710 if (idx != 0) {
711 ti->error = "First device must be a regular device";
712 goto err;
713 }
714 if (dmz->ddev[0]) {
715 ti->error = "Too many regular devices";
716 goto err;
717 }
718 dev = &dmz->dev[idx];
719 dev->flags = DMZ_BDEV_REGULAR;
720 } else {
721 if (dmz->ddev[idx]) {
722 ti->error = "Too many zoned devices";
723 goto err;
724 }
725 if (nr_devs > 1 && idx == 0) {
726 ti->error = "First device must be a regular device";
727 goto err;
728 }
729 dev = &dmz->dev[idx];
730 }
731 dev->bdev = bdev;
732 dev->dev_idx = idx;
733
734 dev->capacity = bdev_nr_sectors(bdev);
735 if (ti->begin) {
736 ti->error = "Partial mapping is not supported";
737 goto err;
738 }
739
740 dmz->ddev[idx] = ddev;
741
742 return 0;
743err:
744 dm_put_device(ti, ddev);
745 return -EINVAL;
746}
747
748/*
749 * Cleanup zoned device information.
750 */
751static void dmz_put_zoned_device(struct dm_target *ti)
752{
753 struct dmz_target *dmz = ti->private;
754 int i;
755
756 for (i = 0; i < dmz->nr_ddevs; i++) {
757 if (dmz->ddev[i]) {
758 dm_put_device(ti, dmz->ddev[i]);
759 dmz->ddev[i] = NULL;
760 }
761 }
762}
763
764static int dmz_fixup_devices(struct dm_target *ti)
765{
766 struct dmz_target *dmz = ti->private;
767 struct dmz_dev *reg_dev = NULL;
768 sector_t zone_nr_sectors = 0;
769 int i;
770
771 /*
772 * When we have more than on devices, the first one must be a
773 * regular block device and the others zoned block devices.
774 */
775 if (dmz->nr_ddevs > 1) {
776 reg_dev = &dmz->dev[0];
777 if (!(reg_dev->flags & DMZ_BDEV_REGULAR)) {
778 ti->error = "Primary disk is not a regular device";
779 return -EINVAL;
780 }
781 for (i = 1; i < dmz->nr_ddevs; i++) {
782 struct dmz_dev *zoned_dev = &dmz->dev[i];
783 struct block_device *bdev = zoned_dev->bdev;
784
785 if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
786 ti->error = "Secondary disk is not a zoned device";
787 return -EINVAL;
788 }
789 if (zone_nr_sectors &&
790 zone_nr_sectors != bdev_zone_sectors(bdev)) {
791 ti->error = "Zone nr sectors mismatch";
792 return -EINVAL;
793 }
794 zone_nr_sectors = bdev_zone_sectors(bdev);
795 zoned_dev->zone_nr_sectors = zone_nr_sectors;
796 zoned_dev->nr_zones = bdev_nr_zones(bdev);
797 }
798 } else {
799 struct dmz_dev *zoned_dev = &dmz->dev[0];
800 struct block_device *bdev = zoned_dev->bdev;
801
802 if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
803 ti->error = "Disk is not a zoned device";
804 return -EINVAL;
805 }
806 zoned_dev->zone_nr_sectors = bdev_zone_sectors(bdev);
807 zoned_dev->nr_zones = bdev_nr_zones(bdev);
808 }
809
810 if (reg_dev) {
811 sector_t zone_offset;
812
813 reg_dev->zone_nr_sectors = zone_nr_sectors;
814 reg_dev->nr_zones =
815 DIV_ROUND_UP_SECTOR_T(reg_dev->capacity,
816 reg_dev->zone_nr_sectors);
817 reg_dev->zone_offset = 0;
818 zone_offset = reg_dev->nr_zones;
819 for (i = 1; i < dmz->nr_ddevs; i++) {
820 dmz->dev[i].zone_offset = zone_offset;
821 zone_offset += dmz->dev[i].nr_zones;
822 }
823 }
824 return 0;
825}
826
827/*
828 * Setup target.
829 */
830static int dmz_ctr(struct dm_target *ti, unsigned int argc, char **argv)
831{
832 struct dmz_target *dmz;
833 int ret, i;
834
835 /* Check arguments */
836 if (argc < 1) {
837 ti->error = "Invalid argument count";
838 return -EINVAL;
839 }
840
841 /* Allocate and initialize the target descriptor */
842 dmz = kzalloc(sizeof(struct dmz_target), GFP_KERNEL);
843 if (!dmz) {
844 ti->error = "Unable to allocate the zoned target descriptor";
845 return -ENOMEM;
846 }
847 dmz->dev = kcalloc(argc, sizeof(struct dmz_dev), GFP_KERNEL);
848 if (!dmz->dev) {
849 ti->error = "Unable to allocate the zoned device descriptors";
850 kfree(dmz);
851 return -ENOMEM;
852 }
853 dmz->ddev = kcalloc(argc, sizeof(struct dm_dev *), GFP_KERNEL);
854 if (!dmz->ddev) {
855 ti->error = "Unable to allocate the dm device descriptors";
856 ret = -ENOMEM;
857 goto err;
858 }
859 dmz->nr_ddevs = argc;
860
861 ti->private = dmz;
862
863 /* Get the target zoned block device */
864 for (i = 0; i < argc; i++) {
865 ret = dmz_get_zoned_device(ti, argv[i], i, argc);
866 if (ret)
867 goto err_dev;
868 }
869 ret = dmz_fixup_devices(ti);
870 if (ret)
871 goto err_dev;
872
873 /* Initialize metadata */
874 ret = dmz_ctr_metadata(dmz->dev, argc, &dmz->metadata,
875 dm_table_device_name(ti->table));
876 if (ret) {
877 ti->error = "Metadata initialization failed";
878 goto err_dev;
879 }
880
881 /* Set target (no write same support) */
882 ti->max_io_len = dmz_zone_nr_sectors(dmz->metadata);
883 ti->num_flush_bios = 1;
884 ti->num_discard_bios = 1;
885 ti->num_write_zeroes_bios = 1;
886 ti->per_io_data_size = sizeof(struct dmz_bioctx);
887 ti->flush_supported = true;
888 ti->discards_supported = true;
889
890 /* The exposed capacity is the number of chunks that can be mapped */
891 ti->len = (sector_t)dmz_nr_chunks(dmz->metadata) <<
892 dmz_zone_nr_sectors_shift(dmz->metadata);
893
894 /* Zone BIO */
895 ret = bioset_init(&dmz->bio_set, DMZ_MIN_BIOS, 0, 0);
896 if (ret) {
897 ti->error = "Create BIO set failed";
898 goto err_meta;
899 }
900
901 /* Chunk BIO work */
902 mutex_init(&dmz->chunk_lock);
903 INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_NOIO);
904 dmz->chunk_wq = alloc_workqueue("dmz_cwq_%s",
905 WQ_MEM_RECLAIM | WQ_UNBOUND, 0,
906 dmz_metadata_label(dmz->metadata));
907 if (!dmz->chunk_wq) {
908 ti->error = "Create chunk workqueue failed";
909 ret = -ENOMEM;
910 goto err_bio;
911 }
912
913 /* Flush work */
914 spin_lock_init(&dmz->flush_lock);
915 bio_list_init(&dmz->flush_list);
916 INIT_DELAYED_WORK(&dmz->flush_work, dmz_flush_work);
917 dmz->flush_wq = alloc_ordered_workqueue("dmz_fwq_%s", WQ_MEM_RECLAIM,
918 dmz_metadata_label(dmz->metadata));
919 if (!dmz->flush_wq) {
920 ti->error = "Create flush workqueue failed";
921 ret = -ENOMEM;
922 goto err_cwq;
923 }
924 mod_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
925
926 /* Initialize reclaim */
927 for (i = 0; i < dmz->nr_ddevs; i++) {
928 ret = dmz_ctr_reclaim(dmz->metadata, &dmz->dev[i].reclaim, i);
929 if (ret) {
930 ti->error = "Zone reclaim initialization failed";
931 goto err_fwq;
932 }
933 }
934
935 DMINFO("(%s): Target device: %llu 512-byte logical sectors (%llu blocks)",
936 dmz_metadata_label(dmz->metadata),
937 (unsigned long long)ti->len,
938 (unsigned long long)dmz_sect2blk(ti->len));
939
940 return 0;
941err_fwq:
942 destroy_workqueue(dmz->flush_wq);
943err_cwq:
944 destroy_workqueue(dmz->chunk_wq);
945err_bio:
946 mutex_destroy(&dmz->chunk_lock);
947 bioset_exit(&dmz->bio_set);
948err_meta:
949 dmz_dtr_metadata(dmz->metadata);
950err_dev:
951 dmz_put_zoned_device(ti);
952err:
953 kfree(dmz->dev);
954 kfree(dmz);
955
956 return ret;
957}
958
959/*
960 * Cleanup target.
961 */
962static void dmz_dtr(struct dm_target *ti)
963{
964 struct dmz_target *dmz = ti->private;
965 int i;
966
967 destroy_workqueue(dmz->chunk_wq);
968
969 for (i = 0; i < dmz->nr_ddevs; i++)
970 dmz_dtr_reclaim(dmz->dev[i].reclaim);
971
972 cancel_delayed_work_sync(&dmz->flush_work);
973 destroy_workqueue(dmz->flush_wq);
974
975 (void) dmz_flush_metadata(dmz->metadata);
976
977 dmz_dtr_metadata(dmz->metadata);
978
979 bioset_exit(&dmz->bio_set);
980
981 dmz_put_zoned_device(ti);
982
983 mutex_destroy(&dmz->chunk_lock);
984
985 kfree(dmz->dev);
986 kfree(dmz);
987}
988
989/*
990 * Setup target request queue limits.
991 */
992static void dmz_io_hints(struct dm_target *ti, struct queue_limits *limits)
993{
994 struct dmz_target *dmz = ti->private;
995 unsigned int chunk_sectors = dmz_zone_nr_sectors(dmz->metadata);
996
997 limits->logical_block_size = DMZ_BLOCK_SIZE;
998 limits->physical_block_size = DMZ_BLOCK_SIZE;
999
1000 blk_limits_io_min(limits, DMZ_BLOCK_SIZE);
1001 blk_limits_io_opt(limits, DMZ_BLOCK_SIZE);
1002
1003 limits->discard_alignment = 0;
1004 limits->discard_granularity = DMZ_BLOCK_SIZE;
1005 limits->max_discard_sectors = chunk_sectors;
1006 limits->max_hw_discard_sectors = chunk_sectors;
1007 limits->max_write_zeroes_sectors = chunk_sectors;
1008
1009 /* FS hint to try to align to the device zone size */
1010 limits->chunk_sectors = chunk_sectors;
1011 limits->max_sectors = chunk_sectors;
1012
1013 /* We are exposing a drive-managed zoned block device */
1014 limits->zoned = BLK_ZONED_NONE;
1015}
1016
1017/*
1018 * Pass on ioctl to the backend device.
1019 */
1020static int dmz_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
1021{
1022 struct dmz_target *dmz = ti->private;
1023 struct dmz_dev *dev = &dmz->dev[0];
1024
1025 if (!dmz_check_bdev(dev))
1026 return -EIO;
1027
1028 *bdev = dev->bdev;
1029
1030 return 0;
1031}
1032
1033/*
1034 * Stop works on suspend.
1035 */
1036static void dmz_suspend(struct dm_target *ti)
1037{
1038 struct dmz_target *dmz = ti->private;
1039 int i;
1040
1041 flush_workqueue(dmz->chunk_wq);
1042 for (i = 0; i < dmz->nr_ddevs; i++)
1043 dmz_suspend_reclaim(dmz->dev[i].reclaim);
1044 cancel_delayed_work_sync(&dmz->flush_work);
1045}
1046
1047/*
1048 * Restart works on resume or if suspend failed.
1049 */
1050static void dmz_resume(struct dm_target *ti)
1051{
1052 struct dmz_target *dmz = ti->private;
1053 int i;
1054
1055 queue_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
1056 for (i = 0; i < dmz->nr_ddevs; i++)
1057 dmz_resume_reclaim(dmz->dev[i].reclaim);
1058}
1059
1060static int dmz_iterate_devices(struct dm_target *ti,
1061 iterate_devices_callout_fn fn, void *data)
1062{
1063 struct dmz_target *dmz = ti->private;
1064 unsigned int zone_nr_sectors = dmz_zone_nr_sectors(dmz->metadata);
1065 sector_t capacity;
1066 int i, r;
1067
1068 for (i = 0; i < dmz->nr_ddevs; i++) {
1069 capacity = dmz->dev[i].capacity & ~(zone_nr_sectors - 1);
1070 r = fn(ti, dmz->ddev[i], 0, capacity, data);
1071 if (r)
1072 break;
1073 }
1074 return r;
1075}
1076
1077static void dmz_status(struct dm_target *ti, status_type_t type,
1078 unsigned int status_flags, char *result,
1079 unsigned int maxlen)
1080{
1081 struct dmz_target *dmz = ti->private;
1082 ssize_t sz = 0;
1083 char buf[BDEVNAME_SIZE];
1084 struct dmz_dev *dev;
1085 int i;
1086
1087 switch (type) {
1088 case STATUSTYPE_INFO:
1089 DMEMIT("%u zones %u/%u cache",
1090 dmz_nr_zones(dmz->metadata),
1091 dmz_nr_unmap_cache_zones(dmz->metadata),
1092 dmz_nr_cache_zones(dmz->metadata));
1093 for (i = 0; i < dmz->nr_ddevs; i++) {
1094 /*
1095 * For a multi-device setup the first device
1096 * contains only cache zones.
1097 */
1098 if ((i == 0) &&
1099 (dmz_nr_cache_zones(dmz->metadata) > 0))
1100 continue;
1101 DMEMIT(" %u/%u random %u/%u sequential",
1102 dmz_nr_unmap_rnd_zones(dmz->metadata, i),
1103 dmz_nr_rnd_zones(dmz->metadata, i),
1104 dmz_nr_unmap_seq_zones(dmz->metadata, i),
1105 dmz_nr_seq_zones(dmz->metadata, i));
1106 }
1107 break;
1108 case STATUSTYPE_TABLE:
1109 dev = &dmz->dev[0];
1110 format_dev_t(buf, dev->bdev->bd_dev);
1111 DMEMIT("%s", buf);
1112 for (i = 1; i < dmz->nr_ddevs; i++) {
1113 dev = &dmz->dev[i];
1114 format_dev_t(buf, dev->bdev->bd_dev);
1115 DMEMIT(" %s", buf);
1116 }
1117 break;
1118 case STATUSTYPE_IMA:
1119 *result = '\0';
1120 break;
1121 }
1122 return;
1123}
1124
1125static int dmz_message(struct dm_target *ti, unsigned int argc, char **argv,
1126 char *result, unsigned int maxlen)
1127{
1128 struct dmz_target *dmz = ti->private;
1129 int r = -EINVAL;
1130
1131 if (!strcasecmp(argv[0], "reclaim")) {
1132 int i;
1133
1134 for (i = 0; i < dmz->nr_ddevs; i++)
1135 dmz_schedule_reclaim(dmz->dev[i].reclaim);
1136 r = 0;
1137 } else
1138 DMERR("unrecognized message %s", argv[0]);
1139 return r;
1140}
1141
1142static struct target_type dmz_type = {
1143 .name = "zoned",
1144 .version = {2, 0, 0},
1145 .features = DM_TARGET_SINGLETON | DM_TARGET_MIXED_ZONED_MODEL,
1146 .module = THIS_MODULE,
1147 .ctr = dmz_ctr,
1148 .dtr = dmz_dtr,
1149 .map = dmz_map,
1150 .io_hints = dmz_io_hints,
1151 .prepare_ioctl = dmz_prepare_ioctl,
1152 .postsuspend = dmz_suspend,
1153 .resume = dmz_resume,
1154 .iterate_devices = dmz_iterate_devices,
1155 .status = dmz_status,
1156 .message = dmz_message,
1157};
1158
1159static int __init dmz_init(void)
1160{
1161 return dm_register_target(&dmz_type);
1162}
1163
1164static void __exit dmz_exit(void)
1165{
1166 dm_unregister_target(&dmz_type);
1167}
1168
1169module_init(dmz_init);
1170module_exit(dmz_exit);
1171
1172MODULE_DESCRIPTION(DM_NAME " target for zoned block devices");
1173MODULE_AUTHOR("Damien Le Moal <damien.lemoal@wdc.com>");
1174MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2017 Western Digital Corporation or its affiliates.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm-zoned.h"
9
10#include <linux/module.h>
11
12#define DM_MSG_PREFIX "zoned"
13
14#define DMZ_MIN_BIOS 8192
15
16/*
17 * Zone BIO context.
18 */
19struct dmz_bioctx {
20 struct dmz_dev *dev;
21 struct dm_zone *zone;
22 struct bio *bio;
23 refcount_t ref;
24};
25
26/*
27 * Chunk work descriptor.
28 */
29struct dm_chunk_work {
30 struct work_struct work;
31 refcount_t refcount;
32 struct dmz_target *target;
33 unsigned int chunk;
34 struct bio_list bio_list;
35};
36
37/*
38 * Target descriptor.
39 */
40struct dmz_target {
41 struct dm_dev **ddev;
42 unsigned int nr_ddevs;
43
44 unsigned int flags;
45
46 /* Zoned block device information */
47 struct dmz_dev *dev;
48
49 /* For metadata handling */
50 struct dmz_metadata *metadata;
51
52 /* For chunk work */
53 struct radix_tree_root chunk_rxtree;
54 struct workqueue_struct *chunk_wq;
55 struct mutex chunk_lock;
56
57 /* For cloned BIOs to zones */
58 struct bio_set bio_set;
59
60 /* For flush */
61 spinlock_t flush_lock;
62 struct bio_list flush_list;
63 struct delayed_work flush_work;
64 struct workqueue_struct *flush_wq;
65};
66
67/*
68 * Flush intervals (seconds).
69 */
70#define DMZ_FLUSH_PERIOD (10 * HZ)
71
72/*
73 * Target BIO completion.
74 */
75static inline void dmz_bio_endio(struct bio *bio, blk_status_t status)
76{
77 struct dmz_bioctx *bioctx =
78 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
79
80 if (status != BLK_STS_OK && bio->bi_status == BLK_STS_OK)
81 bio->bi_status = status;
82 if (bioctx->dev && bio->bi_status != BLK_STS_OK)
83 bioctx->dev->flags |= DMZ_CHECK_BDEV;
84
85 if (refcount_dec_and_test(&bioctx->ref)) {
86 struct dm_zone *zone = bioctx->zone;
87
88 if (zone) {
89 if (bio->bi_status != BLK_STS_OK &&
90 bio_op(bio) == REQ_OP_WRITE &&
91 dmz_is_seq(zone))
92 set_bit(DMZ_SEQ_WRITE_ERR, &zone->flags);
93 dmz_deactivate_zone(zone);
94 }
95 bio_endio(bio);
96 }
97}
98
99/*
100 * Completion callback for an internally cloned target BIO. This terminates the
101 * target BIO when there are no more references to its context.
102 */
103static void dmz_clone_endio(struct bio *clone)
104{
105 struct dmz_bioctx *bioctx = clone->bi_private;
106 blk_status_t status = clone->bi_status;
107
108 bio_put(clone);
109 dmz_bio_endio(bioctx->bio, status);
110}
111
112/*
113 * Issue a clone of a target BIO. The clone may only partially process the
114 * original target BIO.
115 */
116static int dmz_submit_bio(struct dmz_target *dmz, struct dm_zone *zone,
117 struct bio *bio, sector_t chunk_block,
118 unsigned int nr_blocks)
119{
120 struct dmz_bioctx *bioctx =
121 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
122 struct dmz_dev *dev = zone->dev;
123 struct bio *clone;
124
125 if (dev->flags & DMZ_BDEV_DYING)
126 return -EIO;
127
128 clone = bio_clone_fast(bio, GFP_NOIO, &dmz->bio_set);
129 if (!clone)
130 return -ENOMEM;
131
132 bio_set_dev(clone, dev->bdev);
133 bioctx->dev = dev;
134 clone->bi_iter.bi_sector =
135 dmz_start_sect(dmz->metadata, zone) + dmz_blk2sect(chunk_block);
136 clone->bi_iter.bi_size = dmz_blk2sect(nr_blocks) << SECTOR_SHIFT;
137 clone->bi_end_io = dmz_clone_endio;
138 clone->bi_private = bioctx;
139
140 bio_advance(bio, clone->bi_iter.bi_size);
141
142 refcount_inc(&bioctx->ref);
143 submit_bio_noacct(clone);
144
145 if (bio_op(bio) == REQ_OP_WRITE && dmz_is_seq(zone))
146 zone->wp_block += nr_blocks;
147
148 return 0;
149}
150
151/*
152 * Zero out pages of discarded blocks accessed by a read BIO.
153 */
154static void dmz_handle_read_zero(struct dmz_target *dmz, struct bio *bio,
155 sector_t chunk_block, unsigned int nr_blocks)
156{
157 unsigned int size = nr_blocks << DMZ_BLOCK_SHIFT;
158
159 /* Clear nr_blocks */
160 swap(bio->bi_iter.bi_size, size);
161 zero_fill_bio(bio);
162 swap(bio->bi_iter.bi_size, size);
163
164 bio_advance(bio, size);
165}
166
167/*
168 * Process a read BIO.
169 */
170static int dmz_handle_read(struct dmz_target *dmz, struct dm_zone *zone,
171 struct bio *bio)
172{
173 struct dmz_metadata *zmd = dmz->metadata;
174 sector_t chunk_block = dmz_chunk_block(zmd, dmz_bio_block(bio));
175 unsigned int nr_blocks = dmz_bio_blocks(bio);
176 sector_t end_block = chunk_block + nr_blocks;
177 struct dm_zone *rzone, *bzone;
178 int ret;
179
180 /* Read into unmapped chunks need only zeroing the BIO buffer */
181 if (!zone) {
182 zero_fill_bio(bio);
183 return 0;
184 }
185
186 DMDEBUG("(%s): READ chunk %llu -> %s zone %u, block %llu, %u blocks",
187 dmz_metadata_label(zmd),
188 (unsigned long long)dmz_bio_chunk(zmd, bio),
189 (dmz_is_rnd(zone) ? "RND" :
190 (dmz_is_cache(zone) ? "CACHE" : "SEQ")),
191 zone->id,
192 (unsigned long long)chunk_block, nr_blocks);
193
194 /* Check block validity to determine the read location */
195 bzone = zone->bzone;
196 while (chunk_block < end_block) {
197 nr_blocks = 0;
198 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
199 chunk_block < zone->wp_block) {
200 /* Test block validity in the data zone */
201 ret = dmz_block_valid(zmd, zone, chunk_block);
202 if (ret < 0)
203 return ret;
204 if (ret > 0) {
205 /* Read data zone blocks */
206 nr_blocks = ret;
207 rzone = zone;
208 }
209 }
210
211 /*
212 * No valid blocks found in the data zone.
213 * Check the buffer zone, if there is one.
214 */
215 if (!nr_blocks && bzone) {
216 ret = dmz_block_valid(zmd, bzone, chunk_block);
217 if (ret < 0)
218 return ret;
219 if (ret > 0) {
220 /* Read buffer zone blocks */
221 nr_blocks = ret;
222 rzone = bzone;
223 }
224 }
225
226 if (nr_blocks) {
227 /* Valid blocks found: read them */
228 nr_blocks = min_t(unsigned int, nr_blocks,
229 end_block - chunk_block);
230 ret = dmz_submit_bio(dmz, rzone, bio,
231 chunk_block, nr_blocks);
232 if (ret)
233 return ret;
234 chunk_block += nr_blocks;
235 } else {
236 /* No valid block: zeroout the current BIO block */
237 dmz_handle_read_zero(dmz, bio, chunk_block, 1);
238 chunk_block++;
239 }
240 }
241
242 return 0;
243}
244
245/*
246 * Write blocks directly in a data zone, at the write pointer.
247 * If a buffer zone is assigned, invalidate the blocks written
248 * in place.
249 */
250static int dmz_handle_direct_write(struct dmz_target *dmz,
251 struct dm_zone *zone, struct bio *bio,
252 sector_t chunk_block,
253 unsigned int nr_blocks)
254{
255 struct dmz_metadata *zmd = dmz->metadata;
256 struct dm_zone *bzone = zone->bzone;
257 int ret;
258
259 if (dmz_is_readonly(zone))
260 return -EROFS;
261
262 /* Submit write */
263 ret = dmz_submit_bio(dmz, zone, bio, chunk_block, nr_blocks);
264 if (ret)
265 return ret;
266
267 /*
268 * Validate the blocks in the data zone and invalidate
269 * in the buffer zone, if there is one.
270 */
271 ret = dmz_validate_blocks(zmd, zone, chunk_block, nr_blocks);
272 if (ret == 0 && bzone)
273 ret = dmz_invalidate_blocks(zmd, bzone, chunk_block, nr_blocks);
274
275 return ret;
276}
277
278/*
279 * Write blocks in the buffer zone of @zone.
280 * If no buffer zone is assigned yet, get one.
281 * Called with @zone write locked.
282 */
283static int dmz_handle_buffered_write(struct dmz_target *dmz,
284 struct dm_zone *zone, struct bio *bio,
285 sector_t chunk_block,
286 unsigned int nr_blocks)
287{
288 struct dmz_metadata *zmd = dmz->metadata;
289 struct dm_zone *bzone;
290 int ret;
291
292 /* Get the buffer zone. One will be allocated if needed */
293 bzone = dmz_get_chunk_buffer(zmd, zone);
294 if (IS_ERR(bzone))
295 return PTR_ERR(bzone);
296
297 if (dmz_is_readonly(bzone))
298 return -EROFS;
299
300 /* Submit write */
301 ret = dmz_submit_bio(dmz, bzone, bio, chunk_block, nr_blocks);
302 if (ret)
303 return ret;
304
305 /*
306 * Validate the blocks in the buffer zone
307 * and invalidate in the data zone.
308 */
309 ret = dmz_validate_blocks(zmd, bzone, chunk_block, nr_blocks);
310 if (ret == 0 && chunk_block < zone->wp_block)
311 ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);
312
313 return ret;
314}
315
316/*
317 * Process a write BIO.
318 */
319static int dmz_handle_write(struct dmz_target *dmz, struct dm_zone *zone,
320 struct bio *bio)
321{
322 struct dmz_metadata *zmd = dmz->metadata;
323 sector_t chunk_block = dmz_chunk_block(zmd, dmz_bio_block(bio));
324 unsigned int nr_blocks = dmz_bio_blocks(bio);
325
326 if (!zone)
327 return -ENOSPC;
328
329 DMDEBUG("(%s): WRITE chunk %llu -> %s zone %u, block %llu, %u blocks",
330 dmz_metadata_label(zmd),
331 (unsigned long long)dmz_bio_chunk(zmd, bio),
332 (dmz_is_rnd(zone) ? "RND" :
333 (dmz_is_cache(zone) ? "CACHE" : "SEQ")),
334 zone->id,
335 (unsigned long long)chunk_block, nr_blocks);
336
337 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
338 chunk_block == zone->wp_block) {
339 /*
340 * zone is a random zone or it is a sequential zone
341 * and the BIO is aligned to the zone write pointer:
342 * direct write the zone.
343 */
344 return dmz_handle_direct_write(dmz, zone, bio,
345 chunk_block, nr_blocks);
346 }
347
348 /*
349 * This is an unaligned write in a sequential zone:
350 * use buffered write.
351 */
352 return dmz_handle_buffered_write(dmz, zone, bio, chunk_block, nr_blocks);
353}
354
355/*
356 * Process a discard BIO.
357 */
358static int dmz_handle_discard(struct dmz_target *dmz, struct dm_zone *zone,
359 struct bio *bio)
360{
361 struct dmz_metadata *zmd = dmz->metadata;
362 sector_t block = dmz_bio_block(bio);
363 unsigned int nr_blocks = dmz_bio_blocks(bio);
364 sector_t chunk_block = dmz_chunk_block(zmd, block);
365 int ret = 0;
366
367 /* For unmapped chunks, there is nothing to do */
368 if (!zone)
369 return 0;
370
371 if (dmz_is_readonly(zone))
372 return -EROFS;
373
374 DMDEBUG("(%s): DISCARD chunk %llu -> zone %u, block %llu, %u blocks",
375 dmz_metadata_label(dmz->metadata),
376 (unsigned long long)dmz_bio_chunk(zmd, bio),
377 zone->id,
378 (unsigned long long)chunk_block, nr_blocks);
379
380 /*
381 * Invalidate blocks in the data zone and its
382 * buffer zone if one is mapped.
383 */
384 if (dmz_is_rnd(zone) || dmz_is_cache(zone) ||
385 chunk_block < zone->wp_block)
386 ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);
387 if (ret == 0 && zone->bzone)
388 ret = dmz_invalidate_blocks(zmd, zone->bzone,
389 chunk_block, nr_blocks);
390 return ret;
391}
392
393/*
394 * Process a BIO.
395 */
396static void dmz_handle_bio(struct dmz_target *dmz, struct dm_chunk_work *cw,
397 struct bio *bio)
398{
399 struct dmz_bioctx *bioctx =
400 dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
401 struct dmz_metadata *zmd = dmz->metadata;
402 struct dm_zone *zone;
403 int ret;
404
405 dmz_lock_metadata(zmd);
406
407 /*
408 * Get the data zone mapping the chunk. There may be no
409 * mapping for read and discard. If a mapping is obtained,
410 + the zone returned will be set to active state.
411 */
412 zone = dmz_get_chunk_mapping(zmd, dmz_bio_chunk(zmd, bio),
413 bio_op(bio));
414 if (IS_ERR(zone)) {
415 ret = PTR_ERR(zone);
416 goto out;
417 }
418
419 /* Process the BIO */
420 if (zone) {
421 dmz_activate_zone(zone);
422 bioctx->zone = zone;
423 dmz_reclaim_bio_acc(zone->dev->reclaim);
424 }
425
426 switch (bio_op(bio)) {
427 case REQ_OP_READ:
428 ret = dmz_handle_read(dmz, zone, bio);
429 break;
430 case REQ_OP_WRITE:
431 ret = dmz_handle_write(dmz, zone, bio);
432 break;
433 case REQ_OP_DISCARD:
434 case REQ_OP_WRITE_ZEROES:
435 ret = dmz_handle_discard(dmz, zone, bio);
436 break;
437 default:
438 DMERR("(%s): Unsupported BIO operation 0x%x",
439 dmz_metadata_label(dmz->metadata), bio_op(bio));
440 ret = -EIO;
441 }
442
443 /*
444 * Release the chunk mapping. This will check that the mapping
445 * is still valid, that is, that the zone used still has valid blocks.
446 */
447 if (zone)
448 dmz_put_chunk_mapping(zmd, zone);
449out:
450 dmz_bio_endio(bio, errno_to_blk_status(ret));
451
452 dmz_unlock_metadata(zmd);
453}
454
455/*
456 * Increment a chunk reference counter.
457 */
458static inline void dmz_get_chunk_work(struct dm_chunk_work *cw)
459{
460 refcount_inc(&cw->refcount);
461}
462
463/*
464 * Decrement a chunk work reference count and
465 * free it if it becomes 0.
466 */
467static void dmz_put_chunk_work(struct dm_chunk_work *cw)
468{
469 if (refcount_dec_and_test(&cw->refcount)) {
470 WARN_ON(!bio_list_empty(&cw->bio_list));
471 radix_tree_delete(&cw->target->chunk_rxtree, cw->chunk);
472 kfree(cw);
473 }
474}
475
476/*
477 * Chunk BIO work function.
478 */
479static void dmz_chunk_work(struct work_struct *work)
480{
481 struct dm_chunk_work *cw = container_of(work, struct dm_chunk_work, work);
482 struct dmz_target *dmz = cw->target;
483 struct bio *bio;
484
485 mutex_lock(&dmz->chunk_lock);
486
487 /* Process the chunk BIOs */
488 while ((bio = bio_list_pop(&cw->bio_list))) {
489 mutex_unlock(&dmz->chunk_lock);
490 dmz_handle_bio(dmz, cw, bio);
491 mutex_lock(&dmz->chunk_lock);
492 dmz_put_chunk_work(cw);
493 }
494
495 /* Queueing the work incremented the work refcount */
496 dmz_put_chunk_work(cw);
497
498 mutex_unlock(&dmz->chunk_lock);
499}
500
501/*
502 * Flush work.
503 */
504static void dmz_flush_work(struct work_struct *work)
505{
506 struct dmz_target *dmz = container_of(work, struct dmz_target, flush_work.work);
507 struct bio *bio;
508 int ret;
509
510 /* Flush dirty metadata blocks */
511 ret = dmz_flush_metadata(dmz->metadata);
512 if (ret)
513 DMDEBUG("(%s): Metadata flush failed, rc=%d",
514 dmz_metadata_label(dmz->metadata), ret);
515
516 /* Process queued flush requests */
517 while (1) {
518 spin_lock(&dmz->flush_lock);
519 bio = bio_list_pop(&dmz->flush_list);
520 spin_unlock(&dmz->flush_lock);
521
522 if (!bio)
523 break;
524
525 dmz_bio_endio(bio, errno_to_blk_status(ret));
526 }
527
528 queue_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
529}
530
531/*
532 * Get a chunk work and start it to process a new BIO.
533 * If the BIO chunk has no work yet, create one.
534 */
535static int dmz_queue_chunk_work(struct dmz_target *dmz, struct bio *bio)
536{
537 unsigned int chunk = dmz_bio_chunk(dmz->metadata, bio);
538 struct dm_chunk_work *cw;
539 int ret = 0;
540
541 mutex_lock(&dmz->chunk_lock);
542
543 /* Get the BIO chunk work. If one is not active yet, create one */
544 cw = radix_tree_lookup(&dmz->chunk_rxtree, chunk);
545 if (cw) {
546 dmz_get_chunk_work(cw);
547 } else {
548 /* Create a new chunk work */
549 cw = kmalloc(sizeof(struct dm_chunk_work), GFP_NOIO);
550 if (unlikely(!cw)) {
551 ret = -ENOMEM;
552 goto out;
553 }
554
555 INIT_WORK(&cw->work, dmz_chunk_work);
556 refcount_set(&cw->refcount, 1);
557 cw->target = dmz;
558 cw->chunk = chunk;
559 bio_list_init(&cw->bio_list);
560
561 ret = radix_tree_insert(&dmz->chunk_rxtree, chunk, cw);
562 if (unlikely(ret)) {
563 kfree(cw);
564 goto out;
565 }
566 }
567
568 bio_list_add(&cw->bio_list, bio);
569
570 if (queue_work(dmz->chunk_wq, &cw->work))
571 dmz_get_chunk_work(cw);
572out:
573 mutex_unlock(&dmz->chunk_lock);
574 return ret;
575}
576
577/*
578 * Check if the backing device is being removed. If it's on the way out,
579 * start failing I/O. Reclaim and metadata components also call this
580 * function to cleanly abort operation in the event of such failure.
581 */
582bool dmz_bdev_is_dying(struct dmz_dev *dmz_dev)
583{
584 if (dmz_dev->flags & DMZ_BDEV_DYING)
585 return true;
586
587 if (dmz_dev->flags & DMZ_CHECK_BDEV)
588 return !dmz_check_bdev(dmz_dev);
589
590 if (blk_queue_dying(bdev_get_queue(dmz_dev->bdev))) {
591 dmz_dev_warn(dmz_dev, "Backing device queue dying");
592 dmz_dev->flags |= DMZ_BDEV_DYING;
593 }
594
595 return dmz_dev->flags & DMZ_BDEV_DYING;
596}
597
598/*
599 * Check the backing device availability. This detects such events as
600 * backing device going offline due to errors, media removals, etc.
601 * This check is less efficient than dmz_bdev_is_dying() and should
602 * only be performed as a part of error handling.
603 */
604bool dmz_check_bdev(struct dmz_dev *dmz_dev)
605{
606 struct gendisk *disk;
607
608 dmz_dev->flags &= ~DMZ_CHECK_BDEV;
609
610 if (dmz_bdev_is_dying(dmz_dev))
611 return false;
612
613 disk = dmz_dev->bdev->bd_disk;
614 if (disk->fops->check_events &&
615 disk->fops->check_events(disk, 0) & DISK_EVENT_MEDIA_CHANGE) {
616 dmz_dev_warn(dmz_dev, "Backing device offline");
617 dmz_dev->flags |= DMZ_BDEV_DYING;
618 }
619
620 return !(dmz_dev->flags & DMZ_BDEV_DYING);
621}
622
623/*
624 * Process a new BIO.
625 */
626static int dmz_map(struct dm_target *ti, struct bio *bio)
627{
628 struct dmz_target *dmz = ti->private;
629 struct dmz_metadata *zmd = dmz->metadata;
630 struct dmz_bioctx *bioctx = dm_per_bio_data(bio, sizeof(struct dmz_bioctx));
631 sector_t sector = bio->bi_iter.bi_sector;
632 unsigned int nr_sectors = bio_sectors(bio);
633 sector_t chunk_sector;
634 int ret;
635
636 if (dmz_dev_is_dying(zmd))
637 return DM_MAPIO_KILL;
638
639 DMDEBUG("(%s): BIO op %d sector %llu + %u => chunk %llu, block %llu, %u blocks",
640 dmz_metadata_label(zmd),
641 bio_op(bio), (unsigned long long)sector, nr_sectors,
642 (unsigned long long)dmz_bio_chunk(zmd, bio),
643 (unsigned long long)dmz_chunk_block(zmd, dmz_bio_block(bio)),
644 (unsigned int)dmz_bio_blocks(bio));
645
646 if (!nr_sectors && bio_op(bio) != REQ_OP_WRITE)
647 return DM_MAPIO_REMAPPED;
648
649 /* The BIO should be block aligned */
650 if ((nr_sectors & DMZ_BLOCK_SECTORS_MASK) || (sector & DMZ_BLOCK_SECTORS_MASK))
651 return DM_MAPIO_KILL;
652
653 /* Initialize the BIO context */
654 bioctx->dev = NULL;
655 bioctx->zone = NULL;
656 bioctx->bio = bio;
657 refcount_set(&bioctx->ref, 1);
658
659 /* Set the BIO pending in the flush list */
660 if (!nr_sectors && bio_op(bio) == REQ_OP_WRITE) {
661 spin_lock(&dmz->flush_lock);
662 bio_list_add(&dmz->flush_list, bio);
663 spin_unlock(&dmz->flush_lock);
664 mod_delayed_work(dmz->flush_wq, &dmz->flush_work, 0);
665 return DM_MAPIO_SUBMITTED;
666 }
667
668 /* Split zone BIOs to fit entirely into a zone */
669 chunk_sector = sector & (dmz_zone_nr_sectors(zmd) - 1);
670 if (chunk_sector + nr_sectors > dmz_zone_nr_sectors(zmd))
671 dm_accept_partial_bio(bio, dmz_zone_nr_sectors(zmd) - chunk_sector);
672
673 /* Now ready to handle this BIO */
674 ret = dmz_queue_chunk_work(dmz, bio);
675 if (ret) {
676 DMDEBUG("(%s): BIO op %d, can't process chunk %llu, err %i",
677 dmz_metadata_label(zmd),
678 bio_op(bio), (u64)dmz_bio_chunk(zmd, bio),
679 ret);
680 return DM_MAPIO_REQUEUE;
681 }
682
683 return DM_MAPIO_SUBMITTED;
684}
685
686/*
687 * Get zoned device information.
688 */
689static int dmz_get_zoned_device(struct dm_target *ti, char *path,
690 int idx, int nr_devs)
691{
692 struct dmz_target *dmz = ti->private;
693 struct dm_dev *ddev;
694 struct dmz_dev *dev;
695 int ret;
696 struct block_device *bdev;
697
698 /* Get the target device */
699 ret = dm_get_device(ti, path, dm_table_get_mode(ti->table), &ddev);
700 if (ret) {
701 ti->error = "Get target device failed";
702 return ret;
703 }
704
705 bdev = ddev->bdev;
706 if (bdev_zoned_model(bdev) == BLK_ZONED_NONE) {
707 if (nr_devs == 1) {
708 ti->error = "Invalid regular device";
709 goto err;
710 }
711 if (idx != 0) {
712 ti->error = "First device must be a regular device";
713 goto err;
714 }
715 if (dmz->ddev[0]) {
716 ti->error = "Too many regular devices";
717 goto err;
718 }
719 dev = &dmz->dev[idx];
720 dev->flags = DMZ_BDEV_REGULAR;
721 } else {
722 if (dmz->ddev[idx]) {
723 ti->error = "Too many zoned devices";
724 goto err;
725 }
726 if (nr_devs > 1 && idx == 0) {
727 ti->error = "First device must be a regular device";
728 goto err;
729 }
730 dev = &dmz->dev[idx];
731 }
732 dev->bdev = bdev;
733 dev->dev_idx = idx;
734 (void)bdevname(dev->bdev, dev->name);
735
736 dev->capacity = i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
737 if (ti->begin) {
738 ti->error = "Partial mapping is not supported";
739 goto err;
740 }
741
742 dmz->ddev[idx] = ddev;
743
744 return 0;
745err:
746 dm_put_device(ti, ddev);
747 return -EINVAL;
748}
749
750/*
751 * Cleanup zoned device information.
752 */
753static void dmz_put_zoned_device(struct dm_target *ti)
754{
755 struct dmz_target *dmz = ti->private;
756 int i;
757
758 for (i = 0; i < dmz->nr_ddevs; i++) {
759 if (dmz->ddev[i]) {
760 dm_put_device(ti, dmz->ddev[i]);
761 dmz->ddev[i] = NULL;
762 }
763 }
764}
765
766static int dmz_fixup_devices(struct dm_target *ti)
767{
768 struct dmz_target *dmz = ti->private;
769 struct dmz_dev *reg_dev, *zoned_dev;
770 struct request_queue *q;
771 sector_t zone_nr_sectors = 0;
772 int i;
773
774 /*
775 * When we have more than on devices, the first one must be a
776 * regular block device and the others zoned block devices.
777 */
778 if (dmz->nr_ddevs > 1) {
779 reg_dev = &dmz->dev[0];
780 if (!(reg_dev->flags & DMZ_BDEV_REGULAR)) {
781 ti->error = "Primary disk is not a regular device";
782 return -EINVAL;
783 }
784 for (i = 1; i < dmz->nr_ddevs; i++) {
785 zoned_dev = &dmz->dev[i];
786 if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
787 ti->error = "Secondary disk is not a zoned device";
788 return -EINVAL;
789 }
790 q = bdev_get_queue(zoned_dev->bdev);
791 if (zone_nr_sectors &&
792 zone_nr_sectors != blk_queue_zone_sectors(q)) {
793 ti->error = "Zone nr sectors mismatch";
794 return -EINVAL;
795 }
796 zone_nr_sectors = blk_queue_zone_sectors(q);
797 zoned_dev->zone_nr_sectors = zone_nr_sectors;
798 zoned_dev->nr_zones =
799 blkdev_nr_zones(zoned_dev->bdev->bd_disk);
800 }
801 } else {
802 reg_dev = NULL;
803 zoned_dev = &dmz->dev[0];
804 if (zoned_dev->flags & DMZ_BDEV_REGULAR) {
805 ti->error = "Disk is not a zoned device";
806 return -EINVAL;
807 }
808 q = bdev_get_queue(zoned_dev->bdev);
809 zoned_dev->zone_nr_sectors = blk_queue_zone_sectors(q);
810 zoned_dev->nr_zones = blkdev_nr_zones(zoned_dev->bdev->bd_disk);
811 }
812
813 if (reg_dev) {
814 sector_t zone_offset;
815
816 reg_dev->zone_nr_sectors = zone_nr_sectors;
817 reg_dev->nr_zones =
818 DIV_ROUND_UP_SECTOR_T(reg_dev->capacity,
819 reg_dev->zone_nr_sectors);
820 reg_dev->zone_offset = 0;
821 zone_offset = reg_dev->nr_zones;
822 for (i = 1; i < dmz->nr_ddevs; i++) {
823 dmz->dev[i].zone_offset = zone_offset;
824 zone_offset += dmz->dev[i].nr_zones;
825 }
826 }
827 return 0;
828}
829
830/*
831 * Setup target.
832 */
833static int dmz_ctr(struct dm_target *ti, unsigned int argc, char **argv)
834{
835 struct dmz_target *dmz;
836 int ret, i;
837
838 /* Check arguments */
839 if (argc < 1) {
840 ti->error = "Invalid argument count";
841 return -EINVAL;
842 }
843
844 /* Allocate and initialize the target descriptor */
845 dmz = kzalloc(sizeof(struct dmz_target), GFP_KERNEL);
846 if (!dmz) {
847 ti->error = "Unable to allocate the zoned target descriptor";
848 return -ENOMEM;
849 }
850 dmz->dev = kcalloc(argc, sizeof(struct dmz_dev), GFP_KERNEL);
851 if (!dmz->dev) {
852 ti->error = "Unable to allocate the zoned device descriptors";
853 kfree(dmz);
854 return -ENOMEM;
855 }
856 dmz->ddev = kcalloc(argc, sizeof(struct dm_dev *), GFP_KERNEL);
857 if (!dmz->ddev) {
858 ti->error = "Unable to allocate the dm device descriptors";
859 ret = -ENOMEM;
860 goto err;
861 }
862 dmz->nr_ddevs = argc;
863
864 ti->private = dmz;
865
866 /* Get the target zoned block device */
867 for (i = 0; i < argc; i++) {
868 ret = dmz_get_zoned_device(ti, argv[i], i, argc);
869 if (ret)
870 goto err_dev;
871 }
872 ret = dmz_fixup_devices(ti);
873 if (ret)
874 goto err_dev;
875
876 /* Initialize metadata */
877 ret = dmz_ctr_metadata(dmz->dev, argc, &dmz->metadata,
878 dm_table_device_name(ti->table));
879 if (ret) {
880 ti->error = "Metadata initialization failed";
881 goto err_dev;
882 }
883
884 /* Set target (no write same support) */
885 ti->max_io_len = dmz_zone_nr_sectors(dmz->metadata);
886 ti->num_flush_bios = 1;
887 ti->num_discard_bios = 1;
888 ti->num_write_zeroes_bios = 1;
889 ti->per_io_data_size = sizeof(struct dmz_bioctx);
890 ti->flush_supported = true;
891 ti->discards_supported = true;
892
893 /* The exposed capacity is the number of chunks that can be mapped */
894 ti->len = (sector_t)dmz_nr_chunks(dmz->metadata) <<
895 dmz_zone_nr_sectors_shift(dmz->metadata);
896
897 /* Zone BIO */
898 ret = bioset_init(&dmz->bio_set, DMZ_MIN_BIOS, 0, 0);
899 if (ret) {
900 ti->error = "Create BIO set failed";
901 goto err_meta;
902 }
903
904 /* Chunk BIO work */
905 mutex_init(&dmz->chunk_lock);
906 INIT_RADIX_TREE(&dmz->chunk_rxtree, GFP_NOIO);
907 dmz->chunk_wq = alloc_workqueue("dmz_cwq_%s",
908 WQ_MEM_RECLAIM | WQ_UNBOUND, 0,
909 dmz_metadata_label(dmz->metadata));
910 if (!dmz->chunk_wq) {
911 ti->error = "Create chunk workqueue failed";
912 ret = -ENOMEM;
913 goto err_bio;
914 }
915
916 /* Flush work */
917 spin_lock_init(&dmz->flush_lock);
918 bio_list_init(&dmz->flush_list);
919 INIT_DELAYED_WORK(&dmz->flush_work, dmz_flush_work);
920 dmz->flush_wq = alloc_ordered_workqueue("dmz_fwq_%s", WQ_MEM_RECLAIM,
921 dmz_metadata_label(dmz->metadata));
922 if (!dmz->flush_wq) {
923 ti->error = "Create flush workqueue failed";
924 ret = -ENOMEM;
925 goto err_cwq;
926 }
927 mod_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
928
929 /* Initialize reclaim */
930 for (i = 0; i < dmz->nr_ddevs; i++) {
931 ret = dmz_ctr_reclaim(dmz->metadata, &dmz->dev[i].reclaim, i);
932 if (ret) {
933 ti->error = "Zone reclaim initialization failed";
934 goto err_fwq;
935 }
936 }
937
938 DMINFO("(%s): Target device: %llu 512-byte logical sectors (%llu blocks)",
939 dmz_metadata_label(dmz->metadata),
940 (unsigned long long)ti->len,
941 (unsigned long long)dmz_sect2blk(ti->len));
942
943 return 0;
944err_fwq:
945 destroy_workqueue(dmz->flush_wq);
946err_cwq:
947 destroy_workqueue(dmz->chunk_wq);
948err_bio:
949 mutex_destroy(&dmz->chunk_lock);
950 bioset_exit(&dmz->bio_set);
951err_meta:
952 dmz_dtr_metadata(dmz->metadata);
953err_dev:
954 dmz_put_zoned_device(ti);
955err:
956 kfree(dmz->dev);
957 kfree(dmz);
958
959 return ret;
960}
961
962/*
963 * Cleanup target.
964 */
965static void dmz_dtr(struct dm_target *ti)
966{
967 struct dmz_target *dmz = ti->private;
968 int i;
969
970 flush_workqueue(dmz->chunk_wq);
971 destroy_workqueue(dmz->chunk_wq);
972
973 for (i = 0; i < dmz->nr_ddevs; i++)
974 dmz_dtr_reclaim(dmz->dev[i].reclaim);
975
976 cancel_delayed_work_sync(&dmz->flush_work);
977 destroy_workqueue(dmz->flush_wq);
978
979 (void) dmz_flush_metadata(dmz->metadata);
980
981 dmz_dtr_metadata(dmz->metadata);
982
983 bioset_exit(&dmz->bio_set);
984
985 dmz_put_zoned_device(ti);
986
987 mutex_destroy(&dmz->chunk_lock);
988
989 kfree(dmz->dev);
990 kfree(dmz);
991}
992
993/*
994 * Setup target request queue limits.
995 */
996static void dmz_io_hints(struct dm_target *ti, struct queue_limits *limits)
997{
998 struct dmz_target *dmz = ti->private;
999 unsigned int chunk_sectors = dmz_zone_nr_sectors(dmz->metadata);
1000
1001 limits->logical_block_size = DMZ_BLOCK_SIZE;
1002 limits->physical_block_size = DMZ_BLOCK_SIZE;
1003
1004 blk_limits_io_min(limits, DMZ_BLOCK_SIZE);
1005 blk_limits_io_opt(limits, DMZ_BLOCK_SIZE);
1006
1007 limits->discard_alignment = DMZ_BLOCK_SIZE;
1008 limits->discard_granularity = DMZ_BLOCK_SIZE;
1009 limits->max_discard_sectors = chunk_sectors;
1010 limits->max_hw_discard_sectors = chunk_sectors;
1011 limits->max_write_zeroes_sectors = chunk_sectors;
1012
1013 /* FS hint to try to align to the device zone size */
1014 limits->chunk_sectors = chunk_sectors;
1015 limits->max_sectors = chunk_sectors;
1016
1017 /* We are exposing a drive-managed zoned block device */
1018 limits->zoned = BLK_ZONED_NONE;
1019}
1020
1021/*
1022 * Pass on ioctl to the backend device.
1023 */
1024static int dmz_prepare_ioctl(struct dm_target *ti, struct block_device **bdev)
1025{
1026 struct dmz_target *dmz = ti->private;
1027 struct dmz_dev *dev = &dmz->dev[0];
1028
1029 if (!dmz_check_bdev(dev))
1030 return -EIO;
1031
1032 *bdev = dev->bdev;
1033
1034 return 0;
1035}
1036
1037/*
1038 * Stop works on suspend.
1039 */
1040static void dmz_suspend(struct dm_target *ti)
1041{
1042 struct dmz_target *dmz = ti->private;
1043 int i;
1044
1045 flush_workqueue(dmz->chunk_wq);
1046 for (i = 0; i < dmz->nr_ddevs; i++)
1047 dmz_suspend_reclaim(dmz->dev[i].reclaim);
1048 cancel_delayed_work_sync(&dmz->flush_work);
1049}
1050
1051/*
1052 * Restart works on resume or if suspend failed.
1053 */
1054static void dmz_resume(struct dm_target *ti)
1055{
1056 struct dmz_target *dmz = ti->private;
1057 int i;
1058
1059 queue_delayed_work(dmz->flush_wq, &dmz->flush_work, DMZ_FLUSH_PERIOD);
1060 for (i = 0; i < dmz->nr_ddevs; i++)
1061 dmz_resume_reclaim(dmz->dev[i].reclaim);
1062}
1063
1064static int dmz_iterate_devices(struct dm_target *ti,
1065 iterate_devices_callout_fn fn, void *data)
1066{
1067 struct dmz_target *dmz = ti->private;
1068 unsigned int zone_nr_sectors = dmz_zone_nr_sectors(dmz->metadata);
1069 sector_t capacity;
1070 int i, r;
1071
1072 for (i = 0; i < dmz->nr_ddevs; i++) {
1073 capacity = dmz->dev[i].capacity & ~(zone_nr_sectors - 1);
1074 r = fn(ti, dmz->ddev[i], 0, capacity, data);
1075 if (r)
1076 break;
1077 }
1078 return r;
1079}
1080
1081static void dmz_status(struct dm_target *ti, status_type_t type,
1082 unsigned int status_flags, char *result,
1083 unsigned int maxlen)
1084{
1085 struct dmz_target *dmz = ti->private;
1086 ssize_t sz = 0;
1087 char buf[BDEVNAME_SIZE];
1088 struct dmz_dev *dev;
1089 int i;
1090
1091 switch (type) {
1092 case STATUSTYPE_INFO:
1093 DMEMIT("%u zones %u/%u cache",
1094 dmz_nr_zones(dmz->metadata),
1095 dmz_nr_unmap_cache_zones(dmz->metadata),
1096 dmz_nr_cache_zones(dmz->metadata));
1097 for (i = 0; i < dmz->nr_ddevs; i++) {
1098 /*
1099 * For a multi-device setup the first device
1100 * contains only cache zones.
1101 */
1102 if ((i == 0) &&
1103 (dmz_nr_cache_zones(dmz->metadata) > 0))
1104 continue;
1105 DMEMIT(" %u/%u random %u/%u sequential",
1106 dmz_nr_unmap_rnd_zones(dmz->metadata, i),
1107 dmz_nr_rnd_zones(dmz->metadata, i),
1108 dmz_nr_unmap_seq_zones(dmz->metadata, i),
1109 dmz_nr_seq_zones(dmz->metadata, i));
1110 }
1111 break;
1112 case STATUSTYPE_TABLE:
1113 dev = &dmz->dev[0];
1114 format_dev_t(buf, dev->bdev->bd_dev);
1115 DMEMIT("%s", buf);
1116 for (i = 1; i < dmz->nr_ddevs; i++) {
1117 dev = &dmz->dev[i];
1118 format_dev_t(buf, dev->bdev->bd_dev);
1119 DMEMIT(" %s", buf);
1120 }
1121 break;
1122 }
1123 return;
1124}
1125
1126static int dmz_message(struct dm_target *ti, unsigned int argc, char **argv,
1127 char *result, unsigned int maxlen)
1128{
1129 struct dmz_target *dmz = ti->private;
1130 int r = -EINVAL;
1131
1132 if (!strcasecmp(argv[0], "reclaim")) {
1133 int i;
1134
1135 for (i = 0; i < dmz->nr_ddevs; i++)
1136 dmz_schedule_reclaim(dmz->dev[i].reclaim);
1137 r = 0;
1138 } else
1139 DMERR("unrecognized message %s", argv[0]);
1140 return r;
1141}
1142
1143static struct target_type dmz_type = {
1144 .name = "zoned",
1145 .version = {2, 0, 0},
1146 .features = DM_TARGET_SINGLETON | DM_TARGET_ZONED_HM,
1147 .module = THIS_MODULE,
1148 .ctr = dmz_ctr,
1149 .dtr = dmz_dtr,
1150 .map = dmz_map,
1151 .io_hints = dmz_io_hints,
1152 .prepare_ioctl = dmz_prepare_ioctl,
1153 .postsuspend = dmz_suspend,
1154 .resume = dmz_resume,
1155 .iterate_devices = dmz_iterate_devices,
1156 .status = dmz_status,
1157 .message = dmz_message,
1158};
1159
1160static int __init dmz_init(void)
1161{
1162 return dm_register_target(&dmz_type);
1163}
1164
1165static void __exit dmz_exit(void)
1166{
1167 dm_unregister_target(&dmz_type);
1168}
1169
1170module_init(dmz_init);
1171module_exit(dmz_exit);
1172
1173MODULE_DESCRIPTION(DM_NAME " target for zoned block devices");
1174MODULE_AUTHOR("Damien Le Moal <damien.lemoal@wdc.com>");
1175MODULE_LICENSE("GPL");