Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 99d03c141b40914b67d63c9d23b8da4386422ed7

Authored by NeilBrown
Committed by Alasdair G Kergon
1 parent 9d357b0787
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

dm: per target unplug callback support 

Add per-target unplug callback support.

Cc: linux-raid@vger.kernel.org
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>

Showing 2 changed files with 6 additions and 0 deletions Inline Diff

drivers/md/dm-table.c
Diff comments   View file @ 99d03c1
1 /* 1 /*
2 * Copyright (C) 2001 Sistina Software (UK) Limited. 2 * Copyright (C) 2001 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This file is released under the GPL. 5 * This file is released under the GPL.
6 */ 6 */
7 7
8 #include "dm.h" 8 #include "dm.h"
9 9
10 #include <linux/module.h> 10 #include <linux/module.h>
11 #include <linux/vmalloc.h> 11 #include <linux/vmalloc.h>
12 #include <linux/blkdev.h> 12 #include <linux/blkdev.h>
13 #include <linux/namei.h> 13 #include <linux/namei.h>
14 #include <linux/ctype.h> 14 #include <linux/ctype.h>
15 #include <linux/string.h> 15 #include <linux/string.h>
16 #include <linux/slab.h> 16 #include <linux/slab.h>
17 #include <linux/interrupt.h> 17 #include <linux/interrupt.h>
18 #include <linux/mutex.h> 18 #include <linux/mutex.h>
19 #include <linux/delay.h> 19 #include <linux/delay.h>
20 #include <asm/atomic.h> 20 #include <asm/atomic.h>
21 21
22 #define DM_MSG_PREFIX "table" 22 #define DM_MSG_PREFIX "table"
23 23
24 #define MAX_DEPTH 16 24 #define MAX_DEPTH 16
25 #define NODE_SIZE L1_CACHE_BYTES 25 #define NODE_SIZE L1_CACHE_BYTES
26 #define KEYS_PER_NODE (NODE_SIZE / sizeof(sector_t)) 26 #define KEYS_PER_NODE (NODE_SIZE / sizeof(sector_t))
27 #define CHILDREN_PER_NODE (KEYS_PER_NODE + 1) 27 #define CHILDREN_PER_NODE (KEYS_PER_NODE + 1)
28 28
29 /* 29 /*
30 * The table has always exactly one reference from either mapped_device->map 30 * The table has always exactly one reference from either mapped_device->map
31 * or hash_cell->new_map. This reference is not counted in table->holders. 31 * or hash_cell->new_map. This reference is not counted in table->holders.
32 * A pair of dm_create_table/dm_destroy_table functions is used for table 32 * A pair of dm_create_table/dm_destroy_table functions is used for table
33 * creation/destruction. 33 * creation/destruction.
34 * 34 *
35 * Temporary references from the other code increase table->holders. A pair 35 * Temporary references from the other code increase table->holders. A pair
36 * of dm_table_get/dm_table_put functions is used to manipulate it. 36 * of dm_table_get/dm_table_put functions is used to manipulate it.
37 * 37 *
38 * When the table is about to be destroyed, we wait for table->holders to 38 * When the table is about to be destroyed, we wait for table->holders to
39 * drop to zero. 39 * drop to zero.
40 */ 40 */
41 41
42 struct dm_table { 42 struct dm_table {
43 struct mapped_device *md; 43 struct mapped_device *md;
44 atomic_t holders; 44 atomic_t holders;
45 unsigned type; 45 unsigned type;
46 46
47 /* btree table */ 47 /* btree table */
48 unsigned int depth; 48 unsigned int depth;
49 unsigned int counts[MAX_DEPTH]; /* in nodes */ 49 unsigned int counts[MAX_DEPTH]; /* in nodes */
50 sector_t *index[MAX_DEPTH]; 50 sector_t *index[MAX_DEPTH];
51 51
52 unsigned int num_targets; 52 unsigned int num_targets;
53 unsigned int num_allocated; 53 unsigned int num_allocated;
54 sector_t *highs; 54 sector_t *highs;
55 struct dm_target *targets; 55 struct dm_target *targets;
56 56
57 unsigned discards_supported:1; 57 unsigned discards_supported:1;
58 58
59 /* 59 /*
60 * Indicates the rw permissions for the new logical 60 * Indicates the rw permissions for the new logical
61 * device. This should be a combination of FMODE_READ 61 * device. This should be a combination of FMODE_READ
62 * and FMODE_WRITE. 62 * and FMODE_WRITE.
63 */ 63 */
64 fmode_t mode; 64 fmode_t mode;
65 65
66 /* a list of devices used by this table */ 66 /* a list of devices used by this table */
67 struct list_head devices; 67 struct list_head devices;
68 68
69 /* events get handed up using this callback */ 69 /* events get handed up using this callback */
70 void (*event_fn)(void *); 70 void (*event_fn)(void *);
71 void *event_context; 71 void *event_context;
72 72
73 struct dm_md_mempools *mempools; 73 struct dm_md_mempools *mempools;
74 74
75 struct list_head target_callbacks; 75 struct list_head target_callbacks;
76 }; 76 };
77 77
78 /* 78 /*
79 * Similar to ceiling(log_size(n)) 79 * Similar to ceiling(log_size(n))
80 */ 80 */
81 static unsigned int int_log(unsigned int n, unsigned int base) 81 static unsigned int int_log(unsigned int n, unsigned int base)
82 { 82 {
83 int result = 0; 83 int result = 0;
84 84
85 while (n > 1) { 85 while (n > 1) {
86 n = dm_div_up(n, base); 86 n = dm_div_up(n, base);
87 result++; 87 result++;
88 } 88 }
89 89
90 return result; 90 return result;
91 } 91 }
92 92
93 /* 93 /*
94 * Calculate the index of the child node of the n'th node k'th key. 94 * Calculate the index of the child node of the n'th node k'th key.
95 */ 95 */
96 static inline unsigned int get_child(unsigned int n, unsigned int k) 96 static inline unsigned int get_child(unsigned int n, unsigned int k)
97 { 97 {
98 return (n * CHILDREN_PER_NODE) + k; 98 return (n * CHILDREN_PER_NODE) + k;
99 } 99 }
100 100
101 /* 101 /*
102 * Return the n'th node of level l from table t. 102 * Return the n'th node of level l from table t.
103 */ 103 */
104 static inline sector_t *get_node(struct dm_table *t, 104 static inline sector_t *get_node(struct dm_table *t,
105 unsigned int l, unsigned int n) 105 unsigned int l, unsigned int n)
106 { 106 {
107 return t->index[l] + (n * KEYS_PER_NODE); 107 return t->index[l] + (n * KEYS_PER_NODE);
108 } 108 }
109 109
110 /* 110 /*
111 * Return the highest key that you could lookup from the n'th 111 * Return the highest key that you could lookup from the n'th
112 * node on level l of the btree. 112 * node on level l of the btree.
113 */ 113 */
114 static sector_t high(struct dm_table *t, unsigned int l, unsigned int n) 114 static sector_t high(struct dm_table *t, unsigned int l, unsigned int n)
115 { 115 {
116 for (; l < t->depth - 1; l++) 116 for (; l < t->depth - 1; l++)
117 n = get_child(n, CHILDREN_PER_NODE - 1); 117 n = get_child(n, CHILDREN_PER_NODE - 1);
118 118
119 if (n >= t->counts[l]) 119 if (n >= t->counts[l])
120 return (sector_t) - 1; 120 return (sector_t) - 1;
121 121
122 return get_node(t, l, n)[KEYS_PER_NODE - 1]; 122 return get_node(t, l, n)[KEYS_PER_NODE - 1];
123 } 123 }
124 124
125 /* 125 /*
126 * Fills in a level of the btree based on the highs of the level 126 * Fills in a level of the btree based on the highs of the level
127 * below it. 127 * below it.
128 */ 128 */
129 static int setup_btree_index(unsigned int l, struct dm_table *t) 129 static int setup_btree_index(unsigned int l, struct dm_table *t)
130 { 130 {
131 unsigned int n, k; 131 unsigned int n, k;
132 sector_t *node; 132 sector_t *node;
133 133
134 for (n = 0U; n < t->counts[l]; n++) { 134 for (n = 0U; n < t->counts[l]; n++) {
135 node = get_node(t, l, n); 135 node = get_node(t, l, n);
136 136
137 for (k = 0U; k < KEYS_PER_NODE; k++) 137 for (k = 0U; k < KEYS_PER_NODE; k++)
138 node[k] = high(t, l + 1, get_child(n, k)); 138 node[k] = high(t, l + 1, get_child(n, k));
139 } 139 }
140 140
141 return 0; 141 return 0;
142 } 142 }
143 143
144 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size) 144 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size)
145 { 145 {
146 unsigned long size; 146 unsigned long size;
147 void *addr; 147 void *addr;
148 148
149 /* 149 /*
150 * Check that we're not going to overflow. 150 * Check that we're not going to overflow.
151 */ 151 */
152 if (nmemb > (ULONG_MAX / elem_size)) 152 if (nmemb > (ULONG_MAX / elem_size))
153 return NULL; 153 return NULL;
154 154
155 size = nmemb * elem_size; 155 size = nmemb * elem_size;
156 addr = vmalloc(size); 156 addr = vmalloc(size);
157 if (addr) 157 if (addr)
158 memset(addr, 0, size); 158 memset(addr, 0, size);
159 159
160 return addr; 160 return addr;
161 } 161 }
162 162
163 /* 163 /*
164 * highs, and targets are managed as dynamic arrays during a 164 * highs, and targets are managed as dynamic arrays during a
165 * table load. 165 * table load.
166 */ 166 */
167 static int alloc_targets(struct dm_table *t, unsigned int num) 167 static int alloc_targets(struct dm_table *t, unsigned int num)
168 { 168 {
169 sector_t *n_highs; 169 sector_t *n_highs;
170 struct dm_target *n_targets; 170 struct dm_target *n_targets;
171 int n = t->num_targets; 171 int n = t->num_targets;
172 172
173 /* 173 /*
174 * Allocate both the target array and offset array at once. 174 * Allocate both the target array and offset array at once.
175 * Append an empty entry to catch sectors beyond the end of 175 * Append an empty entry to catch sectors beyond the end of
176 * the device. 176 * the device.
177 */ 177 */
178 n_highs = (sector_t *) dm_vcalloc(num + 1, sizeof(struct dm_target) + 178 n_highs = (sector_t *) dm_vcalloc(num + 1, sizeof(struct dm_target) +
179 sizeof(sector_t)); 179 sizeof(sector_t));
180 if (!n_highs) 180 if (!n_highs)
181 return -ENOMEM; 181 return -ENOMEM;
182 182
183 n_targets = (struct dm_target *) (n_highs + num); 183 n_targets = (struct dm_target *) (n_highs + num);
184 184
185 if (n) { 185 if (n) {
186 memcpy(n_highs, t->highs, sizeof(*n_highs) * n); 186 memcpy(n_highs, t->highs, sizeof(*n_highs) * n);
187 memcpy(n_targets, t->targets, sizeof(*n_targets) * n); 187 memcpy(n_targets, t->targets, sizeof(*n_targets) * n);
188 } 188 }
189 189
190 memset(n_highs + n, -1, sizeof(*n_highs) * (num - n)); 190 memset(n_highs + n, -1, sizeof(*n_highs) * (num - n));
191 vfree(t->highs); 191 vfree(t->highs);
192 192
193 t->num_allocated = num; 193 t->num_allocated = num;
194 t->highs = n_highs; 194 t->highs = n_highs;
195 t->targets = n_targets; 195 t->targets = n_targets;
196 196
197 return 0; 197 return 0;
198 } 198 }
199 199
200 int dm_table_create(struct dm_table **result, fmode_t mode, 200 int dm_table_create(struct dm_table **result, fmode_t mode,
201 unsigned num_targets, struct mapped_device *md) 201 unsigned num_targets, struct mapped_device *md)
202 { 202 {
203 struct dm_table *t = kzalloc(sizeof(*t), GFP_KERNEL); 203 struct dm_table *t = kzalloc(sizeof(*t), GFP_KERNEL);
204 204
205 if (!t) 205 if (!t)
206 return -ENOMEM; 206 return -ENOMEM;
207 207
208 INIT_LIST_HEAD(&t->devices); 208 INIT_LIST_HEAD(&t->devices);
209 INIT_LIST_HEAD(&t->target_callbacks); 209 INIT_LIST_HEAD(&t->target_callbacks);
210 atomic_set(&t->holders, 0); 210 atomic_set(&t->holders, 0);
211 t->discards_supported = 1; 211 t->discards_supported = 1;
212 212
213 if (!num_targets) 213 if (!num_targets)
214 num_targets = KEYS_PER_NODE; 214 num_targets = KEYS_PER_NODE;
215 215
216 num_targets = dm_round_up(num_targets, KEYS_PER_NODE); 216 num_targets = dm_round_up(num_targets, KEYS_PER_NODE);
217 217
218 if (alloc_targets(t, num_targets)) { 218 if (alloc_targets(t, num_targets)) {
219 kfree(t); 219 kfree(t);
220 t = NULL; 220 t = NULL;
221 return -ENOMEM; 221 return -ENOMEM;
222 } 222 }
223 223
224 t->mode = mode; 224 t->mode = mode;
225 t->md = md; 225 t->md = md;
226 *result = t; 226 *result = t;
227 return 0; 227 return 0;
228 } 228 }
229 229
230 static void free_devices(struct list_head *devices) 230 static void free_devices(struct list_head *devices)
231 { 231 {
232 struct list_head *tmp, *next; 232 struct list_head *tmp, *next;
233 233
234 list_for_each_safe(tmp, next, devices) { 234 list_for_each_safe(tmp, next, devices) {
235 struct dm_dev_internal *dd = 235 struct dm_dev_internal *dd =
236 list_entry(tmp, struct dm_dev_internal, list); 236 list_entry(tmp, struct dm_dev_internal, list);
237 DMWARN("dm_table_destroy: dm_put_device call missing for %s", 237 DMWARN("dm_table_destroy: dm_put_device call missing for %s",
238 dd->dm_dev.name); 238 dd->dm_dev.name);
239 kfree(dd); 239 kfree(dd);
240 } 240 }
241 } 241 }
242 242
243 void dm_table_destroy(struct dm_table *t) 243 void dm_table_destroy(struct dm_table *t)
244 { 244 {
245 unsigned int i; 245 unsigned int i;
246 246
247 if (!t) 247 if (!t)
248 return; 248 return;
249 249
250 while (atomic_read(&t->holders)) 250 while (atomic_read(&t->holders))
251 msleep(1); 251 msleep(1);
252 smp_mb(); 252 smp_mb();
253 253
254 /* free the indexes */ 254 /* free the indexes */
255 if (t->depth >= 2) 255 if (t->depth >= 2)
256 vfree(t->index[t->depth - 2]); 256 vfree(t->index[t->depth - 2]);
257 257
258 /* free the targets */ 258 /* free the targets */
259 for (i = 0; i < t->num_targets; i++) { 259 for (i = 0; i < t->num_targets; i++) {
260 struct dm_target *tgt = t->targets + i; 260 struct dm_target *tgt = t->targets + i;
261 261
262 if (tgt->type->dtr) 262 if (tgt->type->dtr)
263 tgt->type->dtr(tgt); 263 tgt->type->dtr(tgt);
264 264
265 dm_put_target_type(tgt->type); 265 dm_put_target_type(tgt->type);
266 } 266 }
267 267
268 vfree(t->highs); 268 vfree(t->highs);
269 269
270 /* free the device list */ 270 /* free the device list */
271 if (t->devices.next != &t->devices) 271 if (t->devices.next != &t->devices)
272 free_devices(&t->devices); 272 free_devices(&t->devices);
273 273
274 dm_free_md_mempools(t->mempools); 274 dm_free_md_mempools(t->mempools);
275 275
276 kfree(t); 276 kfree(t);
277 } 277 }
278 278
279 void dm_table_get(struct dm_table *t) 279 void dm_table_get(struct dm_table *t)
280 { 280 {
281 atomic_inc(&t->holders); 281 atomic_inc(&t->holders);
282 } 282 }
283 283
284 void dm_table_put(struct dm_table *t) 284 void dm_table_put(struct dm_table *t)
285 { 285 {
286 if (!t) 286 if (!t)
287 return; 287 return;
288 288
289 smp_mb__before_atomic_dec(); 289 smp_mb__before_atomic_dec();
290 atomic_dec(&t->holders); 290 atomic_dec(&t->holders);
291 } 291 }
292 292
293 /* 293 /*
294 * Checks to see if we need to extend highs or targets. 294 * Checks to see if we need to extend highs or targets.
295 */ 295 */
296 static inline int check_space(struct dm_table *t) 296 static inline int check_space(struct dm_table *t)
297 { 297 {
298 if (t->num_targets >= t->num_allocated) 298 if (t->num_targets >= t->num_allocated)
299 return alloc_targets(t, t->num_allocated * 2); 299 return alloc_targets(t, t->num_allocated * 2);
300 300
301 return 0; 301 return 0;
302 } 302 }
303 303
304 /* 304 /*
305 * See if we've already got a device in the list. 305 * See if we've already got a device in the list.
306 */ 306 */
307 static struct dm_dev_internal *find_device(struct list_head *l, dev_t dev) 307 static struct dm_dev_internal *find_device(struct list_head *l, dev_t dev)
308 { 308 {
309 struct dm_dev_internal *dd; 309 struct dm_dev_internal *dd;
310 310
311 list_for_each_entry (dd, l, list) 311 list_for_each_entry (dd, l, list)
312 if (dd->dm_dev.bdev->bd_dev == dev) 312 if (dd->dm_dev.bdev->bd_dev == dev)
313 return dd; 313 return dd;
314 314
315 return NULL; 315 return NULL;
316 } 316 }
317 317
318 /* 318 /*
319 * Open a device so we can use it as a map destination. 319 * Open a device so we can use it as a map destination.
320 */ 320 */
321 static int open_dev(struct dm_dev_internal *d, dev_t dev, 321 static int open_dev(struct dm_dev_internal *d, dev_t dev,
322 struct mapped_device *md) 322 struct mapped_device *md)
323 { 323 {
324 static char *_claim_ptr = "I belong to device-mapper"; 324 static char *_claim_ptr = "I belong to device-mapper";
325 struct block_device *bdev; 325 struct block_device *bdev;
326 326
327 int r; 327 int r;
328 328
329 BUG_ON(d->dm_dev.bdev); 329 BUG_ON(d->dm_dev.bdev);
330 330
331 bdev = blkdev_get_by_dev(dev, d->dm_dev.mode | FMODE_EXCL, _claim_ptr); 331 bdev = blkdev_get_by_dev(dev, d->dm_dev.mode | FMODE_EXCL, _claim_ptr);
332 if (IS_ERR(bdev)) 332 if (IS_ERR(bdev))
333 return PTR_ERR(bdev); 333 return PTR_ERR(bdev);
334 334
335 r = bd_link_disk_holder(bdev, dm_disk(md)); 335 r = bd_link_disk_holder(bdev, dm_disk(md));
336 if (r) { 336 if (r) {
337 blkdev_put(bdev, d->dm_dev.mode | FMODE_EXCL); 337 blkdev_put(bdev, d->dm_dev.mode | FMODE_EXCL);
338 return r; 338 return r;
339 } 339 }
340 340
341 d->dm_dev.bdev = bdev; 341 d->dm_dev.bdev = bdev;
342 return 0; 342 return 0;
343 } 343 }
344 344
345 /* 345 /*
346 * Close a device that we've been using. 346 * Close a device that we've been using.
347 */ 347 */
348 static void close_dev(struct dm_dev_internal *d, struct mapped_device *md) 348 static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
349 { 349 {
350 if (!d->dm_dev.bdev) 350 if (!d->dm_dev.bdev)
351 return; 351 return;
352 352
353 blkdev_put(d->dm_dev.bdev, d->dm_dev.mode | FMODE_EXCL); 353 blkdev_put(d->dm_dev.bdev, d->dm_dev.mode | FMODE_EXCL);
354 d->dm_dev.bdev = NULL; 354 d->dm_dev.bdev = NULL;
355 } 355 }
356 356
357 /* 357 /*
358 * If possible, this checks an area of a destination device is invalid. 358 * If possible, this checks an area of a destination device is invalid.
359 */ 359 */
360 static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev, 360 static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
361 sector_t start, sector_t len, void *data) 361 sector_t start, sector_t len, void *data)
362 { 362 {
363 struct queue_limits *limits = data; 363 struct queue_limits *limits = data;
364 struct block_device *bdev = dev->bdev; 364 struct block_device *bdev = dev->bdev;
365 sector_t dev_size = 365 sector_t dev_size =
366 i_size_read(bdev->bd_inode) >> SECTOR_SHIFT; 366 i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
367 unsigned short logical_block_size_sectors = 367 unsigned short logical_block_size_sectors =
368 limits->logical_block_size >> SECTOR_SHIFT; 368 limits->logical_block_size >> SECTOR_SHIFT;
369 char b[BDEVNAME_SIZE]; 369 char b[BDEVNAME_SIZE];
370 370
371 if (!dev_size) 371 if (!dev_size)
372 return 0; 372 return 0;
373 373
374 if ((start >= dev_size) || (start + len > dev_size)) { 374 if ((start >= dev_size) || (start + len > dev_size)) {
375 DMWARN("%s: %s too small for target: " 375 DMWARN("%s: %s too small for target: "
376 "start=%llu, len=%llu, dev_size=%llu", 376 "start=%llu, len=%llu, dev_size=%llu",
377 dm_device_name(ti->table->md), bdevname(bdev, b), 377 dm_device_name(ti->table->md), bdevname(bdev, b),
378 (unsigned long long)start, 378 (unsigned long long)start,
379 (unsigned long long)len, 379 (unsigned long long)len,
380 (unsigned long long)dev_size); 380 (unsigned long long)dev_size);
381 return 1; 381 return 1;
382 } 382 }
383 383
384 if (logical_block_size_sectors <= 1) 384 if (logical_block_size_sectors <= 1)
385 return 0; 385 return 0;
386 386
387 if (start & (logical_block_size_sectors - 1)) { 387 if (start & (logical_block_size_sectors - 1)) {
388 DMWARN("%s: start=%llu not aligned to h/w " 388 DMWARN("%s: start=%llu not aligned to h/w "
389 "logical block size %u of %s", 389 "logical block size %u of %s",
390 dm_device_name(ti->table->md), 390 dm_device_name(ti->table->md),
391 (unsigned long long)start, 391 (unsigned long long)start,
392 limits->logical_block_size, bdevname(bdev, b)); 392 limits->logical_block_size, bdevname(bdev, b));
393 return 1; 393 return 1;
394 } 394 }
395 395
396 if (len & (logical_block_size_sectors - 1)) { 396 if (len & (logical_block_size_sectors - 1)) {
397 DMWARN("%s: len=%llu not aligned to h/w " 397 DMWARN("%s: len=%llu not aligned to h/w "
398 "logical block size %u of %s", 398 "logical block size %u of %s",
399 dm_device_name(ti->table->md), 399 dm_device_name(ti->table->md),
400 (unsigned long long)len, 400 (unsigned long long)len,
401 limits->logical_block_size, bdevname(bdev, b)); 401 limits->logical_block_size, bdevname(bdev, b));
402 return 1; 402 return 1;
403 } 403 }
404 404
405 return 0; 405 return 0;
406 } 406 }
407 407
408 /* 408 /*
409 * This upgrades the mode on an already open dm_dev, being 409 * This upgrades the mode on an already open dm_dev, being
410 * careful to leave things as they were if we fail to reopen the 410 * careful to leave things as they were if we fail to reopen the
411 * device and not to touch the existing bdev field in case 411 * device and not to touch the existing bdev field in case
412 * it is accessed concurrently inside dm_table_any_congested(). 412 * it is accessed concurrently inside dm_table_any_congested().
413 */ 413 */
414 static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode, 414 static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode,
415 struct mapped_device *md) 415 struct mapped_device *md)
416 { 416 {
417 int r; 417 int r;
418 struct dm_dev_internal dd_new, dd_old; 418 struct dm_dev_internal dd_new, dd_old;
419 419
420 dd_new = dd_old = *dd; 420 dd_new = dd_old = *dd;
421 421
422 dd_new.dm_dev.mode |= new_mode; 422 dd_new.dm_dev.mode |= new_mode;
423 dd_new.dm_dev.bdev = NULL; 423 dd_new.dm_dev.bdev = NULL;
424 424
425 r = open_dev(&dd_new, dd->dm_dev.bdev->bd_dev, md); 425 r = open_dev(&dd_new, dd->dm_dev.bdev->bd_dev, md);
426 if (r) 426 if (r)
427 return r; 427 return r;
428 428
429 dd->dm_dev.mode |= new_mode; 429 dd->dm_dev.mode |= new_mode;
430 close_dev(&dd_old, md); 430 close_dev(&dd_old, md);
431 431
432 return 0; 432 return 0;
433 } 433 }
434 434
435 /* 435 /*
436 * Add a device to the list, or just increment the usage count if 436 * Add a device to the list, or just increment the usage count if
437 * it's already present. 437 * it's already present.
438 */ 438 */
439 static int __table_get_device(struct dm_table *t, struct dm_target *ti, 439 static int __table_get_device(struct dm_table *t, struct dm_target *ti,
440 const char *path, fmode_t mode, struct dm_dev **result) 440 const char *path, fmode_t mode, struct dm_dev **result)
441 { 441 {
442 int r; 442 int r;
443 dev_t uninitialized_var(dev); 443 dev_t uninitialized_var(dev);
444 struct dm_dev_internal *dd; 444 struct dm_dev_internal *dd;
445 unsigned int major, minor; 445 unsigned int major, minor;
446 446
447 BUG_ON(!t); 447 BUG_ON(!t);
448 448
449 if (sscanf(path, "%u:%u", &major, &minor) == 2) { 449 if (sscanf(path, "%u:%u", &major, &minor) == 2) {
450 /* Extract the major/minor numbers */ 450 /* Extract the major/minor numbers */
451 dev = MKDEV(major, minor); 451 dev = MKDEV(major, minor);
452 if (MAJOR(dev) != major || MINOR(dev) != minor) 452 if (MAJOR(dev) != major || MINOR(dev) != minor)
453 return -EOVERFLOW; 453 return -EOVERFLOW;
454 } else { 454 } else {
455 /* convert the path to a device */ 455 /* convert the path to a device */
456 struct block_device *bdev = lookup_bdev(path); 456 struct block_device *bdev = lookup_bdev(path);
457 457
458 if (IS_ERR(bdev)) 458 if (IS_ERR(bdev))
459 return PTR_ERR(bdev); 459 return PTR_ERR(bdev);
460 dev = bdev->bd_dev; 460 dev = bdev->bd_dev;
461 bdput(bdev); 461 bdput(bdev);
462 } 462 }
463 463
464 dd = find_device(&t->devices, dev); 464 dd = find_device(&t->devices, dev);
465 if (!dd) { 465 if (!dd) {
466 dd = kmalloc(sizeof(*dd), GFP_KERNEL); 466 dd = kmalloc(sizeof(*dd), GFP_KERNEL);
467 if (!dd) 467 if (!dd)
468 return -ENOMEM; 468 return -ENOMEM;
469 469
470 dd->dm_dev.mode = mode; 470 dd->dm_dev.mode = mode;
471 dd->dm_dev.bdev = NULL; 471 dd->dm_dev.bdev = NULL;
472 472
473 if ((r = open_dev(dd, dev, t->md))) { 473 if ((r = open_dev(dd, dev, t->md))) {
474 kfree(dd); 474 kfree(dd);
475 return r; 475 return r;
476 } 476 }
477 477
478 format_dev_t(dd->dm_dev.name, dev); 478 format_dev_t(dd->dm_dev.name, dev);
479 479
480 atomic_set(&dd->count, 0); 480 atomic_set(&dd->count, 0);
481 list_add(&dd->list, &t->devices); 481 list_add(&dd->list, &t->devices);
482 482
483 } else if (dd->dm_dev.mode != (mode | dd->dm_dev.mode)) { 483 } else if (dd->dm_dev.mode != (mode | dd->dm_dev.mode)) {
484 r = upgrade_mode(dd, mode, t->md); 484 r = upgrade_mode(dd, mode, t->md);
485 if (r) 485 if (r)
486 return r; 486 return r;
487 } 487 }
488 atomic_inc(&dd->count); 488 atomic_inc(&dd->count);
489 489
490 *result = &dd->dm_dev; 490 *result = &dd->dm_dev;
491 return 0; 491 return 0;
492 } 492 }
493 493
494 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev, 494 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
495 sector_t start, sector_t len, void *data) 495 sector_t start, sector_t len, void *data)
496 { 496 {
497 struct queue_limits *limits = data; 497 struct queue_limits *limits = data;
498 struct block_device *bdev = dev->bdev; 498 struct block_device *bdev = dev->bdev;
499 struct request_queue *q = bdev_get_queue(bdev); 499 struct request_queue *q = bdev_get_queue(bdev);
500 char b[BDEVNAME_SIZE]; 500 char b[BDEVNAME_SIZE];
501 501
502 if (unlikely(!q)) { 502 if (unlikely(!q)) {
503 DMWARN("%s: Cannot set limits for nonexistent device %s", 503 DMWARN("%s: Cannot set limits for nonexistent device %s",
504 dm_device_name(ti->table->md), bdevname(bdev, b)); 504 dm_device_name(ti->table->md), bdevname(bdev, b));
505 return 0; 505 return 0;
506 } 506 }
507 507
508 if (bdev_stack_limits(limits, bdev, start) < 0) 508 if (bdev_stack_limits(limits, bdev, start) < 0)
509 DMWARN("%s: adding target device %s caused an alignment inconsistency: " 509 DMWARN("%s: adding target device %s caused an alignment inconsistency: "
510 "physical_block_size=%u, logical_block_size=%u, " 510 "physical_block_size=%u, logical_block_size=%u, "
511 "alignment_offset=%u, start=%llu", 511 "alignment_offset=%u, start=%llu",
512 dm_device_name(ti->table->md), bdevname(bdev, b), 512 dm_device_name(ti->table->md), bdevname(bdev, b),
513 q->limits.physical_block_size, 513 q->limits.physical_block_size,
514 q->limits.logical_block_size, 514 q->limits.logical_block_size,
515 q->limits.alignment_offset, 515 q->limits.alignment_offset,
516 (unsigned long long) start << SECTOR_SHIFT); 516 (unsigned long long) start << SECTOR_SHIFT);
517 517
518 /* 518 /*
519 * Check if merge fn is supported. 519 * Check if merge fn is supported.
520 * If not we'll force DM to use PAGE_SIZE or 520 * If not we'll force DM to use PAGE_SIZE or
521 * smaller I/O, just to be safe. 521 * smaller I/O, just to be safe.
522 */ 522 */
523 523
524 if (q->merge_bvec_fn && !ti->type->merge) 524 if (q->merge_bvec_fn && !ti->type->merge)
525 blk_limits_max_hw_sectors(limits, 525 blk_limits_max_hw_sectors(limits,
526 (unsigned int) (PAGE_SIZE >> 9)); 526 (unsigned int) (PAGE_SIZE >> 9));
527 return 0; 527 return 0;
528 } 528 }
529 EXPORT_SYMBOL_GPL(dm_set_device_limits); 529 EXPORT_SYMBOL_GPL(dm_set_device_limits);
530 530
531 int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, 531 int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
532 struct dm_dev **result) 532 struct dm_dev **result)
533 { 533 {
534 return __table_get_device(ti->table, ti, path, mode, result); 534 return __table_get_device(ti->table, ti, path, mode, result);
535 } 535 }
536 536
537 537
538 /* 538 /*
539 * Decrement a devices use count and remove it if necessary. 539 * Decrement a devices use count and remove it if necessary.
540 */ 540 */
541 void dm_put_device(struct dm_target *ti, struct dm_dev *d) 541 void dm_put_device(struct dm_target *ti, struct dm_dev *d)
542 { 542 {
543 struct dm_dev_internal *dd = container_of(d, struct dm_dev_internal, 543 struct dm_dev_internal *dd = container_of(d, struct dm_dev_internal,
544 dm_dev); 544 dm_dev);
545 545
546 if (atomic_dec_and_test(&dd->count)) { 546 if (atomic_dec_and_test(&dd->count)) {
547 close_dev(dd, ti->table->md); 547 close_dev(dd, ti->table->md);
548 list_del(&dd->list); 548 list_del(&dd->list);
549 kfree(dd); 549 kfree(dd);
550 } 550 }
551 } 551 }
552 552
553 /* 553 /*
554 * Checks to see if the target joins onto the end of the table. 554 * Checks to see if the target joins onto the end of the table.
555 */ 555 */
556 static int adjoin(struct dm_table *table, struct dm_target *ti) 556 static int adjoin(struct dm_table *table, struct dm_target *ti)
557 { 557 {
558 struct dm_target *prev; 558 struct dm_target *prev;
559 559
560 if (!table->num_targets) 560 if (!table->num_targets)
561 return !ti->begin; 561 return !ti->begin;
562 562
563 prev = &table->targets[table->num_targets - 1]; 563 prev = &table->targets[table->num_targets - 1];
564 return (ti->begin == (prev->begin + prev->len)); 564 return (ti->begin == (prev->begin + prev->len));
565 } 565 }
566 566
567 /* 567 /*
568 * Used to dynamically allocate the arg array. 568 * Used to dynamically allocate the arg array.
569 */ 569 */
570 static char **realloc_argv(unsigned *array_size, char **old_argv) 570 static char **realloc_argv(unsigned *array_size, char **old_argv)
571 { 571 {
572 char **argv; 572 char **argv;
573 unsigned new_size; 573 unsigned new_size;
574 574
575 new_size = *array_size ? *array_size * 2 : 64; 575 new_size = *array_size ? *array_size * 2 : 64;
576 argv = kmalloc(new_size * sizeof(*argv), GFP_KERNEL); 576 argv = kmalloc(new_size * sizeof(*argv), GFP_KERNEL);
577 if (argv) { 577 if (argv) {
578 memcpy(argv, old_argv, *array_size * sizeof(*argv)); 578 memcpy(argv, old_argv, *array_size * sizeof(*argv));
579 *array_size = new_size; 579 *array_size = new_size;
580 } 580 }
581 581
582 kfree(old_argv); 582 kfree(old_argv);
583 return argv; 583 return argv;
584 } 584 }
585 585
586 /* 586 /*
587 * Destructively splits up the argument list to pass to ctr. 587 * Destructively splits up the argument list to pass to ctr.
588 */ 588 */
589 int dm_split_args(int *argc, char ***argvp, char *input) 589 int dm_split_args(int *argc, char ***argvp, char *input)
590 { 590 {
591 char *start, *end = input, *out, **argv = NULL; 591 char *start, *end = input, *out, **argv = NULL;
592 unsigned array_size = 0; 592 unsigned array_size = 0;
593 593
594 *argc = 0; 594 *argc = 0;
595 595
596 if (!input) { 596 if (!input) {
597 *argvp = NULL; 597 *argvp = NULL;
598 return 0; 598 return 0;
599 } 599 }
600 600
601 argv = realloc_argv(&array_size, argv); 601 argv = realloc_argv(&array_size, argv);
602 if (!argv) 602 if (!argv)
603 return -ENOMEM; 603 return -ENOMEM;
604 604
605 while (1) { 605 while (1) {
606 /* Skip whitespace */ 606 /* Skip whitespace */
607 start = skip_spaces(end); 607 start = skip_spaces(end);
608 608
609 if (!*start) 609 if (!*start)
610 break; /* success, we hit the end */ 610 break; /* success, we hit the end */
611 611
612 /* 'out' is used to remove any back-quotes */ 612 /* 'out' is used to remove any back-quotes */
613 end = out = start; 613 end = out = start;
614 while (*end) { 614 while (*end) {
615 /* Everything apart from '\0' can be quoted */ 615 /* Everything apart from '\0' can be quoted */
616 if (*end == '\\' && *(end + 1)) { 616 if (*end == '\\' && *(end + 1)) {
617 *out++ = *(end + 1); 617 *out++ = *(end + 1);
618 end += 2; 618 end += 2;
619 continue; 619 continue;
620 } 620 }
621 621
622 if (isspace(*end)) 622 if (isspace(*end))
623 break; /* end of token */ 623 break; /* end of token */
624 624
625 *out++ = *end++; 625 *out++ = *end++;
626 } 626 }
627 627
628 /* have we already filled the array ? */ 628 /* have we already filled the array ? */
629 if ((*argc + 1) > array_size) { 629 if ((*argc + 1) > array_size) {
630 argv = realloc_argv(&array_size, argv); 630 argv = realloc_argv(&array_size, argv);
631 if (!argv) 631 if (!argv)
632 return -ENOMEM; 632 return -ENOMEM;
633 } 633 }
634 634
635 /* we know this is whitespace */ 635 /* we know this is whitespace */
636 if (*end) 636 if (*end)
637 end++; 637 end++;
638 638
639 /* terminate the string and put it in the array */ 639 /* terminate the string and put it in the array */
640 *out = '\0'; 640 *out = '\0';
641 argv[*argc] = start; 641 argv[*argc] = start;
642 (*argc)++; 642 (*argc)++;
643 } 643 }
644 644
645 *argvp = argv; 645 *argvp = argv;
646 return 0; 646 return 0;
647 } 647 }
648 648
649 /* 649 /*
650 * Impose necessary and sufficient conditions on a devices's table such 650 * Impose necessary and sufficient conditions on a devices's table such
651 * that any incoming bio which respects its logical_block_size can be 651 * that any incoming bio which respects its logical_block_size can be
652 * processed successfully. If it falls across the boundary between 652 * processed successfully. If it falls across the boundary between
653 * two or more targets, the size of each piece it gets split into must 653 * two or more targets, the size of each piece it gets split into must
654 * be compatible with the logical_block_size of the target processing it. 654 * be compatible with the logical_block_size of the target processing it.
655 */ 655 */
656 static int validate_hardware_logical_block_alignment(struct dm_table *table, 656 static int validate_hardware_logical_block_alignment(struct dm_table *table,
657 struct queue_limits *limits) 657 struct queue_limits *limits)
658 { 658 {
659 /* 659 /*
660 * This function uses arithmetic modulo the logical_block_size 660 * This function uses arithmetic modulo the logical_block_size
661 * (in units of 512-byte sectors). 661 * (in units of 512-byte sectors).
662 */ 662 */
663 unsigned short device_logical_block_size_sects = 663 unsigned short device_logical_block_size_sects =
664 limits->logical_block_size >> SECTOR_SHIFT; 664 limits->logical_block_size >> SECTOR_SHIFT;
665 665
666 /* 666 /*
667 * Offset of the start of the next table entry, mod logical_block_size. 667 * Offset of the start of the next table entry, mod logical_block_size.
668 */ 668 */
669 unsigned short next_target_start = 0; 669 unsigned short next_target_start = 0;
670 670
671 /* 671 /*
672 * Given an aligned bio that extends beyond the end of a 672 * Given an aligned bio that extends beyond the end of a
673 * target, how many sectors must the next target handle? 673 * target, how many sectors must the next target handle?
674 */ 674 */
675 unsigned short remaining = 0; 675 unsigned short remaining = 0;
676 676
677 struct dm_target *uninitialized_var(ti); 677 struct dm_target *uninitialized_var(ti);
678 struct queue_limits ti_limits; 678 struct queue_limits ti_limits;
679 unsigned i = 0; 679 unsigned i = 0;
680 680
681 /* 681 /*
682 * Check each entry in the table in turn. 682 * Check each entry in the table in turn.
683 */ 683 */
684 while (i < dm_table_get_num_targets(table)) { 684 while (i < dm_table_get_num_targets(table)) {
685 ti = dm_table_get_target(table, i++); 685 ti = dm_table_get_target(table, i++);
686 686
687 blk_set_default_limits(&ti_limits); 687 blk_set_default_limits(&ti_limits);
688 688
689 /* combine all target devices' limits */ 689 /* combine all target devices' limits */
690 if (ti->type->iterate_devices) 690 if (ti->type->iterate_devices)
691 ti->type->iterate_devices(ti, dm_set_device_limits, 691 ti->type->iterate_devices(ti, dm_set_device_limits,
692 &ti_limits); 692 &ti_limits);
693 693
694 /* 694 /*
695 * If the remaining sectors fall entirely within this 695 * If the remaining sectors fall entirely within this
696 * table entry are they compatible with its logical_block_size? 696 * table entry are they compatible with its logical_block_size?
697 */ 697 */
698 if (remaining < ti->len && 698 if (remaining < ti->len &&
699 remaining & ((ti_limits.logical_block_size >> 699 remaining & ((ti_limits.logical_block_size >>
700 SECTOR_SHIFT) - 1)) 700 SECTOR_SHIFT) - 1))
701 break; /* Error */ 701 break; /* Error */
702 702
703 next_target_start = 703 next_target_start =
704 (unsigned short) ((next_target_start + ti->len) & 704 (unsigned short) ((next_target_start + ti->len) &
705 (device_logical_block_size_sects - 1)); 705 (device_logical_block_size_sects - 1));
706 remaining = next_target_start ? 706 remaining = next_target_start ?
707 device_logical_block_size_sects - next_target_start : 0; 707 device_logical_block_size_sects - next_target_start : 0;
708 } 708 }
709 709
710 if (remaining) { 710 if (remaining) {
711 DMWARN("%s: table line %u (start sect %llu len %llu) " 711 DMWARN("%s: table line %u (start sect %llu len %llu) "
712 "not aligned to h/w logical block size %u", 712 "not aligned to h/w logical block size %u",
713 dm_device_name(table->md), i, 713 dm_device_name(table->md), i,
714 (unsigned long long) ti->begin, 714 (unsigned long long) ti->begin,
715 (unsigned long long) ti->len, 715 (unsigned long long) ti->len,
716 limits->logical_block_size); 716 limits->logical_block_size);
717 return -EINVAL; 717 return -EINVAL;
718 } 718 }
719 719
720 return 0; 720 return 0;
721 } 721 }
722 722
723 int dm_table_add_target(struct dm_table *t, const char *type, 723 int dm_table_add_target(struct dm_table *t, const char *type,
724 sector_t start, sector_t len, char *params) 724 sector_t start, sector_t len, char *params)
725 { 725 {
726 int r = -EINVAL, argc; 726 int r = -EINVAL, argc;
727 char **argv; 727 char **argv;
728 struct dm_target *tgt; 728 struct dm_target *tgt;
729 729
730 if ((r = check_space(t))) 730 if ((r = check_space(t)))
731 return r; 731 return r;
732 732
733 tgt = t->targets + t->num_targets; 733 tgt = t->targets + t->num_targets;
734 memset(tgt, 0, sizeof(*tgt)); 734 memset(tgt, 0, sizeof(*tgt));
735 735
736 if (!len) { 736 if (!len) {
737 DMERR("%s: zero-length target", dm_device_name(t->md)); 737 DMERR("%s: zero-length target", dm_device_name(t->md));
738 return -EINVAL; 738 return -EINVAL;
739 } 739 }
740 740
741 tgt->type = dm_get_target_type(type); 741 tgt->type = dm_get_target_type(type);
742 if (!tgt->type) { 742 if (!tgt->type) {
743 DMERR("%s: %s: unknown target type", dm_device_name(t->md), 743 DMERR("%s: %s: unknown target type", dm_device_name(t->md),
744 type); 744 type);
745 return -EINVAL; 745 return -EINVAL;
746 } 746 }
747 747
748 tgt->table = t; 748 tgt->table = t;
749 tgt->begin = start; 749 tgt->begin = start;
750 tgt->len = len; 750 tgt->len = len;
751 tgt->error = "Unknown error"; 751 tgt->error = "Unknown error";
752 752
753 /* 753 /*
754 * Does this target adjoin the previous one ? 754 * Does this target adjoin the previous one ?
755 */ 755 */
756 if (!adjoin(t, tgt)) { 756 if (!adjoin(t, tgt)) {
757 tgt->error = "Gap in table"; 757 tgt->error = "Gap in table";
758 r = -EINVAL; 758 r = -EINVAL;
759 goto bad; 759 goto bad;
760 } 760 }
761 761
762 r = dm_split_args(&argc, &argv, params); 762 r = dm_split_args(&argc, &argv, params);
763 if (r) { 763 if (r) {
764 tgt->error = "couldn't split parameters (insufficient memory)"; 764 tgt->error = "couldn't split parameters (insufficient memory)";
765 goto bad; 765 goto bad;
766 } 766 }
767 767
768 r = tgt->type->ctr(tgt, argc, argv); 768 r = tgt->type->ctr(tgt, argc, argv);
769 kfree(argv); 769 kfree(argv);
770 if (r) 770 if (r)
771 goto bad; 771 goto bad;
772 772
773 t->highs[t->num_targets++] = tgt->begin + tgt->len - 1; 773 t->highs[t->num_targets++] = tgt->begin + tgt->len - 1;
774 774
775 if (!tgt->num_discard_requests) 775 if (!tgt->num_discard_requests)
776 t->discards_supported = 0; 776 t->discards_supported = 0;
777 777
778 return 0; 778 return 0;
779 779
780 bad: 780 bad:
781 DMERR("%s: %s: %s", dm_device_name(t->md), type, tgt->error); 781 DMERR("%s: %s: %s", dm_device_name(t->md), type, tgt->error);
782 dm_put_target_type(tgt->type); 782 dm_put_target_type(tgt->type);
783 return r; 783 return r;
784 } 784 }
785 785
786 static int dm_table_set_type(struct dm_table *t) 786 static int dm_table_set_type(struct dm_table *t)
787 { 787 {
788 unsigned i; 788 unsigned i;
789 unsigned bio_based = 0, request_based = 0; 789 unsigned bio_based = 0, request_based = 0;
790 struct dm_target *tgt; 790 struct dm_target *tgt;
791 struct dm_dev_internal *dd; 791 struct dm_dev_internal *dd;
792 struct list_head *devices; 792 struct list_head *devices;
793 793
794 for (i = 0; i < t->num_targets; i++) { 794 for (i = 0; i < t->num_targets; i++) {
795 tgt = t->targets + i; 795 tgt = t->targets + i;
796 if (dm_target_request_based(tgt)) 796 if (dm_target_request_based(tgt))
797 request_based = 1; 797 request_based = 1;
798 else 798 else
799 bio_based = 1; 799 bio_based = 1;
800 800
801 if (bio_based && request_based) { 801 if (bio_based && request_based) {
802 DMWARN("Inconsistent table: different target types" 802 DMWARN("Inconsistent table: different target types"
803 " can't be mixed up"); 803 " can't be mixed up");
804 return -EINVAL; 804 return -EINVAL;
805 } 805 }
806 } 806 }
807 807
808 if (bio_based) { 808 if (bio_based) {
809 /* We must use this table as bio-based */ 809 /* We must use this table as bio-based */
810 t->type = DM_TYPE_BIO_BASED; 810 t->type = DM_TYPE_BIO_BASED;
811 return 0; 811 return 0;
812 } 812 }
813 813
814 BUG_ON(!request_based); /* No targets in this table */ 814 BUG_ON(!request_based); /* No targets in this table */
815 815
816 /* Non-request-stackable devices can't be used for request-based dm */ 816 /* Non-request-stackable devices can't be used for request-based dm */
817 devices = dm_table_get_devices(t); 817 devices = dm_table_get_devices(t);
818 list_for_each_entry(dd, devices, list) { 818 list_for_each_entry(dd, devices, list) {
819 if (!blk_queue_stackable(bdev_get_queue(dd->dm_dev.bdev))) { 819 if (!blk_queue_stackable(bdev_get_queue(dd->dm_dev.bdev))) {
820 DMWARN("table load rejected: including" 820 DMWARN("table load rejected: including"
821 " non-request-stackable devices"); 821 " non-request-stackable devices");
822 return -EINVAL; 822 return -EINVAL;
823 } 823 }
824 } 824 }
825 825
826 /* 826 /*
827 * Request-based dm supports only tables that have a single target now. 827 * Request-based dm supports only tables that have a single target now.
828 * To support multiple targets, request splitting support is needed, 828 * To support multiple targets, request splitting support is needed,
829 * and that needs lots of changes in the block-layer. 829 * and that needs lots of changes in the block-layer.
830 * (e.g. request completion process for partial completion.) 830 * (e.g. request completion process for partial completion.)
831 */ 831 */
832 if (t->num_targets > 1) { 832 if (t->num_targets > 1) {
833 DMWARN("Request-based dm doesn't support multiple targets yet"); 833 DMWARN("Request-based dm doesn't support multiple targets yet");
834 return -EINVAL; 834 return -EINVAL;
835 } 835 }
836 836
837 t->type = DM_TYPE_REQUEST_BASED; 837 t->type = DM_TYPE_REQUEST_BASED;
838 838
839 return 0; 839 return 0;
840 } 840 }
841 841
842 unsigned dm_table_get_type(struct dm_table *t) 842 unsigned dm_table_get_type(struct dm_table *t)
843 { 843 {
844 return t->type; 844 return t->type;
845 } 845 }
846 846
847 bool dm_table_request_based(struct dm_table *t) 847 bool dm_table_request_based(struct dm_table *t)
848 { 848 {
849 return dm_table_get_type(t) == DM_TYPE_REQUEST_BASED; 849 return dm_table_get_type(t) == DM_TYPE_REQUEST_BASED;
850 } 850 }
851 851
852 int dm_table_alloc_md_mempools(struct dm_table *t) 852 int dm_table_alloc_md_mempools(struct dm_table *t)
853 { 853 {
854 unsigned type = dm_table_get_type(t); 854 unsigned type = dm_table_get_type(t);
855 855
856 if (unlikely(type == DM_TYPE_NONE)) { 856 if (unlikely(type == DM_TYPE_NONE)) {
857 DMWARN("no table type is set, can't allocate mempools"); 857 DMWARN("no table type is set, can't allocate mempools");
858 return -EINVAL; 858 return -EINVAL;
859 } 859 }
860 860
861 t->mempools = dm_alloc_md_mempools(type); 861 t->mempools = dm_alloc_md_mempools(type);
862 if (!t->mempools) 862 if (!t->mempools)
863 return -ENOMEM; 863 return -ENOMEM;
864 864
865 return 0; 865 return 0;
866 } 866 }
867 867
868 void dm_table_free_md_mempools(struct dm_table *t) 868 void dm_table_free_md_mempools(struct dm_table *t)
869 { 869 {
870 dm_free_md_mempools(t->mempools); 870 dm_free_md_mempools(t->mempools);
871 t->mempools = NULL; 871 t->mempools = NULL;
872 } 872 }
873 873
874 struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t) 874 struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t)
875 { 875 {
876 return t->mempools; 876 return t->mempools;
877 } 877 }
878 878
879 static int setup_indexes(struct dm_table *t) 879 static int setup_indexes(struct dm_table *t)
880 { 880 {
881 int i; 881 int i;
882 unsigned int total = 0; 882 unsigned int total = 0;
883 sector_t *indexes; 883 sector_t *indexes;
884 884
885 /* allocate the space for *all* the indexes */ 885 /* allocate the space for *all* the indexes */
886 for (i = t->depth - 2; i >= 0; i--) { 886 for (i = t->depth - 2; i >= 0; i--) {
887 t->counts[i] = dm_div_up(t->counts[i + 1], CHILDREN_PER_NODE); 887 t->counts[i] = dm_div_up(t->counts[i + 1], CHILDREN_PER_NODE);
888 total += t->counts[i]; 888 total += t->counts[i];
889 } 889 }
890 890
891 indexes = (sector_t *) dm_vcalloc(total, (unsigned long) NODE_SIZE); 891 indexes = (sector_t *) dm_vcalloc(total, (unsigned long) NODE_SIZE);
892 if (!indexes) 892 if (!indexes)
893 return -ENOMEM; 893 return -ENOMEM;
894 894
895 /* set up internal nodes, bottom-up */ 895 /* set up internal nodes, bottom-up */
896 for (i = t->depth - 2; i >= 0; i--) { 896 for (i = t->depth - 2; i >= 0; i--) {
897 t->index[i] = indexes; 897 t->index[i] = indexes;
898 indexes += (KEYS_PER_NODE * t->counts[i]); 898 indexes += (KEYS_PER_NODE * t->counts[i]);
899 setup_btree_index(i, t); 899 setup_btree_index(i, t);
900 } 900 }
901 901
902 return 0; 902 return 0;
903 } 903 }
904 904
905 /* 905 /*
906 * Builds the btree to index the map. 906 * Builds the btree to index the map.
907 */ 907 */
908 static int dm_table_build_index(struct dm_table *t) 908 static int dm_table_build_index(struct dm_table *t)
909 { 909 {
910 int r = 0; 910 int r = 0;
911 unsigned int leaf_nodes; 911 unsigned int leaf_nodes;
912 912
913 /* how many indexes will the btree have ? */ 913 /* how many indexes will the btree have ? */
914 leaf_nodes = dm_div_up(t->num_targets, KEYS_PER_NODE); 914 leaf_nodes = dm_div_up(t->num_targets, KEYS_PER_NODE);
915 t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE); 915 t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE);
916 916
917 /* leaf layer has already been set up */ 917 /* leaf layer has already been set up */
918 t->counts[t->depth - 1] = leaf_nodes; 918 t->counts[t->depth - 1] = leaf_nodes;
919 t->index[t->depth - 1] = t->highs; 919 t->index[t->depth - 1] = t->highs;
920 920
921 if (t->depth >= 2) 921 if (t->depth >= 2)
922 r = setup_indexes(t); 922 r = setup_indexes(t);
923 923
924 return r; 924 return r;
925 } 925 }
926 926
927 /* 927 /*
928 * Register the mapped device for blk_integrity support if 928 * Register the mapped device for blk_integrity support if
929 * the underlying devices support it. 929 * the underlying devices support it.
930 */ 930 */
931 static int dm_table_prealloc_integrity(struct dm_table *t, struct mapped_device *md) 931 static int dm_table_prealloc_integrity(struct dm_table *t, struct mapped_device *md)
932 { 932 {
933 struct list_head *devices = dm_table_get_devices(t); 933 struct list_head *devices = dm_table_get_devices(t);
934 struct dm_dev_internal *dd; 934 struct dm_dev_internal *dd;
935 935
936 list_for_each_entry(dd, devices, list) 936 list_for_each_entry(dd, devices, list)
937 if (bdev_get_integrity(dd->dm_dev.bdev)) 937 if (bdev_get_integrity(dd->dm_dev.bdev))
938 return blk_integrity_register(dm_disk(md), NULL); 938 return blk_integrity_register(dm_disk(md), NULL);
939 939
940 return 0; 940 return 0;
941 } 941 }
942 942
943 /* 943 /*
944 * Prepares the table for use by building the indices, 944 * Prepares the table for use by building the indices,
945 * setting the type, and allocating mempools. 945 * setting the type, and allocating mempools.
946 */ 946 */
947 int dm_table_complete(struct dm_table *t) 947 int dm_table_complete(struct dm_table *t)
948 { 948 {
949 int r; 949 int r;
950 950
951 r = dm_table_set_type(t); 951 r = dm_table_set_type(t);
952 if (r) { 952 if (r) {
953 DMERR("unable to set table type"); 953 DMERR("unable to set table type");
954 return r; 954 return r;
955 } 955 }
956 956
957 r = dm_table_build_index(t); 957 r = dm_table_build_index(t);
958 if (r) { 958 if (r) {
959 DMERR("unable to build btrees"); 959 DMERR("unable to build btrees");
960 return r; 960 return r;
961 } 961 }
962 962
963 r = dm_table_prealloc_integrity(t, t->md); 963 r = dm_table_prealloc_integrity(t, t->md);
964 if (r) { 964 if (r) {
965 DMERR("could not register integrity profile."); 965 DMERR("could not register integrity profile.");
966 return r; 966 return r;
967 } 967 }
968 968
969 r = dm_table_alloc_md_mempools(t); 969 r = dm_table_alloc_md_mempools(t);
970 if (r) 970 if (r)
971 DMERR("unable to allocate mempools"); 971 DMERR("unable to allocate mempools");
972 972
973 return r; 973 return r;
974 } 974 }
975 975
976 static DEFINE_MUTEX(_event_lock); 976 static DEFINE_MUTEX(_event_lock);
977 void dm_table_event_callback(struct dm_table *t, 977 void dm_table_event_callback(struct dm_table *t,
978 void (*fn)(void *), void *context) 978 void (*fn)(void *), void *context)
979 { 979 {
980 mutex_lock(&_event_lock); 980 mutex_lock(&_event_lock);
981 t->event_fn = fn; 981 t->event_fn = fn;
982 t->event_context = context; 982 t->event_context = context;
983 mutex_unlock(&_event_lock); 983 mutex_unlock(&_event_lock);
984 } 984 }
985 985
986 void dm_table_event(struct dm_table *t) 986 void dm_table_event(struct dm_table *t)
987 { 987 {
988 /* 988 /*
989 * You can no longer call dm_table_event() from interrupt 989 * You can no longer call dm_table_event() from interrupt
990 * context, use a bottom half instead. 990 * context, use a bottom half instead.
991 */ 991 */
992 BUG_ON(in_interrupt()); 992 BUG_ON(in_interrupt());
993 993
994 mutex_lock(&_event_lock); 994 mutex_lock(&_event_lock);
995 if (t->event_fn) 995 if (t->event_fn)
996 t->event_fn(t->event_context); 996 t->event_fn(t->event_context);
997 mutex_unlock(&_event_lock); 997 mutex_unlock(&_event_lock);
998 } 998 }
999 999
1000 sector_t dm_table_get_size(struct dm_table *t) 1000 sector_t dm_table_get_size(struct dm_table *t)
1001 { 1001 {
1002 return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0; 1002 return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0;
1003 } 1003 }
1004 1004
1005 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index) 1005 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index)
1006 { 1006 {
1007 if (index >= t->num_targets) 1007 if (index >= t->num_targets)
1008 return NULL; 1008 return NULL;
1009 1009
1010 return t->targets + index; 1010 return t->targets + index;
1011 } 1011 }
1012 1012
1013 /* 1013 /*
1014 * Search the btree for the correct target. 1014 * Search the btree for the correct target.
1015 * 1015 *
1016 * Caller should check returned pointer with dm_target_is_valid() 1016 * Caller should check returned pointer with dm_target_is_valid()
1017 * to trap I/O beyond end of device. 1017 * to trap I/O beyond end of device.
1018 */ 1018 */
1019 struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector) 1019 struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
1020 { 1020 {
1021 unsigned int l, n = 0, k = 0; 1021 unsigned int l, n = 0, k = 0;
1022 sector_t *node; 1022 sector_t *node;
1023 1023
1024 for (l = 0; l < t->depth; l++) { 1024 for (l = 0; l < t->depth; l++) {
1025 n = get_child(n, k); 1025 n = get_child(n, k);
1026 node = get_node(t, l, n); 1026 node = get_node(t, l, n);
1027 1027
1028 for (k = 0; k < KEYS_PER_NODE; k++) 1028 for (k = 0; k < KEYS_PER_NODE; k++)
1029 if (node[k] >= sector) 1029 if (node[k] >= sector)
1030 break; 1030 break;
1031 } 1031 }
1032 1032
1033 return &t->targets[(KEYS_PER_NODE * n) + k]; 1033 return &t->targets[(KEYS_PER_NODE * n) + k];
1034 } 1034 }
1035 1035
1036 /* 1036 /*
1037 * Establish the new table's queue_limits and validate them. 1037 * Establish the new table's queue_limits and validate them.
1038 */ 1038 */
1039 int dm_calculate_queue_limits(struct dm_table *table, 1039 int dm_calculate_queue_limits(struct dm_table *table,
1040 struct queue_limits *limits) 1040 struct queue_limits *limits)
1041 { 1041 {
1042 struct dm_target *uninitialized_var(ti); 1042 struct dm_target *uninitialized_var(ti);
1043 struct queue_limits ti_limits; 1043 struct queue_limits ti_limits;
1044 unsigned i = 0; 1044 unsigned i = 0;
1045 1045
1046 blk_set_default_limits(limits); 1046 blk_set_default_limits(limits);
1047 1047
1048 while (i < dm_table_get_num_targets(table)) { 1048 while (i < dm_table_get_num_targets(table)) {
1049 blk_set_default_limits(&ti_limits); 1049 blk_set_default_limits(&ti_limits);
1050 1050
1051 ti = dm_table_get_target(table, i++); 1051 ti = dm_table_get_target(table, i++);
1052 1052
1053 if (!ti->type->iterate_devices) 1053 if (!ti->type->iterate_devices)
1054 goto combine_limits; 1054 goto combine_limits;
1055 1055
1056 /* 1056 /*
1057 * Combine queue limits of all the devices this target uses. 1057 * Combine queue limits of all the devices this target uses.
1058 */ 1058 */
1059 ti->type->iterate_devices(ti, dm_set_device_limits, 1059 ti->type->iterate_devices(ti, dm_set_device_limits,
1060 &ti_limits); 1060 &ti_limits);
1061 1061
1062 /* Set I/O hints portion of queue limits */ 1062 /* Set I/O hints portion of queue limits */
1063 if (ti->type->io_hints) 1063 if (ti->type->io_hints)
1064 ti->type->io_hints(ti, &ti_limits); 1064 ti->type->io_hints(ti, &ti_limits);
1065 1065
1066 /* 1066 /*
1067 * Check each device area is consistent with the target's 1067 * Check each device area is consistent with the target's
1068 * overall queue limits. 1068 * overall queue limits.
1069 */ 1069 */
1070 if (ti->type->iterate_devices(ti, device_area_is_invalid, 1070 if (ti->type->iterate_devices(ti, device_area_is_invalid,
1071 &ti_limits)) 1071 &ti_limits))
1072 return -EINVAL; 1072 return -EINVAL;
1073 1073
1074 combine_limits: 1074 combine_limits:
1075 /* 1075 /*
1076 * Merge this target's queue limits into the overall limits 1076 * Merge this target's queue limits into the overall limits
1077 * for the table. 1077 * for the table.
1078 */ 1078 */
1079 if (blk_stack_limits(limits, &ti_limits, 0) < 0) 1079 if (blk_stack_limits(limits, &ti_limits, 0) < 0)
1080 DMWARN("%s: adding target device " 1080 DMWARN("%s: adding target device "
1081 "(start sect %llu len %llu) " 1081 "(start sect %llu len %llu) "
1082 "caused an alignment inconsistency", 1082 "caused an alignment inconsistency",
1083 dm_device_name(table->md), 1083 dm_device_name(table->md),
1084 (unsigned long long) ti->begin, 1084 (unsigned long long) ti->begin,
1085 (unsigned long long) ti->len); 1085 (unsigned long long) ti->len);
1086 } 1086 }
1087 1087
1088 return validate_hardware_logical_block_alignment(table, limits); 1088 return validate_hardware_logical_block_alignment(table, limits);
1089 } 1089 }
1090 1090
1091 /* 1091 /*
1092 * Set the integrity profile for this device if all devices used have 1092 * Set the integrity profile for this device if all devices used have
1093 * matching profiles. 1093 * matching profiles.
1094 */ 1094 */
1095 static void dm_table_set_integrity(struct dm_table *t) 1095 static void dm_table_set_integrity(struct dm_table *t)
1096 { 1096 {
1097 struct list_head *devices = dm_table_get_devices(t); 1097 struct list_head *devices = dm_table_get_devices(t);
1098 struct dm_dev_internal *prev = NULL, *dd = NULL; 1098 struct dm_dev_internal *prev = NULL, *dd = NULL;
1099 1099
1100 if (!blk_get_integrity(dm_disk(t->md))) 1100 if (!blk_get_integrity(dm_disk(t->md)))
1101 return; 1101 return;
1102 1102
1103 list_for_each_entry(dd, devices, list) { 1103 list_for_each_entry(dd, devices, list) {
1104 if (prev && 1104 if (prev &&
1105 blk_integrity_compare(prev->dm_dev.bdev->bd_disk, 1105 blk_integrity_compare(prev->dm_dev.bdev->bd_disk,
1106 dd->dm_dev.bdev->bd_disk) < 0) { 1106 dd->dm_dev.bdev->bd_disk) < 0) {
1107 DMWARN("%s: integrity not set: %s and %s mismatch", 1107 DMWARN("%s: integrity not set: %s and %s mismatch",
1108 dm_device_name(t->md), 1108 dm_device_name(t->md),
1109 prev->dm_dev.bdev->bd_disk->disk_name, 1109 prev->dm_dev.bdev->bd_disk->disk_name,
1110 dd->dm_dev.bdev->bd_disk->disk_name); 1110 dd->dm_dev.bdev->bd_disk->disk_name);
1111 goto no_integrity; 1111 goto no_integrity;
1112 } 1112 }
1113 prev = dd; 1113 prev = dd;
1114 } 1114 }
1115 1115
1116 if (!prev || !bdev_get_integrity(prev->dm_dev.bdev)) 1116 if (!prev || !bdev_get_integrity(prev->dm_dev.bdev))
1117 goto no_integrity; 1117 goto no_integrity;
1118 1118
1119 blk_integrity_register(dm_disk(t->md), 1119 blk_integrity_register(dm_disk(t->md),
1120 bdev_get_integrity(prev->dm_dev.bdev)); 1120 bdev_get_integrity(prev->dm_dev.bdev));
1121 1121
1122 return; 1122 return;
1123 1123
1124 no_integrity: 1124 no_integrity:
1125 blk_integrity_register(dm_disk(t->md), NULL); 1125 blk_integrity_register(dm_disk(t->md), NULL);
1126 1126
1127 return; 1127 return;
1128 } 1128 }
1129 1129
1130 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, 1130 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
1131 struct queue_limits *limits) 1131 struct queue_limits *limits)
1132 { 1132 {
1133 /* 1133 /*
1134 * Copy table's limits to the DM device's request_queue 1134 * Copy table's limits to the DM device's request_queue
1135 */ 1135 */
1136 q->limits = *limits; 1136 q->limits = *limits;
1137 1137
1138 if (!dm_table_supports_discards(t)) 1138 if (!dm_table_supports_discards(t))
1139 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q); 1139 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
1140 else 1140 else
1141 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q); 1141 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
1142 1142
1143 dm_table_set_integrity(t); 1143 dm_table_set_integrity(t);
1144 1144
1145 /* 1145 /*
1146 * QUEUE_FLAG_STACKABLE must be set after all queue settings are 1146 * QUEUE_FLAG_STACKABLE must be set after all queue settings are
1147 * visible to other CPUs because, once the flag is set, incoming bios 1147 * visible to other CPUs because, once the flag is set, incoming bios
1148 * are processed by request-based dm, which refers to the queue 1148 * are processed by request-based dm, which refers to the queue
1149 * settings. 1149 * settings.
1150 * Until the flag set, bios are passed to bio-based dm and queued to 1150 * Until the flag set, bios are passed to bio-based dm and queued to
1151 * md->deferred where queue settings are not needed yet. 1151 * md->deferred where queue settings are not needed yet.
1152 * Those bios are passed to request-based dm at the resume time. 1152 * Those bios are passed to request-based dm at the resume time.
1153 */ 1153 */
1154 smp_mb(); 1154 smp_mb();
1155 if (dm_table_request_based(t)) 1155 if (dm_table_request_based(t))
1156 queue_flag_set_unlocked(QUEUE_FLAG_STACKABLE, q); 1156 queue_flag_set_unlocked(QUEUE_FLAG_STACKABLE, q);
1157 } 1157 }
1158 1158
1159 unsigned int dm_table_get_num_targets(struct dm_table *t) 1159 unsigned int dm_table_get_num_targets(struct dm_table *t)
1160 { 1160 {
1161 return t->num_targets; 1161 return t->num_targets;
1162 } 1162 }
1163 1163
1164 struct list_head *dm_table_get_devices(struct dm_table *t) 1164 struct list_head *dm_table_get_devices(struct dm_table *t)
1165 { 1165 {
1166 return &t->devices; 1166 return &t->devices;
1167 } 1167 }
1168 1168
1169 fmode_t dm_table_get_mode(struct dm_table *t) 1169 fmode_t dm_table_get_mode(struct dm_table *t)
1170 { 1170 {
1171 return t->mode; 1171 return t->mode;
1172 } 1172 }
1173 1173
1174 static void suspend_targets(struct dm_table *t, unsigned postsuspend) 1174 static void suspend_targets(struct dm_table *t, unsigned postsuspend)
1175 { 1175 {
1176 int i = t->num_targets; 1176 int i = t->num_targets;
1177 struct dm_target *ti = t->targets; 1177 struct dm_target *ti = t->targets;
1178 1178
1179 while (i--) { 1179 while (i--) {
1180 if (postsuspend) { 1180 if (postsuspend) {
1181 if (ti->type->postsuspend) 1181 if (ti->type->postsuspend)
1182 ti->type->postsuspend(ti); 1182 ti->type->postsuspend(ti);
1183 } else if (ti->type->presuspend) 1183 } else if (ti->type->presuspend)
1184 ti->type->presuspend(ti); 1184 ti->type->presuspend(ti);
1185 1185
1186 ti++; 1186 ti++;
1187 } 1187 }
1188 } 1188 }
1189 1189
1190 void dm_table_presuspend_targets(struct dm_table *t) 1190 void dm_table_presuspend_targets(struct dm_table *t)
1191 { 1191 {
1192 if (!t) 1192 if (!t)
1193 return; 1193 return;
1194 1194
1195 suspend_targets(t, 0); 1195 suspend_targets(t, 0);
1196 } 1196 }
1197 1197
1198 void dm_table_postsuspend_targets(struct dm_table *t) 1198 void dm_table_postsuspend_targets(struct dm_table *t)
1199 { 1199 {
1200 if (!t) 1200 if (!t)
1201 return; 1201 return;
1202 1202
1203 suspend_targets(t, 1); 1203 suspend_targets(t, 1);
1204 } 1204 }
1205 1205
1206 int dm_table_resume_targets(struct dm_table *t) 1206 int dm_table_resume_targets(struct dm_table *t)
1207 { 1207 {
1208 int i, r = 0; 1208 int i, r = 0;
1209 1209
1210 for (i = 0; i < t->num_targets; i++) { 1210 for (i = 0; i < t->num_targets; i++) {
1211 struct dm_target *ti = t->targets + i; 1211 struct dm_target *ti = t->targets + i;
1212 1212
1213 if (!ti->type->preresume) 1213 if (!ti->type->preresume)
1214 continue; 1214 continue;
1215 1215
1216 r = ti->type->preresume(ti); 1216 r = ti->type->preresume(ti);
1217 if (r) 1217 if (r)
1218 return r; 1218 return r;
1219 } 1219 }
1220 1220
1221 for (i = 0; i < t->num_targets; i++) { 1221 for (i = 0; i < t->num_targets; i++) {
1222 struct dm_target *ti = t->targets + i; 1222 struct dm_target *ti = t->targets + i;
1223 1223
1224 if (ti->type->resume) 1224 if (ti->type->resume)
1225 ti->type->resume(ti); 1225 ti->type->resume(ti);
1226 } 1226 }
1227 1227
1228 return 0; 1228 return 0;
1229 } 1229 }
1230 1230
1231 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb) 1231 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb)
1232 { 1232 {
1233 list_add(&cb->list, &t->target_callbacks); 1233 list_add(&cb->list, &t->target_callbacks);
1234 } 1234 }
1235 EXPORT_SYMBOL_GPL(dm_table_add_target_callbacks); 1235 EXPORT_SYMBOL_GPL(dm_table_add_target_callbacks);
1236 1236
1237 int dm_table_any_congested(struct dm_table *t, int bdi_bits) 1237 int dm_table_any_congested(struct dm_table *t, int bdi_bits)
1238 { 1238 {
1239 struct dm_dev_internal *dd; 1239 struct dm_dev_internal *dd;
1240 struct list_head *devices = dm_table_get_devices(t); 1240 struct list_head *devices = dm_table_get_devices(t);
1241 struct dm_target_callbacks *cb; 1241 struct dm_target_callbacks *cb;
1242 int r = 0; 1242 int r = 0;
1243 1243
1244 list_for_each_entry(dd, devices, list) { 1244 list_for_each_entry(dd, devices, list) {
1245 struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev); 1245 struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev);
1246 char b[BDEVNAME_SIZE]; 1246 char b[BDEVNAME_SIZE];
1247 1247
1248 if (likely(q)) 1248 if (likely(q))
1249 r |= bdi_congested(&q->backing_dev_info, bdi_bits); 1249 r |= bdi_congested(&q->backing_dev_info, bdi_bits);
1250 else 1250 else
1251 DMWARN_LIMIT("%s: any_congested: nonexistent device %s", 1251 DMWARN_LIMIT("%s: any_congested: nonexistent device %s",
1252 dm_device_name(t->md), 1252 dm_device_name(t->md),
1253 bdevname(dd->dm_dev.bdev, b)); 1253 bdevname(dd->dm_dev.bdev, b));
1254 } 1254 }
1255 1255
1256 list_for_each_entry(cb, &t->target_callbacks, list) 1256 list_for_each_entry(cb, &t->target_callbacks, list)
1257 if (cb->congested_fn) 1257 if (cb->congested_fn)
1258 r |= cb->congested_fn(cb, bdi_bits); 1258 r |= cb->congested_fn(cb, bdi_bits);
1259 1259
1260 return r; 1260 return r;
1261 } 1261 }
1262 1262
1263 int dm_table_any_busy_target(struct dm_table *t) 1263 int dm_table_any_busy_target(struct dm_table *t)
1264 { 1264 {
1265 unsigned i; 1265 unsigned i;
1266 struct dm_target *ti; 1266 struct dm_target *ti;
1267 1267
1268 for (i = 0; i < t->num_targets; i++) { 1268 for (i = 0; i < t->num_targets; i++) {
1269 ti = t->targets + i; 1269 ti = t->targets + i;
1270 if (ti->type->busy && ti->type->busy(ti)) 1270 if (ti->type->busy && ti->type->busy(ti))
1271 return 1; 1271 return 1;
1272 } 1272 }
1273 1273
1274 return 0; 1274 return 0;
1275 } 1275 }
1276 1276
1277 void dm_table_unplug_all(struct dm_table *t) 1277 void dm_table_unplug_all(struct dm_table *t)
1278 { 1278 {
1279 struct dm_dev_internal *dd; 1279 struct dm_dev_internal *dd;
1280 struct list_head *devices = dm_table_get_devices(t); 1280 struct list_head *devices = dm_table_get_devices(t);
1281 struct dm_target_callbacks *cb;
1281 1282
1282 list_for_each_entry(dd, devices, list) { 1283 list_for_each_entry(dd, devices, list) {
1283 struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev); 1284 struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev);
1284 char b[BDEVNAME_SIZE]; 1285 char b[BDEVNAME_SIZE];
1285 1286
1286 if (likely(q)) 1287 if (likely(q))
1287 blk_unplug(q); 1288 blk_unplug(q);
1288 else 1289 else
1289 DMWARN_LIMIT("%s: Cannot unplug nonexistent device %s", 1290 DMWARN_LIMIT("%s: Cannot unplug nonexistent device %s",
1290 dm_device_name(t->md), 1291 dm_device_name(t->md),
1291 bdevname(dd->dm_dev.bdev, b)); 1292 bdevname(dd->dm_dev.bdev, b));
1292 } 1293 }
1294
1295 list_for_each_entry(cb, &t->target_callbacks, list)
1296 if (cb->unplug_fn)
1297 cb->unplug_fn(cb);
1293 } 1298 }
1294 1299
1295 struct mapped_device *dm_table_get_md(struct dm_table *t) 1300 struct mapped_device *dm_table_get_md(struct dm_table *t)
1296 { 1301 {
1297 return t->md; 1302 return t->md;
1298 } 1303 }
1299 1304
1300 static int device_discard_capable(struct dm_target *ti, struct dm_dev *dev, 1305 static int device_discard_capable(struct dm_target *ti, struct dm_dev *dev,
1301 sector_t start, sector_t len, void *data) 1306 sector_t start, sector_t len, void *data)
1302 { 1307 {
1303 struct request_queue *q = bdev_get_queue(dev->bdev); 1308 struct request_queue *q = bdev_get_queue(dev->bdev);
1304 1309
1305 return q && blk_queue_discard(q); 1310 return q && blk_queue_discard(q);
1306 } 1311 }
1307 1312
1308 bool dm_table_supports_discards(struct dm_table *t) 1313 bool dm_table_supports_discards(struct dm_table *t)
1309 { 1314 {
1310 struct dm_target *ti; 1315 struct dm_target *ti;
1311 unsigned i = 0; 1316 unsigned i = 0;
1312 1317
1313 if (!t->discards_supported) 1318 if (!t->discards_supported)
1314 return 0; 1319 return 0;
1315 1320
1316 /* 1321 /*
1317 * Ensure that at least one underlying device supports discards. 1322 * Ensure that at least one underlying device supports discards.
1318 * t->devices includes internal dm devices such as mirror logs 1323 * t->devices includes internal dm devices such as mirror logs
1319 * so we need to use iterate_devices here, which targets 1324 * so we need to use iterate_devices here, which targets
1320 * supporting discard must provide. 1325 * supporting discard must provide.
1321 */ 1326 */
1322 while (i < dm_table_get_num_targets(t)) { 1327 while (i < dm_table_get_num_targets(t)) {
1323 ti = dm_table_get_target(t, i++); 1328 ti = dm_table_get_target(t, i++);
1324 1329
1325 if (ti->type->iterate_devices && 1330 if (ti->type->iterate_devices &&
1326 ti->type->iterate_devices(ti, device_discard_capable, NULL)) 1331 ti->type->iterate_devices(ti, device_discard_capable, NULL))
1327 return 1; 1332 return 1;
1328 } 1333 }
1329 1334
1330 return 0; 1335 return 0;
1331 } 1336 }
1332 1337
1333 EXPORT_SYMBOL(dm_vcalloc); 1338 EXPORT_SYMBOL(dm_vcalloc);
1334 EXPORT_SYMBOL(dm_get_device); 1339 EXPORT_SYMBOL(dm_get_device);
1335 EXPORT_SYMBOL(dm_put_device); 1340 EXPORT_SYMBOL(dm_put_device);
1336 EXPORT_SYMBOL(dm_table_event); 1341 EXPORT_SYMBOL(dm_table_event);
1337 EXPORT_SYMBOL(dm_table_get_size); 1342 EXPORT_SYMBOL(dm_table_get_size);
1338 EXPORT_SYMBOL(dm_table_get_mode); 1343 EXPORT_SYMBOL(dm_table_get_mode);
1339 EXPORT_SYMBOL(dm_table_get_md); 1344 EXPORT_SYMBOL(dm_table_get_md);
1340 EXPORT_SYMBOL(dm_table_put); 1345 EXPORT_SYMBOL(dm_table_put);
1341 EXPORT_SYMBOL(dm_table_get); 1346 EXPORT_SYMBOL(dm_table_get);
1342 EXPORT_SYMBOL(dm_table_unplug_all); 1347 EXPORT_SYMBOL(dm_table_unplug_all);
1343 1348
include/linux/device-mapper.h
Diff comments   View file @ 99d03c1
1 /* 1 /*
2 * Copyright (C) 2001 Sistina Software (UK) Limited. 2 * Copyright (C) 2001 Sistina Software (UK) Limited.
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This file is released under the LGPL. 5 * This file is released under the LGPL.
6 */ 6 */
7 7
8 #ifndef _LINUX_DEVICE_MAPPER_H 8 #ifndef _LINUX_DEVICE_MAPPER_H
9 #define _LINUX_DEVICE_MAPPER_H 9 #define _LINUX_DEVICE_MAPPER_H
10 10
11 #include <linux/bio.h> 11 #include <linux/bio.h>
12 #include <linux/blkdev.h> 12 #include <linux/blkdev.h>
13 13
14 struct dm_dev; 14 struct dm_dev;
15 struct dm_target; 15 struct dm_target;
16 struct dm_table; 16 struct dm_table;
17 struct mapped_device; 17 struct mapped_device;
18 struct bio_vec; 18 struct bio_vec;
19 19
20 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t; 20 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
21 21
22 union map_info { 22 union map_info {
23 void *ptr; 23 void *ptr;
24 unsigned long long ll; 24 unsigned long long ll;
25 unsigned target_request_nr; 25 unsigned target_request_nr;
26 }; 26 };
27 27
28 /* 28 /*
29 * In the constructor the target parameter will already have the 29 * In the constructor the target parameter will already have the
30 * table, type, begin and len fields filled in. 30 * table, type, begin and len fields filled in.
31 */ 31 */
32 typedef int (*dm_ctr_fn) (struct dm_target *target, 32 typedef int (*dm_ctr_fn) (struct dm_target *target,
33 unsigned int argc, char **argv); 33 unsigned int argc, char **argv);
34 34
35 /* 35 /*
36 * The destructor doesn't need to free the dm_target, just 36 * The destructor doesn't need to free the dm_target, just
37 * anything hidden ti->private. 37 * anything hidden ti->private.
38 */ 38 */
39 typedef void (*dm_dtr_fn) (struct dm_target *ti); 39 typedef void (*dm_dtr_fn) (struct dm_target *ti);
40 40
41 /* 41 /*
42 * The map function must return: 42 * The map function must return:
43 * < 0: error 43 * < 0: error
44 * = 0: The target will handle the io by resubmitting it later 44 * = 0: The target will handle the io by resubmitting it later
45 * = 1: simple remap complete 45 * = 1: simple remap complete
46 * = 2: The target wants to push back the io 46 * = 2: The target wants to push back the io
47 */ 47 */
48 typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio, 48 typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio,
49 union map_info *map_context); 49 union map_info *map_context);
50 typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone, 50 typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
51 union map_info *map_context); 51 union map_info *map_context);
52 52
53 /* 53 /*
54 * Returns: 54 * Returns:
55 * < 0 : error (currently ignored) 55 * < 0 : error (currently ignored)
56 * 0 : ended successfully 56 * 0 : ended successfully
57 * 1 : for some reason the io has still not completed (eg, 57 * 1 : for some reason the io has still not completed (eg,
58 * multipath target might want to requeue a failed io). 58 * multipath target might want to requeue a failed io).
59 * 2 : The target wants to push back the io 59 * 2 : The target wants to push back the io
60 */ 60 */
61 typedef int (*dm_endio_fn) (struct dm_target *ti, 61 typedef int (*dm_endio_fn) (struct dm_target *ti,
62 struct bio *bio, int error, 62 struct bio *bio, int error,
63 union map_info *map_context); 63 union map_info *map_context);
64 typedef int (*dm_request_endio_fn) (struct dm_target *ti, 64 typedef int (*dm_request_endio_fn) (struct dm_target *ti,
65 struct request *clone, int error, 65 struct request *clone, int error,
66 union map_info *map_context); 66 union map_info *map_context);
67 67
68 typedef void (*dm_flush_fn) (struct dm_target *ti); 68 typedef void (*dm_flush_fn) (struct dm_target *ti);
69 typedef void (*dm_presuspend_fn) (struct dm_target *ti); 69 typedef void (*dm_presuspend_fn) (struct dm_target *ti);
70 typedef void (*dm_postsuspend_fn) (struct dm_target *ti); 70 typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
71 typedef int (*dm_preresume_fn) (struct dm_target *ti); 71 typedef int (*dm_preresume_fn) (struct dm_target *ti);
72 typedef void (*dm_resume_fn) (struct dm_target *ti); 72 typedef void (*dm_resume_fn) (struct dm_target *ti);
73 73
74 typedef int (*dm_status_fn) (struct dm_target *ti, status_type_t status_type, 74 typedef int (*dm_status_fn) (struct dm_target *ti, status_type_t status_type,
75 char *result, unsigned int maxlen); 75 char *result, unsigned int maxlen);
76 76
77 typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv); 77 typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv);
78 78
79 typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd, 79 typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
80 unsigned long arg); 80 unsigned long arg);
81 81
82 typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm, 82 typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm,
83 struct bio_vec *biovec, int max_size); 83 struct bio_vec *biovec, int max_size);
84 84
85 typedef int (*iterate_devices_callout_fn) (struct dm_target *ti, 85 typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
86 struct dm_dev *dev, 86 struct dm_dev *dev,
87 sector_t start, sector_t len, 87 sector_t start, sector_t len,
88 void *data); 88 void *data);
89 89
90 typedef int (*dm_iterate_devices_fn) (struct dm_target *ti, 90 typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
91 iterate_devices_callout_fn fn, 91 iterate_devices_callout_fn fn,
92 void *data); 92 void *data);
93 93
94 typedef void (*dm_io_hints_fn) (struct dm_target *ti, 94 typedef void (*dm_io_hints_fn) (struct dm_target *ti,
95 struct queue_limits *limits); 95 struct queue_limits *limits);
96 96
97 /* 97 /*
98 * Returns: 98 * Returns:
99 * 0: The target can handle the next I/O immediately. 99 * 0: The target can handle the next I/O immediately.
100 * 1: The target can't handle the next I/O immediately. 100 * 1: The target can't handle the next I/O immediately.
101 */ 101 */
102 typedef int (*dm_busy_fn) (struct dm_target *ti); 102 typedef int (*dm_busy_fn) (struct dm_target *ti);
103 103
104 void dm_error(const char *message); 104 void dm_error(const char *message);
105 105
106 /* 106 /*
107 * Combine device limits. 107 * Combine device limits.
108 */ 108 */
109 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev, 109 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
110 sector_t start, sector_t len, void *data); 110 sector_t start, sector_t len, void *data);
111 111
112 struct dm_dev { 112 struct dm_dev {
113 struct block_device *bdev; 113 struct block_device *bdev;
114 fmode_t mode; 114 fmode_t mode;
115 char name[16]; 115 char name[16];
116 }; 116 };
117 117
118 /* 118 /*
119 * Constructors should call these functions to ensure destination devices 119 * Constructors should call these functions to ensure destination devices
120 * are opened/closed correctly. 120 * are opened/closed correctly.
121 */ 121 */
122 int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, 122 int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
123 struct dm_dev **result); 123 struct dm_dev **result);
124 void dm_put_device(struct dm_target *ti, struct dm_dev *d); 124 void dm_put_device(struct dm_target *ti, struct dm_dev *d);
125 125
126 /* 126 /*
127 * Information about a target type 127 * Information about a target type
128 */ 128 */
129 129
130 /* 130 /*
131 * Target features 131 * Target features
132 */ 132 */
133 133
134 struct target_type { 134 struct target_type {
135 uint64_t features; 135 uint64_t features;
136 const char *name; 136 const char *name;
137 struct module *module; 137 struct module *module;
138 unsigned version[3]; 138 unsigned version[3];
139 dm_ctr_fn ctr; 139 dm_ctr_fn ctr;
140 dm_dtr_fn dtr; 140 dm_dtr_fn dtr;
141 dm_map_fn map; 141 dm_map_fn map;
142 dm_map_request_fn map_rq; 142 dm_map_request_fn map_rq;
143 dm_endio_fn end_io; 143 dm_endio_fn end_io;
144 dm_request_endio_fn rq_end_io; 144 dm_request_endio_fn rq_end_io;
145 dm_flush_fn flush; 145 dm_flush_fn flush;
146 dm_presuspend_fn presuspend; 146 dm_presuspend_fn presuspend;
147 dm_postsuspend_fn postsuspend; 147 dm_postsuspend_fn postsuspend;
148 dm_preresume_fn preresume; 148 dm_preresume_fn preresume;
149 dm_resume_fn resume; 149 dm_resume_fn resume;
150 dm_status_fn status; 150 dm_status_fn status;
151 dm_message_fn message; 151 dm_message_fn message;
152 dm_ioctl_fn ioctl; 152 dm_ioctl_fn ioctl;
153 dm_merge_fn merge; 153 dm_merge_fn merge;
154 dm_busy_fn busy; 154 dm_busy_fn busy;
155 dm_iterate_devices_fn iterate_devices; 155 dm_iterate_devices_fn iterate_devices;
156 dm_io_hints_fn io_hints; 156 dm_io_hints_fn io_hints;
157 157
158 /* For internal device-mapper use. */ 158 /* For internal device-mapper use. */
159 struct list_head list; 159 struct list_head list;
160 }; 160 };
161 161
162 struct dm_target { 162 struct dm_target {
163 struct dm_table *table; 163 struct dm_table *table;
164 struct target_type *type; 164 struct target_type *type;
165 165
166 /* target limits */ 166 /* target limits */
167 sector_t begin; 167 sector_t begin;
168 sector_t len; 168 sector_t len;
169 169
170 /* Always a power of 2 */ 170 /* Always a power of 2 */
171 sector_t split_io; 171 sector_t split_io;
172 172
173 /* 173 /*
174 * A number of zero-length barrier requests that will be submitted 174 * A number of zero-length barrier requests that will be submitted
175 * to the target for the purpose of flushing cache. 175 * to the target for the purpose of flushing cache.
176 * 176 *
177 * The request number will be placed in union map_info->target_request_nr. 177 * The request number will be placed in union map_info->target_request_nr.
178 * It is a responsibility of the target driver to remap these requests 178 * It is a responsibility of the target driver to remap these requests
179 * to the real underlying devices. 179 * to the real underlying devices.
180 */ 180 */
181 unsigned num_flush_requests; 181 unsigned num_flush_requests;
182 182
183 /* 183 /*
184 * The number of discard requests that will be submitted to the 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. 185 * target. map_info->request_nr is used just like num_flush_requests.
186 */ 186 */
187 unsigned num_discard_requests; 187 unsigned num_discard_requests;
188 188
189 /* target specific data */ 189 /* target specific data */
190 void *private; 190 void *private;
191 191
192 /* Used to provide an error string from the ctr */ 192 /* Used to provide an error string from the ctr */
193 char *error; 193 char *error;
194 }; 194 };
195 195
196 /* Each target can link one of these into the table */ 196 /* Each target can link one of these into the table */
197 struct dm_target_callbacks { 197 struct dm_target_callbacks {
198 struct list_head list; 198 struct list_head list;
199 int (*congested_fn) (struct dm_target_callbacks *, int); 199 int (*congested_fn) (struct dm_target_callbacks *, int);
200 void (*unplug_fn)(struct dm_target_callbacks *);
200 }; 201 };
201 202
202 int dm_register_target(struct target_type *t); 203 int dm_register_target(struct target_type *t);
203 void dm_unregister_target(struct target_type *t); 204 void dm_unregister_target(struct target_type *t);
204 205
205 /*----------------------------------------------------------------- 206 /*-----------------------------------------------------------------
206 * Functions for creating and manipulating mapped devices. 207 * Functions for creating and manipulating mapped devices.
207 * Drop the reference with dm_put when you finish with the object. 208 * Drop the reference with dm_put when you finish with the object.
208 *---------------------------------------------------------------*/ 209 *---------------------------------------------------------------*/
209 210
210 /* 211 /*
211 * DM_ANY_MINOR chooses the next available minor number. 212 * DM_ANY_MINOR chooses the next available minor number.
212 */ 213 */
213 #define DM_ANY_MINOR (-1) 214 #define DM_ANY_MINOR (-1)
214 int dm_create(int minor, struct mapped_device **md); 215 int dm_create(int minor, struct mapped_device **md);
215 216
216 /* 217 /*
217 * Reference counting for md. 218 * Reference counting for md.
218 */ 219 */
219 struct mapped_device *dm_get_md(dev_t dev); 220 struct mapped_device *dm_get_md(dev_t dev);
220 void dm_get(struct mapped_device *md); 221 void dm_get(struct mapped_device *md);
221 void dm_put(struct mapped_device *md); 222 void dm_put(struct mapped_device *md);
222 223
223 /* 224 /*
224 * An arbitrary pointer may be stored alongside a mapped device. 225 * An arbitrary pointer may be stored alongside a mapped device.
225 */ 226 */
226 void dm_set_mdptr(struct mapped_device *md, void *ptr); 227 void dm_set_mdptr(struct mapped_device *md, void *ptr);
227 void *dm_get_mdptr(struct mapped_device *md); 228 void *dm_get_mdptr(struct mapped_device *md);
228 229
229 /* 230 /*
230 * A device can still be used while suspended, but I/O is deferred. 231 * A device can still be used while suspended, but I/O is deferred.
231 */ 232 */
232 int dm_suspend(struct mapped_device *md, unsigned suspend_flags); 233 int dm_suspend(struct mapped_device *md, unsigned suspend_flags);
233 int dm_resume(struct mapped_device *md); 234 int dm_resume(struct mapped_device *md);
234 235
235 /* 236 /*
236 * Event functions. 237 * Event functions.
237 */ 238 */
238 uint32_t dm_get_event_nr(struct mapped_device *md); 239 uint32_t dm_get_event_nr(struct mapped_device *md);
239 int dm_wait_event(struct mapped_device *md, int event_nr); 240 int dm_wait_event(struct mapped_device *md, int event_nr);
240 uint32_t dm_next_uevent_seq(struct mapped_device *md); 241 uint32_t dm_next_uevent_seq(struct mapped_device *md);
241 void dm_uevent_add(struct mapped_device *md, struct list_head *elist); 242 void dm_uevent_add(struct mapped_device *md, struct list_head *elist);
242 243
243 /* 244 /*
244 * Info functions. 245 * Info functions.
245 */ 246 */
246 const char *dm_device_name(struct mapped_device *md); 247 const char *dm_device_name(struct mapped_device *md);
247 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid); 248 int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid);
248 struct gendisk *dm_disk(struct mapped_device *md); 249 struct gendisk *dm_disk(struct mapped_device *md);
249 int dm_suspended(struct dm_target *ti); 250 int dm_suspended(struct dm_target *ti);
250 int dm_noflush_suspending(struct dm_target *ti); 251 int dm_noflush_suspending(struct dm_target *ti);
251 union map_info *dm_get_mapinfo(struct bio *bio); 252 union map_info *dm_get_mapinfo(struct bio *bio);
252 union map_info *dm_get_rq_mapinfo(struct request *rq); 253 union map_info *dm_get_rq_mapinfo(struct request *rq);
253 254
254 /* 255 /*
255 * Geometry functions. 256 * Geometry functions.
256 */ 257 */
257 int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo); 258 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 int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
259 260
260 261
261 /*----------------------------------------------------------------- 262 /*-----------------------------------------------------------------
262 * Functions for manipulating device-mapper tables. 263 * Functions for manipulating device-mapper tables.
263 *---------------------------------------------------------------*/ 264 *---------------------------------------------------------------*/
264 265
265 /* 266 /*
266 * First create an empty table. 267 * First create an empty table.
267 */ 268 */
268 int dm_table_create(struct dm_table **result, fmode_t mode, 269 int dm_table_create(struct dm_table **result, fmode_t mode,
269 unsigned num_targets, struct mapped_device *md); 270 unsigned num_targets, struct mapped_device *md);
270 271
271 /* 272 /*
272 * Then call this once for each target. 273 * Then call this once for each target.
273 */ 274 */
274 int dm_table_add_target(struct dm_table *t, const char *type, 275 int dm_table_add_target(struct dm_table *t, const char *type,
275 sector_t start, sector_t len, char *params); 276 sector_t start, sector_t len, char *params);
276 277
277 /* 278 /*
278 * Target_ctr should call this if it needs to add any callbacks. 279 * Target_ctr should call this if it needs to add any callbacks.
279 */ 280 */
280 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb); 281 void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
281 282
282 /* 283 /*
283 * Finally call this to make the table ready for use. 284 * Finally call this to make the table ready for use.
284 */ 285 */
285 int dm_table_complete(struct dm_table *t); 286 int dm_table_complete(struct dm_table *t);
286 287
287 /* 288 /*
288 * Unplug all devices in a table. 289 * Unplug all devices in a table.
289 */ 290 */
290 void dm_table_unplug_all(struct dm_table *t); 291 void dm_table_unplug_all(struct dm_table *t);
291 292
292 /* 293 /*
293 * Table reference counting. 294 * Table reference counting.
294 */ 295 */
295 struct dm_table *dm_get_live_table(struct mapped_device *md); 296 struct dm_table *dm_get_live_table(struct mapped_device *md);
296 void dm_table_get(struct dm_table *t); 297 void dm_table_get(struct dm_table *t);
297 void dm_table_put(struct dm_table *t); 298 void dm_table_put(struct dm_table *t);
298 299
299 /* 300 /*
300 * Queries 301 * Queries
301 */ 302 */
302 sector_t dm_table_get_size(struct dm_table *t); 303 sector_t dm_table_get_size(struct dm_table *t);
303 unsigned int dm_table_get_num_targets(struct dm_table *t); 304 unsigned int dm_table_get_num_targets(struct dm_table *t);
304 fmode_t dm_table_get_mode(struct dm_table *t); 305 fmode_t dm_table_get_mode(struct dm_table *t);
305 struct mapped_device *dm_table_get_md(struct dm_table *t); 306 struct mapped_device *dm_table_get_md(struct dm_table *t);
306 307
307 /* 308 /*
308 * Trigger an event. 309 * Trigger an event.
309 */ 310 */
310 void dm_table_event(struct dm_table *t); 311 void dm_table_event(struct dm_table *t);
311 312
312 /* 313 /*
313 * The device must be suspended before calling this method. 314 * The device must be suspended before calling this method.
314 * Returns the previous table, which the caller must destroy. 315 * Returns the previous table, which the caller must destroy.
315 */ 316 */
316 struct dm_table *dm_swap_table(struct mapped_device *md, 317 struct dm_table *dm_swap_table(struct mapped_device *md,
317 struct dm_table *t); 318 struct dm_table *t);
318 319
319 /* 320 /*
320 * A wrapper around vmalloc. 321 * A wrapper around vmalloc.
321 */ 322 */
322 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size); 323 void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
323 324
324 /*----------------------------------------------------------------- 325 /*-----------------------------------------------------------------
325 * Macros. 326 * Macros.
326 *---------------------------------------------------------------*/ 327 *---------------------------------------------------------------*/
327 #define DM_NAME "device-mapper" 328 #define DM_NAME "device-mapper"
328 329
329 #define DMCRIT(f, arg...) \ 330 #define DMCRIT(f, arg...) \
330 printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) 331 printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
331 332
332 #define DMERR(f, arg...) \ 333 #define DMERR(f, arg...) \
333 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) 334 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
334 #define DMERR_LIMIT(f, arg...) \ 335 #define DMERR_LIMIT(f, arg...) \
335 do { \ 336 do { \
336 if (printk_ratelimit()) \ 337 if (printk_ratelimit()) \
337 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \ 338 printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
338 f "\n", ## arg); \ 339 f "\n", ## arg); \
339 } while (0) 340 } while (0)
340 341
341 #define DMWARN(f, arg...) \ 342 #define DMWARN(f, arg...) \
342 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) 343 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
343 #define DMWARN_LIMIT(f, arg...) \ 344 #define DMWARN_LIMIT(f, arg...) \
344 do { \ 345 do { \
345 if (printk_ratelimit()) \ 346 if (printk_ratelimit()) \
346 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \ 347 printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
347 f "\n", ## arg); \ 348 f "\n", ## arg); \
348 } while (0) 349 } while (0)
349 350
350 #define DMINFO(f, arg...) \ 351 #define DMINFO(f, arg...) \
351 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg) 352 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
352 #define DMINFO_LIMIT(f, arg...) \ 353 #define DMINFO_LIMIT(f, arg...) \
353 do { \ 354 do { \
354 if (printk_ratelimit()) \ 355 if (printk_ratelimit()) \
355 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \ 356 printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
356 "\n", ## arg); \ 357 "\n", ## arg); \
357 } while (0) 358 } while (0)
358 359
359 #ifdef CONFIG_DM_DEBUG 360 #ifdef CONFIG_DM_DEBUG
360 # define DMDEBUG(f, arg...) \ 361 # define DMDEBUG(f, arg...) \
361 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg) 362 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
362 # define DMDEBUG_LIMIT(f, arg...) \ 363 # define DMDEBUG_LIMIT(f, arg...) \
363 do { \ 364 do { \
364 if (printk_ratelimit()) \ 365 if (printk_ratelimit()) \
365 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \ 366 printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
366 "\n", ## arg); \ 367 "\n", ## arg); \
367 } while (0) 368 } while (0)
368 #else 369 #else
369 # define DMDEBUG(f, arg...) do {} while (0) 370 # define DMDEBUG(f, arg...) do {} while (0)
370 # define DMDEBUG_LIMIT(f, arg...) do {} while (0) 371 # define DMDEBUG_LIMIT(f, arg...) do {} while (0)
371 #endif 372 #endif
372 373
373 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \ 374 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
374 0 : scnprintf(result + sz, maxlen - sz, x)) 375 0 : scnprintf(result + sz, maxlen - sz, x))
375 376
376 #define SECTOR_SHIFT 9 377 #define SECTOR_SHIFT 9
377 378
378 /* 379 /*
379 * Definitions of return values from target end_io function. 380 * Definitions of return values from target end_io function.
380 */ 381 */
381 #define DM_ENDIO_INCOMPLETE 1 382 #define DM_ENDIO_INCOMPLETE 1
382 #define DM_ENDIO_REQUEUE 2 383 #define DM_ENDIO_REQUEUE 2
383 384
384 /* 385 /*
385 * Definitions of return values from target map function. 386 * Definitions of return values from target map function.
386 */ 387 */
387 #define DM_MAPIO_SUBMITTED 0 388 #define DM_MAPIO_SUBMITTED 0
388 #define DM_MAPIO_REMAPPED 1 389 #define DM_MAPIO_REMAPPED 1
389 #define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE 390 #define DM_MAPIO_REQUEUE DM_ENDIO_REQUEUE
390 391
391 /* 392 /*
392 * Ceiling(n / sz) 393 * Ceiling(n / sz)
393 */ 394 */
394 #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz)) 395 #define dm_div_up(n, sz) (((n) + (sz) - 1) / (sz))
395 396
396 #define dm_sector_div_up(n, sz) ( \ 397 #define dm_sector_div_up(n, sz) ( \
397 { \ 398 { \
398 sector_t _r = ((n) + (sz) - 1); \ 399 sector_t _r = ((n) + (sz) - 1); \
399 sector_div(_r, (sz)); \ 400 sector_div(_r, (sz)); \
400 _r; \ 401 _r; \
401 } \ 402 } \
402 ) 403 )
403 404
404 /* 405 /*
405 * ceiling(n / size) * size 406 * ceiling(n / size) * size
406 */ 407 */
407 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz)) 408 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
408 409
409 #define dm_array_too_big(fixed, obj, num) \ 410 #define dm_array_too_big(fixed, obj, num) \
410 ((num) > (UINT_MAX - (fixed)) / (obj)) 411 ((num) > (UINT_MAX - (fixed)) / (obj))
411 412
412 /* 413 /*
413 * Sector offset taken relative to the start of the target instead of 414 * Sector offset taken relative to the start of the target instead of
414 * relative to the start of the device. 415 * relative to the start of the device.
415 */ 416 */
416 #define dm_target_offset(ti, sector) ((sector) - (ti)->begin) 417 #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
417 418
418 static inline sector_t to_sector(unsigned long n) 419 static inline sector_t to_sector(unsigned long n)
419 { 420 {
420 return (n >> SECTOR_SHIFT); 421 return (n >> SECTOR_SHIFT);
421 } 422 }
422 423
423 static inline unsigned long to_bytes(sector_t n) 424 static inline unsigned long to_bytes(sector_t n)
424 { 425 {
425 return (n << SECTOR_SHIFT); 426 return (n << SECTOR_SHIFT);
426 } 427 }
427 428
428 /*----------------------------------------------------------------- 429 /*-----------------------------------------------------------------
429 * Helper for block layer and dm core operations 430 * Helper for block layer and dm core operations
430 *---------------------------------------------------------------*/ 431 *---------------------------------------------------------------*/
431 void dm_dispatch_request(struct request *rq); 432 void dm_dispatch_request(struct request *rq);
432 void dm_requeue_unmapped_request(struct request *rq); 433 void dm_requeue_unmapped_request(struct request *rq);
433 void dm_kill_unmapped_request(struct request *rq, int error); 434 void dm_kill_unmapped_request(struct request *rq, int error);
434 int dm_underlying_device_busy(struct request_queue *q); 435 int dm_underlying_device_busy(struct request_queue *q);
435 436
436 #endif /* _LINUX_DEVICE_MAPPER_H */ 437 #endif /* _LINUX_DEVICE_MAPPER_H */
437 438