cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

dm-dirty-log.h (4038B)

      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 */