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 16static 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 22static 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 35static 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 41static 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 48static inline void policy_set_dirty(struct dm_cache_policy *p, dm_cblock_t cblock) 49{ 50 p->set_dirty(p, cblock); 51} 52 53static inline void policy_clear_dirty(struct dm_cache_policy *p, dm_cblock_t cblock) 54{ 55 p->clear_dirty(p, cblock); 56} 57 58static 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 65static 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 71static 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 77static inline dm_cblock_t policy_residency(struct dm_cache_policy *p) 78{ 79 return p->residency(p); 80} 81 82static 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 88static 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 101static 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 107static 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 */ 117static 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 122static 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 129static 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 136static 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 */ 146struct 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 */ 154void dm_cache_policy_destroy(struct dm_cache_policy *p); 155 156/* 157 * In case we've forgotten. 158 */ 159const char *dm_cache_policy_get_name(struct dm_cache_policy *p); 160 161const unsigned int *dm_cache_policy_get_version(struct dm_cache_policy *p); 162 163size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p); 164 165/*----------------------------------------------------------------*/ 166 167#endif /* DM_CACHE_POLICY_INTERNAL_H */ 168