gro: Allow tunnel stacking in the case of FOU/GUE
[linux/fpc-iii.git] / drivers / md / dm-log-userspace-base.c
blob058256d2eeea8b6094f50190b9a0116137b238b4
1 /*
2 * Copyright (C) 2006-2009 Red Hat, Inc.
4 * This file is released under the LGPL.
5 */
7 #include <linux/bio.h>
8 #include <linux/slab.h>
9 #include <linux/jiffies.h>
10 #include <linux/dm-dirty-log.h>
11 #include <linux/device-mapper.h>
12 #include <linux/dm-log-userspace.h>
13 #include <linux/module.h>
14 #include <linux/workqueue.h>
16 #include "dm-log-userspace-transfer.h"
18 #define DM_LOG_USERSPACE_VSN "1.3.0"
20 #define FLUSH_ENTRY_POOL_SIZE 16
22 struct dm_dirty_log_flush_entry {
23 int type;
24 region_t region;
25 struct list_head list;
29 * This limit on the number of mark and clear request is, to a degree,
30 * arbitrary. However, there is some basis for the choice in the limits
31 * imposed on the size of data payload by dm-log-userspace-transfer.c:
32 * dm_consult_userspace().
34 #define MAX_FLUSH_GROUP_COUNT 32
36 struct log_c {
37 struct dm_target *ti;
38 struct dm_dev *log_dev;
40 char *usr_argv_str;
41 uint32_t usr_argc;
43 uint32_t region_size;
44 region_t region_count;
45 uint64_t luid;
46 char uuid[DM_UUID_LEN];
49 * Mark and clear requests are held until a flush is issued
50 * so that we can group, and thereby limit, the amount of
51 * network traffic between kernel and userspace. The 'flush_lock'
52 * is used to protect these lists.
54 spinlock_t flush_lock;
55 struct list_head mark_list;
56 struct list_head clear_list;
59 * in_sync_hint gets set when doing is_remote_recovering. It
60 * represents the first region that needs recovery. IOW, the
61 * first zero bit of sync_bits. This can be useful for to limit
62 * traffic for calls like is_remote_recovering and get_resync_work,
63 * but be take care in its use for anything else.
65 uint64_t in_sync_hint;
68 * Workqueue for flush of clear region requests.
70 struct workqueue_struct *dmlog_wq;
71 struct delayed_work flush_log_work;
72 atomic_t sched_flush;
75 * Combine userspace flush and mark requests for efficiency.
77 uint32_t integrated_flush;
79 mempool_t *flush_entry_pool;
82 static struct kmem_cache *_flush_entry_cache;
84 static int userspace_do_request(struct log_c *lc, const char *uuid,
85 int request_type, char *data, size_t data_size,
86 char *rdata, size_t *rdata_size)
88 int r;
91 * If the server isn't there, -ESRCH is returned,
92 * and we must keep trying until the server is
93 * restored.
95 retry:
96 r = dm_consult_userspace(uuid, lc->luid, request_type, data,
97 data_size, rdata, rdata_size);
99 if (r != -ESRCH)
100 return r;
102 DMERR(" Userspace log server not found.");
103 while (1) {
104 set_current_state(TASK_INTERRUPTIBLE);
105 schedule_timeout(2*HZ);
106 DMWARN("Attempting to contact userspace log server...");
107 r = dm_consult_userspace(uuid, lc->luid, DM_ULOG_CTR,
108 lc->usr_argv_str,
109 strlen(lc->usr_argv_str) + 1,
110 NULL, NULL);
111 if (!r)
112 break;
114 DMINFO("Reconnected to userspace log server... DM_ULOG_CTR complete");
115 r = dm_consult_userspace(uuid, lc->luid, DM_ULOG_RESUME, NULL,
116 0, NULL, NULL);
117 if (!r)
118 goto retry;
120 DMERR("Error trying to resume userspace log: %d", r);
122 return -ESRCH;
125 static int build_constructor_string(struct dm_target *ti,
126 unsigned argc, char **argv,
127 char **ctr_str)
129 int i, str_size;
130 char *str = NULL;
132 *ctr_str = NULL;
135 * Determine overall size of the string.
137 for (i = 0, str_size = 0; i < argc; i++)
138 str_size += strlen(argv[i]) + 1; /* +1 for space between args */
140 str_size += 20; /* Max number of chars in a printed u64 number */
142 str = kzalloc(str_size, GFP_KERNEL);
143 if (!str) {
144 DMWARN("Unable to allocate memory for constructor string");
145 return -ENOMEM;
148 str_size = sprintf(str, "%llu", (unsigned long long)ti->len);
149 for (i = 0; i < argc; i++)
150 str_size += sprintf(str + str_size, " %s", argv[i]);
152 *ctr_str = str;
153 return str_size;
156 static void do_flush(struct work_struct *work)
158 int r;
159 struct log_c *lc = container_of(work, struct log_c, flush_log_work.work);
161 atomic_set(&lc->sched_flush, 0);
163 r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH, NULL, 0, NULL, NULL);
165 if (r)
166 dm_table_event(lc->ti->table);
170 * userspace_ctr
172 * argv contains:
173 * <UUID> [integrated_flush] <other args>
174 * Where 'other args' are the userspace implementation-specific log
175 * arguments.
177 * Example:
178 * <UUID> [integrated_flush] clustered-disk <arg count> <log dev>
179 * <region_size> [[no]sync]
181 * This module strips off the <UUID> and uses it for identification
182 * purposes when communicating with userspace about a log.
184 * If integrated_flush is defined, the kernel combines flush
185 * and mark requests.
187 * The rest of the line, beginning with 'clustered-disk', is passed
188 * to the userspace ctr function.
190 static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
191 unsigned argc, char **argv)
193 int r = 0;
194 int str_size;
195 char *ctr_str = NULL;
196 struct log_c *lc = NULL;
197 uint64_t rdata;
198 size_t rdata_size = sizeof(rdata);
199 char *devices_rdata = NULL;
200 size_t devices_rdata_size = DM_NAME_LEN;
202 if (argc < 3) {
203 DMWARN("Too few arguments to userspace dirty log");
204 return -EINVAL;
207 lc = kzalloc(sizeof(*lc), GFP_KERNEL);
208 if (!lc) {
209 DMWARN("Unable to allocate userspace log context.");
210 return -ENOMEM;
213 /* The ptr value is sufficient for local unique id */
214 lc->luid = (unsigned long)lc;
216 lc->ti = ti;
218 if (strlen(argv[0]) > (DM_UUID_LEN - 1)) {
219 DMWARN("UUID argument too long.");
220 kfree(lc);
221 return -EINVAL;
224 lc->usr_argc = argc;
226 strncpy(lc->uuid, argv[0], DM_UUID_LEN);
227 argc--;
228 argv++;
229 spin_lock_init(&lc->flush_lock);
230 INIT_LIST_HEAD(&lc->mark_list);
231 INIT_LIST_HEAD(&lc->clear_list);
233 if (!strcasecmp(argv[0], "integrated_flush")) {
234 lc->integrated_flush = 1;
235 argc--;
236 argv++;
239 str_size = build_constructor_string(ti, argc, argv, &ctr_str);
240 if (str_size < 0) {
241 kfree(lc);
242 return str_size;
245 devices_rdata = kzalloc(devices_rdata_size, GFP_KERNEL);
246 if (!devices_rdata) {
247 DMERR("Failed to allocate memory for device information");
248 r = -ENOMEM;
249 goto out;
252 lc->flush_entry_pool = mempool_create_slab_pool(FLUSH_ENTRY_POOL_SIZE,
253 _flush_entry_cache);
254 if (!lc->flush_entry_pool) {
255 DMERR("Failed to create flush_entry_pool");
256 r = -ENOMEM;
257 goto out;
261 * Send table string and get back any opened device.
263 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_CTR,
264 ctr_str, str_size,
265 devices_rdata, &devices_rdata_size);
267 if (r < 0) {
268 if (r == -ESRCH)
269 DMERR("Userspace log server not found");
270 else
271 DMERR("Userspace log server failed to create log");
272 goto out;
275 /* Since the region size does not change, get it now */
276 rdata_size = sizeof(rdata);
277 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_GET_REGION_SIZE,
278 NULL, 0, (char *)&rdata, &rdata_size);
280 if (r) {
281 DMERR("Failed to get region size of dirty log");
282 goto out;
285 lc->region_size = (uint32_t)rdata;
286 lc->region_count = dm_sector_div_up(ti->len, lc->region_size);
288 if (devices_rdata_size) {
289 if (devices_rdata[devices_rdata_size - 1] != '\0') {
290 DMERR("DM_ULOG_CTR device return string not properly terminated");
291 r = -EINVAL;
292 goto out;
294 r = dm_get_device(ti, devices_rdata,
295 dm_table_get_mode(ti->table), &lc->log_dev);
296 if (r)
297 DMERR("Failed to register %s with device-mapper",
298 devices_rdata);
301 if (lc->integrated_flush) {
302 lc->dmlog_wq = alloc_workqueue("dmlogd", WQ_MEM_RECLAIM, 0);
303 if (!lc->dmlog_wq) {
304 DMERR("couldn't start dmlogd");
305 r = -ENOMEM;
306 goto out;
309 INIT_DELAYED_WORK(&lc->flush_log_work, do_flush);
310 atomic_set(&lc->sched_flush, 0);
313 out:
314 kfree(devices_rdata);
315 if (r) {
316 if (lc->flush_entry_pool)
317 mempool_destroy(lc->flush_entry_pool);
318 kfree(lc);
319 kfree(ctr_str);
320 } else {
321 lc->usr_argv_str = ctr_str;
322 log->context = lc;
325 return r;
328 static void userspace_dtr(struct dm_dirty_log *log)
330 struct log_c *lc = log->context;
332 if (lc->integrated_flush) {
333 /* flush workqueue */
334 if (atomic_read(&lc->sched_flush))
335 flush_delayed_work(&lc->flush_log_work);
337 destroy_workqueue(lc->dmlog_wq);
340 (void) dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_DTR,
341 NULL, 0, NULL, NULL);
343 if (lc->log_dev)
344 dm_put_device(lc->ti, lc->log_dev);
346 mempool_destroy(lc->flush_entry_pool);
348 kfree(lc->usr_argv_str);
349 kfree(lc);
351 return;
354 static int userspace_presuspend(struct dm_dirty_log *log)
356 int r;
357 struct log_c *lc = log->context;
359 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_PRESUSPEND,
360 NULL, 0, NULL, NULL);
362 return r;
365 static int userspace_postsuspend(struct dm_dirty_log *log)
367 int r;
368 struct log_c *lc = log->context;
371 * Run planned flush earlier.
373 if (lc->integrated_flush && atomic_read(&lc->sched_flush))
374 flush_delayed_work(&lc->flush_log_work);
376 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_POSTSUSPEND,
377 NULL, 0, NULL, NULL);
379 return r;
382 static int userspace_resume(struct dm_dirty_log *log)
384 int r;
385 struct log_c *lc = log->context;
387 lc->in_sync_hint = 0;
388 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_RESUME,
389 NULL, 0, NULL, NULL);
391 return r;
394 static uint32_t userspace_get_region_size(struct dm_dirty_log *log)
396 struct log_c *lc = log->context;
398 return lc->region_size;
402 * userspace_is_clean
404 * Check whether a region is clean. If there is any sort of
405 * failure when consulting the server, we return not clean.
407 * Returns: 1 if clean, 0 otherwise
409 static int userspace_is_clean(struct dm_dirty_log *log, region_t region)
411 int r;
412 uint64_t region64 = (uint64_t)region;
413 int64_t is_clean;
414 size_t rdata_size;
415 struct log_c *lc = log->context;
417 rdata_size = sizeof(is_clean);
418 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_CLEAN,
419 (char *)&region64, sizeof(region64),
420 (char *)&is_clean, &rdata_size);
422 return (r) ? 0 : (int)is_clean;
426 * userspace_in_sync
428 * Check if the region is in-sync. If there is any sort
429 * of failure when consulting the server, we assume that
430 * the region is not in sync.
432 * If 'can_block' is set, return immediately
434 * Returns: 1 if in-sync, 0 if not-in-sync, -EWOULDBLOCK
436 static int userspace_in_sync(struct dm_dirty_log *log, region_t region,
437 int can_block)
439 int r;
440 uint64_t region64 = region;
441 int64_t in_sync;
442 size_t rdata_size;
443 struct log_c *lc = log->context;
446 * We can never respond directly - even if in_sync_hint is
447 * set. This is because another machine could see a device
448 * failure and mark the region out-of-sync. If we don't go
449 * to userspace to ask, we might think the region is in-sync
450 * and allow a read to pick up data that is stale. (This is
451 * very unlikely if a device actually fails; but it is very
452 * likely if a connection to one device from one machine fails.)
454 * There still might be a problem if the mirror caches the region
455 * state as in-sync... but then this call would not be made. So,
456 * that is a mirror problem.
458 if (!can_block)
459 return -EWOULDBLOCK;
461 rdata_size = sizeof(in_sync);
462 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IN_SYNC,
463 (char *)&region64, sizeof(region64),
464 (char *)&in_sync, &rdata_size);
465 return (r) ? 0 : (int)in_sync;
468 static int flush_one_by_one(struct log_c *lc, struct list_head *flush_list)
470 int r = 0;
471 struct dm_dirty_log_flush_entry *fe;
473 list_for_each_entry(fe, flush_list, list) {
474 r = userspace_do_request(lc, lc->uuid, fe->type,
475 (char *)&fe->region,
476 sizeof(fe->region),
477 NULL, NULL);
478 if (r)
479 break;
482 return r;
485 static int flush_by_group(struct log_c *lc, struct list_head *flush_list,
486 int flush_with_payload)
488 int r = 0;
489 int count;
490 uint32_t type = 0;
491 struct dm_dirty_log_flush_entry *fe, *tmp_fe;
492 LIST_HEAD(tmp_list);
493 uint64_t group[MAX_FLUSH_GROUP_COUNT];
496 * Group process the requests
498 while (!list_empty(flush_list)) {
499 count = 0;
501 list_for_each_entry_safe(fe, tmp_fe, flush_list, list) {
502 group[count] = fe->region;
503 count++;
505 list_move(&fe->list, &tmp_list);
507 type = fe->type;
508 if (count >= MAX_FLUSH_GROUP_COUNT)
509 break;
512 if (flush_with_payload) {
513 r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
514 (char *)(group),
515 count * sizeof(uint64_t),
516 NULL, NULL);
518 * Integrated flush failed.
520 if (r)
521 break;
522 } else {
523 r = userspace_do_request(lc, lc->uuid, type,
524 (char *)(group),
525 count * sizeof(uint64_t),
526 NULL, NULL);
527 if (r) {
529 * Group send failed. Attempt one-by-one.
531 list_splice_init(&tmp_list, flush_list);
532 r = flush_one_by_one(lc, flush_list);
533 break;
539 * Must collect flush_entrys that were successfully processed
540 * as a group so that they will be free'd by the caller.
542 list_splice_init(&tmp_list, flush_list);
544 return r;
548 * userspace_flush
550 * This function is ok to block.
551 * The flush happens in two stages. First, it sends all
552 * clear/mark requests that are on the list. Then it
553 * tells the server to commit them. This gives the
554 * server a chance to optimise the commit, instead of
555 * doing it for every request.
557 * Additionally, we could implement another thread that
558 * sends the requests up to the server - reducing the
559 * load on flush. Then the flush would have less in
560 * the list and be responsible for the finishing commit.
562 * Returns: 0 on success, < 0 on failure
564 static int userspace_flush(struct dm_dirty_log *log)
566 int r = 0;
567 unsigned long flags;
568 struct log_c *lc = log->context;
569 LIST_HEAD(mark_list);
570 LIST_HEAD(clear_list);
571 int mark_list_is_empty;
572 int clear_list_is_empty;
573 struct dm_dirty_log_flush_entry *fe, *tmp_fe;
574 mempool_t *flush_entry_pool = lc->flush_entry_pool;
576 spin_lock_irqsave(&lc->flush_lock, flags);
577 list_splice_init(&lc->mark_list, &mark_list);
578 list_splice_init(&lc->clear_list, &clear_list);
579 spin_unlock_irqrestore(&lc->flush_lock, flags);
581 mark_list_is_empty = list_empty(&mark_list);
582 clear_list_is_empty = list_empty(&clear_list);
584 if (mark_list_is_empty && clear_list_is_empty)
585 return 0;
587 r = flush_by_group(lc, &clear_list, 0);
588 if (r)
589 goto out;
591 if (!lc->integrated_flush) {
592 r = flush_by_group(lc, &mark_list, 0);
593 if (r)
594 goto out;
595 r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
596 NULL, 0, NULL, NULL);
597 goto out;
601 * Send integrated flush request with mark_list as payload.
603 r = flush_by_group(lc, &mark_list, 1);
604 if (r)
605 goto out;
607 if (mark_list_is_empty && !atomic_read(&lc->sched_flush)) {
609 * When there are only clear region requests,
610 * we schedule a flush in the future.
612 queue_delayed_work(lc->dmlog_wq, &lc->flush_log_work, 3 * HZ);
613 atomic_set(&lc->sched_flush, 1);
614 } else {
616 * Cancel pending flush because we
617 * have already flushed in mark_region.
619 cancel_delayed_work(&lc->flush_log_work);
620 atomic_set(&lc->sched_flush, 0);
623 out:
625 * We can safely remove these entries, even after failure.
626 * Calling code will receive an error and will know that
627 * the log facility has failed.
629 list_for_each_entry_safe(fe, tmp_fe, &mark_list, list) {
630 list_del(&fe->list);
631 mempool_free(fe, flush_entry_pool);
633 list_for_each_entry_safe(fe, tmp_fe, &clear_list, list) {
634 list_del(&fe->list);
635 mempool_free(fe, flush_entry_pool);
638 if (r)
639 dm_table_event(lc->ti->table);
641 return r;
645 * userspace_mark_region
647 * This function should avoid blocking unless absolutely required.
648 * (Memory allocation is valid for blocking.)
650 static void userspace_mark_region(struct dm_dirty_log *log, region_t region)
652 unsigned long flags;
653 struct log_c *lc = log->context;
654 struct dm_dirty_log_flush_entry *fe;
656 /* Wait for an allocation, but _never_ fail */
657 fe = mempool_alloc(lc->flush_entry_pool, GFP_NOIO);
658 BUG_ON(!fe);
660 spin_lock_irqsave(&lc->flush_lock, flags);
661 fe->type = DM_ULOG_MARK_REGION;
662 fe->region = region;
663 list_add(&fe->list, &lc->mark_list);
664 spin_unlock_irqrestore(&lc->flush_lock, flags);
666 return;
670 * userspace_clear_region
672 * This function must not block.
673 * So, the alloc can't block. In the worst case, it is ok to
674 * fail. It would simply mean we can't clear the region.
675 * Does nothing to current sync context, but does mean
676 * the region will be re-sync'ed on a reload of the mirror
677 * even though it is in-sync.
679 static void userspace_clear_region(struct dm_dirty_log *log, region_t region)
681 unsigned long flags;
682 struct log_c *lc = log->context;
683 struct dm_dirty_log_flush_entry *fe;
686 * If we fail to allocate, we skip the clearing of
687 * the region. This doesn't hurt us in any way, except
688 * to cause the region to be resync'ed when the
689 * device is activated next time.
691 fe = mempool_alloc(lc->flush_entry_pool, GFP_ATOMIC);
692 if (!fe) {
693 DMERR("Failed to allocate memory to clear region.");
694 return;
697 spin_lock_irqsave(&lc->flush_lock, flags);
698 fe->type = DM_ULOG_CLEAR_REGION;
699 fe->region = region;
700 list_add(&fe->list, &lc->clear_list);
701 spin_unlock_irqrestore(&lc->flush_lock, flags);
703 return;
707 * userspace_get_resync_work
709 * Get a region that needs recovery. It is valid to return
710 * an error for this function.
712 * Returns: 1 if region filled, 0 if no work, <0 on error
714 static int userspace_get_resync_work(struct dm_dirty_log *log, region_t *region)
716 int r;
717 size_t rdata_size;
718 struct log_c *lc = log->context;
719 struct {
720 int64_t i; /* 64-bit for mix arch compatibility */
721 region_t r;
722 } pkg;
724 if (lc->in_sync_hint >= lc->region_count)
725 return 0;
727 rdata_size = sizeof(pkg);
728 r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_RESYNC_WORK,
729 NULL, 0, (char *)&pkg, &rdata_size);
731 *region = pkg.r;
732 return (r) ? r : (int)pkg.i;
736 * userspace_set_region_sync
738 * Set the sync status of a given region. This function
739 * must not fail.
741 static void userspace_set_region_sync(struct dm_dirty_log *log,
742 region_t region, int in_sync)
744 struct log_c *lc = log->context;
745 struct {
746 region_t r;
747 int64_t i;
748 } pkg;
750 pkg.r = region;
751 pkg.i = (int64_t)in_sync;
753 (void) userspace_do_request(lc, lc->uuid, DM_ULOG_SET_REGION_SYNC,
754 (char *)&pkg, sizeof(pkg), NULL, NULL);
757 * It would be nice to be able to report failures.
758 * However, it is easy enough to detect and resolve.
760 return;
764 * userspace_get_sync_count
766 * If there is any sort of failure when consulting the server,
767 * we assume that the sync count is zero.
769 * Returns: sync count on success, 0 on failure
771 static region_t userspace_get_sync_count(struct dm_dirty_log *log)
773 int r;
774 size_t rdata_size;
775 uint64_t sync_count;
776 struct log_c *lc = log->context;
778 rdata_size = sizeof(sync_count);
779 r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_SYNC_COUNT,
780 NULL, 0, (char *)&sync_count, &rdata_size);
782 if (r)
783 return 0;
785 if (sync_count >= lc->region_count)
786 lc->in_sync_hint = lc->region_count;
788 return (region_t)sync_count;
792 * userspace_status
794 * Returns: amount of space consumed
796 static int userspace_status(struct dm_dirty_log *log, status_type_t status_type,
797 char *result, unsigned maxlen)
799 int r = 0;
800 char *table_args;
801 size_t sz = (size_t)maxlen;
802 struct log_c *lc = log->context;
804 switch (status_type) {
805 case STATUSTYPE_INFO:
806 r = userspace_do_request(lc, lc->uuid, DM_ULOG_STATUS_INFO,
807 NULL, 0, result, &sz);
809 if (r) {
810 sz = 0;
811 DMEMIT("%s 1 COM_FAILURE", log->type->name);
813 break;
814 case STATUSTYPE_TABLE:
815 sz = 0;
816 table_args = strchr(lc->usr_argv_str, ' ');
817 BUG_ON(!table_args); /* There will always be a ' ' */
818 table_args++;
820 DMEMIT("%s %u %s ", log->type->name, lc->usr_argc, lc->uuid);
821 if (lc->integrated_flush)
822 DMEMIT("integrated_flush ");
823 DMEMIT("%s ", table_args);
824 break;
826 return (r) ? 0 : (int)sz;
830 * userspace_is_remote_recovering
832 * Returns: 1 if region recovering, 0 otherwise
834 static int userspace_is_remote_recovering(struct dm_dirty_log *log,
835 region_t region)
837 int r;
838 uint64_t region64 = region;
839 struct log_c *lc = log->context;
840 static unsigned long limit;
841 struct {
842 int64_t is_recovering;
843 uint64_t in_sync_hint;
844 } pkg;
845 size_t rdata_size = sizeof(pkg);
848 * Once the mirror has been reported to be in-sync,
849 * it will never again ask for recovery work. So,
850 * we can safely say there is not a remote machine
851 * recovering if the device is in-sync. (in_sync_hint
852 * must be reset at resume time.)
854 if (region < lc->in_sync_hint)
855 return 0;
856 else if (time_after(limit, jiffies))
857 return 1;
859 limit = jiffies + (HZ / 4);
860 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_REMOTE_RECOVERING,
861 (char *)&region64, sizeof(region64),
862 (char *)&pkg, &rdata_size);
863 if (r)
864 return 1;
866 lc->in_sync_hint = pkg.in_sync_hint;
868 return (int)pkg.is_recovering;
871 static struct dm_dirty_log_type _userspace_type = {
872 .name = "userspace",
873 .module = THIS_MODULE,
874 .ctr = userspace_ctr,
875 .dtr = userspace_dtr,
876 .presuspend = userspace_presuspend,
877 .postsuspend = userspace_postsuspend,
878 .resume = userspace_resume,
879 .get_region_size = userspace_get_region_size,
880 .is_clean = userspace_is_clean,
881 .in_sync = userspace_in_sync,
882 .flush = userspace_flush,
883 .mark_region = userspace_mark_region,
884 .clear_region = userspace_clear_region,
885 .get_resync_work = userspace_get_resync_work,
886 .set_region_sync = userspace_set_region_sync,
887 .get_sync_count = userspace_get_sync_count,
888 .status = userspace_status,
889 .is_remote_recovering = userspace_is_remote_recovering,
892 static int __init userspace_dirty_log_init(void)
894 int r = 0;
896 _flush_entry_cache = KMEM_CACHE(dm_dirty_log_flush_entry, 0);
897 if (!_flush_entry_cache) {
898 DMWARN("Unable to create flush_entry_cache: No memory.");
899 return -ENOMEM;
902 r = dm_ulog_tfr_init();
903 if (r) {
904 DMWARN("Unable to initialize userspace log communications");
905 kmem_cache_destroy(_flush_entry_cache);
906 return r;
909 r = dm_dirty_log_type_register(&_userspace_type);
910 if (r) {
911 DMWARN("Couldn't register userspace dirty log type");
912 dm_ulog_tfr_exit();
913 kmem_cache_destroy(_flush_entry_cache);
914 return r;
917 DMINFO("version " DM_LOG_USERSPACE_VSN " loaded");
918 return 0;
921 static void __exit userspace_dirty_log_exit(void)
923 dm_dirty_log_type_unregister(&_userspace_type);
924 dm_ulog_tfr_exit();
925 kmem_cache_destroy(_flush_entry_cache);
927 DMINFO("version " DM_LOG_USERSPACE_VSN " unloaded");
928 return;
931 module_init(userspace_dirty_log_init);
932 module_exit(userspace_dirty_log_exit);
934 MODULE_DESCRIPTION(DM_NAME " userspace dirty log link");
935 MODULE_AUTHOR("Jonathan Brassow <dm-devel@redhat.com>");
936 MODULE_LICENSE("GPL");