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