1 /* 2 * Copyright (C) 2001-2002 Sistina Software (UK) Limited. 3 * Copyright (C) 2006-2008 Red Hat GmbH 4 * 5 * This file is released under the GPL. 6 */ 7 8 #include "dm-exception-store.h" 9 10 #include <linux/ctype.h> 11 #include <linux/mm.h> 12 #include <linux/pagemap.h> 13 #include <linux/vmalloc.h> 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 17 #define DM_MSG_PREFIX "snapshot exception stores" 18 19 static LIST_HEAD(_exception_store_types); 20 static DEFINE_SPINLOCK(_lock); 21 22 static struct dm_exception_store_type *__find_exception_store_type(const char *name) 23 { 24 struct dm_exception_store_type *type; 25 26 list_for_each_entry(type, &_exception_store_types, list) 27 if (!strcmp(name, type->name)) 28 return type; 29 30 return NULL; 31 } 32 33 static struct dm_exception_store_type *_get_exception_store_type(const char *name) 34 { 35 struct dm_exception_store_type *type; 36 37 spin_lock(&_lock); 38 39 type = __find_exception_store_type(name); 40 41 if (type && !try_module_get(type->module)) 42 type = NULL; 43 44 spin_unlock(&_lock); 45 46 return type; 47 } 48 49 /* 50 * get_type 51 * @type_name 52 * 53 * Attempt to retrieve the dm_exception_store_type by name. If not already 54 * available, attempt to load the appropriate module. 55 * 56 * Exstore modules are named "dm-exstore-" followed by the 'type_name'. 57 * Modules may contain multiple types. 58 * This function will first try the module "dm-exstore-<type_name>", 59 * then truncate 'type_name' on the last '-' and try again. 60 * 61 * For example, if type_name was "clustered-shared", it would search 62 * 'dm-exstore-clustered-shared' then 'dm-exstore-clustered'. 63 * 64 * 'dm-exception-store-<type_name>' is too long of a name in my 65 * opinion, which is why I've chosen to have the files 66 * containing exception store implementations be 'dm-exstore-<type_name>'. 67 * If you want your module to be autoloaded, you will follow this 68 * naming convention. 69 * 70 * Returns: dm_exception_store_type* on success, NULL on failure 71 */ 72 static struct dm_exception_store_type *get_type(const char *type_name) 73 { 74 char *p, *type_name_dup; 75 struct dm_exception_store_type *type; 76 77 type = _get_exception_store_type(type_name); 78 if (type) 79 return type; 80 81 type_name_dup = kstrdup(type_name, GFP_KERNEL); 82 if (!type_name_dup) { 83 DMERR("No memory left to attempt load for \"%s\"", type_name); 84 return NULL; 85 } 86 87 while (request_module("dm-exstore-%s", type_name_dup) || 88 !(type = _get_exception_store_type(type_name))) { 89 p = strrchr(type_name_dup, '-'); 90 if (!p) 91 break; 92 p[0] = '\0'; 93 } 94 95 if (!type) 96 DMWARN("Module for exstore type \"%s\" not found.", type_name); 97 98 kfree(type_name_dup); 99 100 return type; 101 } 102 103 static void put_type(struct dm_exception_store_type *type) 104 { 105 spin_lock(&_lock); 106 module_put(type->module); 107 spin_unlock(&_lock); 108 } 109 110 int dm_exception_store_type_register(struct dm_exception_store_type *type) 111 { 112 int r = 0; 113 114 spin_lock(&_lock); 115 if (!__find_exception_store_type(type->name)) 116 list_add(&type->list, &_exception_store_types); 117 else 118 r = -EEXIST; 119 spin_unlock(&_lock); 120 121 return r; 122 } 123 EXPORT_SYMBOL(dm_exception_store_type_register); 124 125 int dm_exception_store_type_unregister(struct dm_exception_store_type *type) 126 { 127 spin_lock(&_lock); 128 129 if (!__find_exception_store_type(type->name)) { 130 spin_unlock(&_lock); 131 return -EINVAL; 132 } 133 134 list_del(&type->list); 135 136 spin_unlock(&_lock); 137 138 return 0; 139 } 140 EXPORT_SYMBOL(dm_exception_store_type_unregister); 141 142 static int set_chunk_size(struct dm_exception_store *store, 143 const char *chunk_size_arg, char **error) 144 { 145 unsigned chunk_size; 146 147 if (kstrtouint(chunk_size_arg, 10, &chunk_size)) { 148 *error = "Invalid chunk size"; 149 return -EINVAL; 150 } 151 152 if (!chunk_size) { 153 store->chunk_size = store->chunk_mask = store->chunk_shift = 0; 154 return 0; 155 } 156 157 return dm_exception_store_set_chunk_size(store, chunk_size, error); 158 } 159 160 int dm_exception_store_set_chunk_size(struct dm_exception_store *store, 161 unsigned chunk_size, 162 char **error) 163 { 164 /* Check chunk_size is a power of 2 */ 165 if (!is_power_of_2(chunk_size)) { 166 *error = "Chunk size is not a power of 2"; 167 return -EINVAL; 168 } 169 170 /* Validate the chunk size against the device block size */ 171 if (chunk_size % 172 (bdev_logical_block_size(dm_snap_cow(store->snap)->bdev) >> 9) || 173 chunk_size % 174 (bdev_logical_block_size(dm_snap_origin(store->snap)->bdev) >> 9)) { 175 *error = "Chunk size is not a multiple of device blocksize"; 176 return -EINVAL; 177 } 178 179 if (chunk_size > INT_MAX >> SECTOR_SHIFT) { 180 *error = "Chunk size is too high"; 181 return -EINVAL; 182 } 183 184 store->chunk_size = chunk_size; 185 store->chunk_mask = chunk_size - 1; 186 store->chunk_shift = __ffs(chunk_size); 187 188 return 0; 189 } 190 191 int dm_exception_store_create(struct dm_target *ti, int argc, char **argv, 192 struct dm_snapshot *snap, 193 unsigned *args_used, 194 struct dm_exception_store **store) 195 { 196 int r = 0; 197 struct dm_exception_store_type *type = NULL; 198 struct dm_exception_store *tmp_store; 199 char persistent; 200 201 if (argc < 2) { 202 ti->error = "Insufficient exception store arguments"; 203 return -EINVAL; 204 } 205 206 tmp_store = kzalloc(sizeof(*tmp_store), GFP_KERNEL); 207 if (!tmp_store) { 208 ti->error = "Exception store allocation failed"; 209 return -ENOMEM; 210 } 211 212 persistent = toupper(*argv[0]); 213 if (persistent == 'P') 214 type = get_type("P"); 215 else if (persistent == 'N') 216 type = get_type("N"); 217 else { 218 ti->error = "Exception store type is not P or N"; 219 r = -EINVAL; 220 goto bad_type; 221 } 222 223 if (!type) { 224 ti->error = "Exception store type not recognised"; 225 r = -EINVAL; 226 goto bad_type; 227 } 228 229 tmp_store->type = type; 230 tmp_store->snap = snap; 231 232 r = set_chunk_size(tmp_store, argv[1], &ti->error); 233 if (r) 234 goto bad; 235 236 r = type->ctr(tmp_store, (strlen(argv[0]) > 1 ? &argv[0][1] : NULL)); 237 if (r) { 238 ti->error = "Exception store type constructor failed"; 239 goto bad; 240 } 241 242 *args_used = 2; 243 *store = tmp_store; 244 return 0; 245 246 bad: 247 put_type(type); 248 bad_type: 249 kfree(tmp_store); 250 return r; 251 } 252 EXPORT_SYMBOL(dm_exception_store_create); 253 254 void dm_exception_store_destroy(struct dm_exception_store *store) 255 { 256 store->type->dtr(store); 257 put_type(store->type); 258 kfree(store); 259 } 260 EXPORT_SYMBOL(dm_exception_store_destroy); 261 262 int dm_exception_store_init(void) 263 { 264 int r; 265 266 r = dm_transient_snapshot_init(); 267 if (r) { 268 DMERR("Unable to register transient exception store type."); 269 goto transient_fail; 270 } 271 272 r = dm_persistent_snapshot_init(); 273 if (r) { 274 DMERR("Unable to register persistent exception store type"); 275 goto persistent_fail; 276 } 277 278 return 0; 279 280 persistent_fail: 281 dm_transient_snapshot_exit(); 282 transient_fail: 283 return r; 284 } 285 286 void dm_exception_store_exit(void) 287 { 288 dm_persistent_snapshot_exit(); 289 dm_transient_snapshot_exit(); 290 } 291