/* * Copyright (C) 2012 Red Hat. All rights reserved. * * This file is released under the GPL. */ #ifndef DM_CACHE_POLICY_H #define DM_CACHE_POLICY_H #include "dm-cache-block-types.h" #include <linux/device-mapper.h> /*----------------------------------------------------------------*/ /* FIXME: make it clear which methods are optional. Get debug policy to * double check this at start. */ /* * The cache policy makes the important decisions about which blocks get to * live on the faster cache device. * * When the core target has to remap a bio it calls the 'map' method of the * policy. This returns an instruction telling the core target what to do. * * POLICY_HIT: * That block is in the cache. Remap to the cache and carry on. * * POLICY_MISS: * This block is on the origin device. Remap and carry on. * * POLICY_NEW: * This block is currently on the origin device, but the policy wants to * move it. The core should: * * - hold any further io to this origin block * - copy the origin to the given cache block * - release all the held blocks * - remap the original block to the cache * * POLICY_REPLACE: * This block is currently on the origin device. The policy wants to * move it to the cache, with the added complication that the destination * cache block needs a writeback first. The core should: * * - hold any further io to this origin block * - hold any further io to the origin block that's being written back * - writeback * - copy new block to cache * - release held blocks * - remap bio to cache and reissue. * * Should the core run into trouble while processing a POLICY_NEW or * POLICY_REPLACE instruction it will roll back the policies mapping using * remove_mapping() or force_mapping(). These methods must not fail. This * approach avoids having transactional semantics in the policy (ie, the * core informing the policy when a migration is complete), and hence makes * it easier to write new policies. * * In general policy methods should never block, except in the case of the * map function when can_migrate is set. So be careful to implement using * bounded, preallocated memory. */ enum policy_operation { POLICY_HIT, POLICY_MISS, POLICY_NEW, POLICY_REPLACE }; /* * When issuing a POLICY_REPLACE the policy needs to make a callback to * lock the block being demoted. This doesn't need to occur during a * writeback operation since the block remains in the cache. */ struct policy_locker; typedef int (*policy_lock_fn)(struct policy_locker *l, dm_oblock_t oblock); struct policy_locker { policy_lock_fn fn; }; /* * This is the instruction passed back to the core target. */ struct policy_result { enum policy_operation op; dm_oblock_t old_oblock; /* POLICY_REPLACE */ dm_cblock_t cblock; /* POLICY_HIT, POLICY_NEW, POLICY_REPLACE */ }; /* * The cache policy object. Just a bunch of methods. It is envisaged that * this structure will be embedded in a bigger, policy specific structure * (ie. use container_of()). */ struct dm_cache_policy { /* * FIXME: make it clear which methods are optional, and which may * block. */ /* * Destroys this object. */ void (*destroy)(struct dm_cache_policy *p); /* * See large comment above. * * oblock - the origin block we're interested in. * * can_block - indicates whether the current thread is allowed to * block. -EWOULDBLOCK returned if it can't and would. * * can_migrate - gives permission for POLICY_NEW or POLICY_REPLACE * instructions. If denied and the policy would have * returned one of these instructions it should * return -EWOULDBLOCK. * * discarded_oblock - indicates whether the whole origin block is * in a discarded state (FIXME: better to tell the * policy about this sooner, so it can recycle that * cache block if it wants.) * bio - the bio that triggered this call. * result - gets filled in with the instruction. * * May only return 0, or -EWOULDBLOCK (if !can_migrate) */ int (*map)(struct dm_cache_policy *p, dm_oblock_t oblock, bool can_block, bool can_migrate, bool discarded_oblock, struct bio *bio, struct policy_locker *locker, struct policy_result *result); /* * Sometimes we want to see if a block is in the cache, without * triggering any update of stats. (ie. it's not a real hit). * * Must not block. * * Returns 0 if in cache, -ENOENT if not, < 0 for other errors * (-EWOULDBLOCK would be typical). */ int (*lookup)(struct dm_cache_policy *p, dm_oblock_t oblock, dm_cblock_t *cblock); void (*set_dirty)(struct dm_cache_policy *p, dm_oblock_t oblock); void (*clear_dirty)(struct dm_cache_policy *p, dm_oblock_t oblock); /* * Called when a cache target is first created. Used to load a * mapping from the metadata device into the policy. */ int (*load_mapping)(struct dm_cache_policy *p, dm_oblock_t oblock, dm_cblock_t cblock, uint32_t hint, bool hint_valid); /* * Gets the hint for a given cblock. Called in a single threaded * context. So no locking required. */ uint32_t (*get_hint)(struct dm_cache_policy *p, dm_cblock_t cblock); /* * Override functions used on the error paths of the core target. * They must succeed. */ void (*remove_mapping)(struct dm_cache_policy *p, dm_oblock_t oblock); void (*force_mapping)(struct dm_cache_policy *p, dm_oblock_t current_oblock, dm_oblock_t new_oblock); /* * This is called via the invalidate_cblocks message. It is * possible the particular cblock has already been removed due to a * write io in passthrough mode. In which case this should return * -ENODATA. */ int (*remove_cblock)(struct dm_cache_policy *p, dm_cblock_t cblock); /* * Provide a dirty block to be written back by the core target. If * critical_only is set then the policy should only provide work if * it urgently needs it. * * Returns: * * 0 and @cblock,@oblock: block to write back provided * * -ENODATA: no dirty blocks available */ int (*writeback_work)(struct dm_cache_policy *p, dm_oblock_t *oblock, dm_cblock_t *cblock, bool critical_only); /* * How full is the cache? */ dm_cblock_t (*residency)(struct dm_cache_policy *p); /* * Because of where we sit in the block layer, we can be asked to * map a lot of little bios that are all in the same block (no * queue merging has occurred). To stop the policy being fooled by * these, the core target sends regular tick() calls to the policy. * The policy should only count an entry as hit once per tick. */ void (*tick)(struct dm_cache_policy *p, bool can_block); /* * Configuration. */ int (*emit_config_values)(struct dm_cache_policy *p, char *result, unsigned maxlen, ssize_t *sz_ptr); int (*set_config_value)(struct dm_cache_policy *p, const char *key, const char *value); /* * Book keeping ptr for the policy register, not for general use. */ void *private; }; /*----------------------------------------------------------------*/ /* * We maintain a little register of the different policy types. */ #define CACHE_POLICY_NAME_SIZE 16 #define CACHE_POLICY_VERSION_SIZE 3 struct dm_cache_policy_type { /* For use by the register code only. */ struct list_head list; /* * Policy writers should fill in these fields. The name field is * what gets passed on the target line to select your policy. */ char name[CACHE_POLICY_NAME_SIZE]; unsigned version[CACHE_POLICY_VERSION_SIZE]; /* * For use by an alias dm_cache_policy_type to point to the * real dm_cache_policy_type. */ struct dm_cache_policy_type *real; /* * Policies may store a hint for each each cache block. * Currently the size of this hint must be 0 or 4 bytes but we * expect to relax this in future. */ size_t hint_size; struct module *owner; struct dm_cache_policy *(*create)(dm_cblock_t cache_size, sector_t origin_size, sector_t block_size); }; int dm_cache_policy_register(struct dm_cache_policy_type *type); void dm_cache_policy_unregister(struct dm_cache_policy_type *type); /*----------------------------------------------------------------*/ #endif /* DM_CACHE_POLICY_H */