blob: 76d23fa8c7d3a21ba294e62be223f5a6992132a8 [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
22typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
23
24union map_info {
25 void *ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070026};
27
28/*
29 * In the constructor the target parameter will already have the
30 * table, type, begin and len fields filled in.
31 */
32typedef int (*dm_ctr_fn) (struct dm_target *target,
33 unsigned int argc, char **argv);
34
35/*
36 * The destructor doesn't need to free the dm_target, just
37 * anything hidden ti->private.
38 */
39typedef void (*dm_dtr_fn) (struct dm_target *ti);
40
41/*
42 * The map function must return:
43 * < 0: error
44 * = 0: The target will handle the io by resubmitting it later
Kiyoshi Ueda45cbcd72006-12-08 02:41:05 -080045 * = 1: simple remap complete
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -080046 * = 2: The target wants to push back the io
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 */
Mikulas Patocka7de3ee52012-12-21 20:23:41 +000048typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
Kiyoshi Ueda7d763452009-01-06 03:05:07 +000049typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
50 union map_info *map_context);
Mike Snitzere5863d92014-12-17 21:08:12 -050051typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,
52 struct request *rq,
53 union map_info *map_context,
54 struct request **clone);
55typedef void (*dm_release_clone_request_fn) (struct request *clone);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57/*
58 * Returns:
59 * < 0 : error (currently ignored)
60 * 0 : ended successfully
61 * 1 : for some reason the io has still not completed (eg,
62 * multipath target might want to requeue a failed io).
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -080063 * 2 : The target wants to push back the io
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 */
65typedef int (*dm_endio_fn) (struct dm_target *ti,
Mikulas Patocka7de3ee52012-12-21 20:23:41 +000066 struct bio *bio, int error);
Kiyoshi Ueda7d763452009-01-06 03:05:07 +000067typedef int (*dm_request_endio_fn) (struct dm_target *ti,
68 struct request *clone, int error,
69 union map_info *map_context);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71typedef void (*dm_presuspend_fn) (struct dm_target *ti);
Mike Snitzerd67ee212014-10-28 20:13:31 -040072typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
Milan Broz8757b772006-10-03 01:15:36 -070074typedef int (*dm_preresume_fn) (struct dm_target *ti);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075typedef void (*dm_resume_fn) (struct dm_target *ti);
76
Mikulas Patockafd7c0922013-03-01 22:45:44 +000077typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
78 unsigned status_flags, char *result, unsigned maxlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
81
Al Viro647b3d02007-08-28 22:15:59 -040082typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
Milan Brozaa129a22006-10-03 01:15:15 -070083 unsigned long arg);
84
Alasdair G Kergon058ce5c2013-05-10 14:37:17 +010085/*
86 * These iteration functions are typically used to check (and combine)
87 * properties of underlying devices.
88 * E.g. Does at least one underlying device support flush?
89 * Does any underlying device not support WRITE_SAME?
90 *
91 * The callout function is called once for each contiguous section of
92 * an underlying device. State can be maintained in *data.
93 * Return non-zero to stop iterating through any further devices.
94 */
Mike Snitzeraf4874e2009-06-22 10:12:33 +010095typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
96 struct dm_dev *dev,
Mike Snitzer5dea2712009-07-23 20:30:42 +010097 sector_t start, sector_t len,
Mike Snitzeraf4874e2009-06-22 10:12:33 +010098 void *data);
99
Alasdair G Kergon058ce5c2013-05-10 14:37:17 +0100100/*
101 * This function must iterate through each section of device used by the
102 * target until it encounters a non-zero return code, which it then returns.
103 * Returns zero if no callout returned non-zero.
104 */
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100105typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
106 iterate_devices_callout_fn fn,
107 void *data);
108
Mike Snitzer40bea432009-09-04 20:40:25 +0100109typedef void (*dm_io_hints_fn) (struct dm_target *ti,
110 struct queue_limits *limits);
111
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000112/*
113 * Returns:
114 * 0: The target can handle the next I/O immediately.
115 * 1: The target can't handle the next I/O immediately.
116 */
117typedef int (*dm_busy_fn) (struct dm_target *ti);
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119void dm_error(const char *message);
120
Mikulas Patocka82b15192008-10-10 13:37:09 +0100121struct dm_dev {
122 struct block_device *bdev;
Al Viroaeb5d722008-09-02 15:28:45 -0400123 fmode_t mode;
Mikulas Patocka82b15192008-10-10 13:37:09 +0100124 char name[16];
125};
126
Bryn Reeves3cb40212006-10-03 01:15:42 -0700127/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 * Constructors should call these functions to ensure destination devices
129 * are opened/closed correctly.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 */
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +0000131int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
Mike Snitzer11f04312014-06-03 10:30:28 -0400132 struct dm_dev **result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133void dm_put_device(struct dm_target *ti, struct dm_dev *d);
134
135/*
136 * Information about a target type
137 */
Andi Kleenab4c142482009-01-06 03:05:09 +0000138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139struct target_type {
Andi Kleenab4c142482009-01-06 03:05:09 +0000140 uint64_t features;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 const char *name;
142 struct module *module;
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700143 unsigned version[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 dm_ctr_fn ctr;
145 dm_dtr_fn dtr;
146 dm_map_fn map;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000147 dm_map_request_fn map_rq;
Mike Snitzere5863d92014-12-17 21:08:12 -0500148 dm_clone_and_map_request_fn clone_and_map_rq;
149 dm_release_clone_request_fn release_clone_rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 dm_endio_fn end_io;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000151 dm_request_endio_fn rq_end_io;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 dm_presuspend_fn presuspend;
Mike Snitzerd67ee212014-10-28 20:13:31 -0400153 dm_presuspend_undo_fn presuspend_undo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 dm_postsuspend_fn postsuspend;
Milan Broz8757b772006-10-03 01:15:36 -0700155 dm_preresume_fn preresume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 dm_resume_fn resume;
157 dm_status_fn status;
158 dm_message_fn message;
Milan Brozaa129a22006-10-03 01:15:15 -0700159 dm_ioctl_fn ioctl;
Kiyoshi Ueda7d763452009-01-06 03:05:07 +0000160 dm_busy_fn busy;
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100161 dm_iterate_devices_fn iterate_devices;
Mike Snitzer40bea432009-09-04 20:40:25 +0100162 dm_io_hints_fn io_hints;
Cheng Renquan45194e42009-04-02 19:55:28 +0100163
164 /* For internal device-mapper use. */
165 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166};
167
Alasdair G Kergon3791e2f2011-10-31 20:19:00 +0000168/*
169 * Target features
170 */
171
172/*
173 * Any table that contains an instance of this target must have only one.
174 */
175#define DM_TARGET_SINGLETON 0x00000001
176#define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
177
Alasdair G Kergoncc6cbe12011-10-31 20:19:02 +0000178/*
179 * Indicates that a target does not support read-only devices.
180 */
181#define DM_TARGET_ALWAYS_WRITEABLE 0x00000002
182#define dm_target_always_writeable(type) \
183 ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
184
Alasdair G Kergon36a04562011-10-31 20:19:04 +0000185/*
186 * Any device that contains a table with an instance of this target may never
187 * have tables containing any different target type.
188 */
189#define DM_TARGET_IMMUTABLE 0x00000004
190#define dm_target_is_immutable(type) ((type)->features & DM_TARGET_IMMUTABLE)
191
Alasdair G Kergonb0d8ed42013-03-01 22:45:49 +0000192/*
193 * Some targets need to be sent the same WRITE bio severals times so
194 * that they can send copies of it to different devices. This function
195 * examines any supplied bio and returns the number of copies of it the
196 * target requires.
197 */
198typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200struct dm_target {
201 struct dm_table *table;
202 struct target_type *type;
203
204 /* target limits */
205 sector_t begin;
206 sector_t len;
207
Mike Snitzer542f9032012-07-27 15:08:00 +0100208 /* If non-zero, maximum size of I/O submitted to a target. */
209 uint32_t max_io_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000212 * A number of zero-length barrier bios that will be submitted
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100213 * to the target for the purpose of flushing cache.
214 *
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000215 * The bio number can be accessed with dm_bio_get_target_bio_nr.
216 * It is a responsibility of the target driver to remap these bios
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100217 * to the real underlying devices.
218 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000219 unsigned num_flush_bios;
Mikulas Patockaf9ab94c2009-06-22 10:12:20 +0100220
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100221 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000222 * The number of discard bios that will be submitted to the target.
223 * The bio number can be accessed with dm_bio_get_target_bio_nr.
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100224 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000225 unsigned num_discard_bios;
Mike Snitzer5ae89a82010-08-12 04:14:08 +0100226
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000227 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000228 * The number of WRITE SAME bios that will be submitted to the target.
229 * The bio number can be accessed with dm_bio_get_target_bio_nr.
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000230 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000231 unsigned num_write_same_bios;
Mike Snitzerd54eaa52012-12-21 20:23:36 +0000232
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000233 /*
234 * The minimum number of extra bytes allocated in each bio for the
235 * target to use. dm_per_bio_data returns the data location.
236 */
237 unsigned per_bio_data_size;
238
Alasdair G Kergonb0d8ed42013-03-01 22:45:49 +0000239 /*
240 * If defined, this function is called to find out how many
241 * duplicate bios should be sent to the target when writing
242 * data.
243 */
244 dm_num_write_bios_fn num_write_bios;
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* target specific data */
247 void *private;
248
249 /* Used to provide an error string from the ctr */
250 char *error;
Mike Snitzer4c259322011-05-29 12:52:55 +0100251
252 /*
Joe Thornber0e9c24e2012-07-27 15:08:07 +0100253 * Set if this target needs to receive flushes regardless of
254 * whether or not its underlying devices have support.
255 */
256 bool flush_supported:1;
257
258 /*
Mike Snitzer4c259322011-05-29 12:52:55 +0100259 * Set if this target needs to receive discards regardless of
260 * whether or not its underlying devices have support.
261 */
Alasdair G Kergon0ac55482012-07-27 15:08:08 +0100262 bool discards_supported:1;
Milan Broz983c7db2011-09-25 23:26:21 +0100263
264 /*
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000265 * Set if the target required discard bios to be split
Mikulas Patocka7acf0272012-07-27 15:08:03 +0100266 * on max_io_len boundary.
267 */
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000268 bool split_discard_bios:1;
Mikulas Patocka7acf0272012-07-27 15:08:03 +0100269
270 /*
Milan Broz983c7db2011-09-25 23:26:21 +0100271 * Set if this target does not return zeroes on discarded blocks.
272 */
Alasdair G Kergon0ac55482012-07-27 15:08:08 +0100273 bool discard_zeroes_data_unsupported:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274};
275
NeilBrown9d357b02011-01-13 20:00:01 +0000276/* Each target can link one of these into the table */
277struct dm_target_callbacks {
278 struct list_head list;
279 int (*congested_fn) (struct dm_target_callbacks *, int);
280};
281
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000282/*
283 * For bio-based dm.
284 * One of these is allocated for each bio.
285 * This structure shouldn't be touched directly by target drivers.
286 * It is here so that we can inline dm_per_bio_data and
287 * dm_bio_from_per_bio_data
288 */
289struct dm_target_io {
290 struct dm_io *io;
291 struct dm_target *ti;
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000292 unsigned target_bio_nr;
Mikulas Patocka1dd40c32014-03-14 18:41:24 -0400293 unsigned *len_ptr;
Mikulas Patockac0820cf2012-12-21 20:23:38 +0000294 struct bio clone;
295};
296
297static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
298{
299 return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
300}
301
302static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
303{
304 return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
305}
306
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000307static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
Mikulas Patockaddbd6582012-12-21 20:23:39 +0000308{
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000309 return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
Mikulas Patockaddbd6582012-12-21 20:23:39 +0000310}
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312int dm_register_target(struct target_type *t);
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000313void dm_unregister_target(struct target_type *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700314
Mike Snitzer498f0102011-08-02 12:32:04 +0100315/*
316 * Target argument parsing.
317 */
318struct dm_arg_set {
319 unsigned argc;
320 char **argv;
321};
322
323/*
324 * The minimum and maximum value of a numeric argument, together with
325 * the error message to use if the number is found to be outside that range.
326 */
327struct dm_arg {
328 unsigned min;
329 unsigned max;
330 char *error;
331};
332
333/*
334 * Validate the next argument, either returning it as *value or, if invalid,
335 * returning -EINVAL and setting *error.
336 */
337int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
338 unsigned *value, char **error);
339
340/*
341 * Process the next argument as the start of a group containing between
342 * arg->min and arg->max further arguments. Either return the size as
343 * *num_args or, if invalid, return -EINVAL and set *error.
344 */
345int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
346 unsigned *num_args, char **error);
347
348/*
349 * Return the current argument and shift to the next.
350 */
351const char *dm_shift_arg(struct dm_arg_set *as);
352
353/*
354 * Move through num_args arguments.
355 */
356void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
357
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700358/*-----------------------------------------------------------------
359 * Functions for creating and manipulating mapped devices.
360 * Drop the reference with dm_put when you finish with the object.
361 *---------------------------------------------------------------*/
362
363/*
364 * DM_ANY_MINOR chooses the next available minor number.
365 */
366#define DM_ANY_MINOR (-1)
367int dm_create(int minor, struct mapped_device **md);
368
369/*
370 * Reference counting for md.
371 */
372struct mapped_device *dm_get_md(dev_t dev);
373void dm_get(struct mapped_device *md);
Mikulas Patocka09ee96b2015-02-26 11:41:28 -0500374int dm_hold(struct mapped_device *md);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700375void dm_put(struct mapped_device *md);
376
377/*
378 * An arbitrary pointer may be stored alongside a mapped device.
379 */
380void dm_set_mdptr(struct mapped_device *md, void *ptr);
381void *dm_get_mdptr(struct mapped_device *md);
382
383/*
384 * A device can still be used while suspended, but I/O is deferred.
385 */
Kiyoshi Uedaa3d77d32006-12-08 02:41:04 -0800386int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700387int dm_resume(struct mapped_device *md);
388
389/*
390 * Event functions.
391 */
392uint32_t dm_get_event_nr(struct mapped_device *md);
393int dm_wait_event(struct mapped_device *md, int event_nr);
Mike Anderson7a8c3d32007-10-19 22:48:01 +0100394uint32_t dm_next_uevent_seq(struct mapped_device *md);
395void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700396
397/*
398 * Info functions.
399 */
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700400const char *dm_device_name(struct mapped_device *md);
Mike Anderson96a1f7d2007-10-19 22:47:59 +0100401int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700402struct gendisk *dm_disk(struct mapped_device *md);
Kiyoshi Ueda64dbce52009-12-10 23:52:27 +0000403int dm_suspended(struct dm_target *ti);
Kiyoshi Ueda2e93ccc2006-12-08 02:41:09 -0800404int dm_noflush_suspending(struct dm_target *ti);
Mikulas Patocka1dd40c32014-03-14 18:41:24 -0400405void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
Kiyoshi Uedacec47e32009-06-22 10:12:35 +0100406union map_info *dm_get_rq_mapinfo(struct request *rq);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700407
Mike Snitzerf84cb8a2013-09-19 12:13:58 -0400408struct queue_limits *dm_get_queue_limits(struct mapped_device *md);
409
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700410/*
411 * Geometry functions.
412 */
413int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
414int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
415
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700416/*-----------------------------------------------------------------
417 * Functions for manipulating device-mapper tables.
418 *---------------------------------------------------------------*/
419
420/*
421 * First create an empty table.
422 */
Al Viroaeb5d722008-09-02 15:28:45 -0400423int dm_table_create(struct dm_table **result, fmode_t mode,
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700424 unsigned num_targets, struct mapped_device *md);
425
426/*
427 * Then call this once for each target.
428 */
429int dm_table_add_target(struct dm_table *t, const char *type,
430 sector_t start, sector_t len, char *params);
431
432/*
NeilBrown9d357b02011-01-13 20:00:01 +0000433 * Target_ctr should call this if it needs to add any callbacks.
434 */
435void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
436
437/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700438 * Finally call this to make the table ready for use.
439 */
440int dm_table_complete(struct dm_table *t);
441
442/*
Mike Snitzer542f9032012-07-27 15:08:00 +0100443 * Target may require that it is never sent I/O larger than len.
444 */
445int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);
446
447/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700448 * Table reference counting.
449 */
Mikulas Patocka83d5e5b2013-07-10 23:41:18 +0100450struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx);
451void dm_put_live_table(struct mapped_device *md, int srcu_idx);
452void dm_sync_table(struct mapped_device *md);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700453
454/*
455 * Queries
456 */
457sector_t dm_table_get_size(struct dm_table *t);
458unsigned int dm_table_get_num_targets(struct dm_table *t);
Al Viroaeb5d722008-09-02 15:28:45 -0400459fmode_t dm_table_get_mode(struct dm_table *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700460struct mapped_device *dm_table_get_md(struct dm_table *t);
461
462/*
463 * Trigger an event.
464 */
465void dm_table_event(struct dm_table *t);
466
467/*
Mike Snitzer9974fa22014-02-28 15:33:43 +0100468 * Run the queue for request-based targets.
469 */
470void dm_table_run_md_queue_async(struct dm_table *t);
471
472/*
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700473 * The device must be suspended before calling this method.
Alasdair G Kergon042d2a92009-12-10 23:52:24 +0000474 * Returns the previous table, which the caller must destroy.
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700475 */
Alasdair G Kergon042d2a92009-12-10 23:52:24 +0000476struct dm_table *dm_swap_table(struct mapped_device *md,
477 struct dm_table *t);
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700478
Mikulas Patocka54160902008-10-10 13:37:12 +0100479/*
480 * A wrapper around vmalloc.
481 */
482void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
483
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100484/*-----------------------------------------------------------------
485 * Macros.
486 *---------------------------------------------------------------*/
487#define DM_NAME "device-mapper"
488
Namhyung Kim71a16732011-10-31 20:18:54 +0000489#ifdef CONFIG_PRINTK
490extern struct ratelimit_state dm_ratelimit_state;
491
492#define dm_ratelimit() __ratelimit(&dm_ratelimit_state)
493#else
494#define dm_ratelimit() 0
495#endif
496
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000497#define DMCRIT(f, arg...) \
498 printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
499
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100500#define DMERR(f, arg...) \
501 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
502#define DMERR_LIMIT(f, arg...) \
503 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000504 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100505 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
506 f "\n", ## arg); \
507 } while (0)
508
509#define DMWARN(f, arg...) \
510 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
511#define DMWARN_LIMIT(f, arg...) \
512 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000513 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100514 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
515 f "\n", ## arg); \
516 } while (0)
517
518#define DMINFO(f, arg...) \
519 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
520#define DMINFO_LIMIT(f, arg...) \
521 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000522 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100523 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
524 "\n", ## arg); \
525 } while (0)
526
527#ifdef CONFIG_DM_DEBUG
528# define DMDEBUG(f, arg...) \
529 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
530# define DMDEBUG_LIMIT(f, arg...) \
531 do { \
Namhyung Kim71a16732011-10-31 20:18:54 +0000532 if (dm_ratelimit()) \
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100533 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
534 "\n", ## arg); \
535 } while (0)
536#else
537# define DMDEBUG(f, arg...) do {} while (0)
538# define DMDEBUG_LIMIT(f, arg...) do {} while (0)
539#endif
540
541#define DMEMIT(x...) sz += ((sz >= maxlen) ? \
542 0 : scnprintf(result + sz, maxlen - sz, x))
543
544#define SECTOR_SHIFT 9
545
546/*
547 * Definitions of return values from target end_io function.
548 */
549#define DM_ENDIO_INCOMPLETE 1
550#define DM_ENDIO_REQUEUE 2
551
552/*
553 * Definitions of return values from target map function.
554 */
555#define DM_MAPIO_SUBMITTED 0
556#define DM_MAPIO_REMAPPED 1
557#define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE
558
Mikulas Patockafd2ed4d2013-08-16 10:54:23 -0400559#define dm_sector_div64(x, y)( \
560{ \
561 u64 _res; \
562 (x) = div64_u64_rem(x, y, &_res); \
563 _res; \
564} \
565)
566
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100567/*
568 * Ceiling(n / sz)
569 */
570#define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
571
572#define dm_sector_div_up(n, sz) ( \
573{ \
574 sector_t _r = ((n) + (sz) - 1); \
575 sector_div(_r, (sz)); \
576 _r; \
577} \
578)
579
580/*
581 * ceiling(n / size) * size
582 */
583#define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
584
Mikulas Patockad63a5ce2008-10-21 17:44:57 +0100585#define dm_array_too_big(fixed, obj, num) \
586 ((num) > (UINT_MAX - (fixed)) / (obj))
587
Mike Snitzer56a67df2010-08-12 04:14:10 +0100588/*
589 * Sector offset taken relative to the start of the target instead of
590 * relative to the start of the device.
591 */
592#define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
593
Alasdair G Kergon0da336e2008-04-24 21:43:52 +0100594static inline sector_t to_sector(unsigned long n)
595{
596 return (n >> SECTOR_SHIFT);
597}
598
599static inline unsigned long to_bytes(sector_t n)
600{
601 return (n << SECTOR_SHIFT);
602}
603
Alasdair G Kergon17b2f662006-06-26 00:27:33 -0700604#endif /* _LINUX_DEVICE_MAPPER_H */