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