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
  15/*
  16 * Little inline functions that simplify calling the policy methods.
  17 */
  18static inline int policy_map(struct dm_cache_policy *p, dm_oblock_t oblock,
  19                             bool can_block, bool can_migrate, bool discarded_oblock,
  20                             struct bio *bio, struct policy_locker *locker,
  21                             struct policy_result *result)
  22{
  23        return p->map(p, oblock, can_block, can_migrate, discarded_oblock, bio, locker, result);
  24}
  25
  26static inline int policy_lookup(struct dm_cache_policy *p, dm_oblock_t oblock, dm_cblock_t *cblock)
  27{
  28        BUG_ON(!p->lookup);
  29        return p->lookup(p, oblock, cblock);
  30}
  31
  32static inline void policy_set_dirty(struct dm_cache_policy *p, dm_oblock_t oblock)
  33{
  34        if (p->set_dirty)
  35                p->set_dirty(p, oblock);
  36}
  37
  38static inline void policy_clear_dirty(struct dm_cache_policy *p, dm_oblock_t oblock)
  39{
  40        if (p->clear_dirty)
  41                p->clear_dirty(p, oblock);
  42}
  43
  44static inline int policy_load_mapping(struct dm_cache_policy *p,
  45                                      dm_oblock_t oblock, dm_cblock_t cblock,
  46                                      uint32_t hint, bool hint_valid)
  47{
  48        return p->load_mapping(p, oblock, cblock, hint, hint_valid);
  49}
  50
  51static inline uint32_t policy_get_hint(struct dm_cache_policy *p,
  52                                       dm_cblock_t cblock)
  53{
  54        return p->get_hint ? p->get_hint(p, cblock) : 0;
  55}
  56
  57static inline int policy_writeback_work(struct dm_cache_policy *p,
  58                                        dm_oblock_t *oblock,
  59                                        dm_cblock_t *cblock,
  60                                        bool critical_only)
  61{
  62        return p->writeback_work ? p->writeback_work(p, oblock, cblock, critical_only) : -ENOENT;
  63}
  64
  65static inline void policy_remove_mapping(struct dm_cache_policy *p, dm_oblock_t oblock)
  66{
  67        p->remove_mapping(p, oblock);
  68}
  69
  70static inline int policy_remove_cblock(struct dm_cache_policy *p, dm_cblock_t cblock)
  71{
  72        return p->remove_cblock(p, cblock);
  73}
  74
  75static inline void policy_force_mapping(struct dm_cache_policy *p,
  76                                        dm_oblock_t current_oblock, dm_oblock_t new_oblock)
  77{
  78        return p->force_mapping(p, current_oblock, new_oblock);
  79}
  80
  81static inline dm_cblock_t policy_residency(struct dm_cache_policy *p)
  82{
  83        return p->residency(p);
  84}
  85
  86static inline void policy_tick(struct dm_cache_policy *p, bool can_block)
  87{
  88        if (p->tick)
  89                return p->tick(p, can_block);
  90}
  91
  92static inline int policy_emit_config_values(struct dm_cache_policy *p, char *result,
  93                                            unsigned maxlen, ssize_t *sz_ptr)
  94{
  95        ssize_t sz = *sz_ptr;
  96        if (p->emit_config_values)
  97                return p->emit_config_values(p, result, maxlen, sz_ptr);
  98
  99        DMEMIT("0 ");
 100        *sz_ptr = sz;
 101        return 0;
 102}
 103
 104static inline int policy_set_config_value(struct dm_cache_policy *p,
 105                                          const char *key, const char *value)
 106{
 107        return p->set_config_value ? p->set_config_value(p, key, value) : -EINVAL;
 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