Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit aadbe266f2f89ccc68b52f4effc7b3a8b29521ef

Authored by Andrei Warkentin
Committed by Alasdair G Kergon
1 parent 437538267b
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

dm exception store: fix init error path 

Call the correct exit function on failure in dm_exception_store_init.

Signed-off-by: Andrei Warkentin <andrey.warkentin@gmail.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Cc: stable@kernel.org
Signed-off-by: Alasdair G Kergon <agk@redhat.com>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

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