LXR linux/include/linux/dm-dirty-log.h

   1/*
   2 * Copyright (C) 2003 Sistina Software
   3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
   4 *
   5 * Device-Mapper dirty region log.
   6 *
   7 * This file is released under the LGPL.
   8 */
   9
  10#ifndef _LINUX_DM_DIRTY_LOG
  11#define _LINUX_DM_DIRTY_LOG
  12
  13#ifdef __KERNEL__
  14
  15#include <linux/types.h>
  16#include <linux/device-mapper.h>
  17
  18typedef sector_t region_t;
  19
  20struct dm_dirty_log_type;
  21
  22struct dm_dirty_log {
  23        struct dm_dirty_log_type *type;
  24        void *context;
  25};
  26
  27struct dm_dirty_log_type {
  28        const char *name;
  29        struct module *module;
  30
  31        /* For internal device-mapper use */
  32        struct list_head list;
  33
  34        int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti,
  35                   unsigned argc, char **argv);
  36        void (*dtr)(struct dm_dirty_log *log);
  37
  38        /*
  39         * There are times when we don't want the log to touch
  40         * the disk.
  41         */
  42        int (*presuspend)(struct dm_dirty_log *log);
  43        int (*postsuspend)(struct dm_dirty_log *log);
  44        int (*resume)(struct dm_dirty_log *log);
  45
  46        /*
  47         * Retrieves the smallest size of region that the log can
  48         * deal with.
  49         */
  50        uint32_t (*get_region_size)(struct dm_dirty_log *log);
  51
  52        /*
  53         * A predicate to say whether a region is clean or not.
  54         * May block.
  55         */
  56        int (*is_clean)(struct dm_dirty_log *log, region_t region);
  57
  58        /*
  59         *  Returns: 0, 1, -EWOULDBLOCK, < 0
  60         *
  61         * A predicate function to check the area given by
  62         * [sector, sector + len) is in sync.
  63         *
  64         * If -EWOULDBLOCK is returned the state of the region is
  65         * unknown, typically this will result in a read being
  66         * passed to a daemon to deal with, since a daemon is
  67         * allowed to block.
  68         */
  69        int (*in_sync)(struct dm_dirty_log *log, region_t region,
  70                       int can_block);
  71
  72        /*
  73         * Flush the current log state (eg, to disk).  This
  74         * function may block.
  75         */
  76        int (*flush)(struct dm_dirty_log *log);
  77
  78        /*
  79         * Mark an area as clean or dirty.  These functions may
  80         * block, though for performance reasons blocking should
  81         * be extremely rare (eg, allocating another chunk of
  82         * memory for some reason).
  83         */
  84        void (*mark_region)(struct dm_dirty_log *log, region_t region);
  85        void (*clear_region)(struct dm_dirty_log *log, region_t region);
  86
  87        /*
  88         * Returns: <0 (error), 0 (no region), 1 (region)
  89         *
  90         * The mirrord will need perform recovery on regions of
  91         * the mirror that are in the NOSYNC state.  This
  92         * function asks the log to tell the caller about the
  93         * next region that this machine should recover.
  94         *
  95         * Do not confuse this function with 'in_sync()', one
  96         * tells you if an area is synchronised, the other
  97         * assigns recovery work.
  98        */
  99        int (*get_resync_work)(struct dm_dirty_log *log, region_t *region);
 100
 101        /*
 102         * This notifies the log that the resync status of a region
 103         * has changed.  It also clears the region from the recovering
 104         * list (if present).
 105         */
 106        void (*set_region_sync)(struct dm_dirty_log *log,
 107                                region_t region, int in_sync);
 108
 109        /*
 110         * Returns the number of regions that are in sync.
 111         */
 112        region_t (*get_sync_count)(struct dm_dirty_log *log);
 113
 114        /*
 115         * Support function for mirror status requests.
 116         */
 117        int (*status)(struct dm_dirty_log *log, status_type_t status_type,
 118                      char *result, unsigned maxlen);
 119
 120        /*
 121         * is_remote_recovering is necessary for cluster mirroring. It provides
 122         * a way to detect recovery on another node, so we aren't writing
 123         * concurrently.  This function is likely to block (when a cluster log
 124         * is used).
 125         *
 126         * Returns: 0, 1
 127         */
 128        int (*is_remote_recovering)(struct dm_dirty_log *log, region_t region);
 129};
 130
 131int dm_dirty_log_type_register(struct dm_dirty_log_type *type);
 132int dm_dirty_log_type_unregister(struct dm_dirty_log_type *type);
 133
 134/*
 135 * Make sure you use these two functions, rather than calling
 136 * type->constructor/destructor() directly.
 137 */
 138struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
 139                                         struct dm_target *ti,
 140                                         unsigned argc, char **argv);
 141void dm_dirty_log_destroy(struct dm_dirty_log *log);
 142
 143#endif  /* __KERNEL__ */
 144#endif  /* _LINUX_DM_DIRTY_LOG_H */
 145