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 maxlen, ssize_t *sz_ptr) 90 { 91 ssize_t sz = *sz_ptr; 92 if (p->emit_config_values) 93 return p->emit_config_values(p, result, maxlen, sz_ptr); 94 95 DMEMIT("0 "); 96 *sz_ptr = sz; 97 return 0; 98 } 99 100 static inline int policy_set_config_value(struct dm_cache_policy *p, 101 const char *key, const char *value) 102 { 103 return p->set_config_value ? p->set_config_value(p, key, value) : -EINVAL; 104 } 105 106 static inline void policy_allow_migrations(struct dm_cache_policy *p, bool allow) 107 { 108 return p->allow_migrations(p, allow); 109 } 110 111 /*----------------------------------------------------------------*/ 112 113 /* 114 * Some utility functions commonly used by policies and the core target. 115 */ 116 static inline size_t bitset_size_in_bytes(unsigned nr_entries) 117 { 118 return sizeof(unsigned long) * dm_div_up(nr_entries, BITS_PER_LONG); 119 } 120 121 static inline unsigned long *alloc_bitset(unsigned nr_entries) 122 { 123 size_t s = bitset_size_in_bytes(nr_entries); 124 return vzalloc(s); 125 } 126 127 static inline void clear_bitset(void *bitset, unsigned nr_entries) 128 { 129 size_t s = bitset_size_in_bytes(nr_entries); 130 memset(bitset, 0, s); 131 } 132 133 static inline void free_bitset(unsigned long *bits) 134 { 135 vfree(bits); 136 } 137 138 /*----------------------------------------------------------------*/ 139 140 /* 141 * Creates a new cache policy given a policy name, a cache size, an origin size and the block size. 142 */ 143 struct dm_cache_policy *dm_cache_policy_create(const char *name, dm_cblock_t cache_size, 144 sector_t origin_size, sector_t block_size); 145 146 /* 147 * Destroys the policy. This drops references to the policy module as well 148 * as calling it's destroy method. So always use this rather than calling 149 * the policy->destroy method directly. 150 */ 151 void dm_cache_policy_destroy(struct dm_cache_policy *p); 152 153 /* 154 * In case we've forgotten. 155 */ 156 const char *dm_cache_policy_get_name(struct dm_cache_policy *p); 157 158 const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p); 159 160 size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p); 161 162 /*----------------------------------------------------------------*/ 163 164 #endif /* DM_CACHE_POLICY_INTERNAL_H */ 165