drivers/mtd/ubi/gluebi.c

   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         mtd->type = MTD_UBIVOLUME;
 336         if (!di->ro_mode)
 337                 mtd->flags = MTD_WRITEABLE;
 338         mtd->owner      = THIS_MODULE;
 339         mtd->writesize  = di->min_io_size;
 340         mtd->erasesize  = vi->usable_leb_size;
 341         mtd->read       = gluebi_read;
 342         mtd->write      = gluebi_write;
 343         mtd->erase      = gluebi_erase;
 344         mtd->get_device = gluebi_get_device;
 345         mtd->put_device = gluebi_put_device;
 346
 347         /*
 348          * In case of dynamic a volume, MTD device size is just volume size. In
 349          * case of a static volume the size is equivalent to the amount of data
 350          * bytes.
 351          */
 352         if (vi->vol_type == UBI_DYNAMIC_VOLUME)
 353                 mtd->size = (unsigned long long)vi->usable_leb_size * vi->size;
 354         else
 355                 mtd->size = vi->used_bytes;
 356
 357         /* Just a sanity check - make sure this gluebi device does not exist */
 358         mutex_lock(&devices_mutex);
 359         g = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
 360         if (g)
 361                 err_msg("gluebi MTD device %d form UBI device %d volume %d "
 362                         "already exists", g->mtd.index, vi->ubi_num,
 363                         vi->vol_id);
 364         mutex_unlock(&devices_mutex);
 365
 366         if (add_mtd_device(mtd)) {
 367                 err_msg("cannot add MTD device");
 368                 kfree(mtd->name);
 369                 kfree(gluebi);
 370                 return -ENFILE;
 371         }
 372
 373         mutex_lock(&devices_mutex);
 374         list_add_tail(&gluebi->list, &gluebi_devices);
 375         mutex_unlock(&devices_mutex);
 376         return 0;
 377 }
 378
 379 /**
 380  * gluebi_remove - remove a gluebi device.
 381  * @vi: UBI volume description object
 382  *
 383  * This function is called when an UBI volume is removed and it removes
 384  * corresponding fake MTD device. Returns zero in case of success and a
 385  * negative error code in case of failure.
 386  */
 387 static int gluebi_remove(struct ubi_volume_info *vi)
 388 {
 389         int err = 0;
 390         struct mtd_info *mtd;
 391         struct gluebi_device *gluebi;
 392
 393         mutex_lock(&devices_mutex);
 394         gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
 395         if (!gluebi) {
 396                 err_msg("got remove notification for unknown UBI device %d "
 397                         "volume %d", vi->ubi_num, vi->vol_id);
 398                 err = -ENOENT;
 399         } else if (gluebi->refcnt)
 400                 err = -EBUSY;
 401         else
 402                 list_del(&gluebi->list);
 403         mutex_unlock(&devices_mutex);
 404         if (err)
 405                 return err;
 406
 407         mtd = &gluebi->mtd;
 408         err = del_mtd_device(mtd);
 409         if (err) {
 410                 err_msg("cannot remove fake MTD device %d, UBI device %d, "
 411                         "volume %d, error %d", mtd->index, gluebi->ubi_num,
 412                         gluebi->vol_id, err);
 413                 mutex_lock(&devices_mutex);
 414                 list_add_tail(&gluebi->list, &gluebi_devices);
 415                 mutex_unlock(&devices_mutex);
 416                 return err;
 417         }
 418
 419         kfree(mtd->name);
 420         kfree(gluebi);
 421         return 0;
 422 }
 423
 424 /**
 425  * gluebi_updated - UBI volume was updated notifier.
 426  * @vi: volume info structure
 427  *
 428  * This function is called every time an UBI volume is updated. It does nothing
 429  * if te volume @vol is dynamic, and changes MTD device size if the
 430  * volume is static. This is needed because static volumes cannot be read past
 431  * data they contain. This function returns zero in case of success and a
 432  * negative error code in case of error.
 433  */
 434 static int gluebi_updated(struct ubi_volume_info *vi)
 435 {
 436         struct gluebi_device *gluebi;
 437
 438         mutex_lock(&devices_mutex);
 439         gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
 440         if (!gluebi) {
 441                 mutex_unlock(&devices_mutex);
 442                 err_msg("got update notification for unknown UBI device %d "
 443                         "volume %d", vi->ubi_num, vi->vol_id);
 444                 return -ENOENT;
 445         }
 446
 447         if (vi->vol_type == UBI_STATIC_VOLUME)
 448                 gluebi->mtd.size = vi->used_bytes;
 449         mutex_unlock(&devices_mutex);
 450         return 0;
 451 }
 452
 453 /**
 454  * gluebi_resized - UBI volume was re-sized notifier.
 455  * @vi: volume info structure
 456  *
 457  * This function is called every time an UBI volume is re-size. It changes the
 458  * corresponding fake MTD device size. This function returns zero in case of
 459  * success and a negative error code in case of error.
 460  */
 461 static int gluebi_resized(struct ubi_volume_info *vi)
 462 {
 463         struct gluebi_device *gluebi;
 464
 465         mutex_lock(&devices_mutex);
 466         gluebi = find_gluebi_nolock(vi->ubi_num, vi->vol_id);
 467         if (!gluebi) {
 468                 mutex_unlock(&devices_mutex);
 469                 err_msg("got update notification for unknown UBI device %d "
 470                         "volume %d", vi->ubi_num, vi->vol_id);
 471                 return -ENOENT;
 472         }
 473         gluebi->mtd.size = vi->used_bytes;
 474         mutex_unlock(&devices_mutex);
 475         return 0;
 476 }
 477
 478 /**
 479  * gluebi_notify - UBI notification handler.
 480  * @nb: registered notifier block
 481  * @l: notification type
 482  * @ptr: pointer to the &struct ubi_notification object
 483  */
 484 static int gluebi_notify(struct notifier_block *nb, unsigned long l,
 485                          void *ns_ptr)
 486 {
 487         struct ubi_notification *nt = ns_ptr;
 488
 489         switch (l) {
 490         case UBI_VOLUME_ADDED:
 491                 gluebi_create(&nt->di, &nt->vi);
 492                 break;
 493         case UBI_VOLUME_REMOVED:
 494                 gluebi_remove(&nt->vi);
 495                 break;
 496         case UBI_VOLUME_RESIZED:
 497                 gluebi_resized(&nt->vi);
 498                 break;
 499         case UBI_VOLUME_UPDATED:
 500                 gluebi_updated(&nt->vi);
 501                 break;
 502         default:
 503                 break;
 504         }
 505         return NOTIFY_OK;
 506 }
 507
 508 static struct notifier_block gluebi_notifier = {
 509         .notifier_call  = gluebi_notify,
 510 };
 511
 512 static int __init ubi_gluebi_init(void)
 513 {
 514         return ubi_register_volume_notifier(&gluebi_notifier, 0);
 515 }
 516
 517 static void __exit ubi_gluebi_exit(void)
 518 {
 519         struct gluebi_device *gluebi, *g;
 520
 521         list_for_each_entry_safe(gluebi, g, &gluebi_devices, list) {
 522                 int err;
 523                 struct mtd_info *mtd = &gluebi->mtd;
 524
 525                 err = del_mtd_device(mtd);
 526                 if (err)
 527                         err_msg("error %d while removing gluebi MTD device %d, "
 528                                 "UBI device %d, volume %d - ignoring", err,
 529                                 mtd->index, gluebi->ubi_num, gluebi->vol_id);
 530                 kfree(mtd->name);
 531                 kfree(gluebi);
 532         }
 533         ubi_unregister_volume_notifier(&gluebi_notifier);
 534 }
 535
 536 module_init(ubi_gluebi_init);
 537 module_exit(ubi_gluebi_exit);
 538 MODULE_DESCRIPTION("MTD emulation layer over UBI volumes");
 539 MODULE_AUTHOR("Artem Bityutskiy, Joern Engel");
 540 MODULE_LICENSE("GPL");