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  */
  18 static 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
  26 static 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
  32 static 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
  38 static 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
  44 static 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
  51 static inline int policy_walk_mappings(struct dm_cache_policy *p,
  52                                       policy_walk_fn fn, void *context)
  53 {
  54         return p->walk_mappings ? p->walk_mappings(p, fn, context) : 0;
  55 }
  56
  57 static 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
  65 static inline void policy_remove_mapping(struct dm_cache_policy *p, dm_oblock_t oblock)
  66 {
  67         p->remove_mapping(p, oblock);
  68 }
  69
  70 static inline int policy_remove_cblock(struct dm_cache_policy *p, dm_cblock_t cblock)
  71 {
  72         return p->remove_cblock(p, cblock);
  73 }
  74
  75 static 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
  81 static inline dm_cblock_t policy_residency(struct dm_cache_policy *p)
  82 {
  83         return p->residency(p);
  84 }
  85
  86 static 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
  92 static 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
 104 static 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  */
 115 static 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
 120 static 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
 126 static 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
 132 static 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  */
 142 struct 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  */
 150 void dm_cache_policy_destroy(struct dm_cache_policy *p);
 151
 152 /*
 153  * In case we've forgotten.
 154  */
 155 const char *dm_cache_policy_get_name(struct dm_cache_policy *p);
 156
 157 const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p);
 158
 159 size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p);
 160
 161 /*----------------------------------------------------------------*/
 162
 163 #endif /* DM_CACHE_POLICY_INTERNAL_H */