drivers/mtd/ubi/scan.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  * UBI scanning sub-system.
  23  *
  24  * This sub-system is responsible for scanning the flash media, checking UBI
  25  * headers and providing complete information about the UBI flash image.
  26  *
  27  * The scanning information is represented by a &struct ubi_scan_info' object.
  28  * Information about found volumes is represented by &struct ubi_scan_volume
  29  * objects which are kept in volume RB-tree with root at the @volumes field.
  30  * The RB-tree is indexed by the volume ID.
  31  *
  32  * Found logical eraseblocks are represented by &struct ubi_scan_leb objects.
  33  * These objects are kept in per-volume RB-trees with the root at the
  34  * corresponding &struct ubi_scan_volume object. To put it differently, we keep
  35  * an RB-tree of per-volume objects and each of these objects is the root of
  36  * RB-tree of per-eraseblock objects.
  37  *
  38  * Corrupted physical eraseblocks are put to the @corr list, free physical
  39  * eraseblocks are put to the @free list and the physical eraseblock to be
  40  * erased are put to the @erase list.
  41  */
  42
  43 #include <linux/err.h>
  44 #include <linux/crc32.h>
  45 #include <linux/math64.h>
  46 #include "ubi.h"
  47
  48 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
  49 static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si);
  50 #else
  51 #define paranoid_check_si(ubi, si) 0
  52 #endif
  53
  54 /* Temporary variables used during scanning */
  55 static struct ubi_ec_hdr *ech;
  56 static struct ubi_vid_hdr *vidh;
  57
  58 /**
  59  * add_to_list - add physical eraseblock to a list.
  60  * @si: scanning information
  61  * @pnum: physical eraseblock number to add
  62  * @ec: erase counter of the physical eraseblock
  63  * @list: the list to add to
  64  *
  65  * This function adds physical eraseblock @pnum to free, erase, corrupted or
  66  * alien lists. Returns zero in case of success and a negative error code in
  67  * case of failure.
  68  */
  69 static int add_to_list(struct ubi_scan_info *si, int pnum, int ec,
  70                        struct list_head *list)
  71 {
  72         struct ubi_scan_leb *seb;
  73
  74         if (list == &si->free)
  75                 dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
  76         else if (list == &si->erase)
  77                 dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
  78         else if (list == &si->corr) {
  79                 dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
  80                 si->corr_count += 1;
  81         } else if (list == &si->alien)
  82                 dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
  83         else
  84                 BUG();
  85
  86         seb = kmalloc(sizeof(struct ubi_scan_leb), GFP_KERNEL);
  87         if (!seb)
  88                 return -ENOMEM;
  89
  90         seb->pnum = pnum;
  91         seb->ec = ec;
  92         list_add_tail(&seb->u.list, list);
  93         return 0;
  94 }
  95
  96 /**
  97  * validate_vid_hdr - check volume identifier header.
  98  * @vid_hdr: the volume identifier header to check
  99  * @sv: information about the volume this logical eraseblock belongs to
 100  * @pnum: physical eraseblock number the VID header came from
 101  *
 102  * This function checks that data stored in @vid_hdr is consistent. Returns
 103  * non-zero if an inconsistency was found and zero if not.
 104  *
 105  * Note, UBI does sanity check of everything it reads from the flash media.
 106  * Most of the checks are done in the I/O sub-system. Here we check that the
 107  * information in the VID header is consistent to the information in other VID
 108  * headers of the same volume.
 109  */
 110 static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,
 111                             const struct ubi_scan_volume *sv, int pnum)
 112 {
 113         int vol_type = vid_hdr->vol_type;
 114         int vol_id = be32_to_cpu(vid_hdr->vol_id);
 115         int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 116         int data_pad = be32_to_cpu(vid_hdr->data_pad);
 117
 118         if (sv->leb_count != 0) {
 119                 int sv_vol_type;
 120
 121                 /*
 122                  * This is not the first logical eraseblock belonging to this
 123                  * volume. Ensure that the data in its VID header is consistent
 124                  * to the data in previous logical eraseblock headers.
 125                  */
 126
 127                 if (vol_id != sv->vol_id) {
 128                         dbg_err("inconsistent vol_id");
 129                         goto bad;
 130                 }
 131
 132                 if (sv->vol_type == UBI_STATIC_VOLUME)
 133                         sv_vol_type = UBI_VID_STATIC;
 134                 else
 135                         sv_vol_type = UBI_VID_DYNAMIC;
 136
 137                 if (vol_type != sv_vol_type) {
 138                         dbg_err("inconsistent vol_type");
 139                         goto bad;
 140                 }
 141
 142                 if (used_ebs != sv->used_ebs) {
 143                         dbg_err("inconsistent used_ebs");
 144                         goto bad;
 145                 }
 146
 147                 if (data_pad != sv->data_pad) {
 148                         dbg_err("inconsistent data_pad");
 149                         goto bad;
 150                 }
 151         }
 152
 153         return 0;
 154
 155 bad:
 156         ubi_err("inconsistent VID header at PEB %d", pnum);
 157         ubi_dbg_dump_vid_hdr(vid_hdr);
 158         ubi_dbg_dump_sv(sv);
 159         return -EINVAL;
 160 }
 161
 162 /**
 163  * add_volume - add volume to the scanning information.
 164  * @si: scanning information
 165  * @vol_id: ID of the volume to add
 166  * @pnum: physical eraseblock number
 167  * @vid_hdr: volume identifier header
 168  *
 169  * If the volume corresponding to the @vid_hdr logical eraseblock is already
 170  * present in the scanning information, this function does nothing. Otherwise
 171  * it adds corresponding volume to the scanning information. Returns a pointer
 172  * to the scanning volume object in case of success and a negative error code
 173  * in case of failure.
 174  */
 175 static struct ubi_scan_volume *add_volume(struct ubi_scan_info *si, int vol_id,
 176                                           int pnum,
 177                                           const struct ubi_vid_hdr *vid_hdr)
 178 {
 179         struct ubi_scan_volume *sv;
 180         struct rb_node **p = &si->volumes.rb_node, *parent = NULL;
 181
 182         ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));
 183
 184         /* Walk the volume RB-tree to look if this volume is already present */
 185         while (*p) {
 186                 parent = *p;
 187                 sv = rb_entry(parent, struct ubi_scan_volume, rb);
 188
 189                 if (vol_id == sv->vol_id)
 190                         return sv;
 191
 192                 if (vol_id > sv->vol_id)
 193                         p = &(*p)->rb_left;
 194                 else
 195                         p = &(*p)->rb_right;
 196         }
 197
 198         /* The volume is absent - add it */
 199         sv = kmalloc(sizeof(struct ubi_scan_volume), GFP_KERNEL);
 200         if (!sv)
 201                 return ERR_PTR(-ENOMEM);
 202
 203         sv->highest_lnum = sv->leb_count = 0;
 204         sv->vol_id = vol_id;
 205         sv->root = RB_ROOT;
 206         sv->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 207         sv->data_pad = be32_to_cpu(vid_hdr->data_pad);
 208         sv->compat = vid_hdr->compat;
 209         sv->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
 210                                                             : UBI_STATIC_VOLUME;
 211         if (vol_id > si->highest_vol_id)
 212                 si->highest_vol_id = vol_id;
 213
 214         rb_link_node(&sv->rb, parent, p);
 215         rb_insert_color(&sv->rb, &si->volumes);
 216         si->vols_found += 1;
 217         dbg_bld("added volume %d", vol_id);
 218         return sv;
 219 }
 220
 221 /**
 222  * compare_lebs - find out which logical eraseblock is newer.
 223  * @ubi: UBI device description object
 224  * @seb: first logical eraseblock to compare
 225  * @pnum: physical eraseblock number of the second logical eraseblock to
 226  * compare
 227  * @vid_hdr: volume identifier header of the second logical eraseblock
 228  *
 229  * This function compares 2 copies of a LEB and informs which one is newer. In
 230  * case of success this function returns a positive value, in case of failure, a
 231  * negative error code is returned. The success return codes use the following
 232  * bits:
 233  *     o bit 0 is cleared: the first PEB (described by @seb) is newer then the
 234  *       second PEB (described by @pnum and @vid_hdr);
 235  *     o bit 0 is set: the second PEB is newer;
 236  *     o bit 1 is cleared: no bit-flips were detected in the newer LEB;
 237  *     o bit 1 is set: bit-flips were detected in the newer LEB;
 238  *     o bit 2 is cleared: the older LEB is not corrupted;
 239  *     o bit 2 is set: the older LEB is corrupted.
 240  */
 241 static int compare_lebs(struct ubi_device *ubi, const struct ubi_scan_leb *seb,
 242                         int pnum, const struct ubi_vid_hdr *vid_hdr)
 243 {
 244         void *buf;
 245         int len, err, second_is_newer, bitflips = 0, corrupted = 0;
 246         uint32_t data_crc, crc;
 247         struct ubi_vid_hdr *vh = NULL;
 248         unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);
 249
 250         if (sqnum2 == seb->sqnum) {
 251                 /*
 252                  * This must be a really ancient UBI image which has been
 253                  * created before sequence numbers support has been added. At
 254                  * that times we used 32-bit LEB versions stored in logical
 255                  * eraseblocks. That was before UBI got into mainline. We do not
 256                  * support these images anymore. Well, those images will work
 257                  * still work, but only if no unclean reboots happened.
 258                  */
 259                 ubi_err("unsupported on-flash UBI format\n");
 260                 return -EINVAL;
 261         }
 262
 263         /* Obviously the LEB with lower sequence counter is older */
 264         second_is_newer = !!(sqnum2 > seb->sqnum);
 265
 266         /*
 267          * Now we know which copy is newer. If the copy flag of the PEB with
 268          * newer version is not set, then we just return, otherwise we have to
 269          * check data CRC. For the second PEB we already have the VID header,
 270          * for the first one - we'll need to re-read it from flash.
 271          *
 272          * Note: this may be optimized so that we wouldn't read twice.
 273          */
 274
 275         if (second_is_newer) {
 276                 if (!vid_hdr->copy_flag) {
 277                         /* It is not a copy, so it is newer */
 278                         dbg_bld("second PEB %d is newer, copy_flag is unset",
 279                                 pnum);
 280                         return 1;
 281                 }
 282         } else {
 283                 pnum = seb->pnum;
 284
 285                 vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 286                 if (!vh)
 287                         return -ENOMEM;
 288
 289                 err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
 290                 if (err) {
 291                         if (err == UBI_IO_BITFLIPS)
 292                                 bitflips = 1;
 293                         else {
 294                                 dbg_err("VID of PEB %d header is bad, but it "
 295                                         "was OK earlier", pnum);
 296                                 if (err > 0)
 297                                         err = -EIO;
 298
 299                                 goto out_free_vidh;
 300                         }
 301                 }
 302
 303                 if (!vh->copy_flag) {
 304                         /* It is not a copy, so it is newer */
 305                         dbg_bld("first PEB %d is newer, copy_flag is unset",
 306                                 pnum);
 307                         err = bitflips << 1;
 308                         goto out_free_vidh;
 309                 }
 310
 311                 vid_hdr = vh;
 312         }
 313
 314         /* Read the data of the copy and check the CRC */
 315
 316         len = be32_to_cpu(vid_hdr->data_size);
 317         buf = vmalloc(len);
 318         if (!buf) {
 319                 err = -ENOMEM;
 320                 goto out_free_vidh;
 321         }
 322
 323         err = ubi_io_read_data(ubi, buf, pnum, 0, len);
 324         if (err && err != UBI_IO_BITFLIPS && err != -EBADMSG)
 325                 goto out_free_buf;
 326
 327         data_crc = be32_to_cpu(vid_hdr->data_crc);
 328         crc = crc32(UBI_CRC32_INIT, buf, len);
 329         if (crc != data_crc) {
 330                 dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
 331                         pnum, crc, data_crc);
 332                 corrupted = 1;
 333                 bitflips = 0;
 334                 second_is_newer = !second_is_newer;
 335         } else {
 336                 dbg_bld("PEB %d CRC is OK", pnum);
 337                 bitflips = !!err;
 338         }
 339
 340         vfree(buf);
 341         ubi_free_vid_hdr(ubi, vh);
 342
 343         if (second_is_newer)
 344                 dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
 345         else
 346                 dbg_bld("first PEB %d is newer, copy_flag is set", pnum);
 347
 348         return second_is_newer | (bitflips << 1) | (corrupted << 2);
 349
 350 out_free_buf:
 351         vfree(buf);
 352 out_free_vidh:
 353         ubi_free_vid_hdr(ubi, vh);
 354         return err;
 355 }
 356
 357 /**
 358  * ubi_scan_add_used - add physical eraseblock to the scanning information.
 359  * @ubi: UBI device description object
 360  * @si: scanning information
 361  * @pnum: the physical eraseblock number
 362  * @ec: erase counter
 363  * @vid_hdr: the volume identifier header
 364  * @bitflips: if bit-flips were detected when this physical eraseblock was read
 365  *
 366  * This function adds information about a used physical eraseblock to the
 367  * 'used' tree of the corresponding volume. The function is rather complex
 368  * because it has to handle cases when this is not the first physical
 369  * eraseblock belonging to the same logical eraseblock, and the newer one has
 370  * to be picked, while the older one has to be dropped. This function returns
 371  * zero in case of success and a negative error code in case of failure.
 372  */
 373 int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,
 374                       int pnum, int ec, const struct ubi_vid_hdr *vid_hdr,
 375                       int bitflips)
 376 {
 377         int err, vol_id, lnum;
 378         unsigned long long sqnum;
 379         struct ubi_scan_volume *sv;
 380         struct ubi_scan_leb *seb;
 381         struct rb_node **p, *parent = NULL;
 382
 383         vol_id = be32_to_cpu(vid_hdr->vol_id);
 384         lnum = be32_to_cpu(vid_hdr->lnum);
 385         sqnum = be64_to_cpu(vid_hdr->sqnum);
 386
 387         dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",
 388                 pnum, vol_id, lnum, ec, sqnum, bitflips);
 389
 390         sv = add_volume(si, vol_id, pnum, vid_hdr);
 391         if (IS_ERR(sv))
 392                 return PTR_ERR(sv);
 393
 394         if (si->max_sqnum < sqnum)
 395                 si->max_sqnum = sqnum;
 396
 397         /*
 398          * Walk the RB-tree of logical eraseblocks of volume @vol_id to look
 399          * if this is the first instance of this logical eraseblock or not.
 400          */
 401         p = &sv->root.rb_node;
 402         while (*p) {
 403                 int cmp_res;
 404
 405                 parent = *p;
 406                 seb = rb_entry(parent, struct ubi_scan_leb, u.rb);
 407                 if (lnum != seb->lnum) {
 408                         if (lnum < seb->lnum)
 409                                 p = &(*p)->rb_left;
 410                         else
 411                                 p = &(*p)->rb_right;
 412                         continue;
 413                 }
 414
 415                 /*
 416                  * There is already a physical eraseblock describing the same
 417                  * logical eraseblock present.
 418                  */
 419
 420                 dbg_bld("this LEB already exists: PEB %d, sqnum %llu, "
 421                         "EC %d", seb->pnum, seb->sqnum, seb->ec);
 422
 423                 /*
 424                  * Make sure that the logical eraseblocks have different
 425                  * sequence numbers. Otherwise the image is bad.
 426                  *
 427                  * However, if the sequence number is zero, we assume it must
 428                  * be an ancient UBI image from the era when UBI did not have
 429                  * sequence numbers. We still can attach these images, unless
 430                  * there is a need to distinguish between old and new
 431                  * eraseblocks, in which case we'll refuse the image in
 432                  * 'compare_lebs()'. In other words, we attach old clean
 433                  * images, but refuse attaching old images with duplicated
 434                  * logical eraseblocks because there was an unclean reboot.
 435                  */
 436                 if (seb->sqnum == sqnum && sqnum != 0) {
 437                         ubi_err("two LEBs with same sequence number %llu",
 438                                 sqnum);
 439                         ubi_dbg_dump_seb(seb, 0);
 440                         ubi_dbg_dump_vid_hdr(vid_hdr);
 441                         return -EINVAL;
 442                 }
 443
 444                 /*
 445                  * Now we have to drop the older one and preserve the newer
 446                  * one.
 447                  */
 448                 cmp_res = compare_lebs(ubi, seb, pnum, vid_hdr);
 449                 if (cmp_res < 0)
 450                         return cmp_res;
 451
 452                 if (cmp_res & 1) {
 453                         /*
 454                          * This logical eraseblock is newer then the one
 455                          * found earlier.
 456                          */
 457                         err = validate_vid_hdr(vid_hdr, sv, pnum);
 458                         if (err)
 459                                 return err;
 460
 461                         if (cmp_res & 4)
 462                                 err = add_to_list(si, seb->pnum, seb->ec,
 463                                                   &si->corr);
 464                         else
 465                                 err = add_to_list(si, seb->pnum, seb->ec,
 466                                                   &si->erase);
 467                         if (err)
 468                                 return err;
 469
 470                         seb->ec = ec;
 471                         seb->pnum = pnum;
 472                         seb->scrub = ((cmp_res & 2) || bitflips);
 473                         seb->sqnum = sqnum;
 474
 475                         if (sv->highest_lnum == lnum)
 476                                 sv->last_data_size =
 477                                         be32_to_cpu(vid_hdr->data_size);
 478
 479                         return 0;
 480                 } else {
 481                         /*
 482                          * This logical eraseblock is older than the one found
 483                          * previously.
 484                          */
 485                         if (cmp_res & 4)
 486                                 return add_to_list(si, pnum, ec, &si->corr);
 487                         else
 488                                 return add_to_list(si, pnum, ec, &si->erase);
 489                 }
 490         }
 491
 492         /*
 493          * We've met this logical eraseblock for the first time, add it to the
 494          * scanning information.
 495          */
 496
 497         err = validate_vid_hdr(vid_hdr, sv, pnum);
 498         if (err)
 499                 return err;
 500
 501         seb = kmalloc(sizeof(struct ubi_scan_leb), GFP_KERNEL);
 502         if (!seb)
 503                 return -ENOMEM;
 504
 505         seb->ec = ec;
 506         seb->pnum = pnum;
 507         seb->lnum = lnum;
 508         seb->sqnum = sqnum;
 509         seb->scrub = bitflips;
 510
 511         if (sv->highest_lnum <= lnum) {
 512                 sv->highest_lnum = lnum;
 513                 sv->last_data_size = be32_to_cpu(vid_hdr->data_size);
 514         }
 515
 516         sv->leb_count += 1;
 517         rb_link_node(&seb->u.rb, parent, p);
 518         rb_insert_color(&seb->u.rb, &sv->root);
 519         return 0;
 520 }
 521
 522 /**
 523  * ubi_scan_find_sv - find volume in the scanning information.
 524  * @si: scanning information
 525  * @vol_id: the requested volume ID
 526  *
 527  * This function returns a pointer to the volume description or %NULL if there
 528  * are no data about this volume in the scanning information.
 529  */
 530 struct ubi_scan_volume *ubi_scan_find_sv(const struct ubi_scan_info *si,
 531                                          int vol_id)
 532 {
 533         struct ubi_scan_volume *sv;
 534         struct rb_node *p = si->volumes.rb_node;
 535
 536         while (p) {
 537                 sv = rb_entry(p, struct ubi_scan_volume, rb);
 538
 539                 if (vol_id == sv->vol_id)
 540                         return sv;
 541
 542                 if (vol_id > sv->vol_id)
 543                         p = p->rb_left;
 544                 else
 545                         p = p->rb_right;
 546         }
 547
 548         return NULL;
 549 }
 550
 551 /**
 552  * ubi_scan_find_seb - find LEB in the volume scanning information.
 553  * @sv: a pointer to the volume scanning information
 554  * @lnum: the requested logical eraseblock
 555  *
 556  * This function returns a pointer to the scanning logical eraseblock or %NULL
 557  * if there are no data about it in the scanning volume information.
 558  */
 559 struct ubi_scan_leb *ubi_scan_find_seb(const struct ubi_scan_volume *sv,
 560                                        int lnum)
 561 {
 562         struct ubi_scan_leb *seb;
 563         struct rb_node *p = sv->root.rb_node;
 564
 565         while (p) {
 566                 seb = rb_entry(p, struct ubi_scan_leb, u.rb);
 567
 568                 if (lnum == seb->lnum)
 569                         return seb;
 570
 571                 if (lnum > seb->lnum)
 572                         p = p->rb_left;
 573                 else
 574                         p = p->rb_right;
 575         }
 576
 577         return NULL;
 578 }
 579
 580 /**
 581  * ubi_scan_rm_volume - delete scanning information about a volume.
 582  * @si: scanning information
 583  * @sv: the volume scanning information to delete
 584  */
 585 void ubi_scan_rm_volume(struct ubi_scan_info *si, struct ubi_scan_volume *sv)
 586 {
 587         struct rb_node *rb;
 588         struct ubi_scan_leb *seb;
 589
 590         dbg_bld("remove scanning information about volume %d", sv->vol_id);
 591
 592         while ((rb = rb_first(&sv->root))) {
 593                 seb = rb_entry(rb, struct ubi_scan_leb, u.rb);
 594                 rb_erase(&seb->u.rb, &sv->root);
 595                 list_add_tail(&seb->u.list, &si->erase);
 596         }
 597
 598         rb_erase(&sv->rb, &si->volumes);
 599         kfree(sv);
 600         si->vols_found -= 1;
 601 }
 602
 603 /**
 604  * ubi_scan_erase_peb - erase a physical eraseblock.
 605  * @ubi: UBI device description object
 606  * @si: scanning information
 607  * @pnum: physical eraseblock number to erase;
 608  * @ec: erase counter value to write (%UBI_SCAN_UNKNOWN_EC if it is unknown)
 609  *
 610  * This function erases physical eraseblock 'pnum', and writes the erase
 611  * counter header to it. This function should only be used on UBI device
 612  * initialization stages, when the EBA sub-system had not been yet initialized.
 613  * This function returns zero in case of success and a negative error code in
 614  * case of failure.
 615  */
 616 int ubi_scan_erase_peb(struct ubi_device *ubi, const struct ubi_scan_info *si,
 617                        int pnum, int ec)
 618 {
 619         int err;
 620         struct ubi_ec_hdr *ec_hdr;
 621
 622         if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
 623                 /*
 624                  * Erase counter overflow. Upgrade UBI and use 64-bit
 625                  * erase counters internally.
 626                  */
 627                 ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec);
 628                 return -EINVAL;
 629         }
 630
 631         ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 632         if (!ec_hdr)
 633                 return -ENOMEM;
 634
 635         ec_hdr->ec = cpu_to_be64(ec);
 636
 637         err = ubi_io_sync_erase(ubi, pnum, 0);
 638         if (err < 0)
 639                 goto out_free;
 640
 641         err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
 642
 643 out_free:
 644         kfree(ec_hdr);
 645         return err;
 646 }
 647
 648 /**
 649  * ubi_scan_get_free_peb - get a free physical eraseblock.
 650  * @ubi: UBI device description object
 651  * @si: scanning information
 652  *
 653  * This function returns a free physical eraseblock. It is supposed to be
 654  * called on the UBI initialization stages when the wear-leveling sub-system is
 655  * not initialized yet. This function picks a physical eraseblocks from one of
 656  * the lists, writes the EC header if it is needed, and removes it from the
 657  * list.
 658  *
 659  * This function returns scanning physical eraseblock information in case of
 660  * success and an error code in case of failure.
 661  */
 662 struct ubi_scan_leb *ubi_scan_get_free_peb(struct ubi_device *ubi,
 663                                            struct ubi_scan_info *si)
 664 {
 665         int err = 0, i;
 666         struct ubi_scan_leb *seb;
 667
 668         if (!list_empty(&si->free)) {
 669                 seb = list_entry(si->free.next, struct ubi_scan_leb, u.list);
 670                 list_del(&seb->u.list);
 671                 dbg_bld("return free PEB %d, EC %d", seb->pnum, seb->ec);
 672                 return seb;
 673         }
 674
 675         for (i = 0; i < 2; i++) {
 676                 struct list_head *head;
 677                 struct ubi_scan_leb *tmp_seb;
 678
 679                 if (i == 0)
 680                         head = &si->erase;
 681                 else
 682                         head = &si->corr;
 683
 684                 /*
 685                  * We try to erase the first physical eraseblock from the @head
 686                  * list and pick it if we succeed, or try to erase the
 687                  * next one if not. And so forth. We don't want to take care
 688                  * about bad eraseblocks here - they'll be handled later.
 689                  */
 690                 list_for_each_entry_safe(seb, tmp_seb, head, u.list) {
 691                         if (seb->ec == UBI_SCAN_UNKNOWN_EC)
 692                                 seb->ec = si->mean_ec;
 693
 694                         err = ubi_scan_erase_peb(ubi, si, seb->pnum, seb->ec+1);
 695                         if (err)
 696                                 continue;
 697
 698                         seb->ec += 1;
 699                         list_del(&seb->u.list);
 700                         dbg_bld("return PEB %d, EC %d", seb->pnum, seb->ec);
 701                         return seb;
 702                 }
 703         }
 704
 705         ubi_err("no eraseblocks found");
 706         return ERR_PTR(-ENOSPC);
 707 }
 708
 709 /**
 710  * process_eb - read, check UBI headers, and add them to scanning information.
 711  * @ubi: UBI device description object
 712  * @si: scanning information
 713  * @pnum: the physical eraseblock number
 714  *
 715  * This function returns a zero if the physical eraseblock was successfully
 716  * handled and a negative error code in case of failure.
 717  */
 718 static int process_eb(struct ubi_device *ubi, struct ubi_scan_info *si,
 719                       int pnum)
 720 {
 721         long long uninitialized_var(ec);
 722         int err, bitflips = 0, vol_id, ec_corr = 0;
 723
 724         dbg_bld("scan PEB %d", pnum);
 725
 726         /* Skip bad physical eraseblocks */
 727         err = ubi_io_is_bad(ubi, pnum);
 728         if (err < 0)
 729                 return err;
 730         else if (err) {
 731                 /*
 732                  * FIXME: this is actually duty of the I/O sub-system to
 733                  * initialize this, but MTD does not provide enough
 734                  * information.
 735                  */
 736                 si->bad_peb_count += 1;
 737                 return 0;
 738         }
 739
 740         err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
 741         if (err < 0)
 742                 return err;
 743         else if (err == UBI_IO_BITFLIPS)
 744                 bitflips = 1;
 745         else if (err == UBI_IO_PEB_EMPTY)
 746                 return add_to_list(si, pnum, UBI_SCAN_UNKNOWN_EC, &si->erase);
 747         else if (err == UBI_IO_BAD_EC_HDR) {
 748                 /*
 749                  * We have to also look at the VID header, possibly it is not
 750                  * corrupted. Set %bitflips flag in order to make this PEB be
 751                  * moved and EC be re-created.
 752                  */
 753                 ec_corr = 1;
 754                 ec = UBI_SCAN_UNKNOWN_EC;
 755                 bitflips = 1;
 756         }
 757
 758         si->is_empty = 0;
 759
 760         if (!ec_corr) {
 761                 int image_seq;
 762
 763                 /* Make sure UBI version is OK */
 764                 if (ech->version != UBI_VERSION) {
 765                         ubi_err("this UBI version is %d, image version is %d",
 766                                 UBI_VERSION, (int)ech->version);
 767                         return -EINVAL;
 768                 }
 769
 770                 ec = be64_to_cpu(ech->ec);
 771                 if (ec > UBI_MAX_ERASECOUNTER) {
 772                         /*
 773                          * Erase counter overflow. The EC headers have 64 bits
 774                          * reserved, but we anyway make use of only 31 bit
 775                          * values, as this seems to be enough for any existing
 776                          * flash. Upgrade UBI and use 64-bit erase counters
 777                          * internally.
 778                          */
 779                         ubi_err("erase counter overflow, max is %d",
 780                                 UBI_MAX_ERASECOUNTER);
 781                         ubi_dbg_dump_ec_hdr(ech);
 782                         return -EINVAL;
 783                 }
 784
 785                 /*
 786                  * Make sure that all PEBs have the same image sequence number.
 787                  * This allows us to detect situations when users flash UBI
 788                  * images incorrectly, so that the flash has the new UBI image
 789                  * and leftovers from the old one. This feature was added
 790                  * relatively recently, and the sequence number was always
 791                  * zero, because old UBI implementations always set it to zero.
 792                  * For this reasons, we do not panic if some PEBs have zero
 793                  * sequence number, while other PEBs have non-zero sequence
 794                  * number.
 795                  */
 796                 image_seq = be32_to_cpu(ech->image_seq);
 797                 if (!si->image_seq_set) {
 798                         ubi->image_seq = image_seq;
 799                         si->image_seq_set = 1;
 800                 } else if (ubi->image_seq && ubi->image_seq != image_seq) {
 801                         ubi_err("bad image sequence number %d in PEB %d, "
 802                                 "expected %d", image_seq, pnum, ubi->image_seq);
 803                         ubi_dbg_dump_ec_hdr(ech);
 804                         return -EINVAL;
 805                 }
 806
 807         }
 808
 809         /* OK, we've done with the EC header, let's look at the VID header */
 810
 811         err = ubi_io_read_vid_hdr(ubi, pnum, vidh, 0);
 812         if (err < 0)
 813                 return err;
 814         else if (err == UBI_IO_BITFLIPS)
 815                 bitflips = 1;
 816         else if (err == UBI_IO_BAD_VID_HDR ||
 817                  (err == UBI_IO_PEB_FREE && ec_corr)) {
 818                 /* VID header is corrupted */
 819                 err = add_to_list(si, pnum, ec, &si->corr);
 820                 if (err)
 821                         return err;
 822                 goto adjust_mean_ec;
 823         } else if (err == UBI_IO_PEB_FREE) {
 824                 /* No VID header - the physical eraseblock is free */
 825                 err = add_to_list(si, pnum, ec, &si->free);
 826                 if (err)
 827                         return err;
 828                 goto adjust_mean_ec;
 829         }
 830
 831         vol_id = be32_to_cpu(vidh->vol_id);
 832         if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) {
 833                 int lnum = be32_to_cpu(vidh->lnum);
 834
 835                 /* Unsupported internal volume */
 836                 switch (vidh->compat) {
 837                 case UBI_COMPAT_DELETE:
 838                         ubi_msg("\"delete\" compatible internal volume %d:%d"
 839                                 " found, remove it", vol_id, lnum);
 840                         err = add_to_list(si, pnum, ec, &si->corr);
 841                         if (err)
 842                                 return err;
 843                         break;
 844
 845                 case UBI_COMPAT_RO:
 846                         ubi_msg("read-only compatible internal volume %d:%d"
 847                                 " found, switch to read-only mode",
 848                                 vol_id, lnum);
 849                         ubi->ro_mode = 1;
 850                         break;
 851
 852                 case UBI_COMPAT_PRESERVE:
 853                         ubi_msg("\"preserve\" compatible internal volume %d:%d"
 854                                 " found", vol_id, lnum);
 855                         err = add_to_list(si, pnum, ec, &si->alien);
 856                         if (err)
 857                                 return err;
 858                         si->alien_peb_count += 1;
 859                         return 0;
 860
 861                 case UBI_COMPAT_REJECT:
 862                         ubi_err("incompatible internal volume %d:%d found",
 863                                 vol_id, lnum);
 864                         return -EINVAL;
 865                 }
 866         }
 867
 868         if (ec_corr)
 869                 ubi_warn("valid VID header but corrupted EC header at PEB %d",
 870                          pnum);
 871         err = ubi_scan_add_used(ubi, si, pnum, ec, vidh, bitflips);
 872         if (err)
 873                 return err;
 874
 875 adjust_mean_ec:
 876         if (!ec_corr) {
 877                 si->ec_sum += ec;
 878                 si->ec_count += 1;
 879                 if (ec > si->max_ec)
 880                         si->max_ec = ec;
 881                 if (ec < si->min_ec)
 882                         si->min_ec = ec;
 883         }
 884
 885         return 0;
 886 }
 887
 888 /**
 889  * ubi_scan - scan an MTD device.
 890  * @ubi: UBI device description object
 891  *
 892  * This function does full scanning of an MTD device and returns complete
 893  * information about it. In case of failure, an error code is returned.
 894  */
 895 struct ubi_scan_info *ubi_scan(struct ubi_device *ubi)
 896 {
 897         int err, pnum;
 898         struct rb_node *rb1, *rb2;
 899         struct ubi_scan_volume *sv;
 900         struct ubi_scan_leb *seb;
 901         struct ubi_scan_info *si;
 902
 903         si = kzalloc(sizeof(struct ubi_scan_info), GFP_KERNEL);
 904         if (!si)
 905                 return ERR_PTR(-ENOMEM);
 906
 907         INIT_LIST_HEAD(&si->corr);
 908         INIT_LIST_HEAD(&si->free);
 909         INIT_LIST_HEAD(&si->erase);
 910         INIT_LIST_HEAD(&si->alien);
 911         si->volumes = RB_ROOT;
 912         si->is_empty = 1;
 913
 914         err = -ENOMEM;
 915         ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 916         if (!ech)
 917                 goto out_si;
 918
 919         vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
 920         if (!vidh)
 921                 goto out_ech;
 922
 923         for (pnum = 0; pnum < ubi->peb_count; pnum++) {
 924                 cond_resched();
 925
 926                 dbg_gen("process PEB %d", pnum);
 927                 err = process_eb(ubi, si, pnum);
 928                 if (err < 0)
 929                         goto out_vidh;
 930         }
 931
 932         dbg_msg("scanning is finished");
 933
 934         /* Calculate mean erase counter */
 935         if (si->ec_count)
 936                 si->mean_ec = div_u64(si->ec_sum, si->ec_count);
 937
 938         if (si->is_empty)
 939                 ubi_msg("empty MTD device detected");
 940
 941         /*
 942          * Few corrupted PEBs are not a problem and may be just a result of
 943          * unclean reboots. However, many of them may indicate some problems
 944          * with the flash HW or driver. Print a warning in this case.
 945          */
 946         if (si->corr_count >= 8 || si->corr_count >= ubi->peb_count / 4) {
 947                 ubi_warn("%d PEBs are corrupted", si->corr_count);
 948                 printk(KERN_WARNING "corrupted PEBs are:");
 949                 list_for_each_entry(seb, &si->corr, u.list)
 950                         printk(KERN_CONT " %d", seb->pnum);
 951                 printk(KERN_CONT "\n");
 952         }
 953
 954         /*
 955          * In case of unknown erase counter we use the mean erase counter
 956          * value.
 957          */
 958         ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
 959                 ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb)
 960                         if (seb->ec == UBI_SCAN_UNKNOWN_EC)
 961                                 seb->ec = si->mean_ec;
 962         }
 963
 964         list_for_each_entry(seb, &si->free, u.list) {
 965                 if (seb->ec == UBI_SCAN_UNKNOWN_EC)
 966                         seb->ec = si->mean_ec;
 967         }
 968
 969         list_for_each_entry(seb, &si->corr, u.list)
 970                 if (seb->ec == UBI_SCAN_UNKNOWN_EC)
 971                         seb->ec = si->mean_ec;
 972
 973         list_for_each_entry(seb, &si->erase, u.list)
 974                 if (seb->ec == UBI_SCAN_UNKNOWN_EC)
 975                         seb->ec = si->mean_ec;
 976
 977         err = paranoid_check_si(ubi, si);
 978         if (err) {
 979                 if (err > 0)
 980                         err = -EINVAL;
 981                 goto out_vidh;
 982         }
 983
 984         ubi_free_vid_hdr(ubi, vidh);
 985         kfree(ech);
 986
 987         return si;
 988
 989 out_vidh:
 990         ubi_free_vid_hdr(ubi, vidh);
 991 out_ech:
 992         kfree(ech);
 993 out_si:
 994         ubi_scan_destroy_si(si);
 995         return ERR_PTR(err);
 996 }
 997
 998 /**
 999  * destroy_sv - free the scanning volume information
1000  * @sv: scanning volume information
1001  *
1002  * This function destroys the volume RB-tree (@sv->root) and the scanning
1003  * volume information.
1004  */
1005 static void destroy_sv(struct ubi_scan_volume *sv)
1006 {
1007         struct ubi_scan_leb *seb;
1008         struct rb_node *this = sv->root.rb_node;
1009
1010         while (this) {
1011                 if (this->rb_left)
1012                         this = this->rb_left;
1013                 else if (this->rb_right)
1014                         this = this->rb_right;
1015                 else {
1016                         seb = rb_entry(this, struct ubi_scan_leb, u.rb);
1017                         this = rb_parent(this);
1018                         if (this) {
1019                                 if (this->rb_left == &seb->u.rb)
1020                                         this->rb_left = NULL;
1021                                 else
1022                                         this->rb_right = NULL;
1023                         }
1024
1025                         kfree(seb);
1026                 }
1027         }
1028         kfree(sv);
1029 }
1030
1031 /**
1032  * ubi_scan_destroy_si - destroy scanning information.
1033  * @si: scanning information
1034  */
1035 void ubi_scan_destroy_si(struct ubi_scan_info *si)
1036 {
1037         struct ubi_scan_leb *seb, *seb_tmp;
1038         struct ubi_scan_volume *sv;
1039         struct rb_node *rb;
1040
1041         list_for_each_entry_safe(seb, seb_tmp, &si->alien, u.list) {
1042                 list_del(&seb->u.list);
1043                 kfree(seb);
1044         }
1045         list_for_each_entry_safe(seb, seb_tmp, &si->erase, u.list) {
1046                 list_del(&seb->u.list);
1047                 kfree(seb);
1048         }
1049         list_for_each_entry_safe(seb, seb_tmp, &si->corr, u.list) {
1050                 list_del(&seb->u.list);
1051                 kfree(seb);
1052         }
1053         list_for_each_entry_safe(seb, seb_tmp, &si->free, u.list) {
1054                 list_del(&seb->u.list);
1055                 kfree(seb);
1056         }
1057
1058         /* Destroy the volume RB-tree */
1059         rb = si->volumes.rb_node;
1060         while (rb) {
1061                 if (rb->rb_left)
1062                         rb = rb->rb_left;
1063                 else if (rb->rb_right)
1064                         rb = rb->rb_right;
1065                 else {
1066                         sv = rb_entry(rb, struct ubi_scan_volume, rb);
1067
1068                         rb = rb_parent(rb);
1069                         if (rb) {
1070                                 if (rb->rb_left == &sv->rb)
1071                                         rb->rb_left = NULL;
1072                                 else
1073                                         rb->rb_right = NULL;
1074                         }
1075
1076                         destroy_sv(sv);
1077                 }
1078         }
1079
1080         kfree(si);
1081 }
1082
1083 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
1084
1085 /**
1086  * paranoid_check_si - check the scanning information.
1087  * @ubi: UBI device description object
1088  * @si: scanning information
1089  *
1090  * This function returns zero if the scanning information is all right, %1 if
1091  * not and a negative error code if an error occurred.
1092  */
1093 static int paranoid_check_si(struct ubi_device *ubi, struct ubi_scan_info *si)
1094 {
1095         int pnum, err, vols_found = 0;
1096         struct rb_node *rb1, *rb2;
1097         struct ubi_scan_volume *sv;
1098         struct ubi_scan_leb *seb, *last_seb;
1099         uint8_t *buf;
1100
1101         /*
1102          * At first, check that scanning information is OK.
1103          */
1104         ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
1105                 int leb_count = 0;
1106
1107                 cond_resched();
1108
1109                 vols_found += 1;
1110
1111                 if (si->is_empty) {
1112                         ubi_err("bad is_empty flag");
1113                         goto bad_sv;
1114                 }
1115
1116                 if (sv->vol_id < 0 || sv->highest_lnum < 0 ||
1117                     sv->leb_count < 0 || sv->vol_type < 0 || sv->used_ebs < 0 ||
1118                     sv->data_pad < 0 || sv->last_data_size < 0) {
1119                         ubi_err("negative values");
1120                         goto bad_sv;
1121                 }
1122
1123                 if (sv->vol_id >= UBI_MAX_VOLUMES &&
1124                     sv->vol_id < UBI_INTERNAL_VOL_START) {
1125                         ubi_err("bad vol_id");
1126                         goto bad_sv;
1127                 }
1128
1129                 if (sv->vol_id > si->highest_vol_id) {
1130                         ubi_err("highest_vol_id is %d, but vol_id %d is there",
1131                                 si->highest_vol_id, sv->vol_id);
1132                         goto out;
1133                 }
1134
1135                 if (sv->vol_type != UBI_DYNAMIC_VOLUME &&
1136                     sv->vol_type != UBI_STATIC_VOLUME) {
1137                         ubi_err("bad vol_type");
1138                         goto bad_sv;
1139                 }
1140
1141                 if (sv->data_pad > ubi->leb_size / 2) {
1142                         ubi_err("bad data_pad");
1143                         goto bad_sv;
1144                 }
1145
1146                 last_seb = NULL;
1147                 ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb) {
1148                         cond_resched();
1149
1150                         last_seb = seb;
1151                         leb_count += 1;
1152
1153                         if (seb->pnum < 0 || seb->ec < 0) {
1154                                 ubi_err("negative values");
1155                                 goto bad_seb;
1156                         }
1157
1158                         if (seb->ec < si->min_ec) {
1159                                 ubi_err("bad si->min_ec (%d), %d found",
1160                                         si->min_ec, seb->ec);
1161                                 goto bad_seb;
1162                         }
1163
1164                         if (seb->ec > si->max_ec) {
1165                                 ubi_err("bad si->max_ec (%d), %d found",
1166                                         si->max_ec, seb->ec);
1167                                 goto bad_seb;
1168                         }
1169
1170                         if (seb->pnum >= ubi->peb_count) {
1171                                 ubi_err("too high PEB number %d, total PEBs %d",
1172                                         seb->pnum, ubi->peb_count);
1173                                 goto bad_seb;
1174                         }
1175
1176                         if (sv->vol_type == UBI_STATIC_VOLUME) {
1177                                 if (seb->lnum >= sv->used_ebs) {
1178                                         ubi_err("bad lnum or used_ebs");
1179                                         goto bad_seb;
1180                                 }
1181                         } else {
1182                                 if (sv->used_ebs != 0) {
1183                                         ubi_err("non-zero used_ebs");
1184                                         goto bad_seb;
1185                                 }
1186                         }
1187
1188                         if (seb->lnum > sv->highest_lnum) {
1189                                 ubi_err("incorrect highest_lnum or lnum");
1190                                 goto bad_seb;
1191                         }
1192                 }
1193
1194                 if (sv->leb_count != leb_count) {
1195                         ubi_err("bad leb_count, %d objects in the tree",
1196                                 leb_count);
1197                         goto bad_sv;
1198                 }
1199
1200                 if (!last_seb)
1201                         continue;
1202
1203                 seb = last_seb;
1204
1205                 if (seb->lnum != sv->highest_lnum) {
1206                         ubi_err("bad highest_lnum");
1207                         goto bad_seb;
1208                 }
1209         }
1210
1211         if (vols_found != si->vols_found) {
1212                 ubi_err("bad si->vols_found %d, should be %d",
1213                         si->vols_found, vols_found);
1214                 goto out;
1215         }
1216
1217         /* Check that scanning information is correct */
1218         ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb) {
1219                 last_seb = NULL;
1220                 ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb) {
1221                         int vol_type;
1222
1223                         cond_resched();
1224
1225                         last_seb = seb;
1226
1227                         err = ubi_io_read_vid_hdr(ubi, seb->pnum, vidh, 1);
1228                         if (err && err != UBI_IO_BITFLIPS) {
1229                                 ubi_err("VID header is not OK (%d)", err);
1230                                 if (err > 0)
1231                                         err = -EIO;
1232                                 return err;
1233                         }
1234
1235                         vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
1236                                    UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
1237                         if (sv->vol_type != vol_type) {
1238                                 ubi_err("bad vol_type");
1239                                 goto bad_vid_hdr;
1240                         }
1241
1242                         if (seb->sqnum != be64_to_cpu(vidh->sqnum)) {
1243                                 ubi_err("bad sqnum %llu", seb->sqnum);
1244                                 goto bad_vid_hdr;
1245                         }
1246
1247                         if (sv->vol_id != be32_to_cpu(vidh->vol_id)) {
1248                                 ubi_err("bad vol_id %d", sv->vol_id);
1249                                 goto bad_vid_hdr;
1250                         }
1251
1252                         if (sv->compat != vidh->compat) {
1253                                 ubi_err("bad compat %d", vidh->compat);
1254                                 goto bad_vid_hdr;
1255                         }
1256
1257                         if (seb->lnum != be32_to_cpu(vidh->lnum)) {
1258                                 ubi_err("bad lnum %d", seb->lnum);
1259                                 goto bad_vid_hdr;
1260                         }
1261
1262                         if (sv->used_ebs != be32_to_cpu(vidh->used_ebs)) {
1263                                 ubi_err("bad used_ebs %d", sv->used_ebs);
1264                                 goto bad_vid_hdr;
1265                         }
1266
1267                         if (sv->data_pad != be32_to_cpu(vidh->data_pad)) {
1268                                 ubi_err("bad data_pad %d", sv->data_pad);
1269                                 goto bad_vid_hdr;
1270                         }
1271                 }
1272
1273                 if (!last_seb)
1274                         continue;
1275
1276                 if (sv->highest_lnum != be32_to_cpu(vidh->lnum)) {
1277                         ubi_err("bad highest_lnum %d", sv->highest_lnum);
1278                         goto bad_vid_hdr;
1279                 }
1280
1281                 if (sv->last_data_size != be32_to_cpu(vidh->data_size)) {
1282                         ubi_err("bad last_data_size %d", sv->last_data_size);
1283                         goto bad_vid_hdr;
1284                 }
1285         }
1286
1287         /*
1288          * Make sure that all the physical eraseblocks are in one of the lists
1289          * or trees.
1290          */
1291         buf = kzalloc(ubi->peb_count, GFP_KERNEL);
1292         if (!buf)
1293                 return -ENOMEM;
1294
1295         for (pnum = 0; pnum < ubi->peb_count; pnum++) {
1296                 err = ubi_io_is_bad(ubi, pnum);
1297                 if (err < 0) {
1298                         kfree(buf);
1299                         return err;
1300                 } else if (err)
1301                         buf[pnum] = 1;
1302         }
1303
1304         ubi_rb_for_each_entry(rb1, sv, &si->volumes, rb)
1305                 ubi_rb_for_each_entry(rb2, seb, &sv->root, u.rb)
1306                         buf[seb->pnum] = 1;
1307
1308         list_for_each_entry(seb, &si->free, u.list)
1309                 buf[seb->pnum] = 1;
1310
1311         list_for_each_entry(seb, &si->corr, u.list)
1312                 buf[seb->pnum] = 1;
1313
1314         list_for_each_entry(seb, &si->erase, u.list)
1315                 buf[seb->pnum] = 1;
1316
1317         list_for_each_entry(seb, &si->alien, u.list)
1318                 buf[seb->pnum] = 1;
1319
1320         err = 0;
1321         for (pnum = 0; pnum < ubi->peb_count; pnum++)
1322                 if (!buf[pnum]) {
1323                         ubi_err("PEB %d is not referred", pnum);
1324                         err = 1;
1325                 }
1326
1327         kfree(buf);
1328         if (err)
1329                 goto out;
1330         return 0;
1331
1332 bad_seb:
1333         ubi_err("bad scanning information about LEB %d", seb->lnum);
1334         ubi_dbg_dump_seb(seb, 0);
1335         ubi_dbg_dump_sv(sv);
1336         goto out;
1337
1338 bad_sv:
1339         ubi_err("bad scanning information about volume %d", sv->vol_id);
1340         ubi_dbg_dump_sv(sv);
1341         goto out;
1342
1343 bad_vid_hdr:
1344         ubi_err("bad scanning information about volume %d", sv->vol_id);
1345         ubi_dbg_dump_sv(sv);
1346         ubi_dbg_dump_vid_hdr(vidh);
1347
1348 out:
1349         ubi_dbg_dump_stack();
1350         return 1;
1351 }
1352
1353 #endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */