e1e1842c5ce9696e302c8b8b8c357092d08ed2a6
[pandora-kernel.git] / include / linux / device-mapper.h
1 /*
2  * Copyright (C) 2001 Sistina Software (UK) Limited.
3  * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4  *
5  * This file is released under the LGPL.
6  */
7
8 #ifndef _LINUX_DEVICE_MAPPER_H
9 #define _LINUX_DEVICE_MAPPER_H
10
11 #include <linux/bio.h>
12 #include <linux/blkdev.h>
13 #include <linux/ratelimit.h>
14
15 struct dm_dev;
16 struct dm_target;
17 struct dm_table;
18 struct mapped_device;
19 struct bio_vec;
20
21 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
22
23 union map_info {
24         void *ptr;
25         unsigned long long ll;
26         unsigned target_request_nr;
27 };
28
29 /*
30  * In the constructor the target parameter will already have the
31  * table, type, begin and len fields filled in.
32  */
33 typedef int (*dm_ctr_fn) (struct dm_target *target,
34                           unsigned int argc, char **argv);
35
36 /*
37  * The destructor doesn't need to free the dm_target, just
38  * anything hidden ti->private.
39  */
40 typedef void (*dm_dtr_fn) (struct dm_target *ti);
41
42 /*
43  * The map function must return:
44  * < 0: error
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
48  */
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);
53
54 /*
55  * Returns:
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
61  */
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);
68
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);
74
75 typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
76                               char *result, unsigned maxlen);
77
78 typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
79
80 typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
81                             unsigned long arg);
82
83 typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm,
84                             struct bio_vec *biovec, int max_size);
85
86 typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
87                                            struct dm_dev *dev,
88                                            sector_t start, sector_t len,
89                                            void *data);
90
91 typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
92                                       iterate_devices_callout_fn fn,
93                                       void *data);
94
95 typedef void (*dm_io_hints_fn) (struct dm_target *ti,
96                                 struct queue_limits *limits);
97
98 /*
99  * Returns:
100  *    0: The target can handle the next I/O immediately.
101  *    1: The target can't handle the next I/O immediately.
102  */
103 typedef int (*dm_busy_fn) (struct dm_target *ti);
104
105 void dm_error(const char *message);
106
107 /*
108  * Combine device limits.
109  */
110 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
111                          sector_t start, sector_t len, void *data);
112
113 struct dm_dev {
114         struct block_device *bdev;
115         fmode_t mode;
116         char name[16];
117 };
118
119 dev_t dm_get_dev_t(const char *path);
120
121 /*
122  * Constructors should call these functions to ensure destination devices
123  * are opened/closed correctly.
124  */
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);
128
129 /*
130  * Information about a target type
131  */
132
133 struct target_type {
134         uint64_t features;
135         const char *name;
136         struct module *module;
137         unsigned version[3];
138         dm_ctr_fn ctr;
139         dm_dtr_fn dtr;
140         dm_map_fn map;
141         dm_map_request_fn map_rq;
142         dm_endio_fn end_io;
143         dm_request_endio_fn rq_end_io;
144         dm_flush_fn flush;
145         dm_presuspend_fn presuspend;
146         dm_postsuspend_fn postsuspend;
147         dm_preresume_fn preresume;
148         dm_resume_fn resume;
149         dm_status_fn status;
150         dm_message_fn message;
151         dm_ioctl_fn ioctl;
152         dm_merge_fn merge;
153         dm_busy_fn busy;
154         dm_iterate_devices_fn iterate_devices;
155         dm_io_hints_fn io_hints;
156
157         /* For internal device-mapper use. */
158         struct list_head list;
159 };
160
161 /*
162  * Target features
163  */
164
165 /*
166  * Any table that contains an instance of this target must have only one.
167  */
168 #define DM_TARGET_SINGLETON             0x00000001
169 #define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
170
171 /*
172  * Indicates that a target does not support read-only devices.
173  */
174 #define DM_TARGET_ALWAYS_WRITEABLE      0x00000002
175 #define dm_target_always_writeable(type) \
176                 ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
177
178 /*
179  * Any device that contains a table with an instance of this target may never
180  * have tables containing any different target type.
181  */
182 #define DM_TARGET_IMMUTABLE             0x00000004
183 #define dm_target_is_immutable(type)    ((type)->features & DM_TARGET_IMMUTABLE)
184
185 struct dm_target {
186         struct dm_table *table;
187         struct target_type *type;
188
189         /* target limits */
190         sector_t begin;
191         sector_t len;
192
193         /* Always a power of 2 */
194         sector_t split_io;
195
196         /*
197          * A number of zero-length barrier requests that will be submitted
198          * to the target for the purpose of flushing cache.
199          *
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.
203          */
204         unsigned num_flush_requests;
205
206         /*
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.
209          */
210         unsigned num_discard_requests;
211
212         /* target specific data */
213         void *private;
214
215         /* Used to provide an error string from the ctr */
216         char *error;
217
218         /*
219          * Set if this target needs to receive discards regardless of
220          * whether or not its underlying devices have support.
221          */
222         unsigned discards_supported:1;
223
224         /*
225          * Set if this target does not return zeroes on discarded blocks.
226          */
227         unsigned discard_zeroes_data_unsupported:1;
228 };
229
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);
234 };
235
236 int dm_register_target(struct target_type *t);
237 void dm_unregister_target(struct target_type *t);
238
239 /*
240  * Target argument parsing.
241  */
242 struct dm_arg_set {
243         unsigned argc;
244         char **argv;
245 };
246
247 /*
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.
250  */
251 struct dm_arg {
252         unsigned min;
253         unsigned max;
254         char *error;
255 };
256
257 /*
258  * Validate the next argument, either returning it as *value or, if invalid,
259  * returning -EINVAL and setting *error.
260  */
261 int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
262                 unsigned *value, char **error);
263
264 /*
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.
268  */
269 int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
270                       unsigned *num_args, char **error);
271
272 /*
273  * Return the current argument and shift to the next.
274  */
275 const char *dm_shift_arg(struct dm_arg_set *as);
276
277 /*
278  * Move through num_args arguments.
279  */
280 void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
281
282 /*-----------------------------------------------------------------
283  * Functions for creating and manipulating mapped devices.
284  * Drop the reference with dm_put when you finish with the object.
285  *---------------------------------------------------------------*/
286
287 /*
288  * DM_ANY_MINOR chooses the next available minor number.
289  */
290 #define DM_ANY_MINOR (-1)
291 int dm_create(int minor, struct mapped_device **md);
292
293 /*
294  * Reference counting for md.
295  */
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);
299
300 /*
301  * An arbitrary pointer may be stored alongside a mapped device.
302  */
303 void dm_set_mdptr(struct mapped_device *md, void *ptr);
304 void *dm_get_mdptr(struct mapped_device *md);
305
306 /*
307  * A device can still be used while suspended, but I/O is deferred.
308  */
309 int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
310 int dm_resume(struct mapped_device *md);
311
312 /*
313  * Event functions.
314  */
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);
319
320 /*
321  * Info functions.
322  */
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);
330
331 /*
332  * Geometry functions.
333  */
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);
336
337
338 /*-----------------------------------------------------------------
339  * Functions for manipulating device-mapper tables.
340  *---------------------------------------------------------------*/
341
342 /*
343  * First create an empty table.
344  */
345 int dm_table_create(struct dm_table **result, fmode_t mode,
346                     unsigned num_targets, struct mapped_device *md);
347
348 /*
349  * Then call this once for each target.
350  */
351 int dm_table_add_target(struct dm_table *t, const char *type,
352                         sector_t start, sector_t len, char *params);
353
354 /*
355  * Target_ctr should call this if it needs to add any callbacks.
356  */
357 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
358
359 /*
360  * Finally call this to make the table ready for use.
361  */
362 int dm_table_complete(struct dm_table *t);
363
364 /*
365  * Table reference counting.
366  */
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);
370
371 /*
372  * Queries
373  */
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);
378
379 /*
380  * Trigger an event.
381  */
382 void dm_table_event(struct dm_table *t);
383
384 /*
385  * The device must be suspended before calling this method.
386  * Returns the previous table, which the caller must destroy.
387  */
388 struct dm_table *dm_swap_table(struct mapped_device *md,
389                                struct dm_table *t);
390
391 /*
392  * A wrapper around vmalloc.
393  */
394 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
395
396 /*-----------------------------------------------------------------
397  * Macros.
398  *---------------------------------------------------------------*/
399 #define DM_NAME "device-mapper"
400
401 #ifdef CONFIG_PRINTK
402 extern struct ratelimit_state dm_ratelimit_state;
403
404 #define dm_ratelimit()  __ratelimit(&dm_ratelimit_state)
405 #else
406 #define dm_ratelimit()  0
407 #endif
408
409 #define DM_FMT(fmt) DM_NAME ": " DM_MSG_PREFIX ": " fmt "\n"
410
411 #define DMCRIT(fmt, ...) pr_crit(DM_FMT(fmt), ##__VA_ARGS__)
412
413 #define DMERR(fmt, ...) pr_err(DM_FMT(fmt), ##__VA_ARGS__)
414 #define DMERR_LIMIT(fmt, ...)                                           \
415 do {                                                                    \
416         if (dm_ratelimit())                                             \
417                 DMERR(fmt, ##__VA_ARGS__);                              \
418 } while (0)
419
420 #define DMWARN(fmt, ...) pr_warn(DM_FMT(fmt), ##__VA_ARGS__)
421 #define DMWARN_LIMIT(fmt, ...)                                          \
422 do {                                                                    \
423         if (dm_ratelimit())                                             \
424                 DMWARN(fmt, ##__VA_ARGS__);                             \
425 } while (0)
426
427 #define DMINFO(fmt, ...) pr_info(DM_FMT(fmt), ##__VA_ARGS__)
428 #define DMINFO_LIMIT(fmt, ...)                                          \
429 do {                                                                    \
430         if (dm_ratelimit())                                             \
431                 DMINFO(fmt, ##__VA_ARGS__);                             \
432 } while (0)
433
434 #ifdef CONFIG_DM_DEBUG
435 #define DMDEBUG(fmt, ...) printk(KERN_DEBUG DM_FMT(fmt), ##__VA_ARGS__)
436 #define DMDEBUG_LIMIT(fmt, ...)                                         \
437 do {                                                                    \
438         if (dm_ratelimit())                                             \
439                 DMDEBUG(fmt, ##__VA_ARGS__);                            \
440 } while (0)
441 #else
442 #define DMDEBUG(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
443 #define DMDEBUG_LIMIT(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
444 #endif
445
446 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
447                           0 : scnprintf(result + sz, maxlen - sz, x))
448
449 #define SECTOR_SHIFT 9
450
451 /*
452  * Definitions of return values from target end_io function.
453  */
454 #define DM_ENDIO_INCOMPLETE     1
455 #define DM_ENDIO_REQUEUE        2
456
457 /*
458  * Definitions of return values from target map function.
459  */
460 #define DM_MAPIO_SUBMITTED      0
461 #define DM_MAPIO_REMAPPED       1
462 #define DM_MAPIO_REQUEUE        DM_ENDIO_REQUEUE
463
464 /*
465  * Ceiling(n / sz)
466  */
467 #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
468
469 #define dm_sector_div_up(n, sz) ( \
470 { \
471         sector_t _r = ((n) + (sz) - 1); \
472         sector_div(_r, (sz)); \
473         _r; \
474 } \
475 )
476
477 /*
478  * ceiling(n / size) * size
479  */
480 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
481
482 #define dm_array_too_big(fixed, obj, num) \
483         ((num) > (UINT_MAX - (fixed)) / (obj))
484
485 /*
486  * Sector offset taken relative to the start of the target instead of
487  * relative to the start of the device.
488  */
489 #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
490
491 static inline sector_t to_sector(unsigned long n)
492 {
493         return (n >> SECTOR_SHIFT);
494 }
495
496 static inline unsigned long to_bytes(sector_t n)
497 {
498         return (n << SECTOR_SHIFT);
499 }
500
501 /*-----------------------------------------------------------------
502  * Helper for block layer and dm core operations
503  *---------------------------------------------------------------*/
504 void dm_dispatch_request(struct request *rq);
505 void dm_requeue_unmapped_request(struct request *rq);
506 void dm_kill_unmapped_request(struct request *rq, int error);
507 int dm_underlying_device_busy(struct request_queue *q);
508
509 #endif  /* _LINUX_DEVICE_MAPPER_H */