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

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