1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85#include <linux/err.h>
86#include <linux/slab.h>
87#include <linux/crc32.h>
88#include <linux/math64.h>
89#include <linux/random.h>
90#include "ubi.h"
91
92static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai);
93
94
95static struct ubi_ec_hdr *ech;
96static struct ubi_vid_hdr *vidh;
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119static int add_to_list(struct ubi_attach_info *ai, int pnum, int vol_id,
120 int lnum, int ec, int to_head, struct list_head *list)
121{
122 struct ubi_ainf_peb *aeb;
123
124 if (list == &ai->free) {
125 dbg_bld("add to free: PEB %d, EC %d", pnum, ec);
126 } else if (list == &ai->erase) {
127 dbg_bld("add to erase: PEB %d, EC %d", pnum, ec);
128 } else if (list == &ai->alien) {
129 dbg_bld("add to alien: PEB %d, EC %d", pnum, ec);
130 ai->alien_peb_count += 1;
131 } else
132 BUG();
133
134 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
135 if (!aeb)
136 return -ENOMEM;
137
138 aeb->pnum = pnum;
139 aeb->vol_id = vol_id;
140 aeb->lnum = lnum;
141 aeb->ec = ec;
142 if (to_head)
143 list_add(&aeb->u.list, list);
144 else
145 list_add_tail(&aeb->u.list, list);
146 return 0;
147}
148
149
150
151
152
153
154
155
156
157
158
159
160static int add_corrupted(struct ubi_attach_info *ai, int pnum, int ec)
161{
162 struct ubi_ainf_peb *aeb;
163
164 dbg_bld("add to corrupted: PEB %d, EC %d", pnum, ec);
165
166 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
167 if (!aeb)
168 return -ENOMEM;
169
170 ai->corr_peb_count += 1;
171 aeb->pnum = pnum;
172 aeb->ec = ec;
173 list_add(&aeb->u.list, &ai->corr);
174 return 0;
175}
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191static int validate_vid_hdr(const struct ubi_vid_hdr *vid_hdr,
192 const struct ubi_ainf_volume *av, int pnum)
193{
194 int vol_type = vid_hdr->vol_type;
195 int vol_id = be32_to_cpu(vid_hdr->vol_id);
196 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
197 int data_pad = be32_to_cpu(vid_hdr->data_pad);
198
199 if (av->leb_count != 0) {
200 int av_vol_type;
201
202
203
204
205
206
207
208 if (vol_id != av->vol_id) {
209 ubi_err("inconsistent vol_id");
210 goto bad;
211 }
212
213 if (av->vol_type == UBI_STATIC_VOLUME)
214 av_vol_type = UBI_VID_STATIC;
215 else
216 av_vol_type = UBI_VID_DYNAMIC;
217
218 if (vol_type != av_vol_type) {
219 ubi_err("inconsistent vol_type");
220 goto bad;
221 }
222
223 if (used_ebs != av->used_ebs) {
224 ubi_err("inconsistent used_ebs");
225 goto bad;
226 }
227
228 if (data_pad != av->data_pad) {
229 ubi_err("inconsistent data_pad");
230 goto bad;
231 }
232 }
233
234 return 0;
235
236bad:
237 ubi_err("inconsistent VID header at PEB %d", pnum);
238 ubi_dump_vid_hdr(vid_hdr);
239 ubi_dump_av(av);
240 return -EINVAL;
241}
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256static struct ubi_ainf_volume *add_volume(struct ubi_attach_info *ai,
257 int vol_id, int pnum,
258 const struct ubi_vid_hdr *vid_hdr)
259{
260 struct ubi_ainf_volume *av;
261 struct rb_node **p = &ai->volumes.rb_node, *parent = NULL;
262
263 ubi_assert(vol_id == be32_to_cpu(vid_hdr->vol_id));
264
265
266 while (*p) {
267 parent = *p;
268 av = rb_entry(parent, struct ubi_ainf_volume, rb);
269
270 if (vol_id == av->vol_id)
271 return av;
272
273 if (vol_id > av->vol_id)
274 p = &(*p)->rb_left;
275 else
276 p = &(*p)->rb_right;
277 }
278
279
280 av = kmalloc(sizeof(struct ubi_ainf_volume), GFP_KERNEL);
281 if (!av)
282 return ERR_PTR(-ENOMEM);
283
284 av->highest_lnum = av->leb_count = 0;
285 av->vol_id = vol_id;
286 av->root = RB_ROOT;
287 av->used_ebs = be32_to_cpu(vid_hdr->used_ebs);
288 av->data_pad = be32_to_cpu(vid_hdr->data_pad);
289 av->compat = vid_hdr->compat;
290 av->vol_type = vid_hdr->vol_type == UBI_VID_DYNAMIC ? UBI_DYNAMIC_VOLUME
291 : UBI_STATIC_VOLUME;
292 if (vol_id > ai->highest_vol_id)
293 ai->highest_vol_id = vol_id;
294
295 rb_link_node(&av->rb, parent, p);
296 rb_insert_color(&av->rb, &ai->volumes);
297 ai->vols_found += 1;
298 dbg_bld("added volume %d", vol_id);
299 return av;
300}
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,
323 int pnum, const struct ubi_vid_hdr *vid_hdr)
324{
325 int len, err, second_is_newer, bitflips = 0, corrupted = 0;
326 uint32_t data_crc, crc;
327 struct ubi_vid_hdr *vh = NULL;
328 unsigned long long sqnum2 = be64_to_cpu(vid_hdr->sqnum);
329
330 if (sqnum2 == aeb->sqnum) {
331
332
333
334
335
336
337
338
339 ubi_err("unsupported on-flash UBI format");
340 return -EINVAL;
341 }
342
343
344 second_is_newer = (sqnum2 > aeb->sqnum);
345
346
347
348
349
350
351
352
353
354
355 if (second_is_newer) {
356 if (!vid_hdr->copy_flag) {
357
358 dbg_bld("second PEB %d is newer, copy_flag is unset",
359 pnum);
360 return 1;
361 }
362 } else {
363 if (!aeb->copy_flag) {
364
365 dbg_bld("first PEB %d is newer, copy_flag is unset",
366 pnum);
367 return bitflips << 1;
368 }
369
370 vh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
371 if (!vh)
372 return -ENOMEM;
373
374 pnum = aeb->pnum;
375 err = ubi_io_read_vid_hdr(ubi, pnum, vh, 0);
376 if (err) {
377 if (err == UBI_IO_BITFLIPS)
378 bitflips = 1;
379 else {
380 ubi_err("VID of PEB %d header is bad, but it was OK earlier, err %d",
381 pnum, err);
382 if (err > 0)
383 err = -EIO;
384
385 goto out_free_vidh;
386 }
387 }
388
389 vid_hdr = vh;
390 }
391
392
393
394 len = be32_to_cpu(vid_hdr->data_size);
395
396 mutex_lock(&ubi->buf_mutex);
397 err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, len);
398 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
399 goto out_unlock;
400
401 data_crc = be32_to_cpu(vid_hdr->data_crc);
402 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, len);
403 if (crc != data_crc) {
404 dbg_bld("PEB %d CRC error: calculated %#08x, must be %#08x",
405 pnum, crc, data_crc);
406 corrupted = 1;
407 bitflips = 0;
408 second_is_newer = !second_is_newer;
409 } else {
410 dbg_bld("PEB %d CRC is OK", pnum);
411 bitflips = !!err;
412 }
413 mutex_unlock(&ubi->buf_mutex);
414
415 ubi_free_vid_hdr(ubi, vh);
416
417 if (second_is_newer)
418 dbg_bld("second PEB %d is newer, copy_flag is set", pnum);
419 else
420 dbg_bld("first PEB %d is newer, copy_flag is set", pnum);
421
422 return second_is_newer | (bitflips << 1) | (corrupted << 2);
423
424out_unlock:
425 mutex_unlock(&ubi->buf_mutex);
426out_free_vidh:
427 ubi_free_vid_hdr(ubi, vh);
428 return err;
429}
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum,
448 int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips)
449{
450 int err, vol_id, lnum;
451 unsigned long long sqnum;
452 struct ubi_ainf_volume *av;
453 struct ubi_ainf_peb *aeb;
454 struct rb_node **p, *parent = NULL;
455
456 vol_id = be32_to_cpu(vid_hdr->vol_id);
457 lnum = be32_to_cpu(vid_hdr->lnum);
458 sqnum = be64_to_cpu(vid_hdr->sqnum);
459
460 dbg_bld("PEB %d, LEB %d:%d, EC %d, sqnum %llu, bitflips %d",
461 pnum, vol_id, lnum, ec, sqnum, bitflips);
462
463 av = add_volume(ai, vol_id, pnum, vid_hdr);
464 if (IS_ERR(av))
465 return PTR_ERR(av);
466
467 if (ai->max_sqnum < sqnum)
468 ai->max_sqnum = sqnum;
469
470
471
472
473
474 p = &av->root.rb_node;
475 while (*p) {
476 int cmp_res;
477
478 parent = *p;
479 aeb = rb_entry(parent, struct ubi_ainf_peb, u.rb);
480 if (lnum != aeb->lnum) {
481 if (lnum < aeb->lnum)
482 p = &(*p)->rb_left;
483 else
484 p = &(*p)->rb_right;
485 continue;
486 }
487
488
489
490
491
492
493 dbg_bld("this LEB already exists: PEB %d, sqnum %llu, EC %d",
494 aeb->pnum, aeb->sqnum, aeb->ec);
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509 if (aeb->sqnum == sqnum && sqnum != 0) {
510 ubi_err("two LEBs with same sequence number %llu",
511 sqnum);
512 ubi_dump_aeb(aeb, 0);
513 ubi_dump_vid_hdr(vid_hdr);
514 return -EINVAL;
515 }
516
517
518
519
520
521 cmp_res = ubi_compare_lebs(ubi, aeb, pnum, vid_hdr);
522 if (cmp_res < 0)
523 return cmp_res;
524
525 if (cmp_res & 1) {
526
527
528
529
530 err = validate_vid_hdr(vid_hdr, av, pnum);
531 if (err)
532 return err;
533
534 err = add_to_list(ai, aeb->pnum, aeb->vol_id,
535 aeb->lnum, aeb->ec, cmp_res & 4,
536 &ai->erase);
537 if (err)
538 return err;
539
540 aeb->ec = ec;
541 aeb->pnum = pnum;
542 aeb->vol_id = vol_id;
543 aeb->lnum = lnum;
544 aeb->scrub = ((cmp_res & 2) || bitflips);
545 aeb->copy_flag = vid_hdr->copy_flag;
546 aeb->sqnum = sqnum;
547
548 if (av->highest_lnum == lnum)
549 av->last_data_size =
550 be32_to_cpu(vid_hdr->data_size);
551
552 return 0;
553 } else {
554
555
556
557
558 return add_to_list(ai, pnum, vol_id, lnum, ec,
559 cmp_res & 4, &ai->erase);
560 }
561 }
562
563
564
565
566
567
568 err = validate_vid_hdr(vid_hdr, av, pnum);
569 if (err)
570 return err;
571
572 aeb = kmem_cache_alloc(ai->aeb_slab_cache, GFP_KERNEL);
573 if (!aeb)
574 return -ENOMEM;
575
576 aeb->ec = ec;
577 aeb->pnum = pnum;
578 aeb->vol_id = vol_id;
579 aeb->lnum = lnum;
580 aeb->scrub = bitflips;
581 aeb->copy_flag = vid_hdr->copy_flag;
582 aeb->sqnum = sqnum;
583
584 if (av->highest_lnum <= lnum) {
585 av->highest_lnum = lnum;
586 av->last_data_size = be32_to_cpu(vid_hdr->data_size);
587 }
588
589 av->leb_count += 1;
590 rb_link_node(&aeb->u.rb, parent, p);
591 rb_insert_color(&aeb->u.rb, &av->root);
592 return 0;
593}
594
595
596
597
598
599
600
601
602
603struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai,
604 int vol_id)
605{
606 struct ubi_ainf_volume *av;
607 struct rb_node *p = ai->volumes.rb_node;
608
609 while (p) {
610 av = rb_entry(p, struct ubi_ainf_volume, rb);
611
612 if (vol_id == av->vol_id)
613 return av;
614
615 if (vol_id > av->vol_id)
616 p = p->rb_left;
617 else
618 p = p->rb_right;
619 }
620
621 return NULL;
622}
623
624
625
626
627
628
629void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
630{
631 struct rb_node *rb;
632 struct ubi_ainf_peb *aeb;
633
634 dbg_bld("remove attaching information about volume %d", av->vol_id);
635
636 while ((rb = rb_first(&av->root))) {
637 aeb = rb_entry(rb, struct ubi_ainf_peb, u.rb);
638 rb_erase(&aeb->u.rb, &av->root);
639 list_add_tail(&aeb->u.list, &ai->erase);
640 }
641
642 rb_erase(&av->rb, &ai->volumes);
643 kfree(av);
644 ai->vols_found -= 1;
645}
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660static int early_erase_peb(struct ubi_device *ubi,
661 const struct ubi_attach_info *ai, int pnum, int ec)
662{
663 int err;
664 struct ubi_ec_hdr *ec_hdr;
665
666 if ((long long)ec >= UBI_MAX_ERASECOUNTER) {
667
668
669
670
671 ubi_err("erase counter overflow at PEB %d, EC %d", pnum, ec);
672 return -EINVAL;
673 }
674
675 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
676 if (!ec_hdr)
677 return -ENOMEM;
678
679 ec_hdr->ec = cpu_to_be64(ec);
680
681 err = ubi_io_sync_erase(ubi, pnum, 0);
682 if (err < 0)
683 goto out_free;
684
685 err = ubi_io_write_ec_hdr(ubi, pnum, ec_hdr);
686
687out_free:
688 kfree(ec_hdr);
689 return err;
690}
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi,
707 struct ubi_attach_info *ai)
708{
709 int err = 0;
710 struct ubi_ainf_peb *aeb, *tmp_aeb;
711
712 if (!list_empty(&ai->free)) {
713 aeb = list_entry(ai->free.next, struct ubi_ainf_peb, u.list);
714 list_del(&aeb->u.list);
715 dbg_bld("return free PEB %d, EC %d", aeb->pnum, aeb->ec);
716 return aeb;
717 }
718
719
720
721
722
723
724
725 list_for_each_entry_safe(aeb, tmp_aeb, &ai->erase, u.list) {
726 if (aeb->ec == UBI_UNKNOWN)
727 aeb->ec = ai->mean_ec;
728
729 err = early_erase_peb(ubi, ai, aeb->pnum, aeb->ec+1);
730 if (err)
731 continue;
732
733 aeb->ec += 1;
734 list_del(&aeb->u.list);
735 dbg_bld("return PEB %d, EC %d", aeb->pnum, aeb->ec);
736 return aeb;
737 }
738
739 ubi_err("no free eraseblocks");
740 return ERR_PTR(-ENOSPC);
741}
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760static int check_corruption(struct ubi_device *ubi, struct ubi_vid_hdr *vid_hdr,
761 int pnum)
762{
763 int err;
764
765 mutex_lock(&ubi->buf_mutex);
766 memset(ubi->peb_buf, 0x00, ubi->leb_size);
767
768 err = ubi_io_read(ubi, ubi->peb_buf, pnum, ubi->leb_start,
769 ubi->leb_size);
770 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
771
772
773
774
775
776
777
778 err = 0;
779 goto out_unlock;
780 }
781
782 if (err)
783 goto out_unlock;
784
785 if (ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->leb_size))
786 goto out_unlock;
787
788 ubi_err("PEB %d contains corrupted VID header, and the data does not contain all 0xFF",
789 pnum);
790 ubi_err("this may be a non-UBI PEB or a severe VID header corruption which requires manual inspection");
791 ubi_dump_vid_hdr(vid_hdr);
792 pr_err("hexdump of PEB %d offset %d, length %d",
793 pnum, ubi->leb_start, ubi->leb_size);
794 ubi_dbg_print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
795 ubi->peb_buf, ubi->leb_size, 1);
796 err = 1;
797
798out_unlock:
799 mutex_unlock(&ubi->buf_mutex);
800 return err;
801}
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816static int scan_peb(struct ubi_device *ubi, struct ubi_attach_info *ai,
817 int pnum, int *vid, unsigned long long *sqnum)
818{
819 long long uninitialized_var(ec);
820 int err, bitflips = 0, vol_id = -1, ec_err = 0;
821
822 dbg_bld("scan PEB %d", pnum);
823
824
825 err = ubi_io_is_bad(ubi, pnum);
826 if (err < 0)
827 return err;
828 else if (err) {
829 ai->bad_peb_count += 1;
830 return 0;
831 }
832
833 err = ubi_io_read_ec_hdr(ubi, pnum, ech, 0);
834 if (err < 0)
835 return err;
836 switch (err) {
837 case 0:
838 break;
839 case UBI_IO_BITFLIPS:
840 bitflips = 1;
841 break;
842 case UBI_IO_FF:
843 ai->empty_peb_count += 1;
844 return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
845 UBI_UNKNOWN, 0, &ai->erase);
846 case UBI_IO_FF_BITFLIPS:
847 ai->empty_peb_count += 1;
848 return add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
849 UBI_UNKNOWN, 1, &ai->erase);
850 case UBI_IO_BAD_HDR_EBADMSG:
851 case UBI_IO_BAD_HDR:
852
853
854
855
856
857 ec_err = err;
858 ec = UBI_UNKNOWN;
859 bitflips = 1;
860 break;
861 default:
862 ubi_err("'ubi_io_read_ec_hdr()' returned unknown code %d", err);
863 return -EINVAL;
864 }
865
866 if (!ec_err) {
867 int image_seq;
868
869
870 if (ech->version != UBI_VERSION) {
871 ubi_err("this UBI version is %d, image version is %d",
872 UBI_VERSION, (int)ech->version);
873 return -EINVAL;
874 }
875
876 ec = be64_to_cpu(ech->ec);
877 if (ec > UBI_MAX_ERASECOUNTER) {
878
879
880
881
882
883
884
885 ubi_err("erase counter overflow, max is %d",
886 UBI_MAX_ERASECOUNTER);
887 ubi_dump_ec_hdr(ech);
888 return -EINVAL;
889 }
890
891
892
893
894
895
896
897
898
899
900
901
902 image_seq = be32_to_cpu(ech->image_seq);
903 if (!ubi->image_seq && image_seq)
904 ubi->image_seq = image_seq;
905 if (ubi->image_seq && image_seq &&
906 ubi->image_seq != image_seq) {
907 ubi_err("bad image sequence number %d in PEB %d, expected %d",
908 image_seq, pnum, ubi->image_seq);
909 ubi_dump_ec_hdr(ech);
910 return -EINVAL;
911 }
912 }
913
914
915
916 err = ubi_io_read_vid_hdr(ubi, pnum, vidh, 0);
917 if (err < 0)
918 return err;
919 switch (err) {
920 case 0:
921 break;
922 case UBI_IO_BITFLIPS:
923 bitflips = 1;
924 break;
925 case UBI_IO_BAD_HDR_EBADMSG:
926 if (ec_err == UBI_IO_BAD_HDR_EBADMSG)
927
928
929
930
931
932
933 ai->maybe_bad_peb_count += 1;
934 case UBI_IO_BAD_HDR:
935 if (ec_err)
936
937
938
939
940
941
942
943
944
945
946
947
948 err = 0;
949 else
950
951
952
953
954 err = check_corruption(ubi, vidh, pnum);
955
956 if (err < 0)
957 return err;
958 else if (!err)
959
960 err = add_to_list(ai, pnum, UBI_UNKNOWN,
961 UBI_UNKNOWN, ec, 1, &ai->erase);
962 else
963
964 err = add_corrupted(ai, pnum, ec);
965 if (err)
966 return err;
967 goto adjust_mean_ec;
968 case UBI_IO_FF_BITFLIPS:
969 err = add_to_list(ai, pnum, UBI_UNKNOWN, UBI_UNKNOWN,
970 ec, 1, &ai->erase);
971 if (err)
972 return err;
973 goto adjust_mean_ec;
974 case UBI_IO_FF:
975 if (ec_err || bitflips)
976 err = add_to_list(ai, pnum, UBI_UNKNOWN,
977 UBI_UNKNOWN, ec, 1, &ai->erase);
978 else
979 err = add_to_list(ai, pnum, UBI_UNKNOWN,
980 UBI_UNKNOWN, ec, 0, &ai->free);
981 if (err)
982 return err;
983 goto adjust_mean_ec;
984 default:
985 ubi_err("'ubi_io_read_vid_hdr()' returned unknown code %d",
986 err);
987 return -EINVAL;
988 }
989
990 vol_id = be32_to_cpu(vidh->vol_id);
991 if (vid)
992 *vid = vol_id;
993 if (sqnum)
994 *sqnum = be64_to_cpu(vidh->sqnum);
995 if (vol_id > UBI_MAX_VOLUMES && vol_id != UBI_LAYOUT_VOLUME_ID) {
996 int lnum = be32_to_cpu(vidh->lnum);
997
998
999 switch (vidh->compat) {
1000 case UBI_COMPAT_DELETE:
1001 if (vol_id != UBI_FM_SB_VOLUME_ID
1002 && vol_id != UBI_FM_DATA_VOLUME_ID) {
1003 ubi_msg("\"delete\" compatible internal volume %d:%d found, will remove it",
1004 vol_id, lnum);
1005 }
1006 err = add_to_list(ai, pnum, vol_id, lnum,
1007 ec, 1, &ai->erase);
1008 if (err)
1009 return err;
1010 return 0;
1011
1012 case UBI_COMPAT_RO:
1013 ubi_msg("read-only compatible internal volume %d:%d found, switch to read-only mode",
1014 vol_id, lnum);
1015 ubi->ro_mode = 1;
1016 break;
1017
1018 case UBI_COMPAT_PRESERVE:
1019 ubi_msg("\"preserve\" compatible internal volume %d:%d found",
1020 vol_id, lnum);
1021 err = add_to_list(ai, pnum, vol_id, lnum,
1022 ec, 0, &ai->alien);
1023 if (err)
1024 return err;
1025 return 0;
1026
1027 case UBI_COMPAT_REJECT:
1028 ubi_err("incompatible internal volume %d:%d found",
1029 vol_id, lnum);
1030 return -EINVAL;
1031 }
1032 }
1033
1034 if (ec_err)
1035 ubi_warn("valid VID header but corrupted EC header at PEB %d",
1036 pnum);
1037 err = ubi_add_to_av(ubi, ai, pnum, ec, vidh, bitflips);
1038 if (err)
1039 return err;
1040
1041adjust_mean_ec:
1042 if (!ec_err) {
1043 ai->ec_sum += ec;
1044 ai->ec_count += 1;
1045 if (ec > ai->max_ec)
1046 ai->max_ec = ec;
1047 if (ec < ai->min_ec)
1048 ai->min_ec = ec;
1049 }
1050
1051 return 0;
1052}
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065static int late_analysis(struct ubi_device *ubi, struct ubi_attach_info *ai)
1066{
1067 struct ubi_ainf_peb *aeb;
1068 int max_corr, peb_count;
1069
1070 peb_count = ubi->peb_count - ai->bad_peb_count - ai->alien_peb_count;
1071 max_corr = peb_count / 20 ?: 8;
1072
1073
1074
1075
1076
1077
1078 if (ai->corr_peb_count) {
1079 ubi_err("%d PEBs are corrupted and preserved",
1080 ai->corr_peb_count);
1081 pr_err("Corrupted PEBs are:");
1082 list_for_each_entry(aeb, &ai->corr, u.list)
1083 pr_cont(" %d", aeb->pnum);
1084 pr_cont("\n");
1085
1086
1087
1088
1089
1090 if (ai->corr_peb_count >= max_corr) {
1091 ubi_err("too many corrupted PEBs, refusing");
1092 return -EINVAL;
1093 }
1094 }
1095
1096 if (ai->empty_peb_count + ai->maybe_bad_peb_count == peb_count) {
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112 if (ai->maybe_bad_peb_count <= 2) {
1113 ai->is_empty = 1;
1114 ubi_msg("empty MTD device detected");
1115 get_random_bytes(&ubi->image_seq,
1116 sizeof(ubi->image_seq));
1117 } else {
1118 ubi_err("MTD device is not UBI-formatted and possibly contains non-UBI data - refusing it");
1119 return -EINVAL;
1120 }
1121
1122 }
1123
1124 return 0;
1125}
1126
1127
1128
1129
1130
1131
1132
1133
1134static void destroy_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av)
1135{
1136 struct ubi_ainf_peb *aeb;
1137 struct rb_node *this = av->root.rb_node;
1138
1139 while (this) {
1140 if (this->rb_left)
1141 this = this->rb_left;
1142 else if (this->rb_right)
1143 this = this->rb_right;
1144 else {
1145 aeb = rb_entry(this, struct ubi_ainf_peb, u.rb);
1146 this = rb_parent(this);
1147 if (this) {
1148 if (this->rb_left == &aeb->u.rb)
1149 this->rb_left = NULL;
1150 else
1151 this->rb_right = NULL;
1152 }
1153
1154 kmem_cache_free(ai->aeb_slab_cache, aeb);
1155 }
1156 }
1157 kfree(av);
1158}
1159
1160
1161
1162
1163
1164static void destroy_ai(struct ubi_attach_info *ai)
1165{
1166 struct ubi_ainf_peb *aeb, *aeb_tmp;
1167 struct ubi_ainf_volume *av;
1168 struct rb_node *rb;
1169
1170 list_for_each_entry_safe(aeb, aeb_tmp, &ai->alien, u.list) {
1171 list_del(&aeb->u.list);
1172 kmem_cache_free(ai->aeb_slab_cache, aeb);
1173 }
1174 list_for_each_entry_safe(aeb, aeb_tmp, &ai->erase, u.list) {
1175 list_del(&aeb->u.list);
1176 kmem_cache_free(ai->aeb_slab_cache, aeb);
1177 }
1178 list_for_each_entry_safe(aeb, aeb_tmp, &ai->corr, u.list) {
1179 list_del(&aeb->u.list);
1180 kmem_cache_free(ai->aeb_slab_cache, aeb);
1181 }
1182 list_for_each_entry_safe(aeb, aeb_tmp, &ai->free, u.list) {
1183 list_del(&aeb->u.list);
1184 kmem_cache_free(ai->aeb_slab_cache, aeb);
1185 }
1186
1187
1188 rb = ai->volumes.rb_node;
1189 while (rb) {
1190 if (rb->rb_left)
1191 rb = rb->rb_left;
1192 else if (rb->rb_right)
1193 rb = rb->rb_right;
1194 else {
1195 av = rb_entry(rb, struct ubi_ainf_volume, rb);
1196
1197 rb = rb_parent(rb);
1198 if (rb) {
1199 if (rb->rb_left == &av->rb)
1200 rb->rb_left = NULL;
1201 else
1202 rb->rb_right = NULL;
1203 }
1204
1205 destroy_av(ai, av);
1206 }
1207 }
1208
1209 if (ai->aeb_slab_cache)
1210 kmem_cache_destroy(ai->aeb_slab_cache);
1211
1212 kfree(ai);
1213}
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225static int scan_all(struct ubi_device *ubi, struct ubi_attach_info *ai,
1226 int start)
1227{
1228 int err, pnum;
1229 struct rb_node *rb1, *rb2;
1230 struct ubi_ainf_volume *av;
1231 struct ubi_ainf_peb *aeb;
1232
1233 err = -ENOMEM;
1234
1235 ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
1236 if (!ech)
1237 return err;
1238
1239 vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
1240 if (!vidh)
1241 goto out_ech;
1242
1243 for (pnum = start; pnum < ubi->peb_count; pnum++) {
1244 cond_resched();
1245
1246 dbg_gen("process PEB %d", pnum);
1247 err = scan_peb(ubi, ai, pnum, NULL, NULL);
1248 if (err < 0)
1249 goto out_vidh;
1250 }
1251
1252 ubi_msg("scanning is finished");
1253
1254
1255 if (ai->ec_count)
1256 ai->mean_ec = div_u64(ai->ec_sum, ai->ec_count);
1257
1258 err = late_analysis(ubi, ai);
1259 if (err)
1260 goto out_vidh;
1261
1262
1263
1264
1265
1266 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1267 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
1268 if (aeb->ec == UBI_UNKNOWN)
1269 aeb->ec = ai->mean_ec;
1270 }
1271
1272 list_for_each_entry(aeb, &ai->free, u.list) {
1273 if (aeb->ec == UBI_UNKNOWN)
1274 aeb->ec = ai->mean_ec;
1275 }
1276
1277 list_for_each_entry(aeb, &ai->corr, u.list)
1278 if (aeb->ec == UBI_UNKNOWN)
1279 aeb->ec = ai->mean_ec;
1280
1281 list_for_each_entry(aeb, &ai->erase, u.list)
1282 if (aeb->ec == UBI_UNKNOWN)
1283 aeb->ec = ai->mean_ec;
1284
1285 err = self_check_ai(ubi, ai);
1286 if (err)
1287 goto out_vidh;
1288
1289 ubi_free_vid_hdr(ubi, vidh);
1290 kfree(ech);
1291
1292 return 0;
1293
1294out_vidh:
1295 ubi_free_vid_hdr(ubi, vidh);
1296out_ech:
1297 kfree(ech);
1298 return err;
1299}
1300
1301#ifdef CONFIG_MTD_UBI_FASTMAP
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313static int scan_fast(struct ubi_device *ubi, struct ubi_attach_info *ai)
1314{
1315 int err, pnum, fm_anchor = -1;
1316 unsigned long long max_sqnum = 0;
1317
1318 err = -ENOMEM;
1319
1320 ech = kzalloc(ubi->ec_hdr_alsize, GFP_KERNEL);
1321 if (!ech)
1322 goto out;
1323
1324 vidh = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
1325 if (!vidh)
1326 goto out_ech;
1327
1328 for (pnum = 0; pnum < UBI_FM_MAX_START; pnum++) {
1329 int vol_id = -1;
1330 unsigned long long sqnum = -1;
1331 cond_resched();
1332
1333 dbg_gen("process PEB %d", pnum);
1334 err = scan_peb(ubi, ai, pnum, &vol_id, &sqnum);
1335 if (err < 0)
1336 goto out_vidh;
1337
1338 if (vol_id == UBI_FM_SB_VOLUME_ID && sqnum > max_sqnum) {
1339 max_sqnum = sqnum;
1340 fm_anchor = pnum;
1341 }
1342 }
1343
1344 ubi_free_vid_hdr(ubi, vidh);
1345 kfree(ech);
1346
1347 if (fm_anchor < 0)
1348 return UBI_NO_FASTMAP;
1349
1350 return ubi_scan_fastmap(ubi, ai, fm_anchor);
1351
1352out_vidh:
1353 ubi_free_vid_hdr(ubi, vidh);
1354out_ech:
1355 kfree(ech);
1356out:
1357 return err;
1358}
1359
1360#endif
1361
1362static struct ubi_attach_info *alloc_ai(const char *slab_name)
1363{
1364 struct ubi_attach_info *ai;
1365
1366 ai = kzalloc(sizeof(struct ubi_attach_info), GFP_KERNEL);
1367 if (!ai)
1368 return ai;
1369
1370 INIT_LIST_HEAD(&ai->corr);
1371 INIT_LIST_HEAD(&ai->free);
1372 INIT_LIST_HEAD(&ai->erase);
1373 INIT_LIST_HEAD(&ai->alien);
1374 ai->volumes = RB_ROOT;
1375 ai->aeb_slab_cache = kmem_cache_create(slab_name,
1376 sizeof(struct ubi_ainf_peb),
1377 0, 0, NULL);
1378 if (!ai->aeb_slab_cache) {
1379 kfree(ai);
1380 ai = NULL;
1381 }
1382
1383 return ai;
1384}
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394int ubi_attach(struct ubi_device *ubi, int force_scan)
1395{
1396 int err;
1397 struct ubi_attach_info *ai;
1398
1399 ai = alloc_ai("ubi_aeb_slab_cache");
1400 if (!ai)
1401 return -ENOMEM;
1402
1403#ifdef CONFIG_MTD_UBI_FASTMAP
1404
1405 if ((int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd) <= UBI_FM_MAX_START) {
1406 ubi->fm_disabled = 1;
1407 force_scan = 1;
1408 }
1409
1410 if (force_scan)
1411 err = scan_all(ubi, ai, 0);
1412 else {
1413 err = scan_fast(ubi, ai);
1414 if (err > 0) {
1415 if (err != UBI_NO_FASTMAP) {
1416 destroy_ai(ai);
1417 ai = alloc_ai("ubi_aeb_slab_cache2");
1418 if (!ai)
1419 return -ENOMEM;
1420 }
1421
1422 err = scan_all(ubi, ai, UBI_FM_MAX_START);
1423 }
1424 }
1425#else
1426 err = scan_all(ubi, ai, 0);
1427#endif
1428 if (err)
1429 goto out_ai;
1430
1431 ubi->bad_peb_count = ai->bad_peb_count;
1432 ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
1433 ubi->corr_peb_count = ai->corr_peb_count;
1434 ubi->max_ec = ai->max_ec;
1435 ubi->mean_ec = ai->mean_ec;
1436 dbg_gen("max. sequence number: %llu", ai->max_sqnum);
1437
1438 err = ubi_read_volume_table(ubi, ai);
1439 if (err)
1440 goto out_ai;
1441
1442 err = ubi_wl_init(ubi, ai);
1443 if (err)
1444 goto out_vtbl;
1445
1446 err = ubi_eba_init(ubi, ai);
1447 if (err)
1448 goto out_wl;
1449
1450#ifdef CONFIG_MTD_UBI_FASTMAP
1451 if (ubi->fm && ubi_dbg_chk_gen(ubi)) {
1452 struct ubi_attach_info *scan_ai;
1453
1454 scan_ai = alloc_ai("ubi_ckh_aeb_slab_cache");
1455 if (!scan_ai)
1456 goto out_wl;
1457
1458 err = scan_all(ubi, scan_ai, 0);
1459 if (err) {
1460 destroy_ai(scan_ai);
1461 goto out_wl;
1462 }
1463
1464 err = self_check_eba(ubi, ai, scan_ai);
1465 destroy_ai(scan_ai);
1466
1467 if (err)
1468 goto out_wl;
1469 }
1470#endif
1471
1472 destroy_ai(ai);
1473 return 0;
1474
1475out_wl:
1476 ubi_wl_close(ubi);
1477out_vtbl:
1478 ubi_free_internal_volumes(ubi);
1479 vfree(ubi->vtbl);
1480out_ai:
1481 destroy_ai(ai);
1482 return err;
1483}
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493static int self_check_ai(struct ubi_device *ubi, struct ubi_attach_info *ai)
1494{
1495 int pnum, err, vols_found = 0;
1496 struct rb_node *rb1, *rb2;
1497 struct ubi_ainf_volume *av;
1498 struct ubi_ainf_peb *aeb, *last_aeb;
1499 uint8_t *buf;
1500
1501 if (!ubi_dbg_chk_gen(ubi))
1502 return 0;
1503
1504
1505
1506
1507 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1508 int leb_count = 0;
1509
1510 cond_resched();
1511
1512 vols_found += 1;
1513
1514 if (ai->is_empty) {
1515 ubi_err("bad is_empty flag");
1516 goto bad_av;
1517 }
1518
1519 if (av->vol_id < 0 || av->highest_lnum < 0 ||
1520 av->leb_count < 0 || av->vol_type < 0 || av->used_ebs < 0 ||
1521 av->data_pad < 0 || av->last_data_size < 0) {
1522 ubi_err("negative values");
1523 goto bad_av;
1524 }
1525
1526 if (av->vol_id >= UBI_MAX_VOLUMES &&
1527 av->vol_id < UBI_INTERNAL_VOL_START) {
1528 ubi_err("bad vol_id");
1529 goto bad_av;
1530 }
1531
1532 if (av->vol_id > ai->highest_vol_id) {
1533 ubi_err("highest_vol_id is %d, but vol_id %d is there",
1534 ai->highest_vol_id, av->vol_id);
1535 goto out;
1536 }
1537
1538 if (av->vol_type != UBI_DYNAMIC_VOLUME &&
1539 av->vol_type != UBI_STATIC_VOLUME) {
1540 ubi_err("bad vol_type");
1541 goto bad_av;
1542 }
1543
1544 if (av->data_pad > ubi->leb_size / 2) {
1545 ubi_err("bad data_pad");
1546 goto bad_av;
1547 }
1548
1549 last_aeb = NULL;
1550 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
1551 cond_resched();
1552
1553 last_aeb = aeb;
1554 leb_count += 1;
1555
1556 if (aeb->pnum < 0 || aeb->ec < 0) {
1557 ubi_err("negative values");
1558 goto bad_aeb;
1559 }
1560
1561 if (aeb->ec < ai->min_ec) {
1562 ubi_err("bad ai->min_ec (%d), %d found",
1563 ai->min_ec, aeb->ec);
1564 goto bad_aeb;
1565 }
1566
1567 if (aeb->ec > ai->max_ec) {
1568 ubi_err("bad ai->max_ec (%d), %d found",
1569 ai->max_ec, aeb->ec);
1570 goto bad_aeb;
1571 }
1572
1573 if (aeb->pnum >= ubi->peb_count) {
1574 ubi_err("too high PEB number %d, total PEBs %d",
1575 aeb->pnum, ubi->peb_count);
1576 goto bad_aeb;
1577 }
1578
1579 if (av->vol_type == UBI_STATIC_VOLUME) {
1580 if (aeb->lnum >= av->used_ebs) {
1581 ubi_err("bad lnum or used_ebs");
1582 goto bad_aeb;
1583 }
1584 } else {
1585 if (av->used_ebs != 0) {
1586 ubi_err("non-zero used_ebs");
1587 goto bad_aeb;
1588 }
1589 }
1590
1591 if (aeb->lnum > av->highest_lnum) {
1592 ubi_err("incorrect highest_lnum or lnum");
1593 goto bad_aeb;
1594 }
1595 }
1596
1597 if (av->leb_count != leb_count) {
1598 ubi_err("bad leb_count, %d objects in the tree",
1599 leb_count);
1600 goto bad_av;
1601 }
1602
1603 if (!last_aeb)
1604 continue;
1605
1606 aeb = last_aeb;
1607
1608 if (aeb->lnum != av->highest_lnum) {
1609 ubi_err("bad highest_lnum");
1610 goto bad_aeb;
1611 }
1612 }
1613
1614 if (vols_found != ai->vols_found) {
1615 ubi_err("bad ai->vols_found %d, should be %d",
1616 ai->vols_found, vols_found);
1617 goto out;
1618 }
1619
1620
1621 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb) {
1622 last_aeb = NULL;
1623 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb) {
1624 int vol_type;
1625
1626 cond_resched();
1627
1628 last_aeb = aeb;
1629
1630 err = ubi_io_read_vid_hdr(ubi, aeb->pnum, vidh, 1);
1631 if (err && err != UBI_IO_BITFLIPS) {
1632 ubi_err("VID header is not OK (%d)", err);
1633 if (err > 0)
1634 err = -EIO;
1635 return err;
1636 }
1637
1638 vol_type = vidh->vol_type == UBI_VID_DYNAMIC ?
1639 UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
1640 if (av->vol_type != vol_type) {
1641 ubi_err("bad vol_type");
1642 goto bad_vid_hdr;
1643 }
1644
1645 if (aeb->sqnum != be64_to_cpu(vidh->sqnum)) {
1646 ubi_err("bad sqnum %llu", aeb->sqnum);
1647 goto bad_vid_hdr;
1648 }
1649
1650 if (av->vol_id != be32_to_cpu(vidh->vol_id)) {
1651 ubi_err("bad vol_id %d", av->vol_id);
1652 goto bad_vid_hdr;
1653 }
1654
1655 if (av->compat != vidh->compat) {
1656 ubi_err("bad compat %d", vidh->compat);
1657 goto bad_vid_hdr;
1658 }
1659
1660 if (aeb->lnum != be32_to_cpu(vidh->lnum)) {
1661 ubi_err("bad lnum %d", aeb->lnum);
1662 goto bad_vid_hdr;
1663 }
1664
1665 if (av->used_ebs != be32_to_cpu(vidh->used_ebs)) {
1666 ubi_err("bad used_ebs %d", av->used_ebs);
1667 goto bad_vid_hdr;
1668 }
1669
1670 if (av->data_pad != be32_to_cpu(vidh->data_pad)) {
1671 ubi_err("bad data_pad %d", av->data_pad);
1672 goto bad_vid_hdr;
1673 }
1674 }
1675
1676 if (!last_aeb)
1677 continue;
1678
1679 if (av->highest_lnum != be32_to_cpu(vidh->lnum)) {
1680 ubi_err("bad highest_lnum %d", av->highest_lnum);
1681 goto bad_vid_hdr;
1682 }
1683
1684 if (av->last_data_size != be32_to_cpu(vidh->data_size)) {
1685 ubi_err("bad last_data_size %d", av->last_data_size);
1686 goto bad_vid_hdr;
1687 }
1688 }
1689
1690
1691
1692
1693
1694 buf = kzalloc(ubi->peb_count, GFP_KERNEL);
1695 if (!buf)
1696 return -ENOMEM;
1697
1698 for (pnum = 0; pnum < ubi->peb_count; pnum++) {
1699 err = ubi_io_is_bad(ubi, pnum);
1700 if (err < 0) {
1701 kfree(buf);
1702 return err;
1703 } else if (err)
1704 buf[pnum] = 1;
1705 }
1706
1707 ubi_rb_for_each_entry(rb1, av, &ai->volumes, rb)
1708 ubi_rb_for_each_entry(rb2, aeb, &av->root, u.rb)
1709 buf[aeb->pnum] = 1;
1710
1711 list_for_each_entry(aeb, &ai->free, u.list)
1712 buf[aeb->pnum] = 1;
1713
1714 list_for_each_entry(aeb, &ai->corr, u.list)
1715 buf[aeb->pnum] = 1;
1716
1717 list_for_each_entry(aeb, &ai->erase, u.list)
1718 buf[aeb->pnum] = 1;
1719
1720 list_for_each_entry(aeb, &ai->alien, u.list)
1721 buf[aeb->pnum] = 1;
1722
1723 err = 0;
1724 for (pnum = 0; pnum < ubi->peb_count; pnum++)
1725 if (!buf[pnum]) {
1726 ubi_err("PEB %d is not referred", pnum);
1727 err = 1;
1728 }
1729
1730 kfree(buf);
1731 if (err)
1732 goto out;
1733 return 0;
1734
1735bad_aeb:
1736 ubi_err("bad attaching information about LEB %d", aeb->lnum);
1737 ubi_dump_aeb(aeb, 0);
1738 ubi_dump_av(av);
1739 goto out;
1740
1741bad_av:
1742 ubi_err("bad attaching information about volume %d", av->vol_id);
1743 ubi_dump_av(av);
1744 goto out;
1745
1746bad_vid_hdr:
1747 ubi_err("bad attaching information about volume %d", av->vol_id);
1748 ubi_dump_av(av);
1749 ubi_dump_vid_hdr(vidh);
1750
1751out:
1752 dump_stack();
1753 return -EINVAL;
1754}
1755