Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) International Business Machines Corp., 2006
0004  *
0005  * Author: Artem Bityutskiy (Битюцкий Артём)
0006  */
0007 
0008 /*
0009  * UBI attaching sub-system.
0010  *
0011  * This sub-system is responsible for attaching MTD devices and it also
0012  * implements flash media scanning.
0013  *
0014  * The attaching information is represented by a &struct ubi_attach_info'
0015  * object. Information about volumes is represented by &struct ubi_ainf_volume
0016  * objects which are kept in volume RB-tree with root at the @volumes field.
0017  * The RB-tree is indexed by the volume ID.
0018  *
0019  * Logical eraseblocks are represented by &struct ubi_ainf_peb objects. These
0020  * objects are kept in per-volume RB-trees with the root at the corresponding
0021  * &struct ubi_ainf_volume object. To put it differently, we keep an RB-tree of
0022  * per-volume objects and each of these objects is the root of RB-tree of
0023  * per-LEB objects.
0024  *
0025  * Corrupted physical eraseblocks are put to the @corr list, free physical
0026  * eraseblocks are put to the @free list and the physical eraseblock to be
0027  * erased are put to the @erase list.
0028  *
0029  * About corruptions
0030  * ~~~~~~~~~~~~~~~~~
0031  *
0032  * UBI protects EC and VID headers with CRC-32 checksums, so it can detect
0033  * whether the headers are corrupted or not. Sometimes UBI also protects the
0034  * data with CRC-32, e.g., when it executes the atomic LEB change operation, or
0035  * when it moves the contents of a PEB for wear-leveling purposes.
0036  *
0037  * UBI tries to distinguish between 2 types of corruptions.
0038  *
0039  * 1. Corruptions caused by power cuts. These are expected corruptions and UBI
0040  * tries to handle them gracefully, without printing too many warnings and
0041  * error messages. The idea is that we do not lose important data in these
0042  * cases - we may lose only the data which were being written to the media just
0043  * before the power cut happened, and the upper layers (e.g., UBIFS) are
0044  * supposed to handle such data losses (e.g., by using the FS journal).
0045  *
0046  * When UBI detects a corruption (CRC-32 mismatch) in a PEB, and it looks like
0047  * the reason is a power cut, UBI puts this PEB to the @erase list, and all
0048  * PEBs in the @erase list are scheduled for erasure later.
0049  *
0050  * 2. Unexpected corruptions which are not caused by power cuts. During
0051  * attaching, such PEBs are put to the @corr list and UBI preserves them.
0052  * Obviously, this lessens the amount of available PEBs, and if at some  point
0053  * UBI runs out of free PEBs, it switches to R/O mode. UBI also loudly informs
0054  * about such PEBs every time the MTD device is attached.
0055  *
0056  * However, it is difficult to reliably distinguish between these types of
0057  * corruptions and UBI's strategy is as follows (in case of attaching by
0058  * scanning). UBI assumes corruption type 2 if the VID header is corrupted and
0059  * the data area does not contain all 0xFFs, and there were no bit-flips or
0060  * integrity errors (e.g., ECC errors in case of NAND) while reading the data
0061  * area.  Otherwise UBI assumes corruption type 1. So the decision criteria
0062  * are as follows.
0063  *   o If the data area contains only 0xFFs, there are no data, and it is safe
0064  *     to just erase this PEB - this is corruption type 1.
0065  *   o If the data area has bit-flips or data integrity errors (ECC errors on
0066  *     NAND), it is probably a PEB which was being erased when power cut
0067  *     happened, so this is corruption type 1. However, this is just a guess,
0068  *     which might be wrong.
0069  *   o Otherwise this is corruption type 2.
0070  */
0071 
0072 #include <linux/err.h>
0073 #include <linux/slab.h>
0074 #include <linux/crc32.h>
0075 #include <linux/math64.h>
0076 #include <linux/random.h>
0077 #include "ubi.h"
0078 
0079 static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai);
0080 
0081 #define AV_FIND     BIT(0)
0082 #define AV_ADD      BIT(1)
0083 #define AV_FIND_OR_ADD  (AV_FIND | AV_ADD)
0084 
0085 /**
0086  * find_or_add_av - internal function to find a volume, add a volume or do
0087  *          both (find and add if missing).
0088  * @ai: attaching information
0089  * @vol_id: the requested volume ID
0090  * @flags: a combination of the %AV_FIND and %AV_ADD flags describing the
0091  *     expected operation. If only %AV_ADD is set, -EEXIST is returned
0092  *     if the volume already exists. If only %AV_FIND is set, NULL is
0093  *     returned if the volume does not exist. And if both flags are
0094  *     set, the helper first tries to find an existing volume, and if
0095  *     it does not exist it creates a new one.
0096  * @created: in value used to inform the caller whether it"s a newly created
0097  *       volume or not.
0098  *
0099  * This function returns a pointer to a volume description or an ERR_PTR if
0100  * the operation failed. It can also return NULL if only %AV_FIND is set and
0101  * the volume does not exist.
0102  */
0103 static struct ubi_ainf_volume *find_or_add_av(struct ubi_attach_info *ai,
0104                           int vol_id, unsigned int flags,
0105                           bool *created)
0106 {
0107     struct ubi_ainf_volume *av;
0108     struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
0109 
0110     /* Walk the volume RB-tree to look if this volume is already present */
0111     while (*p) {
0112         parent = *p;
0113         av = rb_entry(parent, struct ubi_ainf_volume, rb);
0114 
0115         if (vol_id == av->vol_id) {
0116             *created = false;
0117 
0118             if (!(flags & AV_FIND))
0119                 return ERR_PTR(-EEXIST);
0120 
0121             return av;
0122         }
0123 
0124         if (vol_id > av->vol_id)
0125             p = &(*p)->rb_left;
0126         else
0127             p = &(*p)->rb_right;
0128     }
0129 
0130     if (!(flags & AV_ADD))
0131         return NULL;
0132 
0133     /* The volume is absent - add it */
0134     av = kzalloc(sizeof(*av), GFP_KERNEL);
0135     if (!av)
0136         return ERR_PTR(-ENOMEM);
0137 
0138     av->vol_id = vol_id;
0139 
0140     if (vol_id > ai->highest_vol_id)
0141         ai->highest_vol_id = vol_id;
0142 
0143     rb_link_node(&av->rb, parent, p);
0144     rb_insert_color(&av->rb, &ai->volumes);
0145     ai->vols_found += 1;
0146     *created = true;
0147     dbg_bld("added volume %d", vol_id);
0148     return av;
0149 }
0150 
0151 /**
0152  * ubi_find_or_add_av - search for a volume in the attaching information and
0153  *          add one if it does not exist.
0154  * @ai: attaching information
0155  * @vol_id: the requested volume ID
0156  * @created: whether the volume has been created or not
0157  *
0158  * This function returns a pointer to the new volume description or an
0159  * ERR_PTR if the operation failed.
0160  */
0161 static struct ubi_ainf_volume *ubi_find_or_add_av(struct ubi_attach_info *ai,
0162                           int vol_id, bool *created)
0163 {
0164     return find_or_add_av(ai, vol_id, AV_FIND_OR_ADD, created);
0165 }
0166 
0167 /**
0168  * ubi_alloc_aeb - allocate an aeb element
0169  * @ai: attaching information
0170  * @pnum: physical eraseblock number
0171  * @ec: erase counter of the physical eraseblock
0172  *
0173  * Allocate an aeb object and initialize the pnum and ec information.
0174  * vol_id and lnum are set to UBI_UNKNOWN, and the other fields are
0175  * initialized to zero.
0176  * Note that the element is not added in any list or RB tree.
0177  */
0178 struct ubi_ainf_peb *ubi_alloc_aeb(struct ubi_attach_info *ai, int pnum,
0179                    int ec)
0180 {
0181     struct ubi_ainf_peb *aeb;
0182 
0183     aeb = kmem_cache_zalloc(ai->aeb_slab_cache, GFP_KERNEL);
0184     if (!aeb)
0185         return NULL;
0186 
0187     aeb->pnum = pnum;
0188     aeb->ec = ec;
0189     aeb->vol_id = UBI_UNKNOWN;
0190     aeb->lnum = UBI_UNKNOWN;
0191 
0192     return aeb;
0193 }
0194 
0195 /**
0196  * ubi_free_aeb - free an aeb element
0197  * @ai: attaching information
0198  * @aeb: the element to free
0199  *
0200  * Free an aeb object. The caller must have removed the element from any list
0201  * or RB tree.
0202  */
0203 void ubi_free_aeb(struct ubi_attach_info *ai, struct ubi_ainf_peb *aeb)
0204 {
0205     kmem_cache_free(ai->aeb_slab_cache, aeb);
0206 }
0207 
0208 /**
0209  * add_to_list - add physical eraseblock to a list.
0210  * @ai: attaching information
0211  * @pnum: physical eraseblock number to add
0212  * @vol_id: the last used volume id for the PEB
0213  * @lnum: the last used LEB number for the PEB
0214  * @ec: erase counter of the physical eraseblock
0215  * @to_head: if not zero, add to the head of the list
0216  * @list: the list to add to
0217  *
0218  * This function allocates a 'struct ubi_ainf_peb' object for physical
0219  * eraseblock @pnum and adds it to the "free", "erase", or "alien" lists.
0220  * It stores the @lnum and @vol_id alongside, which can both be
0221  * %UBI_UNKNOWN if they are not available, not readable, or not assigned.
0222  * If @to_head is not zero, PEB will be added to the head of the list, which
0223  * basically means it will be processed first later. E.g., we add corrupted
0224  * PEBs (corrupted due to power cuts) to the head of the erase list to make
0225  * sure we erase them first and get rid of corruptions ASAP. This function
0226  * returns zero in case of success and a negative error code in case of
0227  * failure.
0228  */
0229 static int add_to_list(struct ubi_attach_info *ai, int pnum, int vol_id,
0230                int lnum, int ec, int to_head, struct list_head *list)
0231 {
0232     struct ubi_ainf_peb *aeb;
0233 
0234     if (list == &ai->free) {
0235         dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
0236     } else if (list == &ai->erase) {
0237         dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
0238     } else if (list == &ai->alien) {
0239         dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
0240         ai->alien_peb_count += 1;
0241     } else
0242         BUG();
0243 
0244     aeb = ubi_alloc_aeb(ai, pnum, ec);
0245     if (!aeb)
0246         return -ENOMEM;
0247 
0248     aeb->vol_id = vol_id;
0249     aeb->lnum = lnum;
0250     if (to_head)
0251         list_add(&aeb->u.list, list);
0252     else
0253         list_add_tail(&aeb->u.list, list);
0254     return 0;
0255 }
0256 
0257 /**
0258  * add_corrupted - add a corrupted physical eraseblock.
0259  * @ai: attaching information
0260  * @pnum: physical eraseblock number to add
0261  * @ec: erase counter of the physical eraseblock
0262  *
0263  * This function allocates a 'struct ubi_ainf_peb' object for a corrupted
0264  * physical eraseblock @pnum and adds it to the 'corr' list.  The corruption
0265  * was presumably not caused by a power cut. Returns zero in case of success
0266  * and a negative error code in case of failure.
0267  */
0268 static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec)
0269 {
0270     struct ubi_ainf_peb *aeb;
0271 
0272     dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
0273 
0274     aeb = ubi_alloc_aeb(ai, pnum, ec);
0275     if (!aeb)
0276         return -ENOMEM;
0277 
0278     ai->corr_peb_count += 1;
0279     list_add(&aeb->u.list, &ai->corr);
0280     return 0;
0281 }
0282 
0283 /**
0284  * add_fastmap - add a Fastmap related physical eraseblock.
0285  * @ai: attaching information
0286  * @pnum: physical eraseblock number the VID header came from
0287  * @vid_hdr: the volume identifier header
0288  * @ec: erase counter of the physical eraseblock
0289  *
0290  * This function allocates a 'struct ubi_ainf_peb' object for a Fastamp
0291  * physical eraseblock @pnum and adds it to the 'fastmap' list.
0292  * Such blocks can be Fastmap super and data blocks from both the most
0293  * recent Fastmap we're attaching from or from old Fastmaps which will
0294  * be erased.
0295  */
0296 static int add_fastmap(struct ubi_attach_info *ai, int pnum,
0297                struct ubi_vid_hdr *vid_hdr, int ec)
0298 {
0299     struct ubi_ainf_peb *aeb;
0300 
0301     aeb = ubi_alloc_aeb(ai, pnum, ec);
0302     if (!aeb)
0303         return -ENOMEM;
0304 
0305     aeb->vol_id = be32_to_cpu(vid_hdr->vol_id);
0306     aeb->sqnum = be64_to_cpu(vid_hdr->sqnum);
0307     list_add(&aeb->u.list, &ai->fastmap);
0308 
0309     dbg_bld("add to fastmap list: PEB %d, vol_id %d, sqnum: %llu", pnum,
0310         aeb->vol_id, aeb->sqnum);
0311 
0312     return 0;
0313 }
0314 
0315 /**
0316  * validate_vid_hdr - check volume identifier header.
0317  * @ubi: UBI device description object
0318  * @vid_hdr: the volume identifier header to check
0319  * @av: information about the volume this logical eraseblock belongs to
0320  * @pnum: physical eraseblock number the VID header came from
0321  *
0322  * This function checks that data stored in @vid_hdr is consistent. Returns
0323  * non-zero if an inconsistency was found and zero if not.
0324  *
0325  * Note, UBI does sanity check of everything it reads from the flash media.
0326  * Most of the checks are done in the I/O sub-system. Here we check that the
0327  * information in the VID header is consistent to the information in other VID
0328  * headers of the same volume.
0329  */
0330 static int validate_vid_hdr(const struct ubi_device *ubi,
0331                 const struct ubi_vid_hdr *vid_hdr,
0332                 const struct ubi_ainf_volume *av, int pnum)
0333 {
0334     int vol_type = vid_hdr->vol_type;
0335     int vol_id = be32_to_cpu(vid_hdr->vol_id);
0336     int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
0337     int data_pad = be32_to_cpu(vid_hdr->data_pad);
0338 
0339     if (av->leb_count != 0) {
0340         int av_vol_type;
0341 
0342         /*
0343          * This is not the first logical eraseblock belonging to this
0344          * volume. Ensure that the data in its VID header is consistent
0345          * to the data in previous logical eraseblock headers.
0346          */
0347 
0348         if (vol_id != av->vol_id) {
0349             ubi_err(ubi, "inconsistent vol_id");
0350             goto bad;
0351         }
0352 
0353         if (av->vol_type == UBI_STATIC_VOLUME)
0354             av_vol_type = UBI_VID_STATIC;
0355         else
0356             av_vol_type = UBI_VID_DYNAMIC;
0357 
0358         if (vol_type != av_vol_type) {
0359             ubi_err(ubi, "inconsistent vol_type");
0360             goto bad;
0361         }
0362 
0363         if (used_ebs != av->used_ebs) {
0364             ubi_err(ubi, "inconsistent used_ebs");
0365             goto bad;
0366         }
0367 
0368         if (data_pad != av->data_pad) {
0369             ubi_err(ubi, "inconsistent data_pad");
0370             goto bad;
0371         }
0372     }
0373 
0374     return 0;
0375 
0376 bad:
0377     ubi_err(ubi, "inconsistent VID header at PEB %d", pnum);
0378     ubi_dump_vid_hdr(vid_hdr);
0379     ubi_dump_av(av);
0380     return -EINVAL;
0381 }
0382 
0383 /**
0384  * add_volume - add volume to the attaching information.
0385  * @ai: attaching information
0386  * @vol_id: ID of the volume to add
0387  * @pnum: physical eraseblock number
0388  * @vid_hdr: volume identifier header
0389  *
0390  * If the volume corresponding to the @vid_hdr logical eraseblock is already
0391  * present in the attaching information, this function does nothing. Otherwise
0392  * it adds corresponding volume to the attaching information. Returns a pointer
0393  * to the allocated "av" object in case of success and a negative error code in
0394  * case of failure.
0395  */
0396 static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai,
0397                       int vol_id, int pnum,
0398                       const struct ubi_vid_hdr *vid_hdr)
0399 {
0400     struct ubi_ainf_volume *av;
0401     bool created;
0402 
0403     ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));
0404 
0405     av = ubi_find_or_add_av(ai, vol_id, &created);
0406     if (IS_ERR(av) || !created)
0407         return av;
0408 
0409     av->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
0410     av->data_pad = be32_to_cpu(vid_hdr->data_pad);
0411     av->compat = vid_hdr->compat;
0412     av->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
0413                                 : UBI_STATIC_VOLUME;
0414 
0415     return av;
0416 }
0417 
0418 /**
0419  * ubi_compare_lebs - find out which logical eraseblock is newer.
0420  * @ubi: UBI device description object
0421  * @aeb: first logical eraseblock to compare
0422  * @pnum: physical eraseblock number of the second logical eraseblock to
0423  * compare
0424  * @vid_hdr: volume identifier header of the second logical eraseblock
0425  *
0426  * This function compares 2 copies of a LEB and informs which one is newer. In
0427  * case of success this function returns a positive value, in case of failure, a
0428  * negative error code is returned. The success return codes use the following
0429  * bits:
0430  *     o bit 0 is cleared: the first PEB (described by @aeb) is newer than the
0431  *       second PEB (described by @pnum and @vid_hdr);
0432  *     o bit 0 is set: the second PEB is newer;
0433  *     o bit 1 is cleared: no bit-flips were detected in the newer LEB;
0434  *     o bit 1 is set: bit-flips were detected in the newer LEB;
0435  *     o bit 2 is cleared: the older LEB is not corrupted;
0436  *     o bit 2 is set: the older LEB is corrupted.
0437  */
0438 int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,
0439             int pnum, const struct ubi_vid_hdr *vid_hdr)
0440 {
0441     int len, err, second_is_newer, bitflips = 0, corrupted = 0;
0442     uint32_t data_crc, crc;
0443     struct ubi_vid_io_buf *vidb = NULL;
0444     unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);
0445 
0446     if (sqnum2 == aeb->sqnum) {
0447         /*
0448          * This must be a really ancient UBI image which has been
0449          * created before sequence numbers support has been added. At
0450          * that times we used 32-bit LEB versions stored in logical
0451          * eraseblocks. That was before UBI got into mainline. We do not
0452          * support these images anymore. Well, those images still work,
0453          * but only if no unclean reboots happened.
0454          */
0455         ubi_err(ubi, "unsupported on-flash UBI format");
0456         return -EINVAL;
0457     }
0458 
0459     /* Obviously the LEB with lower sequence counter is older */
0460     second_is_newer = (sqnum2 > aeb->sqnum);
0461 
0462     /*
0463      * Now we know which copy is newer. If the copy flag of the PEB with
0464      * newer version is not set, then we just return, otherwise we have to
0465      * check data CRC. For the second PEB we already have the VID header,
0466      * for the first one - we'll need to re-read it from flash.
0467      *
0468      * Note: this may be optimized so that we wouldn't read twice.
0469      */
0470 
0471     if (second_is_newer) {
0472         if (!vid_hdr->copy_flag) {
0473             /* It is not a copy, so it is newer */
0474             dbg_bld("second PEB %d is newer, copy_flag is unset",
0475                 pnum);
0476             return 1;
0477         }
0478     } else {
0479         if (!aeb->copy_flag) {
0480             /* It is not a copy, so it is newer */
0481             dbg_bld("first PEB %d is newer, copy_flag is unset",
0482                 pnum);
0483             return bitflips << 1;
0484         }
0485 
0486         vidb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);
0487         if (!vidb)
0488             return -ENOMEM;
0489 
0490         pnum = aeb->pnum;
0491         err = ubi_io_read_vid_hdr(ubi, pnum, vidb, 0);
0492         if (err) {
0493             if (err == UBI_IO_BITFLIPS)
0494                 bitflips = 1;
0495             else {
0496                 ubi_err(ubi, "VID of PEB %d header is bad, but it was OK earlier, err %d",
0497                     pnum, err);
0498                 if (err > 0)
0499                     err = -EIO;
0500 
0501                 goto out_free_vidh;
0502             }
0503         }
0504 
0505         vid_hdr = ubi_get_vid_hdr(vidb);
0506     }
0507 
0508     /* Read the data of the copy and check the CRC */
0509 
0510     len = be32_to_cpu(vid_hdr->data_size);
0511 
0512     mutex_lock(&ubi->buf_mutex);
0513     err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, len);
0514     if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
0515         goto out_unlock;
0516 
0517     data_crc = be32_to_cpu(vid_hdr->data_crc);
0518     crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, len);
0519     if (crc != data_crc) {
0520         dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
0521             pnum, crc, data_crc);
0522         corrupted = 1;
0523         bitflips = 0;
0524         second_is_newer = !second_is_newer;
0525     } else {
0526         dbg_bld("PEB %d CRC is OK", pnum);
0527         bitflips |= !!err;
0528     }
0529     mutex_unlock(&ubi->buf_mutex);
0530 
0531     ubi_free_vid_buf(vidb);
0532 
0533     if (second_is_newer)
0534         dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
0535     else
0536         dbg_bld("first PEB %d is newer, copy_flag is set", pnum);
0537 
0538     return second_is_newer | (bitflips << 1) | (corrupted << 2);
0539 
0540 out_unlock:
0541     mutex_unlock(&ubi->buf_mutex);
0542 out_free_vidh:
0543     ubi_free_vid_buf(vidb);
0544     return err;
0545 }
0546 
0547 /**
0548  * ubi_add_to_av - add used physical eraseblock to the attaching information.
0549  * @ubi: UBI device description object
0550  * @ai: attaching information
0551  * @pnum: the physical eraseblock number
0552  * @ec: erase counter
0553  * @vid_hdr: the volume identifier header
0554  * @bitflips: if bit-flips were detected when this physical eraseblock was read
0555  *
0556  * This function adds information about a used physical eraseblock to the
0557  * 'used' tree of the corresponding volume. The function is rather complex
0558  * because it has to handle cases when this is not the first physical
0559  * eraseblock belonging to the same logical eraseblock, and the newer one has
0560  * to be picked, while the older one has to be dropped. This function returns
0561  * zero in case of success and a negative error code in case of failure.
0562  */
0563 int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum,
0564           int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips)
0565 {
0566     int err, vol_id, lnum;
0567     unsigned long long sqnum;
0568     struct ubi_ainf_volume *av;
0569     struct ubi_ainf_peb *aeb;
0570     struct rb_node **p, *parent = NULL;
0571 
0572     vol_id = be32_to_cpu(vid_hdr->vol_id);
0573     lnum = be32_to_cpu(vid_hdr->lnum);
0574     sqnum = be64_to_cpu(vid_hdr->sqnum);
0575 
0576     dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",
0577         pnum, vol_id, lnum, ec, sqnum, bitflips);
0578 
0579     av = add_volume(ai, vol_id, pnum, vid_hdr);
0580     if (IS_ERR(av))
0581         return PTR_ERR(av);
0582 
0583     if (ai->max_sqnum < sqnum)
0584         ai->max_sqnum = sqnum;
0585 
0586     /*
0587      * Walk the RB-tree of logical eraseblocks of volume @vol_id to look
0588      * if this is the first instance of this logical eraseblock or not.
0589      */
0590     p = &av->root.rb_node;
0591     while (*p) {
0592         int cmp_res;
0593 
0594         parent = *p;
0595         aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
0596         if (lnum != aeb->lnum) {
0597             if (lnum < aeb->lnum)
0598                 p = &(*p)->rb_left;
0599             else
0600                 p = &(*p)->rb_right;
0601             continue;
0602         }
0603 
0604         /*
0605          * There is already a physical eraseblock describing the same
0606          * logical eraseblock present.
0607          */
0608 
0609         dbg_bld("this LEB already exists: PEB %d, sqnum %llu, EC %d",
0610             aeb->pnum, aeb->sqnum, aeb->ec);
0611 
0612         /*
0613          * Make sure that the logical eraseblocks have different
0614          * sequence numbers. Otherwise the image is bad.
0615          *
0616          * However, if the sequence number is zero, we assume it must
0617          * be an ancient UBI image from the era when UBI did not have
0618          * sequence numbers. We still can attach these images, unless
0619          * there is a need to distinguish between old and new
0620          * eraseblocks, in which case we'll refuse the image in
0621          * 'ubi_compare_lebs()'. In other words, we attach old clean
0622          * images, but refuse attaching old images with duplicated
0623          * logical eraseblocks because there was an unclean reboot.
0624          */
0625         if (aeb->sqnum == sqnum && sqnum != 0) {
0626             ubi_err(ubi, "two LEBs with same sequence number %llu",
0627                 sqnum);
0628             ubi_dump_aeb(aeb, 0);
0629             ubi_dump_vid_hdr(vid_hdr);
0630             return -EINVAL;
0631         }
0632 
0633         /*
0634          * Now we have to drop the older one and preserve the newer
0635          * one.
0636          */
0637         cmp_res = ubi_compare_lebs(ubi, aeb, pnum, vid_hdr);
0638         if (cmp_res < 0)
0639             return cmp_res;
0640 
0641         if (cmp_res & 1) {
0642             /*
0643              * This logical eraseblock is newer than the one
0644              * found earlier.
0645              */
0646             err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
0647             if (err)
0648                 return err;
0649 
0650             err = add_to_list(ai, aeb->pnum, aeb->vol_id,
0651                       aeb->lnum, aeb->ec, cmp_res & 4,
0652                       &ai->erase);
0653             if (err)
0654                 return err;
0655 
0656             aeb->ec = ec;
0657             aeb->pnum = pnum;
0658             aeb->vol_id = vol_id;
0659             aeb->lnum = lnum;
0660             aeb->scrub = ((cmp_res & 2) || bitflips);
0661             aeb->copy_flag = vid_hdr->copy_flag;
0662             aeb->sqnum = sqnum;
0663 
0664             if (av->highest_lnum == lnum)
0665                 av->last_data_size =
0666                     be32_to_cpu(vid_hdr->data_size);
0667 
0668             return 0;
0669         } else {
0670             /*
0671              * This logical eraseblock is older than the one found
0672              * previously.
0673              */
0674             return add_to_list(ai, pnum, vol_id, lnum, ec,
0675                        cmp_res & 4, &ai->erase);
0676         }
0677     }
0678 
0679     /*
0680      * We've met this logical eraseblock for the first time, add it to the
0681      * attaching information.
0682      */
0683 
0684     err = validate_vid_hdr(ubi, vid_hdr, av, pnum);
0685     if (err)
0686         return err;
0687 
0688     aeb = ubi_alloc_aeb(ai, pnum, ec);
0689     if (!aeb)
0690         return -ENOMEM;
0691 
0692     aeb->vol_id = vol_id;
0693     aeb->lnum = lnum;
0694     aeb->scrub = bitflips;
0695     aeb->copy_flag = vid_hdr->copy_flag;
0696     aeb->sqnum = sqnum;
0697 
0698     if (av->highest_lnum <= lnum) {
0699         av->highest_lnum = lnum;
0700         av->last_data_size = be32_to_cpu(vid_hdr->data_size);
0701     }
0702 
0703     av->leb_count += 1;
0704     rb_link_node(&aeb->u.rb, parent, p);
0705     rb_insert_color(&aeb->u.rb, &av->root);
0706     return 0;
0707 }
0708 
0709 /**
0710  * ubi_add_av - add volume to the attaching information.
0711  * @ai: attaching information
0712  * @vol_id: the requested volume ID
0713  *
0714  * This function returns a pointer to the new volume description or an
0715  * ERR_PTR if the operation failed.
0716  */
0717 struct ubi_ainf_volume *ubi_add_av(struct ubi_attach_info *ai, int vol_id)
0718 {
0719     bool created;
0720 
0721     return find_or_add_av(ai, vol_id, AV_ADD, &created);
0722 }
0723 
0724 /**
0725  * ubi_find_av - find volume in the attaching information.
0726  * @ai: attaching information
0727  * @vol_id: the requested volume ID
0728  *
0729  * This function returns a pointer to the volume description or %NULL if there
0730  * are no data about this volume in the attaching information.
0731  */
0732 struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai,
0733                     int vol_id)
0734 {
0735     bool created;
0736 
0737     return find_or_add_av((struct ubi_attach_info *)ai, vol_id, AV_FIND,
0738                   &created);
0739 }
0740 
0741 static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av,
0742                struct list_head *list);
0743 
0744 /**
0745  * ubi_remove_av - delete attaching information about a volume.
0746  * @ai: attaching information
0747  * @av: the volume attaching information to delete
0748  */
0749 void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
0750 {
0751     dbg_bld("remove attaching information about volume %d", av->vol_id);
0752 
0753     rb_erase(&av->rb, &ai->volumes);
0754     destroy_av(ai, av, &ai->erase);
0755     ai->vols_found -= 1;
0756 }
0757 
0758 /**
0759  * early_erase_peb - erase a physical eraseblock.
0760  * @ubi: UBI device description object
0761  * @ai: attaching information
0762  * @pnum: physical eraseblock number to erase;
0763  * @ec: erase counter value to write (%UBI_UNKNOWN if it is unknown)
0764  *
0765  * This function erases physical eraseblock 'pnum', and writes the erase
0766  * counter header to it. This function should only be used on UBI device
0767  * initialization stages, when the EBA sub-system had not been yet initialized.
0768  * This function returns zero in case of success and a negative error code in
0769  * case of failure.
0770  */
0771 static int early_erase_peb(struct ubi_device *ubi,
0772                const struct ubi_attach_info *ai, int pnum, int ec)
0773 {
0774     int err;
0775     struct ubi_ec_hdr *ec_hdr;
0776 
0777     if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
0778         /*
0779          * Erase counter overflow. Upgrade UBI and use 64-bit
0780          * erase counters internally.
0781          */
0782         ubi_err(ubi, "erase counter overflow at PEB %d, EC %d",
0783             pnum, ec);
0784         return -EINVAL;
0785     }
0786 
0787     ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
0788     if (!ec_hdr)
0789         return -ENOMEM;
0790 
0791     ec_hdr->ec = cpu_to_be64(ec);
0792 
0793     err = ubi_io_sync_erase(ubi, pnum, 0);
0794     if (err < 0)
0795         goto out_free;
0796 
0797     err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
0798 
0799 out_free:
0800     kfree(ec_hdr);
0801     return err;
0802 }
0803 
0804 /**
0805  * ubi_early_get_peb - get a free physical eraseblock.
0806  * @ubi: UBI device description object
0807  * @ai: attaching information
0808  *
0809  * This function returns a free physical eraseblock. It is supposed to be
0810  * called on the UBI initialization stages when the wear-leveling sub-system is
0811  * not initialized yet. This function picks a physical eraseblocks from one of
0812  * the lists, writes the EC header if it is needed, and removes it from the
0813  * list.
0814  *
0815  * This function returns a pointer to the "aeb" of the found free PEB in case
0816  * of success and an error code in case of failure.
0817  */
0818 struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi,
0819                        struct ubi_attach_info *ai)
0820 {
0821     int err = 0;
0822     struct ubi_ainf_peb *aeb, *tmp_aeb;
0823 
0824     if (!list_empty(&ai->free)) {
0825         aeb = list_entry(ai->free.next, struct ubi_ainf_peb, u.list);
0826         list_del(&aeb->u.list);
0827         dbg_bld("return free PEB %d, EC %d", aeb->pnum, aeb->ec);
0828         return aeb;
0829     }
0830 
0831     /*
0832      * We try to erase the first physical eraseblock from the erase list
0833      * and pick it if we succeed, or try to erase the next one if not. And
0834      * so forth. We don't want to take care about bad eraseblocks here -
0835      * they'll be handled later.
0836      */
0837     list_for_each_entry_safe(aeb, tmp_aeb, &ai->erase, u.list) {
0838         if (aeb->ec == UBI_UNKNOWN)
0839             aeb->ec = ai->mean_ec;
0840 
0841         err = early_erase_peb(ubi, ai, aeb->pnum, aeb->ec+1);
0842         if (err)
0843             continue;
0844 
0845         aeb->ec += 1;
0846         list_del(&aeb->u.list);
0847         dbg_bld("return PEB %d, EC %d", aeb->pnum, aeb->ec);
0848         return aeb;
0849     }
0850 
0851     ubi_err(ubi, "no free eraseblocks");
0852     return ERR_PTR(-ENOSPC);
0853 }
0854 
0855 /**
0856  * check_corruption - check the data area of PEB.
0857  * @ubi: UBI device description object
0858  * @vid_hdr: the (corrupted) VID header of this PEB
0859  * @pnum: the physical eraseblock number to check
0860  *
0861  * This is a helper function which is used to distinguish between VID header
0862  * corruptions caused by power cuts and other reasons. If the PEB contains only
0863  * 0xFF bytes in the data area, the VID header is most probably corrupted
0864  * because of a power cut (%0 is returned in this case). Otherwise, it was
0865  * probably corrupted for some other reasons (%1 is returned in this case). A
0866  * negative error code is returned if a read error occurred.
0867  *
0868  * If the corruption reason was a power cut, UBI can safely erase this PEB.
0869  * Otherwise, it should preserve it to avoid possibly destroying important
0870  * information.
0871  */
0872 static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr,
0873                 int pnum)
0874 {
0875     int err;
0876 
0877     mutex_lock(&ubi->buf_mutex);
0878     memset(ubi->peb_buf, 0x00, ubi->leb_size);
0879 
0880     err = ubi_io_read(ubi, ubi->peb_buf, pnum, ubi->leb_start,
0881               ubi->leb_size);
0882     if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
0883         /*
0884          * Bit-flips or integrity errors while reading the data area.
0885          * It is difficult to say for sure what type of corruption is
0886          * this, but presumably a power cut happened while this PEB was
0887          * erased, so it became unstable and corrupted, and should be
0888          * erased.
0889          */
0890         err = 0;
0891         goto out_unlock;
0892     }
0893 
0894     if (err)
0895         goto out_unlock;
0896 
0897     if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))
0898         goto out_unlock;
0899 
0900     ubi_err(ubi, "PEB %d contains corrupted VID header, and the data does not contain all 0xFF",
0901         pnum);
0902     ubi_err(ubi, "this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection");
0903     ubi_dump_vid_hdr(vid_hdr);
0904     pr_err("hexdump of PEB %d offset %d, length %d",
0905            pnum, ubi->leb_start, ubi->leb_size);
0906     ubi_dbg_print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
0907                    ubi->peb_buf, ubi->leb_size, 1);
0908     err = 1;
0909 
0910 out_unlock:
0911     mutex_unlock(&ubi->buf_mutex);
0912     return err;
0913 }
0914 
0915 static bool vol_ignored(int vol_id)
0916 {
0917     switch (vol_id) {
0918         case UBI_LAYOUT_VOLUME_ID:
0919         return true;
0920     }
0921 
0922 #ifdef CONFIG_MTD_UBI_FASTMAP
0923     return ubi_is_fm_vol(vol_id);
0924 #else
0925     return false;
0926 #endif
0927 }
0928 
0929 /**
0930  * scan_peb - scan and process UBI headers of a PEB.
0931  * @ubi: UBI device description object
0932  * @ai: attaching information
0933  * @pnum: the physical eraseblock number
0934  * @fast: true if we're scanning for a Fastmap
0935  *
0936  * This function reads UBI headers of PEB @pnum, checks them, and adds
0937  * information about this PEB to the corresponding list or RB-tree in the
0938  * "attaching info" structure. Returns zero if the physical eraseblock was
0939  * successfully handled and a negative error code in case of failure.
0940  */
0941 static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai,
0942             int pnum, bool fast)
0943 {
0944     struct ubi_ec_hdr *ech = ai->ech;
0945     struct ubi_vid_io_buf *vidb = ai->vidb;
0946     struct ubi_vid_hdr *vidh = ubi_get_vid_hdr(vidb);
0947     long long ec;
0948     int err, bitflips = 0, vol_id = -1, ec_err = 0;
0949 
0950     dbg_bld("scan PEB %d", pnum);
0951 
0952     /* Skip bad physical eraseblocks */
0953     err = ubi_io_is_bad(ubi, pnum);
0954     if (err < 0)
0955         return err;
0956     else if (err) {
0957         ai->bad_peb_count += 1;
0958         return 0;
0959     }
0960 
0961     err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
0962     if (err < 0)
0963         return err;
0964     switch (err) {
0965     case 0:
0966         break;
0967     case UBI_IO_BITFLIPS:
0968         bitflips = 1;
0969         break;
0970     case UBI_IO_FF:
0971         ai->empty_peb_count += 1;
0972         return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
0973                    UBI_UNKNOWN, 0, &ai->erase);
0974     case UBI_IO_FF_BITFLIPS:
0975         ai->empty_peb_count += 1;
0976         return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
0977                    UBI_UNKNOWN, 1, &ai->erase);
0978     case UBI_IO_BAD_HDR_EBADMSG:
0979     case UBI_IO_BAD_HDR:
0980         /*
0981          * We have to also look at the VID header, possibly it is not
0982          * corrupted. Set %bitflips flag in order to make this PEB be
0983          * moved and EC be re-created.
0984          */
0985         ec_err = err;
0986         ec = UBI_UNKNOWN;
0987         bitflips = 1;
0988         break;
0989     default:
0990         ubi_err(ubi, "'ubi_io_read_ec_hdr()' returned unknown code %d",
0991             err);
0992         return -EINVAL;
0993     }
0994 
0995     if (!ec_err) {
0996         int image_seq;
0997 
0998         /* Make sure UBI version is OK */
0999         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 
1183 adjust_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  */
1207 static 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  */
1277 static 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  */
1311 static 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  */
1374 static 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 
1443 out_vidh:
1444     ubi_free_vid_buf(ai->vidb);
1445 out_ech:
1446     kfree(ai->ech);
1447     return err;
1448 }
1449 
1450 static 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  */
1487 static 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 
1535 out_vidh:
1536     ubi_free_vid_buf(scan_ai->vidb);
1537 out_ech:
1538     kfree(scan_ai->ech);
1539 out_ai:
1540     destroy_ai(scan_ai);
1541 out:
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  */
1555 int 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 
1640 out_wl:
1641     ubi_wl_close(ubi);
1642 out_vtbl:
1643     ubi_free_all_volumes(ubi);
1644     vfree(ubi->vtbl);
1645 out_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  */
1658 static 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 
1904 bad_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 
1910 bad_av:
1911     ubi_err(ubi, "bad attaching information about volume %d", av->vol_id);
1912     ubi_dump_av(av);
1913     goto out;
1914 
1915 bad_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 
1920 out:
1921     dump_stack();
1922     return -EINVAL;
1923 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!