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