Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2001 Sistina Software (UK) Limited. |
Alasdair G Kergon | 0da336e | 2008-04-24 21:43:52 +0100 | [diff] [blame] | 3 | * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * |
| 5 | * This file is released under the LGPL. |
| 6 | */ |
| 7 | |
| 8 | #ifndef _LINUX_DEVICE_MAPPER_H |
| 9 | #define _LINUX_DEVICE_MAPPER_H |
| 10 | |
Heinz Mauelshagen | 416cd17 | 2008-04-24 21:43:35 +0100 | [diff] [blame] | 11 | #include <linux/bio.h> |
Milan Broz | f6fccb1 | 2008-07-21 12:00:37 +0100 | [diff] [blame] | 12 | #include <linux/blkdev.h> |
Heinz Mauelshagen | 416cd17 | 2008-04-24 21:43:35 +0100 | [diff] [blame] | 13 | |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 14 | struct dm_dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | struct dm_target; |
| 16 | struct dm_table; |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 17 | struct mapped_device; |
Milan Broz | f6fccb1 | 2008-07-21 12:00:37 +0100 | [diff] [blame] | 18 | struct bio_vec; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | |
| 20 | typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t; |
| 21 | |
| 22 | union map_info { |
| 23 | void *ptr; |
| 24 | unsigned long long ll; |
Mike Snitzer | 57cba5d | 2010-08-12 04:14:04 +0100 | [diff] [blame] | 25 | unsigned target_request_nr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | }; |
| 27 | |
| 28 | /* |
| 29 | * In the constructor the target parameter will already have the |
| 30 | * table, type, begin and len fields filled in. |
| 31 | */ |
| 32 | typedef 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 | */ |
| 39 | typedef 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 Ueda | 45cbcd7 | 2006-12-08 02:41:05 -0800 | [diff] [blame] | 45 | * = 1: simple remap complete |
Kiyoshi Ueda | 2e93ccc | 2006-12-08 02:41:09 -0800 | [diff] [blame] | 46 | * = 2: The target wants to push back the io |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | */ |
| 48 | typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio, |
| 49 | union map_info *map_context); |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 50 | typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone, |
| 51 | union map_info *map_context); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
| 53 | /* |
| 54 | * Returns: |
| 55 | * < 0 : error (currently ignored) |
| 56 | * 0 : ended successfully |
| 57 | * 1 : for some reason the io has still not completed (eg, |
| 58 | * multipath target might want to requeue a failed io). |
Kiyoshi Ueda | 2e93ccc | 2006-12-08 02:41:09 -0800 | [diff] [blame] | 59 | * 2 : The target wants to push back the io |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | */ |
| 61 | typedef int (*dm_endio_fn) (struct dm_target *ti, |
| 62 | struct bio *bio, int error, |
| 63 | union map_info *map_context); |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 64 | typedef int (*dm_request_endio_fn) (struct dm_target *ti, |
| 65 | struct request *clone, int error, |
| 66 | union map_info *map_context); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | |
Bryn Reeves | 999d816 | 2006-10-03 01:15:43 -0700 | [diff] [blame] | 68 | typedef void (*dm_flush_fn) (struct dm_target *ti); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | typedef void (*dm_presuspend_fn) (struct dm_target *ti); |
| 70 | typedef void (*dm_postsuspend_fn) (struct dm_target *ti); |
Milan Broz | 8757b77 | 2006-10-03 01:15:36 -0700 | [diff] [blame] | 71 | typedef int (*dm_preresume_fn) (struct dm_target *ti); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | typedef void (*dm_resume_fn) (struct dm_target *ti); |
| 73 | |
| 74 | typedef int (*dm_status_fn) (struct dm_target *ti, status_type_t status_type, |
| 75 | char *result, unsigned int maxlen); |
| 76 | |
| 77 | typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv); |
| 78 | |
Al Viro | 647b3d0 | 2007-08-28 22:15:59 -0400 | [diff] [blame] | 79 | typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd, |
Milan Broz | aa129a2 | 2006-10-03 01:15:15 -0700 | [diff] [blame] | 80 | unsigned long arg); |
| 81 | |
Milan Broz | f6fccb1 | 2008-07-21 12:00:37 +0100 | [diff] [blame] | 82 | typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm, |
| 83 | struct bio_vec *biovec, int max_size); |
| 84 | |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 85 | typedef int (*iterate_devices_callout_fn) (struct dm_target *ti, |
| 86 | struct dm_dev *dev, |
Mike Snitzer | 5dea271 | 2009-07-23 20:30:42 +0100 | [diff] [blame] | 87 | sector_t start, sector_t len, |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 88 | void *data); |
| 89 | |
| 90 | typedef int (*dm_iterate_devices_fn) (struct dm_target *ti, |
| 91 | iterate_devices_callout_fn fn, |
| 92 | void *data); |
| 93 | |
Mike Snitzer | 40bea43 | 2009-09-04 20:40:25 +0100 | [diff] [blame] | 94 | typedef void (*dm_io_hints_fn) (struct dm_target *ti, |
| 95 | struct queue_limits *limits); |
| 96 | |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 97 | /* |
| 98 | * Returns: |
| 99 | * 0: The target can handle the next I/O immediately. |
| 100 | * 1: The target can't handle the next I/O immediately. |
| 101 | */ |
| 102 | typedef int (*dm_busy_fn) (struct dm_target *ti); |
| 103 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | void dm_error(const char *message); |
| 105 | |
| 106 | /* |
Bryn Reeves | 3cb4021 | 2006-10-03 01:15:42 -0700 | [diff] [blame] | 107 | * Combine device limits. |
| 108 | */ |
Mike Snitzer | 754c5fc | 2009-06-22 10:12:34 +0100 | [diff] [blame] | 109 | int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev, |
Mike Snitzer | 5dea271 | 2009-07-23 20:30:42 +0100 | [diff] [blame] | 110 | sector_t start, sector_t len, void *data); |
Bryn Reeves | 3cb4021 | 2006-10-03 01:15:42 -0700 | [diff] [blame] | 111 | |
Mikulas Patocka | 82b1519 | 2008-10-10 13:37:09 +0100 | [diff] [blame] | 112 | struct dm_dev { |
| 113 | struct block_device *bdev; |
Al Viro | aeb5d72 | 2008-09-02 15:28:45 -0400 | [diff] [blame] | 114 | fmode_t mode; |
Mikulas Patocka | 82b1519 | 2008-10-10 13:37:09 +0100 | [diff] [blame] | 115 | char name[16]; |
| 116 | }; |
| 117 | |
Bryn Reeves | 3cb4021 | 2006-10-03 01:15:42 -0700 | [diff] [blame] | 118 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | * Constructors should call these functions to ensure destination devices |
| 120 | * are opened/closed correctly. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | */ |
Nikanth Karthikesan | 8215d6e | 2010-03-06 02:32:27 +0000 | [diff] [blame] | 122 | int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, |
| 123 | struct dm_dev **result); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | void dm_put_device(struct dm_target *ti, struct dm_dev *d); |
| 125 | |
| 126 | /* |
| 127 | * Information about a target type |
| 128 | */ |
Andi Kleen | ab4c14248 | 2009-01-06 03:05:09 +0000 | [diff] [blame] | 129 | |
| 130 | /* |
| 131 | * Target features |
| 132 | */ |
Andi Kleen | ab4c14248 | 2009-01-06 03:05:09 +0000 | [diff] [blame] | 133 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | struct target_type { |
Andi Kleen | ab4c14248 | 2009-01-06 03:05:09 +0000 | [diff] [blame] | 135 | uint64_t features; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | const char *name; |
| 137 | struct module *module; |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 138 | unsigned version[3]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | dm_ctr_fn ctr; |
| 140 | dm_dtr_fn dtr; |
| 141 | dm_map_fn map; |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 142 | dm_map_request_fn map_rq; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | dm_endio_fn end_io; |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 144 | dm_request_endio_fn rq_end_io; |
Bryn Reeves | 999d816 | 2006-10-03 01:15:43 -0700 | [diff] [blame] | 145 | dm_flush_fn flush; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | dm_presuspend_fn presuspend; |
| 147 | dm_postsuspend_fn postsuspend; |
Milan Broz | 8757b77 | 2006-10-03 01:15:36 -0700 | [diff] [blame] | 148 | dm_preresume_fn preresume; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | dm_resume_fn resume; |
| 150 | dm_status_fn status; |
| 151 | dm_message_fn message; |
Milan Broz | aa129a2 | 2006-10-03 01:15:15 -0700 | [diff] [blame] | 152 | dm_ioctl_fn ioctl; |
Milan Broz | f6fccb1 | 2008-07-21 12:00:37 +0100 | [diff] [blame] | 153 | dm_merge_fn merge; |
Kiyoshi Ueda | 7d76345 | 2009-01-06 03:05:07 +0000 | [diff] [blame] | 154 | dm_busy_fn busy; |
Mike Snitzer | af4874e | 2009-06-22 10:12:33 +0100 | [diff] [blame] | 155 | dm_iterate_devices_fn iterate_devices; |
Mike Snitzer | 40bea43 | 2009-09-04 20:40:25 +0100 | [diff] [blame] | 156 | dm_io_hints_fn io_hints; |
Cheng Renquan | 45194e4 | 2009-04-02 19:55:28 +0100 | [diff] [blame] | 157 | |
| 158 | /* For internal device-mapper use. */ |
| 159 | struct list_head list; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | }; |
| 161 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | struct dm_target { |
| 163 | struct dm_table *table; |
| 164 | struct target_type *type; |
| 165 | |
| 166 | /* target limits */ |
| 167 | sector_t begin; |
| 168 | sector_t len; |
| 169 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | /* Always a power of 2 */ |
| 171 | sector_t split_io; |
| 172 | |
| 173 | /* |
Mikulas Patocka | f9ab94c | 2009-06-22 10:12:20 +0100 | [diff] [blame] | 174 | * A number of zero-length barrier requests that will be submitted |
| 175 | * to the target for the purpose of flushing cache. |
| 176 | * |
Mike Snitzer | 57cba5d | 2010-08-12 04:14:04 +0100 | [diff] [blame] | 177 | * The request number will be placed in union map_info->target_request_nr. |
Mikulas Patocka | f9ab94c | 2009-06-22 10:12:20 +0100 | [diff] [blame] | 178 | * It is a responsibility of the target driver to remap these requests |
| 179 | * to the real underlying devices. |
| 180 | */ |
| 181 | unsigned num_flush_requests; |
| 182 | |
Mike Snitzer | 5ae89a8 | 2010-08-12 04:14:08 +0100 | [diff] [blame] | 183 | /* |
| 184 | * The number of discard requests that will be submitted to the |
| 185 | * target. map_info->request_nr is used just like num_flush_requests. |
| 186 | */ |
| 187 | unsigned num_discard_requests; |
| 188 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | /* target specific data */ |
| 190 | void *private; |
| 191 | |
| 192 | /* Used to provide an error string from the ctr */ |
| 193 | char *error; |
| 194 | }; |
| 195 | |
NeilBrown | 9d357b0 | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 196 | /* Each target can link one of these into the table */ |
| 197 | struct dm_target_callbacks { |
| 198 | struct list_head list; |
| 199 | int (*congested_fn) (struct dm_target_callbacks *, int); |
| 200 | }; |
| 201 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | int dm_register_target(struct target_type *t); |
Mikulas Patocka | 10d3bd0 | 2009-01-06 03:04:58 +0000 | [diff] [blame] | 203 | void dm_unregister_target(struct target_type *t); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 204 | |
| 205 | /*----------------------------------------------------------------- |
| 206 | * Functions for creating and manipulating mapped devices. |
| 207 | * Drop the reference with dm_put when you finish with the object. |
| 208 | *---------------------------------------------------------------*/ |
| 209 | |
| 210 | /* |
| 211 | * DM_ANY_MINOR chooses the next available minor number. |
| 212 | */ |
| 213 | #define DM_ANY_MINOR (-1) |
| 214 | int dm_create(int minor, struct mapped_device **md); |
| 215 | |
| 216 | /* |
| 217 | * Reference counting for md. |
| 218 | */ |
| 219 | struct mapped_device *dm_get_md(dev_t dev); |
| 220 | void dm_get(struct mapped_device *md); |
| 221 | void dm_put(struct mapped_device *md); |
| 222 | |
| 223 | /* |
| 224 | * An arbitrary pointer may be stored alongside a mapped device. |
| 225 | */ |
| 226 | void dm_set_mdptr(struct mapped_device *md, void *ptr); |
| 227 | void *dm_get_mdptr(struct mapped_device *md); |
| 228 | |
| 229 | /* |
| 230 | * A device can still be used while suspended, but I/O is deferred. |
| 231 | */ |
Kiyoshi Ueda | a3d77d3 | 2006-12-08 02:41:04 -0800 | [diff] [blame] | 232 | int dm_suspend(struct mapped_device *md, unsigned suspend_flags); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 233 | int dm_resume(struct mapped_device *md); |
| 234 | |
| 235 | /* |
| 236 | * Event functions. |
| 237 | */ |
| 238 | uint32_t dm_get_event_nr(struct mapped_device *md); |
| 239 | int dm_wait_event(struct mapped_device *md, int event_nr); |
Mike Anderson | 7a8c3d3 | 2007-10-19 22:48:01 +0100 | [diff] [blame] | 240 | uint32_t dm_next_uevent_seq(struct mapped_device *md); |
| 241 | void dm_uevent_add(struct mapped_device *md, struct list_head *elist); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 242 | |
| 243 | /* |
| 244 | * Info functions. |
| 245 | */ |
Alasdair G Kergon | 72d9486 | 2006-06-26 00:27:35 -0700 | [diff] [blame] | 246 | const char *dm_device_name(struct mapped_device *md); |
Mike Anderson | 96a1f7d | 2007-10-19 22:47:59 +0100 | [diff] [blame] | 247 | int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 248 | struct gendisk *dm_disk(struct mapped_device *md); |
Kiyoshi Ueda | 64dbce5 | 2009-12-10 23:52:27 +0000 | [diff] [blame] | 249 | int dm_suspended(struct dm_target *ti); |
Kiyoshi Ueda | 2e93ccc | 2006-12-08 02:41:09 -0800 | [diff] [blame] | 250 | int dm_noflush_suspending(struct dm_target *ti); |
Mikulas Patocka | 89343da | 2008-10-10 13:37:10 +0100 | [diff] [blame] | 251 | union map_info *dm_get_mapinfo(struct bio *bio); |
Kiyoshi Ueda | cec47e3 | 2009-06-22 10:12:35 +0100 | [diff] [blame] | 252 | union map_info *dm_get_rq_mapinfo(struct request *rq); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 253 | |
| 254 | /* |
| 255 | * Geometry functions. |
| 256 | */ |
| 257 | int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo); |
| 258 | int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo); |
| 259 | |
| 260 | |
| 261 | /*----------------------------------------------------------------- |
| 262 | * Functions for manipulating device-mapper tables. |
| 263 | *---------------------------------------------------------------*/ |
| 264 | |
| 265 | /* |
| 266 | * First create an empty table. |
| 267 | */ |
Al Viro | aeb5d72 | 2008-09-02 15:28:45 -0400 | [diff] [blame] | 268 | int dm_table_create(struct dm_table **result, fmode_t mode, |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 269 | unsigned num_targets, struct mapped_device *md); |
| 270 | |
| 271 | /* |
| 272 | * Then call this once for each target. |
| 273 | */ |
| 274 | int dm_table_add_target(struct dm_table *t, const char *type, |
| 275 | sector_t start, sector_t len, char *params); |
| 276 | |
| 277 | /* |
NeilBrown | 9d357b0 | 2011-01-13 20:00:01 +0000 | [diff] [blame] | 278 | * Target_ctr should call this if it needs to add any callbacks. |
| 279 | */ |
| 280 | void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb); |
| 281 | |
| 282 | /* |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 283 | * Finally call this to make the table ready for use. |
| 284 | */ |
| 285 | int dm_table_complete(struct dm_table *t); |
| 286 | |
| 287 | /* |
| 288 | * Table reference counting. |
| 289 | */ |
Alasdair G Kergon | 7c66641 | 2009-12-10 23:52:19 +0000 | [diff] [blame] | 290 | struct dm_table *dm_get_live_table(struct mapped_device *md); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 291 | void dm_table_get(struct dm_table *t); |
| 292 | void dm_table_put(struct dm_table *t); |
| 293 | |
| 294 | /* |
| 295 | * Queries |
| 296 | */ |
| 297 | sector_t dm_table_get_size(struct dm_table *t); |
| 298 | unsigned int dm_table_get_num_targets(struct dm_table *t); |
Al Viro | aeb5d72 | 2008-09-02 15:28:45 -0400 | [diff] [blame] | 299 | fmode_t dm_table_get_mode(struct dm_table *t); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 300 | struct mapped_device *dm_table_get_md(struct dm_table *t); |
| 301 | |
| 302 | /* |
| 303 | * Trigger an event. |
| 304 | */ |
| 305 | void dm_table_event(struct dm_table *t); |
| 306 | |
| 307 | /* |
| 308 | * The device must be suspended before calling this method. |
Alasdair G Kergon | 042d2a9 | 2009-12-10 23:52:24 +0000 | [diff] [blame] | 309 | * Returns the previous table, which the caller must destroy. |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 310 | */ |
Alasdair G Kergon | 042d2a9 | 2009-12-10 23:52:24 +0000 | [diff] [blame] | 311 | struct dm_table *dm_swap_table(struct mapped_device *md, |
| 312 | struct dm_table *t); |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 313 | |
Mikulas Patocka | 5416090 | 2008-10-10 13:37:12 +0100 | [diff] [blame] | 314 | /* |
| 315 | * A wrapper around vmalloc. |
| 316 | */ |
| 317 | void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size); |
| 318 | |
Alasdair G Kergon | 0da336e | 2008-04-24 21:43:52 +0100 | [diff] [blame] | 319 | /*----------------------------------------------------------------- |
| 320 | * Macros. |
| 321 | *---------------------------------------------------------------*/ |
| 322 | #define DM_NAME "device-mapper" |
| 323 | |
Mikulas Patocka | 10d3bd0 | 2009-01-06 03:04:58 +0000 | [diff] [blame] | 324 | #define DMCRIT(f, arg...) \ |
| 325 | printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) |
| 326 | |
Alasdair G Kergon | 0da336e | 2008-04-24 21:43:52 +0100 | [diff] [blame] | 327 | #define DMERR(f, arg...) \ |
| 328 | printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) |
| 329 | #define DMERR_LIMIT(f, arg...) \ |
| 330 | do { \ |
| 331 | if (printk_ratelimit()) \ |
| 332 | printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \ |
| 333 | f "\n", ## arg); \ |
| 334 | } while (0) |
| 335 | |
| 336 | #define DMWARN(f, arg...) \ |
| 337 | printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) |
| 338 | #define DMWARN_LIMIT(f, arg...) \ |
| 339 | do { \ |
| 340 | if (printk_ratelimit()) \ |
| 341 | printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \ |
| 342 | f "\n", ## arg); \ |
| 343 | } while (0) |
| 344 | |
| 345 | #define DMINFO(f, arg...) \ |
| 346 | printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) |
| 347 | #define DMINFO_LIMIT(f, arg...) \ |
| 348 | do { \ |
| 349 | if (printk_ratelimit()) \ |
| 350 | printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \ |
| 351 | "\n", ## arg); \ |
| 352 | } while (0) |
| 353 | |
| 354 | #ifdef CONFIG_DM_DEBUG |
| 355 | # define DMDEBUG(f, arg...) \ |
| 356 | printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg) |
| 357 | # define DMDEBUG_LIMIT(f, arg...) \ |
| 358 | do { \ |
| 359 | if (printk_ratelimit()) \ |
| 360 | printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \ |
| 361 | "\n", ## arg); \ |
| 362 | } while (0) |
| 363 | #else |
| 364 | # define DMDEBUG(f, arg...) do {} while (0) |
| 365 | # define DMDEBUG_LIMIT(f, arg...) do {} while (0) |
| 366 | #endif |
| 367 | |
| 368 | #define DMEMIT(x...) sz += ((sz >= maxlen) ? \ |
| 369 | 0 : scnprintf(result + sz, maxlen - sz, x)) |
| 370 | |
| 371 | #define SECTOR_SHIFT 9 |
| 372 | |
| 373 | /* |
| 374 | * Definitions of return values from target end_io function. |
| 375 | */ |
| 376 | #define DM_ENDIO_INCOMPLETE 1 |
| 377 | #define DM_ENDIO_REQUEUE 2 |
| 378 | |
| 379 | /* |
| 380 | * Definitions of return values from target map function. |
| 381 | */ |
| 382 | #define DM_MAPIO_SUBMITTED 0 |
| 383 | #define DM_MAPIO_REMAPPED 1 |
| 384 | #define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE |
| 385 | |
| 386 | /* |
| 387 | * Ceiling(n / sz) |
| 388 | */ |
| 389 | #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz)) |
| 390 | |
| 391 | #define dm_sector_div_up(n, sz) ( \ |
| 392 | { \ |
| 393 | sector_t _r = ((n) + (sz) - 1); \ |
| 394 | sector_div(_r, (sz)); \ |
| 395 | _r; \ |
| 396 | } \ |
| 397 | ) |
| 398 | |
| 399 | /* |
| 400 | * ceiling(n / size) * size |
| 401 | */ |
| 402 | #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz)) |
| 403 | |
Mikulas Patocka | d63a5ce | 2008-10-21 17:44:57 +0100 | [diff] [blame] | 404 | #define dm_array_too_big(fixed, obj, num) \ |
| 405 | ((num) > (UINT_MAX - (fixed)) / (obj)) |
| 406 | |
Mike Snitzer | 56a67df | 2010-08-12 04:14:10 +0100 | [diff] [blame] | 407 | /* |
| 408 | * Sector offset taken relative to the start of the target instead of |
| 409 | * relative to the start of the device. |
| 410 | */ |
| 411 | #define dm_target_offset(ti, sector) ((sector) - (ti)->begin) |
| 412 | |
Alasdair G Kergon | 0da336e | 2008-04-24 21:43:52 +0100 | [diff] [blame] | 413 | static inline sector_t to_sector(unsigned long n) |
| 414 | { |
| 415 | return (n >> SECTOR_SHIFT); |
| 416 | } |
| 417 | |
| 418 | static inline unsigned long to_bytes(sector_t n) |
| 419 | { |
| 420 | return (n << SECTOR_SHIFT); |
| 421 | } |
| 422 | |
Kiyoshi Ueda | cec47e3 | 2009-06-22 10:12:35 +0100 | [diff] [blame] | 423 | /*----------------------------------------------------------------- |
| 424 | * Helper for block layer and dm core operations |
| 425 | *---------------------------------------------------------------*/ |
| 426 | void dm_dispatch_request(struct request *rq); |
| 427 | void dm_requeue_unmapped_request(struct request *rq); |
| 428 | void dm_kill_unmapped_request(struct request *rq, int error); |
| 429 | int dm_underlying_device_busy(struct request_queue *q); |
| 430 | |
Alasdair G Kergon | 17b2f66 | 2006-06-26 00:27:33 -0700 | [diff] [blame] | 431 | #endif /* _LINUX_DEVICE_MAPPER_H */ |