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 "dm-cache-policy.h"
  11
  12 /*----------------------------------------------------------------*/
  13
  14 /*
  15  * Little inline functions that simplify calling the policy methods.
  16  */
  17 static inline int policy_map(struct dm_cache_policy *p, dm_oblock_t oblock,
  18                              bool can_block, bool can_migrate, bool discarded_oblock,
  19                              struct bio *bio, struct policy_locker *locker,
  20                              struct policy_result *result)
  21 {
  22         return p->map(p, oblock, can_block, can_migrate, discarded_oblock, bio, locker, result);
  23 }
  24
  25 static inline int policy_lookup(struct dm_cache_policy *p, dm_oblock_t oblock, dm_cblock_t *cblock)
  26 {
  27         BUG_ON(!p->lookup);
  28         return p->lookup(p, oblock, cblock);
  29 }
  30
  31 static inline void policy_set_dirty(struct dm_cache_policy *p, dm_oblock_t oblock)
  32 {
  33         if (p->set_dirty)
  34                 p->set_dirty(p, oblock);
  35 }
  36
  37 static inline void policy_clear_dirty(struct dm_cache_policy *p, dm_oblock_t oblock)
  38 {
  39         if (p->clear_dirty)
  40                 p->clear_dirty(p, oblock);
  41 }
  42
  43 static inline int policy_load_mapping(struct dm_cache_policy *p,
  44                                       dm_oblock_t oblock, dm_cblock_t cblock,
  45                                       uint32_t hint, bool hint_valid)
  46 {
  47         return p->load_mapping(p, oblock, cblock, hint, hint_valid);
  48 }
  49
  50 static inline int policy_walk_mappings(struct dm_cache_policy *p,
  51                                       policy_walk_fn fn, void *context)
  52 {
  53         return p->walk_mappings ? p->walk_mappings(p, fn, context) : 0;
  54 }
  55
  56 static inline int policy_writeback_work(struct dm_cache_policy *p,
  57                                         dm_oblock_t *oblock,
  58                                         dm_cblock_t *cblock)
  59 {
  60         return p->writeback_work ? p->writeback_work(p, oblock, cblock) : -ENOENT;
  61 }
  62
  63 static inline void policy_remove_mapping(struct dm_cache_policy *p, dm_oblock_t oblock)
  64 {
  65         p->remove_mapping(p, oblock);
  66 }
  67
  68 static inline int policy_remove_cblock(struct dm_cache_policy *p, dm_cblock_t cblock)
  69 {
  70         return p->remove_cblock(p, cblock);
  71 }
  72
  73 static inline void policy_force_mapping(struct dm_cache_policy *p,
  74                                         dm_oblock_t current_oblock, dm_oblock_t new_oblock)
  75 {
  76         return p->force_mapping(p, current_oblock, new_oblock);
  77 }
  78
  79 static inline dm_cblock_t policy_residency(struct dm_cache_policy *p)
  80 {
  81         return p->residency(p);
  82 }
  83
  84 static inline void policy_tick(struct dm_cache_policy *p)
  85 {
  86         if (p->tick)
  87                 return p->tick(p);
  88 }
  89
  90 static inline int policy_emit_config_values(struct dm_cache_policy *p, char *result, unsigned maxlen)
  91 {
  92         ssize_t sz = 0;
  93         if (p->emit_config_values)
  94                 return p->emit_config_values(p, result, maxlen);
  95
  96         DMEMIT("0");
  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 /*----------------------------------------------------------------*/
 107
 108 /*
 109  * Creates a new cache policy given a policy name, a cache size, an origin size and the block size.
 110  */
 111 struct dm_cache_policy *dm_cache_policy_create(const char *name, dm_cblock_t cache_size,
 112                                                sector_t origin_size, sector_t block_size);
 113
 114 /*
 115  * Destroys the policy.  This drops references to the policy module as well
 116  * as calling it's destroy method.  So always use this rather than calling
 117  * the policy->destroy method directly.
 118  */
 119 void dm_cache_policy_destroy(struct dm_cache_policy *p);
 120
 121 /*
 122  * In case we've forgotten.
 123  */
 124 const char *dm_cache_policy_get_name(struct dm_cache_policy *p);
 125
 126 const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p);
 127
 128 size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p);
 129
 130 /*----------------------------------------------------------------*/
 131
 132 #endif /* DM_CACHE_POLICY_INTERNAL_H */