diff options
Diffstat (limited to 'drivers/md/dm-kcopyd.c')
-rw-r--r-- | drivers/md/dm-kcopyd.c | 654 |
1 files changed, 654 insertions, 0 deletions
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c new file mode 100644 index 000000000000..17345844b03e --- /dev/null +++ b/drivers/md/dm-kcopyd.c | |||
@@ -0,0 +1,654 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2002 Sistina Software (UK) Limited. | ||
3 | * Copyright (C) 2006 Red Hat GmbH | ||
4 | * | ||
5 | * This file is released under the GPL. | ||
6 | * | ||
7 | * Kcopyd provides a simple interface for copying an area of one | ||
8 | * block-device to one or more other block-devices, with an asynchronous | ||
9 | * completion notification. | ||
10 | */ | ||
11 | |||
12 | #include <linux/types.h> | ||
13 | #include <asm/atomic.h> | ||
14 | #include <linux/blkdev.h> | ||
15 | #include <linux/fs.h> | ||
16 | #include <linux/init.h> | ||
17 | #include <linux/list.h> | ||
18 | #include <linux/mempool.h> | ||
19 | #include <linux/module.h> | ||
20 | #include <linux/pagemap.h> | ||
21 | #include <linux/slab.h> | ||
22 | #include <linux/vmalloc.h> | ||
23 | #include <linux/workqueue.h> | ||
24 | #include <linux/mutex.h> | ||
25 | |||
26 | #include "kcopyd.h" | ||
27 | #include "dm.h" | ||
28 | |||
29 | /*----------------------------------------------------------------- | ||
30 | * Each kcopyd client has its own little pool of preallocated | ||
31 | * pages for kcopyd io. | ||
32 | *---------------------------------------------------------------*/ | ||
33 | struct dm_kcopyd_client { | ||
34 | spinlock_t lock; | ||
35 | struct page_list *pages; | ||
36 | unsigned int nr_pages; | ||
37 | unsigned int nr_free_pages; | ||
38 | |||
39 | struct dm_io_client *io_client; | ||
40 | |||
41 | wait_queue_head_t destroyq; | ||
42 | atomic_t nr_jobs; | ||
43 | |||
44 | mempool_t *job_pool; | ||
45 | |||
46 | struct workqueue_struct *kcopyd_wq; | ||
47 | struct work_struct kcopyd_work; | ||
48 | |||
49 | /* | ||
50 | * We maintain three lists of jobs: | ||
51 | * | ||
52 | * i) jobs waiting for pages | ||
53 | * ii) jobs that have pages, and are waiting for the io to be issued. | ||
54 | * iii) jobs that have completed. | ||
55 | * | ||
56 | * All three of these are protected by job_lock. | ||
57 | */ | ||
58 | spinlock_t job_lock; | ||
59 | struct list_head complete_jobs; | ||
60 | struct list_head io_jobs; | ||
61 | struct list_head pages_jobs; | ||
62 | }; | ||
63 | |||
64 | static void wake(struct dm_kcopyd_client *kc) | ||
65 | { | ||
66 | queue_work(kc->kcopyd_wq, &kc->kcopyd_work); | ||
67 | } | ||
68 | |||
69 | static struct page_list *alloc_pl(void) | ||
70 | { | ||
71 | struct page_list *pl; | ||
72 | |||
73 | pl = kmalloc(sizeof(*pl), GFP_KERNEL); | ||
74 | if (!pl) | ||
75 | return NULL; | ||
76 | |||
77 | pl->page = alloc_page(GFP_KERNEL); | ||
78 | if (!pl->page) { | ||
79 | kfree(pl); | ||
80 | return NULL; | ||
81 | } | ||
82 | |||
83 | return pl; | ||
84 | } | ||
85 | |||
86 | static void free_pl(struct page_list *pl) | ||
87 | { | ||
88 | __free_page(pl->page); | ||
89 | kfree(pl); | ||
90 | } | ||
91 | |||
92 | static int kcopyd_get_pages(struct dm_kcopyd_client *kc, | ||
93 | unsigned int nr, struct page_list **pages) | ||
94 | { | ||
95 | struct page_list *pl; | ||
96 | |||
97 | spin_lock(&kc->lock); | ||
98 | if (kc->nr_free_pages < nr) { | ||
99 | spin_unlock(&kc->lock); | ||
100 | return -ENOMEM; | ||
101 | } | ||
102 | |||
103 | kc->nr_free_pages -= nr; | ||
104 | for (*pages = pl = kc->pages; --nr; pl = pl->next) | ||
105 | ; | ||
106 | |||
107 | kc->pages = pl->next; | ||
108 | pl->next = NULL; | ||
109 | |||
110 | spin_unlock(&kc->lock); | ||
111 | |||
112 | return 0; | ||
113 | } | ||
114 | |||
115 | static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl) | ||
116 | { | ||
117 | struct page_list *cursor; | ||
118 | |||
119 | spin_lock(&kc->lock); | ||
120 | for (cursor = pl; cursor->next; cursor = cursor->next) | ||
121 | kc->nr_free_pages++; | ||
122 | |||
123 | kc->nr_free_pages++; | ||
124 | cursor->next = kc->pages; | ||
125 | kc->pages = pl; | ||
126 | spin_unlock(&kc->lock); | ||
127 | } | ||
128 | |||
129 | /* | ||
130 | * These three functions resize the page pool. | ||
131 | */ | ||
132 | static void drop_pages(struct page_list *pl) | ||
133 | { | ||
134 | struct page_list *next; | ||
135 | |||
136 | while (pl) { | ||
137 | next = pl->next; | ||
138 | free_pl(pl); | ||
139 | pl = next; | ||
140 | } | ||
141 | } | ||
142 | |||
143 | static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr) | ||
144 | { | ||
145 | unsigned int i; | ||
146 | struct page_list *pl = NULL, *next; | ||
147 | |||
148 | for (i = 0; i < nr; i++) { | ||
149 | next = alloc_pl(); | ||
150 | if (!next) { | ||
151 | if (pl) | ||
152 | drop_pages(pl); | ||
153 | return -ENOMEM; | ||
154 | } | ||
155 | next->next = pl; | ||
156 | pl = next; | ||
157 | } | ||
158 | |||
159 | kcopyd_put_pages(kc, pl); | ||
160 | kc->nr_pages += nr; | ||
161 | return 0; | ||
162 | } | ||
163 | |||
164 | static void client_free_pages(struct dm_kcopyd_client *kc) | ||
165 | { | ||
166 | BUG_ON(kc->nr_free_pages != kc->nr_pages); | ||
167 | drop_pages(kc->pages); | ||
168 | kc->pages = NULL; | ||
169 | kc->nr_free_pages = kc->nr_pages = 0; | ||
170 | } | ||
171 | |||
172 | /*----------------------------------------------------------------- | ||
173 | * kcopyd_jobs need to be allocated by the *clients* of kcopyd, | ||
174 | * for this reason we use a mempool to prevent the client from | ||
175 | * ever having to do io (which could cause a deadlock). | ||
176 | *---------------------------------------------------------------*/ | ||
177 | struct kcopyd_job { | ||
178 | struct dm_kcopyd_client *kc; | ||
179 | struct list_head list; | ||
180 | unsigned long flags; | ||
181 | |||
182 | /* | ||
183 | * Error state of the job. | ||
184 | */ | ||
185 | int read_err; | ||
186 | unsigned long write_err; | ||
187 | |||
188 | /* | ||
189 | * Either READ or WRITE | ||
190 | */ | ||
191 | int rw; | ||
192 | struct dm_io_region source; | ||
193 | |||
194 | /* | ||
195 | * The destinations for the transfer. | ||
196 | */ | ||
197 | unsigned int num_dests; | ||
198 | struct dm_io_region dests[DM_KCOPYD_MAX_REGIONS]; | ||
199 | |||
200 | sector_t offset; | ||
201 | unsigned int nr_pages; | ||
202 | struct page_list *pages; | ||
203 | |||
204 | /* | ||
205 | * Set this to ensure you are notified when the job has | ||
206 | * completed. 'context' is for callback to use. | ||
207 | */ | ||
208 | dm_kcopyd_notify_fn fn; | ||
209 | void *context; | ||
210 | |||
211 | /* | ||
212 | * These fields are only used if the job has been split | ||
213 | * into more manageable parts. | ||
214 | */ | ||
215 | struct mutex lock; | ||
216 | atomic_t sub_jobs; | ||
217 | sector_t progress; | ||
218 | }; | ||
219 | |||
220 | /* FIXME: this should scale with the number of pages */ | ||
221 | #define MIN_JOBS 512 | ||
222 | |||
223 | static struct kmem_cache *_job_cache; | ||
224 | |||
225 | int __init dm_kcopyd_init(void) | ||
226 | { | ||
227 | _job_cache = KMEM_CACHE(kcopyd_job, 0); | ||
228 | if (!_job_cache) | ||
229 | return -ENOMEM; | ||
230 | |||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | void dm_kcopyd_exit(void) | ||
235 | { | ||
236 | kmem_cache_destroy(_job_cache); | ||
237 | _job_cache = NULL; | ||
238 | } | ||
239 | |||
240 | /* | ||
241 | * Functions to push and pop a job onto the head of a given job | ||
242 | * list. | ||
243 | */ | ||
244 | static struct kcopyd_job *pop(struct list_head *jobs, | ||
245 | struct dm_kcopyd_client *kc) | ||
246 | { | ||
247 | struct kcopyd_job *job = NULL; | ||
248 | unsigned long flags; | ||
249 | |||
250 | spin_lock_irqsave(&kc->job_lock, flags); | ||
251 | |||
252 | if (!list_empty(jobs)) { | ||
253 | job = list_entry(jobs->next, struct kcopyd_job, list); | ||
254 | list_del(&job->list); | ||
255 | } | ||
256 | spin_unlock_irqrestore(&kc->job_lock, flags); | ||
257 | |||
258 | return job; | ||
259 | } | ||
260 | |||
261 | static void push(struct list_head *jobs, struct kcopyd_job *job) | ||
262 | { | ||
263 | unsigned long flags; | ||
264 | struct dm_kcopyd_client *kc = job->kc; | ||
265 | |||
266 | spin_lock_irqsave(&kc->job_lock, flags); | ||
267 | list_add_tail(&job->list, jobs); | ||
268 | spin_unlock_irqrestore(&kc->job_lock, flags); | ||
269 | } | ||
270 | |||
271 | /* | ||
272 | * These three functions process 1 item from the corresponding | ||
273 | * job list. | ||
274 | * | ||
275 | * They return: | ||
276 | * < 0: error | ||
277 | * 0: success | ||
278 | * > 0: can't process yet. | ||
279 | */ | ||
280 | static int run_complete_job(struct kcopyd_job *job) | ||
281 | { | ||
282 | void *context = job->context; | ||
283 | int read_err = job->read_err; | ||
284 | unsigned long write_err = job->write_err; | ||
285 | dm_kcopyd_notify_fn fn = job->fn; | ||
286 | struct dm_kcopyd_client *kc = job->kc; | ||
287 | |||
288 | kcopyd_put_pages(kc, job->pages); | ||
289 | mempool_free(job, kc->job_pool); | ||
290 | fn(read_err, write_err, context); | ||
291 | |||
292 | if (atomic_dec_and_test(&kc->nr_jobs)) | ||
293 | wake_up(&kc->destroyq); | ||
294 | |||
295 | return 0; | ||
296 | } | ||
297 | |||
298 | static void complete_io(unsigned long error, void *context) | ||
299 | { | ||
300 | struct kcopyd_job *job = (struct kcopyd_job *) context; | ||
301 | struct dm_kcopyd_client *kc = job->kc; | ||
302 | |||
303 | if (error) { | ||
304 | if (job->rw == WRITE) | ||
305 | job->write_err |= error; | ||
306 | else | ||
307 | job->read_err = 1; | ||
308 | |||
309 | if (!test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) { | ||
310 | push(&kc->complete_jobs, job); | ||
311 | wake(kc); | ||
312 | return; | ||
313 | } | ||
314 | } | ||
315 | |||
316 | if (job->rw == WRITE) | ||
317 | push(&kc->complete_jobs, job); | ||
318 | |||
319 | else { | ||
320 | job->rw = WRITE; | ||
321 | push(&kc->io_jobs, job); | ||
322 | } | ||
323 | |||
324 | wake(kc); | ||
325 | } | ||
326 | |||
327 | /* | ||
328 | * Request io on as many buffer heads as we can currently get for | ||
329 | * a particular job. | ||
330 | */ | ||
331 | static int run_io_job(struct kcopyd_job *job) | ||
332 | { | ||
333 | int r; | ||
334 | struct dm_io_request io_req = { | ||
335 | .bi_rw = job->rw, | ||
336 | .mem.type = DM_IO_PAGE_LIST, | ||
337 | .mem.ptr.pl = job->pages, | ||
338 | .mem.offset = job->offset, | ||
339 | .notify.fn = complete_io, | ||
340 | .notify.context = job, | ||
341 | .client = job->kc->io_client, | ||
342 | }; | ||
343 | |||
344 | if (job->rw == READ) | ||
345 | r = dm_io(&io_req, 1, &job->source, NULL); | ||
346 | else | ||
347 | r = dm_io(&io_req, job->num_dests, job->dests, NULL); | ||
348 | |||
349 | return r; | ||
350 | } | ||
351 | |||
352 | static int run_pages_job(struct kcopyd_job *job) | ||
353 | { | ||
354 | int r; | ||
355 | |||
356 | job->nr_pages = dm_div_up(job->dests[0].count + job->offset, | ||
357 | PAGE_SIZE >> 9); | ||
358 | r = kcopyd_get_pages(job->kc, job->nr_pages, &job->pages); | ||
359 | if (!r) { | ||
360 | /* this job is ready for io */ | ||
361 | push(&job->kc->io_jobs, job); | ||
362 | return 0; | ||
363 | } | ||
364 | |||
365 | if (r == -ENOMEM) | ||
366 | /* can't complete now */ | ||
367 | return 1; | ||
368 | |||
369 | return r; | ||
370 | } | ||
371 | |||
372 | /* | ||
373 | * Run through a list for as long as possible. Returns the count | ||
374 | * of successful jobs. | ||
375 | */ | ||
376 | static int process_jobs(struct list_head *jobs, struct dm_kcopyd_client *kc, | ||
377 | int (*fn) (struct kcopyd_job *)) | ||
378 | { | ||
379 | struct kcopyd_job *job; | ||
380 | int r, count = 0; | ||
381 | |||
382 | while ((job = pop(jobs, kc))) { | ||
383 | |||
384 | r = fn(job); | ||
385 | |||
386 | if (r < 0) { | ||
387 | /* error this rogue job */ | ||
388 | if (job->rw == WRITE) | ||
389 | job->write_err = (unsigned long) -1L; | ||
390 | else | ||
391 | job->read_err = 1; | ||
392 | push(&kc->complete_jobs, job); | ||
393 | break; | ||
394 | } | ||
395 | |||
396 | if (r > 0) { | ||
397 | /* | ||
398 | * We couldn't service this job ATM, so | ||
399 | * push this job back onto the list. | ||
400 | */ | ||
401 | push(jobs, job); | ||
402 | break; | ||
403 | } | ||
404 | |||
405 | count++; | ||
406 | } | ||
407 | |||
408 | return count; | ||
409 | } | ||
410 | |||
411 | /* | ||
412 | * kcopyd does this every time it's woken up. | ||
413 | */ | ||
414 | static void do_work(struct work_struct *work) | ||
415 | { | ||
416 | struct dm_kcopyd_client *kc = container_of(work, | ||
417 | struct dm_kcopyd_client, kcopyd_work); | ||
418 | |||
419 | /* | ||
420 | * The order that these are called is *very* important. | ||
421 | * complete jobs can free some pages for pages jobs. | ||
422 | * Pages jobs when successful will jump onto the io jobs | ||
423 | * list. io jobs call wake when they complete and it all | ||
424 | * starts again. | ||
425 | */ | ||
426 | process_jobs(&kc->complete_jobs, kc, run_complete_job); | ||
427 | process_jobs(&kc->pages_jobs, kc, run_pages_job); | ||
428 | process_jobs(&kc->io_jobs, kc, run_io_job); | ||
429 | } | ||
430 | |||
431 | /* | ||
432 | * If we are copying a small region we just dispatch a single job | ||
433 | * to do the copy, otherwise the io has to be split up into many | ||
434 | * jobs. | ||
435 | */ | ||
436 | static void dispatch_job(struct kcopyd_job *job) | ||
437 | { | ||
438 | struct dm_kcopyd_client *kc = job->kc; | ||
439 | atomic_inc(&kc->nr_jobs); | ||
440 | push(&kc->pages_jobs, job); | ||
441 | wake(kc); | ||
442 | } | ||
443 | |||
444 | #define SUB_JOB_SIZE 128 | ||
445 | static void segment_complete(int read_err, unsigned long write_err, | ||
446 | void *context) | ||
447 | { | ||
448 | /* FIXME: tidy this function */ | ||
449 | sector_t progress = 0; | ||
450 | sector_t count = 0; | ||
451 | struct kcopyd_job *job = (struct kcopyd_job *) context; | ||
452 | |||
453 | mutex_lock(&job->lock); | ||
454 | |||
455 | /* update the error */ | ||
456 | if (read_err) | ||
457 | job->read_err = 1; | ||
458 | |||
459 | if (write_err) | ||
460 | job->write_err |= write_err; | ||
461 | |||
462 | /* | ||
463 | * Only dispatch more work if there hasn't been an error. | ||
464 | */ | ||
465 | if ((!job->read_err && !job->write_err) || | ||
466 | test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) { | ||
467 | /* get the next chunk of work */ | ||
468 | progress = job->progress; | ||
469 | count = job->source.count - progress; | ||
470 | if (count) { | ||
471 | if (count > SUB_JOB_SIZE) | ||
472 | count = SUB_JOB_SIZE; | ||
473 | |||
474 | job->progress += count; | ||
475 | } | ||
476 | } | ||
477 | mutex_unlock(&job->lock); | ||
478 | |||
479 | if (count) { | ||
480 | int i; | ||
481 | struct kcopyd_job *sub_job = mempool_alloc(job->kc->job_pool, | ||
482 | GFP_NOIO); | ||
483 | |||
484 | *sub_job = *job; | ||
485 | sub_job->source.sector += progress; | ||
486 | sub_job->source.count = count; | ||
487 | |||
488 | for (i = 0; i < job->num_dests; i++) { | ||
489 | sub_job->dests[i].sector += progress; | ||
490 | sub_job->dests[i].count = count; | ||
491 | } | ||
492 | |||
493 | sub_job->fn = segment_complete; | ||
494 | sub_job->context = job; | ||
495 | dispatch_job(sub_job); | ||
496 | |||
497 | } else if (atomic_dec_and_test(&job->sub_jobs)) { | ||
498 | |||
499 | /* | ||
500 | * To avoid a race we must keep the job around | ||
501 | * until after the notify function has completed. | ||
502 | * Otherwise the client may try and stop the job | ||
503 | * after we've completed. | ||
504 | */ | ||
505 | job->fn(read_err, write_err, job->context); | ||
506 | mempool_free(job, job->kc->job_pool); | ||
507 | } | ||
508 | } | ||
509 | |||
510 | /* | ||
511 | * Create some little jobs that will do the move between | ||
512 | * them. | ||
513 | */ | ||
514 | #define SPLIT_COUNT 8 | ||
515 | static void split_job(struct kcopyd_job *job) | ||
516 | { | ||
517 | int i; | ||
518 | |||
519 | atomic_set(&job->sub_jobs, SPLIT_COUNT); | ||
520 | for (i = 0; i < SPLIT_COUNT; i++) | ||
521 | segment_complete(0, 0u, job); | ||
522 | } | ||
523 | |||
524 | int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from, | ||
525 | unsigned int num_dests, struct dm_io_region *dests, | ||
526 | unsigned int flags, dm_kcopyd_notify_fn fn, void *context) | ||
527 | { | ||
528 | struct kcopyd_job *job; | ||
529 | |||
530 | /* | ||
531 | * Allocate a new job. | ||
532 | */ | ||
533 | job = mempool_alloc(kc->job_pool, GFP_NOIO); | ||
534 | |||
535 | /* | ||
536 | * set up for the read. | ||
537 | */ | ||
538 | job->kc = kc; | ||
539 | job->flags = flags; | ||
540 | job->read_err = 0; | ||
541 | job->write_err = 0; | ||
542 | job->rw = READ; | ||
543 | |||
544 | job->source = *from; | ||
545 | |||
546 | job->num_dests = num_dests; | ||
547 | memcpy(&job->dests, dests, sizeof(*dests) * num_dests); | ||
548 | |||
549 | job->offset = 0; | ||
550 | job->nr_pages = 0; | ||
551 | job->pages = NULL; | ||
552 | |||
553 | job->fn = fn; | ||
554 | job->context = context; | ||
555 | |||
556 | if (job->source.count < SUB_JOB_SIZE) | ||
557 | dispatch_job(job); | ||
558 | |||
559 | else { | ||
560 | mutex_init(&job->lock); | ||
561 | job->progress = 0; | ||
562 | split_job(job); | ||
563 | } | ||
564 | |||
565 | return 0; | ||
566 | } | ||
567 | EXPORT_SYMBOL(dm_kcopyd_copy); | ||
568 | |||
569 | /* | ||
570 | * Cancels a kcopyd job, eg. someone might be deactivating a | ||
571 | * mirror. | ||
572 | */ | ||
573 | #if 0 | ||
574 | int kcopyd_cancel(struct kcopyd_job *job, int block) | ||
575 | { | ||
576 | /* FIXME: finish */ | ||
577 | return -1; | ||
578 | } | ||
579 | #endif /* 0 */ | ||
580 | |||
581 | /*----------------------------------------------------------------- | ||
582 | * Client setup | ||
583 | *---------------------------------------------------------------*/ | ||
584 | int dm_kcopyd_client_create(unsigned int nr_pages, | ||
585 | struct dm_kcopyd_client **result) | ||
586 | { | ||
587 | int r = -ENOMEM; | ||
588 | struct dm_kcopyd_client *kc; | ||
589 | |||
590 | kc = kmalloc(sizeof(*kc), GFP_KERNEL); | ||
591 | if (!kc) | ||
592 | return -ENOMEM; | ||
593 | |||
594 | spin_lock_init(&kc->lock); | ||
595 | spin_lock_init(&kc->job_lock); | ||
596 | INIT_LIST_HEAD(&kc->complete_jobs); | ||
597 | INIT_LIST_HEAD(&kc->io_jobs); | ||
598 | INIT_LIST_HEAD(&kc->pages_jobs); | ||
599 | |||
600 | kc->job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache); | ||
601 | if (!kc->job_pool) | ||
602 | goto bad_slab; | ||
603 | |||
604 | INIT_WORK(&kc->kcopyd_work, do_work); | ||
605 | kc->kcopyd_wq = create_singlethread_workqueue("kcopyd"); | ||
606 | if (!kc->kcopyd_wq) | ||
607 | goto bad_workqueue; | ||
608 | |||
609 | kc->pages = NULL; | ||
610 | kc->nr_pages = kc->nr_free_pages = 0; | ||
611 | r = client_alloc_pages(kc, nr_pages); | ||
612 | if (r) | ||
613 | goto bad_client_pages; | ||
614 | |||
615 | kc->io_client = dm_io_client_create(nr_pages); | ||
616 | if (IS_ERR(kc->io_client)) { | ||
617 | r = PTR_ERR(kc->io_client); | ||
618 | goto bad_io_client; | ||
619 | } | ||
620 | |||
621 | init_waitqueue_head(&kc->destroyq); | ||
622 | atomic_set(&kc->nr_jobs, 0); | ||
623 | |||
624 | *result = kc; | ||
625 | return 0; | ||
626 | |||
627 | bad_io_client: | ||
628 | client_free_pages(kc); | ||
629 | bad_client_pages: | ||
630 | destroy_workqueue(kc->kcopyd_wq); | ||
631 | bad_workqueue: | ||
632 | mempool_destroy(kc->job_pool); | ||
633 | bad_slab: | ||
634 | kfree(kc); | ||
635 | |||
636 | return r; | ||
637 | } | ||
638 | EXPORT_SYMBOL(dm_kcopyd_client_create); | ||
639 | |||
640 | void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc) | ||
641 | { | ||
642 | /* Wait for completion of all jobs submitted by this client. */ | ||
643 | wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs)); | ||
644 | |||
645 | BUG_ON(!list_empty(&kc->complete_jobs)); | ||
646 | BUG_ON(!list_empty(&kc->io_jobs)); | ||
647 | BUG_ON(!list_empty(&kc->pages_jobs)); | ||
648 | destroy_workqueue(kc->kcopyd_wq); | ||
649 | dm_io_client_destroy(kc->io_client); | ||
650 | client_free_pages(kc); | ||
651 | mempool_destroy(kc->job_pool); | ||
652 | kfree(kc); | ||
653 | } | ||
654 | EXPORT_SYMBOL(dm_kcopyd_client_destroy); | ||