blob: d77b1c1d7c7267c3186635497eeba492f539d735 [file] [log] [blame]
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001/*
2 * Copyright (c) International Business Machines Corp., 2006
3 * Copyright (c) Nokia Corporation, 2006, 2007
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * Author: Artem Bityutskiy (Битюцкий Артём)
20 */
21
22/*
23 * This file includes volume table manipulation code. The volume table is an
24 * on-flash table containing volume meta-data like name, number of reserved
25 * physical eraseblocks, type, etc. The volume table is stored in the so-called
26 * "layout volume".
27 *
28 * The layout volume is an internal volume which is organized as follows. It
29 * consists of two logical eraseblocks - LEB 0 and LEB 1. Each logical
30 * eraseblock stores one volume table copy, i.e. LEB 0 and LEB 1 duplicate each
31 * other. This redundancy guarantees robustness to unclean reboots. The volume
32 * table is basically an array of volume table records. Each record contains
33 * full information about the volume and protected by a CRC checksum.
34 *
35 * The volume table is changed, it is first changed in RAM. Then LEB 0 is
36 * erased, and the updated volume table is written back to LEB 0. Then same for
37 * LEB 1. This scheme guarantees recoverability from unclean reboots.
38 *
39 * In this UBI implementation the on-flash volume table does not contain any
Artem Bityutskiyfbd01072012-05-17 16:12:26 +030040 * information about how much data static volumes contain.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040041 *
42 * But it would still be beneficial to store this information in the volume
43 * table. For example, suppose we have a static volume X, and all its physical
44 * eraseblocks became bad for some reasons. Suppose we are attaching the
Artem Bityutskiyfbd01072012-05-17 16:12:26 +030045 * corresponding MTD device, for some reason we find no logical eraseblocks
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040046 * corresponding to the volume X. According to the volume table volume X does
47 * exist. So we don't know whether it is just empty or all its physical
Artem Bityutskiyfbd01072012-05-17 16:12:26 +030048 * eraseblocks went bad. So we cannot alarm the user properly.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040049 *
50 * The volume table also stores so-called "update marker", which is used for
51 * volume updates. Before updating the volume, the update marker is set, and
52 * after the update operation is finished, the update marker is cleared. So if
53 * the update operation was interrupted (e.g. by an unclean reboot) - the
54 * update marker is still there and we know that the volume's contents is
55 * damaged.
56 */
57
58#include <linux/crc32.h>
59#include <linux/err.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090060#include <linux/slab.h>
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040061#include <asm/div64.h>
62#include "ubi.h"
63
Artem Bityutskiy7bf523a2012-05-16 18:29:54 +030064static void self_vtbl_check(const struct ubi_device *ubi);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040065
66/* Empty volume table record */
67static struct ubi_vtbl_record empty_vtbl_record;
68
69/**
70 * ubi_change_vtbl_record - change volume table record.
71 * @ubi: UBI device description object
72 * @idx: table index to change
73 * @vtbl_rec: new volume table record
74 *
75 * This function changes volume table record @idx. If @vtbl_rec is %NULL, empty
76 * volume table record is written. The caller does not have to calculate CRC of
77 * the record as it is done by this function. Returns zero in case of success
78 * and a negative error code in case of failure.
79 */
80int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
81 struct ubi_vtbl_record *vtbl_rec)
82{
83 int i, err;
84 uint32_t crc;
Artem Bityutskiy89b96b62007-12-16 20:00:38 +020085 struct ubi_volume *layout_vol;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040086
87 ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);
Artem Bityutskiy91f2d532008-01-24 11:23:23 +020088 layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040089
90 if (!vtbl_rec)
91 vtbl_rec = &empty_vtbl_record;
92 else {
93 crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +030094 vtbl_rec->crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040095 }
96
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040097 memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));
98 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
Artem Bityutskiy89b96b62007-12-16 20:00:38 +020099 err = ubi_eba_unmap_leb(ubi, layout_vol, i);
Artem Bityutskiycae0a772007-12-17 12:46:48 +0200100 if (err)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400101 return err;
Artem Bityutskiycae0a772007-12-17 12:46:48 +0200102
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200103 err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
Richard Weinbergerb36a2612012-05-14 17:55:51 +0200104 ubi->vtbl_size);
Artem Bityutskiycae0a772007-12-17 12:46:48 +0200105 if (err)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400106 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400107 }
108
Artem Bityutskiy7bf523a2012-05-16 18:29:54 +0300109 self_vtbl_check(ubi);
Artem Bityutskiy6dc4a872008-02-01 13:48:49 +0200110 return 0;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400111}
112
113/**
Artem Bityutskiyf40ac9c2008-07-13 21:47:47 +0300114 * ubi_vtbl_rename_volumes - rename UBI volumes in the volume table.
115 * @ubi: UBI device description object
Artem Bityutskiyebaaf1a2008-07-18 13:34:32 +0300116 * @rename_list: list of &struct ubi_rename_entry objects
Artem Bityutskiyf40ac9c2008-07-13 21:47:47 +0300117 *
118 * This function re-names multiple volumes specified in @req in the volume
119 * table. Returns zero in case of success and a negative error code in case of
120 * failure.
121 */
122int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
123 struct list_head *rename_list)
124{
125 int i, err;
126 struct ubi_rename_entry *re;
127 struct ubi_volume *layout_vol;
128
129 list_for_each_entry(re, rename_list, list) {
130 uint32_t crc;
131 struct ubi_volume *vol = re->desc->vol;
132 struct ubi_vtbl_record *vtbl_rec = &ubi->vtbl[vol->vol_id];
133
134 if (re->remove) {
135 memcpy(vtbl_rec, &empty_vtbl_record,
136 sizeof(struct ubi_vtbl_record));
137 continue;
138 }
139
140 vtbl_rec->name_len = cpu_to_be16(re->new_name_len);
141 memcpy(vtbl_rec->name, re->new_name, re->new_name_len);
142 memset(vtbl_rec->name + re->new_name_len, 0,
143 UBI_VOL_NAME_MAX + 1 - re->new_name_len);
144 crc = crc32(UBI_CRC32_INIT, vtbl_rec,
145 UBI_VTBL_RECORD_SIZE_CRC);
146 vtbl_rec->crc = cpu_to_be32(crc);
147 }
148
149 layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
150 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
151 err = ubi_eba_unmap_leb(ubi, layout_vol, i);
152 if (err)
153 return err;
154
155 err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
Richard Weinbergerb36a2612012-05-14 17:55:51 +0200156 ubi->vtbl_size);
Artem Bityutskiyf40ac9c2008-07-13 21:47:47 +0300157 if (err)
158 return err;
159 }
160
161 return 0;
162}
163
164/**
Artem Bityutskiyebaaf1a2008-07-18 13:34:32 +0300165 * vtbl_check - check if volume table is not corrupted and sensible.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400166 * @ubi: UBI device description object
167 * @vtbl: volume table
168 *
169 * This function returns zero if @vtbl is all right, %1 if CRC is incorrect,
170 * and %-EINVAL if it contains inconsistent data.
171 */
172static int vtbl_check(const struct ubi_device *ubi,
173 const struct ubi_vtbl_record *vtbl)
174{
175 int i, n, reserved_pebs, alignment, data_pad, vol_type, name_len;
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300176 int upd_marker, err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400177 uint32_t crc;
178 const char *name;
179
180 for (i = 0; i < ubi->vtbl_slots; i++) {
181 cond_resched();
182
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300183 reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
184 alignment = be32_to_cpu(vtbl[i].alignment);
185 data_pad = be32_to_cpu(vtbl[i].data_pad);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400186 upd_marker = vtbl[i].upd_marker;
187 vol_type = vtbl[i].vol_type;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300188 name_len = be16_to_cpu(vtbl[i].name_len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400189 name = &vtbl[i].name[0];
190
191 crc = crc32(UBI_CRC32_INIT, &vtbl[i], UBI_VTBL_RECORD_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300192 if (be32_to_cpu(vtbl[i].crc) != crc) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400193 ubi_err("bad CRC at record %u: %#08x, not %#08x",
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300194 i, crc, be32_to_cpu(vtbl[i].crc));
Artem Bityutskiy1f021e1d2012-05-16 17:56:50 +0300195 ubi_dump_vtbl_record(&vtbl[i], i);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400196 return 1;
197 }
198
199 if (reserved_pebs == 0) {
200 if (memcmp(&vtbl[i], &empty_vtbl_record,
201 UBI_VTBL_RECORD_SIZE)) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300202 err = 2;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400203 goto bad;
204 }
205 continue;
206 }
207
208 if (reserved_pebs < 0 || alignment < 0 || data_pad < 0 ||
209 name_len < 0) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300210 err = 3;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400211 goto bad;
212 }
213
214 if (alignment > ubi->leb_size || alignment == 0) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300215 err = 4;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400216 goto bad;
217 }
218
Kyungmin Parkcadb40c2008-05-22 10:32:18 +0900219 n = alignment & (ubi->min_io_size - 1);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400220 if (alignment != 1 && n) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300221 err = 5;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400222 goto bad;
223 }
224
225 n = ubi->leb_size % alignment;
226 if (data_pad != n) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300227 ubi_err("bad data_pad, has to be %d", n);
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300228 err = 6;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400229 goto bad;
230 }
231
232 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300233 err = 7;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400234 goto bad;
235 }
236
237 if (upd_marker != 0 && upd_marker != 1) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300238 err = 8;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400239 goto bad;
240 }
241
242 if (reserved_pebs > ubi->good_peb_count) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300243 ubi_err("too large reserved_pebs %d, good PEBs %d",
Deepak Saxena762a9f22008-10-08 12:56:24 -0700244 reserved_pebs, ubi->good_peb_count);
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300245 err = 9;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400246 goto bad;
247 }
248
249 if (name_len > UBI_VOL_NAME_MAX) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300250 err = 10;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400251 goto bad;
252 }
253
254 if (name[0] == '\0') {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300255 err = 11;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400256 goto bad;
257 }
258
259 if (name_len != strnlen(name, name_len + 1)) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300260 err = 12;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400261 goto bad;
262 }
263 }
264
265 /* Checks that all names are unique */
266 for (i = 0; i < ubi->vtbl_slots - 1; i++) {
267 for (n = i + 1; n < ubi->vtbl_slots; n++) {
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300268 int len1 = be16_to_cpu(vtbl[i].name_len);
269 int len2 = be16_to_cpu(vtbl[n].name_len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400270
271 if (len1 > 0 && len1 == len2 &&
272 !strncmp(vtbl[i].name, vtbl[n].name, len1)) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300273 ubi_err("volumes %d and %d have the same name \"%s\"",
274 i, n, vtbl[i].name);
Artem Bityutskiy1f021e1d2012-05-16 17:56:50 +0300275 ubi_dump_vtbl_record(&vtbl[i], i);
276 ubi_dump_vtbl_record(&vtbl[n], n);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400277 return -EINVAL;
278 }
279 }
280 }
281
282 return 0;
283
284bad:
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300285 ubi_err("volume table check failed: record %d, error %d", i, err);
Artem Bityutskiy1f021e1d2012-05-16 17:56:50 +0300286 ubi_dump_vtbl_record(&vtbl[i], i);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400287 return -EINVAL;
288}
289
290/**
291 * create_vtbl - create a copy of volume table.
292 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300293 * @ai: attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400294 * @copy: number of the volume table copy
295 * @vtbl: contents of the volume table
296 *
297 * This function returns zero in case of success and a negative error code in
298 * case of failure.
299 */
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300300static int create_vtbl(struct ubi_device *ubi, struct ubi_attach_info *ai,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400301 int copy, void *vtbl)
302{
303 int err, tries = 0;
Richard Weinberger6bdccff2011-12-22 16:12:57 +0100304 struct ubi_vid_hdr *vid_hdr;
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300305 struct ubi_ainf_peb *new_aeb;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400306
Artem Bityutskiy719bb842012-08-27 17:14:58 +0300307 dbg_gen("create volume table (copy #%d)", copy + 1);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400308
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300309 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400310 if (!vid_hdr)
311 return -ENOMEM;
312
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400313retry:
Artem Bityutskiyc87fbd72012-05-17 15:38:56 +0300314 new_aeb = ubi_early_get_peb(ubi, ai);
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300315 if (IS_ERR(new_aeb)) {
316 err = PTR_ERR(new_aeb);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400317 goto out_free;
318 }
319
Richard Weinberger1f4f4342012-01-10 17:57:03 +0100320 vid_hdr->vol_type = UBI_LAYOUT_VOLUME_TYPE;
Artem Bityutskiy91f2d532008-01-24 11:23:23 +0200321 vid_hdr->vol_id = cpu_to_be32(UBI_LAYOUT_VOLUME_ID);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400322 vid_hdr->compat = UBI_LAYOUT_VOLUME_COMPAT;
323 vid_hdr->data_size = vid_hdr->used_ebs =
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300324 vid_hdr->data_pad = cpu_to_be32(0);
325 vid_hdr->lnum = cpu_to_be32(copy);
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300326 vid_hdr->sqnum = cpu_to_be64(++ai->max_sqnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400327
328 /* The EC header is already there, write the VID header */
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300329 err = ubi_io_write_vid_hdr(ubi, new_aeb->pnum, vid_hdr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400330 if (err)
331 goto write_error;
332
333 /* Write the layout volume contents */
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300334 err = ubi_io_write_data(ubi, vtbl, new_aeb->pnum, 0, ubi->vtbl_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400335 if (err)
336 goto write_error;
337
338 /*
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300339 * And add it to the attaching information. Don't delete the old version
Artem Bityutskiy35611882012-05-17 15:31:31 +0300340 * of this LEB as it will be deleted and freed in 'ubi_add_to_av()'.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400341 */
Artem Bityutskiy35611882012-05-17 15:31:31 +0300342 err = ubi_add_to_av(ubi, ai, new_aeb->pnum, new_aeb->ec, vid_hdr, 0);
Artem Bityutskiy78b495c2012-09-03 17:12:29 +0300343 kmem_cache_free(ai->aeb_slab_cache, new_aeb);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400344 ubi_free_vid_hdr(ubi, vid_hdr);
345 return err;
346
347write_error:
Artem Bityutskiy78d87c92007-05-05 11:24:02 +0300348 if (err == -EIO && ++tries <= 5) {
349 /*
350 * Probably this physical eraseblock went bad, try to pick
351 * another one.
352 */
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300353 list_add(&new_aeb->u.list, &ai->erase);
Florin Malitac4e90ec2007-05-03 11:49:57 -0400354 goto retry;
Artem Bityutskiy78d87c92007-05-05 11:24:02 +0300355 }
Artem Bityutskiy78b495c2012-09-03 17:12:29 +0300356 kmem_cache_free(ai->aeb_slab_cache, new_aeb);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400357out_free:
358 ubi_free_vid_hdr(ubi, vid_hdr);
359 return err;
360
361}
362
363/**
364 * process_lvol - process the layout volume.
365 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300366 * @ai: attaching information
Artem Bityutskiy517af482012-05-17 14:38:34 +0300367 * @av: layout volume attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400368 *
369 * This function is responsible for reading the layout volume, ensuring it is
370 * not corrupted, and recovering from corruptions if needed. Returns volume
371 * table in case of success and a negative error code in case of failure.
372 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300373static struct ubi_vtbl_record *process_lvol(struct ubi_device *ubi,
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300374 struct ubi_attach_info *ai,
Artem Bityutskiy517af482012-05-17 14:38:34 +0300375 struct ubi_ainf_volume *av)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400376{
377 int err;
378 struct rb_node *rb;
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300379 struct ubi_ainf_peb *aeb;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400380 struct ubi_vtbl_record *leb[UBI_LAYOUT_VOLUME_EBS] = { NULL, NULL };
381 int leb_corrupted[UBI_LAYOUT_VOLUME_EBS] = {1, 1};
382
383 /*
384 * UBI goes through the following steps when it changes the layout
385 * volume:
386 * a. erase LEB 0;
387 * b. write new data to LEB 0;
388 * c. erase LEB 1;
389 * d. write new data to LEB 1.
390 *
391 * Before the change, both LEBs contain the same data.
392 *
393 * Due to unclean reboots, the contents of LEB 0 may be lost, but there
394 * should LEB 1. So it is OK if LEB 0 is corrupted while LEB 1 is not.
395 * Similarly, LEB 1 may be lost, but there should be LEB 0. And
396 * finally, unclean reboots may result in a situation when neither LEB
397 * 0 nor LEB 1 are corrupted, but they are different. In this case, LEB
398 * 0 contains more recent information.
399 *
400 * So the plan is to first check LEB 0. Then
Shinya Kuribayashibe436f62010-05-06 19:22:09 +0900401 * a. if LEB 0 is OK, it must be containing the most recent data; then
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400402 * we compare it with LEB 1, and if they are different, we copy LEB
403 * 0 to LEB 1;
404 * b. if LEB 0 is corrupted, but LEB 1 has to be OK, and we copy LEB 1
405 * to LEB 0.
406 */
407
Artem Bityutskiyc8566352008-07-16 17:40:22 +0300408 dbg_gen("check layout volume");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400409
410 /* Read both LEB 0 and LEB 1 into memory */
Artem Bityutskiy517af482012-05-17 14:38:34 +0300411 ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) {
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300412 leb[aeb->lnum] = vzalloc(ubi->vtbl_size);
413 if (!leb[aeb->lnum]) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400414 err = -ENOMEM;
415 goto out_free;
416 }
417
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300418 err = ubi_io_read_data(ubi, leb[aeb->lnum], aeb->pnum, 0,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400419 ubi->vtbl_size);
Brian Norrisd57f40542011-09-20 18:34:25 -0700420 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err))
Artem Bityutskiybeeea632008-05-20 09:54:02 +0300421 /*
422 * Scrub the PEB later. Note, -EBADMSG indicates an
423 * uncorrectable ECC error, but we have our own CRC and
424 * the data will be checked later. If the data is OK,
425 * the PEB will be scrubbed (because we set
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300426 * aeb->scrub). If the data is not OK, the contents of
Artem Bityutskiybeeea632008-05-20 09:54:02 +0300427 * the PEB will be recovered from the second copy, and
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300428 * aeb->scrub will be cleared in
Artem Bityutskiy35611882012-05-17 15:31:31 +0300429 * 'ubi_add_to_av()'.
Artem Bityutskiybeeea632008-05-20 09:54:02 +0300430 */
Artem Bityutskiy2c5ec5c2012-05-17 08:26:24 +0300431 aeb->scrub = 1;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400432 else if (err)
433 goto out_free;
434 }
435
436 err = -EINVAL;
437 if (leb[0]) {
438 leb_corrupted[0] = vtbl_check(ubi, leb[0]);
439 if (leb_corrupted[0] < 0)
440 goto out_free;
441 }
442
443 if (!leb_corrupted[0]) {
444 /* LEB 0 is OK */
445 if (leb[1])
Artem Bityutskiy9c9ec142008-07-18 13:19:52 +0300446 leb_corrupted[1] = memcmp(leb[0], leb[1],
447 ubi->vtbl_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400448 if (leb_corrupted[1]) {
449 ubi_warn("volume table copy #2 is corrupted");
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300450 err = create_vtbl(ubi, ai, 1, leb[0]);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400451 if (err)
452 goto out_free;
453 ubi_msg("volume table was restored");
454 }
455
456 /* Both LEB 1 and LEB 2 are OK and consistent */
Artem Bityutskiy92ad8f32007-05-06 16:12:54 +0300457 vfree(leb[1]);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400458 return leb[0];
459 } else {
460 /* LEB 0 is corrupted or does not exist */
461 if (leb[1]) {
462 leb_corrupted[1] = vtbl_check(ubi, leb[1]);
463 if (leb_corrupted[1] < 0)
464 goto out_free;
465 }
466 if (leb_corrupted[1]) {
467 /* Both LEB 0 and LEB 1 are corrupted */
468 ubi_err("both volume tables are corrupted");
469 goto out_free;
470 }
471
472 ubi_warn("volume table copy #1 is corrupted");
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300473 err = create_vtbl(ubi, ai, 0, leb[1]);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400474 if (err)
475 goto out_free;
476 ubi_msg("volume table was restored");
477
Artem Bityutskiy92ad8f32007-05-06 16:12:54 +0300478 vfree(leb[0]);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400479 return leb[1];
480 }
481
482out_free:
Artem Bityutskiy92ad8f32007-05-06 16:12:54 +0300483 vfree(leb[0]);
484 vfree(leb[1]);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400485 return ERR_PTR(err);
486}
487
488/**
489 * create_empty_lvol - create empty layout volume.
490 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300491 * @ai: attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400492 *
493 * This function returns volume table contents in case of success and a
494 * negative error code in case of failure.
495 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300496static struct ubi_vtbl_record *create_empty_lvol(struct ubi_device *ubi,
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300497 struct ubi_attach_info *ai)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400498{
499 int i;
500 struct ubi_vtbl_record *vtbl;
501
Joe Perches309b5e42010-11-04 20:07:40 -0700502 vtbl = vzalloc(ubi->vtbl_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400503 if (!vtbl)
504 return ERR_PTR(-ENOMEM);
505
506 for (i = 0; i < ubi->vtbl_slots; i++)
507 memcpy(&vtbl[i], &empty_vtbl_record, UBI_VTBL_RECORD_SIZE);
508
509 for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
510 int err;
511
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300512 err = create_vtbl(ubi, ai, i, vtbl);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400513 if (err) {
Artem Bityutskiy92ad8f32007-05-06 16:12:54 +0300514 vfree(vtbl);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400515 return ERR_PTR(err);
516 }
517 }
518
519 return vtbl;
520}
521
522/**
523 * init_volumes - initialize volume information for existing volumes.
524 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300525 * @ai: scanning information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400526 * @vtbl: volume table
527 *
528 * This function allocates volume description objects for existing volumes.
529 * Returns zero in case of success and a negative error code in case of
530 * failure.
531 */
Artem Bityutskiyafc15a82012-05-17 07:46:17 +0300532static int init_volumes(struct ubi_device *ubi,
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300533 const struct ubi_attach_info *ai,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400534 const struct ubi_vtbl_record *vtbl)
535{
536 int i, reserved_pebs = 0;
Artem Bityutskiy517af482012-05-17 14:38:34 +0300537 struct ubi_ainf_volume *av;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400538 struct ubi_volume *vol;
539
540 for (i = 0; i < ubi->vtbl_slots; i++) {
541 cond_resched();
542
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300543 if (be32_to_cpu(vtbl[i].reserved_pebs) == 0)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400544 continue; /* Empty record */
545
546 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
547 if (!vol)
548 return -ENOMEM;
549
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300550 vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
551 vol->alignment = be32_to_cpu(vtbl[i].alignment);
552 vol->data_pad = be32_to_cpu(vtbl[i].data_pad);
Peter Hortonff998792010-01-05 11:14:36 +0000553 vol->upd_marker = vtbl[i].upd_marker;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400554 vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ?
555 UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300556 vol->name_len = be16_to_cpu(vtbl[i].name_len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400557 vol->usable_leb_size = ubi->leb_size - vol->data_pad;
558 memcpy(vol->name, vtbl[i].name, vol->name_len);
559 vol->name[vol->name_len] = '\0';
560 vol->vol_id = i;
561
Artem Bityutskiy4ccf8cf2008-01-16 15:44:24 +0200562 if (vtbl[i].flags & UBI_VTBL_AUTORESIZE_FLG) {
563 /* Auto re-size flag may be set only for one volume */
564 if (ubi->autoresize_vol_id != -1) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300565 ubi_err("more than one auto-resize volume (%d and %d)",
566 ubi->autoresize_vol_id, i);
Adrian Bunkf7f028372008-03-03 20:07:52 +0200567 kfree(vol);
Artem Bityutskiy4ccf8cf2008-01-16 15:44:24 +0200568 return -EINVAL;
569 }
570
571 ubi->autoresize_vol_id = i;
572 }
573
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400574 ubi_assert(!ubi->volumes[i]);
575 ubi->volumes[i] = vol;
576 ubi->vol_count += 1;
577 vol->ubi = ubi;
578 reserved_pebs += vol->reserved_pebs;
579
580 /*
581 * In case of dynamic volume UBI knows nothing about how many
582 * data is stored there. So assume the whole volume is used.
583 */
584 if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
585 vol->used_ebs = vol->reserved_pebs;
586 vol->last_eb_bytes = vol->usable_leb_size;
Vinit Agnihotrid08c3b72007-07-10 13:04:59 +0300587 vol->used_bytes =
588 (long long)vol->used_ebs * vol->usable_leb_size;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400589 continue;
590 }
591
592 /* Static volumes only */
Artem Bityutskiydcd85fd2012-05-17 15:33:20 +0300593 av = ubi_find_av(ai, i);
Artem Bityutskiy517af482012-05-17 14:38:34 +0300594 if (!av) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400595 /*
596 * No eraseblocks belonging to this volume found. We
597 * don't actually know whether this static volume is
598 * completely corrupted or just contains no data. And
599 * we cannot know this as long as data size is not
600 * stored on flash. So we just assume the volume is
601 * empty. FIXME: this should be handled.
602 */
603 continue;
604 }
605
Artem Bityutskiy517af482012-05-17 14:38:34 +0300606 if (av->leb_count != av->used_ebs) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400607 /*
608 * We found a static volume which misses several
609 * eraseblocks. Treat it as corrupted.
610 */
611 ubi_warn("static volume %d misses %d LEBs - corrupted",
Artem Bityutskiy517af482012-05-17 14:38:34 +0300612 av->vol_id, av->used_ebs - av->leb_count);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400613 vol->corrupted = 1;
614 continue;
615 }
616
Artem Bityutskiy517af482012-05-17 14:38:34 +0300617 vol->used_ebs = av->used_ebs;
Vinit Agnihotrid08c3b72007-07-10 13:04:59 +0300618 vol->used_bytes =
619 (long long)(vol->used_ebs - 1) * vol->usable_leb_size;
Artem Bityutskiy517af482012-05-17 14:38:34 +0300620 vol->used_bytes += av->last_data_size;
621 vol->last_eb_bytes = av->last_data_size;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400622 }
623
Artem Bityutskiyd05c77a2007-12-17 15:42:57 +0200624 /* And add the layout volume */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400625 vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
626 if (!vol)
627 return -ENOMEM;
628
629 vol->reserved_pebs = UBI_LAYOUT_VOLUME_EBS;
Richard Weinberger1f4f4342012-01-10 17:57:03 +0100630 vol->alignment = UBI_LAYOUT_VOLUME_ALIGN;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400631 vol->vol_type = UBI_DYNAMIC_VOLUME;
632 vol->name_len = sizeof(UBI_LAYOUT_VOLUME_NAME) - 1;
633 memcpy(vol->name, UBI_LAYOUT_VOLUME_NAME, vol->name_len + 1);
634 vol->usable_leb_size = ubi->leb_size;
635 vol->used_ebs = vol->reserved_pebs;
636 vol->last_eb_bytes = vol->reserved_pebs;
Vinit Agnihotrid08c3b72007-07-10 13:04:59 +0300637 vol->used_bytes =
638 (long long)vol->used_ebs * (ubi->leb_size - vol->data_pad);
Artem Bityutskiy91f2d532008-01-24 11:23:23 +0200639 vol->vol_id = UBI_LAYOUT_VOLUME_ID;
Artem Bityutskiyd05c77a2007-12-17 15:42:57 +0200640 vol->ref_count = 1;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400641
642 ubi_assert(!ubi->volumes[i]);
643 ubi->volumes[vol_id2idx(ubi, vol->vol_id)] = vol;
644 reserved_pebs += vol->reserved_pebs;
645 ubi->vol_count += 1;
646 vol->ubi = ubi;
647
Artem Bityutskiy5fc01ab2010-09-03 23:08:15 +0300648 if (reserved_pebs > ubi->avail_pebs) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400649 ubi_err("not enough PEBs, required %d, available %d",
650 reserved_pebs, ubi->avail_pebs);
Artem Bityutskiy5fc01ab2010-09-03 23:08:15 +0300651 if (ubi->corr_peb_count)
652 ubi_err("%d PEBs are corrupted and not used",
653 ubi->corr_peb_count);
654 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400655 ubi->rsvd_pebs += reserved_pebs;
656 ubi->avail_pebs -= reserved_pebs;
657
658 return 0;
659}
660
661/**
Artem Bityutskiy517af482012-05-17 14:38:34 +0300662 * check_av - check volume attaching information.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400663 * @vol: UBI volume description object
Artem Bityutskiy517af482012-05-17 14:38:34 +0300664 * @av: volume attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400665 *
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300666 * This function returns zero if the volume attaching information is consistent
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400667 * to the data read from the volume tabla, and %-EINVAL if not.
668 */
Artem Bityutskiy517af482012-05-17 14:38:34 +0300669static int check_av(const struct ubi_volume *vol,
670 const struct ubi_ainf_volume *av)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400671{
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300672 int err;
673
Artem Bityutskiy517af482012-05-17 14:38:34 +0300674 if (av->highest_lnum >= vol->reserved_pebs) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300675 err = 1;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400676 goto bad;
677 }
Artem Bityutskiy517af482012-05-17 14:38:34 +0300678 if (av->leb_count > vol->reserved_pebs) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300679 err = 2;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400680 goto bad;
681 }
Artem Bityutskiy517af482012-05-17 14:38:34 +0300682 if (av->vol_type != vol->vol_type) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300683 err = 3;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400684 goto bad;
685 }
Artem Bityutskiy517af482012-05-17 14:38:34 +0300686 if (av->used_ebs > vol->reserved_pebs) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300687 err = 4;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400688 goto bad;
689 }
Artem Bityutskiy517af482012-05-17 14:38:34 +0300690 if (av->data_pad != vol->data_pad) {
Artem Bityutskiy979c9292008-05-14 16:10:33 +0300691 err = 5;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400692 goto bad;
693 }
694 return 0;
695
696bad:
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300697 ubi_err("bad attaching information, error %d", err);
Artem Bityutskiy517af482012-05-17 14:38:34 +0300698 ubi_dump_av(av);
Artem Bityutskiy766381f2012-05-16 17:53:17 +0300699 ubi_dump_vol_info(vol);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400700 return -EINVAL;
701}
702
703/**
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300704 * check_attaching_info - check that attaching information.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400705 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300706 * @ai: attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400707 *
708 * Even though we protect on-flash data by CRC checksums, we still don't trust
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300709 * the media. This function ensures that attaching information is consistent to
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300710 * the information read from the volume table. Returns zero if the attaching
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400711 * information is OK and %-EINVAL if it is not.
712 */
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300713static int check_attaching_info(const struct ubi_device *ubi,
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300714 struct ubi_attach_info *ai)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400715{
716 int err, i;
Artem Bityutskiy517af482012-05-17 14:38:34 +0300717 struct ubi_ainf_volume *av;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400718 struct ubi_volume *vol;
719
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300720 if (ai->vols_found > UBI_INT_VOL_COUNT + ubi->vtbl_slots) {
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300721 ubi_err("found %d volumes while attaching, maximum is %d + %d",
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300722 ai->vols_found, UBI_INT_VOL_COUNT, ubi->vtbl_slots);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400723 return -EINVAL;
724 }
725
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300726 if (ai->highest_vol_id >= ubi->vtbl_slots + UBI_INT_VOL_COUNT &&
727 ai->highest_vol_id < UBI_INTERNAL_VOL_START) {
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300728 ubi_err("too large volume ID %d found", ai->highest_vol_id);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400729 return -EINVAL;
730 }
731
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400732 for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
733 cond_resched();
734
Artem Bityutskiydcd85fd2012-05-17 15:33:20 +0300735 av = ubi_find_av(ai, i);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400736 vol = ubi->volumes[i];
737 if (!vol) {
Artem Bityutskiy517af482012-05-17 14:38:34 +0300738 if (av)
Artem Bityutskiyd717dc22012-05-17 15:36:39 +0300739 ubi_remove_av(ai, av);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400740 continue;
741 }
742
743 if (vol->reserved_pebs == 0) {
744 ubi_assert(i < ubi->vtbl_slots);
745
Artem Bityutskiy517af482012-05-17 14:38:34 +0300746 if (!av)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400747 continue;
748
749 /*
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300750 * During attaching we found a volume which does not
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400751 * exist according to the information in the volume
752 * table. This must have happened due to an unclean
753 * reboot while the volume was being removed. Discard
754 * these eraseblocks.
755 */
Artem Bityutskiy517af482012-05-17 14:38:34 +0300756 ubi_msg("finish volume %d removal", av->vol_id);
Artem Bityutskiyd717dc22012-05-17 15:36:39 +0300757 ubi_remove_av(ai, av);
Artem Bityutskiy517af482012-05-17 14:38:34 +0300758 } else if (av) {
759 err = check_av(vol, av);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400760 if (err)
761 return err;
762 }
763 }
764
765 return 0;
766}
767
768/**
Artem Bityutskiyebaaf1a2008-07-18 13:34:32 +0300769 * ubi_read_volume_table - read the volume table.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400770 * @ubi: UBI device description object
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300771 * @ai: attaching information
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400772 *
773 * This function reads volume table, checks it, recover from errors if needed,
774 * or creates it if needed. Returns zero in case of success and a negative
775 * error code in case of failure.
776 */
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300777int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_attach_info *ai)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400778{
779 int i, err;
Artem Bityutskiy517af482012-05-17 14:38:34 +0300780 struct ubi_ainf_volume *av;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400781
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300782 empty_vtbl_record.crc = cpu_to_be32(0xf116c36b);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400783
784 /*
785 * The number of supported volumes is limited by the eraseblock size
786 * and by the UBI_MAX_VOLUMES constant.
787 */
788 ubi->vtbl_slots = ubi->leb_size / UBI_VTBL_RECORD_SIZE;
789 if (ubi->vtbl_slots > UBI_MAX_VOLUMES)
790 ubi->vtbl_slots = UBI_MAX_VOLUMES;
791
792 ubi->vtbl_size = ubi->vtbl_slots * UBI_VTBL_RECORD_SIZE;
793 ubi->vtbl_size = ALIGN(ubi->vtbl_size, ubi->min_io_size);
794
Artem Bityutskiydcd85fd2012-05-17 15:33:20 +0300795 av = ubi_find_av(ai, UBI_LAYOUT_VOLUME_ID);
Artem Bityutskiy517af482012-05-17 14:38:34 +0300796 if (!av) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400797 /*
798 * No logical eraseblocks belonging to the layout volume were
799 * found. This could mean that the flash is just empty. In
800 * this case we create empty layout volume.
801 *
802 * But if flash is not empty this must be a corruption or the
803 * MTD device just contains garbage.
804 */
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300805 if (ai->is_empty) {
806 ubi->vtbl = create_empty_lvol(ubi, ai);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400807 if (IS_ERR(ubi->vtbl))
808 return PTR_ERR(ubi->vtbl);
809 } else {
810 ubi_err("the layout volume was not found");
811 return -EINVAL;
812 }
813 } else {
Artem Bityutskiy517af482012-05-17 14:38:34 +0300814 if (av->leb_count > UBI_LAYOUT_VOLUME_EBS) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400815 /* This must not happen with proper UBI images */
Artem Bityutskiye2986822012-05-16 18:39:56 +0300816 ubi_err("too many LEBs (%d) in layout volume",
Artem Bityutskiy517af482012-05-17 14:38:34 +0300817 av->leb_count);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400818 return -EINVAL;
819 }
820
Artem Bityutskiy517af482012-05-17 14:38:34 +0300821 ubi->vtbl = process_lvol(ubi, ai, av);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400822 if (IS_ERR(ubi->vtbl))
823 return PTR_ERR(ubi->vtbl);
824 }
825
Artem Bityutskiy5fc01ab2010-09-03 23:08:15 +0300826 ubi->avail_pebs = ubi->good_peb_count - ubi->corr_peb_count;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400827
828 /*
829 * The layout volume is OK, initialize the corresponding in-RAM data
830 * structures.
831 */
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300832 err = init_volumes(ubi, ai, ubi->vtbl);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400833 if (err)
834 goto out_free;
835
836 /*
Artem Bityutskiya4e60422012-05-17 13:09:08 +0300837 * Make sure that the attaching information is consistent to the
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400838 * information stored in the volume table.
839 */
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300840 err = check_attaching_info(ubi, ai);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400841 if (err)
842 goto out_free;
843
844 return 0;
845
846out_free:
Artem Bityutskiy92ad8f32007-05-06 16:12:54 +0300847 vfree(ubi->vtbl);
Artem Bityutskiy9c9ec142008-07-18 13:19:52 +0300848 for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
849 kfree(ubi->volumes[i]);
850 ubi->volumes[i] = NULL;
851 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400852 return err;
853}
854
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400855/**
Artem Bityutskiy7bf523a2012-05-16 18:29:54 +0300856 * self_vtbl_check - check volume table.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400857 * @ubi: UBI device description object
858 */
Artem Bityutskiy7bf523a2012-05-16 18:29:54 +0300859static void self_vtbl_check(const struct ubi_device *ubi)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400860{
Ezequiel Garcia64575572012-11-28 09:18:29 -0300861 if (!ubi_dbg_chk_gen(ubi))
Artem Bityutskiy92d124f2011-03-14 18:17:40 +0200862 return;
863
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400864 if (vtbl_check(ubi, ubi->vtbl)) {
Artem Bityutskiy7bf523a2012-05-16 18:29:54 +0300865 ubi_err("self-check failed");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400866 BUG();
867 }
868}