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