linux - drivers/md/dm.c

3852 lines · 90.7 KiB

1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
4	* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
5	*
6	* This file is released under the GPL.
7	*/
8
9	#include "dm-core.h"
10	#include "dm-rq.h"
11	#include "dm-uevent.h"
12	#include "dm-ima.h"
13
14	#include <linux/bio-integrity.h>
15	#include <linux/init.h>
16	#include <linux/module.h>
17	#include <linux/mutex.h>
18	#include <linux/sched/mm.h>
19	#include <linux/sched/signal.h>
20	#include <linux/blkpg.h>
21	#include <linux/bio.h>
22	#include <linux/mempool.h>
23	#include <linux/dax.h>
24	#include <linux/slab.h>
25	#include <linux/idr.h>
26	#include <linux/uio.h>
27	#include <linux/hdreg.h>
28	#include <linux/delay.h>
29	#include <linux/wait.h>
30	#include <linux/pr.h>
31	#include <linux/refcount.h>
32	#include <linux/part_stat.h>
33	#include <linux/blk-crypto.h>
34	#include <linux/blk-crypto-profile.h>
35
36	#define DM_MSG_PREFIX "core"
37
38	/*
39	* Cookies are numeric values sent with CHANGE and REMOVE
40	* uevents while resuming, removing or renaming the device.
41	*/
42	#define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
43	#define DM_COOKIE_LENGTH 24
44
45	/*
46	* For REQ_POLLED fs bio, this flag is set if we link mapped underlying
47	* dm_io into one list, and reuse bio->bi_private as the list head. Before
48	* ending this fs bio, we will recover its ->bi_private.
49	*/
50	#define REQ_DM_POLL_LIST REQ_DRV
51
52	static const char *_name = DM_NAME;
53
54	static unsigned int major;
55	static unsigned int _major;
56
57	static DEFINE_IDR(_minor_idr);
58
59	static DEFINE_SPINLOCK(_minor_lock);
60
61	static void do_deferred_remove(struct work_struct *w);
62
63	static DECLARE_WORK(deferred_remove_work, do_deferred_remove);
64
65	static struct workqueue_struct *deferred_remove_workqueue;
66
67	atomic_t dm_global_event_nr = ATOMIC_INIT(0);
68	DECLARE_WAIT_QUEUE_HEAD(dm_global_eventq);
69
70	void dm_issue_global_event(void)
71	{
72	atomic_inc(&dm_global_event_nr);
73	wake_up(&dm_global_eventq);
74	}
75
76	DEFINE_STATIC_KEY_FALSE(stats_enabled);
77	DEFINE_STATIC_KEY_FALSE(swap_bios_enabled);
78	DEFINE_STATIC_KEY_FALSE(zoned_enabled);
79
80	/*
81	* One of these is allocated (on-stack) per original bio.
82	*/
83	struct clone_info {
84	struct dm_table *map;
85	struct bio *bio;
86	struct dm_io *io;
87	sector_t sector;
88	unsigned int sector_count;
89	bool is_abnormal_io:1;
90	bool submit_as_polled:1;
91	};
92
93	static inline struct dm_target_io clone_to_tio(struct bio clone)
94	{
95	return container_of(clone, struct dm_target_io, clone);
96	}
97
98	void dm_per_bio_data(struct bio bio, size_t data_size)
99	{
100	if (!dm_tio_flagged(clone_to_tio(bio), DM_TIO_INSIDE_DM_IO))
101	return (char *)bio - DM_TARGET_IO_BIO_OFFSET - data_size;
102	return (char *)bio - DM_IO_BIO_OFFSET - data_size;
103	}
104	EXPORT_SYMBOL_GPL(dm_per_bio_data);
105
106	struct bio dm_bio_from_per_bio_data(void data, size_t data_size)
107	{
108	struct dm_io io = (struct dm_io )((char *)data + data_size);
109
110	if (io->magic == DM_IO_MAGIC)
111	return (struct bio )((char )io + DM_IO_BIO_OFFSET);
112	BUG_ON(io->magic != DM_TIO_MAGIC);
113	return (struct bio )((char )io + DM_TARGET_IO_BIO_OFFSET);
114	}
115	EXPORT_SYMBOL_GPL(dm_bio_from_per_bio_data);
116
117	unsigned int dm_bio_get_target_bio_nr(const struct bio *bio)
118	{
119	return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
120	}
121	EXPORT_SYMBOL_GPL(dm_bio_get_target_bio_nr);
122
123	#define MINOR_ALLOCED ((void *)-1)
124
125	#define DM_NUMA_NODE NUMA_NO_NODE
126	static int dm_numa_node = DM_NUMA_NODE;
127
128	#define DEFAULT_SWAP_BIOS (8 * 1048576 / PAGE_SIZE)
129	static int swap_bios = DEFAULT_SWAP_BIOS;
130	static int get_swap_bios(void)
131	{
132	int latch = READ_ONCE(swap_bios);
133
134	if (unlikely(latch <= 0))
135	latch = DEFAULT_SWAP_BIOS;
136	return latch;
137	}
138
139	struct table_device {
140	struct list_head list;
141	refcount_t count;
142	struct dm_dev dm_dev;
143	};
144
145	/*
146	* Bio-based DM's mempools' reserved IOs set by the user.
147	*/
148	#define RESERVED_BIO_BASED_IOS 16
149	static unsigned int reserved_bio_based_ios = RESERVED_BIO_BASED_IOS;
150
151	static int __dm_get_module_param_int(int *module_param, int min, int max)
152	{
153	int param = READ_ONCE(*module_param);
154	int modified_param = 0;
155	bool modified = true;
156
157	if (param < min)
158	modified_param = min;
159	else if (param > max)
160	modified_param = max;
161	else
162	modified = false;
163
164	if (modified) {
165	(void)cmpxchg(module_param, param, modified_param);
166	param = modified_param;
167	}
168
169	return param;
170	}
171
172	unsigned int __dm_get_module_param(unsigned int *module_param, unsigned int def, unsigned int max)
173	{
174	unsigned int param = READ_ONCE(*module_param);
175	unsigned int modified_param = 0;
176
177	if (!param)
178	modified_param = def;
179	else if (param > max)
180	modified_param = max;
181
182	if (modified_param) {
183	(void)cmpxchg(module_param, param, modified_param);
184	param = modified_param;
185	}
186
187	return param;
188	}
189
190	unsigned int dm_get_reserved_bio_based_ios(void)
191	{
192	return __dm_get_module_param(&reserved_bio_based_ios,
193	RESERVED_BIO_BASED_IOS, DM_RESERVED_MAX_IOS);
194	}
195	EXPORT_SYMBOL_GPL(dm_get_reserved_bio_based_ios);
196
197	static unsigned int dm_get_numa_node(void)
198	{
199	return __dm_get_module_param_int(&dm_numa_node,
200	DM_NUMA_NODE, num_online_nodes() - 1);
201	}
202
203	static int __init local_init(void)
204	{
205	int r;
206
207	r = dm_uevent_init();
208	if (r)
209	return r;
210
211	deferred_remove_workqueue = alloc_ordered_workqueue("kdmremove", 0);
212	if (!deferred_remove_workqueue) {
213	r = -ENOMEM;
214	goto out_uevent_exit;
215	}
216
217	_major = major;
218	r = register_blkdev(_major, _name);
219	if (r < 0)
220	goto out_free_workqueue;
221
222	if (!_major)
223	_major = r;
224
225	return 0;
226
227	out_free_workqueue:
228	destroy_workqueue(deferred_remove_workqueue);
229	out_uevent_exit:
230	dm_uevent_exit();
231
232	return r;
233	}
234
235	static void local_exit(void)
236	{
237	destroy_workqueue(deferred_remove_workqueue);
238
239	unregister_blkdev(_major, _name);
240	dm_uevent_exit();
241
242	_major = 0;
243
244	DMINFO("cleaned up");
245	}
246
247	static int (*_inits[])(void) __initdata = {
248	local_init,
249	dm_target_init,
250	dm_linear_init,
251	dm_stripe_init,
252	dm_io_init,
253	dm_kcopyd_init,
254	dm_interface_init,
255	dm_statistics_init,
256	};
257
258	static void (*_exits[])(void) = {
259	local_exit,
260	dm_target_exit,
261	dm_linear_exit,
262	dm_stripe_exit,
263	dm_io_exit,
264	dm_kcopyd_exit,
265	dm_interface_exit,
266	dm_statistics_exit,
267	};
268
269	static int __init dm_init(void)
270	{
271	const int count = ARRAY_SIZE(_inits);
272	int r, i;
273
274	#if (IS_ENABLED(CONFIG_IMA) && !IS_ENABLED(CONFIG_IMA_DISABLE_HTABLE))
275	DMINFO("CONFIG_IMA_DISABLE_HTABLE is disabled."
276	" Duplicate IMA measurements will not be recorded in the IMA log.");
277	#endif
278
279	for (i = 0; i < count; i++) {
280	r = _inits[i]();
281	if (r)
282	goto bad;
283	}
284
285	return 0;
286	bad:
287	while (i--)
288	_exits[i]();
289
290	return r;
291	}
292
293	static void __exit dm_exit(void)
294	{
295	int i = ARRAY_SIZE(_exits);
296
297	while (i--)
298	_exits[i]();
299
300	/*
301	* Should be empty by this point.
302	*/
303	idr_destroy(&_minor_idr);
304	}
305
306	/*
307	* Block device functions
308	*/
309	int dm_deleting_md(struct mapped_device *md)
310	{
311	return test_bit(DMF_DELETING, &md->flags);
312	}
313
314	static int dm_blk_open(struct gendisk *disk, blk_mode_t mode)
315	{
316	struct mapped_device *md;
317
318	spin_lock(&_minor_lock);
319
320	md = disk->private_data;
321	if (!md)
322	goto out;
323
324	if (test_bit(DMF_FREEING, &md->flags) \|\|
325	dm_deleting_md(md)) {
326	md = NULL;
327	goto out;
328	}
329
330	dm_get(md);
331	atomic_inc(&md->open_count);
332	out:
333	spin_unlock(&_minor_lock);
334
335	return md ? 0 : -ENXIO;
336	}
337
338	static void dm_blk_close(struct gendisk *disk)
339	{
340	struct mapped_device *md;
341
342	spin_lock(&_minor_lock);
343
344	md = disk->private_data;
345	if (WARN_ON(!md))
346	goto out;
347
348	if (atomic_dec_and_test(&md->open_count) &&
349	(test_bit(DMF_DEFERRED_REMOVE, &md->flags)))
350	queue_work(deferred_remove_workqueue, &deferred_remove_work);
351
352	dm_put(md);
353	out:
354	spin_unlock(&_minor_lock);
355	}
356
357	int dm_open_count(struct mapped_device *md)
358	{
359	return atomic_read(&md->open_count);
360	}
361
362	/*
363	* Guarantees nothing is using the device before it's deleted.
364	*/
365	int dm_lock_for_deletion(struct mapped_device *md, bool mark_deferred, bool only_deferred)
366	{
367	int r = 0;
368
369	spin_lock(&_minor_lock);
370
371	if (dm_open_count(md)) {
372	r = -EBUSY;
373	if (mark_deferred)
374	set_bit(DMF_DEFERRED_REMOVE, &md->flags);
375	} else if (only_deferred && !test_bit(DMF_DEFERRED_REMOVE, &md->flags))
376	r = -EEXIST;
377	else
378	set_bit(DMF_DELETING, &md->flags);
379
380	spin_unlock(&_minor_lock);
381
382	return r;
383	}
384
385	int dm_cancel_deferred_remove(struct mapped_device *md)
386	{
387	int r = 0;
388
389	spin_lock(&_minor_lock);
390
391	if (test_bit(DMF_DELETING, &md->flags))
392	r = -EBUSY;
393	else
394	clear_bit(DMF_DEFERRED_REMOVE, &md->flags);
395
396	spin_unlock(&_minor_lock);
397
398	return r;
399	}
400
401	static void do_deferred_remove(struct work_struct *w)
402	{
403	dm_deferred_remove();
404	}
405
406	static int dm_blk_getgeo(struct gendisk disk, struct hd_geometry geo)
407	{
408	struct mapped_device *md = disk->private_data;
409
410	return dm_get_geometry(md, geo);
411	}
412
413	static int dm_prepare_ioctl(struct mapped_device md, int srcu_idx,
414	struct block_device **bdev, unsigned int cmd,
415	unsigned long arg, bool *forward)
416	{
417	struct dm_target *ti;
418	struct dm_table *map;
419	int r;
420
421	retry:
422	r = -ENOTTY;
423	map = dm_get_live_table(md, srcu_idx);
424	if (!map \|\| !dm_table_get_size(map))
425	return r;
426
427	/* We only support devices that have a single target */
428	if (map->num_targets != 1)
429	return r;
430
431	ti = dm_table_get_target(map, 0);
432	if (!ti->type->prepare_ioctl)
433	return r;
434
435	if (dm_suspended_md(md))
436	return -EAGAIN;
437
438	r = ti->type->prepare_ioctl(ti, bdev, cmd, arg, forward);
439	if (r == -ENOTCONN && *forward && !fatal_signal_pending(current)) {
440	dm_put_live_table(md, *srcu_idx);
441	fsleep(10000);
442	goto retry;
443	}
444
445	return r;
446	}
447
448	static void dm_unprepare_ioctl(struct mapped_device *md, int srcu_idx)
449	{
450	dm_put_live_table(md, srcu_idx);
451	}
452
453	static int dm_blk_ioctl(struct block_device *bdev, blk_mode_t mode,
454	unsigned int cmd, unsigned long arg)
455	{
456	struct mapped_device *md = bdev->bd_disk->private_data;
457	int r, srcu_idx;
458	bool forward = true;
459
460	r = dm_prepare_ioctl(md, &srcu_idx, &bdev, cmd, arg, &forward);
461	if (!forward \|\| r < 0)
462	goto out;
463
464	if (r > 0) {
465	/*
466	* Target determined this ioctl is being issued against a
467	* subset of the parent bdev; require extra privileges.
468	*/
469	if (!capable(CAP_SYS_RAWIO)) {
470	DMDEBUG_LIMIT(
471	"%s: sending ioctl %x to DM device without required privilege.",
472	current->comm, cmd);
473	r = -ENOIOCTLCMD;
474	goto out;
475	}
476	}
477
478	if (!bdev->bd_disk->fops->ioctl)
479	r = -ENOTTY;
480	else
481	r = bdev->bd_disk->fops->ioctl(bdev, mode, cmd, arg);
482	out:
483	dm_unprepare_ioctl(md, srcu_idx);
484	return r;
485	}
486
487	u64 dm_start_time_ns_from_clone(struct bio *bio)
488	{
489	return jiffies_to_nsecs(clone_to_tio(bio)->io->start_time);
490	}
491	EXPORT_SYMBOL_GPL(dm_start_time_ns_from_clone);
492
493	static inline unsigned int dm_io_sectors(struct dm_io io, struct bio bio)
494	{
495	/*
496	* If REQ_PREFLUSH set, don't account payload, it will be
497	* submitted (and accounted) after this flush completes.
498	*/
499	if (io->requeue_flush_with_data)
500	return 0;
501	if (unlikely(dm_io_flagged(io, DM_IO_WAS_SPLIT)))
502	return io->sectors;
503	return bio_sectors(bio);
504	}
505
506	static void dm_io_acct(struct dm_io *io, bool end)
507	{
508	struct bio *bio = io->orig_bio;
509
510	if (dm_io_flagged(io, DM_IO_BLK_STAT)) {
511	if (!end)
512	bdev_start_io_acct(bio->bi_bdev, bio_op(bio),
513	io->start_time);
514	else
515	bdev_end_io_acct(bio->bi_bdev, bio_op(bio),
516	dm_io_sectors(io, bio),
517	io->start_time);
518	}
519
520	if (static_branch_unlikely(&stats_enabled) &&
521	unlikely(dm_stats_used(&io->md->stats))) {
522	sector_t sector;
523
524	if (unlikely(dm_io_flagged(io, DM_IO_WAS_SPLIT)))
525	sector = bio_end_sector(bio) - io->sector_offset;
526	else
527	sector = bio->bi_iter.bi_sector;
528
529	dm_stats_account_io(&io->md->stats, bio_data_dir(bio),
530	sector, dm_io_sectors(io, bio),
531	end, io->start_time, &io->stats_aux);
532	}
533	}
534
535	static void __dm_start_io_acct(struct dm_io *io)
536	{
537	dm_io_acct(io, false);
538	}
539
540	static void dm_start_io_acct(struct dm_io io, struct bio clone)
541	{
542	/*
543	* Ensure IO accounting is only ever started once.
544	*/
545	if (dm_io_flagged(io, DM_IO_ACCOUNTED))
546	return;
547
548	/* Expect no possibility for race unless DM_TIO_IS_DUPLICATE_BIO. */
549	if (!clone \|\| likely(dm_tio_is_normal(clone_to_tio(clone)))) {
550	dm_io_set_flag(io, DM_IO_ACCOUNTED);
551	} else {
552	unsigned long flags;
553	/* Can afford locking given DM_TIO_IS_DUPLICATE_BIO */
554	spin_lock_irqsave(&io->lock, flags);
555	if (dm_io_flagged(io, DM_IO_ACCOUNTED)) {
556	spin_unlock_irqrestore(&io->lock, flags);
557	return;
558	}
559	dm_io_set_flag(io, DM_IO_ACCOUNTED);
560	spin_unlock_irqrestore(&io->lock, flags);
561	}
562
563	__dm_start_io_acct(io);
564	}
565
566	static void dm_end_io_acct(struct dm_io *io)
567	{
568	dm_io_acct(io, true);
569	}
570
571	static struct dm_io alloc_io(struct mapped_device md, struct bio *bio, gfp_t gfp_mask)
572	{
573	struct dm_io *io;
574	struct dm_target_io *tio;
575	struct bio *clone;
576
577	clone = bio_alloc_clone(NULL, bio, gfp_mask, &md->mempools->io_bs);
578	if (unlikely(!clone))
579	return NULL;
580	tio = clone_to_tio(clone);
581	tio->flags = 0;
582	dm_tio_set_flag(tio, DM_TIO_INSIDE_DM_IO);
583	tio->io = NULL;
584
585	io = container_of(tio, struct dm_io, tio);
586	io->magic = DM_IO_MAGIC;
587	io->status = BLK_STS_OK;
588	io->requeue_flush_with_data = false;
589
590	/* one ref is for submission, the other is for completion */
591	atomic_set(&io->io_count, 2);
592	this_cpu_inc(*md->pending_io);
593	io->orig_bio = bio;
594	io->md = md;
595	spin_lock_init(&io->lock);
596	io->start_time = jiffies;
597	io->flags = 0;
598	if (blk_queue_io_stat(md->queue))
599	dm_io_set_flag(io, DM_IO_BLK_STAT);
600
601	if (static_branch_unlikely(&stats_enabled) &&
602	unlikely(dm_stats_used(&md->stats)))
603	dm_stats_record_start(&md->stats, &io->stats_aux);
604
605	return io;
606	}
607
608	static void free_io(struct dm_io *io)
609	{
610	bio_put(&io->tio.clone);
611	}
612
613	static struct bio alloc_tio(struct clone_info ci, struct dm_target *ti,
614	unsigned int target_bio_nr, unsigned int *len, gfp_t gfp_mask)
615	{
616	struct mapped_device *md = ci->io->md;
617	struct dm_target_io *tio;
618	struct bio *clone;
619
620	if (!ci->io->tio.io) {
621	/* the dm_target_io embedded in ci->io is available */
622	tio = &ci->io->tio;
623	/* alloc_io() already initialized embedded clone */
624	clone = &tio->clone;
625	} else {
626	clone = bio_alloc_clone(NULL, ci->bio, gfp_mask,
627	&md->mempools->bs);
628	if (!clone)
629	return NULL;
630
631	/* REQ_DM_POLL_LIST shouldn't be inherited */
632	clone->bi_opf &= ~REQ_DM_POLL_LIST;
633
634	tio = clone_to_tio(clone);
635	tio->flags = 0; /* also clears DM_TIO_INSIDE_DM_IO */
636	}
637
638	tio->magic = DM_TIO_MAGIC;
639	tio->io = ci->io;
640	tio->ti = ti;
641	tio->target_bio_nr = target_bio_nr;
642	tio->len_ptr = len;
643	tio->old_sector = 0;
644
645	/* Set default bdev, but target must bio_set_dev() before issuing IO */
646	clone->bi_bdev = md->disk->part0;
647	if (likely(ti != NULL) && unlikely(ti->needs_bio_set_dev))
648	bio_set_dev(clone, md->disk->part0);
649
650	if (len) {
651	clone->bi_iter.bi_size = to_bytes(*len);
652	if (bio_integrity(clone))
653	bio_integrity_trim(clone);
654	}
655
656	return clone;
657	}
658
659	static void free_tio(struct bio *clone)
660	{
661	if (dm_tio_flagged(clone_to_tio(clone), DM_TIO_INSIDE_DM_IO))
662	return;
663	bio_put(clone);
664	}
665
666	/*
667	* Add the bio to the list of deferred io.
668	*/
669	static void queue_io(struct mapped_device md, struct bio bio)
670	{
671	unsigned long flags;
672
673	spin_lock_irqsave(&md->deferred_lock, flags);
674	bio_list_add(&md->deferred, bio);
675	spin_unlock_irqrestore(&md->deferred_lock, flags);
676	queue_work(md->wq, &md->work);
677	}
678
679	/*
680	* Everyone (including functions in this file), should use this
681	* function to access the md->map field, and make sure they call
682	* dm_put_live_table() when finished.
683	*/
684	struct dm_table dm_get_live_table(struct mapped_device md,
685	int *srcu_idx) __acquires(md->io_barrier)
686	{
687	*srcu_idx = srcu_read_lock(&md->io_barrier);
688
689	return srcu_dereference(md->map, &md->io_barrier);
690	}
691
692	void dm_put_live_table(struct mapped_device *md,
693	int srcu_idx) __releases(md->io_barrier)
694	{
695	srcu_read_unlock(&md->io_barrier, srcu_idx);
696	}
697
698	void dm_sync_table(struct mapped_device *md)
699	{
700	synchronize_srcu(&md->io_barrier);
701	synchronize_rcu_expedited();
702	}
703
704	/*
705	* A fast alternative to dm_get_live_table/dm_put_live_table.
706	* The caller must not block between these two functions.
707	*/
708	static struct dm_table dm_get_live_table_fast(struct mapped_device md) __acquires(RCU)
709	{
710	rcu_read_lock();
711	return rcu_dereference(md->map);
712	}
713
714	static void dm_put_live_table_fast(struct mapped_device *md) __releases(RCU)
715	{
716	rcu_read_unlock();
717	}
718
719	static char *_dm_claim_ptr = "I belong to device-mapper";
720
721	/*
722	* Open a table device so we can use it as a map destination.
723	*/
724	static struct table_device open_table_device(struct mapped_device md,
725	dev_t dev, blk_mode_t mode)
726	{
727	struct table_device *td;
728	struct file *bdev_file;
729	struct block_device *bdev;
730	u64 part_off;
731	int r;
732
733	td = kmalloc_node(sizeof(*td), GFP_KERNEL, md->numa_node_id);
734	if (!td)
735	return ERR_PTR(-ENOMEM);
736	refcount_set(&td->count, 1);
737
738	/*
739	* Open the backing device with kernel rather than caller
740	* credentials. Otherwise the caller's credentials would be
741	* pinned in bdev_file->f_cred until the table device is closed.
742	* That would keep the caller's thread keyring alive long beyond the
743	* lifetime of the caller, breaking userspace expectation (e.g.
744	* cryptsetup(8) leaking the LUKS volume key).
745	*/
746	scoped_with_kernel_creds()
747	bdev_file = bdev_file_open_by_dev(dev, mode, _dm_claim_ptr, NULL);
748	if (IS_ERR(bdev_file)) {
749	r = PTR_ERR(bdev_file);
750	goto out_free_td;
751	}
752
753	bdev = file_bdev(bdev_file);
754
755	/*
756	* We can be called before the dm disk is added. In that case we can't
757	* register the holder relation here. It will be done once add_disk was
758	* called.
759	*/
760	if (md->disk->slave_dir) {
761	r = bd_link_disk_holder(bdev, md->disk);
762	if (r)
763	goto out_blkdev_put;
764	}
765
766	td->dm_dev.mode = mode;
767	td->dm_dev.bdev = bdev;
768	td->dm_dev.bdev_file = bdev_file;
769	td->dm_dev.dax_dev = fs_dax_get_by_bdev(bdev, &part_off,
770	NULL, NULL);
771	format_dev_t(td->dm_dev.name, dev);
772	list_add(&td->list, &md->table_devices);
773	return td;
774
775	out_blkdev_put:
776	__fput_sync(bdev_file);
777	out_free_td:
778	kfree(td);
779	return ERR_PTR(r);
780	}
781
782	/*
783	* Close a table device that we've been using.
784	*/
785	static void close_table_device(struct table_device td, struct mapped_device md)
786	{
787	if (md->disk->slave_dir)
788	bd_unlink_disk_holder(td->dm_dev.bdev, md->disk);
789
790	/* Leverage async fput() if DMF_DEFERRED_REMOVE set */
791	if (unlikely(test_bit(DMF_DEFERRED_REMOVE, &md->flags)))
792	fput(td->dm_dev.bdev_file);
793	else
794	__fput_sync(td->dm_dev.bdev_file);
795
796	put_dax(td->dm_dev.dax_dev);
797	list_del(&td->list);
798	kfree(td);
799	}
800
801	static struct table_device find_table_device(struct list_head l, dev_t dev,
802	blk_mode_t mode)
803	{
804	struct table_device *td;
805
806	list_for_each_entry(td, l, list)
807	if (td->dm_dev.bdev->bd_dev == dev && td->dm_dev.mode == mode)
808	return td;
809
810	return NULL;
811	}
812
813	int dm_get_table_device(struct mapped_device *md, dev_t dev, blk_mode_t mode,
814	struct dm_dev **result)
815	{
816	struct table_device *td;
817
818	mutex_lock(&md->table_devices_lock);
819	td = find_table_device(&md->table_devices, dev, mode);
820	if (!td) {
821	td = open_table_device(md, dev, mode);
822	if (IS_ERR(td)) {
823	mutex_unlock(&md->table_devices_lock);
824	return PTR_ERR(td);
825	}
826	} else {
827	refcount_inc(&td->count);
828	}
829	mutex_unlock(&md->table_devices_lock);
830
831	*result = &td->dm_dev;
832	return 0;
833	}
834
835	void dm_put_table_device(struct mapped_device md, struct dm_dev d)
836	{
837	struct table_device *td = container_of(d, struct table_device, dm_dev);
838
839	mutex_lock(&md->table_devices_lock);
840	if (refcount_dec_and_test(&td->count))
841	close_table_device(td, md);
842	mutex_unlock(&md->table_devices_lock);
843	}
844
845	/*
846	* Get the geometry associated with a dm device
847	*/
848	int dm_get_geometry(struct mapped_device md, struct hd_geometry geo)
849	{
850	*geo = md->geometry;
851
852	return 0;
853	}
854
855	/*
856	* Set the geometry of a device.
857	*/
858	int dm_set_geometry(struct mapped_device md, struct hd_geometry geo)
859	{
860	sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
861
862	if (geo->start > sz) {
863	DMERR("Start sector is beyond the geometry limits.");
864	return -EINVAL;
865	}
866
867	md->geometry = *geo;
868
869	return 0;
870	}
871
872	static int __noflush_suspending(struct mapped_device *md)
873	{
874	return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
875	}
876
877	static void dm_requeue_add_io(struct dm_io *io, bool first_stage)
878	{
879	struct mapped_device *md = io->md;
880
881	if (first_stage) {
882	struct dm_io *next = md->requeue_list;
883
884	md->requeue_list = io;
885	io->next = next;
886	} else {
887	bio_list_add_head(&md->deferred, io->orig_bio);
888	}
889	}
890
891	static void dm_kick_requeue(struct mapped_device *md, bool first_stage)
892	{
893	if (first_stage)
894	queue_work(md->wq, &md->requeue_work);
895	else
896	queue_work(md->wq, &md->work);
897	}
898
899	/*
900	* Return true if the dm_io's original bio is requeued.
901	* io->status is updated with error if requeue disallowed.
902	*/
903	static bool dm_handle_requeue(struct dm_io *io, bool first_stage)
904	{
905	struct bio *bio = io->orig_bio;
906	bool handle_requeue = (io->status == BLK_STS_DM_REQUEUE);
907	bool handle_polled_eagain = ((io->status == BLK_STS_AGAIN) &&
908	(bio->bi_opf & REQ_POLLED));
909	struct mapped_device *md = io->md;
910	bool requeued = false;
911
912	if (handle_requeue \|\| handle_polled_eagain) {
913	unsigned long flags;
914
915	if (bio->bi_opf & REQ_POLLED) {
916	/*
917	* Upper layer won't help us poll split bio
918	* (io->orig_bio may only reflect a subset of the
919	* pre-split original) so clear REQ_POLLED.
920	*/
921	bio_clear_polled(bio);
922	}
923
924	/*
925	* Target requested pushing back the I/O or
926	* polled IO hit BLK_STS_AGAIN.
927	*/
928	spin_lock_irqsave(&md->deferred_lock, flags);
929	if ((__noflush_suspending(md) &&
930	!WARN_ON_ONCE(dm_is_zone_write(md, bio))) \|\|
931	handle_polled_eagain \|\| first_stage) {
932	dm_requeue_add_io(io, first_stage);
933	requeued = true;
934	} else {
935	/*
936	* noflush suspend was interrupted or this is
937	* a write to a zoned target.
938	*/
939	io->status = BLK_STS_IOERR;
940	}
941	spin_unlock_irqrestore(&md->deferred_lock, flags);
942	}
943
944	if (requeued)
945	dm_kick_requeue(md, first_stage);
946
947	return requeued;
948	}
949
950	static void __dm_io_complete(struct dm_io *io, bool first_stage)
951	{
952	struct bio *bio = io->orig_bio;
953	struct mapped_device *md = io->md;
954	blk_status_t io_error;
955	bool requeued;
956	bool requeue_flush_with_data;
957
958	requeued = dm_handle_requeue(io, first_stage);
959	if (requeued && first_stage)
960	return;
961
962	io_error = io->status;
963	if (dm_io_flagged(io, DM_IO_ACCOUNTED))
964	dm_end_io_acct(io);
965	else if (!io_error) {
966	/*
967	* Must handle target that DM_MAPIO_SUBMITTED only to
968	* then bio_endio() rather than dm_submit_bio_remap()
969	*/
970	__dm_start_io_acct(io);
971	dm_end_io_acct(io);
972	}
973	requeue_flush_with_data = io->requeue_flush_with_data;
974	free_io(io);
975	smp_wmb();
976	this_cpu_dec(*md->pending_io);
977
978	/* nudge anyone waiting on suspend queue */
979	if (unlikely(wq_has_sleeper(&md->wait)))
980	wake_up(&md->wait);
981
982	/* Return early if the original bio was requeued */
983	if (requeued)
984	return;
985
986	if (unlikely(requeue_flush_with_data)) {
987	/*
988	* Preflush done for flush with data, reissue
989	* without REQ_PREFLUSH.
990	*/
991	bio->bi_opf &= ~REQ_PREFLUSH;
992	queue_io(md, bio);
993	} else {
994	/* done with normal IO or empty flush */
995	if (io_error)
996	bio->bi_status = io_error;
997	bio_endio(bio);
998	}
999	}
1000
1001	static void dm_wq_requeue_work(struct work_struct *work)
1002	{
1003	struct mapped_device *md = container_of(work, struct mapped_device,
1004	requeue_work);
1005	unsigned long flags;
1006	struct dm_io *io;
1007
1008	/* reuse deferred lock to simplify dm_handle_requeue */
1009	spin_lock_irqsave(&md->deferred_lock, flags);
1010	io = md->requeue_list;
1011	md->requeue_list = NULL;
1012	spin_unlock_irqrestore(&md->deferred_lock, flags);
1013
1014	while (io) {
1015	struct dm_io *next = io->next;
1016
1017	dm_io_rewind(io, &md->disk->bio_split);
1018
1019	io->next = NULL;
1020	__dm_io_complete(io, false);
1021	io = next;
1022	cond_resched();
1023	}
1024	}
1025
1026	/*
1027	* Two staged requeue:
1028	*
1029	* 1) io->orig_bio points to the real original bio, and the part mapped to
1030	* this io must be requeued, instead of other parts of the original bio.
1031	*
1032	* 2) io->orig_bio points to new cloned bio which matches the requeued dm_io.
1033	*/
1034	static inline void dm_io_complete(struct dm_io *io)
1035	{
1036	/*
1037	* Only dm_io that has been split needs two stage requeue, otherwise
1038	* we may run into long bio clone chain during suspend and OOM could
1039	* be triggered.
1040	*
1041	* Also flush data dm_io won't be marked as DM_IO_WAS_SPLIT, so they
1042	* also aren't handled via the first stage requeue.
1043	*/
1044	__dm_io_complete(io, dm_io_flagged(io, DM_IO_WAS_SPLIT));
1045	}
1046
1047	/*
1048	* Decrements the number of outstanding ios that a bio has been
1049	* cloned into, completing the original io if necc.
1050	*/
1051	static inline void __dm_io_dec_pending(struct dm_io *io)
1052	{
1053	if (atomic_dec_and_test(&io->io_count))
1054	dm_io_complete(io);
1055	}
1056
1057	static void dm_io_set_error(struct dm_io *io, blk_status_t error)
1058	{
1059	unsigned long flags;
1060
1061	/* Push-back supersedes any I/O errors */
1062	spin_lock_irqsave(&io->lock, flags);
1063	if (!(io->status == BLK_STS_DM_REQUEUE &&
1064	__noflush_suspending(io->md))) {
1065	io->status = error;
1066	}
1067	spin_unlock_irqrestore(&io->lock, flags);
1068	}
1069
1070	static void dm_io_dec_pending(struct dm_io *io, blk_status_t error)
1071	{
1072	if (unlikely(error))
1073	dm_io_set_error(io, error);
1074
1075	__dm_io_dec_pending(io);
1076	}
1077
1078	/*
1079	* The queue_limits are only valid as long as you have a reference
1080	* count on 'md'. But _not_ imposing verification to avoid atomic_read(),
1081	*/
1082	static inline struct queue_limits dm_get_queue_limits(struct mapped_device md)
1083	{
1084	return &md->queue->limits;
1085	}
1086
1087	static bool swap_bios_limit(struct dm_target ti, struct bio bio)
1088	{
1089	return unlikely((bio->bi_opf & REQ_SWAP) != 0) && unlikely(ti->limit_swap_bios);
1090	}
1091
1092	static void clone_endio(struct bio *bio)
1093	{
1094	blk_status_t error = bio->bi_status;
1095	struct dm_target_io *tio = clone_to_tio(bio);
1096	struct dm_target *ti = tio->ti;
1097	dm_endio_fn endio = likely(ti != NULL) ? ti->type->end_io : NULL;
1098	struct dm_io *io = tio->io;
1099	struct mapped_device *md = io->md;
1100
1101	if (unlikely(error == BLK_STS_TARGET)) {
1102	if (bio_op(bio) == REQ_OP_DISCARD &&
1103	!bdev_max_discard_sectors(bio->bi_bdev))
1104	blk_queue_disable_discard(md->queue);
1105	else if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
1106	!bdev_write_zeroes_sectors(bio->bi_bdev))
1107	blk_queue_disable_write_zeroes(md->queue);
1108	}
1109
1110	if (static_branch_unlikely(&zoned_enabled) &&
1111	unlikely(bdev_is_zoned(bio->bi_bdev)))
1112	dm_zone_endio(io, bio);
1113
1114	if (endio) {
1115	int r = endio(ti, bio, &error);
1116
1117	switch (r) {
1118	case DM_ENDIO_REQUEUE:
1119	if (static_branch_unlikely(&zoned_enabled)) {
1120	/*
1121	* Requeuing writes to a sequential zone of a zoned
1122	* target will break the sequential write pattern:
1123	* fail such IO.
1124	*/
1125	if (WARN_ON_ONCE(dm_is_zone_write(md, bio)))
1126	error = BLK_STS_IOERR;
1127	else
1128	error = BLK_STS_DM_REQUEUE;
1129	} else
1130	error = BLK_STS_DM_REQUEUE;
1131	fallthrough;
1132	case DM_ENDIO_DONE:
1133	break;
1134	case DM_ENDIO_INCOMPLETE:
1135	/* The target will handle the io */
1136	return;
1137	default:
1138	DMCRIT("unimplemented target endio return value: %d", r);
1139	BUG();
1140	}
1141	}
1142
1143	if (static_branch_unlikely(&swap_bios_enabled) &&
1144	likely(ti != NULL) && unlikely(swap_bios_limit(ti, bio)))
1145	up(&md->swap_bios_semaphore);
1146
1147	free_tio(bio);
1148	dm_io_dec_pending(io, error);
1149	}
1150
1151	/*
1152	* Return maximum size of I/O possible at the supplied sector up to the current
1153	* target boundary.
1154	*/
1155	static inline sector_t max_io_len_target_boundary(struct dm_target *ti,
1156	sector_t target_offset)
1157	{
1158	return ti->len - target_offset;
1159	}
1160
1161	static sector_t __max_io_len(struct dm_target *ti, sector_t sector,
1162	unsigned int max_granularity,
1163	unsigned int max_sectors)
1164	{
1165	sector_t target_offset = dm_target_offset(ti, sector);
1166	sector_t len = max_io_len_target_boundary(ti, target_offset);
1167
1168	/*
1169	* Does the target need to split IO even further?
1170	* - varied (per target) IO splitting is a tenet of DM; this
1171	* explains why stacked chunk_sectors based splitting via
1172	* bio_split_to_limits() isn't possible here.
1173	*/
1174	if (!max_granularity)
1175	return len;
1176	return min_t(sector_t, len,
1177	min(max_sectors ? : queue_max_sectors(ti->table->md->queue),
1178	blk_boundary_sectors_left(target_offset, max_granularity)));
1179	}
1180
1181	static inline sector_t max_io_len(struct dm_target *ti, sector_t sector)
1182	{
1183	return __max_io_len(ti, sector, ti->max_io_len, 0);
1184	}
1185
1186	int dm_set_target_max_io_len(struct dm_target *ti, sector_t len)
1187	{
1188	if (len > UINT_MAX) {
1189	DMERR("Specified maximum size of target IO (%llu) exceeds limit (%u)",
1190	(unsigned long long)len, UINT_MAX);
1191	ti->error = "Maximum size of target IO is too large";
1192	return -EINVAL;
1193	}
1194
1195	ti->max_io_len = (uint32_t) len;
1196
1197	return 0;
1198	}
1199	EXPORT_SYMBOL_GPL(dm_set_target_max_io_len);
1200
1201	static struct dm_target dm_dax_get_live_target(struct mapped_device md,
1202	sector_t sector, int *srcu_idx)
1203	__acquires(md->io_barrier)
1204	{
1205	struct dm_table *map;
1206	struct dm_target *ti;
1207
1208	map = dm_get_live_table(md, srcu_idx);
1209	if (!map)
1210	return NULL;
1211
1212	ti = dm_table_find_target(map, sector);
1213	if (!ti)
1214	return NULL;
1215
1216	return ti;
1217	}
1218
1219	static long dm_dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff,
1220	long nr_pages, enum dax_access_mode mode, void **kaddr,
1221	unsigned long *pfn)
1222	{
1223	struct mapped_device *md = dax_get_private(dax_dev);
1224	sector_t sector = pgoff * PAGE_SECTORS;
1225	struct dm_target *ti;
1226	long len, ret = -EIO;
1227	int srcu_idx;
1228
1229	ti = dm_dax_get_live_target(md, sector, &srcu_idx);
1230
1231	if (!ti)
1232	goto out;
1233	if (!ti->type->direct_access)
1234	goto out;
1235	len = max_io_len(ti, sector) / PAGE_SECTORS;
1236	if (len < 1)
1237	goto out;
1238	nr_pages = min(len, nr_pages);
1239	ret = ti->type->direct_access(ti, pgoff, nr_pages, mode, kaddr, pfn);
1240
1241	out:
1242	dm_put_live_table(md, srcu_idx);
1243
1244	return ret;
1245	}
1246
1247	static int dm_dax_zero_page_range(struct dax_device *dax_dev, pgoff_t pgoff,
1248	size_t nr_pages)
1249	{
1250	struct mapped_device *md = dax_get_private(dax_dev);
1251	sector_t sector = pgoff * PAGE_SECTORS;
1252	struct dm_target *ti;
1253	int ret = -EIO;
1254	int srcu_idx;
1255
1256	ti = dm_dax_get_live_target(md, sector, &srcu_idx);
1257
1258	if (!ti)
1259	goto out;
1260	if (WARN_ON(!ti->type->dax_zero_page_range)) {
1261	/*
1262	* ->zero_page_range() is mandatory dax operation. If we are
1263	* here, something is wrong.
1264	*/
1265	goto out;
1266	}
1267	ret = ti->type->dax_zero_page_range(ti, pgoff, nr_pages);
1268	out:
1269	dm_put_live_table(md, srcu_idx);
1270
1271	return ret;
1272	}
1273
1274	static size_t dm_dax_recovery_write(struct dax_device *dax_dev, pgoff_t pgoff,
1275	void addr, size_t bytes, struct iov_iter i)
1276	{
1277	struct mapped_device *md = dax_get_private(dax_dev);
1278	sector_t sector = pgoff * PAGE_SECTORS;
1279	struct dm_target *ti;
1280	int srcu_idx;
1281	long ret = 0;
1282
1283	ti = dm_dax_get_live_target(md, sector, &srcu_idx);
1284	if (!ti \|\| !ti->type->dax_recovery_write)
1285	goto out;
1286
1287	ret = ti->type->dax_recovery_write(ti, pgoff, addr, bytes, i);
1288	out:
1289	dm_put_live_table(md, srcu_idx);
1290	return ret;
1291	}
1292
1293	/*
1294	* A target may call dm_accept_partial_bio only from the map routine. It is
1295	* allowed for all bio types except REQ_PREFLUSH, REQ_OP_ZONE_* zone management
1296	* operations, zone append writes (native with REQ_OP_ZONE_APPEND or emulated
1297	* with write BIOs flagged with BIO_EMULATES_ZONE_APPEND) and any bio serviced
1298	* by __send_duplicate_bios().
1299	*
1300	* dm_accept_partial_bio informs the dm that the target only wants to process
1301	* additional n_sectors sectors of the bio and the rest of the data should be
1302	* sent in a next bio.
1303	*
1304	* A diagram that explains the arithmetics:
1305	* +--------------------+---------------+-------+
1306	* \| 1 \| 2 \| 3 \|
1307	* +--------------------+---------------+-------+
1308	*
1309	* <-------------- *tio->len_ptr --------------->
1310	* <----- bio_sectors ----->
1311	* <-- n_sectors -->
1312	*
1313	* Region 1 was already iterated over with bio_advance or similar function.
1314	* (it may be empty if the target doesn't use bio_advance)
1315	* Region 2 is the remaining bio size that the target wants to process.
1316	* (it may be empty if region 1 is non-empty, although there is no reason
1317	* to make it empty)
1318	* The target requires that region 3 is to be sent in the next bio.
1319	*
1320	* If the target wants to receive multiple copies of the bio (via num_*bios, etc),
1321	* the partially processed part (the sum of regions 1+2) must be the same for all
1322	* copies of the bio.
1323	*/
1324	void dm_accept_partial_bio(struct bio *bio, unsigned int n_sectors)
1325	{
1326	struct dm_target_io *tio = clone_to_tio(bio);
1327	struct dm_io *io = tio->io;
1328	unsigned int bio_sectors = bio_sectors(bio);
1329
1330	BUG_ON(dm_tio_flagged(tio, DM_TIO_IS_DUPLICATE_BIO));
1331	BUG_ON(bio_sectors > *tio->len_ptr);
1332	BUG_ON(n_sectors > bio_sectors);
1333	BUG_ON(bio->bi_opf & REQ_ATOMIC);
1334
1335	if (static_branch_unlikely(&zoned_enabled) &&
1336	unlikely(bdev_is_zoned(bio->bi_bdev))) {
1337	enum req_op op = bio_op(bio);
1338
1339	BUG_ON(op_is_zone_mgmt(op));
1340	BUG_ON(op == REQ_OP_WRITE);
1341	BUG_ON(op == REQ_OP_WRITE_ZEROES);
1342	BUG_ON(op == REQ_OP_ZONE_APPEND);
1343	}
1344
1345	*tio->len_ptr -= bio_sectors - n_sectors;
1346	bio->bi_iter.bi_size = n_sectors << SECTOR_SHIFT;
1347
1348	/*
1349	* __split_and_process_bio() may have already saved mapped part
1350	* for accounting but it is being reduced so update accordingly.
1351	*/
1352	dm_io_set_flag(io, DM_IO_WAS_SPLIT);
1353	io->sectors = n_sectors;
1354	io->sector_offset = bio_sectors(io->orig_bio);
1355	}
1356	EXPORT_SYMBOL_GPL(dm_accept_partial_bio);
1357
1358	/*
1359	* @clone: clone bio that DM core passed to target's .map function
1360	* @tgt_clone: clone of @clone bio that target needs submitted
1361	*
1362	* Targets should use this interface to submit bios they take
1363	* ownership of when returning DM_MAPIO_SUBMITTED.
1364	*
1365	* Target should also enable ti->accounts_remapped_io
1366	*/
1367	void dm_submit_bio_remap(struct bio clone, struct bio tgt_clone)
1368	{
1369	struct dm_target_io *tio = clone_to_tio(clone);
1370	struct dm_io *io = tio->io;
1371
1372	/* establish bio that will get submitted */
1373	if (!tgt_clone)
1374	tgt_clone = clone;
1375
1376	bio_clone_blkg_association(tgt_clone, io->orig_bio);
1377
1378	/*
1379	* Account io->origin_bio to DM dev on behalf of target
1380	* that took ownership of IO with DM_MAPIO_SUBMITTED.
1381	*/
1382	dm_start_io_acct(io, clone);
1383
1384	trace_block_bio_remap(tgt_clone, disk_devt(io->md->disk),
1385	tio->old_sector);
1386	submit_bio_noacct(tgt_clone);
1387	}
1388	EXPORT_SYMBOL_GPL(dm_submit_bio_remap);
1389
1390	static noinline void __set_swap_bios_limit(struct mapped_device *md, int latch)
1391	{
1392	mutex_lock(&md->swap_bios_lock);
1393	while (latch < md->swap_bios) {
1394	cond_resched();
1395	down(&md->swap_bios_semaphore);
1396	md->swap_bios--;
1397	}
1398	while (latch > md->swap_bios) {
1399	cond_resched();
1400	up(&md->swap_bios_semaphore);
1401	md->swap_bios++;
1402	}
1403	mutex_unlock(&md->swap_bios_lock);
1404	}
1405
1406	static void __map_bio(struct bio *clone)
1407	{
1408	struct dm_target_io *tio = clone_to_tio(clone);
1409	struct dm_target *ti = tio->ti;
1410	struct dm_io *io = tio->io;
1411	struct mapped_device *md = io->md;
1412	int r;
1413
1414	clone->bi_end_io = clone_endio;
1415
1416	/*
1417	* Map the clone.
1418	*/
1419	tio->old_sector = clone->bi_iter.bi_sector;
1420
1421	if (static_branch_unlikely(&swap_bios_enabled) &&
1422	unlikely(swap_bios_limit(ti, clone))) {
1423	int latch = get_swap_bios();
1424
1425	if (unlikely(latch != md->swap_bios))
1426	__set_swap_bios_limit(md, latch);
1427	down(&md->swap_bios_semaphore);
1428	}
1429
1430	if (likely(ti->type->map == linear_map))
1431	r = linear_map(ti, clone);
1432	else if (ti->type->map == stripe_map)
1433	r = stripe_map(ti, clone);
1434	else
1435	r = ti->type->map(ti, clone);
1436
1437	switch (r) {
1438	case DM_MAPIO_SUBMITTED:
1439	/* target has assumed ownership of this io */
1440	if (!ti->accounts_remapped_io)
1441	dm_start_io_acct(io, clone);
1442	break;
1443	case DM_MAPIO_REMAPPED:
1444	dm_submit_bio_remap(clone, NULL);
1445	break;
1446	case DM_MAPIO_KILL:
1447	case DM_MAPIO_REQUEUE:
1448	if (static_branch_unlikely(&swap_bios_enabled) &&
1449	unlikely(swap_bios_limit(ti, clone)))
1450	up(&md->swap_bios_semaphore);
1451	free_tio(clone);
1452	if (r == DM_MAPIO_KILL)
1453	dm_io_dec_pending(io, BLK_STS_IOERR);
1454	else
1455	dm_io_dec_pending(io, BLK_STS_DM_REQUEUE);
1456	break;
1457	default:
1458	DMCRIT("unimplemented target map return value: %d", r);
1459	BUG();
1460	}
1461	}
1462
1463	static void setup_split_accounting(struct clone_info *ci, unsigned int len)
1464	{
1465	struct dm_io *io = ci->io;
1466
1467	if (ci->sector_count > len) {
1468	/*
1469	* Split needed, save the mapped part for accounting.
1470	* NOTE: dm_accept_partial_bio() will update accordingly.
1471	*/
1472	dm_io_set_flag(io, DM_IO_WAS_SPLIT);
1473	io->sectors = len;
1474	io->sector_offset = bio_sectors(ci->bio);
1475	}
1476	}
1477
1478	static void alloc_multiple_bios(struct bio_list blist, struct clone_info ci,
1479	struct dm_target *ti, unsigned int num_bios,
1480	unsigned *len)
1481	{
1482	struct bio *bio;
1483	int try;
1484
1485	for (try = 0; try < 2; try++) {
1486	int bio_nr;
1487
1488	if (try && num_bios > 1)
1489	mutex_lock(&ci->io->md->table_devices_lock);
1490	for (bio_nr = 0; bio_nr < num_bios; bio_nr++) {
1491	bio = alloc_tio(ci, ti, bio_nr, len,
1492	try ? GFP_NOIO : GFP_NOWAIT);
1493	if (!bio)
1494	break;
1495
1496	bio_list_add(blist, bio);
1497	}
1498	if (try && num_bios > 1)
1499	mutex_unlock(&ci->io->md->table_devices_lock);
1500	if (bio_nr == num_bios)
1501	return;
1502
1503	while ((bio = bio_list_pop(blist)))
1504	free_tio(bio);
1505	}
1506	}
1507
1508	static unsigned int __send_duplicate_bios(struct clone_info ci, struct dm_target ti,
1509	unsigned int num_bios, unsigned int *len)
1510	{
1511	struct bio_list blist = BIO_EMPTY_LIST;
1512	struct bio *clone;
1513	unsigned int ret = 0;
1514
1515	if (WARN_ON_ONCE(num_bios == 0)) /* num_bios = 0 is a bug in caller */
1516	return 0;
1517
1518	/* dm_accept_partial_bio() is not supported with shared tio->len_ptr */
1519	if (len)
1520	setup_split_accounting(ci, *len);
1521
1522	/*
1523	* Using alloc_multiple_bios(), even if num_bios is 1, to consistently
1524	* support allocating using GFP_NOWAIT with GFP_NOIO fallback.
1525	*/
1526	alloc_multiple_bios(&blist, ci, ti, num_bios, len);
1527	while ((clone = bio_list_pop(&blist))) {
1528	if (num_bios > 1)
1529	dm_tio_set_flag(clone_to_tio(clone), DM_TIO_IS_DUPLICATE_BIO);
1530	__map_bio(clone);
1531	ret += 1;
1532	}
1533
1534	return ret;
1535	}
1536
1537	static void __send_empty_flush(struct clone_info *ci)
1538	{
1539	struct dm_table *t = ci->map;
1540	struct bio flush_bio;
1541	blk_opf_t opf = REQ_OP_WRITE \| REQ_PREFLUSH \| REQ_SYNC;
1542
1543	if ((ci->io->orig_bio->bi_opf & (REQ_IDLE \| REQ_SYNC)) ==
1544	(REQ_IDLE \| REQ_SYNC))
1545	opf \|= REQ_IDLE;
1546
1547	/*
1548	* Use an on-stack bio for this, it's safe since we don't
1549	* need to reference it after submit. It's just used as
1550	* the basis for the clone(s).
1551	*/
1552	bio_init(&flush_bio, ci->io->md->disk->part0, NULL, 0, opf);
1553
1554	ci->bio = &flush_bio;
1555	ci->sector_count = 0;
1556	ci->io->tio.clone.bi_iter.bi_size = 0;
1557
1558	if (!t->flush_bypasses_map) {
1559	for (unsigned int i = 0; i < t->num_targets; i++) {
1560	unsigned int bios;
1561	struct dm_target *ti = dm_table_get_target(t, i);
1562
1563	if (unlikely(ti->num_flush_bios == 0))
1564	continue;
1565
1566	atomic_add(ti->num_flush_bios, &ci->io->io_count);
1567	bios = __send_duplicate_bios(ci, ti, ti->num_flush_bios,
1568	NULL);
1569	atomic_sub(ti->num_flush_bios - bios, &ci->io->io_count);
1570	}
1571	} else {
1572	/*
1573	* Note that there's no need to grab t->devices_lock here
1574	* because the targets that support flush optimization don't
1575	* modify the list of devices.
1576	*/
1577	struct list_head *devices = dm_table_get_devices(t);
1578	unsigned int len = 0;
1579	struct dm_dev_internal *dd;
1580	list_for_each_entry(dd, devices, list) {
1581	struct bio *clone;
1582	/*
1583	* Note that the structure dm_target_io is not
1584	* associated with any target (because the device may be
1585	* used by multiple targets), so we set tio->ti = NULL.
1586	* We must check for NULL in the I/O processing path, to
1587	* avoid NULL pointer dereference.
1588	*/
1589	clone = alloc_tio(ci, NULL, 0, &len, GFP_NOIO);
1590	atomic_add(1, &ci->io->io_count);
1591	bio_set_dev(clone, dd->dm_dev->bdev);
1592	clone->bi_end_io = clone_endio;
1593	dm_submit_bio_remap(clone, NULL);
1594	}
1595	}
1596
1597	/*
1598	* alloc_io() takes one extra reference for submission, so the
1599	* reference won't reach 0 without the following subtraction
1600	*/
1601	atomic_sub(1, &ci->io->io_count);
1602
1603	bio_uninit(ci->bio);
1604	}
1605
1606	static void __send_abnormal_io(struct clone_info ci, struct dm_target ti,
1607	unsigned int num_bios, unsigned int max_granularity,
1608	unsigned int max_sectors)
1609	{
1610	unsigned int len, bios;
1611
1612	len = min_t(sector_t, ci->sector_count,
1613	__max_io_len(ti, ci->sector, max_granularity, max_sectors));
1614
1615	atomic_add(num_bios, &ci->io->io_count);
1616	bios = __send_duplicate_bios(ci, ti, num_bios, &len);
1617	/*
1618	* alloc_io() takes one extra reference for submission, so the
1619	* reference won't reach 0 without the following (+1) subtraction
1620	*/
1621	atomic_sub(num_bios - bios + 1, &ci->io->io_count);
1622
1623	ci->sector += len;
1624	ci->sector_count -= len;
1625	}
1626
1627	static bool is_abnormal_io(struct bio *bio)
1628	{
1629	switch (bio_op(bio)) {
1630	case REQ_OP_READ:
1631	case REQ_OP_WRITE:
1632	case REQ_OP_FLUSH:
1633	return false;
1634	case REQ_OP_DISCARD:
1635	case REQ_OP_SECURE_ERASE:
1636	case REQ_OP_WRITE_ZEROES:
1637	case REQ_OP_ZONE_RESET_ALL:
1638	return true;
1639	default:
1640	return false;
1641	}
1642	}
1643
1644	static blk_status_t __process_abnormal_io(struct clone_info *ci,
1645	struct dm_target *ti)
1646	{
1647	unsigned int num_bios = 0;
1648	unsigned int max_granularity = 0;
1649	unsigned int max_sectors = 0;
1650	struct queue_limits *limits = dm_get_queue_limits(ti->table->md);
1651
1652	switch (bio_op(ci->bio)) {
1653	case REQ_OP_DISCARD:
1654	num_bios = ti->num_discard_bios;
1655	max_sectors = limits->max_discard_sectors;
1656	if (ti->max_discard_granularity)
1657	max_granularity = max_sectors;
1658	break;
1659	case REQ_OP_SECURE_ERASE:
1660	num_bios = ti->num_secure_erase_bios;
1661	max_sectors = limits->max_secure_erase_sectors;
1662	break;
1663	case REQ_OP_WRITE_ZEROES:
1664	num_bios = ti->num_write_zeroes_bios;
1665	max_sectors = limits->max_write_zeroes_sectors;
1666	break;
1667	default:
1668	break;
1669	}
1670
1671	/*
1672	* Even though the device advertised support for this type of
1673	* request, that does not mean every target supports it, and
1674	* reconfiguration might also have changed that since the
1675	* check was performed.
1676	*/
1677	if (unlikely(!num_bios))
1678	return BLK_STS_NOTSUPP;
1679
1680	__send_abnormal_io(ci, ti, num_bios, max_granularity, max_sectors);
1681
1682	return BLK_STS_OK;
1683	}
1684
1685	/*
1686	* Reuse ->bi_private as dm_io list head for storing all dm_io instances
1687	* associated with this bio, and this bio's bi_private needs to be
1688	* stored in dm_io->data before the reuse.
1689	*
1690	* bio->bi_private is owned by fs or upper layer, so block layer won't
1691	* touch it after splitting. Meantime it won't be changed by anyone after
1692	* bio is submitted. So this reuse is safe.
1693	*/
1694	static inline struct dm_io *dm_poll_list_head(struct bio bio)
1695	{
1696	return (struct dm_io **)&bio->bi_private;
1697	}
1698
1699	static void dm_queue_poll_io(struct bio bio, struct dm_io io)
1700	{
1701	struct dm_io **head = dm_poll_list_head(bio);
1702
1703	if (!(bio->bi_opf & REQ_DM_POLL_LIST)) {
1704	bio->bi_opf \|= REQ_DM_POLL_LIST;
1705	/*
1706	* Save .bi_private into dm_io, so that we can reuse
1707	* .bi_private as dm_io list head for storing dm_io list
1708	*/
1709	io->data = bio->bi_private;
1710
1711	/* tell block layer to poll for completion */
1712	bio->bi_cookie = ~BLK_QC_T_NONE;
1713
1714	io->next = NULL;
1715	} else {
1716	/*
1717	* bio recursed due to split, reuse original poll list,
1718	* and save bio->bi_private too.
1719	*/
1720	io->data = (*head)->data;
1721	io->next = *head;
1722	}
1723
1724	*head = io;
1725	}
1726
1727	/*
1728	* Select the correct strategy for processing a non-flush bio.
1729	*/
1730	static blk_status_t __split_and_process_bio(struct clone_info *ci)
1731	{
1732	struct bio *clone;
1733	struct dm_target *ti;
1734	unsigned int len;
1735
1736	ti = dm_table_find_target(ci->map, ci->sector);
1737	if (unlikely(!ti))
1738	return BLK_STS_IOERR;
1739
1740	if (unlikely(ci->is_abnormal_io))
1741	return __process_abnormal_io(ci, ti);
1742
1743	/*
1744	* Only support bio polling for normal IO, and the target io is
1745	* exactly inside the dm_io instance (verified in dm_poll_dm_io)
1746	*/
1747	ci->submit_as_polled = !!(ci->bio->bi_opf & REQ_POLLED);
1748
1749	len = min_t(sector_t, max_io_len(ti, ci->sector), ci->sector_count);
1750	if (ci->bio->bi_opf & REQ_ATOMIC) {
1751	if (unlikely(!dm_target_supports_atomic_writes(ti->type)))
1752	return BLK_STS_IOERR;
1753	if (unlikely(len != ci->sector_count))
1754	return BLK_STS_IOERR;
1755	}
1756
1757	setup_split_accounting(ci, len);
1758
1759	if (unlikely(ci->bio->bi_opf & REQ_NOWAIT)) {
1760	if (unlikely(!dm_target_supports_nowait(ti->type)))
1761	return BLK_STS_NOTSUPP;
1762
1763	clone = alloc_tio(ci, ti, 0, &len, GFP_NOWAIT);
1764	if (unlikely(!clone))
1765	return BLK_STS_AGAIN;
1766	} else {
1767	clone = alloc_tio(ci, ti, 0, &len, GFP_NOIO);
1768	}
1769	__map_bio(clone);
1770
1771	ci->sector += len;
1772	ci->sector_count -= len;
1773
1774	return BLK_STS_OK;
1775	}
1776
1777	static void init_clone_info(struct clone_info ci, struct dm_io io,
1778	struct dm_table map, struct bio bio, bool is_abnormal)
1779	{
1780	ci->map = map;
1781	ci->io = io;
1782	ci->bio = bio;
1783	ci->is_abnormal_io = is_abnormal;
1784	ci->submit_as_polled = false;
1785	ci->sector = bio->bi_iter.bi_sector;
1786	ci->sector_count = bio_sectors(bio);
1787
1788	/* Shouldn't happen but sector_count was being set to 0 so... */
1789	if (static_branch_unlikely(&zoned_enabled) &&
1790	WARN_ON_ONCE(op_is_zone_mgmt(bio_op(bio)) && ci->sector_count))
1791	ci->sector_count = 0;
1792	}
1793
1794	#ifdef CONFIG_BLK_DEV_ZONED
1795	static inline bool dm_zone_bio_needs_split(struct bio *bio)
1796	{
1797	/*
1798	* Special case the zone operations that cannot or should not be split.
1799	*/
1800	switch (bio_op(bio)) {
1801	case REQ_OP_ZONE_APPEND:
1802	case REQ_OP_ZONE_FINISH:
1803	case REQ_OP_ZONE_RESET:
1804	case REQ_OP_ZONE_RESET_ALL:
1805	return false;
1806	default:
1807	break;
1808	}
1809
1810	/*
1811	* When mapped devices use the block layer zone write plugging, we must
1812	* split any large BIO to the mapped device limits to not submit BIOs
1813	* that span zone boundaries and to avoid potential deadlocks with
1814	* queue freeze operations.
1815	*/
1816	return bio_needs_zone_write_plugging(bio) \|\| bio_straddles_zones(bio);
1817	}
1818
1819	static inline bool dm_zone_plug_bio(struct mapped_device md, struct bio bio)
1820	{
1821	if (!bio_needs_zone_write_plugging(bio))
1822	return false;
1823	return blk_zone_plug_bio(bio, 0);
1824	}
1825
1826	static blk_status_t __send_zone_reset_all_emulated(struct clone_info *ci,
1827	struct dm_target *ti)
1828	{
1829	struct bio_list blist = BIO_EMPTY_LIST;
1830	struct mapped_device *md = ci->io->md;
1831	unsigned int zone_sectors = md->disk->queue->limits.chunk_sectors;
1832	unsigned long *need_reset;
1833	unsigned int i, nr_zones, nr_reset;
1834	unsigned int num_bios = 0;
1835	blk_status_t sts = BLK_STS_OK;
1836	sector_t sector = ti->begin;
1837	struct bio *clone;
1838	int ret;
1839
1840	nr_zones = ti->len >> ilog2(zone_sectors);
1841	need_reset = bitmap_zalloc(nr_zones, GFP_NOIO);
1842	if (!need_reset)
1843	return BLK_STS_RESOURCE;
1844
1845	ret = dm_zone_get_reset_bitmap(md, ci->map, ti->begin,
1846	nr_zones, need_reset);
1847	if (ret) {
1848	sts = BLK_STS_IOERR;
1849	goto free_bitmap;
1850	}
1851
1852	/* If we have no zone to reset, we are done. */
1853	nr_reset = bitmap_weight(need_reset, nr_zones);
1854	if (!nr_reset)
1855	goto free_bitmap;
1856
1857	atomic_add(nr_zones, &ci->io->io_count);
1858
1859	for (i = 0; i < nr_zones; i++) {
1860
1861	if (!test_bit(i, need_reset)) {
1862	sector += zone_sectors;
1863	continue;
1864	}
1865
1866	if (bio_list_empty(&blist)) {
1867	/* This may take a while, so be nice to others */
1868	if (num_bios)
1869	cond_resched();
1870
1871	/*
1872	* We may need to reset thousands of zones, so let's
1873	* not go crazy with the clone allocation.
1874	*/
1875	alloc_multiple_bios(&blist, ci, ti, min(nr_reset, 32),
1876	NULL);
1877	}
1878
1879	/* Get a clone and change it to a regular reset operation. */
1880	clone = bio_list_pop(&blist);
1881	clone->bi_opf &= ~REQ_OP_MASK;
1882	clone->bi_opf \|= REQ_OP_ZONE_RESET \| REQ_SYNC;
1883	clone->bi_iter.bi_sector = sector;
1884	clone->bi_iter.bi_size = 0;
1885	__map_bio(clone);
1886
1887	sector += zone_sectors;
1888	num_bios++;
1889	nr_reset--;
1890	}
1891
1892	WARN_ON_ONCE(!bio_list_empty(&blist));
1893	atomic_sub(nr_zones - num_bios, &ci->io->io_count);
1894	ci->sector_count = 0;
1895
1896	free_bitmap:
1897	bitmap_free(need_reset);
1898
1899	return sts;
1900	}
1901
1902	static void __send_zone_reset_all_native(struct clone_info *ci,
1903	struct dm_target *ti)
1904	{
1905	unsigned int bios;
1906
1907	atomic_add(1, &ci->io->io_count);
1908	bios = __send_duplicate_bios(ci, ti, 1, NULL);
1909	atomic_sub(1 - bios, &ci->io->io_count);
1910
1911	ci->sector_count = 0;
1912	}
1913
1914	static blk_status_t __send_zone_reset_all(struct clone_info *ci)
1915	{
1916	struct dm_table *t = ci->map;
1917	blk_status_t sts = BLK_STS_OK;
1918
1919	for (unsigned int i = 0; i < t->num_targets; i++) {
1920	struct dm_target *ti = dm_table_get_target(t, i);
1921
1922	if (ti->zone_reset_all_supported) {
1923	__send_zone_reset_all_native(ci, ti);
1924	continue;
1925	}
1926
1927	sts = __send_zone_reset_all_emulated(ci, ti);
1928	if (sts != BLK_STS_OK)
1929	break;
1930	}
1931
1932	/* Release the reference that alloc_io() took for submission. */
1933	atomic_sub(1, &ci->io->io_count);
1934
1935	return sts;
1936	}
1937
1938	#else
1939	static inline bool dm_zone_bio_needs_split(struct bio *bio)
1940	{
1941	return false;
1942	}
1943	static inline bool dm_zone_plug_bio(struct mapped_device md, struct bio bio)
1944	{
1945	return false;
1946	}
1947	static blk_status_t __send_zone_reset_all(struct clone_info *ci)
1948	{
1949	return BLK_STS_NOTSUPP;
1950	}
1951	#endif
1952
1953	/*
1954	* Entry point to split a bio into clones and submit them to the targets.
1955	*/
1956	static void dm_split_and_process_bio(struct mapped_device *md,
1957	struct dm_table map, struct bio bio)
1958	{
1959	struct clone_info ci;
1960	struct dm_io *io;
1961	blk_status_t error = BLK_STS_OK;
1962	bool is_abnormal, need_split;
1963
1964	is_abnormal = is_abnormal_io(bio);
1965	if (static_branch_unlikely(&zoned_enabled)) {
1966	need_split = is_abnormal \|\| dm_zone_bio_needs_split(bio);
1967	} else {
1968	need_split = is_abnormal;
1969	}
1970
1971	if (unlikely(need_split)) {
1972	/*
1973	* Use bio_split_to_limits() for abnormal IO (e.g. discard, etc)
1974	* otherwise associated queue_limits won't be imposed.
1975	* Also split the BIO for mapped devices needing zone append
1976	* emulation to ensure that the BIO does not cross zone
1977	* boundaries.
1978	*/
1979	bio = bio_split_to_limits(bio);
1980	if (!bio)
1981	return;
1982	}
1983
1984	/*
1985	* Use the block layer zone write plugging for mapped devices that
1986	* need zone append emulation (e.g. dm-crypt).
1987	*/
1988	if (static_branch_unlikely(&zoned_enabled) && dm_zone_plug_bio(md, bio))
1989	return;
1990
1991	/* Only support nowait for normal IO */
1992	if (unlikely(bio->bi_opf & REQ_NOWAIT) && !is_abnormal) {
1993	/*
1994	* Don't support NOWAIT for FLUSH because it may allocate
1995	* multiple bios and there's no easy way how to undo the
1996	* allocations.
1997	*/
1998	if (bio->bi_opf & REQ_PREFLUSH) {
1999	bio_wouldblock_error(bio);
2000	return;
2001	}
2002	io = alloc_io(md, bio, GFP_NOWAIT);
2003	if (unlikely(!io)) {
2004	/* Unable to do anything without dm_io. */
2005	bio_wouldblock_error(bio);
2006	return;
2007	}
2008	} else {
2009	io = alloc_io(md, bio, GFP_NOIO);
2010	}
2011	init_clone_info(&ci, io, map, bio, is_abnormal);
2012
2013	if (unlikely((bio->bi_opf & REQ_PREFLUSH) != 0)) {
2014	/*
2015	* The "flush_bypasses_map" is set on targets where it is safe
2016	* to skip the map function and submit bios directly to the
2017	* underlying block devices - currently, it is set for dm-linear
2018	* and dm-stripe.
2019	*
2020	* If we have just one underlying device (i.e. there is one
2021	* linear target or multiple linear targets pointing to the same
2022	* device), we can send the flush with data directly to it.
2023	*/
2024	if (bio->bi_iter.bi_size && map->flush_bypasses_map) {
2025	struct list_head *devices = dm_table_get_devices(map);
2026	if (devices->next == devices->prev)
2027	goto send_preflush_with_data;
2028	}
2029	if (bio->bi_iter.bi_size)
2030	io->requeue_flush_with_data = true;
2031	__send_empty_flush(&ci);
2032	/* dm_io_complete submits any data associated with flush */
2033	goto out;
2034	}
2035
2036	send_preflush_with_data:
2037	if (static_branch_unlikely(&zoned_enabled) &&
2038	(bio_op(bio) == REQ_OP_ZONE_RESET_ALL)) {
2039	error = __send_zone_reset_all(&ci);
2040	goto out;
2041	}
2042
2043	error = __split_and_process_bio(&ci);
2044	if (error \|\| !ci.sector_count)
2045	goto out;
2046	/*
2047	* Remainder must be passed to submit_bio_noacct() so it gets handled
2048	* after bios already submitted have been completely processed.
2049	*/
2050	bio_trim(bio, io->sectors, ci.sector_count);
2051	trace_block_split(bio, bio->bi_iter.bi_sector);
2052	bio_inc_remaining(bio);
2053	submit_bio_noacct(bio);
2054	out:
2055	/*
2056	* Drop the extra reference count for non-POLLED bio, and hold one
2057	* reference for POLLED bio, which will be released in dm_poll_bio
2058	*
2059	* Add every dm_io instance into the dm_io list head which is stored
2060	* in bio->bi_private, so that dm_poll_bio can poll them all.
2061	*/
2062	if (error \|\| !ci.submit_as_polled) {
2063	/*
2064	* In case of submission failure, the extra reference for
2065	* submitting io isn't consumed yet
2066	*/
2067	if (error)
2068	atomic_dec(&io->io_count);
2069	dm_io_dec_pending(io, error);
2070	} else
2071	dm_queue_poll_io(bio, io);
2072	}
2073
2074	static void dm_submit_bio(struct bio *bio)
2075	{
2076	struct mapped_device *md = bio->bi_bdev->bd_disk->private_data;
2077	int srcu_idx;
2078	struct dm_table *map;
2079
2080	map = dm_get_live_table(md, &srcu_idx);
2081	if (unlikely(!map)) {
2082	DMERR_LIMIT("%s: mapping table unavailable, erroring io",
2083	dm_device_name(md));
2084	bio_io_error(bio);
2085	goto out;
2086	}
2087
2088	/* If suspended, queue this IO for later */
2089	if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))) {
2090	if (bio->bi_opf & REQ_NOWAIT)
2091	bio_wouldblock_error(bio);
2092	else if (bio->bi_opf & REQ_RAHEAD)
2093	bio_io_error(bio);
2094	else
2095	queue_io(md, bio);
2096	goto out;
2097	}
2098
2099	dm_split_and_process_bio(md, map, bio);
2100	out:
2101	dm_put_live_table(md, srcu_idx);
2102	}
2103
2104	static bool dm_poll_dm_io(struct dm_io io, struct io_comp_batch iob,
2105	unsigned int flags)
2106	{
2107	WARN_ON_ONCE(!dm_tio_is_normal(&io->tio));
2108
2109	/* don't poll if the mapped io is done */
2110	if (atomic_read(&io->io_count) > 1) {
2111	/*
2112	* DM hides the target queues from the upper poller, which may
2113	* decide it is safe to spin on a single stacked queue. Do not
2114	* pass that spinning policy down to a target queue: one slow
2115	* clone could keep the task inside dm_poll_bio() for a long
2116	* time. Poll target bios once and let the caller decide
2117	* whether to keep polling, reap completions or reschedule.
2118	*/
2119	bio_poll(&io->tio.clone, iob, flags \| BLK_POLL_ONESHOT);
2120	}
2121
2122	/* bio_poll holds the last reference */
2123	return atomic_read(&io->io_count) == 1;
2124	}
2125
2126	static int dm_poll_bio(struct bio bio, struct io_comp_batch iob,
2127	unsigned int flags)
2128	{
2129	struct dm_io **head = dm_poll_list_head(bio);
2130	struct dm_io list = head;
2131	struct dm_io *tmp = NULL;
2132	struct dm_io curr, next;
2133
2134	/* Only poll normal bio which was marked as REQ_DM_POLL_LIST */
2135	if (!(bio->bi_opf & REQ_DM_POLL_LIST))
2136	return 0;
2137
2138	WARN_ON_ONCE(!list);
2139
2140	/*
2141	* Restore .bi_private before possibly completing dm_io.
2142	*
2143	* bio_poll() is only possible once @bio has been completely
2144	* submitted via submit_bio_noacct()'s depth-first submission.
2145	* So there is no dm_queue_poll_io() race associated with
2146	* clearing REQ_DM_POLL_LIST here.
2147	*/
2148	bio->bi_opf &= ~REQ_DM_POLL_LIST;
2149	bio->bi_private = list->data;
2150
2151	for (curr = list, next = curr->next; curr; curr = next, next =
2152	curr ? curr->next : NULL) {
2153	if (dm_poll_dm_io(curr, iob, flags)) {
2154	/*
2155	* clone_endio() has already occurred, so no
2156	* error handling is needed here.
2157	*/
2158	__dm_io_dec_pending(curr);
2159	} else {
2160	curr->next = tmp;
2161	tmp = curr;
2162	}
2163	}
2164
2165	/* Not done? */
2166	if (tmp) {
2167	bio->bi_opf \|= REQ_DM_POLL_LIST;
2168	/* Reset bio->bi_private to dm_io list head */
2169	*head = tmp;
2170	return 0;
2171	}
2172	return 1;
2173	}
2174
2175	/*
2176	*---------------------------------------------------------------
2177	* An IDR is used to keep track of allocated minor numbers.
2178	*---------------------------------------------------------------
2179	*/
2180	static void free_minor(int minor)
2181	{
2182	spin_lock(&_minor_lock);
2183	idr_remove(&_minor_idr, minor);
2184	spin_unlock(&_minor_lock);
2185	}
2186
2187	/*
2188	* See if the device with a specific minor # is free.
2189	*/
2190	static int specific_minor(int minor)
2191	{
2192	int r;
2193
2194	if (minor >= (1 << MINORBITS))
2195	return -EINVAL;
2196
2197	idr_preload(GFP_KERNEL);
2198	spin_lock(&_minor_lock);
2199
2200	r = idr_alloc(&_minor_idr, MINOR_ALLOCED, minor, minor + 1, GFP_NOWAIT);
2201
2202	spin_unlock(&_minor_lock);
2203	idr_preload_end();
2204	if (r < 0)
2205	return r == -ENOSPC ? -EBUSY : r;
2206	return 0;
2207	}
2208
2209	static int next_free_minor(int *minor)
2210	{
2211	int r;
2212
2213	idr_preload(GFP_KERNEL);
2214	spin_lock(&_minor_lock);
2215
2216	r = idr_alloc(&_minor_idr, MINOR_ALLOCED, 0, 1 << MINORBITS, GFP_NOWAIT);
2217
2218	spin_unlock(&_minor_lock);
2219	idr_preload_end();
2220	if (r < 0)
2221	return r;
2222	*minor = r;
2223	return 0;
2224	}
2225
2226	static const struct block_device_operations dm_blk_dops;
2227	static const struct block_device_operations dm_rq_blk_dops;
2228	static const struct dax_operations dm_dax_ops;
2229
2230	static void dm_wq_work(struct work_struct *work);
2231
2232	#ifdef CONFIG_BLK_INLINE_ENCRYPTION
2233	static void dm_queue_destroy_crypto_profile(struct request_queue *q)
2234	{
2235	dm_destroy_crypto_profile(q->crypto_profile);
2236	}
2237
2238	#else /* CONFIG_BLK_INLINE_ENCRYPTION */
2239
2240	static inline void dm_queue_destroy_crypto_profile(struct request_queue *q)
2241	{
2242	}
2243	#endif /* !CONFIG_BLK_INLINE_ENCRYPTION */
2244
2245	static void cleanup_mapped_device(struct mapped_device *md)
2246	{
2247	if (md->wq)
2248	destroy_workqueue(md->wq);
2249	dm_free_md_mempools(md->mempools);
2250
2251	if (md->dax_dev) {
2252	dax_remove_host(md->disk);
2253	kill_dax(md->dax_dev);
2254	put_dax(md->dax_dev);
2255	md->dax_dev = NULL;
2256	}
2257
2258	if (md->disk) {
2259	spin_lock(&_minor_lock);
2260	md->disk->private_data = NULL;
2261	spin_unlock(&_minor_lock);
2262	if (dm_get_md_type(md) != DM_TYPE_NONE) {
2263	struct table_device *td;
2264
2265	dm_sysfs_exit(md);
2266	list_for_each_entry(td, &md->table_devices, list) {
2267	bd_unlink_disk_holder(td->dm_dev.bdev,
2268	md->disk);
2269	}
2270
2271	/*
2272	* Hold lock to make sure del_gendisk() won't concurrent
2273	* with open/close_table_device().
2274	*/
2275	mutex_lock(&md->table_devices_lock);
2276	del_gendisk(md->disk);
2277	mutex_unlock(&md->table_devices_lock);
2278	}
2279	dm_queue_destroy_crypto_profile(md->queue);
2280	put_disk(md->disk);
2281	}
2282
2283	if (md->pending_io) {
2284	free_percpu(md->pending_io);
2285	md->pending_io = NULL;
2286	}
2287
2288	cleanup_srcu_struct(&md->io_barrier);
2289
2290	mutex_destroy(&md->suspend_lock);
2291	mutex_destroy(&md->type_lock);
2292	mutex_destroy(&md->table_devices_lock);
2293	mutex_destroy(&md->swap_bios_lock);
2294
2295	dm_mq_cleanup_mapped_device(md);
2296	}
2297
2298	/*
2299	* Allocate and initialise a blank device with a given minor.
2300	*/
2301	static struct mapped_device *alloc_dev(int minor)
2302	{
2303	int r, numa_node_id = dm_get_numa_node();
2304	struct dax_device *dax_dev;
2305	struct mapped_device *md;
2306	void *old_md;
2307
2308	md = kvzalloc_node(sizeof(*md), GFP_KERNEL, numa_node_id);
2309	if (!md) {
2310	DMERR("unable to allocate device, out of memory.");
2311	return NULL;
2312	}
2313
2314	if (!try_module_get(THIS_MODULE))
2315	goto bad_module_get;
2316
2317	/* get a minor number for the dev */
2318	if (minor == DM_ANY_MINOR)
2319	r = next_free_minor(&minor);
2320	else
2321	r = specific_minor(minor);
2322	if (r < 0)
2323	goto bad_minor;
2324
2325	r = init_srcu_struct(&md->io_barrier);
2326	if (r < 0)
2327	goto bad_io_barrier;
2328
2329	md->numa_node_id = numa_node_id;
2330	md->init_tio_pdu = false;
2331	md->type = DM_TYPE_NONE;
2332	mutex_init(&md->suspend_lock);
2333	mutex_init(&md->type_lock);
2334	mutex_init(&md->table_devices_lock);
2335	spin_lock_init(&md->deferred_lock);
2336	atomic_set(&md->holders, 1);
2337	atomic_set(&md->open_count, 0);
2338	atomic_set(&md->event_nr, 0);
2339	atomic_set(&md->uevent_seq, 0);
2340	INIT_LIST_HEAD(&md->uevent_list);
2341	INIT_LIST_HEAD(&md->table_devices);
2342	spin_lock_init(&md->uevent_lock);
2343
2344	/*
2345	* default to bio-based until DM table is loaded and md->type
2346	* established. If request-based table is loaded: blk-mq will
2347	* override accordingly.
2348	*/
2349	md->disk = blk_alloc_disk(NULL, md->numa_node_id);
2350	if (IS_ERR(md->disk)) {
2351	md->disk = NULL;
2352	goto bad;
2353	}
2354	md->queue = md->disk->queue;
2355
2356	init_waitqueue_head(&md->wait);
2357	INIT_WORK(&md->work, dm_wq_work);
2358	INIT_WORK(&md->requeue_work, dm_wq_requeue_work);
2359	init_waitqueue_head(&md->eventq);
2360	init_completion(&md->kobj_holder.completion);
2361
2362	md->requeue_list = NULL;
2363	md->swap_bios = get_swap_bios();
2364	sema_init(&md->swap_bios_semaphore, md->swap_bios);
2365	mutex_init(&md->swap_bios_lock);
2366
2367	md->disk->major = _major;
2368	md->disk->first_minor = minor;
2369	md->disk->minors = 1;
2370	md->disk->flags \|= GENHD_FL_NO_PART;
2371	md->disk->fops = &dm_blk_dops;
2372	md->disk->private_data = md;
2373	sprintf(md->disk->disk_name, "dm-%d", minor);
2374
2375	dax_dev = alloc_dax(md, &dm_dax_ops);
2376	if (IS_ERR(dax_dev)) {
2377	if (PTR_ERR(dax_dev) != -EOPNOTSUPP)
2378	goto bad;
2379	} else {
2380	set_dax_nocache(dax_dev);
2381	set_dax_nomc(dax_dev);
2382	md->dax_dev = dax_dev;
2383	if (dax_add_host(dax_dev, md->disk))
2384	goto bad;
2385	}
2386
2387	format_dev_t(md->name, MKDEV(_major, minor));
2388
2389	md->wq = alloc_workqueue("kdmflush/%s", WQ_MEM_RECLAIM \| WQ_PERCPU, 0,
2390	md->name);
2391	if (!md->wq)
2392	goto bad;
2393
2394	md->pending_io = alloc_percpu(unsigned long);
2395	if (!md->pending_io)
2396	goto bad;
2397
2398	r = dm_stats_init(&md->stats);
2399	if (r < 0)
2400	goto bad;
2401
2402	/* Populate the mapping, nobody knows we exist yet */
2403	spin_lock(&_minor_lock);
2404	old_md = idr_replace(&_minor_idr, md, minor);
2405	spin_unlock(&_minor_lock);
2406
2407	BUG_ON(old_md != MINOR_ALLOCED);
2408
2409	return md;
2410
2411	bad:
2412	cleanup_mapped_device(md);
2413	bad_io_barrier:
2414	free_minor(minor);
2415	bad_minor:
2416	module_put(THIS_MODULE);
2417	bad_module_get:
2418	kvfree(md);
2419	return NULL;
2420	}
2421
2422	static void unlock_fs(struct mapped_device *md);
2423
2424	static void free_dev(struct mapped_device *md)
2425	{
2426	int minor = MINOR(disk_devt(md->disk));
2427
2428	unlock_fs(md);
2429
2430	cleanup_mapped_device(md);
2431
2432	WARN_ON_ONCE(!list_empty(&md->table_devices));
2433	dm_stats_cleanup(&md->stats);
2434	free_minor(minor);
2435
2436	module_put(THIS_MODULE);
2437	kvfree(md);
2438	}
2439
2440	/*
2441	* Bind a table to the device.
2442	*/
2443	static void event_callback(void *context)
2444	{
2445	unsigned long flags;
2446	LIST_HEAD(uevents);
2447	struct mapped_device *md = context;
2448
2449	spin_lock_irqsave(&md->uevent_lock, flags);
2450	list_splice_init(&md->uevent_list, &uevents);
2451	spin_unlock_irqrestore(&md->uevent_lock, flags);
2452
2453	dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
2454
2455	atomic_inc(&md->event_nr);
2456	wake_up(&md->eventq);
2457	dm_issue_global_event();
2458	}
2459
2460	/*
2461	* Returns old map, which caller must destroy.
2462	*/
2463	static struct dm_table __bind(struct mapped_device md, struct dm_table *t,
2464	struct queue_limits *limits)
2465	{
2466	struct dm_table *old_map;
2467	sector_t size, old_size;
2468
2469	lockdep_assert_held(&md->suspend_lock);
2470
2471	size = dm_table_get_size(t);
2472
2473	old_size = dm_get_size(md);
2474
2475	if (!dm_table_supports_size_change(t, old_size, size)) {
2476	old_map = ERR_PTR(-EINVAL);
2477	goto out;
2478	}
2479
2480	set_capacity(md->disk, size);
2481
2482	if (limits) {
2483	int ret = dm_table_set_restrictions(t, md->queue, limits);
2484	if (ret) {
2485	set_capacity(md->disk, old_size);
2486	old_map = ERR_PTR(ret);
2487	goto out;
2488	}
2489	}
2490
2491	/*
2492	* Wipe any geometry if the size of the table changed.
2493	*/
2494	if (size != old_size)
2495	memset(&md->geometry, 0, sizeof(md->geometry));
2496
2497	dm_table_event_callback(t, event_callback, md);
2498
2499	if (dm_table_request_based(t)) {
2500	/*
2501	* Leverage the fact that request-based DM targets are
2502	* immutable singletons - used to optimize dm_mq_queue_rq.
2503	*/
2504	md->immutable_target = dm_table_get_immutable_target(t);
2505
2506	/*
2507	* There is no need to reload with request-based dm because the
2508	* size of front_pad doesn't change.
2509	*
2510	* Note for future: If you are to reload bioset, prep-ed
2511	* requests in the queue may refer to bio from the old bioset,
2512	* so you must walk through the queue to unprep.
2513	*/
2514	if (!md->mempools)
2515	md->mempools = t->mempools;
2516	else
2517	dm_free_md_mempools(t->mempools);
2518	} else {
2519	/*
2520	* The md may already have mempools that need changing.
2521	* If so, reload bioset because front_pad may have changed
2522	* because a different table was loaded.
2523	*/
2524	dm_free_md_mempools(md->mempools);
2525	md->mempools = t->mempools;
2526	}
2527	t->mempools = NULL;
2528
2529	old_map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
2530	rcu_assign_pointer(md->map, (void *)t);
2531	md->immutable_target_type = dm_table_get_immutable_target_type(t);
2532
2533	if (old_map)
2534	dm_sync_table(md);
2535	out:
2536	return old_map;
2537	}
2538
2539	/*
2540	* Returns unbound table for the caller to free.
2541	*/
2542	static struct dm_table __unbind(struct mapped_device md)
2543	{
2544	struct dm_table *map = rcu_dereference_protected(md->map, 1);
2545
2546	if (!map)
2547	return NULL;
2548
2549	dm_table_event_callback(map, NULL, NULL);
2550	RCU_INIT_POINTER(md->map, NULL);
2551	dm_sync_table(md);
2552
2553	return map;
2554	}
2555
2556	/*
2557	* Constructor for a new device.
2558	*/
2559	int dm_create(int minor, struct mapped_device **result)
2560	{
2561	struct mapped_device *md;
2562
2563	md = alloc_dev(minor);
2564	if (!md)
2565	return -ENXIO;
2566
2567	dm_ima_init(md);
2568
2569	*result = md;
2570	return 0;
2571	}
2572
2573	/*
2574	* Functions to manage md->type.
2575	* All are required to hold md->type_lock.
2576	*/
2577	void dm_lock_md_type(struct mapped_device *md)
2578	{
2579	mutex_lock(&md->type_lock);
2580	}
2581
2582	void dm_unlock_md_type(struct mapped_device *md)
2583	{
2584	mutex_unlock(&md->type_lock);
2585	}
2586
2587	enum dm_queue_mode dm_get_md_type(struct mapped_device *md)
2588	{
2589	return md->type;
2590	}
2591
2592	struct target_type dm_get_immutable_target_type(struct mapped_device md)
2593	{
2594	return md->immutable_target_type;
2595	}
2596
2597	/*
2598	* Setup the DM device's queue based on md's type
2599	*/
2600	int dm_setup_md_queue(struct mapped_device md, struct dm_table t)
2601	{
2602	enum dm_queue_mode type = dm_table_get_type(t);
2603	struct queue_limits limits;
2604	struct table_device *td;
2605	int r;
2606
2607	WARN_ON_ONCE(type == DM_TYPE_NONE);
2608
2609	if (type == DM_TYPE_REQUEST_BASED) {
2610	md->disk->fops = &dm_rq_blk_dops;
2611	r = dm_mq_init_request_queue(md, t);
2612	if (r) {
2613	DMERR("Cannot initialize queue for request-based dm mapped device");
2614	return r;
2615	}
2616	}
2617
2618	r = dm_calculate_queue_limits(t, &limits);
2619	if (r) {
2620	DMERR("Cannot calculate initial queue limits");
2621	return r;
2622	}
2623	r = dm_table_set_restrictions(t, md->queue, &limits);
2624	if (r)
2625	return r;
2626
2627	/*
2628	* Hold lock to make sure add_disk() and del_gendisk() won't concurrent
2629	* with open_table_device() and close_table_device().
2630	*/
2631	mutex_lock(&md->table_devices_lock);
2632	r = add_disk(md->disk);
2633	if (r) {
2634	mutex_unlock(&md->table_devices_lock);
2635	return r;
2636	}
2637
2638	/*
2639	* Register the holder relationship for devices added before the disk
2640	* was live.
2641	*/
2642	list_for_each_entry(td, &md->table_devices, list) {
2643	r = bd_link_disk_holder(td->dm_dev.bdev, md->disk);
2644	if (r)
2645	goto out_undo_holders;
2646	}
2647	mutex_unlock(&md->table_devices_lock);
2648
2649	r = dm_sysfs_init(md);
2650	if (r)
2651	goto lock_out_undo_holders;
2652
2653	md->type = type;
2654
2655	return 0;
2656
2657	lock_out_undo_holders:
2658	mutex_lock(&md->table_devices_lock);
2659	out_undo_holders:
2660	list_for_each_entry_continue_reverse(td, &md->table_devices, list)
2661	bd_unlink_disk_holder(td->dm_dev.bdev, md->disk);
2662	del_gendisk(md->disk);
2663	mutex_unlock(&md->table_devices_lock);
2664	return r;
2665	}
2666
2667	struct mapped_device *dm_get_md(dev_t dev)
2668	{
2669	struct mapped_device *md;
2670	unsigned int minor = MINOR(dev);
2671
2672	if (MAJOR(dev) != _major \|\| minor >= (1 << MINORBITS))
2673	return NULL;
2674
2675	spin_lock(&_minor_lock);
2676
2677	md = idr_find(&_minor_idr, minor);
2678	if (!md \|\| md == MINOR_ALLOCED \|\| (MINOR(disk_devt(dm_disk(md))) != minor) \|\|
2679	test_bit(DMF_FREEING, &md->flags) \|\| dm_deleting_md(md)) {
2680	md = NULL;
2681	goto out;
2682	}
2683	dm_get(md);
2684	out:
2685	spin_unlock(&_minor_lock);
2686
2687	return md;
2688	}
2689	EXPORT_SYMBOL_GPL(dm_get_md);
2690
2691	void dm_get_mdptr(struct mapped_device md)
2692	{
2693	return md->interface_ptr;
2694	}
2695
2696	void dm_set_mdptr(struct mapped_device md, void ptr)
2697	{
2698	md->interface_ptr = ptr;
2699	}
2700
2701	void dm_get(struct mapped_device *md)
2702	{
2703	atomic_inc(&md->holders);
2704	BUG_ON(test_bit(DMF_FREEING, &md->flags));
2705	}
2706
2707	int dm_hold(struct mapped_device *md)
2708	{
2709	spin_lock(&_minor_lock);
2710	if (test_bit(DMF_FREEING, &md->flags)) {
2711	spin_unlock(&_minor_lock);
2712	return -EBUSY;
2713	}
2714	dm_get(md);
2715	spin_unlock(&_minor_lock);
2716	return 0;
2717	}
2718	EXPORT_SYMBOL_GPL(dm_hold);
2719
2720	const char dm_device_name(struct mapped_device md)
2721	{
2722	return md->name;
2723	}
2724	EXPORT_SYMBOL_GPL(dm_device_name);
2725
2726	static void __dm_destroy(struct mapped_device *md, bool wait)
2727	{
2728	struct dm_table *map;
2729	int srcu_idx;
2730
2731	might_sleep();
2732
2733	spin_lock(&_minor_lock);
2734	idr_replace(&_minor_idr, MINOR_ALLOCED, MINOR(disk_devt(dm_disk(md))));
2735	set_bit(DMF_FREEING, &md->flags);
2736	spin_unlock(&_minor_lock);
2737
2738	blk_mark_disk_dead(md->disk);
2739
2740	/*
2741	* Take suspend_lock so that presuspend and postsuspend methods
2742	* do not race with internal suspend.
2743	*/
2744	mutex_lock(&md->suspend_lock);
2745	map = dm_get_live_table(md, &srcu_idx);
2746	if (!dm_suspended_md(md)) {
2747	dm_table_presuspend_targets(map);
2748	set_bit(DMF_SUSPENDED, &md->flags);
2749	set_bit(DMF_POST_SUSPENDING, &md->flags);
2750	dm_table_postsuspend_targets(map);
2751	}
2752	/* dm_put_live_table must be before fsleep, otherwise deadlock is possible */
2753	dm_put_live_table(md, srcu_idx);
2754	mutex_unlock(&md->suspend_lock);
2755
2756	/*
2757	* Rare, but there may be I/O requests still going to complete,
2758	* for example. Wait for all references to disappear.
2759	* No one should increment the reference count of the mapped_device,
2760	* after the mapped_device state becomes DMF_FREEING.
2761	*/
2762	if (wait)
2763	while (atomic_read(&md->holders))
2764	fsleep(1000);
2765	else if (atomic_read(&md->holders))
2766	DMWARN("%s: Forcibly removing mapped_device still in use! (%d users)",
2767	dm_device_name(md), atomic_read(&md->holders));
2768
2769	dm_table_destroy(__unbind(md));
2770	free_dev(md);
2771	}
2772
2773	void dm_destroy(struct mapped_device *md)
2774	{
2775	__dm_destroy(md, true);
2776	}
2777
2778	void dm_destroy_immediate(struct mapped_device *md)
2779	{
2780	__dm_destroy(md, false);
2781	}
2782
2783	void dm_put(struct mapped_device *md)
2784	{
2785	atomic_dec(&md->holders);
2786	}
2787	EXPORT_SYMBOL_GPL(dm_put);
2788
2789	static bool dm_in_flight_bios(struct mapped_device *md)
2790	{
2791	int cpu;
2792	unsigned long sum = 0;
2793
2794	for_each_possible_cpu(cpu)
2795	sum += *per_cpu_ptr(md->pending_io, cpu);
2796
2797	return sum != 0;
2798	}
2799
2800	static int dm_wait_for_bios_completion(struct mapped_device *md, unsigned int task_state)
2801	{
2802	int r = 0;
2803	DEFINE_WAIT(wait);
2804
2805	while (true) {
2806	prepare_to_wait(&md->wait, &wait, task_state);
2807
2808	if (!dm_in_flight_bios(md))
2809	break;
2810
2811	if (signal_pending_state(task_state, current)) {
2812	r = -ERESTARTSYS;
2813	break;
2814	}
2815
2816	io_schedule();
2817	}
2818	finish_wait(&md->wait, &wait);
2819
2820	smp_rmb();
2821
2822	return r;
2823	}
2824
2825	static int dm_wait_for_completion(struct mapped_device *md, unsigned int task_state)
2826	{
2827	int r = 0;
2828
2829	if (!queue_is_mq(md->queue))
2830	return dm_wait_for_bios_completion(md, task_state);
2831
2832	while (true) {
2833	if (!blk_mq_queue_inflight(md->queue))
2834	break;
2835
2836	if (signal_pending_state(task_state, current)) {
2837	r = -ERESTARTSYS;
2838	break;
2839	}
2840
2841	fsleep(5000);
2842	}
2843
2844	return r;
2845	}
2846
2847	/*
2848	* Process the deferred bios
2849	*/
2850	static void dm_wq_work(struct work_struct *work)
2851	{
2852	struct mapped_device *md = container_of(work, struct mapped_device, work);
2853	struct bio *bio;
2854
2855	while (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
2856	spin_lock_irq(&md->deferred_lock);
2857	bio = bio_list_pop(&md->deferred);
2858	spin_unlock_irq(&md->deferred_lock);
2859
2860	if (!bio)
2861	break;
2862
2863	submit_bio_noacct(bio);
2864	cond_resched();
2865	}
2866	}
2867
2868	static void dm_queue_flush(struct mapped_device *md)
2869	{
2870	clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2871	clear_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
2872	smp_mb__after_atomic();
2873	queue_work(md->wq, &md->work);
2874	}
2875
2876	/*
2877	* Swap in a new table, returning the old one for the caller to destroy.
2878	*/
2879	struct dm_table dm_swap_table(struct mapped_device md, struct dm_table *table)
2880	{
2881	struct dm_table live_map = NULL, map = ERR_PTR(-EINVAL);
2882	struct queue_limits limits;
2883	bool update_limits = true;
2884	int r;
2885
2886	mutex_lock(&md->suspend_lock);
2887
2888	/* device must be suspended */
2889	if (!dm_suspended_md(md))
2890	goto out;
2891
2892	/*
2893	* To avoid a potential deadlock locking the queue limits, disallow
2894	* updating the queue limits during a table swap, when updating an
2895	* immutable request-based dm device (dm-multipath) during a noflush
2896	* suspend. It is userspace's responsibility to make sure that the new
2897	* table uses the same limits as the existing table, if it asks for a
2898	* noflush suspend.
2899	*/
2900	if (dm_request_based(md) && md->immutable_target &&
2901	__noflush_suspending(md))
2902	update_limits = false;
2903	/*
2904	* If the new table has no data devices, retain the existing limits.
2905	* This helps multipath with queue_if_no_path if all paths disappear,
2906	* then new I/O is queued based on these limits, and then some paths
2907	* reappear.
2908	*/
2909	else if (dm_table_has_no_data_devices(table)) {
2910	live_map = dm_get_live_table_fast(md);
2911	if (live_map)
2912	limits = md->queue->limits;
2913	dm_put_live_table_fast(md);
2914	}
2915
2916	if (update_limits && !live_map) {
2917	r = dm_calculate_queue_limits(table, &limits);
2918	if (r) {
2919	map = ERR_PTR(r);
2920	goto out;
2921	}
2922	}
2923
2924	map = __bind(md, table, update_limits ? &limits : NULL);
2925	dm_issue_global_event();
2926
2927	out:
2928	mutex_unlock(&md->suspend_lock);
2929	return map;
2930	}
2931
2932	/*
2933	* Functions to lock and unlock any filesystem running on the
2934	* device.
2935	*/
2936	static int lock_fs(struct mapped_device *md)
2937	{
2938	int r;
2939
2940	WARN_ON(test_bit(DMF_FROZEN, &md->flags));
2941
2942	r = bdev_freeze(md->disk->part0);
2943	if (!r)
2944	set_bit(DMF_FROZEN, &md->flags);
2945	return r;
2946	}
2947
2948	static void unlock_fs(struct mapped_device *md)
2949	{
2950	if (!test_bit(DMF_FROZEN, &md->flags))
2951	return;
2952	bdev_thaw(md->disk->part0);
2953	clear_bit(DMF_FROZEN, &md->flags);
2954	}
2955
2956	/*
2957	* @suspend_flags: DM_SUSPEND_LOCKFS_FLAG and/or DM_SUSPEND_NOFLUSH_FLAG
2958	* @task_state: e.g. TASK_INTERRUPTIBLE or TASK_UNINTERRUPTIBLE
2959	* @dmf_suspended_flag: DMF_SUSPENDED or DMF_SUSPENDED_INTERNALLY
2960	*
2961	* If __dm_suspend returns 0, the device is completely quiescent
2962	* now. There is no request-processing activity. All new requests
2963	* are being added to md->deferred list.
2964	*/
2965	static int __dm_suspend(struct mapped_device md, struct dm_table map,
2966	unsigned int suspend_flags, unsigned int task_state,
2967	int dmf_suspended_flag)
2968	{
2969	bool do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG;
2970	bool noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG;
2971	int r = 0;
2972
2973	lockdep_assert_held(&md->suspend_lock);
2974
2975	/*
2976	* DMF_NOFLUSH_SUSPENDING must be set before presuspend.
2977	*/
2978	if (noflush)
2979	set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
2980	else
2981	DMDEBUG("%s: suspending with flush", dm_device_name(md));
2982
2983	/*
2984	* This gets reverted if there's an error later and the targets
2985	* provide the .presuspend_undo hook.
2986	*/
2987	dm_table_presuspend_targets(map);
2988
2989	/*
2990	* Flush I/O to the device.
2991	* Any I/O submitted after lock_fs() may not be flushed.
2992	* noflush takes precedence over do_lockfs.
2993	* (lock_fs() flushes I/Os and waits for them to complete.)
2994	*/
2995	if (!noflush && do_lockfs) {
2996	r = lock_fs(md);
2997	if (r) {
2998	dm_table_presuspend_undo_targets(map);
2999	return r;
3000	}
3001	}
3002
3003	/*
3004	* Here we must make sure that no processes are submitting requests
3005	* to target drivers i.e. no one may be executing
3006	* dm_split_and_process_bio from dm_submit_bio.
3007	*
3008	* To get all processes out of dm_split_and_process_bio in dm_submit_bio,
3009	* we take the write lock. To prevent any process from reentering
3010	* dm_split_and_process_bio from dm_submit_bio and quiesce the thread
3011	* (dm_wq_work), we set DMF_BLOCK_IO_FOR_SUSPEND and call
3012	* flush_workqueue(md->wq).
3013	*/
3014	set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
3015	if (map)
3016	synchronize_srcu(&md->io_barrier);
3017
3018	/*
3019	* Stop md->queue before flushing md->wq in case request-based
3020	* dm defers requests to md->wq from md->queue.
3021	*/
3022	if (map && dm_request_based(md)) {
3023	dm_stop_queue(md->queue);
3024	set_bit(DMF_QUEUE_STOPPED, &md->flags);
3025	}
3026
3027	flush_workqueue(md->wq);
3028
3029	/*
3030	* At this point no more requests are entering target request routines.
3031	* We call dm_wait_for_completion to wait for all existing requests
3032	* to finish.
3033	*/
3034	if (map)
3035	r = dm_wait_for_completion(md, task_state);
3036	if (!r)
3037	set_bit(dmf_suspended_flag, &md->flags);
3038
3039	if (map)
3040	synchronize_srcu(&md->io_barrier);
3041
3042	/* were we interrupted ? */
3043	if (r < 0) {
3044	dm_queue_flush(md);
3045
3046	if (test_and_clear_bit(DMF_QUEUE_STOPPED, &md->flags))
3047	dm_start_queue(md->queue);
3048
3049	unlock_fs(md);
3050	dm_table_presuspend_undo_targets(map);
3051	/* pushback list is already flushed, so skip flush */
3052	}
3053
3054	return r;
3055	}
3056
3057	/*
3058	* We need to be able to change a mapping table under a mounted
3059	* filesystem. For example we might want to move some data in
3060	* the background. Before the table can be swapped with
3061	* dm_bind_table, dm_suspend must be called to flush any in
3062	* flight bios and ensure that any further io gets deferred.
3063	*/
3064	/*
3065	* Suspend mechanism in request-based dm.
3066	*
3067	* 1. Flush all I/Os by lock_fs() if needed.
3068	* 2. Stop dispatching any I/O by stopping the request_queue.
3069	* 3. Wait for all in-flight I/Os to be completed or requeued.
3070	*
3071	* To abort suspend, start the request_queue.
3072	*/
3073	int dm_suspend(struct mapped_device *md, unsigned int suspend_flags)
3074	{
3075	struct dm_table *map = NULL;
3076	int r = 0;
3077
3078	retry:
3079	mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
3080
3081	if (dm_suspended_md(md)) {
3082	r = -EINVAL;
3083	goto out_unlock;
3084	}
3085
3086	if (dm_suspended_internally_md(md)) {
3087	/* already internally suspended, wait for internal resume */
3088	mutex_unlock(&md->suspend_lock);
3089	r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
3090	if (r)
3091	return r;
3092	goto retry;
3093	}
3094
3095	map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
3096	if (!map) {
3097	/* avoid deadlock with fs/namespace.c:do_mount() */
3098	suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG;
3099	}
3100
3101	r = __dm_suspend(md, map, suspend_flags, TASK_INTERRUPTIBLE, DMF_SUSPENDED);
3102	if (r)
3103	goto out_unlock;
3104
3105	set_bit(DMF_POST_SUSPENDING, &md->flags);
3106	dm_table_postsuspend_targets(map);
3107	clear_bit(DMF_POST_SUSPENDING, &md->flags);
3108
3109	out_unlock:
3110	mutex_unlock(&md->suspend_lock);
3111	return r;
3112	}
3113
3114	static int __dm_resume(struct mapped_device md, struct dm_table map)
3115	{
3116	if (map) {
3117	int r = dm_table_resume_targets(map);
3118
3119	if (r)
3120	return r;
3121	}
3122
3123	dm_queue_flush(md);
3124
3125	/*
3126	* Flushing deferred I/Os must be done after targets are resumed
3127	* so that mapping of targets can work correctly.
3128	* Request-based dm is queueing the deferred I/Os in its request_queue.
3129	*/
3130	if (test_and_clear_bit(DMF_QUEUE_STOPPED, &md->flags))
3131	dm_start_queue(md->queue);
3132
3133	unlock_fs(md);
3134
3135	return 0;
3136	}
3137
3138	int dm_resume(struct mapped_device *md)
3139	{
3140	int r;
3141	struct dm_table *map = NULL;
3142
3143	retry:
3144	r = -EINVAL;
3145	mutex_lock_nested(&md->suspend_lock, SINGLE_DEPTH_NESTING);
3146
3147	if (!dm_suspended_md(md) \|\| test_bit(DMF_FREEING, &md->flags))
3148	goto out;
3149
3150	if (dm_suspended_internally_md(md)) {
3151	/* already internally suspended, wait for internal resume */
3152	mutex_unlock(&md->suspend_lock);
3153	r = wait_on_bit(&md->flags, DMF_SUSPENDED_INTERNALLY, TASK_INTERRUPTIBLE);
3154	if (r)
3155	return r;
3156	goto retry;
3157	}
3158
3159	map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
3160	if (!map \|\| !dm_table_get_size(map))
3161	goto out;
3162
3163	r = __dm_resume(md, map);
3164	if (r)
3165	goto out;
3166
3167	clear_bit(DMF_SUSPENDED, &md->flags);
3168	out:
3169	mutex_unlock(&md->suspend_lock);
3170
3171	return r;
3172	}
3173
3174	/*
3175	* Internal suspend/resume works like userspace-driven suspend. It waits
3176	* until all bios finish and prevents issuing new bios to the target drivers.
3177	* It may be used only from the kernel.
3178	*/
3179
3180	static void __dm_internal_suspend(struct mapped_device *md, unsigned int suspend_flags)
3181	{
3182	struct dm_table *map = NULL;
3183
3184	lockdep_assert_held(&md->suspend_lock);
3185
3186	if (md->internal_suspend_count++)
3187	return; /* nested internal suspend */
3188
3189	if (dm_suspended_md(md)) {
3190	set_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
3191	return; /* nest suspend */
3192	}
3193
3194	map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
3195
3196	/*
3197	* Using TASK_UNINTERRUPTIBLE because only NOFLUSH internal suspend is
3198	* supported. Properly supporting a TASK_INTERRUPTIBLE internal suspend
3199	* would require changing .presuspend to return an error -- avoid this
3200	* until there is a need for more elaborate variants of internal suspend.
3201	*/
3202	(void) __dm_suspend(md, map, suspend_flags, TASK_UNINTERRUPTIBLE,
3203	DMF_SUSPENDED_INTERNALLY);
3204
3205	set_bit(DMF_POST_SUSPENDING, &md->flags);
3206	dm_table_postsuspend_targets(map);
3207	clear_bit(DMF_POST_SUSPENDING, &md->flags);
3208	}
3209
3210	static void __dm_internal_resume(struct mapped_device *md)
3211	{
3212	int r;
3213	struct dm_table *map;
3214
3215	BUG_ON(!md->internal_suspend_count);
3216
3217	if (--md->internal_suspend_count)
3218	return; /* resume from nested internal suspend */
3219
3220	if (dm_suspended_md(md))
3221	goto done; /* resume from nested suspend */
3222
3223	map = rcu_dereference_protected(md->map, lockdep_is_held(&md->suspend_lock));
3224	r = __dm_resume(md, map);
3225	if (r) {
3226	/*
3227	* If a preresume method of some target failed, we are in a
3228	* tricky situation. We can't return an error to the caller. We
3229	* can't fake success because then the "resume" and
3230	* "postsuspend" methods would not be paired correctly, and it
3231	* would break various targets, for example it would cause list
3232	* corruption in the "origin" target.
3233	*
3234	* So, we fake normal suspend here, to make sure that the
3235	* "resume" and "postsuspend" methods will be paired correctly.
3236	*/
3237	DMERR("Preresume method failed: %d", r);
3238	set_bit(DMF_SUSPENDED, &md->flags);
3239	}
3240	done:
3241	clear_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
3242	smp_mb__after_atomic();
3243	wake_up_bit(&md->flags, DMF_SUSPENDED_INTERNALLY);
3244	}
3245
3246	void dm_internal_suspend_noflush(struct mapped_device *md)
3247	{
3248	mutex_lock(&md->suspend_lock);
3249	__dm_internal_suspend(md, DM_SUSPEND_NOFLUSH_FLAG);
3250	mutex_unlock(&md->suspend_lock);
3251	}
3252	EXPORT_SYMBOL_GPL(dm_internal_suspend_noflush);
3253
3254	void dm_internal_resume(struct mapped_device *md)
3255	{
3256	mutex_lock(&md->suspend_lock);
3257	__dm_internal_resume(md);
3258	mutex_unlock(&md->suspend_lock);
3259	}
3260	EXPORT_SYMBOL_GPL(dm_internal_resume);
3261
3262	/*
3263	* Fast variants of internal suspend/resume hold md->suspend_lock,
3264	* which prevents interaction with userspace-driven suspend.
3265	*/
3266
3267	void dm_internal_suspend_fast(struct mapped_device *md)
3268	{
3269	mutex_lock(&md->suspend_lock);
3270	if (dm_suspended_md(md) \|\| dm_suspended_internally_md(md))
3271	return;
3272
3273	set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
3274	synchronize_srcu(&md->io_barrier);
3275	flush_workqueue(md->wq);
3276	dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
3277	}
3278	EXPORT_SYMBOL_GPL(dm_internal_suspend_fast);
3279
3280	void dm_internal_resume_fast(struct mapped_device *md)
3281	{
3282	if (dm_suspended_md(md) \|\| dm_suspended_internally_md(md))
3283	goto done;
3284
3285	dm_queue_flush(md);
3286
3287	done:
3288	mutex_unlock(&md->suspend_lock);
3289	}
3290	EXPORT_SYMBOL_GPL(dm_internal_resume_fast);
3291
3292	/*
3293	*---------------------------------------------------------------
3294	* Event notification.
3295	*---------------------------------------------------------------
3296	*/
3297	int dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
3298	unsigned int cookie, bool need_resize_uevent)
3299	{
3300	int r;
3301	unsigned int noio_flag;
3302	char udev_cookie[DM_COOKIE_LENGTH];
3303	char *envp[3] = { NULL, NULL, NULL };
3304	char **envpp = envp;
3305	if (cookie) {
3306	snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
3307	DM_COOKIE_ENV_VAR_NAME, cookie);
3308	*envpp++ = udev_cookie;
3309	}
3310	if (need_resize_uevent) {
3311	*envpp++ = "RESIZE=1";
3312	}
3313
3314	noio_flag = memalloc_noio_save();
3315
3316	r = kobject_uevent_env(&disk_to_dev(md->disk)->kobj, action, envp);
3317
3318	memalloc_noio_restore(noio_flag);
3319
3320	return r;
3321	}
3322
3323	uint32_t dm_next_uevent_seq(struct mapped_device *md)
3324	{
3325	return atomic_add_return(1, &md->uevent_seq);
3326	}
3327
3328	uint32_t dm_get_event_nr(struct mapped_device *md)
3329	{
3330	return atomic_read(&md->event_nr);
3331	}
3332
3333	int dm_wait_event(struct mapped_device *md, int event_nr)
3334	{
3335	return wait_event_interruptible(md->eventq,
3336	(event_nr != atomic_read(&md->event_nr)));
3337	}
3338
3339	void dm_uevent_add(struct mapped_device md, struct list_head elist)
3340	{
3341	unsigned long flags;
3342
3343	spin_lock_irqsave(&md->uevent_lock, flags);
3344	list_add(elist, &md->uevent_list);
3345	spin_unlock_irqrestore(&md->uevent_lock, flags);
3346	}
3347
3348	/*
3349	* The gendisk is only valid as long as you have a reference
3350	* count on 'md'.
3351	*/
3352	struct gendisk dm_disk(struct mapped_device md)
3353	{
3354	return md->disk;
3355	}
3356	EXPORT_SYMBOL_GPL(dm_disk);
3357
3358	struct kobject dm_kobject(struct mapped_device md)
3359	{
3360	return &md->kobj_holder.kobj;
3361	}
3362
3363	struct mapped_device dm_get_from_kobject(struct kobject kobj)
3364	{
3365	struct mapped_device *md;
3366
3367	md = container_of(kobj, struct mapped_device, kobj_holder.kobj);
3368
3369	spin_lock(&_minor_lock);
3370	if (test_bit(DMF_FREEING, &md->flags) \|\| dm_deleting_md(md)) {
3371	md = NULL;
3372	goto out;
3373	}
3374	dm_get(md);
3375	out:
3376	spin_unlock(&_minor_lock);
3377
3378	return md;
3379	}
3380
3381	int dm_suspended_md(struct mapped_device *md)
3382	{
3383	return test_bit(DMF_SUSPENDED, &md->flags);
3384	}
3385
3386	static int dm_post_suspending_md(struct mapped_device *md)
3387	{
3388	return test_bit(DMF_POST_SUSPENDING, &md->flags);
3389	}
3390
3391	int dm_suspended_internally_md(struct mapped_device *md)
3392	{
3393	return test_bit(DMF_SUSPENDED_INTERNALLY, &md->flags);
3394	}
3395
3396	int dm_test_deferred_remove_flag(struct mapped_device *md)
3397	{
3398	return test_bit(DMF_DEFERRED_REMOVE, &md->flags);
3399	}
3400
3401	int dm_suspended(struct dm_target *ti)
3402	{
3403	return dm_suspended_md(ti->table->md);
3404	}
3405	EXPORT_SYMBOL_GPL(dm_suspended);
3406
3407	int dm_post_suspending(struct dm_target *ti)
3408	{
3409	return dm_post_suspending_md(ti->table->md);
3410	}
3411	EXPORT_SYMBOL_GPL(dm_post_suspending);
3412
3413	int dm_noflush_suspending(struct dm_target *ti)
3414	{
3415	return __noflush_suspending(ti->table->md);
3416	}
3417	EXPORT_SYMBOL_GPL(dm_noflush_suspending);
3418
3419	void dm_free_md_mempools(struct dm_md_mempools *pools)
3420	{
3421	if (!pools)
3422	return;
3423
3424	bioset_exit(&pools->bs);
3425	bioset_exit(&pools->io_bs);
3426
3427	kfree(pools);
3428	}
3429
3430	struct dm_blkdev_id {
3431	u8 *id;
3432	enum blk_unique_id type;
3433	};
3434
3435	static int __dm_get_unique_id(struct dm_target ti, struct dm_dev dev,
3436	sector_t start, sector_t len, void *data)
3437	{
3438	struct dm_blkdev_id *dm_id = data;
3439	const struct block_device_operations *fops = dev->bdev->bd_disk->fops;
3440
3441	if (!fops->get_unique_id)
3442	return 0;
3443
3444	return fops->get_unique_id(dev->bdev->bd_disk, dm_id->id, dm_id->type);
3445	}
3446
3447	/*
3448	* Allow access to get_unique_id() for the first device returning a
3449	* non-zero result. Reasonable use expects all devices to have the
3450	* same unique id.
3451	*/
3452	static int dm_blk_get_unique_id(struct gendisk disk, u8 id,
3453	enum blk_unique_id type)
3454	{
3455	struct mapped_device *md = disk->private_data;
3456	struct dm_table *table;
3457	struct dm_target *ti;
3458	int ret = 0, srcu_idx;
3459
3460	struct dm_blkdev_id dm_id = {
3461	.id = id,
3462	.type = type,
3463	};
3464
3465	table = dm_get_live_table(md, &srcu_idx);
3466	if (!table \|\| !dm_table_get_size(table))
3467	goto out;
3468
3469	/* We only support devices that have a single target */
3470	if (table->num_targets != 1)
3471	goto out;
3472	ti = dm_table_get_target(table, 0);
3473
3474	if (!ti->type->iterate_devices)
3475	goto out;
3476
3477	ret = ti->type->iterate_devices(ti, __dm_get_unique_id, &dm_id);
3478	out:
3479	dm_put_live_table(md, srcu_idx);
3480	return ret;
3481	}
3482
3483	struct dm_pr {
3484	u64 old_key;
3485	u64 new_key;
3486	u32 flags;
3487	bool abort;
3488	bool fail_early;
3489	int ret;
3490	enum pr_type type;
3491	struct pr_keys *read_keys;
3492	struct pr_held_reservation *rsv;
3493	};
3494
3495	static int dm_call_pr(struct block_device *bdev, iterate_devices_callout_fn fn,
3496	struct dm_pr *pr)
3497	{
3498	struct mapped_device *md = bdev->bd_disk->private_data;
3499	struct dm_table *table;
3500	struct dm_target *ti;
3501	int ret = -ENOTTY, srcu_idx;
3502
3503	table = dm_get_live_table(md, &srcu_idx);
3504	if (!table \|\| !dm_table_get_size(table))
3505	goto out;
3506
3507	/* We only support devices that have a single target */
3508	if (table->num_targets != 1)
3509	goto out;
3510	ti = dm_table_get_target(table, 0);
3511
3512	if (dm_suspended_md(md)) {
3513	ret = -EAGAIN;
3514	goto out;
3515	}
3516
3517	ret = -EINVAL;
3518	if (!ti->type->iterate_devices)
3519	goto out;
3520
3521	ti->type->iterate_devices(ti, fn, pr);
3522	ret = 0;
3523	out:
3524	dm_put_live_table(md, srcu_idx);
3525	return ret;
3526	}
3527
3528	/*
3529	* For register / unregister we need to manually call out to every path.
3530	*/
3531	static int __dm_pr_register(struct dm_target ti, struct dm_dev dev,
3532	sector_t start, sector_t len, void *data)
3533	{
3534	struct dm_pr *pr = data;
3535	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3536	int ret;
3537
3538	if (!ops \|\| !ops->pr_register) {
3539	pr->ret = -EOPNOTSUPP;
3540	return -1;
3541	}
3542
3543	ret = ops->pr_register(dev->bdev, pr->old_key, pr->new_key, pr->flags);
3544	if (!ret)
3545	return 0;
3546
3547	if (!pr->ret)
3548	pr->ret = ret;
3549
3550	if (pr->fail_early)
3551	return -1;
3552
3553	return 0;
3554	}
3555
3556	static int dm_pr_register(struct block_device *bdev, u64 old_key, u64 new_key,
3557	u32 flags)
3558	{
3559	struct dm_pr pr = {
3560	.old_key = old_key,
3561	.new_key = new_key,
3562	.flags = flags,
3563	.fail_early = true,
3564	.ret = 0,
3565	};
3566	int ret;
3567
3568	ret = dm_call_pr(bdev, __dm_pr_register, &pr);
3569	if (ret) {
3570	/* Didn't even get to register a path */
3571	return ret;
3572	}
3573
3574	if (!pr.ret)
3575	return 0;
3576	ret = pr.ret;
3577
3578	if (!new_key)
3579	return ret;
3580
3581	/* unregister all paths if we failed to register any path */
3582	pr.old_key = new_key;
3583	pr.new_key = 0;
3584	pr.flags = 0;
3585	pr.fail_early = false;
3586	(void) dm_call_pr(bdev, __dm_pr_register, &pr);
3587	return ret;
3588	}
3589
3590
3591	static int __dm_pr_reserve(struct dm_target ti, struct dm_dev dev,
3592	sector_t start, sector_t len, void *data)
3593	{
3594	struct dm_pr *pr = data;
3595	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3596
3597	if (!ops \|\| !ops->pr_reserve) {
3598	pr->ret = -EOPNOTSUPP;
3599	return -1;
3600	}
3601
3602	pr->ret = ops->pr_reserve(dev->bdev, pr->old_key, pr->type, pr->flags);
3603	if (!pr->ret)
3604	return -1;
3605
3606	return 0;
3607	}
3608
3609	static int dm_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
3610	u32 flags)
3611	{
3612	struct dm_pr pr = {
3613	.old_key = key,
3614	.flags = flags,
3615	.type = type,
3616	.fail_early = false,
3617	.ret = 0,
3618	};
3619	int ret;
3620
3621	ret = dm_call_pr(bdev, __dm_pr_reserve, &pr);
3622	if (ret)
3623	return ret;
3624
3625	return pr.ret;
3626	}
3627
3628	/*
3629	* If there is a non-All Registrants type of reservation, the release must be
3630	* sent down the holding path. For the cases where there is no reservation or
3631	* the path is not the holder the device will also return success, so we must
3632	* try each path to make sure we got the correct path.
3633	*/
3634	static int __dm_pr_release(struct dm_target ti, struct dm_dev dev,
3635	sector_t start, sector_t len, void *data)
3636	{
3637	struct dm_pr *pr = data;
3638	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3639
3640	if (!ops \|\| !ops->pr_release) {
3641	pr->ret = -EOPNOTSUPP;
3642	return -1;
3643	}
3644
3645	pr->ret = ops->pr_release(dev->bdev, pr->old_key, pr->type);
3646	if (pr->ret)
3647	return -1;
3648
3649	return 0;
3650	}
3651
3652	static int dm_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
3653	{
3654	struct dm_pr pr = {
3655	.old_key = key,
3656	.type = type,
3657	.fail_early = false,
3658	};
3659	int ret;
3660
3661	ret = dm_call_pr(bdev, __dm_pr_release, &pr);
3662	if (ret)
3663	return ret;
3664
3665	return pr.ret;
3666	}
3667
3668	static int __dm_pr_preempt(struct dm_target ti, struct dm_dev dev,
3669	sector_t start, sector_t len, void *data)
3670	{
3671	struct dm_pr *pr = data;
3672	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3673
3674	if (!ops \|\| !ops->pr_preempt) {
3675	pr->ret = -EOPNOTSUPP;
3676	return -1;
3677	}
3678
3679	pr->ret = ops->pr_preempt(dev->bdev, pr->old_key, pr->new_key, pr->type,
3680	pr->abort);
3681	if (!pr->ret)
3682	return -1;
3683
3684	return 0;
3685	}
3686
3687	static int dm_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
3688	enum pr_type type, bool abort)
3689	{
3690	struct dm_pr pr = {
3691	.new_key = new_key,
3692	.old_key = old_key,
3693	.type = type,
3694	.fail_early = false,
3695	};
3696	int ret;
3697
3698	ret = dm_call_pr(bdev, __dm_pr_preempt, &pr);
3699	if (ret)
3700	return ret;
3701
3702	return pr.ret;
3703	}
3704
3705	static int dm_pr_clear(struct block_device *bdev, u64 key)
3706	{
3707	struct mapped_device *md = bdev->bd_disk->private_data;
3708	const struct pr_ops *ops;
3709	int r, srcu_idx;
3710	bool forward = true;
3711
3712	/* Not a real ioctl, but targets must not interpret non-DM ioctls */
3713	r = dm_prepare_ioctl(md, &srcu_idx, &bdev, 0, 0, &forward);
3714	if (r < 0)
3715	goto out;
3716	WARN_ON_ONCE(!forward);
3717
3718	ops = bdev->bd_disk->fops->pr_ops;
3719	if (ops && ops->pr_clear)
3720	r = ops->pr_clear(bdev, key);
3721	else
3722	r = -EOPNOTSUPP;
3723	out:
3724	dm_unprepare_ioctl(md, srcu_idx);
3725	return r;
3726	}
3727
3728	static int __dm_pr_read_keys(struct dm_target ti, struct dm_dev dev,
3729	sector_t start, sector_t len, void *data)
3730	{
3731	struct dm_pr *pr = data;
3732	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3733
3734	if (!ops \|\| !ops->pr_read_keys) {
3735	pr->ret = -EOPNOTSUPP;
3736	return -1;
3737	}
3738
3739	pr->ret = ops->pr_read_keys(dev->bdev, pr->read_keys);
3740	if (!pr->ret)
3741	return -1;
3742
3743	return 0;
3744	}
3745
3746	static int dm_pr_read_keys(struct block_device bdev, struct pr_keys keys)
3747	{
3748	struct dm_pr pr = {
3749	.read_keys = keys,
3750	};
3751	int ret;
3752
3753	ret = dm_call_pr(bdev, __dm_pr_read_keys, &pr);
3754	if (ret)
3755	return ret;
3756
3757	return pr.ret;
3758	}
3759
3760	static int __dm_pr_read_reservation(struct dm_target ti, struct dm_dev dev,
3761	sector_t start, sector_t len, void *data)
3762	{
3763	struct dm_pr *pr = data;
3764	const struct pr_ops *ops = dev->bdev->bd_disk->fops->pr_ops;
3765
3766	if (!ops \|\| !ops->pr_read_reservation) {
3767	pr->ret = -EOPNOTSUPP;
3768	return -1;
3769	}
3770
3771	pr->ret = ops->pr_read_reservation(dev->bdev, pr->rsv);
3772	if (!pr->ret)
3773	return -1;
3774
3775	return 0;
3776	}
3777
3778	static int dm_pr_read_reservation(struct block_device *bdev,
3779	struct pr_held_reservation *rsv)
3780	{
3781	struct dm_pr pr = {
3782	.rsv = rsv,
3783	};
3784	int ret;
3785
3786	ret = dm_call_pr(bdev, __dm_pr_read_reservation, &pr);
3787	if (ret)
3788	return ret;
3789
3790	return pr.ret;
3791	}
3792
3793	static const struct pr_ops dm_pr_ops = {
3794	.pr_register = dm_pr_register,
3795	.pr_reserve = dm_pr_reserve,
3796	.pr_release = dm_pr_release,
3797	.pr_preempt = dm_pr_preempt,
3798	.pr_clear = dm_pr_clear,
3799	.pr_read_keys = dm_pr_read_keys,
3800	.pr_read_reservation = dm_pr_read_reservation,
3801	};
3802
3803	static const struct block_device_operations dm_blk_dops = {
3804	.submit_bio = dm_submit_bio,
3805	.poll_bio = dm_poll_bio,
3806	.open = dm_blk_open,
3807	.release = dm_blk_close,
3808	.ioctl = dm_blk_ioctl,
3809	.getgeo = dm_blk_getgeo,
3810	.report_zones = dm_blk_report_zones,
3811	.get_unique_id = dm_blk_get_unique_id,
3812	.pr_ops = &dm_pr_ops,
3813	.owner = THIS_MODULE
3814	};
3815
3816	static const struct block_device_operations dm_rq_blk_dops = {
3817	.open = dm_blk_open,
3818	.release = dm_blk_close,
3819	.ioctl = dm_blk_ioctl,
3820	.getgeo = dm_blk_getgeo,
3821	.get_unique_id = dm_blk_get_unique_id,
3822	.pr_ops = &dm_pr_ops,
3823	.owner = THIS_MODULE
3824	};
3825
3826	static const struct dax_operations dm_dax_ops = {
3827	.direct_access = dm_dax_direct_access,
3828	.zero_page_range = dm_dax_zero_page_range,
3829	.recovery_write = dm_dax_recovery_write,
3830	};
3831
3832	/*
3833	* module hooks
3834	*/
3835	module_init(dm_init);
3836	module_exit(dm_exit);
3837
3838	module_param(major, uint, 0);
3839	MODULE_PARM_DESC(major, "The major number of the device mapper");
3840
3841	module_param(reserved_bio_based_ios, uint, 0644);
3842	MODULE_PARM_DESC(reserved_bio_based_ios, "Reserved IOs in bio-based mempools");
3843
3844	module_param(dm_numa_node, int, 0644);
3845	MODULE_PARM_DESC(dm_numa_node, "NUMA node for DM device memory allocations");
3846
3847	module_param(swap_bios, int, 0644);
3848	MODULE_PARM_DESC(swap_bios, "Maximum allowed inflight swap IOs");
3849
3850	MODULE_DESCRIPTION(DM_NAME " driver");
3851	MODULE_AUTHOR("Joe Thornber <[email protected]>");
3852	MODULE_LICENSE("GPL");