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