SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/mtd/ubi/eba.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 (Битюцкий Артём)
  19  */
  20
  21 /*
  22  * The UBI Eraseblock Association (EBA) unit.
  23  *
  24  * This unit is responsible for I/O to/from logical eraseblock.
  25  *
  26  * Although in this implementation the EBA table is fully kept and managed in
  27  * RAM, which assumes poor scalability, it might be (partially) maintained on
  28  * flash in future implementations.
  29  *
  30  * The EBA unit implements per-logical eraseblock locking. Before accessing a
  31  * logical eraseblock it is locked for reading or writing. The per-logical
  32  * eraseblock locking is implemented by means of the lock tree. The lock tree
  33  * is an RB-tree which refers all the currently locked logical eraseblocks. The
  34  * lock tree elements are &struct ubi_ltree_entry objects. They are indexed by
  35  * (@vol_id, @lnum) pairs.
  36  *
  37  * EBA also maintains the global sequence counter which is incremented each
  38  * time a logical eraseblock is mapped to a physical eraseblock and it is
  39  * stored in the volume identifier header. This means that each VID header has
  40  * a unique sequence number. The sequence number is only increased an we assume
  41  * 64 bits is enough to never overflow.
  42  */
  43
  44 #include <linux/slab.h>
  45 #include <linux/crc32.h>
  46 #include <linux/err.h>
  47 #include "ubi.h"
  48
  49 /* Number of physical eraseblocks reserved for atomic LEB change operation */
  50 #define EBA_RESERVED_PEBS 1
  51
  52 /**
  53  * next_sqnum - get next sequence number.
  54  * @ubi: UBI device description object
  55  *
  56  * This function returns next sequence number to use, which is just the current
  57  * global sequence counter value. It also increases the global sequence
  58  * counter.
  59  */
  60 static unsigned long long next_sqnum(struct ubi_device *ubi)
  61 {
  62         unsigned long long sqnum;
  63
  64         spin_lock(&ubi->ltree_lock);
  65         sqnum = ubi->global_sqnum++;
  66         spin_unlock(&ubi->ltree_lock);
  67
  68         return sqnum;
  69 }
  70
  71 /**
  72  * ubi_get_compat - get compatibility flags of a volume.
  73  * @ubi: UBI device description object
  74  * @vol_id: volume ID
  75  *
  76  * This function returns compatibility flags for an internal volume. User
  77  * volumes have no compatibility flags, so %0 is returned.
  78  */
  79 static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
  80 {
  81         if (vol_id == UBI_LAYOUT_VOL_ID)
  82                 return UBI_LAYOUT_VOLUME_COMPAT;
  83         return 0;
  84 }
  85
  86 /**
  87  * ltree_lookup - look up the lock tree.
  88  * @ubi: UBI device description object
  89  * @vol_id: volume ID
  90  * @lnum: logical eraseblock number
  91  *
  92  * This function returns a pointer to the corresponding &struct ubi_ltree_entry
  93  * object if the logical eraseblock is locked and %NULL if it is not.
  94  * @ubi->ltree_lock has to be locked.
  95  */
  96 static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
  97                                             int lnum)
  98 {
  99         struct rb_node *p;
 100
 101         p = ubi->ltree.rb_node;
 102         while (p) {
 103                 struct ubi_ltree_entry *le;
 104
 105                 le = rb_entry(p, struct ubi_ltree_entry, rb);
 106
 107                 if (vol_id < le->vol_id)
 108                         p = p->rb_left;
 109                 else if (vol_id > le->vol_id)
 110                         p = p->rb_right;
 111                 else {
 112                         if (lnum < le->lnum)
 113                                 p = p->rb_left;
 114                         else if (lnum > le->lnum)
 115                                 p = p->rb_right;
 116                         else
 117                                 return le;
 118                 }
 119         }
 120
 121         return NULL;
 122 }
 123
 124 /**
 125  * ltree_add_entry - add new entry to the lock tree.
 126  * @ubi: UBI device description object
 127  * @vol_id: volume ID
 128  * @lnum: logical eraseblock number
 129  *
 130  * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the
 131  * lock tree. If such entry is already there, its usage counter is increased.
 132  * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation
 133  * failed.
 134  */
 135 static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
 136                                                int vol_id, int lnum)
 137 {
 138         struct ubi_ltree_entry *le, *le1, *le_free;
 139
 140         le = kmem_cache_alloc(ubi_ltree_slab, GFP_NOFS);
 141         if (!le)
 142                 return ERR_PTR(-ENOMEM);
 143
 144         le->vol_id = vol_id;
 145         le->lnum = lnum;
 146
 147         spin_lock(&ubi->ltree_lock);
 148         le1 = ltree_lookup(ubi, vol_id, lnum);
 149
 150         if (le1) {
 151                 /*
 152                  * This logical eraseblock is already locked. The newly
 153                  * allocated lock entry is not needed.
 154                  */
 155                 le_free = le;
 156                 le = le1;
 157         } else {
 158                 struct rb_node **p, *parent = NULL;
 159
 160                 /*
 161                  * No lock entry, add the newly allocated one to the
 162                  * @ubi->ltree RB-tree.
 163                  */
 164                 le_free = NULL;
 165
 166                 p = &ubi->ltree.rb_node;
 167                 while (*p) {
 168                         parent = *p;
 169                         le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
 170
 171                         if (vol_id < le1->vol_id)
 172                                 p = &(*p)->rb_left;
 173                         else if (vol_id > le1->vol_id)
 174                                 p = &(*p)->rb_right;
 175                         else {
 176                                 ubi_assert(lnum != le1->lnum);
 177                                 if (lnum < le1->lnum)
 178                                         p = &(*p)->rb_left;
 179                                 else
 180                                         p = &(*p)->rb_right;
 181                         }
 182                 }
 183
 184                 rb_link_node(&le->rb, parent, p);
 185                 rb_insert_color(&le->rb, &ubi->ltree);
 186         }
 187         le->users += 1;
 188         spin_unlock(&ubi->ltree_lock);
 189
 190         if (le_free)
 191                 kmem_cache_free(ubi_ltree_slab, le_free);
 192
 193         return le;
 194 }
 195
 196 /**
 197  * leb_read_lock - lock logical eraseblock for reading.
 198  * @ubi: UBI device description object
 199  * @vol_id: volume ID
 200  * @lnum: logical eraseblock number
 201  *
 202  * This function locks a logical eraseblock for reading. Returns zero in case
 203  * of success and a negative error code in case of failure.
 204  */
 205 static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
 206 {
 207         struct ubi_ltree_entry *le;
 208
 209         le = ltree_add_entry(ubi, vol_id, lnum);
 210         if (IS_ERR(le))
 211                 return PTR_ERR(le);
 212         down_read(&le->mutex);
 213         return 0;
 214 }
 215
 216 /**
 217  * leb_read_unlock - unlock logical eraseblock.
 218  * @ubi: UBI device description object
 219  * @vol_id: volume ID
 220  * @lnum: logical eraseblock number
 221  */
 222 static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 223 {
 224         int free = 0;
 225         struct ubi_ltree_entry *le;
 226
 227         spin_lock(&ubi->ltree_lock);
 228         le = ltree_lookup(ubi, vol_id, lnum);
 229         le->users -= 1;
 230         ubi_assert(le->users >= 0);
 231         if (le->users == 0) {
 232                 rb_erase(&le->rb, &ubi->ltree);
 233                 free = 1;
 234         }
 235         spin_unlock(&ubi->ltree_lock);
 236
 237         up_read(&le->mutex);
 238         if (free)
 239                 kmem_cache_free(ubi_ltree_slab, le);
 240 }
 241
 242 /**
 243  * leb_write_lock - lock logical eraseblock for writing.
 244  * @ubi: UBI device description object
 245  * @vol_id: volume ID
 246  * @lnum: logical eraseblock number
 247  *
 248  * This function locks a logical eraseblock for writing. Returns zero in case
 249  * of success and a negative error code in case of failure.
 250  */
 251 static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
 252 {
 253         struct ubi_ltree_entry *le;
 254
 255         le = ltree_add_entry(ubi, vol_id, lnum);
 256         if (IS_ERR(le))
 257                 return PTR_ERR(le);
 258         down_write(&le->mutex);
 259         return 0;
 260 }
 261
 262 /**
 263  * leb_write_unlock - unlock logical eraseblock.
 264  * @ubi: UBI device description object
 265  * @vol_id: volume ID
 266  * @lnum: logical eraseblock number
 267  */
 268 static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
 269 {
 270         int free;
 271         struct ubi_ltree_entry *le;
 272
 273         spin_lock(&ubi->ltree_lock);
 274         le = ltree_lookup(ubi, vol_id, lnum);
 275         le->users -= 1;
 276         ubi_assert(le->users >= 0);
 277         if (le->users == 0) {
 278                 rb_erase(&le->rb, &ubi->ltree);
 279                 free = 1;
 280         } else
 281                 free = 0;
 282         spin_unlock(&ubi->ltree_lock);
 283
 284         up_write(&le->mutex);
 285         if (free)
 286                 kmem_cache_free(ubi_ltree_slab, le);
 287 }
 288
 289 /**
 290  * ubi_eba_unmap_leb - un-map logical eraseblock.
 291  * @ubi: UBI device description object
 292  * @vol: volume description object
 293  * @lnum: logical eraseblock number
 294  *
 295  * This function un-maps logical eraseblock @lnum and schedules corresponding
 296  * physical eraseblock for erasure. Returns zero in case of success and a
 297  * negative error code in case of failure.
 298  */
 299 int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
 300                       int lnum)
 301 {
 302         int err, pnum, vol_id = vol->vol_id;
 303
 304         if (ubi->ro_mode)
 305                 return -EROFS;
 306
 307         err = leb_write_lock(ubi, vol_id, lnum);
 308         if (err)
 309                 return err;
 310
 311         pnum = vol->eba_tbl[lnum];
 312         if (pnum < 0)
 313                 /* This logical eraseblock is already unmapped */
 314                 goto out_unlock;
 315
 316         dbg_eba("erase LEB %d:%d, PEB %d", vol_id, lnum, pnum);
 317
 318         vol->eba_tbl[lnum] = UBI_LEB_UNMAPPED;
 319         err = ubi_wl_put_peb(ubi, pnum, 0);
 320
 321 out_unlock:
 322         leb_write_unlock(ubi, vol_id, lnum);
 323         return err;
 324 }
 325
 326 /**
 327  * ubi_eba_read_leb - read data.
 328  * @ubi: UBI device description object
 329  * @vol: volume description object
 330  * @lnum: logical eraseblock number
 331  * @buf: buffer to store the read data
 332  * @offset: offset from where to read
 333  * @len: how many bytes to read
 334  * @check: data CRC check flag
 335  *
 336  * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF
 337  * bytes. The @check flag only makes sense for static volumes and forces
 338  * eraseblock data CRC checking.
 339  *
 340  * In case of success this function returns zero. In case of a static volume,
 341  * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be
 342  * returned for any volume type if an ECC error was detected by the MTD device
 343  * driver. Other negative error cored may be returned in case of other errors.
 344  */
 345 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
 346                      void *buf, int offset, int len, int check)
 347 {
 348         int err, pnum, scrub = 0, vol_id = vol->vol_id;
 349         struct ubi_vid_hdr *vid_hdr;
 350         uint32_t uninitialized_var(crc);
 351
 352         err = leb_read_lock(ubi, vol_id, lnum);
 353         if (err)
 354                 return err;
 355
 356         pnum = vol->eba_tbl[lnum];
 357         if (pnum < 0) {
 358                 /*
 359                  * The logical eraseblock is not mapped, fill the whole buffer
 360                  * with 0xFF bytes. The exception is static volumes for which
 361                  * it is an error to read unmapped logical eraseblocks.
 362                  */
 363                 dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",
 364                         len, offset, vol_id, lnum);
 365                 leb_read_unlock(ubi, vol_id, lnum);
 366                 ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);
 367                 memset(buf, 0xFF, len);
 368                 return 0;
 369         }
 370
 371         dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",
 372                 len, offset, vol_id, lnum, pnum);
 373
 374         if (vol->vol_type == UBI_DYNAMIC_VOLUME)
 375                 check = 0;
 376
 377 retry:
 378         if (check) {
 379                 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 380                 if (!vid_hdr) {
 381                         err = -ENOMEM;
 382                         goto out_unlock;
 383                 }
 384
 385                 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
 386                 if (err && err != UBI_IO_BITFLIPS) {
 387                         if (err > 0) {
 388                                 /*
 389                                  * The header is either absent or corrupted.
 390                                  * The former case means there is a bug -
 391                                  * switch to read-only mode just in case.
 392                                  * The latter case means a real corruption - we
 393                                  * may try to recover data. FIXME: but this is
 394                                  * not implemented.
 395                                  */
 396                                 if (err == UBI_IO_BAD_VID_HDR) {
 397                                         ubi_warn("bad VID header at PEB %d, LEB"
 398                                                  "%d:%d", pnum, vol_id, lnum);
 399                                         err = -EBADMSG;
 400                                 } else
 401                                         ubi_ro_mode(ubi);
 402                         }
 403                         goto out_free;
 404                 } else if (err == UBI_IO_BITFLIPS)
 405                         scrub = 1;
 406
 407                 ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs));
 408                 ubi_assert(len == be32_to_cpu(vid_hdr->data_size));
 409
 410                 crc = be32_to_cpu(vid_hdr->data_crc);
 411                 ubi_free_vid_hdr(ubi, vid_hdr);
 412         }
 413
 414         err = ubi_io_read_data(ubi, buf, pnum, offset, len);
 415         if (err) {
 416                 if (err == UBI_IO_BITFLIPS) {
 417                         scrub = 1;
 418                         err = 0;
 419                 } else if (err == -EBADMSG) {
 420                         if (vol->vol_type == UBI_DYNAMIC_VOLUME)
 421                                 goto out_unlock;
 422                         scrub = 1;
 423                         if (!check) {
 424                                 ubi_msg("force data checking");
 425                                 check = 1;
 426                                 goto retry;
 427                         }
 428                 } else
 429                         goto out_unlock;
 430         }
 431
 432         if (check) {
 433                 uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);
 434                 if (crc1 != crc) {
 435                         ubi_warn("CRC error: calculated %#08x, must be %#08x",
 436                                  crc1, crc);
 437                         err = -EBADMSG;
 438                         goto out_unlock;
 439                 }
 440         }
 441
 442         if (scrub)
 443                 err = ubi_wl_scrub_peb(ubi, pnum);
 444
 445         leb_read_unlock(ubi, vol_id, lnum);
 446         return err;
 447
 448 out_free:
 449         ubi_free_vid_hdr(ubi, vid_hdr);
 450 out_unlock:
 451         leb_read_unlock(ubi, vol_id, lnum);
 452         return err;
 453 }
 454
 455 /**
 456  * recover_peb - recover from write failure.
 457  * @ubi: UBI device description object
 458  * @pnum: the physical eraseblock to recover
 459  * @vol_id: volume ID
 460  * @lnum: logical eraseblock number
 461  * @buf: data which was not written because of the write failure
 462  * @offset: offset of the failed write
 463  * @len: how many bytes should have been written
 464  *
 465  * This function is called in case of a write failure and moves all good data
 466  * from the potentially bad physical eraseblock to a good physical eraseblock.
 467  * This function also writes the data which was not written due to the failure.
 468  * Returns new physical eraseblock number in case of success, and a negative
 469  * error code in case of failure.
 470  */
 471 static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
 472                        const void *buf, int offset, int len)
 473 {
 474         int err, idx = vol_id2idx(ubi, vol_id), new_pnum, data_size, tries = 0;
 475         struct ubi_volume *vol = ubi->volumes[idx];
 476         struct ubi_vid_hdr *vid_hdr;
 477
 478         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 479         if (!vid_hdr) {
 480                 return -ENOMEM;
 481         }
 482
 483         mutex_lock(&ubi->buf_mutex);
 484
 485 retry:
 486         new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
 487         if (new_pnum < 0) {
 488                 mutex_unlock(&ubi->buf_mutex);
 489                 ubi_free_vid_hdr(ubi, vid_hdr);
 490                 return new_pnum;
 491         }
 492
 493         ubi_msg("recover PEB %d, move data to PEB %d", pnum, new_pnum);
 494
 495         err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
 496         if (err && err != UBI_IO_BITFLIPS) {
 497                 if (err > 0)
 498                         err = -EIO;
 499                 goto out_put;
 500         }
 501
 502         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 503         err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
 504         if (err)
 505                 goto write_error;
 506
 507         data_size = offset + len;
 508         memset(ubi->peb_buf1 + offset, 0xFF, len);
 509
 510         /* Read everything before the area where the write failure happened */
 511         if (offset > 0) {
 512                 err = ubi_io_read_data(ubi, ubi->peb_buf1, pnum, 0, offset);
 513                 if (err && err != UBI_IO_BITFLIPS)
 514                         goto out_put;
 515         }
 516
 517         memcpy(ubi->peb_buf1 + offset, buf, len);
 518
 519         err = ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size);
 520         if (err)
 521                 goto write_error;
 522
 523         mutex_unlock(&ubi->buf_mutex);
 524         ubi_free_vid_hdr(ubi, vid_hdr);
 525
 526         vol->eba_tbl[lnum] = new_pnum;
 527         ubi_wl_put_peb(ubi, pnum, 1);
 528
 529         ubi_msg("data was successfully recovered");
 530         return 0;
 531
 532 out_put:
 533         mutex_unlock(&ubi->buf_mutex);
 534         ubi_wl_put_peb(ubi, new_pnum, 1);
 535         ubi_free_vid_hdr(ubi, vid_hdr);
 536         return err;
 537
 538 write_error:
 539         /*
 540          * Bad luck? This physical eraseblock is bad too? Crud. Let's try to
 541          * get another one.
 542          */
 543         ubi_warn("failed to write to PEB %d", new_pnum);
 544         ubi_wl_put_peb(ubi, new_pnum, 1);
 545         if (++tries > UBI_IO_RETRIES) {
 546                 mutex_unlock(&ubi->buf_mutex);
 547                 ubi_free_vid_hdr(ubi, vid_hdr);
 548                 return err;
 549         }
 550         ubi_msg("try again");
 551         goto retry;
 552 }
 553
 554 /**
 555  * ubi_eba_write_leb - write data to dynamic volume.
 556  * @ubi: UBI device description object
 557  * @vol: volume description object
 558  * @lnum: logical eraseblock number
 559  * @buf: the data to write
 560  * @offset: offset within the logical eraseblock where to write
 561  * @len: how many bytes to write
 562  * @dtype: data type
 563  *
 564  * This function writes data to logical eraseblock @lnum of a dynamic volume
 565  * @vol. Returns zero in case of success and a negative error code in case
 566  * of failure. In case of error, it is possible that something was still
 567  * written to the flash media, but may be some garbage.
 568  */
 569 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
 570                       const void *buf, int offset, int len, int dtype)
 571 {
 572         int err, pnum, tries = 0, vol_id = vol->vol_id;
 573         struct ubi_vid_hdr *vid_hdr;
 574
 575         if (ubi->ro_mode)
 576                 return -EROFS;
 577
 578         err = leb_write_lock(ubi, vol_id, lnum);
 579         if (err)
 580                 return err;
 581
 582         pnum = vol->eba_tbl[lnum];
 583         if (pnum >= 0) {
 584                 dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d",
 585                         len, offset, vol_id, lnum, pnum);
 586
 587                 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
 588                 if (err) {
 589                         ubi_warn("failed to write data to PEB %d", pnum);
 590                         if (err == -EIO && ubi->bad_allowed)
 591                                 err = recover_peb(ubi, pnum, vol_id, lnum, buf,
 592                                                   offset, len);
 593                         if (err)
 594                                 ubi_ro_mode(ubi);
 595                 }
 596                 leb_write_unlock(ubi, vol_id, lnum);
 597                 return err;
 598         }
 599
 600         /*
 601          * The logical eraseblock is not mapped. We have to get a free physical
 602          * eraseblock and write the volume identifier header there first.
 603          */
 604         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 605         if (!vid_hdr) {
 606                 leb_write_unlock(ubi, vol_id, lnum);
 607                 return -ENOMEM;
 608         }
 609
 610         vid_hdr->vol_type = UBI_VID_DYNAMIC;
 611         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 612         vid_hdr->vol_id = cpu_to_be32(vol_id);
 613         vid_hdr->lnum = cpu_to_be32(lnum);
 614         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
 615         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
 616
 617 retry:
 618         pnum = ubi_wl_get_peb(ubi, dtype);
 619         if (pnum < 0) {
 620                 ubi_free_vid_hdr(ubi, vid_hdr);
 621                 leb_write_unlock(ubi, vol_id, lnum);
 622                 return pnum;
 623         }
 624
 625         dbg_eba("write VID hdr and %d bytes at offset %d of LEB %d:%d, PEB %d",
 626                 len, offset, vol_id, lnum, pnum);
 627
 628         err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
 629         if (err) {
 630                 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
 631                          vol_id, lnum, pnum);
 632                 goto write_error;
 633         }
 634
 635         if (len) {
 636                 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
 637                 if (err) {
 638                         ubi_warn("failed to write %d bytes at offset %d of "
 639                                  "LEB %d:%d, PEB %d", len, offset, vol_id,
 640                                  lnum, pnum);
 641                         goto write_error;
 642                 }
 643         }
 644
 645         vol->eba_tbl[lnum] = pnum;
 646
 647         leb_write_unlock(ubi, vol_id, lnum);
 648         ubi_free_vid_hdr(ubi, vid_hdr);
 649         return 0;
 650
 651 write_error:
 652         if (err != -EIO || !ubi->bad_allowed) {
 653                 ubi_ro_mode(ubi);
 654                 leb_write_unlock(ubi, vol_id, lnum);
 655                 ubi_free_vid_hdr(ubi, vid_hdr);
 656                 return err;
 657         }
 658
 659         /*
 660          * Fortunately, this is the first write operation to this physical
 661          * eraseblock, so just put it and request a new one. We assume that if
 662          * this physical eraseblock went bad, the erase code will handle that.
 663          */
 664         err = ubi_wl_put_peb(ubi, pnum, 1);
 665         if (err || ++tries > UBI_IO_RETRIES) {
 666                 ubi_ro_mode(ubi);
 667                 leb_write_unlock(ubi, vol_id, lnum);
 668                 ubi_free_vid_hdr(ubi, vid_hdr);
 669                 return err;
 670         }
 671
 672         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 673         ubi_msg("try another PEB");
 674         goto retry;
 675 }
 676
 677 /**
 678  * ubi_eba_write_leb_st - write data to static volume.
 679  * @ubi: UBI device description object
 680  * @vol: volume description object
 681  * @lnum: logical eraseblock number
 682  * @buf: data to write
 683  * @len: how many bytes to write
 684  * @dtype: data type
 685  * @used_ebs: how many logical eraseblocks will this volume contain
 686  *
 687  * This function writes data to logical eraseblock @lnum of static volume
 688  * @vol. The @used_ebs argument should contain total number of logical
 689  * eraseblock in this static volume.
 690  *
 691  * When writing to the last logical eraseblock, the @len argument doesn't have
 692  * to be aligned to the minimal I/O unit size. Instead, it has to be equivalent
 693  * to the real data size, although the @buf buffer has to contain the
 694  * alignment. In all other cases, @len has to be aligned.
 695  *
 696  * It is prohibited to write more then once to logical eraseblocks of static
 697  * volumes. This function returns zero in case of success and a negative error
 698  * code in case of failure.
 699  */
 700 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
 701                          int lnum, const void *buf, int len, int dtype,
 702                          int used_ebs)
 703 {
 704         int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
 705         struct ubi_vid_hdr *vid_hdr;
 706         uint32_t crc;
 707
 708         if (ubi->ro_mode)
 709                 return -EROFS;
 710
 711         if (lnum == used_ebs - 1)
 712                 /* If this is the last LEB @len may be unaligned */
 713                 len = ALIGN(data_size, ubi->min_io_size);
 714         else
 715                 ubi_assert(len % ubi->min_io_size == 0);
 716
 717         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 718         if (!vid_hdr)
 719                 return -ENOMEM;
 720
 721         err = leb_write_lock(ubi, vol_id, lnum);
 722         if (err) {
 723                 ubi_free_vid_hdr(ubi, vid_hdr);
 724                 return err;
 725         }
 726
 727         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 728         vid_hdr->vol_id = cpu_to_be32(vol_id);
 729         vid_hdr->lnum = cpu_to_be32(lnum);
 730         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
 731         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
 732
 733         crc = crc32(UBI_CRC32_INIT, buf, data_size);
 734         vid_hdr->vol_type = UBI_VID_STATIC;
 735         vid_hdr->data_size = cpu_to_be32(data_size);
 736         vid_hdr->used_ebs = cpu_to_be32(used_ebs);
 737         vid_hdr->data_crc = cpu_to_be32(crc);
 738
 739 retry:
 740         pnum = ubi_wl_get_peb(ubi, dtype);
 741         if (pnum < 0) {
 742                 ubi_free_vid_hdr(ubi, vid_hdr);
 743                 leb_write_unlock(ubi, vol_id, lnum);
 744                 return pnum;
 745         }
 746
 747         dbg_eba("write VID hdr and %d bytes at LEB %d:%d, PEB %d, used_ebs %d",
 748                 len, vol_id, lnum, pnum, used_ebs);
 749
 750         err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
 751         if (err) {
 752                 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
 753                          vol_id, lnum, pnum);
 754                 goto write_error;
 755         }
 756
 757         err = ubi_io_write_data(ubi, buf, pnum, 0, len);
 758         if (err) {
 759                 ubi_warn("failed to write %d bytes of data to PEB %d",
 760                          len, pnum);
 761                 goto write_error;
 762         }
 763
 764         ubi_assert(vol->eba_tbl[lnum] < 0);
 765         vol->eba_tbl[lnum] = pnum;
 766
 767         leb_write_unlock(ubi, vol_id, lnum);
 768         ubi_free_vid_hdr(ubi, vid_hdr);
 769         return 0;
 770
 771 write_error:
 772         if (err != -EIO || !ubi->bad_allowed) {
 773                 /*
 774                  * This flash device does not admit of bad eraseblocks or
 775                  * something nasty and unexpected happened. Switch to read-only
 776                  * mode just in case.
 777                  */
 778                 ubi_ro_mode(ubi);
 779                 leb_write_unlock(ubi, vol_id, lnum);
 780                 ubi_free_vid_hdr(ubi, vid_hdr);
 781                 return err;
 782         }
 783
 784         err = ubi_wl_put_peb(ubi, pnum, 1);
 785         if (err || ++tries > UBI_IO_RETRIES) {
 786                 ubi_ro_mode(ubi);
 787                 leb_write_unlock(ubi, vol_id, lnum);
 788                 ubi_free_vid_hdr(ubi, vid_hdr);
 789                 return err;
 790         }
 791
 792         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 793         ubi_msg("try another PEB");
 794         goto retry;
 795 }
 796
 797 /*
 798  * ubi_eba_atomic_leb_change - change logical eraseblock atomically.
 799  * @ubi: UBI device description object
 800  * @vol: volume escription object
 801  * @lnum: logical eraseblock number
 802  * @buf: data to write
 803  * @len: how many bytes to write
 804  * @dtype: data type
 805  *
 806  * This function changes the contents of a logical eraseblock atomically. @buf
 807  * has to contain new logical eraseblock data, and @len - the length of the
 808  * data, which has to be aligned. This function guarantees that in case of an
 809  * unclean reboot the old contents is preserved. Returns zero in case of
 810  * success and a negative error code in case of failure.
 811  *
 812  * UBI reserves one LEB for the "atomic LEB change" operation, so only one
 813  * LEB change may be done at a time. This is ensured by @ubi->alc_mutex.
 814  */
 815 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
 816                               int lnum, const void *buf, int len, int dtype)
 817 {
 818         int err, pnum, tries = 0, vol_id = vol->vol_id;
 819         struct ubi_vid_hdr *vid_hdr;
 820         uint32_t crc;
 821
 822         if (ubi->ro_mode)
 823                 return -EROFS;
 824
 825         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
 826         if (!vid_hdr)
 827                 return -ENOMEM;
 828
 829         mutex_lock(&ubi->alc_mutex);
 830         err = leb_write_lock(ubi, vol_id, lnum);
 831         if (err)
 832                 goto out_mutex;
 833
 834         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 835         vid_hdr->vol_id = cpu_to_be32(vol_id);
 836         vid_hdr->lnum = cpu_to_be32(lnum);
 837         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
 838         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
 839
 840         crc = crc32(UBI_CRC32_INIT, buf, len);
 841         vid_hdr->vol_type = UBI_VID_DYNAMIC;
 842         vid_hdr->data_size = cpu_to_be32(len);
 843         vid_hdr->copy_flag = 1;
 844         vid_hdr->data_crc = cpu_to_be32(crc);
 845
 846 retry:
 847         pnum = ubi_wl_get_peb(ubi, dtype);
 848         if (pnum < 0) {
 849                 err = pnum;
 850                 goto out_leb_unlock;
 851         }
 852
 853         dbg_eba("change LEB %d:%d, PEB %d, write VID hdr to PEB %d",
 854                 vol_id, lnum, vol->eba_tbl[lnum], pnum);
 855
 856         err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
 857         if (err) {
 858                 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
 859                          vol_id, lnum, pnum);
 860                 goto write_error;
 861         }
 862
 863         err = ubi_io_write_data(ubi, buf, pnum, 0, len);
 864         if (err) {
 865                 ubi_warn("failed to write %d bytes of data to PEB %d",
 866                          len, pnum);
 867                 goto write_error;
 868         }
 869
 870         if (vol->eba_tbl[lnum] >= 0) {
 871                 err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 1);
 872                 if (err)
 873                         goto out_leb_unlock;
 874         }
 875
 876         vol->eba_tbl[lnum] = pnum;
 877
 878 out_leb_unlock:
 879         leb_write_unlock(ubi, vol_id, lnum);
 880 out_mutex:
 881         mutex_unlock(&ubi->alc_mutex);
 882         ubi_free_vid_hdr(ubi, vid_hdr);
 883         return err;
 884
 885 write_error:
 886         if (err != -EIO || !ubi->bad_allowed) {
 887                 /*
 888                  * This flash device does not admit of bad eraseblocks or
 889                  * something nasty and unexpected happened. Switch to read-only
 890                  * mode just in case.
 891                  */
 892                 ubi_ro_mode(ubi);
 893                 goto out_leb_unlock;
 894         }
 895
 896         err = ubi_wl_put_peb(ubi, pnum, 1);
 897         if (err || ++tries > UBI_IO_RETRIES) {
 898                 ubi_ro_mode(ubi);
 899                 goto out_leb_unlock;
 900         }
 901
 902         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
 903         ubi_msg("try another PEB");
 904         goto retry;
 905 }
 906
 907 /**
 908  * ubi_eba_copy_leb - copy logical eraseblock.
 909  * @ubi: UBI device description object
 910  * @from: physical eraseblock number from where to copy
 911  * @to: physical eraseblock number where to copy
 912  * @vid_hdr: VID header of the @from physical eraseblock
 913  *
 914  * This function copies logical eraseblock from physical eraseblock @from to
 915  * physical eraseblock @to. The @vid_hdr buffer may be changed by this
 916  * function. Returns zero in case of success, %UBI_IO_BITFLIPS if the operation
 917  * was canceled because bit-flips were detected at the target PEB, and a
 918  * negative error code in case of failure.
 919  */
 920 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
 921                      struct ubi_vid_hdr *vid_hdr)
 922 {
 923         int err, vol_id, lnum, data_size, aldata_size, pnum, idx;
 924         struct ubi_volume *vol;
 925         uint32_t crc;
 926
 927         vol_id = be32_to_cpu(vid_hdr->vol_id);
 928         lnum = be32_to_cpu(vid_hdr->lnum);
 929
 930         dbg_eba("copy LEB %d:%d, PEB %d to PEB %d", vol_id, lnum, from, to);
 931
 932         if (vid_hdr->vol_type == UBI_VID_STATIC) {
 933                 data_size = be32_to_cpu(vid_hdr->data_size);
 934                 aldata_size = ALIGN(data_size, ubi->min_io_size);
 935         } else
 936                 data_size = aldata_size =
 937                             ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
 938
 939         /*
 940          * We do not want anybody to write to this logical eraseblock while we
 941          * are moving it, so we lock it.
 942          */
 943         err = leb_write_lock(ubi, vol_id, lnum);
 944         if (err)
 945                 return err;
 946
 947         mutex_lock(&ubi->buf_mutex);
 948
 949         /*
 950          * But the logical eraseblock might have been put by this time.
 951          * Cancel if it is true.
 952          */
 953         idx = vol_id2idx(ubi, vol_id);
 954
 955         /*
 956          * We may race with volume deletion/re-size, so we have to hold
 957          * @ubi->volumes_lock.
 958          */
 959         spin_lock(&ubi->volumes_lock);
 960         vol = ubi->volumes[idx];
 961         if (!vol) {
 962                 dbg_eba("volume %d was removed meanwhile", vol_id);
 963                 spin_unlock(&ubi->volumes_lock);
 964                 goto out_unlock;
 965         }
 966
 967         pnum = vol->eba_tbl[lnum];
 968         if (pnum != from) {
 969                 dbg_eba("LEB %d:%d is no longer mapped to PEB %d, mapped to "
 970                         "PEB %d, cancel", vol_id, lnum, from, pnum);
 971                 spin_unlock(&ubi->volumes_lock);
 972                 goto out_unlock;
 973         }
 974         spin_unlock(&ubi->volumes_lock);
 975
 976         /* OK, now the LEB is locked and we can safely start moving it */
 977
 978         dbg_eba("read %d bytes of data", aldata_size);
 979         err = ubi_io_read_data(ubi, ubi->peb_buf1, from, 0, aldata_size);
 980         if (err && err != UBI_IO_BITFLIPS) {
 981                 ubi_warn("error %d while reading data from PEB %d",
 982                          err, from);
 983                 goto out_unlock;
 984         }
 985
 986         /*
 987          * Now we have got to calculate how much data we have to to copy. In
 988          * case of a static volume it is fairly easy - the VID header contains
 989          * the data size. In case of a dynamic volume it is more difficult - we
 990          * have to read the contents, cut 0xFF bytes from the end and copy only
 991          * the first part. We must do this to avoid writing 0xFF bytes as it
 992          * may have some side-effects. And not only this. It is important not
 993          * to include those 0xFFs to CRC because later the they may be filled
 994          * by data.
 995          */
 996         if (vid_hdr->vol_type == UBI_VID_DYNAMIC)
 997                 aldata_size = data_size =
 998                         ubi_calc_data_len(ubi, ubi->peb_buf1, data_size);
 999
1000         cond_resched();
1001         crc = crc32(UBI_CRC32_INIT, ubi->peb_buf1, data_size);
1002         cond_resched();
1003
1004         /*
1005          * It may turn out to me that the whole @from physical eraseblock
1006          * contains only 0xFF bytes. Then we have to only write the VID header
1007          * and do not write any data. This also means we should not set
1008          * @vid_hdr->copy_flag, @vid_hdr->data_size, and @vid_hdr->data_crc.
1009          */
1010         if (data_size > 0) {
1011                 vid_hdr->copy_flag = 1;
1012                 vid_hdr->data_size = cpu_to_be32(data_size);
1013                 vid_hdr->data_crc = cpu_to_be32(crc);
1014         }
1015         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
1016
1017         err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
1018         if (err)
1019                 goto out_unlock;
1020
1021         cond_resched();
1022
1023         /* Read the VID header back and check if it was written correctly */
1024         err = ubi_io_read_vid_hdr(ubi, to, vid_hdr, 1);
1025         if (err) {
1026                 if (err != UBI_IO_BITFLIPS)
1027                         ubi_warn("cannot read VID header back from PEB %d", to);
1028                 goto out_unlock;
1029         }
1030
1031         if (data_size > 0) {
1032                 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
1033                 if (err)
1034                         goto out_unlock;
1035
1036                 cond_resched();
1037
1038                 /*
1039                  * We've written the data and are going to read it back to make
1040                  * sure it was written correctly.
1041                  */
1042
1043                 err = ubi_io_read_data(ubi, ubi->peb_buf2, to, 0, aldata_size);
1044                 if (err) {
1045                         if (err != UBI_IO_BITFLIPS)
1046                                 ubi_warn("cannot read data back from PEB %d",
1047                                          to);
1048                         goto out_unlock;
1049                 }
1050
1051                 cond_resched();
1052
1053                 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
1054                         ubi_warn("read data back from PEB %d - it is different",
1055                                  to);
1056                         goto out_unlock;
1057                 }
1058         }
1059
1060         ubi_assert(vol->eba_tbl[lnum] == from);
1061         vol->eba_tbl[lnum] = to;
1062
1063 out_unlock:
1064         mutex_unlock(&ubi->buf_mutex);
1065         leb_write_unlock(ubi, vol_id, lnum);
1066         return err;
1067 }
1068
1069 /**
1070  * ubi_eba_init_scan - initialize the EBA unit using scanning information.
1071  * @ubi: UBI device description object
1072  * @si: scanning information
1073  *
1074  * This function returns zero in case of success and a negative error code in
1075  * case of failure.
1076  */
1077 int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
1078 {
1079         int i, j, err, num_volumes;
1080         struct ubi_scan_volume *sv;
1081         struct ubi_volume *vol;
1082         struct ubi_scan_leb *seb;
1083         struct rb_node *rb;
1084
1085         dbg_eba("initialize EBA unit");
1086
1087         spin_lock_init(&ubi->ltree_lock);
1088         mutex_init(&ubi->alc_mutex);
1089         ubi->ltree = RB_ROOT;
1090
1091         ubi->global_sqnum = si->max_sqnum + 1;
1092         num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1093
1094         for (i = 0; i < num_volumes; i++) {
1095                 vol = ubi->volumes[i];
1096                 if (!vol)
1097                         continue;
1098
1099                 cond_resched();
1100
1101                 vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int),
1102                                        GFP_KERNEL);
1103                 if (!vol->eba_tbl) {
1104                         err = -ENOMEM;
1105                         goto out_free;
1106                 }
1107
1108                 for (j = 0; j < vol->reserved_pebs; j++)
1109                         vol->eba_tbl[j] = UBI_LEB_UNMAPPED;
1110
1111                 sv = ubi_scan_find_sv(si, idx2vol_id(ubi, i));
1112                 if (!sv)
1113                         continue;
1114
1115                 ubi_rb_for_each_entry(rb, seb, &sv->root, u.rb) {
1116                         if (seb->lnum >= vol->reserved_pebs)
1117                                 /*
1118                                  * This may happen in case of an unclean reboot
1119                                  * during re-size.
1120                                  */
1121                                 ubi_scan_move_to_list(sv, seb, &si->erase);
1122                         vol->eba_tbl[seb->lnum] = seb->pnum;
1123                 }
1124         }
1125
1126         if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
1127                 ubi_err("no enough physical eraseblocks (%d, need %d)",
1128                         ubi->avail_pebs, EBA_RESERVED_PEBS);
1129                 err = -ENOSPC;
1130                 goto out_free;
1131         }
1132         ubi->avail_pebs -= EBA_RESERVED_PEBS;
1133         ubi->rsvd_pebs += EBA_RESERVED_PEBS;
1134
1135         if (ubi->bad_allowed) {
1136                 ubi_calculate_reserved(ubi);
1137
1138                 if (ubi->avail_pebs < ubi->beb_rsvd_level) {
1139                         /* No enough free physical eraseblocks */
1140                         ubi->beb_rsvd_pebs = ubi->avail_pebs;
1141                         ubi_warn("cannot reserve enough PEBs for bad PEB "
1142                                  "handling, reserved %d, need %d",
1143                                  ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
1144                 } else
1145                         ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
1146
1147                 ubi->avail_pebs -= ubi->beb_rsvd_pebs;
1148                 ubi->rsvd_pebs  += ubi->beb_rsvd_pebs;
1149         }
1150
1151         dbg_eba("EBA unit is initialized");
1152         return 0;
1153
1154 out_free:
1155         for (i = 0; i < num_volumes; i++) {
1156                 if (!ubi->volumes[i])
1157                         continue;
1158                 kfree(ubi->volumes[i]->eba_tbl);
1159         }
1160         return err;
1161 }
1162
1163 /**
1164  * ubi_eba_close - close EBA unit.
1165  * @ubi: UBI device description object
1166  */
1167 void ubi_eba_close(const struct ubi_device *ubi)
1168 {
1169         int i, num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1170
1171         dbg_eba("close EBA unit");
1172
1173         for (i = 0; i < num_volumes; i++) {
1174                 if (!ubi->volumes[i])
1175                         continue;
1176                 kfree(ubi->volumes[i]->eba_tbl);
1177         }
1178 }