1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (c) International Business Machines Corp., 2006
4 *
5 * Author: Artem Bityutskiy (Битюцкий Артём), Joern Engel
6 */
7
8 /*
9 * This is a small driver which implements fake MTD devices on top of UBI
10 * volumes. This sounds strange, but it is in fact quite useful to make
11 * MTD-oriented software (including all the legacy software) work on top of
12 * UBI.
13 *
14 * Gluebi emulates MTD devices of "MTD_UBIVOLUME" type. Their minimal I/O unit
15 * size (@mtd->writesize) is equivalent to the UBI minimal I/O unit. The
16 * eraseblock size is equivalent to the logical eraseblock size of the volume.
17 */
18
19 #include <linux/err.h>
20 #include <linux/list.h>
21 #include <linux/slab.h>
22 #include <linux/sched.h>
23 #include <linux/math64.h>
24 #include <linux/module.h>
25 #include <linux/mutex.h>
26 #include <linux/mtd/ubi.h>
27 #include <linux/mtd/mtd.h>
28 #include "ubi-media.h"
29
30 #define err_msg(fmt, ...) \
31 pr_err("gluebi (pid %d): %s: " fmt "\n", \
32 current->pid, __func__, ##__VA_ARGS__)
33
34 /**
35 * struct gluebi_device - a gluebi device description data structure.
36 * @mtd: emulated MTD device description object
37 * @refcnt: gluebi device reference count
38 * @desc: UBI volume descriptor
39 * @ubi_num: UBI device number this gluebi device works on
40 * @vol_id: ID of UBI volume this gluebi device works on
41 * @list: link in a list of gluebi devices
42 */
43 struct gluebi_device {
44 struct mtd_info mtd;
45 int refcnt;
46 struct ubi_volume_desc *desc;
47 int ubi_num;
48 int vol_id;
49 struct list_head list;
50 };
51
52 /* List of all gluebi devices */
53 static LIST_HEAD(gluebi_devices);
54 static DEFINE_MUTEX(devices_mutex);
55
56 /**
57 * find_gluebi_nolock - find a gluebi device.
58 * @ubi_num: UBI device number
59 * @vol_id: volume ID
60 *
61 * This function seraches for gluebi device corresponding to UBI device
62 * @ubi_num and UBI volume @vol_id. Returns the gluebi device description
63 * object in case of success and %NULL in case of failure. The caller has to
64 * have the &devices_mutex locked.
65 */
find_gluebi_nolock(int ubi_num,int vol_id)66 static struct gluebi_device *find_gluebi_nolock(int ubi_num, int vol_id)
67 {
68 struct gluebi_device *gluebi;
69
70 list_for_each_entry(gluebi, &gluebi_devices, list)
71 if (gluebi->ubi_num == ubi_num && gluebi->vol_id == vol_id)
72 return gluebi;
73 return NULL;
74 }
75
76 /**
77 * gluebi_get_device - get MTD device reference.
78 * @mtd: the MTD device description object
79 *
80 * This function is called every time the MTD device is being opened and
81 * implements the MTD get_device() operation. Returns zero in case of success
82 * and a negative error code in case of failure.
83 */
gluebi_get_device(struct mtd_info * mtd)84 static int gluebi_get_device(struct mtd_info *mtd)
85 {
86 struct gluebi_device *gluebi;
87 int ubi_mode = UBI_READONLY;
88
89 if (mtd->flags & MTD_WRITEABLE)
90 ubi_mode = UBI_READWRITE;
91
92 gluebi = container_of(mtd, struct gluebi_device, mtd);
93 mutex_lock(&devices_mutex);
94 if (gluebi->refcnt > 0) {
95 /*
96 * The MTD device is already referenced and this is just one
97 * more reference. MTD allows many users to open the same
98 * volume simultaneously and do not distinguish between
99 * readers/writers/exclusive/meta openers as UBI does. So we do
100 * not open the UBI volume again - just increase the reference
101 * counter and return.
102 */
103 gluebi->refcnt += 1;
104 mutex_unlock(&devices_mutex);
105 return 0;
106 }
107
108 /*
109 * This is the first reference to this UBI volume via the MTD device
110 * interface. Open the corresponding volume in read-write mode.
111 */
112 gluebi->desc = ubi_open_volume(gluebi->ubi_num, gluebi->vol_id,
113 ubi_mode);
114 if (IS_ERR(gluebi->desc)) {
115 mutex_unlock(&devices_mutex);
116 return PTR_ERR(gluebi->desc);
117 }
118 gluebi->refcnt += 1;
119 mutex_unlock(&devices_mutex);
120 return 0;
121 }
122
123 /**
124 * gluebi_put_device - put MTD device reference.
125 * @mtd: the MTD device description object
126 *
127 * This function is called every time the MTD device is being put. Returns
128 * zero in case of success and a negative error code in case of failure.
129 */
gluebi_put_device(struct mtd_info * mtd)130 static void gluebi_put_device(struct mtd_info *mtd)
131 {
132 struct gluebi_device *gluebi;
133
134 gluebi = container_of(mtd, struct gluebi_device, mtd);
135 mutex_lock(&devices_mutex);
136 gluebi->refcnt -= 1;
137 if (gluebi->refcnt == 0)
138 ubi_close_volume(gluebi->desc);
139 mutex_unlock(&devices_mutex);
140 }
141
142 /**
143 * gluebi_read - read operation of emulated MTD devices.
144 * @mtd: MTD device description object
145 * @from: absolute offset from where to read
146 * @len: how many bytes to read
147 * @retlen: count of read bytes is returned here
148 * @buf: buffer to store the read data
149 *
150 * This function returns zero in case of success and a negative error code in
151 * case of failure.
152 */
gluebi_read(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,unsigned char * buf)153 static int gluebi_read(struct mtd_info *mtd, loff_t from, size_t len,
154 size_t *retlen, unsigned char *buf)
155 {
156 int err = 0, lnum, offs, bytes_left;
157 struct gluebi_device *gluebi;
158
159 gluebi = container_of(mtd, struct gluebi_device, mtd);
160 lnum = div_u64_rem(from, mtd->erasesize, &offs);
161 bytes_left = len;
162 while (bytes_left) {
163 size_t to_read = mtd->erasesize - offs;
164
165 if (to_read > bytes_left)
166 to_read = bytes_left;
167
168 err = ubi_read(gluebi->desc, lnum, buf, offs, to_read);
169 if (err)
170 break;
171
172 lnum += 1;
173 offs = 0;
174 bytes_left -= to_read;
175 buf += to_read;
176 }
177
178 *retlen = len - bytes_left;
179 return err;
180 }
181
182 /**
183 * gluebi_write - write operation of emulated MTD devices.
184 * @mtd: MTD device description object
185 * @to: absolute offset where to write
186 * @len: how many bytes to write
187 * @retlen: count of written bytes is returned here
188 * @buf: buffer with data to write
189 *
190 * This function returns zero in case of success and a negative error code in
191 * case of failure.
192 */
gluebi_write(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)193 static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len,
194 size_t *retlen, const u_char *buf)
195 {
196 int err = 0, lnum, offs, bytes_left;
197 struct gluebi_device *gluebi;
198
199 gluebi = container_of(mtd, struct gluebi_device, mtd);
200 lnum = div_u64_rem(to, mtd->erasesize, &offs);
201
202 if (len % mtd->writesize || offs % mtd->writesize)
203 return -EINVAL;
204
205 bytes_left = len;
206 while (bytes_left) {
207 size_t to_write = mtd->erasesize - offs;
208
209 if (to_write > bytes_left)
210 to_write = bytes_left;
211
212 err = ubi_leb_write(gluebi->desc, lnum, buf, offs, to_write);
213 if (err)
214 break;
215
216 lnum += 1;
217 offs = 0;
218 bytes_left -= to_write;
219 buf += to_write;
220 }
221
222 *retlen = len - bytes_left;
223 return err;
224 }
225
226 /**
227 * gluebi_erase - erase operation of emulated MTD devices.
228 * @mtd: the MTD device description object
229 * @instr: the erase operation description
230 *
231 * This function calls the erase callback when finishes. Returns zero in case
232 * of success and a negative error code in case of failure.
233 */
gluebi_erase(struct mtd_info * mtd,struct erase_info * instr)234 static int gluebi_erase(struct mtd_info *mtd, struct erase_info *instr)
235 {
236 int err, i, lnum, count;
237 struct gluebi_device *gluebi;
238
239 if (mtd_mod_by_ws(instr->addr, mtd) || mtd_mod_by_ws(instr->len, mtd))
240 return -EINVAL;
241
242 lnum = mtd_div_by_eb(instr->addr, mtd);
243 count = mtd_div_by_eb(instr->len, mtd);
244 gluebi = container_of(mtd, struct gluebi_device, mtd);
245
246 for (i = 0; i < count - 1; i++) {
247 err = ubi_leb_unmap(gluebi->desc, lnum + i);
248 if (err)
249 goto out_err;
250 }
251 /*
252 * MTD erase operations are synchronous, so we have to make sure the
253 * physical eraseblock is wiped out.
254 *
255 * Thus, perform leb_erase instead of leb_unmap operation - leb_erase
256 * will wait for the end of operations
257 */
258 err = ubi_leb_erase(gluebi->desc, lnum + i);
259 if (err)
260 goto out_err;
261
262 return 0;
263
264 out_err:
265 instr->fail_addr = (long long)lnum * mtd->erasesize;
266 return err;
267 }
268
269 /**
270 * gluebi_create - create a gluebi device for an UBI volume.
271 * @di: UBI device description object
272 * @vi: UBI volume description object
273 *
274 * This function is called when a new UBI volume is created in order to create
275 * corresponding fake MTD device. Returns zero in case of success and a
276 * negative error code in case of failure.
277 */
gluebi_create(struct ubi_device_info * di,struct ubi_volume_info * vi)278 static int gluebi_create(struct ubi_device_info *di,
279 struct ubi_volume_info *vi)
280 {
281 struct gluebi_device *gluebi, *g;
282 struct mtd_info *mtd;
283
284 gluebi = kzalloc(sizeof(struct gluebi_device), GFP_KERNEL);
285 if (!gluebi)
286 return -ENOMEM;
287
288 mtd = &gluebi->mtd;
289 mtd->name = kmemdup(vi->name, vi->name_len + 1, GFP_KERNEL);
290 if (!mtd->name) {
291 kfree(gluebi);
292 return -ENOMEM;
293 }
294
295 gluebi->vol_id = vi->vol_id;
296 gluebi->ubi_num = vi->ubi_num;
297 mtd->type = MTD_UBIVOLUME;
298 if (!di->ro_mode)
299 mtd->flags = MTD_WRITEABLE;
300 mtd->owner = THIS_MODULE;
301 mtd->writesize = di->min_io_size;
302 mtd->erasesize = vi->usable_leb_size;
303 mtd->_read = gluebi_read;
304 mtd->_write = gluebi_write;
305 mtd->_erase = gluebi_erase;
306 mtd->_get_device = gluebi_get_device;
307 mtd->_put_device = gluebi_put_device;
308
309 /*
310 * In case of dynamic a volume, MTD device size is just volume size. In
311 * case of a static volume the size is equivalent to the amount of data
312 * bytes.
313 */
314 if (vi->vol_type == UBI_DYNAMIC_VOLUME)
315 mtd->size = (unsigned long long)vi->usable_leb_size * vi->size;
316 else
317 mtd->size = vi->used_bytes;
318
319 /* Just a sanity check - make sure this gluebi device does not exist */
320 mutex_lock(&devices_mutex);
321 g = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
322 if (g)
323 err_msg("gluebi MTD device %d form UBI device %d volume %d already exists",
324 g->mtd.index, vi->ubi_num, vi->vol_id);
325 mutex_unlock(&devices_mutex);
326
327 if (mtd_device_register(mtd, NULL, 0)) {
328 err_msg("cannot add MTD device");
329 kfree(mtd->name);
330 kfree(gluebi);
331 return -ENFILE;
332 }
333
334 mutex_lock(&devices_mutex);
335 list_add_tail(&gluebi->list, &gluebi_devices);
336 mutex_unlock(&devices_mutex);
337 return 0;
338 }
339
340 /**
341 * gluebi_remove - remove a gluebi device.
342 * @vi: UBI volume description object
343 *
344 * This function is called when an UBI volume is removed and it removes
345 * corresponding fake MTD device. Returns zero in case of success and a
346 * negative error code in case of failure.
347 */
gluebi_remove(struct ubi_volume_info * vi)348 static int gluebi_remove(struct ubi_volume_info *vi)
349 {
350 int err = 0;
351 struct mtd_info *mtd;
352 struct gluebi_device *gluebi;
353
354 mutex_lock(&devices_mutex);
355 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
356 if (!gluebi) {
357 err_msg("got remove notification for unknown UBI device %d volume %d",
358 vi->ubi_num, vi->vol_id);
359 err = -ENOENT;
360 } else if (gluebi->refcnt)
361 err = -EBUSY;
362 else
363 list_del(&gluebi->list);
364 mutex_unlock(&devices_mutex);
365 if (err)
366 return err;
367
368 mtd = &gluebi->mtd;
369 err = mtd_device_unregister(mtd);
370 if (err) {
371 err_msg("cannot remove fake MTD device %d, UBI device %d, volume %d, error %d",
372 mtd->index, gluebi->ubi_num, gluebi->vol_id, err);
373 mutex_lock(&devices_mutex);
374 list_add_tail(&gluebi->list, &gluebi_devices);
375 mutex_unlock(&devices_mutex);
376 return err;
377 }
378
379 kfree(mtd->name);
380 kfree(gluebi);
381 return 0;
382 }
383
384 /**
385 * gluebi_updated - UBI volume was updated notifier.
386 * @vi: volume info structure
387 *
388 * This function is called every time an UBI volume is updated. It does nothing
389 * if te volume @vol is dynamic, and changes MTD device size if the
390 * volume is static. This is needed because static volumes cannot be read past
391 * data they contain. This function returns zero in case of success and a
392 * negative error code in case of error.
393 */
gluebi_updated(struct ubi_volume_info * vi)394 static int gluebi_updated(struct ubi_volume_info *vi)
395 {
396 struct gluebi_device *gluebi;
397
398 mutex_lock(&devices_mutex);
399 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
400 if (!gluebi) {
401 mutex_unlock(&devices_mutex);
402 err_msg("got update notification for unknown UBI device %d volume %d",
403 vi->ubi_num, vi->vol_id);
404 return -ENOENT;
405 }
406
407 if (vi->vol_type == UBI_STATIC_VOLUME)
408 gluebi->mtd.size = vi->used_bytes;
409 mutex_unlock(&devices_mutex);
410 return 0;
411 }
412
413 /**
414 * gluebi_resized - UBI volume was re-sized notifier.
415 * @vi: volume info structure
416 *
417 * This function is called every time an UBI volume is re-size. It changes the
418 * corresponding fake MTD device size. This function returns zero in case of
419 * success and a negative error code in case of error.
420 */
gluebi_resized(struct ubi_volume_info * vi)421 static int gluebi_resized(struct ubi_volume_info *vi)
422 {
423 struct gluebi_device *gluebi;
424
425 mutex_lock(&devices_mutex);
426 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
427 if (!gluebi) {
428 mutex_unlock(&devices_mutex);
429 err_msg("got update notification for unknown UBI device %d volume %d",
430 vi->ubi_num, vi->vol_id);
431 return -ENOENT;
432 }
433 gluebi->mtd.size = vi->used_bytes;
434 mutex_unlock(&devices_mutex);
435 return 0;
436 }
437
438 /**
439 * gluebi_notify - UBI notification handler.
440 * @nb: registered notifier block
441 * @l: notification type
442 * @ns_ptr: pointer to the &struct ubi_notification object
443 */
gluebi_notify(struct notifier_block * nb,unsigned long l,void * ns_ptr)444 static int gluebi_notify(struct notifier_block *nb, unsigned long l,
445 void *ns_ptr)
446 {
447 struct ubi_notification *nt = ns_ptr;
448
449 switch (l) {
450 case UBI_VOLUME_ADDED:
451 gluebi_create(&nt->di, &nt->vi);
452 break;
453 case UBI_VOLUME_REMOVED:
454 gluebi_remove(&nt->vi);
455 break;
456 case UBI_VOLUME_RESIZED:
457 gluebi_resized(&nt->vi);
458 break;
459 case UBI_VOLUME_UPDATED:
460 gluebi_updated(&nt->vi);
461 break;
462 default:
463 break;
464 }
465 return NOTIFY_OK;
466 }
467
468 static struct notifier_block gluebi_notifier = {
469 .notifier_call = gluebi_notify,
470 };
471
ubi_gluebi_init(void)472 static int __init ubi_gluebi_init(void)
473 {
474 return ubi_register_volume_notifier(&gluebi_notifier, 0);
475 }
476
ubi_gluebi_exit(void)477 static void __exit ubi_gluebi_exit(void)
478 {
479 struct gluebi_device *gluebi, *g;
480
481 list_for_each_entry_safe(gluebi, g, &gluebi_devices, list) {
482 int err;
483 struct mtd_info *mtd = &gluebi->mtd;
484
485 err = mtd_device_unregister(mtd);
486 if (err)
487 err_msg("error %d while removing gluebi MTD device %d, UBI device %d, volume %d - ignoring",
488 err, mtd->index, gluebi->ubi_num,
489 gluebi->vol_id);
490 kfree(mtd->name);
491 kfree(gluebi);
492 }
493 ubi_unregister_volume_notifier(&gluebi_notifier);
494 }
495
496 module_init(ubi_gluebi_init);
497 module_exit(ubi_gluebi_exit);
498 MODULE_DESCRIPTION("MTD emulation layer over UBI volumes");
499 MODULE_AUTHOR("Artem Bityutskiy, Joern Engel");
500 MODULE_LICENSE("GPL");
501