blob: ef7962e84444d90429afbb0d5e53fd7eaf7d7668 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2001 Sistina Software (UK) Limited.
Alasdair G Kergon0da336e2008-04-24 21:43:52 +01003 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This file is released under the LGPL.
6 */
7
8#ifndef _LINUX_DEVICE_MAPPER_H
9#define _LINUX_DEVICE_MAPPER_H
10
Heinz Mauelshagen416cd172008-04-24 21:43:35 +010011#include <linux/bio.h>
Milan Brozf6fccb12008-07-21 12:00:37 +010012#include <linux/blkdev.h>
Mikulas Patockafd2ed4d2013-08-16 10:54:23 -040013#include <linux/math64.h>
Namhyung Kim71a16732011-10-31 20:18:54 +000014#include <linux/ratelimit.h>
Heinz Mauelshagen416cd172008-04-24 21:43:35 +010015
Mike Snitzeraf4874e2009-06-22 10:12:33 +010016struct dm_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070017struct dm_target;
18struct dm_table;
Alasdair G Kergon17b2f662006-06-26 00:27:33 -070019struct mapped_device;
Milan Brozf6fccb12008-07-21 12:00:37 +010020struct bio_vec;
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Mike Snitzere83068a2016-05-24 21:16:51 -040022/*
23 * Type of table, mapped_device's mempool and request_queue
24 */
25#define DM_TYPE_NONE 0
26#define DM_TYPE_BIO_BASED 1
27#define DM_TYPE_REQUEST_BASED 2
28#define DM_TYPE_MQ_REQUEST_BASED 3
Toshi Kani545ed202016-06-22 17:54:53 -060029#define DM_TYPE_DAX_BIO_BASED 4
Mike Snitzere83068a2016-05-24 21:16:51 -040030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
32
33union map_info {
34 void *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035};
36
37/*
38 * In the constructor the target parameter will already have the
39 * table, type, begin and len fields filled in.
40 */
41typedef int (*dm_ctr_fn) (struct dm_target *target,
42 unsigned int argc, char **argv);
43
44/*
45 * The destructor doesn't need to free the dm_target, just
46 * anything hidden ti->private.
47 */
48typedef void (*dm_dtr_fn) (struct dm_target *ti);
49
50/*
51 * The map function must return:
52 * < 0: error
53 * = 0: The target will handle the io by resubmitting it later
Kiyoshi Ueda45cbcd72006-12-08 02:41:05 -080054 * = 1: simple remap complete
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -080055 * = 2: The target wants to push back the io
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 */
Mikulas Patocka7de3ee52012-12-21 20:23:41 +000057typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
Kiyoshi Ueda7d763452009-01-06 03:05:07 +000058typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
59 union map_info *map_context);
Mike Snitzere5863d92014-12-17 21:08:12 -050060typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,
61 struct request *rq,
62 union map_info *map_context,
63 struct request **clone);
64typedef void (*dm_release_clone_request_fn) (struct request *clone);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/*
67 * Returns:
68 * < 0 : error (currently ignored)
69 * 0 : ended successfully
70 * 1 : for some reason the io has still not completed (eg,
71 * multipath target might want to requeue a failed io).
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -080072 * 2 : The target wants to push back the io
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 */
74typedef int (*dm_endio_fn) (struct dm_target *ti,
Mikulas Patocka7de3ee52012-12-21 20:23:41 +000075 struct bio *bio, int error);
Kiyoshi Ueda7d763452009-01-06 03:05:07 +000076typedef int (*dm_request_endio_fn) (struct dm_target *ti,
77 struct request *clone, int error,
78 union map_info *map_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80typedef void (*dm_presuspend_fn) (struct dm_target *ti);
Mike Snitzerd67ee212014-10-28 20:13:31 -040081typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
Milan Broz8757b772006-10-03 01:15:36 -070083typedef int (*dm_preresume_fn) (struct dm_target *ti);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084typedef void (*dm_resume_fn) (struct dm_target *ti);
85
Mikulas Patockafd7c0922013-03-01 22:45:44 +000086typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
87 unsigned status_flags, char *result, unsigned maxlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
90
Christoph Hellwige56f81e2015-10-15 14:10:50 +020091typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti,
92 struct block_device **bdev, fmode_t *mode);
Milan Brozaa129a22006-10-03 01:15:15 -070093
Alasdair G Kergon058ce5c2013-05-10 14:37:17 +010094/*
95 * These iteration functions are typically used to check (and combine)
96 * properties of underlying devices.
97 * E.g. Does at least one underlying device support flush?
98 * Does any underlying device not support WRITE_SAME?
99 *
100 * The callout function is called once for each contiguous section of
101 * an underlying device. State can be maintained in *data.
102 * Return non-zero to stop iterating through any further devices.
103 */
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100104typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
105 struct dm_dev *dev,
Mike Snitzer5dea2712009-07-23 20:30:42 +0100106 sector_t start, sector_t len,
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100107 void *data);
108
Alasdair G Kergon058ce5c2013-05-10 14:37:17 +0100109/*
110 * This function must iterate through each section of device used by the
111 * target until it encounters a non-zero return code, which it then returns.
112 * Returns zero if no callout returned non-zero.
113 */
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100114typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
115 iterate_devices_callout_fn fn,
116 void *data);
117
Mike Snitzer40bea432009-09-04 20:40:25 +0100118typedef void (*dm_io_hints_fn) (struct dm_target *ti,
119 struct queue_limits *limits);
120
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000121/*
122 * Returns:
123 * 0: The target can handle the next I/O immediately.
124 * 1: The target can't handle the next I/O immediately.
125 */
126typedef int (*dm_busy_fn) (struct dm_target *ti);
127
Toshi Kani545ed202016-06-22 17:54:53 -0600128/*
129 * Returns:
130 * < 0 : error
131 * >= 0 : the number of bytes accessible at the address
132 */
133typedef long (*dm_direct_access_fn) (struct dm_target *ti, sector_t sector,
Linus Torvaldsf0c98eb2016-07-28 17:22:07 -0700134 void **kaddr, pfn_t *pfn, long size);
Toshi Kani545ed202016-06-22 17:54:53 -0600135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136void dm_error(const char *message);
137
Mikulas Patocka82b15192008-10-10 13:37:09 +0100138struct dm_dev {
139 struct block_device *bdev;
Al Viroaeb5d722008-09-02 15:28:45 -0400140 fmode_t mode;
Mikulas Patocka82b15192008-10-10 13:37:09 +0100141 char name[16];
142};
143
DingXiang4df2bf42016-02-02 12:29:18 +0800144dev_t dm_get_dev_t(const char *path);
145
Bryn Reeves3cb40212006-10-03 01:15:42 -0700146/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 * Constructors should call these functions to ensure destination devices
148 * are opened/closed correctly.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 */
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +0000150int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
Mike Snitzer11f04312014-06-03 10:30:28 -0400151 struct dm_dev **result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152void dm_put_device(struct dm_target *ti, struct dm_dev *d);
153
154/*
155 * Information about a target type
156 */
Andi Kleenab4c142482009-01-06 03:05:09 +0000157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158struct target_type {
Andi Kleenab4c142482009-01-06 03:05:09 +0000159 uint64_t features;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 const char *name;
161 struct module *module;
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700162 unsigned version[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 dm_ctr_fn ctr;
164 dm_dtr_fn dtr;
165 dm_map_fn map;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000166 dm_map_request_fn map_rq;
Mike Snitzere5863d92014-12-17 21:08:12 -0500167 dm_clone_and_map_request_fn clone_and_map_rq;
168 dm_release_clone_request_fn release_clone_rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 dm_endio_fn end_io;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000170 dm_request_endio_fn rq_end_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 dm_presuspend_fn presuspend;
Mike Snitzerd67ee212014-10-28 20:13:31 -0400172 dm_presuspend_undo_fn presuspend_undo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 dm_postsuspend_fn postsuspend;
Milan Broz8757b772006-10-03 01:15:36 -0700174 dm_preresume_fn preresume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 dm_resume_fn resume;
176 dm_status_fn status;
177 dm_message_fn message;
Christoph Hellwige56f81e2015-10-15 14:10:50 +0200178 dm_prepare_ioctl_fn prepare_ioctl;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000179 dm_busy_fn busy;
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100180 dm_iterate_devices_fn iterate_devices;
Mike Snitzer40bea432009-09-04 20:40:25 +0100181 dm_io_hints_fn io_hints;
Toshi Kani545ed202016-06-22 17:54:53 -0600182 dm_direct_access_fn direct_access;
Cheng Renquan45194e42009-04-02 19:55:28 +0100183
184 /* For internal device-mapper use. */
185 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186};
187
Alasdair G Kergon3791e2f2011-10-31 20:19:00 +0000188/*
189 * Target features
190 */
191
192/*
193 * Any table that contains an instance of this target must have only one.
194 */
195#define DM_TARGET_SINGLETON 0x00000001
196#define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
197
Alasdair G Kergoncc6cbe12011-10-31 20:19:02 +0000198/*
199 * Indicates that a target does not support read-only devices.
200 */
201#define DM_TARGET_ALWAYS_WRITEABLE 0x00000002
202#define dm_target_always_writeable(type) \
203 ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
204
Alasdair G Kergon36a04562011-10-31 20:19:04 +0000205/*
206 * Any device that contains a table with an instance of this target may never
207 * have tables containing any different target type.
208 */
209#define DM_TARGET_IMMUTABLE 0x00000004
210#define dm_target_is_immutable(type) ((type)->features & DM_TARGET_IMMUTABLE)
211
Alasdair G Kergonb0d8ed42013-03-01 22:45:49 +0000212/*
Mike Snitzerf083b092016-02-06 18:38:46 -0500213 * Indicates that a target may replace any target; even immutable targets.
214 * .map, .map_rq, .clone_and_map_rq and .release_clone_rq are all defined.
215 */
216#define DM_TARGET_WILDCARD 0x00000008
217#define dm_target_is_wildcard(type) ((type)->features & DM_TARGET_WILDCARD)
218
219/*
Alasdair G Kergonb0d8ed42013-03-01 22:45:49 +0000220 * Some targets need to be sent the same WRITE bio severals times so
221 * that they can send copies of it to different devices. This function
222 * examines any supplied bio and returns the number of copies of it the
223 * target requires.
224 */
225typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227struct dm_target {
228 struct dm_table *table;
229 struct target_type *type;
230
231 /* target limits */
232 sector_t begin;
233 sector_t len;
234
Mike Snitzer542f9032012-07-27 15:08:00 +0100235 /* If non-zero, maximum size of I/O submitted to a target. */
236 uint32_t max_io_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000239 * A number of zero-length barrier bios that will be submitted
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100240 * to the target for the purpose of flushing cache.
241 *
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000242 * The bio number can be accessed with dm_bio_get_target_bio_nr.
243 * It is a responsibility of the target driver to remap these bios
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100244 * to the real underlying devices.
245 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000246 unsigned num_flush_bios;
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100247
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100248 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000249 * The number of discard bios that will be submitted to the target.
250 * The bio number can be accessed with dm_bio_get_target_bio_nr.
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100251 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000252 unsigned num_discard_bios;
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100253
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000254 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000255 * The number of WRITE SAME bios that will be submitted to the target.
256 * The bio number can be accessed with dm_bio_get_target_bio_nr.
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000257 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000258 unsigned num_write_same_bios;
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000259
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000260 /*
Mike Snitzer30187e12016-01-31 13:28:26 -0500261 * The minimum number of extra bytes allocated in each io for the
262 * target to use.
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000263 */
Mike Snitzer30187e12016-01-31 13:28:26 -0500264 unsigned per_io_data_size;
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000265
Alasdair G Kergonb0d8ed42013-03-01 22:45:49 +0000266 /*
267 * If defined, this function is called to find out how many
268 * duplicate bios should be sent to the target when writing
269 * data.
270 */
271 dm_num_write_bios_fn num_write_bios;
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 /* target specific data */
274 void *private;
275
276 /* Used to provide an error string from the ctr */
277 char *error;
Mike Snitzer4c259322011-05-29 12:52:55 +0100278
279 /*
Joe Thornber0e9c24e2012-07-27 15:08:07 +0100280 * Set if this target needs to receive flushes regardless of
281 * whether or not its underlying devices have support.
282 */
283 bool flush_supported:1;
284
285 /*
Mike Snitzer4c259322011-05-29 12:52:55 +0100286 * Set if this target needs to receive discards regardless of
287 * whether or not its underlying devices have support.
288 */
Alasdair G Kergon0ac55482012-07-27 15:08:08 +0100289 bool discards_supported:1;
Milan Broz983c7db2011-09-25 23:26:21 +0100290
291 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000292 * Set if the target required discard bios to be split
Mikulas Patocka7acf0272012-07-27 15:08:03 +0100293 * on max_io_len boundary.
294 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000295 bool split_discard_bios:1;
Mikulas Patocka7acf0272012-07-27 15:08:03 +0100296
297 /*
Milan Broz983c7db2011-09-25 23:26:21 +0100298 * Set if this target does not return zeroes on discarded blocks.
299 */
Alasdair G Kergon0ac55482012-07-27 15:08:08 +0100300 bool discard_zeroes_data_unsupported:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301};
302
NeilBrown9d357b02011-01-13 20:00:01 +0000303/* Each target can link one of these into the table */
304struct dm_target_callbacks {
305 struct list_head list;
306 int (*congested_fn) (struct dm_target_callbacks *, int);
307};
308
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000309/*
310 * For bio-based dm.
311 * One of these is allocated for each bio.
312 * This structure shouldn't be touched directly by target drivers.
313 * It is here so that we can inline dm_per_bio_data and
314 * dm_bio_from_per_bio_data
315 */
316struct dm_target_io {
317 struct dm_io *io;
318 struct dm_target *ti;
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000319 unsigned target_bio_nr;
Mikulas Patocka1dd40c32014-03-14 18:41:24 -0400320 unsigned *len_ptr;
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000321 struct bio clone;
322};
323
324static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
325{
326 return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
327}
328
329static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
330{
331 return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
332}
333
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000334static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
Mikulas Patockaddbd6582012-12-21 20:23:39 +0000335{
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000336 return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
Mikulas Patockaddbd6582012-12-21 20:23:39 +0000337}
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339int dm_register_target(struct target_type *t);
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000340void dm_unregister_target(struct target_type *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700341
Mike Snitzer498f0102011-08-02 12:32:04 +0100342/*
343 * Target argument parsing.
344 */
345struct dm_arg_set {
346 unsigned argc;
347 char **argv;
348};
349
350/*
351 * The minimum and maximum value of a numeric argument, together with
352 * the error message to use if the number is found to be outside that range.
353 */
354struct dm_arg {
355 unsigned min;
356 unsigned max;
357 char *error;
358};
359
360/*
361 * Validate the next argument, either returning it as *value or, if invalid,
362 * returning -EINVAL and setting *error.
363 */
364int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
365 unsigned *value, char **error);
366
367/*
368 * Process the next argument as the start of a group containing between
369 * arg->min and arg->max further arguments. Either return the size as
370 * *num_args or, if invalid, return -EINVAL and set *error.
371 */
372int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
373 unsigned *num_args, char **error);
374
375/*
376 * Return the current argument and shift to the next.
377 */
378const char *dm_shift_arg(struct dm_arg_set *as);
379
380/*
381 * Move through num_args arguments.
382 */
383void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
384
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700385/*-----------------------------------------------------------------
386 * Functions for creating and manipulating mapped devices.
387 * Drop the reference with dm_put when you finish with the object.
388 *---------------------------------------------------------------*/
389
390/*
391 * DM_ANY_MINOR chooses the next available minor number.
392 */
393#define DM_ANY_MINOR (-1)
394int dm_create(int minor, struct mapped_device **md);
395
396/*
397 * Reference counting for md.
398 */
399struct mapped_device *dm_get_md(dev_t dev);
400void dm_get(struct mapped_device *md);
Mikulas Patocka09ee96b2015-02-26 11:41:28 -0500401int dm_hold(struct mapped_device *md);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700402void dm_put(struct mapped_device *md);
403
404/*
405 * An arbitrary pointer may be stored alongside a mapped device.
406 */
407void dm_set_mdptr(struct mapped_device *md, void *ptr);
408void *dm_get_mdptr(struct mapped_device *md);
409
410/*
411 * A device can still be used while suspended, but I/O is deferred.
412 */
Kiyoshi Uedaa3d77d32006-12-08 02:41:04 -0800413int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700414int dm_resume(struct mapped_device *md);
415
416/*
417 * Event functions.
418 */
419uint32_t dm_get_event_nr(struct mapped_device *md);
420int dm_wait_event(struct mapped_device *md, int event_nr);
Mike Anderson7a8c3d32007-10-19 22:48:01 +0100421uint32_t dm_next_uevent_seq(struct mapped_device *md);
422void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700423
424/*
425 * Info functions.
426 */
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700427const char *dm_device_name(struct mapped_device *md);
Mike Anderson96a1f7d2007-10-19 22:47:59 +0100428int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700429struct gendisk *dm_disk(struct mapped_device *md);
Kiyoshi Ueda64dbce52009-12-10 23:52:27 +0000430int dm_suspended(struct dm_target *ti);
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -0800431int dm_noflush_suspending(struct dm_target *ti);
Mikulas Patocka1dd40c32014-03-14 18:41:24 -0400432void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
Kiyoshi Uedacec47e32009-06-22 10:12:35 +0100433union map_info *dm_get_rq_mapinfo(struct request *rq);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700434
Mike Snitzerf84cb8a2013-09-19 12:13:58 -0400435struct queue_limits *dm_get_queue_limits(struct mapped_device *md);
436
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700437/*
438 * Geometry functions.
439 */
440int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
441int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
442
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700443/*-----------------------------------------------------------------
444 * Functions for manipulating device-mapper tables.
445 *---------------------------------------------------------------*/
446
447/*
448 * First create an empty table.
449 */
Al Viroaeb5d722008-09-02 15:28:45 -0400450int dm_table_create(struct dm_table **result, fmode_t mode,
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700451 unsigned num_targets, struct mapped_device *md);
452
453/*
454 * Then call this once for each target.
455 */
456int dm_table_add_target(struct dm_table *t, const char *type,
457 sector_t start, sector_t len, char *params);
458
459/*
NeilBrown9d357b02011-01-13 20:00:01 +0000460 * Target_ctr should call this if it needs to add any callbacks.
461 */
462void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
463
464/*
Mike Snitzere83068a2016-05-24 21:16:51 -0400465 * Target can use this to set the table's type.
466 * Can only ever be called from a target's ctr.
467 * Useful for "hybrid" target (supports both bio-based
468 * and request-based).
469 */
470void dm_table_set_type(struct dm_table *t, unsigned type);
471
472/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700473 * Finally call this to make the table ready for use.
474 */
475int dm_table_complete(struct dm_table *t);
476
477/*
Mike Snitzer542f9032012-07-27 15:08:00 +0100478 * Target may require that it is never sent I/O larger than len.
479 */
480int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);
481
482/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700483 * Table reference counting.
484 */
Mikulas Patocka83d5e5b2013-07-10 23:41:18 +0100485struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx);
486void dm_put_live_table(struct mapped_device *md, int srcu_idx);
487void dm_sync_table(struct mapped_device *md);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700488
489/*
490 * Queries
491 */
492sector_t dm_table_get_size(struct dm_table *t);
493unsigned int dm_table_get_num_targets(struct dm_table *t);
Al Viroaeb5d722008-09-02 15:28:45 -0400494fmode_t dm_table_get_mode(struct dm_table *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700495struct mapped_device *dm_table_get_md(struct dm_table *t);
496
497/*
498 * Trigger an event.
499 */
500void dm_table_event(struct dm_table *t);
501
502/*
Mike Snitzer9974fa22014-02-28 15:33:43 +0100503 * Run the queue for request-based targets.
504 */
505void dm_table_run_md_queue_async(struct dm_table *t);
506
507/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700508 * The device must be suspended before calling this method.
Alasdair G Kergon042d2a92009-12-10 23:52:24 +0000509 * Returns the previous table, which the caller must destroy.
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700510 */
Alasdair G Kergon042d2a92009-12-10 23:52:24 +0000511struct dm_table *dm_swap_table(struct mapped_device *md,
512 struct dm_table *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700513
Mikulas Patocka54160902008-10-10 13:37:12 +0100514/*
515 * A wrapper around vmalloc.
516 */
517void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
518
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100519/*-----------------------------------------------------------------
520 * Macros.
521 *---------------------------------------------------------------*/
522#define DM_NAME "device-mapper"
523
Namhyung Kim71a16732011-10-31 20:18:54 +0000524#ifdef CONFIG_PRINTK
525extern struct ratelimit_state dm_ratelimit_state;
526
527#define dm_ratelimit() __ratelimit(&dm_ratelimit_state)
528#else
529#define dm_ratelimit() 0
530#endif
531
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000532#define DMCRIT(f, arg...) \
533 printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
534
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100535#define DMERR(f, arg...) \
536 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
537#define DMERR_LIMIT(f, arg...) \
538 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000539 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100540 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
541 f "\n", ## arg); \
542 } while (0)
543
544#define DMWARN(f, arg...) \
545 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
546#define DMWARN_LIMIT(f, arg...) \
547 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000548 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100549 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
550 f "\n", ## arg); \
551 } while (0)
552
553#define DMINFO(f, arg...) \
554 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
555#define DMINFO_LIMIT(f, arg...) \
556 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000557 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100558 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
559 "\n", ## arg); \
560 } while (0)
561
562#ifdef CONFIG_DM_DEBUG
563# define DMDEBUG(f, arg...) \
564 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
565# define DMDEBUG_LIMIT(f, arg...) \
566 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000567 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100568 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
569 "\n", ## arg); \
570 } while (0)
571#else
572# define DMDEBUG(f, arg...) do {} while (0)
573# define DMDEBUG_LIMIT(f, arg...) do {} while (0)
574#endif
575
576#define DMEMIT(x...) sz += ((sz >= maxlen) ? \
577 0 : scnprintf(result + sz, maxlen - sz, x))
578
579#define SECTOR_SHIFT 9
580
581/*
582 * Definitions of return values from target end_io function.
583 */
584#define DM_ENDIO_INCOMPLETE 1
585#define DM_ENDIO_REQUEUE 2
586
587/*
588 * Definitions of return values from target map function.
589 */
590#define DM_MAPIO_SUBMITTED 0
591#define DM_MAPIO_REMAPPED 1
592#define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE
Mike Snitzera8ac51e2016-09-09 19:24:57 -0400593#define DM_MAPIO_DELAY_REQUEUE 3
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100594
Mikulas Patockafd2ed4d2013-08-16 10:54:23 -0400595#define dm_sector_div64(x, y)( \
596{ \
597 u64 _res; \
598 (x) = div64_u64_rem(x, y, &_res); \
599 _res; \
600} \
601)
602
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100603/*
604 * Ceiling(n / sz)
605 */
606#define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
607
608#define dm_sector_div_up(n, sz) ( \
609{ \
610 sector_t _r = ((n) + (sz) - 1); \
611 sector_div(_r, (sz)); \
612 _r; \
613} \
614)
615
616/*
617 * ceiling(n / size) * size
618 */
619#define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
620
Mikulas Patockad63a5ce2008-10-21 17:44:57 +0100621#define dm_array_too_big(fixed, obj, num) \
622 ((num) > (UINT_MAX - (fixed)) / (obj))
623
Mike Snitzer56a67df2010-08-12 04:14:10 +0100624/*
625 * Sector offset taken relative to the start of the target instead of
626 * relative to the start of the device.
627 */
628#define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
629
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100630static inline sector_t to_sector(unsigned long n)
631{
632 return (n >> SECTOR_SHIFT);
633}
634
635static inline unsigned long to_bytes(sector_t n)
636{
637 return (n << SECTOR_SHIFT);
638}
639
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700640#endif /* _LINUX_DEVICE_MAPPER_H */