xref: /openbmc/linux/include/linux/device-mapper.h (revision d2c3c8dcb5987b8352e82089c79a41b6e17e28d2)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * Copyright (C) 2001 Sistina Software (UK) Limited.
30da336e5SAlasdair G Kergon  * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
41da177e4SLinus Torvalds  *
51da177e4SLinus Torvalds  * This file is released under the LGPL.
61da177e4SLinus Torvalds  */
71da177e4SLinus Torvalds 
81da177e4SLinus Torvalds #ifndef _LINUX_DEVICE_MAPPER_H
91da177e4SLinus Torvalds #define _LINUX_DEVICE_MAPPER_H
101da177e4SLinus Torvalds 
11416cd17bSHeinz Mauelshagen #include <linux/bio.h>
12f6fccb12SMilan Broz #include <linux/blkdev.h>
13fd2ed4d2SMikulas Patocka #include <linux/math64.h>
1471a16736SNamhyung Kim #include <linux/ratelimit.h>
15416cd17bSHeinz Mauelshagen 
16af4874e0SMike Snitzer struct dm_dev;
171da177e4SLinus Torvalds struct dm_target;
181da177e4SLinus Torvalds struct dm_table;
1917b2f66fSAlasdair G Kergon struct mapped_device;
20f6fccb12SMilan Broz struct bio_vec;
211da177e4SLinus Torvalds 
22e83068a5SMike Snitzer /*
23e83068a5SMike Snitzer  * Type of table, mapped_device's mempool and request_queue
24e83068a5SMike Snitzer  */
257e0d574fSBart Van Assche enum dm_queue_mode {
267e0d574fSBart Van Assche 	DM_TYPE_NONE		 = 0,
277e0d574fSBart Van Assche 	DM_TYPE_BIO_BASED	 = 1,
287e0d574fSBart Van Assche 	DM_TYPE_REQUEST_BASED	 = 2,
297e0d574fSBart Van Assche 	DM_TYPE_MQ_REQUEST_BASED = 3,
307e0d574fSBart Van Assche 	DM_TYPE_DAX_BIO_BASED	 = 4,
317e0d574fSBart Van Assche };
32e83068a5SMike Snitzer 
331da177e4SLinus Torvalds typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
341da177e4SLinus Torvalds 
351da177e4SLinus Torvalds union map_info {
361da177e4SLinus Torvalds 	void *ptr;
371da177e4SLinus Torvalds };
381da177e4SLinus Torvalds 
391da177e4SLinus Torvalds /*
401da177e4SLinus Torvalds  * In the constructor the target parameter will already have the
411da177e4SLinus Torvalds  * table, type, begin and len fields filled in.
421da177e4SLinus Torvalds  */
431da177e4SLinus Torvalds typedef int (*dm_ctr_fn) (struct dm_target *target,
441da177e4SLinus Torvalds 			  unsigned int argc, char **argv);
451da177e4SLinus Torvalds 
461da177e4SLinus Torvalds /*
471da177e4SLinus Torvalds  * The destructor doesn't need to free the dm_target, just
481da177e4SLinus Torvalds  * anything hidden ti->private.
491da177e4SLinus Torvalds  */
501da177e4SLinus Torvalds typedef void (*dm_dtr_fn) (struct dm_target *ti);
511da177e4SLinus Torvalds 
521da177e4SLinus Torvalds /*
531da177e4SLinus Torvalds  * The map function must return:
541da177e4SLinus Torvalds  * < 0: error
551da177e4SLinus Torvalds  * = 0: The target will handle the io by resubmitting it later
5645cbcd79SKiyoshi Ueda  * = 1: simple remap complete
572e93ccc1SKiyoshi Ueda  * = 2: The target wants to push back the io
581da177e4SLinus Torvalds  */
597de3ee57SMikulas Patocka typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
60e5863d9aSMike Snitzer typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,
61e5863d9aSMike Snitzer 					    struct request *rq,
62e5863d9aSMike Snitzer 					    union map_info *map_context,
63e5863d9aSMike Snitzer 					    struct request **clone);
64e5863d9aSMike Snitzer typedef void (*dm_release_clone_request_fn) (struct request *clone);
651da177e4SLinus Torvalds 
661da177e4SLinus Torvalds /*
671da177e4SLinus Torvalds  * Returns:
681da177e4SLinus Torvalds  * < 0 : error (currently ignored)
691da177e4SLinus Torvalds  * 0   : ended successfully
701da177e4SLinus Torvalds  * 1   : for some reason the io has still not completed (eg,
711da177e4SLinus Torvalds  *       multipath target might want to requeue a failed io).
722e93ccc1SKiyoshi Ueda  * 2   : The target wants to push back the io
731da177e4SLinus Torvalds  */
741da177e4SLinus Torvalds typedef int (*dm_endio_fn) (struct dm_target *ti,
754e4cbee9SChristoph Hellwig 			    struct bio *bio, blk_status_t *error);
767d76345dSKiyoshi Ueda typedef int (*dm_request_endio_fn) (struct dm_target *ti,
772a842acaSChristoph Hellwig 				    struct request *clone, blk_status_t error,
787d76345dSKiyoshi Ueda 				    union map_info *map_context);
791da177e4SLinus Torvalds 
801da177e4SLinus Torvalds typedef void (*dm_presuspend_fn) (struct dm_target *ti);
81d67ee213SMike Snitzer typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);
821da177e4SLinus Torvalds typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
838757b776SMilan Broz typedef int (*dm_preresume_fn) (struct dm_target *ti);
841da177e4SLinus Torvalds typedef void (*dm_resume_fn) (struct dm_target *ti);
851da177e4SLinus Torvalds 
86fd7c092eSMikulas Patocka typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
871f4e0ff0SAlasdair G Kergon 			      unsigned status_flags, char *result, unsigned maxlen);
881da177e4SLinus Torvalds 
891da177e4SLinus Torvalds typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
901da177e4SLinus Torvalds 
91e56f81e0SChristoph Hellwig typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti,
92e56f81e0SChristoph Hellwig 			    struct block_device **bdev, fmode_t *mode);
93aa129a22SMilan Broz 
94058ce5caSAlasdair G Kergon /*
95058ce5caSAlasdair G Kergon  * These iteration functions are typically used to check (and combine)
96058ce5caSAlasdair G Kergon  * properties of underlying devices.
97058ce5caSAlasdair G Kergon  * E.g. Does at least one underlying device support flush?
98058ce5caSAlasdair G Kergon  *      Does any underlying device not support WRITE_SAME?
99058ce5caSAlasdair G Kergon  *
100058ce5caSAlasdair G Kergon  * The callout function is called once for each contiguous section of
101058ce5caSAlasdair G Kergon  * an underlying device.  State can be maintained in *data.
102058ce5caSAlasdair G Kergon  * Return non-zero to stop iterating through any further devices.
103058ce5caSAlasdair G Kergon  */
104af4874e0SMike Snitzer typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
105af4874e0SMike Snitzer 					   struct dm_dev *dev,
1065dea271bSMike Snitzer 					   sector_t start, sector_t len,
107af4874e0SMike Snitzer 					   void *data);
108af4874e0SMike Snitzer 
109058ce5caSAlasdair G Kergon /*
110058ce5caSAlasdair G Kergon  * This function must iterate through each section of device used by the
111058ce5caSAlasdair G Kergon  * target until it encounters a non-zero return code, which it then returns.
112058ce5caSAlasdair G Kergon  * Returns zero if no callout returned non-zero.
113058ce5caSAlasdair G Kergon  */
114af4874e0SMike Snitzer typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
115af4874e0SMike Snitzer 				      iterate_devices_callout_fn fn,
116af4874e0SMike Snitzer 				      void *data);
117af4874e0SMike Snitzer 
11840bea431SMike Snitzer typedef void (*dm_io_hints_fn) (struct dm_target *ti,
11940bea431SMike Snitzer 				struct queue_limits *limits);
12040bea431SMike Snitzer 
1217d76345dSKiyoshi Ueda /*
1227d76345dSKiyoshi Ueda  * Returns:
1237d76345dSKiyoshi Ueda  *    0: The target can handle the next I/O immediately.
1247d76345dSKiyoshi Ueda  *    1: The target can't handle the next I/O immediately.
1257d76345dSKiyoshi Ueda  */
1267d76345dSKiyoshi Ueda typedef int (*dm_busy_fn) (struct dm_target *ti);
1277d76345dSKiyoshi Ueda 
128545ed20eSToshi Kani /*
129545ed20eSToshi Kani  * Returns:
130545ed20eSToshi Kani  *  < 0 : error
131545ed20eSToshi Kani  * >= 0 : the number of bytes accessible at the address
132545ed20eSToshi Kani  */
133817bf402SDan Williams typedef long (*dm_dax_direct_access_fn) (struct dm_target *ti, pgoff_t pgoff,
134817bf402SDan Williams 		long nr_pages, void **kaddr, pfn_t *pfn);
135f26c5719SDan Williams #define PAGE_SECTORS (PAGE_SIZE / 512)
136545ed20eSToshi Kani 
1371da177e4SLinus Torvalds void dm_error(const char *message);
1381da177e4SLinus Torvalds 
13982b1519bSMikulas Patocka struct dm_dev {
14082b1519bSMikulas Patocka 	struct block_device *bdev;
141817bf402SDan Williams 	struct dax_device *dax_dev;
142aeb5d727SAl Viro 	fmode_t mode;
14382b1519bSMikulas Patocka 	char name[16];
14482b1519bSMikulas Patocka };
14582b1519bSMikulas Patocka 
1464df2bf46SDingXiang dev_t dm_get_dev_t(const char *path);
1474df2bf46SDingXiang 
1483cb40214SBryn Reeves /*
1491da177e4SLinus Torvalds  * Constructors should call these functions to ensure destination devices
1501da177e4SLinus Torvalds  * are opened/closed correctly.
1511da177e4SLinus Torvalds  */
1528215d6ecSNikanth Karthikesan int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
1538215d6ecSNikanth Karthikesan 		  struct dm_dev **result);
1541da177e4SLinus Torvalds void dm_put_device(struct dm_target *ti, struct dm_dev *d);
1551da177e4SLinus Torvalds 
1561da177e4SLinus Torvalds /*
1571da177e4SLinus Torvalds  * Information about a target type
1581da177e4SLinus Torvalds  */
159ab4c1424SAndi Kleen 
1601da177e4SLinus Torvalds struct target_type {
161ab4c1424SAndi Kleen 	uint64_t features;
1621da177e4SLinus Torvalds 	const char *name;
1631da177e4SLinus Torvalds 	struct module *module;
1641da177e4SLinus Torvalds 	unsigned version[3];
1651da177e4SLinus Torvalds 	dm_ctr_fn ctr;
1661da177e4SLinus Torvalds 	dm_dtr_fn dtr;
1671da177e4SLinus Torvalds 	dm_map_fn map;
168e5863d9aSMike Snitzer 	dm_clone_and_map_request_fn clone_and_map_rq;
169e5863d9aSMike Snitzer 	dm_release_clone_request_fn release_clone_rq;
1701da177e4SLinus Torvalds 	dm_endio_fn end_io;
1717d76345dSKiyoshi Ueda 	dm_request_endio_fn rq_end_io;
1721da177e4SLinus Torvalds 	dm_presuspend_fn presuspend;
173d67ee213SMike Snitzer 	dm_presuspend_undo_fn presuspend_undo;
1741da177e4SLinus Torvalds 	dm_postsuspend_fn postsuspend;
1758757b776SMilan Broz 	dm_preresume_fn preresume;
1761da177e4SLinus Torvalds 	dm_resume_fn resume;
1771da177e4SLinus Torvalds 	dm_status_fn status;
1781da177e4SLinus Torvalds 	dm_message_fn message;
179e56f81e0SChristoph Hellwig 	dm_prepare_ioctl_fn prepare_ioctl;
1807d76345dSKiyoshi Ueda 	dm_busy_fn busy;
181af4874e0SMike Snitzer 	dm_iterate_devices_fn iterate_devices;
18240bea431SMike Snitzer 	dm_io_hints_fn io_hints;
183817bf402SDan Williams 	dm_dax_direct_access_fn direct_access;
18445194e4fSCheng Renquan 
18545194e4fSCheng Renquan 	/* For internal device-mapper use. */
18645194e4fSCheng Renquan 	struct list_head list;
1871da177e4SLinus Torvalds };
1881da177e4SLinus Torvalds 
1893791e2fcSAlasdair G Kergon /*
1903791e2fcSAlasdair G Kergon  * Target features
1913791e2fcSAlasdair G Kergon  */
1923791e2fcSAlasdair G Kergon 
1933791e2fcSAlasdair G Kergon /*
1943791e2fcSAlasdair G Kergon  * Any table that contains an instance of this target must have only one.
1953791e2fcSAlasdair G Kergon  */
1963791e2fcSAlasdair G Kergon #define DM_TARGET_SINGLETON		0x00000001
1973791e2fcSAlasdair G Kergon #define dm_target_needs_singleton(type)	((type)->features & DM_TARGET_SINGLETON)
1983791e2fcSAlasdair G Kergon 
199cc6cbe14SAlasdair G Kergon /*
200cc6cbe14SAlasdair G Kergon  * Indicates that a target does not support read-only devices.
201cc6cbe14SAlasdair G Kergon  */
202cc6cbe14SAlasdair G Kergon #define DM_TARGET_ALWAYS_WRITEABLE	0x00000002
203cc6cbe14SAlasdair G Kergon #define dm_target_always_writeable(type) \
204cc6cbe14SAlasdair G Kergon 		((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
205cc6cbe14SAlasdair G Kergon 
20636a0456fSAlasdair G Kergon /*
20736a0456fSAlasdair G Kergon  * Any device that contains a table with an instance of this target may never
20836a0456fSAlasdair G Kergon  * have tables containing any different target type.
20936a0456fSAlasdair G Kergon  */
21036a0456fSAlasdair G Kergon #define DM_TARGET_IMMUTABLE		0x00000004
21136a0456fSAlasdair G Kergon #define dm_target_is_immutable(type)	((type)->features & DM_TARGET_IMMUTABLE)
21236a0456fSAlasdair G Kergon 
213b0d8ed4dSAlasdair G Kergon /*
214f083b09bSMike Snitzer  * Indicates that a target may replace any target; even immutable targets.
215f083b09bSMike Snitzer  * .map, .map_rq, .clone_and_map_rq and .release_clone_rq are all defined.
216f083b09bSMike Snitzer  */
217f083b09bSMike Snitzer #define DM_TARGET_WILDCARD		0x00000008
218f083b09bSMike Snitzer #define dm_target_is_wildcard(type)	((type)->features & DM_TARGET_WILDCARD)
219f083b09bSMike Snitzer 
220f083b09bSMike Snitzer /*
221b0d8ed4dSAlasdair G Kergon  * Some targets need to be sent the same WRITE bio severals times so
222b0d8ed4dSAlasdair G Kergon  * that they can send copies of it to different devices.  This function
223b0d8ed4dSAlasdair G Kergon  * examines any supplied bio and returns the number of copies of it the
224b0d8ed4dSAlasdair G Kergon  * target requires.
225b0d8ed4dSAlasdair G Kergon  */
226b0d8ed4dSAlasdair G Kergon typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);
227b0d8ed4dSAlasdair G Kergon 
2289b4b5a79SMilan Broz /*
2299b4b5a79SMilan Broz  * A target implements own bio data integrity.
2309b4b5a79SMilan Broz  */
2319b4b5a79SMilan Broz #define DM_TARGET_INTEGRITY		0x00000010
2329b4b5a79SMilan Broz #define dm_target_has_integrity(type)	((type)->features & DM_TARGET_INTEGRITY)
2339b4b5a79SMilan Broz 
234e2460f2aSMikulas Patocka /*
235e2460f2aSMikulas Patocka  * A target passes integrity data to the lower device.
236e2460f2aSMikulas Patocka  */
237e2460f2aSMikulas Patocka #define DM_TARGET_PASSES_INTEGRITY	0x00000020
238e2460f2aSMikulas Patocka #define dm_target_passes_integrity(type) ((type)->features & DM_TARGET_PASSES_INTEGRITY)
239e2460f2aSMikulas Patocka 
2401da177e4SLinus Torvalds struct dm_target {
2411da177e4SLinus Torvalds 	struct dm_table *table;
2421da177e4SLinus Torvalds 	struct target_type *type;
2431da177e4SLinus Torvalds 
2441da177e4SLinus Torvalds 	/* target limits */
2451da177e4SLinus Torvalds 	sector_t begin;
2461da177e4SLinus Torvalds 	sector_t len;
2471da177e4SLinus Torvalds 
248542f9038SMike Snitzer 	/* If non-zero, maximum size of I/O submitted to a target. */
249542f9038SMike Snitzer 	uint32_t max_io_len;
2501da177e4SLinus Torvalds 
2511da177e4SLinus Torvalds 	/*
25255a62eefSAlasdair G Kergon 	 * A number of zero-length barrier bios that will be submitted
253f9ab94ceSMikulas Patocka 	 * to the target for the purpose of flushing cache.
254f9ab94ceSMikulas Patocka 	 *
25555a62eefSAlasdair G Kergon 	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
25655a62eefSAlasdair G Kergon 	 * It is a responsibility of the target driver to remap these bios
257f9ab94ceSMikulas Patocka 	 * to the real underlying devices.
258f9ab94ceSMikulas Patocka 	 */
25955a62eefSAlasdair G Kergon 	unsigned num_flush_bios;
260f9ab94ceSMikulas Patocka 
2615ae89a87SMike Snitzer 	/*
26255a62eefSAlasdair G Kergon 	 * The number of discard bios that will be submitted to the target.
26355a62eefSAlasdair G Kergon 	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
2645ae89a87SMike Snitzer 	 */
26555a62eefSAlasdair G Kergon 	unsigned num_discard_bios;
2665ae89a87SMike Snitzer 
267d54eaa5aSMike Snitzer 	/*
26855a62eefSAlasdair G Kergon 	 * The number of WRITE SAME bios that will be submitted to the target.
26955a62eefSAlasdair G Kergon 	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
270d54eaa5aSMike Snitzer 	 */
27155a62eefSAlasdair G Kergon 	unsigned num_write_same_bios;
272d54eaa5aSMike Snitzer 
273c0820cf5SMikulas Patocka 	/*
274ac62d620SChristoph Hellwig 	 * The number of WRITE ZEROES bios that will be submitted to the target.
275ac62d620SChristoph Hellwig 	 * The bio number can be accessed with dm_bio_get_target_bio_nr.
276ac62d620SChristoph Hellwig 	 */
277ac62d620SChristoph Hellwig 	unsigned num_write_zeroes_bios;
278ac62d620SChristoph Hellwig 
279ac62d620SChristoph Hellwig 	/*
28030187e1dSMike Snitzer 	 * The minimum number of extra bytes allocated in each io for the
28130187e1dSMike Snitzer 	 * target to use.
282c0820cf5SMikulas Patocka 	 */
28330187e1dSMike Snitzer 	unsigned per_io_data_size;
284c0820cf5SMikulas Patocka 
285b0d8ed4dSAlasdair G Kergon 	/*
286b0d8ed4dSAlasdair G Kergon 	 * If defined, this function is called to find out how many
287b0d8ed4dSAlasdair G Kergon 	 * duplicate bios should be sent to the target when writing
288b0d8ed4dSAlasdair G Kergon 	 * data.
289b0d8ed4dSAlasdair G Kergon 	 */
290b0d8ed4dSAlasdair G Kergon 	dm_num_write_bios_fn num_write_bios;
291b0d8ed4dSAlasdair G Kergon 
2921da177e4SLinus Torvalds 	/* target specific data */
2931da177e4SLinus Torvalds 	void *private;
2941da177e4SLinus Torvalds 
2951da177e4SLinus Torvalds 	/* Used to provide an error string from the ctr */
2961da177e4SLinus Torvalds 	char *error;
2974c259327SMike Snitzer 
2984c259327SMike Snitzer 	/*
2990e9c24edSJoe Thornber 	 * Set if this target needs to receive flushes regardless of
3000e9c24edSJoe Thornber 	 * whether or not its underlying devices have support.
3010e9c24edSJoe Thornber 	 */
3020e9c24edSJoe Thornber 	bool flush_supported:1;
3030e9c24edSJoe Thornber 
3040e9c24edSJoe Thornber 	/*
3054c259327SMike Snitzer 	 * Set if this target needs to receive discards regardless of
3064c259327SMike Snitzer 	 * whether or not its underlying devices have support.
3074c259327SMike Snitzer 	 */
3080ac55489SAlasdair G Kergon 	bool discards_supported:1;
309983c7db3SMilan Broz 
310983c7db3SMilan Broz 	/*
31155a62eefSAlasdair G Kergon 	 * Set if the target required discard bios to be split
3127acf0277SMikulas Patocka 	 * on max_io_len boundary.
3137acf0277SMikulas Patocka 	 */
31455a62eefSAlasdair G Kergon 	bool split_discard_bios:1;
3151da177e4SLinus Torvalds };
3161da177e4SLinus Torvalds 
3179d357b07SNeilBrown /* Each target can link one of these into the table */
3189d357b07SNeilBrown struct dm_target_callbacks {
3199d357b07SNeilBrown 	struct list_head list;
3209d357b07SNeilBrown 	int (*congested_fn) (struct dm_target_callbacks *, int);
3219d357b07SNeilBrown };
3229d357b07SNeilBrown 
323c0820cf5SMikulas Patocka /*
324c0820cf5SMikulas Patocka  * For bio-based dm.
325c0820cf5SMikulas Patocka  * One of these is allocated for each bio.
326c0820cf5SMikulas Patocka  * This structure shouldn't be touched directly by target drivers.
327c0820cf5SMikulas Patocka  * It is here so that we can inline dm_per_bio_data and
328c0820cf5SMikulas Patocka  * dm_bio_from_per_bio_data
329c0820cf5SMikulas Patocka  */
330c0820cf5SMikulas Patocka struct dm_target_io {
331c0820cf5SMikulas Patocka 	struct dm_io *io;
332c0820cf5SMikulas Patocka 	struct dm_target *ti;
33355a62eefSAlasdair G Kergon 	unsigned target_bio_nr;
3341dd40c3eSMikulas Patocka 	unsigned *len_ptr;
335c0820cf5SMikulas Patocka 	struct bio clone;
336c0820cf5SMikulas Patocka };
337c0820cf5SMikulas Patocka 
338c0820cf5SMikulas Patocka static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
339c0820cf5SMikulas Patocka {
340c0820cf5SMikulas Patocka 	return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
341c0820cf5SMikulas Patocka }
342c0820cf5SMikulas Patocka 
343c0820cf5SMikulas Patocka static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
344c0820cf5SMikulas Patocka {
345c0820cf5SMikulas Patocka 	return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
346c0820cf5SMikulas Patocka }
347c0820cf5SMikulas Patocka 
34855a62eefSAlasdair G Kergon static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
349ddbd658fSMikulas Patocka {
35055a62eefSAlasdair G Kergon 	return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
351ddbd658fSMikulas Patocka }
352ddbd658fSMikulas Patocka 
3531da177e4SLinus Torvalds int dm_register_target(struct target_type *t);
35410d3bd09SMikulas Patocka void dm_unregister_target(struct target_type *t);
35517b2f66fSAlasdair G Kergon 
356498f0103SMike Snitzer /*
357498f0103SMike Snitzer  * Target argument parsing.
358498f0103SMike Snitzer  */
359498f0103SMike Snitzer struct dm_arg_set {
360498f0103SMike Snitzer 	unsigned argc;
361498f0103SMike Snitzer 	char **argv;
362498f0103SMike Snitzer };
363498f0103SMike Snitzer 
364498f0103SMike Snitzer /*
365498f0103SMike Snitzer  * The minimum and maximum value of a numeric argument, together with
366498f0103SMike Snitzer  * the error message to use if the number is found to be outside that range.
367498f0103SMike Snitzer  */
368498f0103SMike Snitzer struct dm_arg {
369498f0103SMike Snitzer 	unsigned min;
370498f0103SMike Snitzer 	unsigned max;
371498f0103SMike Snitzer 	char *error;
372498f0103SMike Snitzer };
373498f0103SMike Snitzer 
374498f0103SMike Snitzer /*
375498f0103SMike Snitzer  * Validate the next argument, either returning it as *value or, if invalid,
376498f0103SMike Snitzer  * returning -EINVAL and setting *error.
377498f0103SMike Snitzer  */
378498f0103SMike Snitzer int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
379498f0103SMike Snitzer 		unsigned *value, char **error);
380498f0103SMike Snitzer 
381498f0103SMike Snitzer /*
382498f0103SMike Snitzer  * Process the next argument as the start of a group containing between
383498f0103SMike Snitzer  * arg->min and arg->max further arguments. Either return the size as
384498f0103SMike Snitzer  * *num_args or, if invalid, return -EINVAL and set *error.
385498f0103SMike Snitzer  */
386498f0103SMike Snitzer int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
387498f0103SMike Snitzer 		      unsigned *num_args, char **error);
388498f0103SMike Snitzer 
389498f0103SMike Snitzer /*
390498f0103SMike Snitzer  * Return the current argument and shift to the next.
391498f0103SMike Snitzer  */
392498f0103SMike Snitzer const char *dm_shift_arg(struct dm_arg_set *as);
393498f0103SMike Snitzer 
394498f0103SMike Snitzer /*
395498f0103SMike Snitzer  * Move through num_args arguments.
396498f0103SMike Snitzer  */
397498f0103SMike Snitzer void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
398498f0103SMike Snitzer 
39917b2f66fSAlasdair G Kergon /*-----------------------------------------------------------------
40017b2f66fSAlasdair G Kergon  * Functions for creating and manipulating mapped devices.
40117b2f66fSAlasdair G Kergon  * Drop the reference with dm_put when you finish with the object.
40217b2f66fSAlasdair G Kergon  *---------------------------------------------------------------*/
40317b2f66fSAlasdair G Kergon 
40417b2f66fSAlasdair G Kergon /*
40517b2f66fSAlasdair G Kergon  * DM_ANY_MINOR chooses the next available minor number.
40617b2f66fSAlasdair G Kergon  */
40717b2f66fSAlasdair G Kergon #define DM_ANY_MINOR (-1)
40817b2f66fSAlasdair G Kergon int dm_create(int minor, struct mapped_device **md);
40917b2f66fSAlasdair G Kergon 
41017b2f66fSAlasdair G Kergon /*
41117b2f66fSAlasdair G Kergon  * Reference counting for md.
41217b2f66fSAlasdair G Kergon  */
41317b2f66fSAlasdair G Kergon struct mapped_device *dm_get_md(dev_t dev);
41417b2f66fSAlasdair G Kergon void dm_get(struct mapped_device *md);
41509ee96b2SMikulas Patocka int dm_hold(struct mapped_device *md);
41617b2f66fSAlasdair G Kergon void dm_put(struct mapped_device *md);
41717b2f66fSAlasdair G Kergon 
41817b2f66fSAlasdair G Kergon /*
41917b2f66fSAlasdair G Kergon  * An arbitrary pointer may be stored alongside a mapped device.
42017b2f66fSAlasdair G Kergon  */
42117b2f66fSAlasdair G Kergon void dm_set_mdptr(struct mapped_device *md, void *ptr);
42217b2f66fSAlasdair G Kergon void *dm_get_mdptr(struct mapped_device *md);
42317b2f66fSAlasdair G Kergon 
42417b2f66fSAlasdair G Kergon /*
42517b2f66fSAlasdair G Kergon  * A device can still be used while suspended, but I/O is deferred.
42617b2f66fSAlasdair G Kergon  */
427a3d77d35SKiyoshi Ueda int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
42817b2f66fSAlasdair G Kergon int dm_resume(struct mapped_device *md);
42917b2f66fSAlasdair G Kergon 
43017b2f66fSAlasdair G Kergon /*
43117b2f66fSAlasdair G Kergon  * Event functions.
43217b2f66fSAlasdair G Kergon  */
43317b2f66fSAlasdair G Kergon uint32_t dm_get_event_nr(struct mapped_device *md);
43417b2f66fSAlasdair G Kergon int dm_wait_event(struct mapped_device *md, int event_nr);
4357a8c3d3bSMike Anderson uint32_t dm_next_uevent_seq(struct mapped_device *md);
4367a8c3d3bSMike Anderson void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
43717b2f66fSAlasdair G Kergon 
43817b2f66fSAlasdair G Kergon /*
43917b2f66fSAlasdair G Kergon  * Info functions.
44017b2f66fSAlasdair G Kergon  */
44172d94861SAlasdair G Kergon const char *dm_device_name(struct mapped_device *md);
44296a1f7dbSMike Anderson int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
44317b2f66fSAlasdair G Kergon struct gendisk *dm_disk(struct mapped_device *md);
44464dbce58SKiyoshi Ueda int dm_suspended(struct dm_target *ti);
4452e93ccc1SKiyoshi Ueda int dm_noflush_suspending(struct dm_target *ti);
4461dd40c3eSMikulas Patocka void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
447cec47e3dSKiyoshi Ueda union map_info *dm_get_rq_mapinfo(struct request *rq);
44817b2f66fSAlasdair G Kergon 
449f84cb8a4SMike Snitzer struct queue_limits *dm_get_queue_limits(struct mapped_device *md);
450f84cb8a4SMike Snitzer 
45117b2f66fSAlasdair G Kergon /*
45217b2f66fSAlasdair G Kergon  * Geometry functions.
45317b2f66fSAlasdair G Kergon  */
45417b2f66fSAlasdair G Kergon int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
45517b2f66fSAlasdair G Kergon int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
45617b2f66fSAlasdair G Kergon 
45717b2f66fSAlasdair G Kergon /*-----------------------------------------------------------------
45817b2f66fSAlasdair G Kergon  * Functions for manipulating device-mapper tables.
45917b2f66fSAlasdair G Kergon  *---------------------------------------------------------------*/
46017b2f66fSAlasdair G Kergon 
46117b2f66fSAlasdair G Kergon /*
46217b2f66fSAlasdair G Kergon  * First create an empty table.
46317b2f66fSAlasdair G Kergon  */
464aeb5d727SAl Viro int dm_table_create(struct dm_table **result, fmode_t mode,
46517b2f66fSAlasdair G Kergon 		    unsigned num_targets, struct mapped_device *md);
46617b2f66fSAlasdair G Kergon 
46717b2f66fSAlasdair G Kergon /*
46817b2f66fSAlasdair G Kergon  * Then call this once for each target.
46917b2f66fSAlasdair G Kergon  */
47017b2f66fSAlasdair G Kergon int dm_table_add_target(struct dm_table *t, const char *type,
47117b2f66fSAlasdair G Kergon 			sector_t start, sector_t len, char *params);
47217b2f66fSAlasdair G Kergon 
47317b2f66fSAlasdair G Kergon /*
4749d357b07SNeilBrown  * Target_ctr should call this if it needs to add any callbacks.
4759d357b07SNeilBrown  */
4769d357b07SNeilBrown void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
4779d357b07SNeilBrown 
4789d357b07SNeilBrown /*
479e83068a5SMike Snitzer  * Target can use this to set the table's type.
480e83068a5SMike Snitzer  * Can only ever be called from a target's ctr.
481e83068a5SMike Snitzer  * Useful for "hybrid" target (supports both bio-based
482e83068a5SMike Snitzer  * and request-based).
483e83068a5SMike Snitzer  */
4847e0d574fSBart Van Assche void dm_table_set_type(struct dm_table *t, enum dm_queue_mode type);
485e83068a5SMike Snitzer 
486e83068a5SMike Snitzer /*
48717b2f66fSAlasdair G Kergon  * Finally call this to make the table ready for use.
48817b2f66fSAlasdair G Kergon  */
48917b2f66fSAlasdair G Kergon int dm_table_complete(struct dm_table *t);
49017b2f66fSAlasdair G Kergon 
49117b2f66fSAlasdair G Kergon /*
492542f9038SMike Snitzer  * Target may require that it is never sent I/O larger than len.
493542f9038SMike Snitzer  */
494542f9038SMike Snitzer int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);
495542f9038SMike Snitzer 
496542f9038SMike Snitzer /*
49717b2f66fSAlasdair G Kergon  * Table reference counting.
49817b2f66fSAlasdair G Kergon  */
49983d5e5b0SMikulas Patocka struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx);
50083d5e5b0SMikulas Patocka void dm_put_live_table(struct mapped_device *md, int srcu_idx);
50183d5e5b0SMikulas Patocka void dm_sync_table(struct mapped_device *md);
50217b2f66fSAlasdair G Kergon 
50317b2f66fSAlasdair G Kergon /*
50417b2f66fSAlasdair G Kergon  * Queries
50517b2f66fSAlasdair G Kergon  */
50617b2f66fSAlasdair G Kergon sector_t dm_table_get_size(struct dm_table *t);
50717b2f66fSAlasdair G Kergon unsigned int dm_table_get_num_targets(struct dm_table *t);
508aeb5d727SAl Viro fmode_t dm_table_get_mode(struct dm_table *t);
50917b2f66fSAlasdair G Kergon struct mapped_device *dm_table_get_md(struct dm_table *t);
51017b2f66fSAlasdair G Kergon 
51117b2f66fSAlasdair G Kergon /*
51217b2f66fSAlasdair G Kergon  * Trigger an event.
51317b2f66fSAlasdair G Kergon  */
51417b2f66fSAlasdair G Kergon void dm_table_event(struct dm_table *t);
51517b2f66fSAlasdair G Kergon 
51617b2f66fSAlasdair G Kergon /*
5179974fa2cSMike Snitzer  * Run the queue for request-based targets.
5189974fa2cSMike Snitzer  */
5199974fa2cSMike Snitzer void dm_table_run_md_queue_async(struct dm_table *t);
5209974fa2cSMike Snitzer 
5219974fa2cSMike Snitzer /*
52217b2f66fSAlasdair G Kergon  * The device must be suspended before calling this method.
523042d2a9bSAlasdair G Kergon  * Returns the previous table, which the caller must destroy.
52417b2f66fSAlasdair G Kergon  */
525042d2a9bSAlasdair G Kergon struct dm_table *dm_swap_table(struct mapped_device *md,
526042d2a9bSAlasdair G Kergon 			       struct dm_table *t);
52717b2f66fSAlasdair G Kergon 
52854160904SMikulas Patocka /*
52954160904SMikulas Patocka  * A wrapper around vmalloc.
53054160904SMikulas Patocka  */
53154160904SMikulas Patocka void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
53254160904SMikulas Patocka 
5330da336e5SAlasdair G Kergon /*-----------------------------------------------------------------
5340da336e5SAlasdair G Kergon  * Macros.
5350da336e5SAlasdair G Kergon  *---------------------------------------------------------------*/
5360da336e5SAlasdair G Kergon #define DM_NAME "device-mapper"
5370da336e5SAlasdair G Kergon 
53871a16736SNamhyung Kim #ifdef CONFIG_PRINTK
53971a16736SNamhyung Kim extern struct ratelimit_state dm_ratelimit_state;
54071a16736SNamhyung Kim 
54171a16736SNamhyung Kim #define dm_ratelimit()	__ratelimit(&dm_ratelimit_state)
54271a16736SNamhyung Kim #else
54371a16736SNamhyung Kim #define dm_ratelimit()	0
54471a16736SNamhyung Kim #endif
54571a16736SNamhyung Kim 
546*d2c3c8dcSJoe Perches #define DM_FMT(fmt) DM_NAME ": " DM_MSG_PREFIX ": " fmt "\n"
54710d3bd09SMikulas Patocka 
548*d2c3c8dcSJoe Perches #define DMCRIT(fmt, ...) pr_crit(DM_FMT(fmt), ##__VA_ARGS__)
549*d2c3c8dcSJoe Perches 
550*d2c3c8dcSJoe Perches #define DMERR(fmt, ...) pr_err(DM_FMT(fmt), ##__VA_ARGS__)
551*d2c3c8dcSJoe Perches #define DMERR_LIMIT(fmt, ...)						\
5520da336e5SAlasdair G Kergon do {									\
55371a16736SNamhyung Kim 	if (dm_ratelimit())						\
554*d2c3c8dcSJoe Perches 		DMERR(fmt, ##__VA_ARGS__);				\
5550da336e5SAlasdair G Kergon } while (0)
5560da336e5SAlasdair G Kergon 
557*d2c3c8dcSJoe Perches #define DMWARN(fmt, ...) pr_warn(DM_FMT(fmt), ##__VA_ARGS__)
558*d2c3c8dcSJoe Perches #define DMWARN_LIMIT(fmt, ...)						\
5590da336e5SAlasdair G Kergon do {									\
56071a16736SNamhyung Kim 	if (dm_ratelimit())						\
561*d2c3c8dcSJoe Perches 		DMWARN(fmt, ##__VA_ARGS__);				\
5620da336e5SAlasdair G Kergon } while (0)
5630da336e5SAlasdair G Kergon 
564*d2c3c8dcSJoe Perches #define DMINFO(fmt, ...) pr_info(DM_FMT(fmt), ##__VA_ARGS__)
565*d2c3c8dcSJoe Perches #define DMINFO_LIMIT(fmt, ...)						\
5660da336e5SAlasdair G Kergon do {									\
56771a16736SNamhyung Kim 	if (dm_ratelimit())						\
568*d2c3c8dcSJoe Perches 		DMINFO(fmt, ##__VA_ARGS__);				\
5690da336e5SAlasdair G Kergon } while (0)
5700da336e5SAlasdair G Kergon 
5710da336e5SAlasdair G Kergon #ifdef CONFIG_DM_DEBUG
572*d2c3c8dcSJoe Perches #define DMDEBUG(fmt, ...) printk(KERN_DEBUG DM_FMT(fmt), ##__VA_ARGS__)
573*d2c3c8dcSJoe Perches #define DMDEBUG_LIMIT(fmt, ...)						\
5740da336e5SAlasdair G Kergon do {									\
57571a16736SNamhyung Kim 	if (dm_ratelimit())						\
576*d2c3c8dcSJoe Perches 		DMDEBUG(fmt, ##__VA_ARGS__);				\
5770da336e5SAlasdair G Kergon } while (0)
5780da336e5SAlasdair G Kergon #else
579*d2c3c8dcSJoe Perches #define DMDEBUG(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
580*d2c3c8dcSJoe Perches #define DMDEBUG_LIMIT(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
5810da336e5SAlasdair G Kergon #endif
5820da336e5SAlasdair G Kergon 
5830da336e5SAlasdair G Kergon #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
5840da336e5SAlasdair G Kergon 			  0 : scnprintf(result + sz, maxlen - sz, x))
5850da336e5SAlasdair G Kergon 
5860da336e5SAlasdair G Kergon #define SECTOR_SHIFT 9
5870da336e5SAlasdair G Kergon 
5880da336e5SAlasdair G Kergon /*
5890da336e5SAlasdair G Kergon  * Definitions of return values from target end_io function.
5900da336e5SAlasdair G Kergon  */
5917ed8578aSChristoph Hellwig #define DM_ENDIO_DONE		0
5920da336e5SAlasdair G Kergon #define DM_ENDIO_INCOMPLETE	1
5930da336e5SAlasdair G Kergon #define DM_ENDIO_REQUEUE	2
5940da336e5SAlasdair G Kergon 
5950da336e5SAlasdair G Kergon /*
5960da336e5SAlasdair G Kergon  * Definitions of return values from target map function.
5970da336e5SAlasdair G Kergon  */
5980da336e5SAlasdair G Kergon #define DM_MAPIO_SUBMITTED	0
5990da336e5SAlasdair G Kergon #define DM_MAPIO_REMAPPED	1
6000da336e5SAlasdair G Kergon #define DM_MAPIO_REQUEUE	DM_ENDIO_REQUEUE
601a8ac51e4SMike Snitzer #define DM_MAPIO_DELAY_REQUEUE	3
602412445acSChristoph Hellwig #define DM_MAPIO_KILL		4
6030da336e5SAlasdair G Kergon 
604fd2ed4d2SMikulas Patocka #define dm_sector_div64(x, y)( \
605fd2ed4d2SMikulas Patocka { \
606fd2ed4d2SMikulas Patocka 	u64 _res; \
607fd2ed4d2SMikulas Patocka 	(x) = div64_u64_rem(x, y, &_res); \
608fd2ed4d2SMikulas Patocka 	_res; \
609fd2ed4d2SMikulas Patocka } \
610fd2ed4d2SMikulas Patocka )
611fd2ed4d2SMikulas Patocka 
6120da336e5SAlasdair G Kergon /*
6130da336e5SAlasdair G Kergon  * Ceiling(n / sz)
6140da336e5SAlasdair G Kergon  */
6150da336e5SAlasdair G Kergon #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
6160da336e5SAlasdair G Kergon 
6170da336e5SAlasdair G Kergon #define dm_sector_div_up(n, sz) ( \
6180da336e5SAlasdair G Kergon { \
6190da336e5SAlasdair G Kergon 	sector_t _r = ((n) + (sz) - 1); \
6200da336e5SAlasdair G Kergon 	sector_div(_r, (sz)); \
6210da336e5SAlasdair G Kergon 	_r; \
6220da336e5SAlasdair G Kergon } \
6230da336e5SAlasdair G Kergon )
6240da336e5SAlasdair G Kergon 
6250da336e5SAlasdair G Kergon /*
6260da336e5SAlasdair G Kergon  * ceiling(n / size) * size
6270da336e5SAlasdair G Kergon  */
6280da336e5SAlasdair G Kergon #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
6290da336e5SAlasdair G Kergon 
630d63a5ce3SMikulas Patocka #define dm_array_too_big(fixed, obj, num) \
631d63a5ce3SMikulas Patocka 	((num) > (UINT_MAX - (fixed)) / (obj))
632d63a5ce3SMikulas Patocka 
63356a67df7SMike Snitzer /*
63456a67df7SMike Snitzer  * Sector offset taken relative to the start of the target instead of
63556a67df7SMike Snitzer  * relative to the start of the device.
63656a67df7SMike Snitzer  */
63756a67df7SMike Snitzer #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
63856a67df7SMike Snitzer 
6390da336e5SAlasdair G Kergon static inline sector_t to_sector(unsigned long n)
6400da336e5SAlasdair G Kergon {
6410da336e5SAlasdair G Kergon 	return (n >> SECTOR_SHIFT);
6420da336e5SAlasdair G Kergon }
6430da336e5SAlasdair G Kergon 
6440da336e5SAlasdair G Kergon static inline unsigned long to_bytes(sector_t n)
6450da336e5SAlasdair G Kergon {
6460da336e5SAlasdair G Kergon 	return (n << SECTOR_SHIFT);
6470da336e5SAlasdair G Kergon }
6480da336e5SAlasdair G Kergon 
6491da177e4SLinus Torvalds #endif	/* _LINUX_DEVICE_MAPPER_H */
650