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 	    chunk_size %
178 	    (bdev_logical_block_size(dm_snap_origin(store->snap)->bdev) >> 9)) {
179 		*error = "Chunk size is not a multiple of device blocksize";
180 		return -EINVAL;
181 	}
182 
183 	if (chunk_size > INT_MAX >> SECTOR_SHIFT) {
184 		*error = "Chunk size is too high";
185 		return -EINVAL;
186 	}
187 
188 	store->chunk_size = chunk_size;
189 	store->chunk_mask = chunk_size - 1;
190 	store->chunk_shift = ffs(chunk_size) - 1;
191 
192 	return 0;
193 }
194 
195 int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
196 			      struct dm_snapshot *snap,
197 			      unsigned *args_used,
198 			      struct dm_exception_store **store)
199 {
200 	int r = 0;
201 	struct dm_exception_store_type *type = NULL;
202 	struct dm_exception_store *tmp_store;
203 	char persistent;
204 
205 	if (argc < 2) {
206 		ti->error = "Insufficient exception store arguments";
207 		return -EINVAL;
208 	}
209 
210 	tmp_store = kmalloc(sizeof(*tmp_store), GFP_KERNEL);
211 	if (!tmp_store) {
212 		ti->error = "Exception store allocation failed";
213 		return -ENOMEM;
214 	}
215 
216 	persistent = toupper(*argv[0]);
217 	if (persistent == 'P')
218 		type = get_type("P");
219 	else if (persistent == 'N')
220 		type = get_type("N");
221 	else {
222 		ti->error = "Persistent flag is not P or N";
223 		r = -EINVAL;
224 		goto bad_type;
225 	}
226 
227 	if (!type) {
228 		ti->error = "Exception store type not recognised";
229 		r = -EINVAL;
230 		goto bad_type;
231 	}
232 
233 	tmp_store->type = type;
234 	tmp_store->snap = snap;
235 
236 	r = set_chunk_size(tmp_store, argv[1], &ti->error);
237 	if (r)
238 		goto bad;
239 
240 	r = type->ctr(tmp_store, 0, NULL);
241 	if (r) {
242 		ti->error = "Exception store type constructor failed";
243 		goto bad;
244 	}
245 
246 	*args_used = 2;
247 	*store = tmp_store;
248 	return 0;
249 
250 bad:
251 	put_type(type);
252 bad_type:
253 	kfree(tmp_store);
254 	return r;
255 }
256 EXPORT_SYMBOL(dm_exception_store_create);
257 
258 void dm_exception_store_destroy(struct dm_exception_store *store)
259 {
260 	store->type->dtr(store);
261 	put_type(store->type);
262 	kfree(store);
263 }
264 EXPORT_SYMBOL(dm_exception_store_destroy);
265 
266 int dm_exception_store_init(void)
267 {
268 	int r;
269 
270 	r = dm_transient_snapshot_init();
271 	if (r) {
272 		DMERR("Unable to register transient exception store type.");
273 		goto transient_fail;
274 	}
275 
276 	r = dm_persistent_snapshot_init();
277 	if (r) {
278 		DMERR("Unable to register persistent exception store type");
279 		goto persistent_fail;
280 	}
281 
282 	return 0;
283 
284 persistent_fail:
285 	dm_persistent_snapshot_exit();
286 transient_fail:
287 	return r;
288 }
289 
290 void dm_exception_store_exit(void)
291 {
292 	dm_persistent_snapshot_exit();
293 	dm_transient_snapshot_exit();
294 }
295