LXR linux/drivers/md/dm-cache-policy-internal.h

   1/*
   2 * Copyright (C) 2012 Red Hat. All rights reserved.
   3 *
   4 * This file is released under the GPL.
   5 */
   6
   7#ifndef DM_CACHE_POLICY_INTERNAL_H
   8#define DM_CACHE_POLICY_INTERNAL_H
   9
  10#include <linux/vmalloc.h>
  11#include "dm-cache-policy.h"
  12
  13/*----------------------------------------------------------------*/
  14
  15static inline int policy_lookup(struct dm_cache_policy *p, dm_oblock_t oblock, dm_cblock_t *cblock,
  16                                int data_dir, bool fast_copy, bool *background_queued)
  17{
  18        return p->lookup(p, oblock, cblock, data_dir, fast_copy, background_queued);
  19}
  20
  21static inline int policy_lookup_with_work(struct dm_cache_policy *p,
  22                                          dm_oblock_t oblock, dm_cblock_t *cblock,
  23                                          int data_dir, bool fast_copy,
  24                                          struct policy_work **work)
  25{
  26        if (!p->lookup_with_work) {
  27                *work = NULL;
  28                return p->lookup(p, oblock, cblock, data_dir, fast_copy, NULL);
  29        }
  30
  31        return p->lookup_with_work(p, oblock, cblock, data_dir, fast_copy, work);
  32}
  33
  34static inline int policy_get_background_work(struct dm_cache_policy *p,
  35                                             bool idle, struct policy_work **result)
  36{
  37        return p->get_background_work(p, idle, result);
  38}
  39
  40static inline void policy_complete_background_work(struct dm_cache_policy *p,
  41                                                   struct policy_work *work,
  42                                                   bool success)
  43{
  44        return p->complete_background_work(p, work, success);
  45}
  46
  47static inline void policy_set_dirty(struct dm_cache_policy *p, dm_cblock_t cblock)
  48{
  49        p->set_dirty(p, cblock);
  50}
  51
  52static inline void policy_clear_dirty(struct dm_cache_policy *p, dm_cblock_t cblock)
  53{
  54        p->clear_dirty(p, cblock);
  55}
  56
  57static inline int policy_load_mapping(struct dm_cache_policy *p,
  58                                      dm_oblock_t oblock, dm_cblock_t cblock,
  59                                      bool dirty, uint32_t hint, bool hint_valid)
  60{
  61        return p->load_mapping(p, oblock, cblock, dirty, hint, hint_valid);
  62}
  63
  64static inline int policy_invalidate_mapping(struct dm_cache_policy *p,
  65                                            dm_cblock_t cblock)
  66{
  67        return p->invalidate_mapping(p, cblock);
  68}
  69
  70static inline uint32_t policy_get_hint(struct dm_cache_policy *p,
  71                                       dm_cblock_t cblock)
  72{
  73        return p->get_hint ? p->get_hint(p, cblock) : 0;
  74}
  75
  76static inline dm_cblock_t policy_residency(struct dm_cache_policy *p)
  77{
  78        return p->residency(p);
  79}
  80
  81static inline void policy_tick(struct dm_cache_policy *p, bool can_block)
  82{
  83        if (p->tick)
  84                return p->tick(p, can_block);
  85}
  86
  87static inline int policy_emit_config_values(struct dm_cache_policy *p, char *result,
  88                                            unsigned maxlen, ssize_t *sz_ptr)
  89{
  90        ssize_t sz = *sz_ptr;
  91        if (p->emit_config_values)
  92                return p->emit_config_values(p, result, maxlen, sz_ptr);
  93
  94        DMEMIT("0 ");
  95        *sz_ptr = sz;
  96        return 0;
  97}
  98
  99static inline int policy_set_config_value(struct dm_cache_policy *p,
 100                                          const char *key, const char *value)
 101{
 102        return p->set_config_value ? p->set_config_value(p, key, value) : -EINVAL;
 103}
 104
 105static inline void policy_allow_migrations(struct dm_cache_policy *p, bool allow)
 106{
 107        return p->allow_migrations(p, allow);
 108}
 109
 110/*----------------------------------------------------------------*/
 111
 112/*
 113 * Some utility functions commonly used by policies and the core target.
 114 */
 115static inline size_t bitset_size_in_bytes(unsigned nr_entries)
 116{
 117        return sizeof(unsigned long) * dm_div_up(nr_entries, BITS_PER_LONG);
 118}
 119
 120static inline unsigned long *alloc_bitset(unsigned nr_entries)
 121{
 122        size_t s = bitset_size_in_bytes(nr_entries);
 123        return vzalloc(s);
 124}
 125
 126static inline void clear_bitset(void *bitset, unsigned nr_entries)
 127{
 128        size_t s = bitset_size_in_bytes(nr_entries);
 129        memset(bitset, 0, s);
 130}
 131
 132static inline void free_bitset(unsigned long *bits)
 133{
 134        vfree(bits);
 135}
 136
 137/*----------------------------------------------------------------*/
 138
 139/*
 140 * Creates a new cache policy given a policy name, a cache size, an origin size and the block size.
 141 */
 142struct dm_cache_policy *dm_cache_policy_create(const char *name, dm_cblock_t cache_size,
 143                                               sector_t origin_size, sector_t block_size);
 144
 145/*
 146 * Destroys the policy.  This drops references to the policy module as well
 147 * as calling it's destroy method.  So always use this rather than calling
 148 * the policy->destroy method directly.
 149 */
 150void dm_cache_policy_destroy(struct dm_cache_policy *p);
 151
 152/*
 153 * In case we've forgotten.
 154 */
 155const char *dm_cache_policy_get_name(struct dm_cache_policy *p);
 156
 157const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p);
 158
 159size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p);
 160
 161/*----------------------------------------------------------------*/
 162
 163#endif /* DM_CACHE_POLICY_INTERNAL_H */
 164