blob: 10f457ca6af2568ab9073f8a7ab7477a0f946a94 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2003 Sistina Software
Heinz Mauelshagen891ce202007-05-09 02:33:00 -07003 * Copyright (C) 2006 Red Hat GmbH
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This file is released under the GPL.
6 */
7
Mikulas Patocka952b3552009-12-10 23:51:57 +00008#include "dm.h"
9
Mikulas Patocka586e80e2008-10-21 17:44:59 +010010#include <linux/device-mapper.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
12#include <linux/bio.h>
13#include <linux/mempool.h>
14#include <linux/module.h>
15#include <linux/sched.h>
16#include <linux/slab.h>
Alasdair G Kergona765e202008-04-24 22:02:01 +010017#include <linux/dm-io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Mikulas Patockaf1e53982009-12-10 23:51:58 +000019#define DM_MSG_PREFIX "io"
20
21#define DM_IO_MAX_REGIONS BITS_PER_LONG
22
Heinz Mauelshagen891ce202007-05-09 02:33:00 -070023struct dm_io_client {
24 mempool_t *pool;
25 struct bio_set *bios;
26};
27
Mikulas Patockaf1e53982009-12-10 23:51:58 +000028/*
29 * Aligning 'struct io' reduces the number of bits required to store
30 * its address. Refer to store_io_and_region_in_bio() below.
31 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070032struct io {
Alasdair G Kergone01fd7e2008-04-24 21:43:14 +010033 unsigned long error_bits;
Mikulas Patocka5af443a2009-06-22 10:12:25 +010034 unsigned long eopnotsupp_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 atomic_t count;
36 struct task_struct *sleeper;
Heinz Mauelshagen891ce202007-05-09 02:33:00 -070037 struct dm_io_client *client;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 io_notify_fn callback;
39 void *context;
Mikulas Patockaf1e53982009-12-10 23:51:58 +000040} __attribute__((aligned(DM_IO_MAX_REGIONS)));
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Mikulas Patocka952b3552009-12-10 23:51:57 +000042static struct kmem_cache *_dm_io_cache;
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044/*
45 * io contexts are only dynamically allocated for asynchronous
46 * io. Since async io is likely to be the majority of io we'll
Heinz Mauelshagen891ce202007-05-09 02:33:00 -070047 * have the same number of io contexts as bios! (FIXME: must reduce this).
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 */
Heinz Mauelshagen891ce202007-05-09 02:33:00 -070049
Linus Torvalds1da177e2005-04-16 15:20:36 -070050static unsigned int pages_to_ios(unsigned int pages)
51{
52 return 4 * pages; /* too many ? */
53}
54
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -070055/*
56 * Create a client with mempool and bioset.
57 */
58struct dm_io_client *dm_io_client_create(unsigned num_pages)
59{
60 unsigned ios = pages_to_ios(num_pages);
61 struct dm_io_client *client;
62
63 client = kmalloc(sizeof(*client), GFP_KERNEL);
64 if (!client)
65 return ERR_PTR(-ENOMEM);
66
Mikulas Patocka952b3552009-12-10 23:51:57 +000067 client->pool = mempool_create_slab_pool(ios, _dm_io_cache);
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -070068 if (!client->pool)
69 goto bad;
70
Jens Axboebb799ca2008-12-10 15:35:05 +010071 client->bios = bioset_create(16, 0);
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -070072 if (!client->bios)
73 goto bad;
74
75 return client;
76
77 bad:
78 if (client->pool)
79 mempool_destroy(client->pool);
80 kfree(client);
81 return ERR_PTR(-ENOMEM);
82}
83EXPORT_SYMBOL(dm_io_client_create);
84
85int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client)
86{
87 return mempool_resize(client->pool, pages_to_ios(num_pages),
88 GFP_KERNEL);
89}
90EXPORT_SYMBOL(dm_io_client_resize);
91
92void dm_io_client_destroy(struct dm_io_client *client)
93{
94 mempool_destroy(client->pool);
95 bioset_free(client->bios);
96 kfree(client);
97}
98EXPORT_SYMBOL(dm_io_client_destroy);
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100/*-----------------------------------------------------------------
101 * We need to keep track of which region a bio is doing io for.
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000102 * To avoid a memory allocation to store just 5 or 6 bits, we
103 * ensure the 'struct io' pointer is aligned so enough low bits are
104 * always zero and then combine it with the region number directly in
105 * bi_private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 *---------------------------------------------------------------*/
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000107static void store_io_and_region_in_bio(struct bio *bio, struct io *io,
108 unsigned region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000110 if (unlikely(!IS_ALIGNED((unsigned long)io, DM_IO_MAX_REGIONS))) {
111 DMCRIT("Unaligned struct io pointer %p", io);
112 BUG();
113 }
114
115 bio->bi_private = (void *)((unsigned long)io | region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000118static void retrieve_io_and_region_from_bio(struct bio *bio, struct io **io,
119 unsigned *region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000121 unsigned long val = (unsigned long)bio->bi_private;
122
123 *io = (void *)(val & -(unsigned long)DM_IO_MAX_REGIONS);
124 *region = val & (DM_IO_MAX_REGIONS - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125}
126
127/*-----------------------------------------------------------------
128 * We need an io object to keep track of the number of bios that
129 * have been dispatched for a particular io.
130 *---------------------------------------------------------------*/
131static void dec_count(struct io *io, unsigned int region, int error)
132{
Mikulas Patocka5af443a2009-06-22 10:12:25 +0100133 if (error) {
Alasdair G Kergone01fd7e2008-04-24 21:43:14 +0100134 set_bit(region, &io->error_bits);
Mikulas Patocka5af443a2009-06-22 10:12:25 +0100135 if (error == -EOPNOTSUPP)
136 set_bit(region, &io->eopnotsupp_bits);
137 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 if (atomic_dec_and_test(&io->count)) {
140 if (io->sleeper)
141 wake_up_process(io->sleeper);
142
143 else {
Alasdair G Kergone01fd7e2008-04-24 21:43:14 +0100144 unsigned long r = io->error_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 io_notify_fn fn = io->callback;
146 void *context = io->context;
147
Milan Brozbf17ce32007-05-09 02:33:05 -0700148 mempool_free(io, io->client->pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 fn(r, context);
150 }
151 }
152}
153
NeilBrown6712ecf2007-09-27 12:47:43 +0200154static void endio(struct bio *bio, int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Heinz Mauelshagenc897feb2007-05-09 02:33:00 -0700156 struct io *io;
157 unsigned region;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if (error && bio_data_dir(bio) == READ)
160 zero_fill_bio(bio);
161
Heinz Mauelshagenc897feb2007-05-09 02:33:00 -0700162 /*
163 * The bio destructor in bio_put() may use the io object.
164 */
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000165 retrieve_io_and_region_from_bio(bio, &io, &region);
Heinz Mauelshagenc897feb2007-05-09 02:33:00 -0700166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 bio_put(bio);
168
Heinz Mauelshagenc897feb2007-05-09 02:33:00 -0700169 dec_count(io, region, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170}
171
172/*-----------------------------------------------------------------
173 * These little objects provide an abstraction for getting a new
174 * destination page for io.
175 *---------------------------------------------------------------*/
176struct dpages {
177 void (*get_page)(struct dpages *dp,
178 struct page **p, unsigned long *len, unsigned *offset);
179 void (*next_page)(struct dpages *dp);
180
181 unsigned context_u;
182 void *context_ptr;
183};
184
185/*
186 * Functions for getting the pages from a list.
187 */
188static void list_get_page(struct dpages *dp,
189 struct page **p, unsigned long *len, unsigned *offset)
190{
191 unsigned o = dp->context_u;
192 struct page_list *pl = (struct page_list *) dp->context_ptr;
193
194 *p = pl->page;
195 *len = PAGE_SIZE - o;
196 *offset = o;
197}
198
199static void list_next_page(struct dpages *dp)
200{
201 struct page_list *pl = (struct page_list *) dp->context_ptr;
202 dp->context_ptr = pl->next;
203 dp->context_u = 0;
204}
205
206static void list_dp_init(struct dpages *dp, struct page_list *pl, unsigned offset)
207{
208 dp->get_page = list_get_page;
209 dp->next_page = list_next_page;
210 dp->context_u = offset;
211 dp->context_ptr = pl;
212}
213
214/*
215 * Functions for getting the pages from a bvec.
216 */
217static void bvec_get_page(struct dpages *dp,
218 struct page **p, unsigned long *len, unsigned *offset)
219{
220 struct bio_vec *bvec = (struct bio_vec *) dp->context_ptr;
221 *p = bvec->bv_page;
222 *len = bvec->bv_len;
223 *offset = bvec->bv_offset;
224}
225
226static void bvec_next_page(struct dpages *dp)
227{
228 struct bio_vec *bvec = (struct bio_vec *) dp->context_ptr;
229 dp->context_ptr = bvec + 1;
230}
231
232static void bvec_dp_init(struct dpages *dp, struct bio_vec *bvec)
233{
234 dp->get_page = bvec_get_page;
235 dp->next_page = bvec_next_page;
236 dp->context_ptr = bvec;
237}
238
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -0700239/*
240 * Functions for getting the pages from a VMA.
241 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242static void vm_get_page(struct dpages *dp,
243 struct page **p, unsigned long *len, unsigned *offset)
244{
245 *p = vmalloc_to_page(dp->context_ptr);
246 *offset = dp->context_u;
247 *len = PAGE_SIZE - dp->context_u;
248}
249
250static void vm_next_page(struct dpages *dp)
251{
252 dp->context_ptr += PAGE_SIZE - dp->context_u;
253 dp->context_u = 0;
254}
255
256static void vm_dp_init(struct dpages *dp, void *data)
257{
258 dp->get_page = vm_get_page;
259 dp->next_page = vm_next_page;
260 dp->context_u = ((unsigned long) data) & (PAGE_SIZE - 1);
261 dp->context_ptr = data;
262}
263
Peter Osterlund36763472005-09-06 15:16:42 -0700264static void dm_bio_destructor(struct bio *bio)
265{
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000266 unsigned region;
267 struct io *io;
268
269 retrieve_io_and_region_from_bio(bio, &io, &region);
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700270
Milan Brozbf17ce32007-05-09 02:33:05 -0700271 bio_free(bio, io->client->bios);
Peter Osterlund36763472005-09-06 15:16:42 -0700272}
273
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -0700274/*
275 * Functions for getting the pages from kernel memory.
276 */
277static void km_get_page(struct dpages *dp, struct page **p, unsigned long *len,
278 unsigned *offset)
279{
280 *p = virt_to_page(dp->context_ptr);
281 *offset = dp->context_u;
282 *len = PAGE_SIZE - dp->context_u;
283}
284
285static void km_next_page(struct dpages *dp)
286{
287 dp->context_ptr += PAGE_SIZE - dp->context_u;
288 dp->context_u = 0;
289}
290
291static void km_dp_init(struct dpages *dp, void *data)
292{
293 dp->get_page = km_get_page;
294 dp->next_page = km_next_page;
295 dp->context_u = ((unsigned long) data) & (PAGE_SIZE - 1);
296 dp->context_ptr = data;
297}
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299/*-----------------------------------------------------------------
300 * IO routines that accept a list of pages.
301 *---------------------------------------------------------------*/
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100302static void do_region(int rw, unsigned region, struct dm_io_region *where,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 struct dpages *dp, struct io *io)
304{
305 struct bio *bio;
306 struct page *page;
307 unsigned long len;
308 unsigned offset;
309 unsigned num_bvecs;
310 sector_t remaining = where->count;
311
Mikulas Patocka12fc0f42009-12-10 23:52:22 +0000312 /*
313 * where->count may be zero if rw holds a write barrier and we
314 * need to send a zero-sized barrier.
315 */
316 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 /*
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000318 * Allocate a suitably sized-bio.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 */
Jun'ichi Nomura596f1382007-07-12 17:27:45 +0100320 num_bvecs = dm_sector_div_up(remaining,
321 (PAGE_SIZE >> SECTOR_SHIFT));
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000322 num_bvecs = min_t(int, bio_get_nr_vecs(where->bdev), num_bvecs);
Milan Brozbf17ce32007-05-09 02:33:05 -0700323 bio = bio_alloc_bioset(GFP_NOIO, num_bvecs, io->client->bios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 bio->bi_sector = where->sector + (where->count - remaining);
325 bio->bi_bdev = where->bdev;
326 bio->bi_end_io = endio;
Peter Osterlund36763472005-09-06 15:16:42 -0700327 bio->bi_destructor = dm_bio_destructor;
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000328 store_io_and_region_in_bio(bio, io, region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 /*
331 * Try and add as many pages as possible.
332 */
333 while (remaining) {
334 dp->get_page(dp, &page, &len, &offset);
335 len = min(len, to_bytes(remaining));
336 if (!bio_add_page(bio, page, len, offset))
337 break;
338
339 offset = 0;
340 remaining -= to_sector(len);
341 dp->next_page(dp);
342 }
343
344 atomic_inc(&io->count);
345 submit_bio(rw, bio);
Mikulas Patocka12fc0f42009-12-10 23:52:22 +0000346 } while (remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347}
348
349static void dispatch_io(int rw, unsigned int num_regions,
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100350 struct dm_io_region *where, struct dpages *dp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 struct io *io, int sync)
352{
353 int i;
354 struct dpages old_pages = *dp;
355
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000356 BUG_ON(num_regions > DM_IO_MAX_REGIONS);
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (sync)
Jens Axboe93dbb392009-02-16 10:25:40 +0100359 rw |= (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 /*
362 * For multiple regions we need to be careful to rewind
363 * the dp object for each call to do_region.
364 */
365 for (i = 0; i < num_regions; i++) {
366 *dp = old_pages;
Mikulas Patocka12fc0f42009-12-10 23:52:22 +0000367 if (where[i].count || (rw & (1 << BIO_RW_BARRIER)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 do_region(rw, i, where + i, dp, io);
369 }
370
371 /*
Heinz Mauelshagenf00b16a2006-12-08 02:41:01 -0800372 * Drop the extra reference that we were holding to avoid
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 * the io being completed too early.
374 */
375 dec_count(io, 0, 0);
376}
377
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700378static int sync_io(struct dm_io_client *client, unsigned int num_regions,
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100379 struct dm_io_region *where, int rw, struct dpages *dp,
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700380 unsigned long *error_bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000382 /*
383 * gcc <= 4.3 can't do the alignment for stack variables, so we must
384 * align it on our own.
385 * volatile prevents the optimizer from removing or reusing
386 * "io_" field from the stack frame (allowed in ANSI C).
387 */
388 volatile char io_[sizeof(struct io) + __alignof__(struct io) - 1];
389 struct io *io = (struct io *)PTR_ALIGN(&io_, __alignof__(struct io));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
Mikulas Patocka7ff14a32008-04-24 22:10:47 +0100391 if (num_regions > 1 && (rw & RW_MASK) != WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 WARN_ON(1);
393 return -EIO;
394 }
395
Mikulas Patocka51aa3222009-06-22 10:12:26 +0100396retry:
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000397 io->error_bits = 0;
398 io->eopnotsupp_bits = 0;
399 atomic_set(&io->count, 1); /* see dispatch_io() */
400 io->sleeper = current;
401 io->client = client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000403 dispatch_io(rw, num_regions, where, dp, io, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 while (1) {
406 set_current_state(TASK_UNINTERRUPTIBLE);
407
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000408 if (!atomic_read(&io->count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 break;
410
411 io_schedule();
412 }
413 set_current_state(TASK_RUNNING);
414
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000415 if (io->eopnotsupp_bits && (rw & (1 << BIO_RW_BARRIER))) {
Mikulas Patocka51aa3222009-06-22 10:12:26 +0100416 rw &= ~(1 << BIO_RW_BARRIER);
417 goto retry;
418 }
419
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700420 if (error_bits)
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000421 *error_bits = io->error_bits;
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700422
Mikulas Patockaf1e53982009-12-10 23:51:58 +0000423 return io->error_bits ? -EIO : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424}
425
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700426static int async_io(struct dm_io_client *client, unsigned int num_regions,
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100427 struct dm_io_region *where, int rw, struct dpages *dp,
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700428 io_notify_fn fn, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
430 struct io *io;
431
Mikulas Patocka7ff14a32008-04-24 22:10:47 +0100432 if (num_regions > 1 && (rw & RW_MASK) != WRITE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 WARN_ON(1);
434 fn(1, context);
435 return -EIO;
436 }
437
Milan Brozbf17ce32007-05-09 02:33:05 -0700438 io = mempool_alloc(client->pool, GFP_NOIO);
Alasdair G Kergone01fd7e2008-04-24 21:43:14 +0100439 io->error_bits = 0;
Mikulas Patocka5af443a2009-06-22 10:12:25 +0100440 io->eopnotsupp_bits = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 atomic_set(&io->count, 1); /* see dispatch_io() */
442 io->sleeper = NULL;
Heinz Mauelshagen891ce202007-05-09 02:33:00 -0700443 io->client = client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 io->callback = fn;
445 io->context = context;
446
447 dispatch_io(rw, num_regions, where, dp, io, 0);
448 return 0;
449}
450
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -0700451static int dp_init(struct dm_io_request *io_req, struct dpages *dp)
452{
453 /* Set up dpages based on memory type */
454 switch (io_req->mem.type) {
455 case DM_IO_PAGE_LIST:
456 list_dp_init(dp, io_req->mem.ptr.pl, io_req->mem.offset);
457 break;
458
459 case DM_IO_BVEC:
460 bvec_dp_init(dp, io_req->mem.ptr.bvec);
461 break;
462
463 case DM_IO_VMA:
464 vm_dp_init(dp, io_req->mem.ptr.vma);
465 break;
466
467 case DM_IO_KMEM:
468 km_dp_init(dp, io_req->mem.ptr.addr);
469 break;
470
471 default:
472 return -EINVAL;
473 }
474
475 return 0;
476}
477
478/*
Mikulas Patocka7ff14a32008-04-24 22:10:47 +0100479 * New collapsed (a)synchronous interface.
480 *
481 * If the IO is asynchronous (i.e. it has notify.fn), you must either unplug
482 * the queue with blk_unplug() some time later or set the BIO_RW_SYNC bit in
483 * io_req->bi_rw. If you fail to do one of these, the IO will be submitted to
484 * the disk after q->unplug_delay, which defaults to 3ms in blk-settings.c.
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -0700485 */
486int dm_io(struct dm_io_request *io_req, unsigned num_regions,
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100487 struct dm_io_region *where, unsigned long *sync_error_bits)
Heinz Mauelshagenc8b03af2007-05-09 02:33:01 -0700488{
489 int r;
490 struct dpages dp;
491
492 r = dp_init(io_req, &dp);
493 if (r)
494 return r;
495
496 if (!io_req->notify.fn)
497 return sync_io(io_req->client, num_regions, where,
498 io_req->bi_rw, &dp, sync_error_bits);
499
500 return async_io(io_req->client, num_regions, where, io_req->bi_rw,
501 &dp, io_req->notify.fn, io_req->notify.context);
502}
503EXPORT_SYMBOL(dm_io);
Mikulas Patocka952b3552009-12-10 23:51:57 +0000504
505int __init dm_io_init(void)
506{
507 _dm_io_cache = KMEM_CACHE(io, 0);
508 if (!_dm_io_cache)
509 return -ENOMEM;
510
511 return 0;
512}
513
514void dm_io_exit(void)
515{
516 kmem_cache_destroy(_dm_io_cache);
517 _dm_io_cache = NULL;
518}