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