blob: cb7c075f2144969d5f416d440060455ee2904933 [file] [log] [blame]
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001/*
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/*
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040022 * 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.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040026 *
27 * Gluebi emulates MTD devices of "MTD_UBIVOLUME" type. Their minimal I/O unit
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040028 * size (@mtd->writesize) is equivalent to the UBI minimal I/O unit. The
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040029 * eraseblock size is equivalent to the logical eraseblock size of the volume.
30 */
31
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040032#include <linux/err.h>
33#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040035#include <linux/sched.h>
Artem Bityutskiy3013ee32009-01-16 19:08:43 +020036#include <linux/math64.h>
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040037#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, ...) \
Artem Bityutskiye28453b2012-08-27 15:13:05 +030044 pr_err("gluebi (pid %d): %s: " fmt "\n", \
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040045 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}
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040088
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{
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +040099 struct gluebi_device *gluebi;
100 int ubi_mode = UBI_READONLY;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400101
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400102 if (!try_module_get(THIS_MODULE))
103 return -ENODEV;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400104
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400105 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) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400111 /*
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
Andrew Murray061eebb2015-08-10 12:02:09 +0100115 * readers/writers/exclusive/meta openers as UBI does. So we do
116 * not open the UBI volume again - just increase the reference
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400117 * counter and return.
118 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400119 gluebi->refcnt += 1;
120 mutex_unlock(&devices_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400121 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 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400128 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);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400137 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{
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400149 struct gluebi_device *gluebi;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400150
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400151 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);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400158}
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{
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300174 int err = 0, lnum, offs, bytes_left;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400175 struct gluebi_device *gluebi;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400176
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400177 gluebi = container_of(mtd, struct gluebi_device, mtd);
Artem Bityutskiy3013ee32009-01-16 19:08:43 +0200178 lnum = div_u64_rem(from, mtd->erasesize, &offs);
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300179 bytes_left = len;
180 while (bytes_left) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400181 size_t to_read = mtd->erasesize - offs;
182
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300183 if (to_read > bytes_left)
184 to_read = bytes_left;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400185
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400186 err = ubi_read(gluebi->desc, lnum, buf, offs, to_read);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400187 if (err)
188 break;
189
190 lnum += 1;
191 offs = 0;
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300192 bytes_left -= to_read;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400193 buf += to_read;
194 }
195
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300196 *retlen = len - bytes_left;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400197 return err;
198}
199
200/**
201 * gluebi_write - write operation of emulated MTD devices.
202 * @mtd: MTD device description object
203 * @to: absolute offset where to write
204 * @len: how many bytes to write
205 * @retlen: count of written bytes is returned here
206 * @buf: buffer with data to write
207 *
208 * This function returns zero in case of success and a negative error code in
209 * case of failure.
210 */
211static int gluebi_write(struct mtd_info *mtd, loff_t to, size_t len,
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400212 size_t *retlen, const u_char *buf)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400213{
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300214 int err = 0, lnum, offs, bytes_left;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400215 struct gluebi_device *gluebi;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400216
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400217 gluebi = container_of(mtd, struct gluebi_device, mtd);
Artem Bityutskiy3013ee32009-01-16 19:08:43 +0200218 lnum = div_u64_rem(to, mtd->erasesize, &offs);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400219
220 if (len % mtd->writesize || offs % mtd->writesize)
221 return -EINVAL;
222
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300223 bytes_left = len;
224 while (bytes_left) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400225 size_t to_write = mtd->erasesize - offs;
226
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300227 if (to_write > bytes_left)
228 to_write = bytes_left;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400229
Richard Weinbergerb36a2612012-05-14 17:55:51 +0200230 err = ubi_leb_write(gluebi->desc, lnum, buf, offs, to_write);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400231 if (err)
232 break;
233
234 lnum += 1;
235 offs = 0;
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300236 bytes_left -= to_write;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400237 buf += to_write;
238 }
239
Ezequiel Garcia41c04382012-11-19 20:35:20 -0300240 *retlen = len - bytes_left;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400241 return err;
242}
243
244/**
245 * gluebi_erase - erase operation of emulated MTD devices.
246 * @mtd: the MTD device description object
247 * @instr: the erase operation description
248 *
249 * This function calls the erase callback when finishes. Returns zero in case
250 * of success and a negative error code in case of failure.
251 */
252static int gluebi_erase(struct mtd_info *mtd, struct erase_info *instr)
253{
254 int err, i, lnum, count;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400255 struct gluebi_device *gluebi;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400256
Adrian Hunter69423d92008-12-10 13:37:21 +0000257 if (mtd_mod_by_ws(instr->addr, mtd) || mtd_mod_by_ws(instr->len, mtd))
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400258 return -EINVAL;
259
Adrian Hunter69423d92008-12-10 13:37:21 +0000260 lnum = mtd_div_by_eb(instr->addr, mtd);
261 count = mtd_div_by_eb(instr->len, mtd);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400262 gluebi = container_of(mtd, struct gluebi_device, mtd);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400263
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400264 for (i = 0; i < count - 1; i++) {
265 err = ubi_leb_unmap(gluebi->desc, lnum + i);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400266 if (err)
267 goto out_err;
268 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400269 /*
270 * MTD erase operations are synchronous, so we have to make sure the
271 * physical eraseblock is wiped out.
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400272 *
273 * Thus, perform leb_erase instead of leb_unmap operation - leb_erase
274 * will wait for the end of operations
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400275 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400276 err = ubi_leb_erase(gluebi->desc, lnum + i);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400277 if (err)
278 goto out_err;
279
Artem Bityutskiy9c9ec142008-07-18 13:19:52 +0300280 instr->state = MTD_ERASE_DONE;
281 mtd_erase_callback(instr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400282 return 0;
283
284out_err:
285 instr->state = MTD_ERASE_FAILED;
Adrian Hunter69423d92008-12-10 13:37:21 +0000286 instr->fail_addr = (long long)lnum * mtd->erasesize;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400287 return err;
288}
289
290/**
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400291 * gluebi_create - create a gluebi device for an UBI volume.
292 * @di: UBI device description object
293 * @vi: UBI volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400294 *
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400295 * This function is called when a new UBI volume is created in order to create
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400296 * corresponding fake MTD device. Returns zero in case of success and a
297 * negative error code in case of failure.
298 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400299static int gluebi_create(struct ubi_device_info *di,
300 struct ubi_volume_info *vi)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400301{
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400302 struct gluebi_device *gluebi, *g;
303 struct mtd_info *mtd;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400304
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400305 gluebi = kzalloc(sizeof(struct gluebi_device), GFP_KERNEL);
306 if (!gluebi)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400307 return -ENOMEM;
308
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400309 mtd = &gluebi->mtd;
310 mtd->name = kmemdup(vi->name, vi->name_len + 1, GFP_KERNEL);
311 if (!mtd->name) {
312 kfree(gluebi);
313 return -ENOMEM;
314 }
315
316 gluebi->vol_id = vi->vol_id;
Artem Bityutskiyc8cc4522009-07-10 16:59:36 +0300317 gluebi->ubi_num = vi->ubi_num;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400318 mtd->type = MTD_UBIVOLUME;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400319 if (!di->ro_mode)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400320 mtd->flags = MTD_WRITEABLE;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400321 mtd->owner = THIS_MODULE;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400322 mtd->writesize = di->min_io_size;
323 mtd->erasesize = vi->usable_leb_size;
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200324 mtd->_read = gluebi_read;
325 mtd->_write = gluebi_write;
326 mtd->_erase = gluebi_erase;
327 mtd->_get_device = gluebi_get_device;
328 mtd->_put_device = gluebi_put_device;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400329
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300330 /*
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400331 * In case of dynamic a volume, MTD device size is just volume size. In
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300332 * case of a static volume the size is equivalent to the amount of data
Jan Altenbergcbd8a9d2008-03-28 16:13:53 +0100333 * bytes.
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300334 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400335 if (vi->vol_type == UBI_DYNAMIC_VOLUME)
336 mtd->size = (unsigned long long)vi->usable_leb_size * vi->size;
Jan Altenbergcbd8a9d2008-03-28 16:13:53 +0100337 else
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400338 mtd->size = vi->used_bytes;
339
340 /* Just a sanity check - make sure this gluebi device does not exist */
341 mutex_lock(&devices_mutex);
342 g = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
343 if (g)
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300344 err_msg("gluebi MTD device %d form UBI device %d volume %d already exists",
345 g->mtd.index, vi->ubi_num, vi->vol_id);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400346 mutex_unlock(&devices_mutex);
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300347
Jamie Ilesee0e87b2011-05-23 10:23:40 +0100348 if (mtd_device_register(mtd, NULL, 0)) {
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400349 err_msg("cannot add MTD device");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400350 kfree(mtd->name);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400351 kfree(gluebi);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400352 return -ENFILE;
353 }
354
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400355 mutex_lock(&devices_mutex);
356 list_add_tail(&gluebi->list, &gluebi_devices);
357 mutex_unlock(&devices_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400358 return 0;
359}
360
361/**
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400362 * gluebi_remove - remove a gluebi device.
363 * @vi: UBI volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400364 *
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400365 * This function is called when an UBI volume is removed and it removes
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400366 * corresponding fake MTD device. Returns zero in case of success and a
367 * negative error code in case of failure.
368 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400369static int gluebi_remove(struct ubi_volume_info *vi)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400370{
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400371 int err = 0;
372 struct mtd_info *mtd;
373 struct gluebi_device *gluebi;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400374
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400375 mutex_lock(&devices_mutex);
376 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
377 if (!gluebi) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300378 err_msg("got remove notification for unknown UBI device %d volume %d",
379 vi->ubi_num, vi->vol_id);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400380 err = -ENOENT;
381 } else if (gluebi->refcnt)
382 err = -EBUSY;
383 else
384 list_del(&gluebi->list);
385 mutex_unlock(&devices_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400386 if (err)
387 return err;
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400388
389 mtd = &gluebi->mtd;
Jamie Ilesee0e87b2011-05-23 10:23:40 +0100390 err = mtd_device_unregister(mtd);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400391 if (err) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300392 err_msg("cannot remove fake MTD device %d, UBI device %d, volume %d, error %d",
393 mtd->index, gluebi->ubi_num, gluebi->vol_id, err);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400394 mutex_lock(&devices_mutex);
395 list_add_tail(&gluebi->list, &gluebi_devices);
396 mutex_unlock(&devices_mutex);
397 return err;
398 }
399
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400400 kfree(mtd->name);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400401 kfree(gluebi);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400402 return 0;
403}
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300404
405/**
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400406 * gluebi_updated - UBI volume was updated notifier.
407 * @vi: volume info structure
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300408 *
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400409 * This function is called every time an UBI volume is updated. It does nothing
410 * if te volume @vol is dynamic, and changes MTD device size if the
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300411 * volume is static. This is needed because static volumes cannot be read past
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400412 * data they contain. This function returns zero in case of success and a
413 * negative error code in case of error.
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300414 */
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400415static int gluebi_updated(struct ubi_volume_info *vi)
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300416{
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400417 struct gluebi_device *gluebi;
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300418
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400419 mutex_lock(&devices_mutex);
420 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
421 if (!gluebi) {
422 mutex_unlock(&devices_mutex);
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300423 err_msg("got update notification for unknown UBI device %d volume %d",
424 vi->ubi_num, vi->vol_id);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400425 return -ENOENT;
426 }
427
428 if (vi->vol_type == UBI_STATIC_VOLUME)
429 gluebi->mtd.size = vi->used_bytes;
430 mutex_unlock(&devices_mutex);
431 return 0;
Artem Bityutskiy941dfb02007-05-05 16:33:13 +0300432}
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400433
434/**
435 * gluebi_resized - UBI volume was re-sized notifier.
436 * @vi: volume info structure
437 *
438 * This function is called every time an UBI volume is re-size. It changes the
439 * corresponding fake MTD device size. This function returns zero in case of
440 * success and a negative error code in case of error.
441 */
442static int gluebi_resized(struct ubi_volume_info *vi)
443{
444 struct gluebi_device *gluebi;
445
446 mutex_lock(&devices_mutex);
447 gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
448 if (!gluebi) {
449 mutex_unlock(&devices_mutex);
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300450 err_msg("got update notification for unknown UBI device %d volume %d",
451 vi->ubi_num, vi->vol_id);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400452 return -ENOENT;
453 }
454 gluebi->mtd.size = vi->used_bytes;
455 mutex_unlock(&devices_mutex);
456 return 0;
457}
458
459/**
460 * gluebi_notify - UBI notification handler.
461 * @nb: registered notifier block
462 * @l: notification type
463 * @ptr: pointer to the &struct ubi_notification object
464 */
465static int gluebi_notify(struct notifier_block *nb, unsigned long l,
466 void *ns_ptr)
467{
468 struct ubi_notification *nt = ns_ptr;
469
470 switch (l) {
471 case UBI_VOLUME_ADDED:
472 gluebi_create(&nt->di, &nt->vi);
473 break;
474 case UBI_VOLUME_REMOVED:
475 gluebi_remove(&nt->vi);
476 break;
477 case UBI_VOLUME_RESIZED:
478 gluebi_resized(&nt->vi);
479 break;
480 case UBI_VOLUME_UPDATED:
481 gluebi_updated(&nt->vi);
482 break;
483 default:
484 break;
485 }
486 return NOTIFY_OK;
487}
488
489static struct notifier_block gluebi_notifier = {
490 .notifier_call = gluebi_notify,
491};
492
493static int __init ubi_gluebi_init(void)
494{
495 return ubi_register_volume_notifier(&gluebi_notifier, 0);
496}
497
498static void __exit ubi_gluebi_exit(void)
499{
500 struct gluebi_device *gluebi, *g;
501
502 list_for_each_entry_safe(gluebi, g, &gluebi_devices, list) {
503 int err;
504 struct mtd_info *mtd = &gluebi->mtd;
505
Jamie Ilesee0e87b2011-05-23 10:23:40 +0100506 err = mtd_device_unregister(mtd);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400507 if (err)
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300508 err_msg("error %d while removing gluebi MTD device %d, UBI device %d, volume %d - ignoring",
509 err, mtd->index, gluebi->ubi_num,
510 gluebi->vol_id);
Dmitry Pervushin2ba3d762009-05-31 18:32:59 +0400511 kfree(mtd->name);
512 kfree(gluebi);
513 }
514 ubi_unregister_volume_notifier(&gluebi_notifier);
515}
516
517module_init(ubi_gluebi_init);
518module_exit(ubi_gluebi_exit);
519MODULE_DESCRIPTION("MTD emulation layer over UBI volumes");
520MODULE_AUTHOR("Artem Bityutskiy, Joern Engel");
521MODULE_LICENSE("GPL");