1
2
3
4
5
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
15struct dm_dev;
16struct dm_target;
17struct dm_table;
18struct mapped_device;
19struct bio_vec;
20
21typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
22
23union map_info {
24 void *ptr;
25 unsigned long long ll;
26};
27
28
29
30
31
32typedef int (*dm_ctr_fn) (struct dm_target *target,
33 unsigned int argc, char **argv);
34
35
36
37
38
39typedef void (*dm_dtr_fn) (struct dm_target *ti);
40
41
42
43
44
45
46
47
48typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
49typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
50 union map_info *map_context);
51
52
53
54
55
56
57
58
59
60typedef int (*dm_endio_fn) (struct dm_target *ti,
61 struct bio *bio, int error);
62typedef int (*dm_request_endio_fn) (struct dm_target *ti,
63 struct request *clone, int error,
64 union map_info *map_context);
65
66typedef void (*dm_presuspend_fn) (struct dm_target *ti);
67typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
68typedef int (*dm_preresume_fn) (struct dm_target *ti);
69typedef void (*dm_resume_fn) (struct dm_target *ti);
70
71typedef void (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
72 unsigned status_flags, char *result, unsigned maxlen);
73
74typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
75
76typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
77 unsigned long arg);
78
79typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm,
80 struct bio_vec *biovec, int max_size);
81
82
83
84
85
86
87
88
89
90
91
92typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
93 struct dm_dev *dev,
94 sector_t start, sector_t len,
95 void *data);
96
97
98
99
100
101
102typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
103 iterate_devices_callout_fn fn,
104 void *data);
105
106typedef void (*dm_io_hints_fn) (struct dm_target *ti,
107 struct queue_limits *limits);
108
109
110
111
112
113
114typedef int (*dm_busy_fn) (struct dm_target *ti);
115
116void dm_error(const char *message);
117
118
119
120
121int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
122 sector_t start, sector_t len, void *data);
123
124struct dm_dev {
125 struct block_device *bdev;
126 fmode_t mode;
127 char name[16];
128};
129
130
131
132
133
134int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
135 struct dm_dev **result);
136void dm_put_device(struct dm_target *ti, struct dm_dev *d);
137
138
139
140
141
142struct target_type {
143 uint64_t features;
144 const char *name;
145 struct module *module;
146 unsigned version[3];
147 dm_ctr_fn ctr;
148 dm_dtr_fn dtr;
149 dm_map_fn map;
150 dm_map_request_fn map_rq;
151 dm_endio_fn end_io;
152 dm_request_endio_fn rq_end_io;
153 dm_presuspend_fn presuspend;
154 dm_postsuspend_fn postsuspend;
155 dm_preresume_fn preresume;
156 dm_resume_fn resume;
157 dm_status_fn status;
158 dm_message_fn message;
159 dm_ioctl_fn ioctl;
160 dm_merge_fn merge;
161 dm_busy_fn busy;
162 dm_iterate_devices_fn iterate_devices;
163 dm_io_hints_fn io_hints;
164
165
166 struct list_head list;
167};
168
169
170
171
172
173
174
175
176#define DM_TARGET_SINGLETON 0x00000001
177#define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
178
179
180
181
182#define DM_TARGET_ALWAYS_WRITEABLE 0x00000002
183#define dm_target_always_writeable(type) \
184 ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
185
186
187
188
189
190#define DM_TARGET_IMMUTABLE 0x00000004
191#define dm_target_is_immutable(type) ((type)->features & DM_TARGET_IMMUTABLE)
192
193
194
195
196
197
198
199typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);
200
201struct dm_target {
202 struct dm_table *table;
203 struct target_type *type;
204
205
206 sector_t begin;
207 sector_t len;
208
209
210 uint32_t max_io_len;
211
212
213
214
215
216
217
218
219
220 unsigned num_flush_bios;
221
222
223
224
225
226 unsigned num_discard_bios;
227
228
229
230
231
232 unsigned num_write_same_bios;
233
234
235
236
237
238 unsigned per_bio_data_size;
239
240
241
242
243
244
245 dm_num_write_bios_fn num_write_bios;
246
247
248 void *private;
249
250
251 char *error;
252
253
254
255
256
257 bool flush_supported:1;
258
259
260
261
262
263 bool discards_supported:1;
264
265
266
267
268
269 bool split_discard_bios:1;
270
271
272
273
274 bool discard_zeroes_data_unsupported:1;
275};
276
277
278struct dm_target_callbacks {
279 struct list_head list;
280 int (*congested_fn) (struct dm_target_callbacks *, int);
281};
282
283
284
285
286
287
288
289
290struct dm_target_io {
291 struct dm_io *io;
292 struct dm_target *ti;
293 union map_info info;
294 unsigned target_bio_nr;
295 struct bio clone;
296};
297
298static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
299{
300 return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
301}
302
303static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
304{
305 return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
306}
307
308static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
309{
310 return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
311}
312
313int dm_register_target(struct target_type *t);
314void dm_unregister_target(struct target_type *t);
315
316
317
318
319struct dm_arg_set {
320 unsigned argc;
321 char **argv;
322};
323
324
325
326
327
328struct dm_arg {
329 unsigned min;
330 unsigned max;
331 char *error;
332};
333
334
335
336
337
338int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
339 unsigned *value, char **error);
340
341
342
343
344
345
346int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
347 unsigned *num_args, char **error);
348
349
350
351
352const char *dm_shift_arg(struct dm_arg_set *as);
353
354
355
356
357void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
358
359
360
361
362
363
364
365
366
367#define DM_ANY_MINOR (-1)
368int dm_create(int minor, struct mapped_device **md);
369
370
371
372
373struct mapped_device *dm_get_md(dev_t dev);
374void dm_get(struct mapped_device *md);
375void dm_put(struct mapped_device *md);
376
377
378
379
380void dm_set_mdptr(struct mapped_device *md, void *ptr);
381void *dm_get_mdptr(struct mapped_device *md);
382
383
384
385
386int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
387int dm_resume(struct mapped_device *md);
388
389
390
391
392uint32_t dm_get_event_nr(struct mapped_device *md);
393int dm_wait_event(struct mapped_device *md, int event_nr);
394uint32_t dm_next_uevent_seq(struct mapped_device *md);
395void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
396
397
398
399
400const char *dm_device_name(struct mapped_device *md);
401int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
402struct gendisk *dm_disk(struct mapped_device *md);
403int dm_suspended(struct dm_target *ti);
404int dm_noflush_suspending(struct dm_target *ti);
405union map_info *dm_get_mapinfo(struct bio *bio);
406union map_info *dm_get_rq_mapinfo(struct request *rq);
407
408
409
410
411int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
412int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
413
414
415
416
417
418
419
420
421
422int dm_table_create(struct dm_table **result, fmode_t mode,
423 unsigned num_targets, struct mapped_device *md);
424
425
426
427
428int dm_table_add_target(struct dm_table *t, const char *type,
429 sector_t start, sector_t len, char *params);
430
431
432
433
434void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
435
436
437
438
439int dm_table_complete(struct dm_table *t);
440
441
442
443
444int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);
445
446
447
448
449struct dm_table *dm_get_live_table(struct mapped_device *md, int *srcu_idx);
450void dm_put_live_table(struct mapped_device *md, int srcu_idx);
451void dm_sync_table(struct mapped_device *md);
452
453
454
455
456sector_t dm_table_get_size(struct dm_table *t);
457unsigned int dm_table_get_num_targets(struct dm_table *t);
458fmode_t dm_table_get_mode(struct dm_table *t);
459struct mapped_device *dm_table_get_md(struct dm_table *t);
460
461
462
463
464void dm_table_event(struct dm_table *t);
465
466
467
468
469
470struct dm_table *dm_swap_table(struct mapped_device *md,
471 struct dm_table *t);
472
473
474
475
476void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
477
478
479
480
481#define DM_NAME "device-mapper"
482
483#ifdef CONFIG_PRINTK
484extern struct ratelimit_state dm_ratelimit_state;
485
486#define dm_ratelimit() __ratelimit(&dm_ratelimit_state)
487#else
488#define dm_ratelimit() 0
489#endif
490
491#define DMCRIT(f, arg...) \
492 printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
493
494#define DMERR(f, arg...) \
495 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
496#define DMERR_LIMIT(f, arg...) \
497 do { \
498 if (dm_ratelimit()) \
499 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
500 f "\n", ## arg); \
501 } while (0)
502
503#define DMWARN(f, arg...) \
504 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
505#define DMWARN_LIMIT(f, arg...) \
506 do { \
507 if (dm_ratelimit()) \
508 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
509 f "\n", ## arg); \
510 } while (0)
511
512#define DMINFO(f, arg...) \
513 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
514#define DMINFO_LIMIT(f, arg...) \
515 do { \
516 if (dm_ratelimit()) \
517 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
518 "\n", ## arg); \
519 } while (0)
520
521#ifdef CONFIG_DM_DEBUG
522# define DMDEBUG(f, arg...) \
523 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
524# define DMDEBUG_LIMIT(f, arg...) \
525 do { \
526 if (dm_ratelimit()) \
527 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
528 "\n", ## arg); \
529 } while (0)
530#else
531# define DMDEBUG(f, arg...) do {} while (0)
532# define DMDEBUG_LIMIT(f, arg...) do {} while (0)
533#endif
534
535#define DMEMIT(x...) sz += ((sz >= maxlen) ? \
536 0 : scnprintf(result + sz, maxlen - sz, x))
537
538#define SECTOR_SHIFT 9
539
540
541
542
543#define DM_ENDIO_INCOMPLETE 1
544#define DM_ENDIO_REQUEUE 2
545
546
547
548
549#define DM_MAPIO_SUBMITTED 0
550#define DM_MAPIO_REMAPPED 1
551#define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE
552
553
554
555
556#define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
557
558#define dm_sector_div_up(n, sz) ( \
559{ \
560 sector_t _r = ((n) + (sz) - 1); \
561 sector_div(_r, (sz)); \
562 _r; \
563} \
564)
565
566
567
568
569#define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
570
571#define dm_array_too_big(fixed, obj, num) \
572 ((num) > (UINT_MAX - (fixed)) / (obj))
573
574
575
576
577
578#define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
579
580static inline sector_t to_sector(unsigned long n)
581{
582 return (n >> SECTOR_SHIFT);
583}
584
585static inline unsigned long to_bytes(sector_t n)
586{
587 return (n << SECTOR_SHIFT);
588}
589
590
591
592
593void dm_dispatch_request(struct request *rq);
594void dm_requeue_unmapped_request(struct request *rq);
595void dm_kill_unmapped_request(struct request *rq, int error);
596int dm_underlying_device_busy(struct request_queue *q);
597
598#endif
599