Root/drivers/md/dm-log-userspace-base.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive