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