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