drivers/md/dm-cache-policy.c

   1 /*
   2  * Copyright (C) 2012 Red Hat. All rights reserved.
   3  *
   4  * This file is released under the GPL.
   5  */
   6
   7 #include "dm-cache-policy-internal.h"
   8 #include "dm.h"
   9
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12
  13 /*----------------------------------------------------------------*/
  14
  15 #define DM_MSG_PREFIX "cache-policy"
  16
  17 static DEFINE_SPINLOCK(register_lock);
  18 static LIST_HEAD(register_list);
  19
  20 static struct dm_cache_policy_type *__find_policy(const char *name)
  21 {
  22         struct dm_cache_policy_type *t;
  23
  24         list_for_each_entry(t, &register_list, list)
  25                 if (!strcmp(t->name, name))
  26                         return t;
  27
  28         return NULL;
  29 }
  30
  31 static struct dm_cache_policy_type *__get_policy_once(const char *name)
  32 {
  33         struct dm_cache_policy_type *t = __find_policy(name);
  34
  35         if (t && !try_module_get(t->owner)) {
  36                 DMWARN("couldn't get module %s", name);
  37                 t = ERR_PTR(-EINVAL);
  38         }
  39
  40         return t;
  41 }
  42
  43 static struct dm_cache_policy_type *get_policy_once(const char *name)
  44 {
  45         struct dm_cache_policy_type *t;
  46
  47         spin_lock(&register_lock);
  48         t = __get_policy_once(name);
  49         spin_unlock(&register_lock);
  50
  51         return t;
  52 }
  53
  54 static struct dm_cache_policy_type *get_policy(const char *name)
  55 {
  56         struct dm_cache_policy_type *t;
  57
  58         t = get_policy_once(name);
  59         if (IS_ERR(t))
  60                 return NULL;
  61
  62         if (t)
  63                 return t;
  64
  65         request_module("dm-cache-%s", name);
  66
  67         t = get_policy_once(name);
  68         if (IS_ERR(t))
  69                 return NULL;
  70
  71         return t;
  72 }
  73
  74 static void put_policy(struct dm_cache_policy_type *t)
  75 {
  76         module_put(t->owner);
  77 }
  78
  79 int dm_cache_policy_register(struct dm_cache_policy_type *type)
  80 {
  81         int r;
  82
  83         /* One size fits all for now */
  84         if (type->hint_size != 0 && type->hint_size != 4) {
  85                 DMWARN("hint size must be 0 or 4 but %llu supplied.", (unsigned long long) type->hint_size);
  86                 return -EINVAL;
  87         }
  88
  89         spin_lock(&register_lock);
  90         if (__find_policy(type->name)) {
  91                 DMWARN("attempt to register policy under duplicate name %s", type->name);
  92                 r = -EINVAL;
  93         } else {
  94                 list_add(&type->list, &register_list);
  95                 r = 0;
  96         }
  97         spin_unlock(&register_lock);
  98
  99         return r;
 100 }
 101 EXPORT_SYMBOL_GPL(dm_cache_policy_register);
 102
 103 void dm_cache_policy_unregister(struct dm_cache_policy_type *type)
 104 {
 105         spin_lock(&register_lock);
 106         list_del_init(&type->list);
 107         spin_unlock(&register_lock);
 108 }
 109 EXPORT_SYMBOL_GPL(dm_cache_policy_unregister);
 110
 111 struct dm_cache_policy *dm_cache_policy_create(const char *name,
 112                                                dm_cblock_t cache_size,
 113                                                sector_t origin_size,
 114                                                sector_t cache_block_size)
 115 {
 116         struct dm_cache_policy *p = NULL;
 117         struct dm_cache_policy_type *type;
 118
 119         type = get_policy(name);
 120         if (!type) {
 121                 DMWARN("unknown policy type");
 122                 return NULL;
 123         }
 124
 125         p = type->create(cache_size, origin_size, cache_block_size);
 126         if (!p) {
 127                 put_policy(type);
 128                 return NULL;
 129         }
 130         p->private = type;
 131
 132         return p;
 133 }
 134 EXPORT_SYMBOL_GPL(dm_cache_policy_create);
 135
 136 void dm_cache_policy_destroy(struct dm_cache_policy *p)
 137 {
 138         struct dm_cache_policy_type *t = p->private;
 139
 140         p->destroy(p);
 141         put_policy(t);
 142 }
 143 EXPORT_SYMBOL_GPL(dm_cache_policy_destroy);
 144
 145 const char *dm_cache_policy_get_name(struct dm_cache_policy *p)
 146 {
 147         struct dm_cache_policy_type *t = p->private;
 148
 149         return t->name;
 150 }
 151 EXPORT_SYMBOL_GPL(dm_cache_policy_get_name);
 152
 153 const unsigned *dm_cache_policy_get_version(struct dm_cache_policy *p)
 154 {
 155         struct dm_cache_policy_type *t = p->private;
 156
 157         return t->version;
 158 }
 159 EXPORT_SYMBOL_GPL(dm_cache_policy_get_version);
 160
 161 size_t dm_cache_policy_get_hint_size(struct dm_cache_policy *p)
 162 {
 163         struct dm_cache_policy_type *t = p->private;
 164
 165         return t->hint_size;
 166 }
 167 EXPORT_SYMBOL_GPL(dm_cache_policy_get_hint_size);
 168
 169 /*----------------------------------------------------------------*/