linux/drivers/mtd/ubi/attach.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Copyright (c) International Business Machines Corp., 2006
   4 *
   5 * Author: Artem Bityutskiy (Битюцкий Артём)
   6 */
   7
   8/*
   9 * UBI attaching sub-system.
  10 *
  11 * This sub-system is responsible for attaching MTD devices and it also
  12 * implements flash media scanning.
  13 *
  14 * The attaching information is represented by a &struct ubi_attach_info'
  15 * object. Information about volumes is represented by &struct ubi_ainf_volume
  16 * objects which are kept in volume RB-tree with root at the @volumes field.
  17 * The RB-tree is indexed by the volume ID.
  18 *
  19 * Logical eraseblocks are represented by &struct ubi_ainf_peb objects. These
  20 * objects are kept in per-volume RB-trees with the root at the corresponding
  21 * &struct ubi_ainf_volume object. To put it differently, we keep an RB-tree of
  22 * per-volume objects and each of these objects is the root of RB-tree of
  23 * per-LEB objects.
  24 *
  25 * Corrupted physical eraseblocks are put to the @corr list, free physical
  26 * eraseblocks are put to the @free list and the physical eraseblock to be
  27 * erased are put to the @erase list.
  28 *
  29 * About corruptions
  30 * ~~~~~~~~~~~~~~~~~
  31 *
  32 * UBI protects EC and VID headers with CRC-32 checksums, so it can detect
  33 * whether the headers are corrupted or not. Sometimes UBI also protects the
  34 * data with CRC-32, e.g., when it executes the atomic LEB change operation, or
  35 * when it moves the contents of a PEB for wear-leveling purposes.
  36 *
  37 * UBI tries to distinguish between 2 types of corruptions.
  38 *
  39 * 1. Corruptions caused by power cuts. These are expected corruptions and UBI
  40 * tries to handle them gracefully, without printing too many warnings and
  41 * error messages. The idea is that we do not lose important data in these
  42 * cases - we may lose only the data which were being written to the media just
  43 * before the power cut happened, and the upper layers (e.g., UBIFS) are
  44 * supposed to handle such data losses (e.g., by using the FS journal).
  45 *
  46 * When UBI detects a corruption (CRC-32 mismatch) in a PEB, and it looks like
  47 * the reason is a power cut, UBI puts this PEB to the @erase list, and all
  48 * PEBs in the @erase list are scheduled for erasure later.
  49 *
  50 * 2. Unexpected corruptions which are not caused by power cuts. During
  51 * attaching, such PEBs are put to the @corr list and UBI preserves them.
  52 * Obviously, this lessens the amount of available PEBs, and if at some  point
  53 * UBI runs out of free PEBs, it switches to R/O mode. UBI also loudly informs
  54 * about such PEBs every time the MTD device is attached.
  55 *
  56 * However, it is difficult to reliably distinguish between these types of
  57 * corruptions and UBI's strategy is as follows (in case of attaching by
  58 * scanning). UBI assumes corruption type 2 if the VID header is corrupted and
  59 * the data area does not contain all 0xFFs, and there were no bit-flips or
  60 * integrity errors (e.g., ECC errors in case of NAND) while reading the data
  61 * area.  Otherwise UBI assumes corruption type 1. So the decision criteria
  62 * are as follows.
  63 *   o If the data area contains only 0xFFs, there are no data, and it is safe
  64 *     to just erase this PEB - this is corruption type 1.
  65 *   o If the data area has bit-flips or data integrity errors (ECC errors on
  66 *     NAND), it is probably a PEB which was being erased when power cut
  67 *     happened, so this is corruption type 1. However, this is just a guess,
  68 *     which might be wrong.
  69 *   o Otherwise this is corruption type 2.
  70 */
  71
  72#include <linux/err.h>
  73#include <linux/slab.h>
  74#include <linux/crc32.h>
  75#include <linux/math64.h>
  76#include <linux/random.h>
  77#include "ubi.h"
  78
  79static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai);
  80
  81#define AV_FIND         BIT(0)
  82#define AV_ADD          BIT(1)
  83#define AV_FIND_OR_ADD  (AV_FIND | AV_ADD)
  84
  85/**
  86 * find_or_add_av - internal function to find a volume, add a volume or do
  87 *                  both (find and add if missing).
  88 * @ai: attaching information
  89 * @vol_id: the requested volume ID
  90 * @flags: a combination of the %AV_FIND and %AV_ADD flags describing the
  91 *         expected operation. If only %AV_ADD is set, -EEXIST is returned
  92 *         if the volume already exists. If only %AV_FIND is set, NULL is
  93 *         returned if the volume does not exist. And if both flags are
  94 *         set, the helper first tries to find an existing volume, and if
  95 *         it does not exist it creates a new one.
  96 * @created: in value used to inform the caller whether it"s a newly created
  97 *           volume or not.
  98 *
  99 * This function returns a pointer to a volume description or an ERR_PTR if
 100 * the operation failed. It can also return NULL if only %AV_FIND is set and
 101 * the volume does not exist.
 102 */
 103static struct ubi_ainf_volume *find_or_add_av(struct ubi_attach_info *ai,
 104                                              int vol_id, unsigned int flags,
 105                                              bool *created)
 106{
 107        struct ubi_ainf_volume *av;
 108        struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
 109
 110        /* Walk the volume RB-tree to look if this volume is already present */
 111        while (*p) {
 112                parent = *p;
 113                av = rb_entry(parent, struct ubi_ainf_volume, rb);
 114
 115                if (vol_id == av->vol_id) {
 116                        *created = false;
 117
 118                        if (!(flags & AV_FIND))
 119                                return ERR_PTR(-EEXIST);
 120
 121                        return av;
 122                }
 123
 124                if (vol_id > av->vol_id)
 125                        p = &(*p)->rb_left;
 126                else
 127                        p = &(*p)->rb_right;
 128        }
 129
 130        if (!(flags & AV_ADD))
 131                return NULL;
 132
 133        /* The volume is absent - add it */
 134        av = kzalloc(sizeof(*av), GFP_KERNEL);
 135        if (!av)
 136                return ERR_PTR(-ENOMEM);
 137
 138        av->vol_id = vol_id;
 139
 140        if (vol_id > ai->highest_vol_id)
 141                ai->highest_vol_id = vol_id;
 142
 143        rb_link_node(&av->rb, parent, p);
 144        rb_insert_color(&av->rb, &ai->volumes);
 145        ai->vols_found += 1;
 146        *created = true;
 147        dbg_bld("added volume %d", vol_id);
 148        return av;
 149}
 150
 151/**
 152 * ubi_find_or_add_av - search for a volume in the attaching information and
 153 *                      add one if it does not exist.
 154 * @ai: attaching information
 155 * @vol_id: the requested volume ID
 156 * @created: whether the volume has been created or not
 157 *
 158 * This function returns a pointer to the new volume description or an
 159 * ERR_PTR if the operation failed.
 160 */
 161static struct ubi_ainf_volume *ubi_find_or_add_av(struct ubi_attach_info *ai,
 162                                                  int vol_id, bool *created)
 163{
 164        return find_or_add_av(ai, vol_id, AV_FIND_OR_ADD, created);
 165}
 166
 167/**
 168 * ubi_alloc_aeb - allocate an aeb element
 169 * @ai: attaching information
 170 * @pnum: physical eraseblock number
 171 * @ec: erase counter of the physical eraseblock
 172 *
 173 * Allocate an aeb object and initialize the pnum and ec information.
 174 * vol_id and lnum are set to UBI_UNKNOWN, and the other fields are
 175 * initialized to zero.
 176 * Note that the element is not added in any list or RB tree.
 177 */
 178struct ubi_ainf_peb *ubi_alloc_aeb(struct ubi_attach_info *ai, int pnum,
 179                                   int ec)
 180{
 181        struct ubi_ainf_peb *aeb;
 182
 183        aeb = kmem_cache_zalloc(ai->aeb_slab_cache, GFP_KERNEL);
 184        if (!aeb)
 185                return NULL;
 186
 187        aeb->pnum = pnum;
 188        aeb->ec = ec;
 189        aeb->vol_id = UBI_UNKNOWN;
 190        aeb->lnum = UBI_UNKNOWN;
 191
 192        return aeb;
 193}
 194
 195/**
 196 * ubi_free_aeb - free an aeb element
 197 * @ai: attaching information
 198 * @aeb: the element to free
 199 *
 200 * Free an aeb object. The caller must have removed the element from any list
 201 * or RB tree.
 202 */
 203void ubi_free_aeb(struct ubi_attach_info *ai, struct ubi_ainf_peb *aeb)
 204{
 205        kmem_cache_free(ai->aeb_slab_cache, aeb);
 206}
 207
 208/**
 209 * add_to_list - add physical eraseblock to a list.
 210 * @ai: attaching information
 211 * @pnum: physical eraseblock number to add
 212 * @vol_id: the last used volume id for the PEB
 213 * @lnum: the last used LEB number for the PEB
 214 * @ec: erase counter of the physical eraseblock
 215 * @to_head: if not zero, add to the head of the list
 216 * @list: the list to add to
 217 *
 218 * This function allocates a 'struct ubi_ainf_peb' object for physical
 219 * eraseblock @pnum and adds it to the "free", "erase", or "alien" lists.
 220 * It stores the @lnum and @vol_id alongside, which can both be
 221 * %UBI_UNKNOWN if they are not available, not readable, or not assigned.
 222 * If @to_head is not zero, PEB will be added to the head of the list, which
 223 * basically means it will be processed first later. E.g., we add corrupted
 224 * PEBs (corrupted due to power cuts) to the head of the erase list to make
 225 * sure we erase them first and get rid of corruptions ASAP. This function
 226 * returns zero in case of success and a negative error code in case of
 227 * failure.
 228 */
 229static int add_to_list(struct ubi_attach_info *ai, int pnum, int vol_id,
 230                       int lnum, int ec, int to_head, struct list_head *list)
 231{
 232        struct ubi_ainf_peb *aeb;
 233
 234        if (list == &ai->free) {
 235                dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
 236        } else if (list == &ai->erase) {
 237                dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
 238        } else if (list == &ai->alien) {
 239                dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
 240                ai->alien_peb_count += 1;
 241        } else
 242                BUG();
 243
 244        aeb = ubi_alloc_aeb(ai, pnum, ec);
 245        if (!aeb)
 246                return -ENOMEM;
 247
 248        aeb->vol_id = vol_id;
 249        aeb->lnum = lnum;
 250        if (to_head)
 251                list_add(&aeb->u.list, list);
 252        else
 253                list_add_tail(&aeb->u.list, list);
 254        return 0;
 255}
 256
 257/**
 258 * add_corrupted - add a corrupted physical eraseblock.
 259 * @ai: attaching information
 260 * @pnum: physical eraseblock number to add
 261 * @ec: erase counter of the physical eraseblock
 262 *
 263 * This function allocates a 'struct ubi_ainf_peb' object for a corrupted
 264 * physical eraseblock @pnum and adds it to the 'corr' list.  The corruption
 265 * was presumably not caused by a power cut. Returns zero in case of success
 266 * and a negative error code in case of failure.
 267 */
 268static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec)
 269{
 270        struct ubi_ainf_peb *aeb;
 271
 272        dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
 273
 274        aeb = ubi_alloc_aeb(ai, pnum, ec);
 275        if (!aeb)
 276                return -ENOMEM;
 277
 278        ai->corr_peb_count += 1;
 279        list_add(&aeb->u.list, &ai->corr);
 280        return 0;
 281}
 282
 283/**
 284 * add_fastmap - add a Fastmap related physical eraseblock.
 285 * @ai: attaching information
 286 * @pnum: physical eraseblock number the VID header came from
 287 * @vid_hdr: the volume identifier header
 288 * @ec: erase counter of the physical eraseblock
 289 *
 290 * This function allocates a 'struct ubi_ainf_peb' object for a Fastamp
 291 * physical eraseblock @pnum and adds it to the 'fastmap' list.
 292 * Such blocks can be Fastmap super and data blocks from both the most
 293 * recent Fastmap we're attaching from or from old Fastmaps which will
 294 * be erased.
 295 */
 296static int add_fastmap(struct ubi_attach_info *ai, int pnum,
 297                       struct ubi_vid_hdr *vid_hdr, int ec)
 298{
 299        struct ubi_ainf_peb *aeb;
 300
 301        aeb = ubi_alloc_aeb(ai, pnum, ec);
 302        if (!aeb)
 303                return -ENOMEM;
 304
 305        aeb->vol_id = be32_to_cpu(vid_hdr->vol_id);
 306        aeb->sqnum = be64_to_cpu(vid_hdr->sqnum);
 307        list_add(&aeb->u.list, &ai->fastmap);
 308
 309        dbg_bld("add to fastmap list: PEB %d, vol_id %d, sqnum: %llu", pnum,
 310                aeb->vol_id, aeb->sqnum);
 311
 312        return 0;
 313}
 314
 315/**
 316 * validate_vid_hdr - check volume identifier header.
 317 * @ubi: UBI device description object
 318 * @vid_hdr: the volume identifier header to check
 319 * @av: information about the volume this logical eraseblock belongs to
 320 * @pnum: physical eraseblock number the VID header came from
 321 *
 322 * This function checks that data stored in @vid_hdr is consistent. Returns
 323 * non-zero if an inconsistency was found and zero if not.
 324 *
 325 * Note, UBI does sanity check of everything it reads from the flash media.
 326 * Most of the checks are done in the I/O sub-system. Here we check that the
 327 * information in the VID header is consistent to the information in other VID
 328 * headers of the same volume.
 329 */
 330static int validate_vid_hdr(const struct ubi_device *ubi,
 331                            const struct ubi_vid_hdr *vid_hdr,
 332                            const struct ubi_ainf_volume *av, int pnum)
 333{
 334        int vol_type = vid_hdr->vol_type;
 335        int vol_id = be32_to_cpu(vid_hdr->vol_id);
 336        int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 337        int data_pad = be32_to_cpu(vid_hdr->data_pad);
 338
 339        if (av->leb_count != 0) {
 340                int av_vol_type;
 341
 342                /*
 343                 * This is not the first logical eraseblock belonging to this
 344                 * volume. Ensure that the data in its VID header is consistent
 345                 * to the data in previous logical eraseblock headers.
 346                 */
 347
 348                if (vol_id != av->vol_id) {
 349                        ubi_err(ubi, "inconsistent vol_id");
 350                        goto bad;
 351                }
 352
 353                if (av->vol_type == UBI_STATIC_VOLUME)
 354                        av_vol_type = UBI_VID_STATIC;
 355                else
 356                        av_vol_type = UBI_VID_DYNAMIC;
 357
 358                if (vol_type != av_vol_type) {
 359                        ubi_err(ubi, "inconsistent vol_type");
 360                        goto bad;
 361                }
 362
 363                if (used_ebs != av->used_ebs) {
 364                        ubi_err(ubi, "inconsistent used_ebs");
 365                        goto bad;
 366                }
 367
 368                if (data_pad != av->data_pad) {
 369                        ubi_err(ubi, "inconsistent data_pad");
 370                        goto bad;
 371                }
 372        }
 373
 374        return 0;
 375
 376bad:
 377        ubi_err(ubi, "inconsistent VID header at PEB %d", pnum);
 378        ubi_dump_vid_hdr(vid_hdr);
 379        ubi_dump_av(av);
 380        return -EINVAL;
 381}
 382
 383/**
 384 * add_volume - add volume to the attaching information.
 385 * @ai: attaching information
 386 * @vol_id: ID of the volume to add
 387 * @pnum: physical eraseblock number
 388 * @vid_hdr: volume identifier header
 389 *
 390 * If the volume corresponding to the @vid_hdr logical eraseblock is already
 391 * present in the attaching information, this function does nothing. Otherwise
 392 * it adds corresponding volume to the attaching information. Returns a pointer
 393 * to the allocated "av" object in case of success and a negative error code in
 394 * case of failure.
 395 */
 396static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai,
 397                                          int vol_id, int pnum,
 398                                          const struct ubi_vid_hdr *vid_hdr)
 399{
 400        struct ubi_ainf_volume *av;
 401        bool created;
 402
 403        ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));
 404
 405        av = ubi_find_or_add_av(ai, vol_id, &created);
 406        if (IS_ERR(av) || !created)
 407                return av;
 408
 409        av->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
 410        av->data_pad = be32_to_cpu(vid_hdr->data_pad);
 411        av->compat = vid_hdr->compat;
 412        av->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
 413                                                            : UBI_STATIC_VOLUME;
 414
 415        return av;
 416}
 417
 418/**
 419 * ubi_compare_lebs - find out which logical eraseblock is newer.
 420 * @ubi: UBI device description object
 421 * @aeb: first logical eraseblock to compare
 422 * @pnum: physical eraseblock number of the second logical eraseblock to
 423 * compare
 424 * @vid_hdr: volume identifier header of the second logical eraseblock
 425 *
 426 * This function compares 2 copies of a LEB and informs which one is newer. In
 427 * case of success this function returns a positive value, in case of failure, a
 428 * negative error code is returned. The success return codes use the following
 429 * bits:
 430 *     o bit 0 is cleared: the first PEB (described by @aeb) is newer than the
 431 *       second PEB (described by @pnum and @vid_hdr);
 432 *     o bit 0 is set: the second PEB is newer;
 433 *     o bit 1 is cleared: no bit-flips were detected in the newer LEB;
 434 *     o bit 1 is set: bit-flips were detected in the newer LEB;
 435 *     o bit 2 is cleared: the older LEB is not corrupted;
 436 *     o bit 2 is set: the older LEB is corrupted.
 437 */
 438int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,
 439                        int pnum, const struct ubi_vid_hdr *vid_hdr)
 440{
 441        int len, err, second_is_newer, bitflips = 0, corrupted = 0;
 442        uint32_t data_crc, crc;
 443        struct ubi_vid_io_buf *vidb = NULL;
 444        unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);
 445
 446        if (sqnum2 == aeb->sqnum) {
 447                /*
 448                 * This must be a really ancient UBI image which has been
 449                 * created before sequence numbers support has been added. At
 450                 * that times we used 32-bit LEB versions stored in logical
 451                 * eraseblocks. That was before UBI got into mainline. We do not
 452                 * support these images anymore. Well, those images still work,
 453                 * but only if no unclean reboots happened.
 454                 */
 455                ubi_err(ubi, "unsupported on-flash UBI format");
 456                return -EINVAL;
 457        }
 458
 459        /* Obviously the LEB with lower sequence counter is older */
 460        second_is_newer = (sqnum2 > aeb->sqnum);
 461
 462        /*
 463         * Now we know which copy is newer. If the copy flag of the PEB with
 464         * newer version is not set, then we just return, otherwise we have to
 465         * check data CRC. For the second PEB we already have the VID header,
 466         * for the first one - we'll need to re-read it from flash.
 467         *
 468         * Note: this may be optimized so that we wouldn't read twice.
 469         */
 470
 471        if (second_is_newer) {
 472                if (!vid_hdr->copy_flag) {
 473                        /* It is not a copy, so it is newer */
 474                        dbg_bld("second PEB %d is newer, copy_flag is unset",
 475                                pnum);
 476                        return 1;
 477                }
 478        } else {
 479                if (!aeb->copy_flag) {
 480                        /* It is not a copy, so it is newer */
 481                        dbg_bld("first PEB %d is newer, copy_flag is unset",
 482                                pnum);
 483                        return bitflips << 1;
 484                }
 485
 486                vidb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
 487                if (!vidb)
 488                        return -ENOMEM;
 489
 490                pnum = aeb->pnum;
 491                err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 0);
 492                if (err) {
 493                        if (err == UBI_IO_BITFLIPS)
 494                                bitflips = 1;
 495                        else {
 496                                ubi_err(ubi, "VID of PEB %d header is bad, but it was OK earlier, err %d",
 497                                        pnum, err);
 498                                if (err > 0)
 499                                        err = -EIO;
 500
 501                                goto out_free_vidh;
 502                        }
 503                }
 504
 505                vid_hdr = ubi_get_vid_hdr(vidb);
 506        }
 507
 508        /* Read the data of the copy and check the CRC */
 509
 510        len = be32_to_cpu(vid_hdr->data_size);
 511
 512        mutex_lock(&ubi->buf_mutex);
 513        err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, len);
 514        if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
 515                goto out_unlock;
 516
 517        data_crc = be32_to_cpu(vid_hdr->data_crc);
 518        crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, len);
 519        if (crc != data_crc) {
 520                dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
 521                        pnum, crc, data_crc);
 522                corrupted = 1;
 523                bitflips = 0;
 524                second_is_newer = !second_is_newer;
 525        } else {
 526                dbg_bld("PEB %d CRC is OK", pnum);
 527                bitflips |= !!err;
 528        }
 529        mutex_unlock(&ubi->buf_mutex);
 530
 531        ubi_free_vid_buf(vidb);
 532
 533        if (second_is_newer)
 534                dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
 535        else
 536                dbg_bld("first PEB %d is newer, copy_flag is set", pnum);
 537
 538        return second_is_newer | (bitflips << 1) | (corrupted << 2);
 539
 540out_unlock:
 541        mutex_unlock(&ubi->buf_mutex);
 542out_free_vidh:
 543        ubi_free_vid_buf(vidb);
 544        return err;
 545}
 546
 547/**
 548 * ubi_add_to_av - add used physical eraseblock to the attaching information.
 549 * @ubi: UBI device description object
 550 * @ai: attaching information
 551 * @pnum: the physical eraseblock number
 552 * @ec: erase counter
 553 * @vid_hdr: the volume identifier header
 554 * @bitflips: if bit-flips were detected when this physical eraseblock was read
 555 *
 556 * This function adds information about a used physical eraseblock to the
 557 * 'used' tree of the corresponding volume. The function is rather complex
 558 * because it has to handle cases when this is not the first physical
 559 * eraseblock belonging to the same logical eraseblock, and the newer one has
 560 * to be picked, while the older one has to be dropped. This function returns
 561 * zero in case of success and a negative error code in case of failure.
 562 */
 563int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum,
 564                  int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips)
 565{
 566        int err, vol_id, lnum;
 567        unsigned long long sqnum;
 568        struct ubi_ainf_volume *av;
 569        struct ubi_ainf_peb *aeb;
 570        struct rb_node **p, *parent = NULL;
 571
 572        vol_id = be32_to_cpu(vid_hdr->vol_id);
 573        lnum = be32_to_cpu(vid_hdr->lnum);
 574        sqnum = be64_to_cpu(vid_hdr->sqnum);
 575
 576        dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",
 577                pnum, vol_id, lnum, ec, sqnum, bitflips);
 578
 579        av = add_volume(ai, vol_id, pnum, vid_hdr);
 580        if (IS_ERR(av))
 581                return PTR_ERR(av);
 582
 583        if (ai->max_sqnum < sqnum)
 584                ai->max_sqnum = sqnum;
 585
 586        /*
 587         * Walk the RB-tree of logical eraseblocks of volume @vol_id to look
 588         * if this is the first instance of this logical eraseblock or not.
 589         */
 590        p = &av->root.rb_node;
 591        while (*p) {
 592                int cmp_res;
 593
 594                parent = *p;
 595                aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
 596                if (lnum != aeb->lnum) {
 597                        if (lnum < aeb->lnum)
 598                                p = &(*p)->rb_left;
 599                        else
 600                                p = &(*p)->rb_right;
 601                        continue;
 602                }
 603
 604                /*
 605                 * There is already a physical eraseblock describing the same
 606                 * logical eraseblock present.
 607                 */
 608
 609                dbg_bld("this LEB already exists: PEB %d, sqnum %llu, EC %d",
 610                        aeb->pnum, aeb->sqnum, aeb->ec);
 611
 612                /*
 613                 * Make sure that the logical eraseblocks have different
 614                 * sequence numbers. Otherwise the image is bad.
 615                 *
 616                 * However, if the sequence number is zero, we assume it must
 617                 * be an ancient UBI image from the era when UBI did not have
 618                 * sequence numbers. We still can attach these images, unless
 619                 * there is a need to distinguish between old and new
 620                 * eraseblocks, in which case we'll refuse the image in
 621                 * 'ubi_compare_lebs()'. In other words, we attach old clean
 622                 * images, but refuse attaching old images with duplicated
 623                 * logical eraseblocks because there was an unclean reboot.
 624                 */
 625                if (aeb->sqnum == sqnum && sqnum != 0) {
 626                        ubi_err(ubi, "two LEBs with same sequence number %llu",
 627                                sqnum);
 628                        ubi_dump_aeb(aeb, 0);
 629                        ubi_dump_vid_hdr(vid_hdr);
 630                        return -EINVAL;
 631                }
 632
 633                /*
 634                 * Now we have to drop the older one and preserve the newer
 635                 * one.
 636                 */
 637                cmp_res = ubi_compare_lebs(ubi, aeb, pnum, vid_hdr);
 638                if (cmp_res < 0)
 639                        return cmp_res;
 640
 641                if (cmp_res & 1) {
 642                        /*
 643                         * This logical eraseblock is newer than the one
 644                         * found earlier.
 645                         */
 646                        err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
 647                        if (err)
 648                                return err;
 649
 650                        err = add_to_list(ai, aeb->pnum, aeb->vol_id,
 651                                          aeb->lnum, aeb->ec, cmp_res & 4,
 652                                          &ai->erase);
 653                        if (err)
 654                                return err;
 655
 656                        aeb->ec = ec;
 657                        aeb->pnum = pnum;
 658                        aeb->vol_id = vol_id;
 659                        aeb->lnum = lnum;
 660                        aeb->scrub = ((cmp_res & 2) || bitflips);
 661                        aeb->copy_flag = vid_hdr->copy_flag;
 662                        aeb->sqnum = sqnum;
 663
 664                        if (av->highest_lnum == lnum)
 665                                av->last_data_size =
 666                                        be32_to_cpu(vid_hdr->data_size);
 667
 668                        return 0;
 669                } else {
 670                        /*
 671                         * This logical eraseblock is older than the one found
 672                         * previously.
 673                         */
 674                        return add_to_list(ai, pnum, vol_id, lnum, ec,
 675                                           cmp_res & 4, &ai->erase);
 676                }
 677        }
 678
 679        /*
 680         * We've met this logical eraseblock for the first time, add it to the
 681         * attaching information.
 682         */
 683
 684        err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
 685        if (err)
 686                return err;
 687
 688        aeb = ubi_alloc_aeb(ai, pnum, ec);
 689        if (!aeb)
 690                return -ENOMEM;
 691
 692        aeb->vol_id = vol_id;
 693        aeb->lnum = lnum;
 694        aeb->scrub = bitflips;
 695        aeb->copy_flag = vid_hdr->copy_flag;
 696        aeb->sqnum = sqnum;
 697
 698        if (av->highest_lnum <= lnum) {
 699                av->highest_lnum = lnum;
 700                av->last_data_size = be32_to_cpu(vid_hdr->data_size);
 701        }
 702
 703        av->leb_count += 1;
 704        rb_link_node(&aeb->u.rb, parent, p);
 705        rb_insert_color(&aeb->u.rb, &av->root);
 706        return 0;
 707}
 708
 709/**
 710 * ubi_add_av - add volume to the attaching information.
 711 * @ai: attaching information
 712 * @vol_id: the requested volume ID
 713 *
 714 * This function returns a pointer to the new volume description or an
 715 * ERR_PTR if the operation failed.
 716 */
 717struct ubi_ainf_volume *ubi_add_av(struct ubi_attach_info *ai, int vol_id)
 718{
 719        bool created;
 720
 721        return find_or_add_av(ai, vol_id, AV_ADD, &created);
 722}
 723
 724/**
 725 * ubi_find_av - find volume in the attaching information.
 726 * @ai: attaching information
 727 * @vol_id: the requested volume ID
 728 *
 729 * This function returns a pointer to the volume description or %NULL if there
 730 * are no data about this volume in the attaching information.
 731 */
 732struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai,
 733                                    int vol_id)
 734{
 735        bool created;
 736
 737        return find_or_add_av((struct ubi_attach_info *)ai, vol_id, AV_FIND,
 738                              &created);
 739}
 740
 741static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av,
 742                       struct list_head *list);
 743
 744/**
 745 * ubi_remove_av - delete attaching information about a volume.
 746 * @ai: attaching information
 747 * @av: the volume attaching information to delete
 748 */
 749void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
 750{
 751        dbg_bld("remove attaching information about volume %d", av->vol_id);
 752
 753        rb_erase(&av->rb, &ai->volumes);
 754        destroy_av(ai, av, &ai->erase);
 755        ai->vols_found -= 1;
 756}
 757
 758/**
 759 * early_erase_peb - erase a physical eraseblock.
 760 * @ubi: UBI device description object
 761 * @ai: attaching information
 762 * @pnum: physical eraseblock number to erase;
 763 * @ec: erase counter value to write (%UBI_UNKNOWN if it is unknown)
 764 *
 765 * This function erases physical eraseblock 'pnum', and writes the erase
 766 * counter header to it. This function should only be used on UBI device
 767 * initialization stages, when the EBA sub-system had not been yet initialized.
 768 * This function returns zero in case of success and a negative error code in
 769 * case of failure.
 770 */
 771static int early_erase_peb(struct ubi_device *ubi,
 772                           const struct ubi_attach_info *ai, int pnum, int ec)
 773{
 774        int err;
 775        struct ubi_ec_hdr *ec_hdr;
 776
 777        if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
 778                /*
 779                 * Erase counter overflow. Upgrade UBI and use 64-bit
 780                 * erase counters internally.
 781                 */
 782                ubi_err(ubi, "erase counter overflow at PEB %d, EC %d",
 783                        pnum, ec);
 784                return -EINVAL;
 785        }
 786
 787        ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
 788        if (!ec_hdr)
 789                return -ENOMEM;
 790
 791        ec_hdr->ec = cpu_to_be64(ec);
 792
 793        err = ubi_io_sync_erase(ubi, pnum, 0);
 794        if (err < 0)
 795                goto out_free;
 796
 797        err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
 798
 799out_free:
 800        kfree(ec_hdr);
 801        return err;
 802}
 803
 804/**
 805 * ubi_early_get_peb - get a free physical eraseblock.
 806 * @ubi: UBI device description object
 807 * @ai: attaching information
 808 *
 809 * This function returns a free physical eraseblock. It is supposed to be
 810 * called on the UBI initialization stages when the wear-leveling sub-system is
 811 * not initialized yet. This function picks a physical eraseblocks from one of
 812 * the lists, writes the EC header if it is needed, and removes it from the
 813 * list.
 814 *
 815 * This function returns a pointer to the "aeb" of the found free PEB in case
 816 * of success and an error code in case of failure.
 817 */
 818struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi,
 819                                       struct ubi_attach_info *ai)
 820{
 821        int err = 0;
 822        struct ubi_ainf_peb *aeb, *tmp_aeb;
 823
 824        if (!list_empty(&ai->free)) {
 825                aeb = list_entry(ai->free.next, struct ubi_ainf_peb, u.list);
 826                list_del(&aeb->u.list);
 827                dbg_bld("return free PEB %d, EC %d", aeb->pnum, aeb->ec);
 828                return aeb;
 829        }
 830
 831        /*
 832         * We try to erase the first physical eraseblock from the erase list
 833         * and pick it if we succeed, or try to erase the next one if not. And
 834         * so forth. We don't want to take care about bad eraseblocks here -
 835         * they'll be handled later.
 836         */
 837        list_for_each_entry_safe(aeb, tmp_aeb, &ai->erase, u.list) {
 838                if (aeb->ec == UBI_UNKNOWN)
 839                        aeb->ec = ai->mean_ec;
 840
 841                err = early_erase_peb(ubi, ai, aeb->pnum, aeb->ec+1);
 842                if (err)
 843                        continue;
 844
 845                aeb->ec += 1;
 846                list_del(&aeb->u.list);
 847                dbg_bld("return PEB %d, EC %d", aeb->pnum, aeb->ec);
 848                return aeb;
 849        }
 850
 851        ubi_err(ubi, "no free eraseblocks");
 852        return ERR_PTR(-ENOSPC);
 853}
 854
 855/**
 856 * check_corruption - check the data area of PEB.
 857 * @ubi: UBI device description object
 858 * @vid_hdr: the (corrupted) VID header of this PEB
 859 * @pnum: the physical eraseblock number to check
 860 *
 861 * This is a helper function which is used to distinguish between VID header
 862 * corruptions caused by power cuts and other reasons. If the PEB contains only
 863 * 0xFF bytes in the data area, the VID header is most probably corrupted
 864 * because of a power cut (%0 is returned in this case). Otherwise, it was
 865 * probably corrupted for some other reasons (%1 is returned in this case). A
 866 * negative error code is returned if a read error occurred.
 867 *
 868 * If the corruption reason was a power cut, UBI can safely erase this PEB.
 869 * Otherwise, it should preserve it to avoid possibly destroying important
 870 * information.
 871 */
 872static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr,
 873                            int pnum)
 874{
 875        int err;
 876
 877        mutex_lock(&ubi->buf_mutex);
 878        memset(ubi->peb_buf, 0x00, ubi->leb_size);
 879
 880        err = ubi_io_read(ubi, ubi->peb_buf, pnum, ubi->leb_start,
 881                          ubi->leb_size);
 882        if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
 883                /*
 884                 * Bit-flips or integrity errors while reading the data area.
 885                 * It is difficult to say for sure what type of corruption is
 886                 * this, but presumably a power cut happened while this PEB was
 887                 * erased, so it became unstable and corrupted, and should be
 888                 * erased.
 889                 */
 890                err = 0;
 891                goto out_unlock;
 892        }
 893
 894        if (err)
 895                goto out_unlock;
 896
 897        if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))
 898                goto out_unlock;
 899
 900        ubi_err(ubi, "PEB %d contains corrupted VID header, and the data does not contain all 0xFF",
 901                pnum);
 902        ubi_err(ubi, "this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection");
 903        ubi_dump_vid_hdr(vid_hdr);
 904        pr_err("hexdump of PEB %d offset %d, length %d",
 905               pnum, ubi->leb_start, ubi->leb_size);
 906        ubi_dbg_print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
 907                               ubi->peb_buf, ubi->leb_size, 1);
 908        err = 1;
 909
 910out_unlock:
 911        mutex_unlock(&ubi->buf_mutex);
 912        return err;
 913}
 914
 915static bool vol_ignored(int vol_id)
 916{
 917        switch (vol_id) {
 918                case UBI_LAYOUT_VOLUME_ID:
 919                return true;
 920        }
 921
 922#ifdef CONFIG_MTD_UBI_FASTMAP
 923        return ubi_is_fm_vol(vol_id);
 924#else
 925        return false;
 926#endif
 927}
 928
 929/**
 930 * scan_peb - scan and process UBI headers of a PEB.
 931 * @ubi: UBI device description object
 932 * @ai: attaching information
 933 * @pnum: the physical eraseblock number
 934 * @fast: true if we're scanning for a Fastmap
 935 *
 936 * This function reads UBI headers of PEB @pnum, checks them, and adds
 937 * information about this PEB to the corresponding list or RB-tree in the
 938 * "attaching info" structure. Returns zero if the physical eraseblock was
 939 * successfully handled and a negative error code in case of failure.
 940 */
 941static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai,
 942                    int pnum, bool fast)
 943{
 944        struct ubi_ec_hdr *ech = ai->ech;
 945        struct ubi_vid_io_buf *vidb = ai->vidb;
 946        struct ubi_vid_hdr *vidh = ubi_get_vid_hdr(vidb);
 947        long long ec;
 948        int err, bitflips = 0, vol_id = -1, ec_err = 0;
 949
 950        dbg_bld("scan PEB %d", pnum);
 951
 952        /* Skip bad physical eraseblocks */
 953        err = ubi_io_is_bad(ubi, pnum);
 954        if (err < 0)
 955                return err;
 956        else if (err) {
 957                ai->bad_peb_count += 1;
 958                return 0;
 959        }
 960
 961        err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
 962        if (err < 0)
 963                return err;
 964        switch (err) {
 965        case 0:
 966                break;
 967        case UBI_IO_BITFLIPS:
 968                bitflips = 1;
 969                break;
 970        case UBI_IO_FF:
 971                ai->empty_peb_count += 1;
 972                return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
 973                                   UBI_UNKNOWN, 0, &ai->erase);
 974        case UBI_IO_FF_BITFLIPS:
 975                ai->empty_peb_count += 1;
 976                return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
 977                                   UBI_UNKNOWN, 1, &ai->erase);
 978        case UBI_IO_BAD_HDR_EBADMSG:
 979        case UBI_IO_BAD_HDR:
 980                /*
 981                 * We have to also look at the VID header, possibly it is not
 982                 * corrupted. Set %bitflips flag in order to make this PEB be
 983                 * moved and EC be re-created.
 984                 */
 985                ec_err = err;
 986                ec = UBI_UNKNOWN;
 987                bitflips = 1;
 988                break;
 989        default:
 990                ubi_err(ubi, "'ubi_io_read_ec_hdr()' returned unknown code %d",
 991                        err);
 992                return -EINVAL;
 993        }
 994
 995        if (!ec_err) {
 996                int image_seq;
 997
 998                /* Make sure UBI version is OK */
 999                if (ech->version != UBI_VERSION) {
1000                        ubi_err(ubi, "this UBI version is %d, image version is %d",
1001                                UBI_VERSION, (int)ech->version);
1002                        return -EINVAL;
1003                }
1004
1005                ec = be64_to_cpu(ech->ec);
1006                if (ec > UBI_MAX_ERASECOUNTER) {
1007                        /*
1008                         * Erase counter overflow. The EC headers have 64 bits
1009                         * reserved, but we anyway make use of only 31 bit
1010                         * values, as this seems to be enough for any existing
1011                         * flash. Upgrade UBI and use 64-bit erase counters
1012                         * internally.
1013                         */
1014                        ubi_err(ubi, "erase counter overflow, max is %d",
1015                                UBI_MAX_ERASECOUNTER);
1016                        ubi_dump_ec_hdr(ech);
1017                        return -EINVAL;
1018                }
1019
1020                /*
1021                 * Make sure that all PEBs have the same image sequence number.
1022                 * This allows us to detect situations when users flash UBI
1023                 * images incorrectly, so that the flash has the new UBI image
1024                 * and leftovers from the old one. This feature was added
1025                 * relatively recently, and the sequence number was always
1026                 * zero, because old UBI implementations always set it to zero.
1027                 * For this reasons, we do not panic if some PEBs have zero
1028                 * sequence number, while other PEBs have non-zero sequence
1029                 * number.
1030                 */
1031                image_seq = be32_to_cpu(ech->image_seq);
1032                if (!ubi->image_seq)
1033                        ubi->image_seq = image_seq;
1034                if (image_seq && ubi->image_seq != image_seq) {
1035                        ubi_err(ubi, "bad image sequence number %d in PEB %d, expected %d",
1036                                image_seq, pnum, ubi->image_seq);
1037                        ubi_dump_ec_hdr(ech);
1038                        return -EINVAL;
1039                }
1040        }
1041
1042        /* OK, we've done with the EC header, let's look at the VID header */
1043
1044        err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 0);
1045        if (err < 0)
1046                return err;
1047        switch (err) {
1048        case 0:
1049                break;
1050        case UBI_IO_BITFLIPS:
1051                bitflips = 1;
1052                break;
1053        case UBI_IO_BAD_HDR_EBADMSG:
1054                if (ec_err == UBI_IO_BAD_HDR_EBADMSG)
1055                        /*
1056                         * Both EC and VID headers are corrupted and were read
1057                         * with data integrity error, probably this is a bad
1058                         * PEB, bit it is not marked as bad yet. This may also
1059                         * be a result of power cut during erasure.
1060                         */
1061                        ai->maybe_bad_peb_count += 1;
1062                fallthrough;
1063        case UBI_IO_BAD_HDR:
1064                        /*
1065                         * If we're facing a bad VID header we have to drop *all*
1066                         * Fastmap data structures we find. The most recent Fastmap
1067                         * could be bad and therefore there is a chance that we attach
1068                         * from an old one. On a fine MTD stack a PEB must not render
1069                         * bad all of a sudden, but the reality is different.
1070                         * So, let's be paranoid and help finding the root cause by
1071                         * falling back to scanning mode instead of attaching with a
1072                         * bad EBA table and cause data corruption which is hard to
1073                         * analyze.
1074                         */
1075                        if (fast)
1076                                ai->force_full_scan = 1;
1077
1078                if (ec_err)
1079                        /*
1080                         * Both headers are corrupted. There is a possibility
1081                         * that this a valid UBI PEB which has corresponding
1082                         * LEB, but the headers are corrupted. However, it is
1083                         * impossible to distinguish it from a PEB which just
1084                         * contains garbage because of a power cut during erase
1085                         * operation. So we just schedule this PEB for erasure.
1086                         *
1087                         * Besides, in case of NOR flash, we deliberately
1088                         * corrupt both headers because NOR flash erasure is
1089                         * slow and can start from the end.
1090                         */
1091                        err = 0;
1092                else
1093                        /*
1094                         * The EC was OK, but the VID header is corrupted. We
1095                         * have to check what is in the data area.
1096                         */
1097                        err = check_corruption(ubi, vidh, pnum);
1098
1099                if (err < 0)
1100                        return err;
1101                else if (!err)
1102                        /* This corruption is caused by a power cut */
1103                        err = add_to_list(ai, pnum, UBI_UNKNOWN,
1104                                          UBI_UNKNOWN, ec, 1, &ai->erase);
1105                else
1106                        /* This is an unexpected corruption */
1107                        err = add_corrupted(ai, pnum, ec);
1108                if (err)
1109                        return err;
1110                goto adjust_mean_ec;
1111        case UBI_IO_FF_BITFLIPS:
1112                err = add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
1113                                  ec, 1, &ai->erase);
1114                if (err)
1115                        return err;
1116                goto adjust_mean_ec;
1117        case UBI_IO_FF:
1118                if (ec_err || bitflips)
1119                        err = add_to_list(ai, pnum, UBI_UNKNOWN,
1120                                          UBI_UNKNOWN, ec, 1, &ai->erase);
1121                else
1122                        err = add_to_list(ai, pnum, UBI_UNKNOWN,
1123                                          UBI_UNKNOWN, ec, 0, &ai->free);
1124                if (err)
1125                        return err;
1126                goto adjust_mean_ec;
1127        default:
1128                ubi_err(ubi, "'ubi_io_read_vid_hdr()' returned unknown code %d",
1129                        err);
1130                return -EINVAL;
1131        }
1132
1133        vol_id = be32_to_cpu(vidh->vol_id);
1134        if (vol_id > UBI_MAX_VOLUMES && !vol_ignored(vol_id)) {
1135                int lnum = be32_to_cpu(vidh->lnum);
1136
1137                /* Unsupported internal volume */
1138                switch (vidh->compat) {
1139                case UBI_COMPAT_DELETE:
1140                        ubi_msg(ubi, "\"delete\" compatible internal volume %d:%d found, will remove it",
1141                                vol_id, lnum);
1142
1143                        err = add_to_list(ai, pnum, vol_id, lnum,
1144                                          ec, 1, &ai->erase);
1145                        if (err)
1146                                return err;
1147                        return 0;
1148
1149                case UBI_COMPAT_RO:
1150                        ubi_msg(ubi, "read-only compatible internal volume %d:%d found, switch to read-only mode",
1151                                vol_id, lnum);
1152                        ubi->ro_mode = 1;
1153                        break;
1154
1155                case UBI_COMPAT_PRESERVE:
1156                        ubi_msg(ubi, "\"preserve\" compatible internal volume %d:%d found",
1157                                vol_id, lnum);
1158                        err = add_to_list(ai, pnum, vol_id, lnum,
1159                                          ec, 0, &ai->alien);
1160                        if (err)
1161                                return err;
1162                        return 0;
1163
1164                case UBI_COMPAT_REJECT:
1165                        ubi_err(ubi, "incompatible internal volume %d:%d found",
1166                                vol_id, lnum);
1167                        return -EINVAL;
1168                }
1169        }
1170
1171        if (ec_err)
1172                ubi_warn(ubi, "valid VID header but corrupted EC header at PEB %d",
1173                         pnum);
1174
1175        if (ubi_is_fm_vol(vol_id))
1176                err = add_fastmap(ai, pnum, vidh, ec);
1177        else
1178                err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);
1179
1180        if (err)
1181                return err;
1182
1183adjust_mean_ec:
1184        if (!ec_err) {
1185                ai->ec_sum += ec;
1186                ai->ec_count += 1;
1187                if (ec > ai->max_ec)
1188                        ai->max_ec = ec;
1189                if (ec < ai->min_ec)
1190                        ai->min_ec = ec;
1191        }
1192
1193        return 0;
1194}
1195
1196/**
1197 * late_analysis - analyze the overall situation with PEB.
1198 * @ubi: UBI device description object
1199 * @ai: attaching information
1200 *
1201 * This is a helper function which takes a look what PEBs we have after we
1202 * gather information about all of them ("ai" is compete). It decides whether
1203 * the flash is empty and should be formatted of whether there are too many
1204 * corrupted PEBs and we should not attach this MTD device. Returns zero if we
1205 * should proceed with attaching the MTD device, and %-EINVAL if we should not.
1206 */
1207static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai)
1208{
1209        struct ubi_ainf_peb *aeb;
1210        int max_corr, peb_count;
1211
1212        peb_count = ubi->peb_count - ai->bad_peb_count - ai->alien_peb_count;
1213        max_corr = peb_count / 20 ?: 8;
1214
1215        /*
1216         * Few corrupted PEBs is not a problem and may be just a result of
1217         * unclean reboots. However, many of them may indicate some problems
1218         * with the flash HW or driver.
1219         */
1220        if (ai->corr_peb_count) {
1221                ubi_err(ubi, "%d PEBs are corrupted and preserved",
1222                        ai->corr_peb_count);
1223                pr_err("Corrupted PEBs are:");
1224                list_for_each_entry(aeb, &ai->corr, u.list)
1225                        pr_cont(" %d", aeb->pnum);
1226                pr_cont("\n");
1227
1228                /*
1229                 * If too many PEBs are corrupted, we refuse attaching,
1230                 * otherwise, only print a warning.
1231                 */
1232                if (ai->corr_peb_count >= max_corr) {
1233                        ubi_err(ubi, "too many corrupted PEBs, refusing");
1234                        return -EINVAL;
1235                }
1236        }
1237
1238        if (ai->empty_peb_count + ai->maybe_bad_peb_count == peb_count) {
1239                /*
1240                 * All PEBs are empty, or almost all - a couple PEBs look like
1241                 * they may be bad PEBs which were not marked as bad yet.
1242                 *
1243                 * This piece of code basically tries to distinguish between
1244                 * the following situations:
1245                 *
1246                 * 1. Flash is empty, but there are few bad PEBs, which are not
1247                 *    marked as bad so far, and which were read with error. We
1248                 *    want to go ahead and format this flash. While formatting,
1249                 *    the faulty PEBs will probably be marked as bad.
1250                 *
1251                 * 2. Flash contains non-UBI data and we do not want to format
1252                 *    it and destroy possibly important information.
1253                 */
1254                if (ai->maybe_bad_peb_count <= 2) {
1255                        ai->is_empty = 1;
1256                        ubi_msg(ubi, "empty MTD device detected");
1257                        get_random_bytes(&ubi->image_seq,
1258                                         sizeof(ubi->image_seq));
1259                } else {
1260                        ubi_err(ubi, "MTD device is not UBI-formatted and possibly contains non-UBI data - refusing it");
1261                        return -EINVAL;
1262                }
1263
1264        }
1265
1266        return 0;
1267}
1268
1269/**
1270 * destroy_av - free volume attaching information.
1271 * @av: volume attaching information
1272 * @ai: attaching information
1273 * @list: put the aeb elements in there if !NULL, otherwise free them
1274 *
1275 * This function destroys the volume attaching information.
1276 */
1277static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av,
1278                       struct list_head *list)
1279{
1280        struct ubi_ainf_peb *aeb;
1281        struct rb_node *this = av->root.rb_node;
1282
1283        while (this) {
1284                if (this->rb_left)
1285                        this = this->rb_left;
1286                else if (this->rb_right)
1287                        this = this->rb_right;
1288                else {
1289                        aeb = rb_entry(this, struct ubi_ainf_peb, u.rb);
1290                        this = rb_parent(this);
1291                        if (this) {
1292                                if (this->rb_left == &aeb->u.rb)
1293                                        this->rb_left = NULL;
1294                                else
1295                                        this->rb_right = NULL;
1296                        }
1297
1298                        if (list)
1299                                list_add_tail(&aeb->u.list, list);
1300                        else
1301                                ubi_free_aeb(ai, aeb);
1302                }
1303        }
1304        kfree(av);
1305}
1306
1307/**
1308 * destroy_ai - destroy attaching information.
1309 * @ai: attaching information
1310 */
1311static void destroy_ai(struct ubi_attach_info *ai)
1312{
1313        struct ubi_ainf_peb *aeb, *aeb_tmp;
1314        struct ubi_ainf_volume *av;
1315        struct rb_node *rb;
1316
1317        list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) {
1318                list_del(&aeb->u.list);
1319                ubi_free_aeb(ai, aeb);
1320        }
1321        list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) {
1322                list_del(&aeb->u.list);
1323                ubi_free_aeb(ai, aeb);
1324        }
1325        list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) {
1326                list_del(&aeb->u.list);
1327                ubi_free_aeb(ai, aeb);
1328        }
1329        list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) {
1330                list_del(&aeb->u.list);
1331                ubi_free_aeb(ai, aeb);
1332        }
1333        list_for_each_entry_safe(aeb, aeb_tmp, &ai->fastmap, u.list) {
1334                list_del(&aeb->u.list);
1335                ubi_free_aeb(ai, aeb);
1336        }
1337
1338        /* Destroy the volume RB-tree */
1339        rb = ai->volumes.rb_node;
1340        while (rb) {
1341                if (rb->rb_left)
1342                        rb = rb->rb_left;
1343                else if (rb->rb_right)
1344                        rb = rb->rb_right;
1345                else {
1346                        av = rb_entry(rb, struct ubi_ainf_volume, rb);
1347
1348                        rb = rb_parent(rb);
1349                        if (rb) {
1350                                if (rb->rb_left == &av->rb)
1351                                        rb->rb_left = NULL;
1352                                else
1353                                        rb->rb_right = NULL;
1354                        }
1355
1356                        destroy_av(ai, av, NULL);
1357                }
1358        }
1359
1360        kmem_cache_destroy(ai->aeb_slab_cache);
1361        kfree(ai);
1362}
1363
1364/**
1365 * scan_all - scan entire MTD device.
1366 * @ubi: UBI device description object
1367 * @ai: attach info object
1368 * @start: start scanning at this PEB
1369 *
1370 * This function does full scanning of an MTD device and returns complete
1371 * information about it in form of a "struct ubi_attach_info" object. In case
1372 * of failure, an error code is returned.
1373 */
1374static int scan_all(struct ubi_device *ubi, struct ubi_attach_info *ai,
1375                    int start)
1376{
1377        int err, pnum;
1378        struct rb_node *rb1, *rb2;
1379        struct ubi_ainf_volume *av;
1380        struct ubi_ainf_peb *aeb;
1381
1382        err = -ENOMEM;
1383
1384        ai->ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
1385        if (!ai->ech)
1386                return err;
1387
1388        ai->vidb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
1389        if (!ai->vidb)
1390                goto out_ech;
1391
1392        for (pnum = start; pnum < ubi->peb_count; pnum++) {
1393                cond_resched();
1394
1395                dbg_gen("process PEB %d", pnum);
1396                err = scan_peb(ubi, ai, pnum, false);
1397                if (err < 0)
1398                        goto out_vidh;
1399        }
1400
1401        ubi_msg(ubi, "scanning is finished");
1402
1403        /* Calculate mean erase counter */
1404        if (ai->ec_count)
1405                ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count);
1406
1407        err = late_analysis(ubi, ai);
1408        if (err)
1409                goto out_vidh;
1410
1411        /*
1412         * In case of unknown erase counter we use the mean erase counter
1413         * value.
1414         */
1415        ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1416                ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
1417                        if (aeb->ec == UBI_UNKNOWN)
1418                                aeb->ec = ai->mean_ec;
1419        }
1420
1421        list_for_each_entry(aeb, &ai->free, u.list) {
1422                if (aeb->ec == UBI_UNKNOWN)
1423                        aeb->ec = ai->mean_ec;
1424        }
1425
1426        list_for_each_entry(aeb, &ai->corr, u.list)
1427                if (aeb->ec == UBI_UNKNOWN)
1428                        aeb->ec = ai->mean_ec;
1429
1430        list_for_each_entry(aeb, &ai->erase, u.list)
1431                if (aeb->ec == UBI_UNKNOWN)
1432                        aeb->ec = ai->mean_ec;
1433
1434        err = self_check_ai(ubi, ai);
1435        if (err)
1436                goto out_vidh;
1437
1438        ubi_free_vid_buf(ai->vidb);
1439        kfree(ai->ech);
1440
1441        return 0;
1442
1443out_vidh:
1444        ubi_free_vid_buf(ai->vidb);
1445out_ech:
1446        kfree(ai->ech);
1447        return err;
1448}
1449
1450static struct ubi_attach_info *alloc_ai(void)
1451{
1452        struct ubi_attach_info *ai;
1453
1454        ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL);
1455        if (!ai)
1456                return ai;
1457
1458        INIT_LIST_HEAD(&ai->corr);
1459        INIT_LIST_HEAD(&ai->free);
1460        INIT_LIST_HEAD(&ai->erase);
1461        INIT_LIST_HEAD(&ai->alien);
1462        INIT_LIST_HEAD(&ai->fastmap);
1463        ai->volumes = RB_ROOT;
1464        ai->aeb_slab_cache = kmem_cache_create("ubi_aeb_slab_cache",
1465                                               sizeof(struct ubi_ainf_peb),
1466                                               0, 0, NULL);
1467        if (!ai->aeb_slab_cache) {
1468                kfree(ai);
1469                ai = NULL;
1470        }
1471
1472        return ai;
1473}
1474
1475#ifdef CONFIG_MTD_UBI_FASTMAP
1476
1477/**
1478 * scan_fast - try to find a fastmap and attach from it.
1479 * @ubi: UBI device description object
1480 * @ai: attach info object
1481 *
1482 * Returns 0 on success, negative return values indicate an internal
1483 * error.
1484 * UBI_NO_FASTMAP denotes that no fastmap was found.
1485 * UBI_BAD_FASTMAP denotes that the found fastmap was invalid.
1486 */
1487static int scan_fast(struct ubi_device *ubi, struct ubi_attach_info **ai)
1488{
1489        int err, pnum;
1490        struct ubi_attach_info *scan_ai;
1491
1492        err = -ENOMEM;
1493
1494        scan_ai = alloc_ai();
1495        if (!scan_ai)
1496                goto out;
1497
1498        scan_ai->ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
1499        if (!scan_ai->ech)
1500                goto out_ai;
1501
1502        scan_ai->vidb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
1503        if (!scan_ai->vidb)
1504                goto out_ech;
1505
1506        for (pnum = 0; pnum < UBI_FM_MAX_START; pnum++) {
1507                cond_resched();
1508
1509                dbg_gen("process PEB %d", pnum);
1510                err = scan_peb(ubi, scan_ai, pnum, true);
1511                if (err < 0)
1512                        goto out_vidh;
1513        }
1514
1515        ubi_free_vid_buf(scan_ai->vidb);
1516        kfree(scan_ai->ech);
1517
1518        if (scan_ai->force_full_scan)
1519                err = UBI_NO_FASTMAP;
1520        else
1521                err = ubi_scan_fastmap(ubi, *ai, scan_ai);
1522
1523        if (err) {
1524                /*
1525                 * Didn't attach via fastmap, do a full scan but reuse what
1526                 * we've aready scanned.
1527                 */
1528                destroy_ai(*ai);
1529                *ai = scan_ai;
1530        } else
1531                destroy_ai(scan_ai);
1532
1533        return err;
1534
1535out_vidh:
1536        ubi_free_vid_buf(scan_ai->vidb);
1537out_ech:
1538        kfree(scan_ai->ech);
1539out_ai:
1540        destroy_ai(scan_ai);
1541out:
1542        return err;
1543}
1544
1545#endif
1546
1547/**
1548 * ubi_attach - attach an MTD device.
1549 * @ubi: UBI device descriptor
1550 * @force_scan: if set to non-zero attach by scanning
1551 *
1552 * This function returns zero in case of success and a negative error code in
1553 * case of failure.
1554 */
1555int ubi_attach(struct ubi_device *ubi, int force_scan)
1556{
1557        int err;
1558        struct ubi_attach_info *ai;
1559
1560        ai = alloc_ai();
1561        if (!ai)
1562                return -ENOMEM;
1563
1564#ifdef CONFIG_MTD_UBI_FASTMAP
1565        /* On small flash devices we disable fastmap in any case. */
1566        if ((int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd) <= UBI_FM_MAX_START) {
1567                ubi->fm_disabled = 1;
1568                force_scan = 1;
1569        }
1570
1571        if (force_scan)
1572                err = scan_all(ubi, ai, 0);
1573        else {
1574                err = scan_fast(ubi, &ai);
1575                if (err > 0 || mtd_is_eccerr(err)) {
1576                        if (err != UBI_NO_FASTMAP) {
1577                                destroy_ai(ai);
1578                                ai = alloc_ai();
1579                                if (!ai)
1580                                        return -ENOMEM;
1581
1582                                err = scan_all(ubi, ai, 0);
1583                        } else {
1584                                err = scan_all(ubi, ai, UBI_FM_MAX_START);
1585                        }
1586                }
1587        }
1588#else
1589        err = scan_all(ubi, ai, 0);
1590#endif
1591        if (err)
1592                goto out_ai;
1593
1594        ubi->bad_peb_count = ai->bad_peb_count;
1595        ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
1596        ubi->corr_peb_count = ai->corr_peb_count;
1597        ubi->max_ec = ai->max_ec;
1598        ubi->mean_ec = ai->mean_ec;
1599        dbg_gen("max. sequence number:       %llu", ai->max_sqnum);
1600
1601        err = ubi_read_volume_table(ubi, ai);
1602        if (err)
1603                goto out_ai;
1604
1605        err = ubi_wl_init(ubi, ai);
1606        if (err)
1607                goto out_vtbl;
1608
1609        err = ubi_eba_init(ubi, ai);
1610        if (err)
1611                goto out_wl;
1612
1613#ifdef CONFIG_MTD_UBI_FASTMAP
1614        if (ubi->fm && ubi_dbg_chk_fastmap(ubi)) {
1615                struct ubi_attach_info *scan_ai;
1616
1617                scan_ai = alloc_ai();
1618                if (!scan_ai) {
1619                        err = -ENOMEM;
1620                        goto out_wl;
1621                }
1622
1623                err = scan_all(ubi, scan_ai, 0);
1624                if (err) {
1625                        destroy_ai(scan_ai);
1626                        goto out_wl;
1627                }
1628
1629                err = self_check_eba(ubi, ai, scan_ai);
1630                destroy_ai(scan_ai);
1631
1632                if (err)
1633                        goto out_wl;
1634        }
1635#endif
1636
1637        destroy_ai(ai);
1638        return 0;
1639
1640out_wl:
1641        ubi_wl_close(ubi);
1642out_vtbl:
1643        ubi_free_all_volumes(ubi);
1644        vfree(ubi->vtbl);
1645out_ai:
1646        destroy_ai(ai);
1647        return err;
1648}
1649
1650/**
1651 * self_check_ai - check the attaching information.
1652 * @ubi: UBI device description object
1653 * @ai: attaching information
1654 *
1655 * This function returns zero if the attaching information is all right, and a
1656 * negative error code if not or if an error occurred.
1657 */
1658static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai)
1659{
1660        struct ubi_vid_io_buf *vidb = ai->vidb;
1661        struct ubi_vid_hdr *vidh = ubi_get_vid_hdr(vidb);
1662        int pnum, err, vols_found = 0;
1663        struct rb_node *rb1, *rb2;
1664        struct ubi_ainf_volume *av;
1665        struct ubi_ainf_peb *aeb, *last_aeb;
1666        uint8_t *buf;
1667
1668        if (!ubi_dbg_chk_gen(ubi))
1669                return 0;
1670
1671        /*
1672         * At first, check that attaching information is OK.
1673         */
1674        ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1675                int leb_count = 0;
1676
1677                cond_resched();
1678
1679                vols_found += 1;
1680
1681                if (ai->is_empty) {
1682                        ubi_err(ubi, "bad is_empty flag");
1683                        goto bad_av;
1684                }
1685
1686                if (av->vol_id < 0 || av->highest_lnum < 0 ||
1687                    av->leb_count < 0 || av->vol_type < 0 || av->used_ebs < 0 ||
1688                    av->data_pad < 0 || av->last_data_size < 0) {
1689                        ubi_err(ubi, "negative values");
1690                        goto bad_av;
1691                }
1692
1693                if (av->vol_id >= UBI_MAX_VOLUMES &&
1694                    av->vol_id < UBI_INTERNAL_VOL_START) {
1695                        ubi_err(ubi, "bad vol_id");
1696                        goto bad_av;
1697                }
1698
1699                if (av->vol_id > ai->highest_vol_id) {
1700                        ubi_err(ubi, "highest_vol_id is %d, but vol_id %d is there",
1701                                ai->highest_vol_id, av->vol_id);
1702                        goto out;
1703                }
1704
1705                if (av->vol_type != UBI_DYNAMIC_VOLUME &&
1706                    av->vol_type != UBI_STATIC_VOLUME) {
1707                        ubi_err(ubi, "bad vol_type");
1708                        goto bad_av;
1709                }
1710
1711                if (av->data_pad > ubi->leb_size / 2) {
1712                        ubi_err(ubi, "bad data_pad");
1713                        goto bad_av;
1714                }
1715
1716                last_aeb = NULL;
1717                ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
1718                        cond_resched();
1719
1720                        last_aeb = aeb;
1721                        leb_count += 1;
1722
1723                        if (aeb->pnum < 0 || aeb->ec < 0) {
1724                                ubi_err(ubi, "negative values");
1725                                goto bad_aeb;
1726                        }
1727
1728                        if (aeb->ec < ai->min_ec) {
1729                                ubi_err(ubi, "bad ai->min_ec (%d), %d found",
1730                                        ai->min_ec, aeb->ec);
1731                                goto bad_aeb;
1732                        }
1733
1734                        if (aeb->ec > ai->max_ec) {
1735                                ubi_err(ubi, "bad ai->max_ec (%d), %d found",
1736                                        ai->max_ec, aeb->ec);
1737                                goto bad_aeb;
1738                        }
1739
1740                        if (aeb->pnum >= ubi->peb_count) {
1741                                ubi_err(ubi, "too high PEB number %d, total PEBs %d",
1742                                        aeb->pnum, ubi->peb_count);
1743                                goto bad_aeb;
1744                        }
1745
1746                        if (av->vol_type == UBI_STATIC_VOLUME) {
1747                                if (aeb->lnum >= av->used_ebs) {
1748                                        ubi_err(ubi, "bad lnum or used_ebs");
1749                                        goto bad_aeb;
1750                                }
1751                        } else {
1752                                if (av->used_ebs != 0) {
1753                                        ubi_err(ubi, "non-zero used_ebs");
1754                                        goto bad_aeb;
1755                                }
1756                        }
1757
1758                        if (aeb->lnum > av->highest_lnum) {
1759                                ubi_err(ubi, "incorrect highest_lnum or lnum");
1760                                goto bad_aeb;
1761                        }
1762                }
1763
1764                if (av->leb_count != leb_count) {
1765                        ubi_err(ubi, "bad leb_count, %d objects in the tree",
1766                                leb_count);
1767                        goto bad_av;
1768                }
1769
1770                if (!last_aeb)
1771                        continue;
1772
1773                aeb = last_aeb;
1774
1775                if (aeb->lnum != av->highest_lnum) {
1776                        ubi_err(ubi, "bad highest_lnum");
1777                        goto bad_aeb;
1778                }
1779        }
1780
1781        if (vols_found != ai->vols_found) {
1782                ubi_err(ubi, "bad ai->vols_found %d, should be %d",
1783                        ai->vols_found, vols_found);
1784                goto out;
1785        }
1786
1787        /* Check that attaching information is correct */
1788        ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1789                last_aeb = NULL;
1790                ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
1791                        int vol_type;
1792
1793                        cond_resched();
1794
1795                        last_aeb = aeb;
1796
1797                        err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidb, 1);
1798                        if (err && err != UBI_IO_BITFLIPS) {
1799                                ubi_err(ubi, "VID header is not OK (%d)",
1800                                        err);
1801                                if (err > 0)
1802                                        err = -EIO;
1803                                return err;
1804                        }
1805
1806                        vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
1807                                   UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
1808                        if (av->vol_type != vol_type) {
1809                                ubi_err(ubi, "bad vol_type");
1810                                goto bad_vid_hdr;
1811                        }
1812
1813                        if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) {
1814                                ubi_err(ubi, "bad sqnum %llu", aeb->sqnum);
1815                                goto bad_vid_hdr;
1816                        }
1817
1818                        if (av->vol_id != be32_to_cpu(vidh->vol_id)) {
1819                                ubi_err(ubi, "bad vol_id %d", av->vol_id);
1820                                goto bad_vid_hdr;
1821                        }
1822
1823                        if (av->compat != vidh->compat) {
1824                                ubi_err(ubi, "bad compat %d", vidh->compat);
1825                                goto bad_vid_hdr;
1826                        }
1827
1828                        if (aeb->lnum != be32_to_cpu(vidh->lnum)) {
1829                                ubi_err(ubi, "bad lnum %d", aeb->lnum);
1830                                goto bad_vid_hdr;
1831                        }
1832
1833                        if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) {
1834                                ubi_err(ubi, "bad used_ebs %d", av->used_ebs);
1835                                goto bad_vid_hdr;
1836                        }
1837
1838                        if (av->data_pad != be32_to_cpu(vidh->data_pad)) {
1839                                ubi_err(ubi, "bad data_pad %d", av->data_pad);
1840                                goto bad_vid_hdr;
1841                        }
1842                }
1843
1844                if (!last_aeb)
1845                        continue;
1846
1847                if (av->highest_lnum != be32_to_cpu(vidh->lnum)) {
1848                        ubi_err(ubi, "bad highest_lnum %d", av->highest_lnum);
1849                        goto bad_vid_hdr;
1850                }
1851
1852                if (av->last_data_size != be32_to_cpu(vidh->data_size)) {
1853                        ubi_err(ubi, "bad last_data_size %d",
1854                                av->last_data_size);
1855                        goto bad_vid_hdr;
1856                }
1857        }
1858
1859        /*
1860         * Make sure that all the physical eraseblocks are in one of the lists
1861         * or trees.
1862         */
1863        buf = kzalloc(ubi->peb_count, GFP_KERNEL);
1864        if (!buf)
1865                return -ENOMEM;
1866
1867        for (pnum = 0; pnum < ubi->peb_count; pnum++) {
1868                err = ubi_io_is_bad(ubi, pnum);
1869                if (err < 0) {
1870                        kfree(buf);
1871                        return err;
1872                } else if (err)
1873                        buf[pnum] = 1;
1874        }
1875
1876        ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb)
1877                ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
1878                        buf[aeb->pnum] = 1;
1879
1880        list_for_each_entry(aeb, &ai->free, u.list)
1881                buf[aeb->pnum] = 1;
1882
1883        list_for_each_entry(aeb, &ai->corr, u.list)
1884                buf[aeb->pnum] = 1;
1885
1886        list_for_each_entry(aeb, &ai->erase, u.list)
1887                buf[aeb->pnum] = 1;
1888
1889        list_for_each_entry(aeb, &ai->alien, u.list)
1890                buf[aeb->pnum] = 1;
1891
1892        err = 0;
1893        for (pnum = 0; pnum < ubi->peb_count; pnum++)
1894                if (!buf[pnum]) {
1895                        ubi_err(ubi, "PEB %d is not referred", pnum);
1896                        err = 1;
1897                }
1898
1899        kfree(buf);
1900        if (err)
1901                goto out;
1902        return 0;
1903
1904bad_aeb:
1905        ubi_err(ubi, "bad attaching information about LEB %d", aeb->lnum);
1906        ubi_dump_aeb(aeb, 0);
1907        ubi_dump_av(av);
1908        goto out;
1909
1910bad_av:
1911        ubi_err(ubi, "bad attaching information about volume %d", av->vol_id);
1912        ubi_dump_av(av);
1913        goto out;
1914
1915bad_vid_hdr:
1916        ubi_err(ubi, "bad attaching information about volume %d", av->vol_id);
1917        ubi_dump_av(av);
1918        ubi_dump_vid_hdr(vidh);
1919
1920out:
1921        dump_stack();
1922        return -EINVAL;
1923}
1924