878 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Copyright (c) International Business Machines Corp., 20064 * Copyright (c) Nokia Corporation, 2006, 20075 *6 * Author: Artem Bityutskiy (Битюцкий Артём)7 */8 9/*10 * This file includes volume table manipulation code. The volume table is an11 * on-flash table containing volume meta-data like name, number of reserved12 * physical eraseblocks, type, etc. The volume table is stored in the so-called13 * "layout volume".14 *15 * The layout volume is an internal volume which is organized as follows. It16 * consists of two logical eraseblocks - LEB 0 and LEB 1. Each logical17 * eraseblock stores one volume table copy, i.e. LEB 0 and LEB 1 duplicate each18 * other. This redundancy guarantees robustness to unclean reboots. The volume19 * table is basically an array of volume table records. Each record contains20 * full information about the volume and protected by a CRC checksum. Note,21 * nowadays we use the atomic LEB change operation when updating the volume22 * table, so we do not really need 2 LEBs anymore, but we preserve the older23 * design for the backward compatibility reasons.24 *25 * When the volume table is changed, it is first changed in RAM. Then LEB 0 is26 * erased, and the updated volume table is written back to LEB 0. Then same for27 * LEB 1. This scheme guarantees recoverability from unclean reboots.28 *29 * In this UBI implementation the on-flash volume table does not contain any30 * information about how much data static volumes contain.31 *32 * But it would still be beneficial to store this information in the volume33 * table. For example, suppose we have a static volume X, and all its physical34 * eraseblocks became bad for some reasons. Suppose we are attaching the35 * corresponding MTD device, for some reason we find no logical eraseblocks36 * corresponding to the volume X. According to the volume table volume X does37 * exist. So we don't know whether it is just empty or all its physical38 * eraseblocks went bad. So we cannot alarm the user properly.39 *40 * The volume table also stores so-called "update marker", which is used for41 * volume updates. Before updating the volume, the update marker is set, and42 * after the update operation is finished, the update marker is cleared. So if43 * the update operation was interrupted (e.g. by an unclean reboot) - the44 * update marker is still there and we know that the volume's contents is45 * damaged.46 */47 48#include <linux/crc32.h>49#include <linux/err.h>50#include <linux/slab.h>51#include <asm/div64.h>52#include "ubi.h"53 54static void self_vtbl_check(const struct ubi_device *ubi);55 56/* Empty volume table record */57static struct ubi_vtbl_record empty_vtbl_record;58 59/**60 * ubi_update_layout_vol - helper for updatting layout volumes on flash61 * @ubi: UBI device description object62 */63static int ubi_update_layout_vol(struct ubi_device *ubi)64{65 struct ubi_volume *layout_vol;66 int i, err;67 68 layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];69 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {70 err = ubi_eba_atomic_leb_change(ubi, layout_vol, i, ubi->vtbl,71 ubi->vtbl_size);72 if (err)73 return err;74 }75 76 return 0;77}78 79/**80 * ubi_change_vtbl_record - change volume table record.81 * @ubi: UBI device description object82 * @idx: table index to change83 * @vtbl_rec: new volume table record84 *85 * This function changes volume table record @idx. If @vtbl_rec is %NULL, empty86 * volume table record is written. The caller does not have to calculate CRC of87 * the record as it is done by this function. Returns zero in case of success88 * and a negative error code in case of failure.89 */90int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,91 struct ubi_vtbl_record *vtbl_rec)92{93 int err;94 uint32_t crc;95 96 ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);97 98 if (!vtbl_rec)99 vtbl_rec = &empty_vtbl_record;100 else {101 crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);102 vtbl_rec->crc = cpu_to_be32(crc);103 }104 105 memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));106 err = ubi_update_layout_vol(ubi);107 108 self_vtbl_check(ubi);109 return err ? err : 0;110}111 112/**113 * ubi_vtbl_rename_volumes - rename UBI volumes in the volume table.114 * @ubi: UBI device description object115 * @rename_list: list of &struct ubi_rename_entry objects116 *117 * This function re-names multiple volumes specified in @req in the volume118 * table. Returns zero in case of success and a negative error code in case of119 * failure.120 */121int ubi_vtbl_rename_volumes(struct ubi_device *ubi,122 struct list_head *rename_list)123{124 struct ubi_rename_entry *re;125 126 list_for_each_entry(re, rename_list, list) {127 uint32_t crc;128 struct ubi_volume *vol = re->desc->vol;129 struct ubi_vtbl_record *vtbl_rec = &ubi->vtbl[vol->vol_id];130 131 if (re->remove) {132 memcpy(vtbl_rec, &empty_vtbl_record,133 sizeof(struct ubi_vtbl_record));134 continue;135 }136 137 vtbl_rec->name_len = cpu_to_be16(re->new_name_len);138 memcpy(vtbl_rec->name, re->new_name, re->new_name_len);139 memset(vtbl_rec->name + re->new_name_len, 0,140 UBI_VOL_NAME_MAX + 1 - re->new_name_len);141 crc = crc32(UBI_CRC32_INIT, vtbl_rec,142 UBI_VTBL_RECORD_SIZE_CRC);143 vtbl_rec->crc = cpu_to_be32(crc);144 }145 146 return ubi_update_layout_vol(ubi);147}148 149/**150 * vtbl_check - check if volume table is not corrupted and sensible.151 * @ubi: UBI device description object152 * @vtbl: volume table153 *154 * This function returns zero if @vtbl is all right, %1 if CRC is incorrect,155 * and %-EINVAL if it contains inconsistent data.156 */157static int vtbl_check(const struct ubi_device *ubi,158 const struct ubi_vtbl_record *vtbl)159{160 int i, n, reserved_pebs, alignment, data_pad, vol_type, name_len;161 int upd_marker, err;162 uint32_t crc;163 const char *name;164 165 for (i = 0; i < ubi->vtbl_slots; i++) {166 cond_resched();167 168 reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);169 alignment = be32_to_cpu(vtbl[i].alignment);170 data_pad = be32_to_cpu(vtbl[i].data_pad);171 upd_marker = vtbl[i].upd_marker;172 vol_type = vtbl[i].vol_type;173 name_len = be16_to_cpu(vtbl[i].name_len);174 name = &vtbl[i].name[0];175 176 crc = crc32(UBI_CRC32_INIT, &vtbl[i], UBI_VTBL_RECORD_SIZE_CRC);177 if (be32_to_cpu(vtbl[i].crc) != crc) {178 ubi_err(ubi, "bad CRC at record %u: %#08x, not %#08x",179 i, crc, be32_to_cpu(vtbl[i].crc));180 ubi_dump_vtbl_record(&vtbl[i], i);181 return 1;182 }183 184 if (reserved_pebs == 0) {185 if (memcmp(&vtbl[i], &empty_vtbl_record,186 UBI_VTBL_RECORD_SIZE)) {187 err = 2;188 goto bad;189 }190 continue;191 }192 193 if (reserved_pebs < 0 || alignment < 0 || data_pad < 0 ||194 name_len < 0) {195 err = 3;196 goto bad;197 }198 199 if (alignment > ubi->leb_size || alignment == 0) {200 err = 4;201 goto bad;202 }203 204 n = alignment & (ubi->min_io_size - 1);205 if (alignment != 1 && n) {206 err = 5;207 goto bad;208 }209 210 n = ubi->leb_size % alignment;211 if (data_pad != n) {212 ubi_err(ubi, "bad data_pad, has to be %d", n);213 err = 6;214 goto bad;215 }216 217 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {218 err = 7;219 goto bad;220 }221 222 if (upd_marker != 0 && upd_marker != 1) {223 err = 8;224 goto bad;225 }226 227 if (reserved_pebs > ubi->good_peb_count) {228 ubi_err(ubi, "too large reserved_pebs %d, good PEBs %d",229 reserved_pebs, ubi->good_peb_count);230 err = 9;231 goto bad;232 }233 234 if (name_len > UBI_VOL_NAME_MAX) {235 err = 10;236 goto bad;237 }238 239 if (name[0] == '\0') {240 err = 11;241 goto bad;242 }243 244 if (name_len != strnlen(name, name_len + 1)) {245 err = 12;246 goto bad;247 }248 }249 250 /* Checks that all names are unique */251 for (i = 0; i < ubi->vtbl_slots - 1; i++) {252 for (n = i + 1; n < ubi->vtbl_slots; n++) {253 int len1 = be16_to_cpu(vtbl[i].name_len);254 int len2 = be16_to_cpu(vtbl[n].name_len);255 256 if (len1 > 0 && len1 == len2 &&257 !strncmp(vtbl[i].name, vtbl[n].name, len1)) {258 ubi_err(ubi, "volumes %d and %d have the same name \"%s\"",259 i, n, vtbl[i].name);260 ubi_dump_vtbl_record(&vtbl[i], i);261 ubi_dump_vtbl_record(&vtbl[n], n);262 return -EINVAL;263 }264 }265 }266 267 return 0;268 269bad:270 ubi_err(ubi, "volume table check failed: record %d, error %d", i, err);271 ubi_dump_vtbl_record(&vtbl[i], i);272 return -EINVAL;273}274 275/**276 * create_vtbl - create a copy of volume table.277 * @ubi: UBI device description object278 * @ai: attaching information279 * @copy: number of the volume table copy280 * @vtbl: contents of the volume table281 *282 * This function returns zero in case of success and a negative error code in283 * case of failure.284 */285static int create_vtbl(struct ubi_device *ubi, struct ubi_attach_info *ai,286 int copy, void *vtbl)287{288 int err, tries = 0;289 struct ubi_vid_io_buf *vidb;290 struct ubi_vid_hdr *vid_hdr;291 struct ubi_ainf_peb *new_aeb;292 293 dbg_gen("create volume table (copy #%d)", copy + 1);294 295 vidb = ubi_alloc_vid_buf(ubi, GFP_KERNEL);296 if (!vidb)297 return -ENOMEM;298 299 vid_hdr = ubi_get_vid_hdr(vidb);300 301retry:302 new_aeb = ubi_early_get_peb(ubi, ai);303 if (IS_ERR(new_aeb)) {304 err = PTR_ERR(new_aeb);305 goto out_free;306 }307 308 vid_hdr->vol_type = UBI_LAYOUT_VOLUME_TYPE;309 vid_hdr->vol_id = cpu_to_be32(UBI_LAYOUT_VOLUME_ID);310 vid_hdr->compat = UBI_LAYOUT_VOLUME_COMPAT;311 vid_hdr->data_size = vid_hdr->used_ebs =312 vid_hdr->data_pad = cpu_to_be32(0);313 vid_hdr->lnum = cpu_to_be32(copy);314 vid_hdr->sqnum = cpu_to_be64(++ai->max_sqnum);315 316 /* The EC header is already there, write the VID header */317 err = ubi_io_write_vid_hdr(ubi, new_aeb->pnum, vidb);318 if (err)319 goto write_error;320 321 /* Write the layout volume contents */322 err = ubi_io_write_data(ubi, vtbl, new_aeb->pnum, 0, ubi->vtbl_size);323 if (err)324 goto write_error;325 326 /*327 * And add it to the attaching information. Don't delete the old version328 * of this LEB as it will be deleted and freed in 'ubi_add_to_av()'.329 */330 err = ubi_add_to_av(ubi, ai, new_aeb->pnum, new_aeb->ec, vid_hdr, 0);331 ubi_free_aeb(ai, new_aeb);332 ubi_free_vid_buf(vidb);333 return err;334 335write_error:336 if (err == -EIO && ++tries <= 5) {337 /*338 * Probably this physical eraseblock went bad, try to pick339 * another one.340 */341 list_add(&new_aeb->u.list, &ai->erase);342 goto retry;343 }344 ubi_free_aeb(ai, new_aeb);345out_free:346 ubi_free_vid_buf(vidb);347 return err;348 349}350 351/**352 * process_lvol - process the layout volume.353 * @ubi: UBI device description object354 * @ai: attaching information355 * @av: layout volume attaching information356 *357 * This function is responsible for reading the layout volume, ensuring it is358 * not corrupted, and recovering from corruptions if needed. Returns volume359 * table in case of success and a negative error code in case of failure.360 */361static struct ubi_vtbl_record *process_lvol(struct ubi_device *ubi,362 struct ubi_attach_info *ai,363 struct ubi_ainf_volume *av)364{365 int err;366 struct rb_node *rb;367 struct ubi_ainf_peb *aeb;368 struct ubi_vtbl_record *leb[UBI_LAYOUT_VOLUME_EBS] = { NULL, NULL };369 int leb_corrupted[UBI_LAYOUT_VOLUME_EBS] = {1, 1};370 371 /*372 * UBI goes through the following steps when it changes the layout373 * volume:374 * a. erase LEB 0;375 * b. write new data to LEB 0;376 * c. erase LEB 1;377 * d. write new data to LEB 1.378 *379 * Before the change, both LEBs contain the same data.380 *381 * Due to unclean reboots, the contents of LEB 0 may be lost, but there382 * should LEB 1. So it is OK if LEB 0 is corrupted while LEB 1 is not.383 * Similarly, LEB 1 may be lost, but there should be LEB 0. And384 * finally, unclean reboots may result in a situation when neither LEB385 * 0 nor LEB 1 are corrupted, but they are different. In this case, LEB386 * 0 contains more recent information.387 *388 * So the plan is to first check LEB 0. Then389 * a. if LEB 0 is OK, it must be containing the most recent data; then390 * we compare it with LEB 1, and if they are different, we copy LEB391 * 0 to LEB 1;392 * b. if LEB 0 is corrupted, but LEB 1 has to be OK, and we copy LEB 1393 * to LEB 0.394 */395 396 dbg_gen("check layout volume");397 398 /* Read both LEB 0 and LEB 1 into memory */399 ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) {400 leb[aeb->lnum] = vzalloc(ubi->vtbl_size);401 if (!leb[aeb->lnum]) {402 err = -ENOMEM;403 goto out_free;404 }405 406 err = ubi_io_read_data(ubi, leb[aeb->lnum], aeb->pnum, 0,407 ubi->vtbl_size);408 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err))409 /*410 * Scrub the PEB later. Note, -EBADMSG indicates an411 * uncorrectable ECC error, but we have our own CRC and412 * the data will be checked later. If the data is OK,413 * the PEB will be scrubbed (because we set414 * aeb->scrub). If the data is not OK, the contents of415 * the PEB will be recovered from the second copy, and416 * aeb->scrub will be cleared in417 * 'ubi_add_to_av()'.418 */419 aeb->scrub = 1;420 else if (err)421 goto out_free;422 }423 424 err = -EINVAL;425 if (leb[0]) {426 leb_corrupted[0] = vtbl_check(ubi, leb[0]);427 if (leb_corrupted[0] < 0)428 goto out_free;429 }430 431 if (!leb_corrupted[0]) {432 /* LEB 0 is OK */433 if (leb[1])434 leb_corrupted[1] = memcmp(leb[0], leb[1],435 ubi->vtbl_size);436 if (leb_corrupted[1]) {437 ubi_warn(ubi, "volume table copy #2 is corrupted");438 err = create_vtbl(ubi, ai, 1, leb[0]);439 if (err)440 goto out_free;441 ubi_msg(ubi, "volume table was restored");442 }443 444 /* Both LEB 1 and LEB 2 are OK and consistent */445 vfree(leb[1]);446 return leb[0];447 } else {448 /* LEB 0 is corrupted or does not exist */449 if (leb[1]) {450 leb_corrupted[1] = vtbl_check(ubi, leb[1]);451 if (leb_corrupted[1] < 0)452 goto out_free;453 }454 if (leb_corrupted[1]) {455 /* Both LEB 0 and LEB 1 are corrupted */456 ubi_err(ubi, "both volume tables are corrupted");457 goto out_free;458 }459 460 ubi_warn(ubi, "volume table copy #1 is corrupted");461 err = create_vtbl(ubi, ai, 0, leb[1]);462 if (err)463 goto out_free;464 ubi_msg(ubi, "volume table was restored");465 466 vfree(leb[0]);467 return leb[1];468 }469 470out_free:471 vfree(leb[0]);472 vfree(leb[1]);473 return ERR_PTR(err);474}475 476/**477 * create_empty_lvol - create empty layout volume.478 * @ubi: UBI device description object479 * @ai: attaching information480 *481 * This function returns volume table contents in case of success and a482 * negative error code in case of failure.483 */484static struct ubi_vtbl_record *create_empty_lvol(struct ubi_device *ubi,485 struct ubi_attach_info *ai)486{487 int i;488 struct ubi_vtbl_record *vtbl;489 490 vtbl = vzalloc(ubi->vtbl_size);491 if (!vtbl)492 return ERR_PTR(-ENOMEM);493 494 for (i = 0; i < ubi->vtbl_slots; i++)495 memcpy(&vtbl[i], &empty_vtbl_record, UBI_VTBL_RECORD_SIZE);496 497 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {498 int err;499 500 err = create_vtbl(ubi, ai, i, vtbl);501 if (err) {502 vfree(vtbl);503 return ERR_PTR(err);504 }505 }506 507 return vtbl;508}509 510/**511 * init_volumes - initialize volume information for existing volumes.512 * @ubi: UBI device description object513 * @ai: scanning information514 * @vtbl: volume table515 *516 * This function allocates volume description objects for existing volumes.517 * Returns zero in case of success and a negative error code in case of518 * failure.519 */520static int init_volumes(struct ubi_device *ubi,521 const struct ubi_attach_info *ai,522 const struct ubi_vtbl_record *vtbl)523{524 int i, err, reserved_pebs = 0;525 struct ubi_ainf_volume *av;526 struct ubi_volume *vol;527 528 for (i = 0; i < ubi->vtbl_slots; i++) {529 cond_resched();530 531 if (be32_to_cpu(vtbl[i].reserved_pebs) == 0)532 continue; /* Empty record */533 534 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);535 if (!vol)536 return -ENOMEM;537 538 vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);539 vol->alignment = be32_to_cpu(vtbl[i].alignment);540 vol->data_pad = be32_to_cpu(vtbl[i].data_pad);541 vol->upd_marker = vtbl[i].upd_marker;542 vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ?543 UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;544 vol->name_len = be16_to_cpu(vtbl[i].name_len);545 vol->usable_leb_size = ubi->leb_size - vol->data_pad;546 memcpy(vol->name, vtbl[i].name, vol->name_len);547 vol->name[vol->name_len] = '\0';548 vol->vol_id = i;549 550 if (vtbl[i].flags & UBI_VTBL_SKIP_CRC_CHECK_FLG)551 vol->skip_check = 1;552 553 if (vtbl[i].flags & UBI_VTBL_AUTORESIZE_FLG) {554 /* Auto re-size flag may be set only for one volume */555 if (ubi->autoresize_vol_id != -1) {556 ubi_err(ubi, "more than one auto-resize volume (%d and %d)",557 ubi->autoresize_vol_id, i);558 kfree(vol);559 return -EINVAL;560 }561 562 ubi->autoresize_vol_id = i;563 }564 565 ubi_assert(!ubi->volumes[i]);566 ubi->volumes[i] = vol;567 ubi->vol_count += 1;568 vol->ubi = ubi;569 reserved_pebs += vol->reserved_pebs;570 571 /*572 * We use ubi->peb_count and not vol->reserved_pebs because573 * we want to keep the code simple. Otherwise we'd have to574 * resize/check the bitmap upon volume resize too.575 * Allocating a few bytes more does not hurt.576 */577 err = ubi_fastmap_init_checkmap(vol, ubi->peb_count);578 if (err)579 return err;580 581 /*582 * In case of dynamic volume UBI knows nothing about how many583 * data is stored there. So assume the whole volume is used.584 */585 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {586 vol->used_ebs = vol->reserved_pebs;587 vol->last_eb_bytes = vol->usable_leb_size;588 vol->used_bytes =589 (long long)vol->used_ebs * vol->usable_leb_size;590 continue;591 }592 593 /* Static volumes only */594 av = ubi_find_av(ai, i);595 if (!av || !av->leb_count) {596 /*597 * No eraseblocks belonging to this volume found. We598 * don't actually know whether this static volume is599 * completely corrupted or just contains no data. And600 * we cannot know this as long as data size is not601 * stored on flash. So we just assume the volume is602 * empty. FIXME: this should be handled.603 */604 continue;605 }606 607 if (av->leb_count != av->used_ebs) {608 /*609 * We found a static volume which misses several610 * eraseblocks. Treat it as corrupted.611 */612 ubi_warn(ubi, "static volume %d misses %d LEBs - corrupted",613 av->vol_id, av->used_ebs - av->leb_count);614 vol->corrupted = 1;615 continue;616 }617 618 vol->used_ebs = av->used_ebs;619 vol->used_bytes =620 (long long)(vol->used_ebs - 1) * vol->usable_leb_size;621 vol->used_bytes += av->last_data_size;622 vol->last_eb_bytes = av->last_data_size;623 }624 625 /* And add the layout volume */626 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);627 if (!vol)628 return -ENOMEM;629 630 vol->reserved_pebs = UBI_LAYOUT_VOLUME_EBS;631 vol->alignment = UBI_LAYOUT_VOLUME_ALIGN;632 vol->vol_type = UBI_DYNAMIC_VOLUME;633 vol->name_len = sizeof(UBI_LAYOUT_VOLUME_NAME) - 1;634 memcpy(vol->name, UBI_LAYOUT_VOLUME_NAME, vol->name_len + 1);635 vol->usable_leb_size = ubi->leb_size;636 vol->used_ebs = vol->reserved_pebs;637 vol->last_eb_bytes = vol->reserved_pebs;638 vol->used_bytes =639 (long long)vol->used_ebs * (ubi->leb_size - vol->data_pad);640 vol->vol_id = UBI_LAYOUT_VOLUME_ID;641 vol->ref_count = 1;642 643 ubi_assert(!ubi->volumes[i]);644 ubi->volumes[vol_id2idx(ubi, vol->vol_id)] = vol;645 reserved_pebs += vol->reserved_pebs;646 ubi->vol_count += 1;647 vol->ubi = ubi;648 err = ubi_fastmap_init_checkmap(vol, UBI_LAYOUT_VOLUME_EBS);649 if (err)650 return err;651 652 if (reserved_pebs > ubi->avail_pebs) {653 ubi_err(ubi, "not enough PEBs, required %d, available %d",654 reserved_pebs, ubi->avail_pebs);655 if (ubi->corr_peb_count)656 ubi_err(ubi, "%d PEBs are corrupted and not used",657 ubi->corr_peb_count);658 return -ENOSPC;659 }660 ubi->rsvd_pebs += reserved_pebs;661 ubi->avail_pebs -= reserved_pebs;662 663 return 0;664}665 666/**667 * check_av - check volume attaching information.668 * @vol: UBI volume description object669 * @av: volume attaching information670 *671 * This function returns zero if the volume attaching information is consistent672 * to the data read from the volume tabla, and %-EINVAL if not.673 */674static int check_av(const struct ubi_volume *vol,675 const struct ubi_ainf_volume *av)676{677 int err;678 679 if (av->highest_lnum >= vol->reserved_pebs) {680 err = 1;681 goto bad;682 }683 if (av->leb_count > vol->reserved_pebs) {684 err = 2;685 goto bad;686 }687 if (av->vol_type != vol->vol_type) {688 err = 3;689 goto bad;690 }691 if (av->used_ebs > vol->reserved_pebs) {692 err = 4;693 goto bad;694 }695 if (av->data_pad != vol->data_pad) {696 err = 5;697 goto bad;698 }699 return 0;700 701bad:702 ubi_err(vol->ubi, "bad attaching information, error %d", err);703 ubi_dump_av(av);704 ubi_dump_vol_info(vol);705 return -EINVAL;706}707 708/**709 * check_attaching_info - check that attaching information.710 * @ubi: UBI device description object711 * @ai: attaching information712 *713 * Even though we protect on-flash data by CRC checksums, we still don't trust714 * the media. This function ensures that attaching information is consistent to715 * the information read from the volume table. Returns zero if the attaching716 * information is OK and %-EINVAL if it is not.717 */718static int check_attaching_info(const struct ubi_device *ubi,719 struct ubi_attach_info *ai)720{721 int err, i;722 struct ubi_ainf_volume *av;723 struct ubi_volume *vol;724 725 if (ai->vols_found > UBI_INT_VOL_COUNT + ubi->vtbl_slots) {726 ubi_err(ubi, "found %d volumes while attaching, maximum is %d + %d",727 ai->vols_found, UBI_INT_VOL_COUNT, ubi->vtbl_slots);728 return -EINVAL;729 }730 731 if (ai->highest_vol_id >= ubi->vtbl_slots + UBI_INT_VOL_COUNT &&732 ai->highest_vol_id < UBI_INTERNAL_VOL_START) {733 ubi_err(ubi, "too large volume ID %d found",734 ai->highest_vol_id);735 return -EINVAL;736 }737 738 for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {739 cond_resched();740 741 av = ubi_find_av(ai, i);742 vol = ubi->volumes[i];743 if (!vol) {744 if (av)745 ubi_remove_av(ai, av);746 continue;747 }748 749 if (vol->reserved_pebs == 0) {750 ubi_assert(i < ubi->vtbl_slots);751 752 if (!av)753 continue;754 755 /*756 * During attaching we found a volume which does not757 * exist according to the information in the volume758 * table. This must have happened due to an unclean759 * reboot while the volume was being removed. Discard760 * these eraseblocks.761 */762 ubi_msg(ubi, "finish volume %d removal", av->vol_id);763 ubi_remove_av(ai, av);764 } else if (av) {765 err = check_av(vol, av);766 if (err)767 return err;768 }769 }770 771 return 0;772}773 774/**775 * ubi_read_volume_table - read the volume table.776 * @ubi: UBI device description object777 * @ai: attaching information778 *779 * This function reads volume table, checks it, recover from errors if needed,780 * or creates it if needed. Returns zero in case of success and a negative781 * error code in case of failure.782 */783int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_attach_info *ai)784{785 int err;786 struct ubi_ainf_volume *av;787 788 empty_vtbl_record.crc = cpu_to_be32(0xf116c36b);789 790 /*791 * The number of supported volumes is limited by the eraseblock size792 * and by the UBI_MAX_VOLUMES constant.793 */794 795 if (ubi->leb_size < UBI_VTBL_RECORD_SIZE) {796 ubi_err(ubi, "LEB size too small for a volume record");797 return -EINVAL;798 }799 800 ubi->vtbl_slots = ubi->leb_size / UBI_VTBL_RECORD_SIZE;801 if (ubi->vtbl_slots > UBI_MAX_VOLUMES)802 ubi->vtbl_slots = UBI_MAX_VOLUMES;803 804 ubi->vtbl_size = ubi->vtbl_slots * UBI_VTBL_RECORD_SIZE;805 ubi->vtbl_size = ALIGN(ubi->vtbl_size, ubi->min_io_size);806 807 av = ubi_find_av(ai, UBI_LAYOUT_VOLUME_ID);808 if (!av) {809 /*810 * No logical eraseblocks belonging to the layout volume were811 * found. This could mean that the flash is just empty. In812 * this case we create empty layout volume.813 *814 * But if flash is not empty this must be a corruption or the815 * MTD device just contains garbage.816 */817 if (ai->is_empty) {818 ubi->vtbl = create_empty_lvol(ubi, ai);819 if (IS_ERR(ubi->vtbl))820 return PTR_ERR(ubi->vtbl);821 } else {822 ubi_err(ubi, "the layout volume was not found");823 return -EINVAL;824 }825 } else {826 if (av->leb_count > UBI_LAYOUT_VOLUME_EBS) {827 /* This must not happen with proper UBI images */828 ubi_err(ubi, "too many LEBs (%d) in layout volume",829 av->leb_count);830 return -EINVAL;831 }832 833 ubi->vtbl = process_lvol(ubi, ai, av);834 if (IS_ERR(ubi->vtbl))835 return PTR_ERR(ubi->vtbl);836 }837 838 ubi->avail_pebs = ubi->good_peb_count - ubi->corr_peb_count;839 840 /*841 * The layout volume is OK, initialize the corresponding in-RAM data842 * structures.843 */844 err = init_volumes(ubi, ai, ubi->vtbl);845 if (err)846 goto out_free;847 848 /*849 * Make sure that the attaching information is consistent to the850 * information stored in the volume table.851 */852 err = check_attaching_info(ubi, ai);853 if (err)854 goto out_free;855 856 return 0;857 858out_free:859 vfree(ubi->vtbl);860 ubi_free_all_volumes(ubi);861 return err;862}863 864/**865 * self_vtbl_check - check volume table.866 * @ubi: UBI device description object867 */868static void self_vtbl_check(const struct ubi_device *ubi)869{870 if (!ubi_dbg_chk_gen(ubi))871 return;872 873 if (vtbl_check(ubi, ubi->vtbl)) {874 ubi_err(ubi, "self-check failed");875 BUG();876 }877}878