1
2
3
4
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
22struct dm_dirty_log_flush_entry {
23 int type;
24 region_t region;
25 struct list_head list;
26};
27
28
29
30
31
32
33
34#define MAX_FLUSH_GROUP_COUNT 32
35
36struct 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
50
51
52
53
54 spinlock_t flush_lock;
55 struct list_head mark_list;
56 struct list_head clear_list;
57
58
59
60
61
62
63
64
65 uint64_t in_sync_hint;
66
67
68
69
70 struct workqueue_struct *dmlog_wq;
71 struct delayed_work flush_log_work;
72 atomic_t sched_flush;
73
74
75
76
77 uint32_t integrated_flush;
78
79 mempool_t *flush_entry_pool;
80};
81
82static struct kmem_cache *_flush_entry_cache;
83
84static 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
92
93
94
95retry:
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
125static 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
136
137 for (i = 0, str_size = 0; i < argc; i++)
138 str_size += strlen(argv[i]) + 1;
139
140 str_size += 20;
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
156static 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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190static 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
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 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;
258 }
259
260
261
262
263 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_CTR,
264 ctr_str, str_size,
265 devices_rdata, &devices_rdata_size);
266
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;
273 }
274
275
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);
279
280 if (r) {
281 DMERR("Failed to get region size of dirty log");
282 goto out;
283 }
284
285 lc->region_size = (uint32_t)rdata;
286 lc->region_count = dm_sector_div_up(ti->len, lc->region_size);
287
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;
293 }
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);
299 }
300
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;
307 }
308
309 INIT_DELAYED_WORK(&lc->flush_log_work, do_flush);
310 atomic_set(&lc->sched_flush, 0);
311 }
312
313out:
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;
323 }
324
325 return r;
326}
327
328static void userspace_dtr(struct dm_dirty_log *log)
329{
330 struct log_c *lc = log->context;
331
332 if (lc->integrated_flush) {
333
334 if (atomic_read(&lc->sched_flush))
335 flush_delayed_work(&lc->flush_log_work);
336
337 destroy_workqueue(lc->dmlog_wq);
338 }
339
340 (void) dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_DTR,
341 NULL, 0, NULL, NULL);
342
343 if (lc->log_dev)
344 dm_put_device(lc->ti, lc->log_dev);
345
346 mempool_destroy(lc->flush_entry_pool);
347
348 kfree(lc->usr_argv_str);
349 kfree(lc);
350
351 return;
352}
353
354static int userspace_presuspend(struct dm_dirty_log *log)
355{
356 int r;
357 struct log_c *lc = log->context;
358
359 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_PRESUSPEND,
360 NULL, 0, NULL, NULL);
361
362 return r;
363}
364
365static int userspace_postsuspend(struct dm_dirty_log *log)
366{
367 int r;
368 struct log_c *lc = log->context;
369
370
371
372
373 if (lc->integrated_flush && atomic_read(&lc->sched_flush))
374 flush_delayed_work(&lc->flush_log_work);
375
376 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_POSTSUSPEND,
377 NULL, 0, NULL, NULL);
378
379 return r;
380}
381
382static int userspace_resume(struct dm_dirty_log *log)
383{
384 int r;
385 struct log_c *lc = log->context;
386
387 lc->in_sync_hint = 0;
388 r = dm_consult_userspace(lc->uuid, lc->luid, DM_ULOG_RESUME,
389 NULL, 0, NULL, NULL);
390
391 return r;
392}
393
394static uint32_t userspace_get_region_size(struct dm_dirty_log *log)
395{
396 struct log_c *lc = log->context;
397
398 return lc->region_size;
399}
400
401
402
403
404
405
406
407
408
409static int userspace_is_clean(struct dm_dirty_log *log, region_t region)
410{
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;
416
417 rdata_size = sizeof(is_clean);
418 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_CLEAN,
419 (char *)®ion64, sizeof(region64),
420 (char *)&is_clean, &rdata_size);
421
422 return (r) ? 0 : (int)is_clean;
423}
424
425
426
427
428
429
430
431
432
433
434
435
436static int userspace_in_sync(struct dm_dirty_log *log, region_t region,
437 int can_block)
438{
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;
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458 if (!can_block)
459 return -EWOULDBLOCK;
460
461 rdata_size = sizeof(in_sync);
462 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IN_SYNC,
463 (char *)®ion64, sizeof(region64),
464 (char *)&in_sync, &rdata_size);
465 return (r) ? 0 : (int)in_sync;
466}
467
468static int flush_one_by_one(struct log_c *lc, struct list_head *flush_list)
469{
470 int r = 0;
471 struct dm_dirty_log_flush_entry *fe;
472
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;
480 }
481
482 return r;
483}
484
485static int flush_by_group(struct log_c *lc, struct list_head *flush_list,
486 int flush_with_payload)
487{
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];
494
495
496
497
498 while (!list_empty(flush_list)) {
499 count = 0;
500
501 list_for_each_entry_safe(fe, tmp_fe, flush_list, list) {
502 group[count] = fe->region;
503 count++;
504
505 list_move(&fe->list, &tmp_list);
506
507 type = fe->type;
508 if (count >= MAX_FLUSH_GROUP_COUNT)
509 break;
510 }
511
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);
517
518
519
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) {
528
529
530
531 list_splice_init(&tmp_list, flush_list);
532 r = flush_one_by_one(lc, flush_list);
533 break;
534 }
535 }
536 }
537
538
539
540
541
542 list_splice_init(&tmp_list, flush_list);
543
544 return r;
545}
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564static int userspace_flush(struct dm_dirty_log *log)
565{
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;
575
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);
580
581 mark_list_is_empty = list_empty(&mark_list);
582 clear_list_is_empty = list_empty(&clear_list);
583
584 if (mark_list_is_empty && clear_list_is_empty)
585 return 0;
586
587 r = flush_by_group(lc, &clear_list, 0);
588 if (r)
589 goto out;
590
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;
598 }
599
600
601
602
603 r = flush_by_group(lc, &mark_list, 1);
604 if (r)
605 goto out;
606
607 if (mark_list_is_empty && !atomic_read(&lc->sched_flush)) {
608
609
610
611
612 queue_delayed_work(lc->dmlog_wq, &lc->flush_log_work, 3 * HZ);
613 atomic_set(&lc->sched_flush, 1);
614 } else {
615
616
617
618
619 cancel_delayed_work(&lc->flush_log_work);
620 atomic_set(&lc->sched_flush, 0);
621 }
622
623out:
624
625
626
627
628
629 list_for_each_entry_safe(fe, tmp_fe, &mark_list, list) {
630 list_del(&fe->list);
631 mempool_free(fe, flush_entry_pool);
632 }
633 list_for_each_entry_safe(fe, tmp_fe, &clear_list, list) {
634 list_del(&fe->list);
635 mempool_free(fe, flush_entry_pool);
636 }
637
638 if (r)
639 dm_table_event(lc->ti->table);
640
641 return r;
642}
643
644
645
646
647
648
649
650static void userspace_mark_region(struct dm_dirty_log *log, region_t region)
651{
652 unsigned long flags;
653 struct log_c *lc = log->context;
654 struct dm_dirty_log_flush_entry *fe;
655
656
657 fe = mempool_alloc(lc->flush_entry_pool, GFP_NOIO);
658 BUG_ON(!fe);
659
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);
665
666 return;
667}
668
669
670
671
672
673
674
675
676
677
678
679static void userspace_clear_region(struct dm_dirty_log *log, region_t region)
680{
681 unsigned long flags;
682 struct log_c *lc = log->context;
683 struct dm_dirty_log_flush_entry *fe;
684
685
686
687
688
689
690
691 fe = mempool_alloc(lc->flush_entry_pool, GFP_ATOMIC);
692 if (!fe) {
693 DMERR("Failed to allocate memory to clear region.");
694 return;
695 }
696
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);
702
703 return;
704}
705
706
707
708
709
710
711
712
713
714static int userspace_get_resync_work(struct dm_dirty_log *log, region_t *region)
715{
716 int r;
717 size_t rdata_size;
718 struct log_c *lc = log->context;
719 struct {
720 int64_t i;
721 region_t r;
722 } pkg;
723
724 if (lc->in_sync_hint >= lc->region_count)
725 return 0;
726
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);
730
731 *region = pkg.r;
732 return (r) ? r : (int)pkg.i;
733}
734
735
736
737
738
739
740
741static void userspace_set_region_sync(struct dm_dirty_log *log,
742 region_t region, int in_sync)
743{
744 struct log_c *lc = log->context;
745 struct {
746 region_t r;
747 int64_t i;
748 } pkg;
749
750 pkg.r = region;
751 pkg.i = (int64_t)in_sync;
752
753 (void) userspace_do_request(lc, lc->uuid, DM_ULOG_SET_REGION_SYNC,
754 (char *)&pkg, sizeof(pkg), NULL, NULL);
755
756
757
758
759
760 return;
761}
762
763
764
765
766
767
768
769
770
771static region_t userspace_get_sync_count(struct dm_dirty_log *log)
772{
773 int r;
774 size_t rdata_size;
775 uint64_t sync_count;
776 struct log_c *lc = log->context;
777
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);
781
782 if (r)
783 return 0;
784
785 if (sync_count >= lc->region_count)
786 lc->in_sync_hint = lc->region_count;
787
788 return (region_t)sync_count;
789}
790
791
792
793
794
795
796static int userspace_status(struct dm_dirty_log *log, status_type_t status_type,
797 char *result, unsigned maxlen)
798{
799 int r = 0;
800 char *table_args;
801 size_t sz = (size_t)maxlen;
802 struct log_c *lc = log->context;
803
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);
808
809 if (r) {
810 sz = 0;
811 DMEMIT("%s 1 COM_FAILURE", log->type->name);
812 }
813 break;
814 case STATUSTYPE_TABLE:
815 sz = 0;
816 table_args = strchr(lc->usr_argv_str, ' ');
817 BUG_ON(!table_args);
818 table_args++;
819
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;
825 }
826 return (r) ? 0 : (int)sz;
827}
828
829
830
831
832
833
834static int userspace_is_remote_recovering(struct dm_dirty_log *log,
835 region_t region)
836{
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);
846
847
848
849
850
851
852
853
854 if (region < lc->in_sync_hint)
855 return 0;
856 else if (time_after(limit, jiffies))
857 return 1;
858
859 limit = jiffies + (HZ / 4);
860 r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_REMOTE_RECOVERING,
861 (char *)®ion64, sizeof(region64),
862 (char *)&pkg, &rdata_size);
863 if (r)
864 return 1;
865
866 lc->in_sync_hint = pkg.in_sync_hint;
867
868 return (int)pkg.is_recovering;
869}
870
871static 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,
890};
891
892static int __init userspace_dirty_log_init(void)
893{
894 int r = 0;
895
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;
900 }
901
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;
907 }
908
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;
915 }
916
917 DMINFO("version " DM_LOG_USERSPACE_VSN " loaded");
918 return 0;
919}
920
921static void __exit userspace_dirty_log_exit(void)
922{
923 dm_dirty_log_type_unregister(&_userspace_type);
924 dm_ulog_tfr_exit();
925 kmem_cache_destroy(_flush_entry_cache);
926
927 DMINFO("version " DM_LOG_USERSPACE_VSN " unloaded");
928 return;
929}
930
931module_init(userspace_dirty_log_init);
932module_exit(userspace_dirty_log_exit);
933
934MODULE_DESCRIPTION(DM_NAME " userspace dirty log link");
935MODULE_AUTHOR("Jonathan Brassow <dm-devel@redhat.com>");
936MODULE_LICENSE("GPL");
937