2 * Copyright (C) 2001 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
5 * This file is released under the LGPL.
8 #ifndef _LINUX_DEVICE_MAPPER_H
9 #define _LINUX_DEVICE_MAPPER_H
11 #include <linux/bio.h>
12 #include <linux/blkdev.h>
13 #include <linux/ratelimit.h>
21 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
25 unsigned long long ll;
26 unsigned target_request_nr;
30 * In the constructor the target parameter will already have the
31 * table, type, begin and len fields filled in.
33 typedef int (*dm_ctr_fn) (struct dm_target *target,
34 unsigned int argc, char **argv);
37 * The destructor doesn't need to free the dm_target, just
38 * anything hidden ti->private.
40 typedef void (*dm_dtr_fn) (struct dm_target *ti);
43 * The map function must return:
45 * = 0: The target will handle the io by resubmitting it later
46 * = 1: simple remap complete
47 * = 2: The target wants to push back the io
49 typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio,
50 union map_info *map_context);
51 typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
52 union map_info *map_context);
56 * < 0 : error (currently ignored)
57 * 0 : ended successfully
58 * 1 : for some reason the io has still not completed (eg,
59 * multipath target might want to requeue a failed io).
60 * 2 : The target wants to push back the io
62 typedef int (*dm_endio_fn) (struct dm_target *ti,
63 struct bio *bio, int error,
64 union map_info *map_context);
65 typedef int (*dm_request_endio_fn) (struct dm_target *ti,
66 struct request *clone, int error,
67 union map_info *map_context);
69 typedef void (*dm_flush_fn) (struct dm_target *ti);
70 typedef void (*dm_presuspend_fn) (struct dm_target *ti);
71 typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
72 typedef int (*dm_preresume_fn) (struct dm_target *ti);
73 typedef void (*dm_resume_fn) (struct dm_target *ti);
75 typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
76 char *result, unsigned maxlen);
78 typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
80 typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
83 typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm,
84 struct bio_vec *biovec, int max_size);
86 typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
88 sector_t start, sector_t len,
91 typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
92 iterate_devices_callout_fn fn,
95 typedef void (*dm_io_hints_fn) (struct dm_target *ti,
96 struct queue_limits *limits);
100 * 0: The target can handle the next I/O immediately.
101 * 1: The target can't handle the next I/O immediately.
103 typedef int (*dm_busy_fn) (struct dm_target *ti);
105 void dm_error(const char *message);
108 * Combine device limits.
110 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
111 sector_t start, sector_t len, void *data);
114 struct block_device *bdev;
119 dev_t dm_get_dev_t(const char *path);
122 * Constructors should call these functions to ensure destination devices
123 * are opened/closed correctly.
125 int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
126 struct dm_dev **result);
127 void dm_put_device(struct dm_target *ti, struct dm_dev *d);
130 * Information about a target type
136 struct module *module;
141 dm_map_request_fn map_rq;
143 dm_request_endio_fn rq_end_io;
145 dm_presuspend_fn presuspend;
146 dm_postsuspend_fn postsuspend;
147 dm_preresume_fn preresume;
150 dm_message_fn message;
154 dm_iterate_devices_fn iterate_devices;
155 dm_io_hints_fn io_hints;
157 /* For internal device-mapper use. */
158 struct list_head list;
166 * Any table that contains an instance of this target must have only one.
168 #define DM_TARGET_SINGLETON 0x00000001
169 #define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
172 * Indicates that a target does not support read-only devices.
174 #define DM_TARGET_ALWAYS_WRITEABLE 0x00000002
175 #define dm_target_always_writeable(type) \
176 ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
179 * Any device that contains a table with an instance of this target may never
180 * have tables containing any different target type.
182 #define DM_TARGET_IMMUTABLE 0x00000004
183 #define dm_target_is_immutable(type) ((type)->features & DM_TARGET_IMMUTABLE)
186 struct dm_table *table;
187 struct target_type *type;
193 /* Always a power of 2 */
197 * A number of zero-length barrier requests that will be submitted
198 * to the target for the purpose of flushing cache.
200 * The request number will be placed in union map_info->target_request_nr.
201 * It is a responsibility of the target driver to remap these requests
202 * to the real underlying devices.
204 unsigned num_flush_requests;
207 * The number of discard requests that will be submitted to the
208 * target. map_info->request_nr is used just like num_flush_requests.
210 unsigned num_discard_requests;
212 /* target specific data */
215 /* Used to provide an error string from the ctr */
219 * Set if this target needs to receive discards regardless of
220 * whether or not its underlying devices have support.
222 unsigned discards_supported:1;
225 * Set if this target does not return zeroes on discarded blocks.
227 unsigned discard_zeroes_data_unsupported:1;
230 /* Each target can link one of these into the table */
231 struct dm_target_callbacks {
232 struct list_head list;
233 int (*congested_fn) (struct dm_target_callbacks *, int);
236 int dm_register_target(struct target_type *t);
237 void dm_unregister_target(struct target_type *t);
240 * Target argument parsing.
248 * The minimum and maximum value of a numeric argument, together with
249 * the error message to use if the number is found to be outside that range.
258 * Validate the next argument, either returning it as *value or, if invalid,
259 * returning -EINVAL and setting *error.
261 int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
262 unsigned *value, char **error);
265 * Process the next argument as the start of a group containing between
266 * arg->min and arg->max further arguments. Either return the size as
267 * *num_args or, if invalid, return -EINVAL and set *error.
269 int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
270 unsigned *num_args, char **error);
273 * Return the current argument and shift to the next.
275 const char *dm_shift_arg(struct dm_arg_set *as);
278 * Move through num_args arguments.
280 void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
282 /*-----------------------------------------------------------------
283 * Functions for creating and manipulating mapped devices.
284 * Drop the reference with dm_put when you finish with the object.
285 *---------------------------------------------------------------*/
288 * DM_ANY_MINOR chooses the next available minor number.
290 #define DM_ANY_MINOR (-1)
291 int dm_create(int minor, struct mapped_device **md);
294 * Reference counting for md.
296 struct mapped_device *dm_get_md(dev_t dev);
297 void dm_get(struct mapped_device *md);
298 void dm_put(struct mapped_device *md);
301 * An arbitrary pointer may be stored alongside a mapped device.
303 void dm_set_mdptr(struct mapped_device *md, void *ptr);
304 void *dm_get_mdptr(struct mapped_device *md);
307 * A device can still be used while suspended, but I/O is deferred.
309 int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
310 int dm_resume(struct mapped_device *md);
315 uint32_t dm_get_event_nr(struct mapped_device *md);
316 int dm_wait_event(struct mapped_device *md, int event_nr);
317 uint32_t dm_next_uevent_seq(struct mapped_device *md);
318 void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
323 const char *dm_device_name(struct mapped_device *md);
324 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
325 struct gendisk *dm_disk(struct mapped_device *md);
326 int dm_suspended(struct dm_target *ti);
327 int dm_noflush_suspending(struct dm_target *ti);
328 union map_info *dm_get_mapinfo(struct bio *bio);
329 union map_info *dm_get_rq_mapinfo(struct request *rq);
332 * Geometry functions.
334 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
335 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
338 /*-----------------------------------------------------------------
339 * Functions for manipulating device-mapper tables.
340 *---------------------------------------------------------------*/
343 * First create an empty table.
345 int dm_table_create(struct dm_table **result, fmode_t mode,
346 unsigned num_targets, struct mapped_device *md);
349 * Then call this once for each target.
351 int dm_table_add_target(struct dm_table *t, const char *type,
352 sector_t start, sector_t len, char *params);
355 * Target_ctr should call this if it needs to add any callbacks.
357 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
360 * Finally call this to make the table ready for use.
362 int dm_table_complete(struct dm_table *t);
365 * Table reference counting.
367 struct dm_table *dm_get_live_table(struct mapped_device *md);
368 void dm_table_get(struct dm_table *t);
369 void dm_table_put(struct dm_table *t);
374 sector_t dm_table_get_size(struct dm_table *t);
375 unsigned int dm_table_get_num_targets(struct dm_table *t);
376 fmode_t dm_table_get_mode(struct dm_table *t);
377 struct mapped_device *dm_table_get_md(struct dm_table *t);
382 void dm_table_event(struct dm_table *t);
385 * The device must be suspended before calling this method.
386 * Returns the previous table, which the caller must destroy.
388 struct dm_table *dm_swap_table(struct mapped_device *md,
392 * A wrapper around vmalloc.
394 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
396 /*-----------------------------------------------------------------
398 *---------------------------------------------------------------*/
399 #define DM_NAME "device-mapper"
401 #define DM_RATELIMIT(pr_func, fmt, ...) \
403 static DEFINE_RATELIMIT_STATE(rs, DEFAULT_RATELIMIT_INTERVAL, \
404 DEFAULT_RATELIMIT_BURST); \
406 if (__ratelimit(&rs)) \
407 pr_func(DM_FMT(fmt), ##__VA_ARGS__); \
410 #define DM_FMT(fmt) DM_NAME ": " DM_MSG_PREFIX ": " fmt "\n"
412 #define DMCRIT(fmt, ...) pr_crit(DM_FMT(fmt), ##__VA_ARGS__)
414 #define DMERR(fmt, ...) pr_err(DM_FMT(fmt), ##__VA_ARGS__)
415 #define DMERR_LIMIT(fmt, ...) DM_RATELIMIT(pr_err, fmt, ##__VA_ARGS__)
416 #define DMWARN(fmt, ...) pr_warn(DM_FMT(fmt), ##__VA_ARGS__)
417 #define DMWARN_LIMIT(fmt, ...) DM_RATELIMIT(pr_warn, fmt, ##__VA_ARGS__)
418 #define DMINFO(fmt, ...) pr_info(DM_FMT(fmt), ##__VA_ARGS__)
419 #define DMINFO_LIMIT(fmt, ...) DM_RATELIMIT(pr_info, fmt, ##__VA_ARGS__)
421 #ifdef CONFIG_DM_DEBUG
422 #define DMDEBUG(fmt, ...) printk(KERN_DEBUG DM_FMT(fmt), ##__VA_ARGS__)
423 #define DMDEBUG_LIMIT(fmt, ...) DM_RATELIMIT(pr_debug, fmt, ##__VA_ARGS__)
425 #define DMDEBUG(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
426 #define DMDEBUG_LIMIT(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
429 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
430 0 : scnprintf(result + sz, maxlen - sz, x))
432 #define SECTOR_SHIFT 9
435 * Definitions of return values from target end_io function.
437 #define DM_ENDIO_INCOMPLETE 1
438 #define DM_ENDIO_REQUEUE 2
441 * Definitions of return values from target map function.
443 #define DM_MAPIO_SUBMITTED 0
444 #define DM_MAPIO_REMAPPED 1
445 #define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE
450 #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
452 #define dm_sector_div_up(n, sz) ( \
454 sector_t _r = ((n) + (sz) - 1); \
455 sector_div(_r, (sz)); \
461 * ceiling(n / size) * size
463 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
465 #define dm_array_too_big(fixed, obj, num) \
466 ((num) > (UINT_MAX - (fixed)) / (obj))
469 * Sector offset taken relative to the start of the target instead of
470 * relative to the start of the device.
472 #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
474 static inline sector_t to_sector(unsigned long n)
476 return (n >> SECTOR_SHIFT);
479 static inline unsigned long to_bytes(sector_t n)
481 return (n << SECTOR_SHIFT);
484 /*-----------------------------------------------------------------
485 * Helper for block layer and dm core operations
486 *---------------------------------------------------------------*/
487 void dm_dispatch_request(struct request *rq);
488 void dm_requeue_unmapped_request(struct request *rq);
489 void dm_kill_unmapped_request(struct request *rq, int error);
490 int dm_underlying_device_busy(struct request_queue *q);
492 #endif /* _LINUX_DEVICE_MAPPER_H */