1 /*
2  * Copyright (C) 2006-2009 Red Hat, Inc.
3  *
4  * This file is released under the LGPL.
5  */
6 
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>
15 
16 #include "dm-log-userspace-transfer.h"
17 
18 #define DM_LOG_USERSPACE_VSN "1.3.0"
19 
20 #define FLUSH_ENTRY_POOL_SIZE 16
21 
22 struct dm_dirty_log_flush_entry {
23 	int type;
24 	region_t region;
25 	struct list_head list;
26 };
27 
28 /*
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().
33  */
34 #define MAX_FLUSH_GROUP_COUNT 32
35 
36 struct log_c {
37 	struct dm_target *ti;
38 	struct dm_dev *log_dev;
39 
40 	char *usr_argv_str;
41 	uint32_t usr_argc;
42 
43 	uint32_t region_size;
44 	region_t region_count;
45 	uint64_t luid;
46 	char uuid[DM_UUID_LEN];
47 
48 	/*
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.
53 	 */
54 	spinlock_t flush_lock;
55 	struct list_head mark_list;
56 	struct list_head clear_list;
57 
58 	/*
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.
64 	 */
65 	uint64_t in_sync_hint;
66 
67 	/*
68 	 * Workqueue for flush of clear region requests.
69 	 */
70 	struct workqueue_struct *dmlog_wq;
71 	struct delayed_work flush_log_work;
72 	atomic_t sched_flush;
73 
74 	/*
75 	 * Combine userspace flush and mark requests for efficiency.
76 	 */
77 	uint32_t integrated_flush;
78 
79 	mempool_t flush_entry_pool;
80 };
81 
82 static struct kmem_cache *_flush_entry_cache;
83 
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)
87 {
88 	int r;
89 
90 	/*
91 	 * If the server isn't there, -ESRCH is returned,
92 	 * and we must keep trying until the server is
93 	 * restored.
94 	 */
95 retry:
96 	r = dm_consult_userspace(uuid, lc->luid, request_type, data,
97 				 data_size, rdata, rdata_size);
98 
99 	if (r != -ESRCH)
100 		return r;
101 
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;
113 	}
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;
119 
120 	DMERR("Error trying to resume userspace log: %d", r);
121 
122 	return -ESRCH;
123 }
124 
125 static int build_constructor_string(struct dm_target *ti,
126 				    unsigned argc, char **argv,
127 				    char **ctr_str)
128 {
129 	int i, str_size;
130 	char *str = NULL;
131 
132 	*ctr_str = NULL;
133 
134 	/*
135 	 * Determine overall size of the string.
136 	 */
137 	for (i = 0, str_size = 0; i < argc; i++)
138 		str_size += strlen(argv[i]) + 1; /* +1 for space between args */
139 
140 	str_size += 20; /* Max number of chars in a printed u64 number */
141 
142 	str = kzalloc(str_size, GFP_KERNEL);
143 	if (!str) {
144 		DMWARN("Unable to allocate memory for constructor string");
145 		return -ENOMEM;
146 	}
147 
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]);
151 
152 	*ctr_str = str;
153 	return str_size;
154 }
155 
156 static void do_flush(struct work_struct *work)
157 {
158 	int r;
159 	struct log_c *lc = container_of(work, struct log_c, flush_log_work.work);
160 
161 	atomic_set(&lc->sched_flush, 0);
162 
163 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH, NULL, 0, NULL, NULL);
164 
165 	if (r)
166 		dm_table_event(lc->ti->table);
167 }
168 
169 /*
170  * userspace_ctr
171  *
172  * argv contains:
173  *	<UUID> [integrated_flush] <other args>
174  * Where 'other args' are the userspace implementation-specific log
175  * arguments.
176  *
177  * Example:
178  *	<UUID> [integrated_flush] clustered-disk <arg count> <log dev>
179  *	<region_size> [[no]sync]
180  *
181  * This module strips off the <UUID> and uses it for identification
182  * purposes when communicating with userspace about a log.
183  *
184  * If integrated_flush is defined, the kernel combines flush
185  * and mark requests.
186  *
187  * The rest of the line, beginning with 'clustered-disk', is passed
188  * to the userspace ctr function.
189  */
190 static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
191 			 unsigned argc, char **argv)
192 {
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;
201 
202 	if (argc < 3) {
203 		DMWARN("Too few arguments to userspace dirty log");
204 		return -EINVAL;
205 	}
206 
207 	lc = kzalloc(sizeof(*lc), GFP_KERNEL);
208 	if (!lc) {
209 		DMWARN("Unable to allocate userspace log context.");
210 		return -ENOMEM;
211 	}
212 
213 	/* The ptr value is sufficient for local unique id */
214 	lc->luid = (unsigned long)lc;
215 
216 	lc->ti = ti;
217 
218 	if (strlen(argv[0]) > (DM_UUID_LEN - 1)) {
219 		DMWARN("UUID argument too long.");
220 		kfree(lc);
221 		return -EINVAL;
222 	}
223 
224 	lc->usr_argc = argc;
225 
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);
232 
233 	if (!strcasecmp(argv[0], "integrated_flush")) {
234 		lc->integrated_flush = 1;
235 		argc--;
236 		argv++;
237 	}
238 
239 	str_size = build_constructor_string(ti, argc, argv, &ctr_str);
240 	if (str_size < 0) {
241 		kfree(lc);
242 		return str_size;
243 	}
244 
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;
250 	}
251 
252 	r = mempool_init_slab_pool(&lc->flush_entry_pool, FLUSH_ENTRY_POOL_SIZE,
253 				   _flush_entry_cache);
254 	if (r) {
255 		DMERR("Failed to create flush_entry_pool");
256 		goto out;
257 	}
258 
259 	/*
260 	 * Send table string and get back any opened device.
261 	 */
262 	r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_CTR,
263 				 ctr_str, str_size,
264 				 devices_rdata, &devices_rdata_size);
265 
266 	if (r < 0) {
267 		if (r == -ESRCH)
268 			DMERR("Userspace log server not found");
269 		else
270 			DMERR("Userspace log server failed to create log");
271 		goto out;
272 	}
273 
274 	/* Since the region size does not change, get it now */
275 	rdata_size = sizeof(rdata);
276 	r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_GET_REGION_SIZE,
277 				 NULL, 0, (char *)&rdata, &rdata_size);
278 
279 	if (r) {
280 		DMERR("Failed to get region size of dirty log");
281 		goto out;
282 	}
283 
284 	lc->region_size = (uint32_t)rdata;
285 	lc->region_count = dm_sector_div_up(ti->len, lc->region_size);
286 
287 	if (devices_rdata_size) {
288 		if (devices_rdata[devices_rdata_size - 1] != '\0') {
289 			DMERR("DM_ULOG_CTR device return string not properly terminated");
290 			r = -EINVAL;
291 			goto out;
292 		}
293 		r = dm_get_device(ti, devices_rdata,
294 				  dm_table_get_mode(ti->table), &lc->log_dev);
295 		if (r)
296 			DMERR("Failed to register %s with device-mapper",
297 			      devices_rdata);
298 	}
299 
300 	if (lc->integrated_flush) {
301 		lc->dmlog_wq = alloc_workqueue("dmlogd", WQ_MEM_RECLAIM, 0);
302 		if (!lc->dmlog_wq) {
303 			DMERR("couldn't start dmlogd");
304 			r = -ENOMEM;
305 			goto out;
306 		}
307 
308 		INIT_DELAYED_WORK(&lc->flush_log_work, do_flush);
309 		atomic_set(&lc->sched_flush, 0);
310 	}
311 
312 out:
313 	kfree(devices_rdata);
314 	if (r) {
315 		mempool_exit(&lc->flush_entry_pool);
316 		kfree(lc);
317 		kfree(ctr_str);
318 	} else {
319 		lc->usr_argv_str = ctr_str;
320 		log->context = lc;
321 	}
322 
323 	return r;
324 }
325 
326 static void userspace_dtr(struct dm_dirty_log *log)
327 {
328 	struct log_c *lc = log->context;
329 
330 	if (lc->integrated_flush) {
331 		/* flush workqueue */
332 		if (atomic_read(&lc->sched_flush))
333 			flush_delayed_work(&lc->flush_log_work);
334 
335 		destroy_workqueue(lc->dmlog_wq);
336 	}
337 
338 	(void) dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_DTR,
339 				    NULL, 0, NULL, NULL);
340 
341 	if (lc->log_dev)
342 		dm_put_device(lc->ti, lc->log_dev);
343 
344 	mempool_exit(&lc->flush_entry_pool);
345 
346 	kfree(lc->usr_argv_str);
347 	kfree(lc);
348 
349 	return;
350 }
351 
352 static int userspace_presuspend(struct dm_dirty_log *log)
353 {
354 	int r;
355 	struct log_c *lc = log->context;
356 
357 	r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_PRESUSPEND,
358 				 NULL, 0, NULL, NULL);
359 
360 	return r;
361 }
362 
363 static int userspace_postsuspend(struct dm_dirty_log *log)
364 {
365 	int r;
366 	struct log_c *lc = log->context;
367 
368 	/*
369 	 * Run planned flush earlier.
370 	 */
371 	if (lc->integrated_flush && atomic_read(&lc->sched_flush))
372 		flush_delayed_work(&lc->flush_log_work);
373 
374 	r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_POSTSUSPEND,
375 				 NULL, 0, NULL, NULL);
376 
377 	return r;
378 }
379 
380 static int userspace_resume(struct dm_dirty_log *log)
381 {
382 	int r;
383 	struct log_c *lc = log->context;
384 
385 	lc->in_sync_hint = 0;
386 	r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_RESUME,
387 				 NULL, 0, NULL, NULL);
388 
389 	return r;
390 }
391 
392 static uint32_t userspace_get_region_size(struct dm_dirty_log *log)
393 {
394 	struct log_c *lc = log->context;
395 
396 	return lc->region_size;
397 }
398 
399 /*
400  * userspace_is_clean
401  *
402  * Check whether a region is clean.  If there is any sort of
403  * failure when consulting the server, we return not clean.
404  *
405  * Returns: 1 if clean, 0 otherwise
406  */
407 static int userspace_is_clean(struct dm_dirty_log *log, region_t region)
408 {
409 	int r;
410 	uint64_t region64 = (uint64_t)region;
411 	int64_t is_clean;
412 	size_t rdata_size;
413 	struct log_c *lc = log->context;
414 
415 	rdata_size = sizeof(is_clean);
416 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_CLEAN,
417 				 (char *)&region64, sizeof(region64),
418 				 (char *)&is_clean, &rdata_size);
419 
420 	return (r) ? 0 : (int)is_clean;
421 }
422 
423 /*
424  * userspace_in_sync
425  *
426  * Check if the region is in-sync.  If there is any sort
427  * of failure when consulting the server, we assume that
428  * the region is not in sync.
429  *
430  * If 'can_block' is set, return immediately
431  *
432  * Returns: 1 if in-sync, 0 if not-in-sync, -EWOULDBLOCK
433  */
434 static int userspace_in_sync(struct dm_dirty_log *log, region_t region,
435 			     int can_block)
436 {
437 	int r;
438 	uint64_t region64 = region;
439 	int64_t in_sync;
440 	size_t rdata_size;
441 	struct log_c *lc = log->context;
442 
443 	/*
444 	 * We can never respond directly - even if in_sync_hint is
445 	 * set.  This is because another machine could see a device
446 	 * failure and mark the region out-of-sync.  If we don't go
447 	 * to userspace to ask, we might think the region is in-sync
448 	 * and allow a read to pick up data that is stale.  (This is
449 	 * very unlikely if a device actually fails; but it is very
450 	 * likely if a connection to one device from one machine fails.)
451 	 *
452 	 * There still might be a problem if the mirror caches the region
453 	 * state as in-sync... but then this call would not be made.  So,
454 	 * that is a mirror problem.
455 	 */
456 	if (!can_block)
457 		return -EWOULDBLOCK;
458 
459 	rdata_size = sizeof(in_sync);
460 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_IN_SYNC,
461 				 (char *)&region64, sizeof(region64),
462 				 (char *)&in_sync, &rdata_size);
463 	return (r) ? 0 : (int)in_sync;
464 }
465 
466 static int flush_one_by_one(struct log_c *lc, struct list_head *flush_list)
467 {
468 	int r = 0;
469 	struct dm_dirty_log_flush_entry *fe;
470 
471 	list_for_each_entry(fe, flush_list, list) {
472 		r = userspace_do_request(lc, lc->uuid, fe->type,
473 					 (char *)&fe->region,
474 					 sizeof(fe->region),
475 					 NULL, NULL);
476 		if (r)
477 			break;
478 	}
479 
480 	return r;
481 }
482 
483 static int flush_by_group(struct log_c *lc, struct list_head *flush_list,
484 			  int flush_with_payload)
485 {
486 	int r = 0;
487 	int count;
488 	uint32_t type = 0;
489 	struct dm_dirty_log_flush_entry *fe, *tmp_fe;
490 	LIST_HEAD(tmp_list);
491 	uint64_t group[MAX_FLUSH_GROUP_COUNT];
492 
493 	/*
494 	 * Group process the requests
495 	 */
496 	while (!list_empty(flush_list)) {
497 		count = 0;
498 
499 		list_for_each_entry_safe(fe, tmp_fe, flush_list, list) {
500 			group[count] = fe->region;
501 			count++;
502 
503 			list_move(&fe->list, &tmp_list);
504 
505 			type = fe->type;
506 			if (count >= MAX_FLUSH_GROUP_COUNT)
507 				break;
508 		}
509 
510 		if (flush_with_payload) {
511 			r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
512 						 (char *)(group),
513 						 count * sizeof(uint64_t),
514 						 NULL, NULL);
515 			/*
516 			 * Integrated flush failed.
517 			 */
518 			if (r)
519 				break;
520 		} else {
521 			r = userspace_do_request(lc, lc->uuid, type,
522 						 (char *)(group),
523 						 count * sizeof(uint64_t),
524 						 NULL, NULL);
525 			if (r) {
526 				/*
527 				 * Group send failed.  Attempt one-by-one.
528 				 */
529 				list_splice_init(&tmp_list, flush_list);
530 				r = flush_one_by_one(lc, flush_list);
531 				break;
532 			}
533 		}
534 	}
535 
536 	/*
537 	 * Must collect flush_entrys that were successfully processed
538 	 * as a group so that they will be free'd by the caller.
539 	 */
540 	list_splice_init(&tmp_list, flush_list);
541 
542 	return r;
543 }
544 
545 /*
546  * userspace_flush
547  *
548  * This function is ok to block.
549  * The flush happens in two stages.  First, it sends all
550  * clear/mark requests that are on the list.  Then it
551  * tells the server to commit them.  This gives the
552  * server a chance to optimise the commit, instead of
553  * doing it for every request.
554  *
555  * Additionally, we could implement another thread that
556  * sends the requests up to the server - reducing the
557  * load on flush.  Then the flush would have less in
558  * the list and be responsible for the finishing commit.
559  *
560  * Returns: 0 on success, < 0 on failure
561  */
562 static int userspace_flush(struct dm_dirty_log *log)
563 {
564 	int r = 0;
565 	unsigned long flags;
566 	struct log_c *lc = log->context;
567 	LIST_HEAD(mark_list);
568 	LIST_HEAD(clear_list);
569 	int mark_list_is_empty;
570 	int clear_list_is_empty;
571 	struct dm_dirty_log_flush_entry *fe, *tmp_fe;
572 	mempool_t *flush_entry_pool = &lc->flush_entry_pool;
573 
574 	spin_lock_irqsave(&lc->flush_lock, flags);
575 	list_splice_init(&lc->mark_list, &mark_list);
576 	list_splice_init(&lc->clear_list, &clear_list);
577 	spin_unlock_irqrestore(&lc->flush_lock, flags);
578 
579 	mark_list_is_empty = list_empty(&mark_list);
580 	clear_list_is_empty = list_empty(&clear_list);
581 
582 	if (mark_list_is_empty && clear_list_is_empty)
583 		return 0;
584 
585 	r = flush_by_group(lc, &clear_list, 0);
586 	if (r)
587 		goto out;
588 
589 	if (!lc->integrated_flush) {
590 		r = flush_by_group(lc, &mark_list, 0);
591 		if (r)
592 			goto out;
593 		r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
594 					 NULL, 0, NULL, NULL);
595 		goto out;
596 	}
597 
598 	/*
599 	 * Send integrated flush request with mark_list as payload.
600 	 */
601 	r = flush_by_group(lc, &mark_list, 1);
602 	if (r)
603 		goto out;
604 
605 	if (mark_list_is_empty && !atomic_read(&lc->sched_flush)) {
606 		/*
607 		 * When there are only clear region requests,
608 		 * we schedule a flush in the future.
609 		 */
610 		queue_delayed_work(lc->dmlog_wq, &lc->flush_log_work, 3 * HZ);
611 		atomic_set(&lc->sched_flush, 1);
612 	} else {
613 		/*
614 		 * Cancel pending flush because we
615 		 * have already flushed in mark_region.
616 		 */
617 		cancel_delayed_work(&lc->flush_log_work);
618 		atomic_set(&lc->sched_flush, 0);
619 	}
620 
621 out:
622 	/*
623 	 * We can safely remove these entries, even after failure.
624 	 * Calling code will receive an error and will know that
625 	 * the log facility has failed.
626 	 */
627 	list_for_each_entry_safe(fe, tmp_fe, &mark_list, list) {
628 		list_del(&fe->list);
629 		mempool_free(fe, flush_entry_pool);
630 	}
631 	list_for_each_entry_safe(fe, tmp_fe, &clear_list, list) {
632 		list_del(&fe->list);
633 		mempool_free(fe, flush_entry_pool);
634 	}
635 
636 	if (r)
637 		dm_table_event(lc->ti->table);
638 
639 	return r;
640 }
641 
642 /*
643  * userspace_mark_region
644  *
645  * This function should avoid blocking unless absolutely required.
646  * (Memory allocation is valid for blocking.)
647  */
648 static void userspace_mark_region(struct dm_dirty_log *log, region_t region)
649 {
650 	unsigned long flags;
651 	struct log_c *lc = log->context;
652 	struct dm_dirty_log_flush_entry *fe;
653 
654 	/* Wait for an allocation, but _never_ fail */
655 	fe = mempool_alloc(&lc->flush_entry_pool, GFP_NOIO);
656 	BUG_ON(!fe);
657 
658 	spin_lock_irqsave(&lc->flush_lock, flags);
659 	fe->type = DM_ULOG_MARK_REGION;
660 	fe->region = region;
661 	list_add(&fe->list, &lc->mark_list);
662 	spin_unlock_irqrestore(&lc->flush_lock, flags);
663 
664 	return;
665 }
666 
667 /*
668  * userspace_clear_region
669  *
670  * This function must not block.
671  * So, the alloc can't block.  In the worst case, it is ok to
672  * fail.  It would simply mean we can't clear the region.
673  * Does nothing to current sync context, but does mean
674  * the region will be re-sync'ed on a reload of the mirror
675  * even though it is in-sync.
676  */
677 static void userspace_clear_region(struct dm_dirty_log *log, region_t region)
678 {
679 	unsigned long flags;
680 	struct log_c *lc = log->context;
681 	struct dm_dirty_log_flush_entry *fe;
682 
683 	/*
684 	 * If we fail to allocate, we skip the clearing of
685 	 * the region.  This doesn't hurt us in any way, except
686 	 * to cause the region to be resync'ed when the
687 	 * device is activated next time.
688 	 */
689 	fe = mempool_alloc(&lc->flush_entry_pool, GFP_ATOMIC);
690 	if (!fe) {
691 		DMERR("Failed to allocate memory to clear region.");
692 		return;
693 	}
694 
695 	spin_lock_irqsave(&lc->flush_lock, flags);
696 	fe->type = DM_ULOG_CLEAR_REGION;
697 	fe->region = region;
698 	list_add(&fe->list, &lc->clear_list);
699 	spin_unlock_irqrestore(&lc->flush_lock, flags);
700 
701 	return;
702 }
703 
704 /*
705  * userspace_get_resync_work
706  *
707  * Get a region that needs recovery.  It is valid to return
708  * an error for this function.
709  *
710  * Returns: 1 if region filled, 0 if no work, <0 on error
711  */
712 static int userspace_get_resync_work(struct dm_dirty_log *log, region_t *region)
713 {
714 	int r;
715 	size_t rdata_size;
716 	struct log_c *lc = log->context;
717 	struct {
718 		int64_t i; /* 64-bit for mix arch compatibility */
719 		region_t r;
720 	} pkg;
721 
722 	if (lc->in_sync_hint >= lc->region_count)
723 		return 0;
724 
725 	rdata_size = sizeof(pkg);
726 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_RESYNC_WORK,
727 				 NULL, 0, (char *)&pkg, &rdata_size);
728 
729 	*region = pkg.r;
730 	return (r) ? r : (int)pkg.i;
731 }
732 
733 /*
734  * userspace_set_region_sync
735  *
736  * Set the sync status of a given region.  This function
737  * must not fail.
738  */
739 static void userspace_set_region_sync(struct dm_dirty_log *log,
740 				      region_t region, int in_sync)
741 {
742 	struct log_c *lc = log->context;
743 	struct {
744 		region_t r;
745 		int64_t i;
746 	} pkg;
747 
748 	pkg.r = region;
749 	pkg.i = (int64_t)in_sync;
750 
751 	(void) userspace_do_request(lc, lc->uuid, DM_ULOG_SET_REGION_SYNC,
752 				    (char *)&pkg, sizeof(pkg), NULL, NULL);
753 
754 	/*
755 	 * It would be nice to be able to report failures.
756 	 * However, it is easy enough to detect and resolve.
757 	 */
758 	return;
759 }
760 
761 /*
762  * userspace_get_sync_count
763  *
764  * If there is any sort of failure when consulting the server,
765  * we assume that the sync count is zero.
766  *
767  * Returns: sync count on success, 0 on failure
768  */
769 static region_t userspace_get_sync_count(struct dm_dirty_log *log)
770 {
771 	int r;
772 	size_t rdata_size;
773 	uint64_t sync_count;
774 	struct log_c *lc = log->context;
775 
776 	rdata_size = sizeof(sync_count);
777 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_SYNC_COUNT,
778 				 NULL, 0, (char *)&sync_count, &rdata_size);
779 
780 	if (r)
781 		return 0;
782 
783 	if (sync_count >= lc->region_count)
784 		lc->in_sync_hint = lc->region_count;
785 
786 	return (region_t)sync_count;
787 }
788 
789 /*
790  * userspace_status
791  *
792  * Returns: amount of space consumed
793  */
794 static int userspace_status(struct dm_dirty_log *log, status_type_t status_type,
795 			    char *result, unsigned maxlen)
796 {
797 	int r = 0;
798 	char *table_args;
799 	size_t sz = (size_t)maxlen;
800 	struct log_c *lc = log->context;
801 
802 	switch (status_type) {
803 	case STATUSTYPE_INFO:
804 		r = userspace_do_request(lc, lc->uuid, DM_ULOG_STATUS_INFO,
805 					 NULL, 0, result, &sz);
806 
807 		if (r) {
808 			sz = 0;
809 			DMEMIT("%s 1 COM_FAILURE", log->type->name);
810 		}
811 		break;
812 	case STATUSTYPE_TABLE:
813 		sz = 0;
814 		table_args = strchr(lc->usr_argv_str, ' ');
815 		BUG_ON(!table_args); /* There will always be a ' ' */
816 		table_args++;
817 
818 		DMEMIT("%s %u %s ", log->type->name, lc->usr_argc, lc->uuid);
819 		if (lc->integrated_flush)
820 			DMEMIT("integrated_flush ");
821 		DMEMIT("%s ", table_args);
822 		break;
823 	case STATUSTYPE_IMA:
824 		*result = '\0';
825 		break;
826 	}
827 	return (r) ? 0 : (int)sz;
828 }
829 
830 /*
831  * userspace_is_remote_recovering
832  *
833  * Returns: 1 if region recovering, 0 otherwise
834  */
835 static int userspace_is_remote_recovering(struct dm_dirty_log *log,
836 					  region_t region)
837 {
838 	int r;
839 	uint64_t region64 = region;
840 	struct log_c *lc = log->context;
841 	static unsigned long limit;
842 	struct {
843 		int64_t is_recovering;
844 		uint64_t in_sync_hint;
845 	} pkg;
846 	size_t rdata_size = sizeof(pkg);
847 
848 	/*
849 	 * Once the mirror has been reported to be in-sync,
850 	 * it will never again ask for recovery work.  So,
851 	 * we can safely say there is not a remote machine
852 	 * recovering if the device is in-sync.  (in_sync_hint
853 	 * must be reset at resume time.)
854 	 */
855 	if (region < lc->in_sync_hint)
856 		return 0;
857 	else if (time_after(limit, jiffies))
858 		return 1;
859 
860 	limit = jiffies + (HZ / 4);
861 	r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_REMOTE_RECOVERING,
862 				 (char *)&region64, sizeof(region64),
863 				 (char *)&pkg, &rdata_size);
864 	if (r)
865 		return 1;
866 
867 	lc->in_sync_hint = pkg.in_sync_hint;
868 
869 	return (int)pkg.is_recovering;
870 }
871 
872 static struct dm_dirty_log_type _userspace_type = {
873 	.name = "userspace",
874 	.module = THIS_MODULE,
875 	.ctr = userspace_ctr,
876 	.dtr = userspace_dtr,
877 	.presuspend = userspace_presuspend,
878 	.postsuspend = userspace_postsuspend,
879 	.resume = userspace_resume,
880 	.get_region_size = userspace_get_region_size,
881 	.is_clean = userspace_is_clean,
882 	.in_sync = userspace_in_sync,
883 	.flush = userspace_flush,
884 	.mark_region = userspace_mark_region,
885 	.clear_region = userspace_clear_region,
886 	.get_resync_work = userspace_get_resync_work,
887 	.set_region_sync = userspace_set_region_sync,
888 	.get_sync_count = userspace_get_sync_count,
889 	.status = userspace_status,
890 	.is_remote_recovering = userspace_is_remote_recovering,
891 };
892 
893 static int __init userspace_dirty_log_init(void)
894 {
895 	int r = 0;
896 
897 	_flush_entry_cache = KMEM_CACHE(dm_dirty_log_flush_entry, 0);
898 	if (!_flush_entry_cache) {
899 		DMWARN("Unable to create flush_entry_cache: No memory.");
900 		return -ENOMEM;
901 	}
902 
903 	r = dm_ulog_tfr_init();
904 	if (r) {
905 		DMWARN("Unable to initialize userspace log communications");
906 		kmem_cache_destroy(_flush_entry_cache);
907 		return r;
908 	}
909 
910 	r = dm_dirty_log_type_register(&_userspace_type);
911 	if (r) {
912 		DMWARN("Couldn't register userspace dirty log type");
913 		dm_ulog_tfr_exit();
914 		kmem_cache_destroy(_flush_entry_cache);
915 		return r;
916 	}
917 
918 	DMINFO("version " DM_LOG_USERSPACE_VSN " loaded");
919 	return 0;
920 }
921 
922 static void __exit userspace_dirty_log_exit(void)
923 {
924 	dm_dirty_log_type_unregister(&_userspace_type);
925 	dm_ulog_tfr_exit();
926 	kmem_cache_destroy(_flush_entry_cache);
927 
928 	DMINFO("version " DM_LOG_USERSPACE_VSN " unloaded");
929 	return;
930 }
931 
932 module_init(userspace_dirty_log_init);
933 module_exit(userspace_dirty_log_exit);
934 
935 MODULE_DESCRIPTION(DM_NAME " userspace dirty log link");
936 MODULE_AUTHOR("Jonathan Brassow <dm-devel@redhat.com>");
937 MODULE_LICENSE("GPL");
938