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 */ 164