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#ifndef __UBOOT__
77#include <linux/crc32.h>
78#include <linux/err.h>
79#include <linux/slab.h>
80#else
81#include <ubi_uboot.h>
82#endif
83
84#include "ubi.h"
85
86static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
87static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
88static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
89 const struct ubi_ec_hdr *ec_hdr);
90static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
91static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
92 const struct ubi_vid_hdr *vid_hdr);
93static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
94 int offset, int len);
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
119 int len)
120{
121 int err, retries = 0;
122 size_t read;
123 loff_t addr;
124
125 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
126
127 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
128 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
129 ubi_assert(len > 0);
130
131 err = self_check_not_bad(ubi, pnum);
132 if (err)
133 return err;
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155 *((uint8_t *)buf) ^= 0xFF;
156
157 addr = (loff_t)pnum * ubi->peb_size + offset;
158retry:
159 err = mtd_read(ubi->mtd, addr, len, &read, buf);
160 if (err) {
161 const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
162
163 if (mtd_is_bitflip(err)) {
164
165
166
167
168
169
170
171
172 ubi_msg(ubi, "fixable bit-flip detected at PEB %d",
173 pnum);
174 ubi_assert(len == read);
175 return UBI_IO_BITFLIPS;
176 }
177
178 if (retries++ < UBI_IO_RETRIES) {
179 ubi_warn(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",
180 err, errstr, len, pnum, offset, read);
181 yield();
182 goto retry;
183 }
184
185 ubi_err(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",
186 err, errstr, len, pnum, offset, read);
187 dump_stack();
188
189
190
191
192
193
194 if (read != len && mtd_is_eccerr(err)) {
195 ubi_assert(0);
196 err = -EIO;
197 }
198 } else {
199 ubi_assert(len == read);
200
201 if (ubi_dbg_is_bitflip(ubi)) {
202 dbg_gen("bit-flip (emulated)");
203 err = UBI_IO_BITFLIPS;
204 }
205 }
206
207 return err;
208}
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
228 int len)
229{
230 int err;
231 size_t written;
232 loff_t addr;
233
234 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
235
236 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
237 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
238 ubi_assert(offset % ubi->hdrs_min_io_size == 0);
239 ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
240
241 if (ubi->ro_mode) {
242 ubi_err(ubi, "read-only mode");
243 return -EROFS;
244 }
245
246 err = self_check_not_bad(ubi, pnum);
247 if (err)
248 return err;
249
250
251 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
252 if (err)
253 return err;
254
255 if (offset >= ubi->leb_start) {
256
257
258
259
260 err = self_check_peb_ec_hdr(ubi, pnum);
261 if (err)
262 return err;
263 err = self_check_peb_vid_hdr(ubi, pnum);
264 if (err)
265 return err;
266 }
267
268 if (ubi_dbg_is_write_failure(ubi)) {
269 ubi_err(ubi, "cannot write %d bytes to PEB %d:%d (emulated)",
270 len, pnum, offset);
271 dump_stack();
272 return -EIO;
273 }
274
275 addr = (loff_t)pnum * ubi->peb_size + offset;
276 err = mtd_write(ubi->mtd, addr, len, &written, buf);
277 if (err) {
278 ubi_err(ubi, "error %d while writing %d bytes to PEB %d:%d, written %zd bytes",
279 err, len, pnum, offset, written);
280 dump_stack();
281 ubi_dump_flash(ubi, pnum, offset, len);
282 } else
283 ubi_assert(written == len);
284
285 if (!err) {
286 err = self_check_write(ubi, buf, pnum, offset, len);
287 if (err)
288 return err;
289
290
291
292
293
294 offset += len;
295 len = ubi->peb_size - offset;
296 if (len)
297 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
298 }
299
300 return err;
301}
302
303
304
305
306
307
308
309
310static void erase_callback(struct erase_info *ei)
311{
312 wake_up_interruptible((wait_queue_head_t *)ei->priv);
313}
314
315
316
317
318
319
320
321
322
323
324static int do_sync_erase(struct ubi_device *ubi, int pnum)
325{
326 int err, retries = 0;
327 struct erase_info ei;
328 wait_queue_head_t wq;
329
330 dbg_io("erase PEB %d", pnum);
331 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
332
333 if (ubi->ro_mode) {
334 ubi_err(ubi, "read-only mode");
335 return -EROFS;
336 }
337
338retry:
339 init_waitqueue_head(&wq);
340 memset(&ei, 0, sizeof(struct erase_info));
341
342 ei.mtd = ubi->mtd;
343 ei.addr = (loff_t)pnum * ubi->peb_size;
344 ei.len = ubi->peb_size;
345 ei.callback = erase_callback;
346 ei.priv = (unsigned long)&wq;
347
348 err = mtd_erase(ubi->mtd, &ei);
349 if (err) {
350 if (retries++ < UBI_IO_RETRIES) {
351 ubi_warn(ubi, "error %d while erasing PEB %d, retry",
352 err, pnum);
353 yield();
354 goto retry;
355 }
356 ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);
357 dump_stack();
358 return err;
359 }
360
361 err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
362 ei.state == MTD_ERASE_FAILED);
363 if (err) {
364 ubi_err(ubi, "interrupted PEB %d erasure", pnum);
365 return -EINTR;
366 }
367
368 if (ei.state == MTD_ERASE_FAILED) {
369 if (retries++ < UBI_IO_RETRIES) {
370 ubi_warn(ubi, "error while erasing PEB %d, retry",
371 pnum);
372 yield();
373 goto retry;
374 }
375 ubi_err(ubi, "cannot erase PEB %d", pnum);
376 dump_stack();
377 return -EIO;
378 }
379
380 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
381 if (err)
382 return err;
383
384 if (ubi_dbg_is_erase_failure(ubi)) {
385 ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);
386 return -EIO;
387 }
388
389 return 0;
390}
391
392
393static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
394
395
396
397
398
399
400
401
402
403
404static int torture_peb(struct ubi_device *ubi, int pnum)
405{
406 int err, i, patt_count;
407
408 ubi_msg(ubi, "run torture test for PEB %d", pnum);
409 patt_count = ARRAY_SIZE(patterns);
410 ubi_assert(patt_count > 0);
411
412 mutex_lock(&ubi->buf_mutex);
413 for (i = 0; i < patt_count; i++) {
414 err = do_sync_erase(ubi, pnum);
415 if (err)
416 goto out;
417
418
419 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
420 if (err)
421 goto out;
422
423 err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
424 if (err == 0) {
425 ubi_err(ubi, "erased PEB %d, but a non-0xFF byte found",
426 pnum);
427 err = -EIO;
428 goto out;
429 }
430
431
432 memset(ubi->peb_buf, patterns[i], ubi->peb_size);
433 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
434 if (err)
435 goto out;
436
437 memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);
438 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
439 if (err)
440 goto out;
441
442 err = ubi_check_pattern(ubi->peb_buf, patterns[i],
443 ubi->peb_size);
444 if (err == 0) {
445 ubi_err(ubi, "pattern %x checking failed for PEB %d",
446 patterns[i], pnum);
447 err = -EIO;
448 goto out;
449 }
450 }
451
452 err = patt_count;
453 ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);
454
455out:
456 mutex_unlock(&ubi->buf_mutex);
457 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
458
459
460
461
462
463 ubi_err(ubi, "read problems on freshly erased PEB %d, must be bad",
464 pnum);
465 err = -EIO;
466 }
467 return err;
468}
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
491{
492 int err;
493 size_t written;
494 loff_t addr;
495 uint32_t data = 0;
496 struct ubi_ec_hdr ec_hdr;
497
498
499
500
501
502
503
504
505 struct ubi_vid_hdr vid_hdr;
506
507
508
509
510
511
512
513
514 addr = (loff_t)pnum * ubi->peb_size;
515 err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
516 if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
517 err != UBI_IO_FF){
518 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
519 if(err)
520 goto error;
521 }
522
523 err = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
524 if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
525 err != UBI_IO_FF){
526 addr += ubi->vid_hdr_aloffset;
527 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
528 if (err)
529 goto error;
530 }
531 return 0;
532
533error:
534
535
536
537
538
539 ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
540 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
541 return -EIO;
542}
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
561{
562 int err, ret = 0;
563
564 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
565
566 err = self_check_not_bad(ubi, pnum);
567 if (err != 0)
568 return err;
569
570 if (ubi->ro_mode) {
571 ubi_err(ubi, "read-only mode");
572 return -EROFS;
573 }
574
575 if (ubi->nor_flash) {
576 err = nor_erase_prepare(ubi, pnum);
577 if (err)
578 return err;
579 }
580
581 if (torture) {
582 ret = torture_peb(ubi, pnum);
583 if (ret < 0)
584 return ret;
585 }
586
587 err = do_sync_erase(ubi, pnum);
588 if (err)
589 return err;
590
591 return ret + 1;
592}
593
594
595
596
597
598
599
600
601
602int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
603{
604 struct mtd_info *mtd = ubi->mtd;
605
606 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
607
608 if (ubi->bad_allowed) {
609 int ret;
610
611 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
612 if (ret < 0)
613 ubi_err(ubi, "error %d while checking if PEB %d is bad",
614 ret, pnum);
615 else if (ret)
616 dbg_io("PEB %d is bad", pnum);
617 return ret;
618 }
619
620 return 0;
621}
622
623
624
625
626
627
628
629
630
631int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
632{
633 int err;
634 struct mtd_info *mtd = ubi->mtd;
635
636 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
637
638 if (ubi->ro_mode) {
639 ubi_err(ubi, "read-only mode");
640 return -EROFS;
641 }
642
643 if (!ubi->bad_allowed)
644 return 0;
645
646 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
647 if (err)
648 ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
649 return err;
650}
651
652
653
654
655
656
657
658
659
660static int validate_ec_hdr(const struct ubi_device *ubi,
661 const struct ubi_ec_hdr *ec_hdr)
662{
663 long long ec;
664 int vid_hdr_offset, leb_start;
665
666 ec = be64_to_cpu(ec_hdr->ec);
667 vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
668 leb_start = be32_to_cpu(ec_hdr->data_offset);
669
670 if (ec_hdr->version != UBI_VERSION) {
671 ubi_err(ubi, "node with incompatible UBI version found: this UBI version is %d, image version is %d",
672 UBI_VERSION, (int)ec_hdr->version);
673 goto bad;
674 }
675
676 if (vid_hdr_offset != ubi->vid_hdr_offset) {
677 ubi_err(ubi, "bad VID header offset %d, expected %d",
678 vid_hdr_offset, ubi->vid_hdr_offset);
679 goto bad;
680 }
681
682 if (leb_start != ubi->leb_start) {
683 ubi_err(ubi, "bad data offset %d, expected %d",
684 leb_start, ubi->leb_start);
685 goto bad;
686 }
687
688 if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
689 ubi_err(ubi, "bad erase counter %lld", ec);
690 goto bad;
691 }
692
693 return 0;
694
695bad:
696 ubi_err(ubi, "bad EC header");
697 ubi_dump_ec_hdr(ec_hdr);
698 dump_stack();
699 return 1;
700}
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
725 struct ubi_ec_hdr *ec_hdr, int verbose)
726{
727 int err, read_err;
728 uint32_t crc, magic, hdr_crc;
729
730 dbg_io("read EC header from PEB %d", pnum);
731 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
732
733 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
734 if (read_err) {
735 if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
736 return read_err;
737
738
739
740
741
742
743
744
745
746
747 }
748
749 magic = be32_to_cpu(ec_hdr->magic);
750 if (magic != UBI_EC_HDR_MAGIC) {
751 if (mtd_is_eccerr(read_err))
752 return UBI_IO_BAD_HDR_EBADMSG;
753
754
755
756
757
758
759 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
760
761 if (verbose)
762 ubi_warn(ubi, "no EC header found at PEB %d, only 0xFF bytes",
763 pnum);
764 dbg_bld("no EC header found at PEB %d, only 0xFF bytes",
765 pnum);
766 if (!read_err)
767 return UBI_IO_FF;
768 else
769 return UBI_IO_FF_BITFLIPS;
770 }
771
772
773
774
775
776 if (verbose) {
777 ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
778 pnum, magic, UBI_EC_HDR_MAGIC);
779 ubi_dump_ec_hdr(ec_hdr);
780 }
781 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
782 pnum, magic, UBI_EC_HDR_MAGIC);
783 return UBI_IO_BAD_HDR;
784 }
785
786 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
787 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
788
789 if (hdr_crc != crc) {
790 if (verbose) {
791 ubi_warn(ubi, "bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
792 pnum, crc, hdr_crc);
793 ubi_dump_ec_hdr(ec_hdr);
794 }
795 dbg_bld("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
796 pnum, crc, hdr_crc);
797
798 if (!read_err)
799 return UBI_IO_BAD_HDR;
800 else
801 return UBI_IO_BAD_HDR_EBADMSG;
802 }
803
804
805 err = validate_ec_hdr(ubi, ec_hdr);
806 if (err) {
807 ubi_err(ubi, "validation failed for PEB %d", pnum);
808 return -EINVAL;
809 }
810
811
812
813
814
815 return read_err ? UBI_IO_BITFLIPS : 0;
816}
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
834 struct ubi_ec_hdr *ec_hdr)
835{
836 int err;
837 uint32_t crc;
838
839 dbg_io("write EC header to PEB %d", pnum);
840 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
841
842 ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
843 ec_hdr->version = UBI_VERSION;
844 ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
845 ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
846 ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
847 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
848 ec_hdr->hdr_crc = cpu_to_be32(crc);
849
850 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
851 if (err)
852 return err;
853
854 if (ubi_dbg_power_cut(ubi, POWER_CUT_EC_WRITE))
855 return -EROFS;
856
857 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
858 return err;
859}
860
861
862
863
864
865
866
867
868
869static int validate_vid_hdr(const struct ubi_device *ubi,
870 const struct ubi_vid_hdr *vid_hdr)
871{
872 int vol_type = vid_hdr->vol_type;
873 int copy_flag = vid_hdr->copy_flag;
874 int vol_id = be32_to_cpu(vid_hdr->vol_id);
875 int lnum = be32_to_cpu(vid_hdr->lnum);
876 int compat = vid_hdr->compat;
877 int data_size = be32_to_cpu(vid_hdr->data_size);
878 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
879 int data_pad = be32_to_cpu(vid_hdr->data_pad);
880 int data_crc = be32_to_cpu(vid_hdr->data_crc);
881 int usable_leb_size = ubi->leb_size - data_pad;
882
883 if (copy_flag != 0 && copy_flag != 1) {
884 ubi_err(ubi, "bad copy_flag");
885 goto bad;
886 }
887
888 if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
889 data_pad < 0) {
890 ubi_err(ubi, "negative values");
891 goto bad;
892 }
893
894 if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
895 ubi_err(ubi, "bad vol_id");
896 goto bad;
897 }
898
899 if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
900 ubi_err(ubi, "bad compat");
901 goto bad;
902 }
903
904 if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
905 compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
906 compat != UBI_COMPAT_REJECT) {
907 ubi_err(ubi, "bad compat");
908 goto bad;
909 }
910
911 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
912 ubi_err(ubi, "bad vol_type");
913 goto bad;
914 }
915
916 if (data_pad >= ubi->leb_size / 2) {
917 ubi_err(ubi, "bad data_pad");
918 goto bad;
919 }
920
921 if (vol_type == UBI_VID_STATIC) {
922
923
924
925
926
927
928 if (used_ebs == 0) {
929 ubi_err(ubi, "zero used_ebs");
930 goto bad;
931 }
932 if (data_size == 0) {
933 ubi_err(ubi, "zero data_size");
934 goto bad;
935 }
936 if (lnum < used_ebs - 1) {
937 if (data_size != usable_leb_size) {
938 ubi_err(ubi, "bad data_size");
939 goto bad;
940 }
941 } else if (lnum == used_ebs - 1) {
942 if (data_size == 0) {
943 ubi_err(ubi, "bad data_size at last LEB");
944 goto bad;
945 }
946 } else {
947 ubi_err(ubi, "too high lnum");
948 goto bad;
949 }
950 } else {
951 if (copy_flag == 0) {
952 if (data_crc != 0) {
953 ubi_err(ubi, "non-zero data CRC");
954 goto bad;
955 }
956 if (data_size != 0) {
957 ubi_err(ubi, "non-zero data_size");
958 goto bad;
959 }
960 } else {
961 if (data_size == 0) {
962 ubi_err(ubi, "zero data_size of copy");
963 goto bad;
964 }
965 }
966 if (used_ebs != 0) {
967 ubi_err(ubi, "bad used_ebs");
968 goto bad;
969 }
970 }
971
972 return 0;
973
974bad:
975 ubi_err(ubi, "bad VID header");
976 ubi_dump_vid_hdr(vid_hdr);
977 dump_stack();
978 return 1;
979}
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
998 struct ubi_vid_hdr *vid_hdr, int verbose)
999{
1000 int err, read_err;
1001 uint32_t crc, magic, hdr_crc;
1002 void *p;
1003
1004 dbg_io("read VID header from PEB %d", pnum);
1005 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1006
1007 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1008 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1009 ubi->vid_hdr_alsize);
1010 if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
1011 return read_err;
1012
1013 magic = be32_to_cpu(vid_hdr->magic);
1014 if (magic != UBI_VID_HDR_MAGIC) {
1015 if (mtd_is_eccerr(read_err))
1016 return UBI_IO_BAD_HDR_EBADMSG;
1017
1018 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
1019 if (verbose)
1020 ubi_warn(ubi, "no VID header found at PEB %d, only 0xFF bytes",
1021 pnum);
1022 dbg_bld("no VID header found at PEB %d, only 0xFF bytes",
1023 pnum);
1024 if (!read_err)
1025 return UBI_IO_FF;
1026 else
1027 return UBI_IO_FF_BITFLIPS;
1028 }
1029
1030 if (verbose) {
1031 ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
1032 pnum, magic, UBI_VID_HDR_MAGIC);
1033 ubi_dump_vid_hdr(vid_hdr);
1034 }
1035 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
1036 pnum, magic, UBI_VID_HDR_MAGIC);
1037 return UBI_IO_BAD_HDR;
1038 }
1039
1040 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1041 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1042
1043 if (hdr_crc != crc) {
1044 if (verbose) {
1045 ubi_warn(ubi, "bad CRC at PEB %d, calculated %#08x, read %#08x",
1046 pnum, crc, hdr_crc);
1047 ubi_dump_vid_hdr(vid_hdr);
1048 }
1049 dbg_bld("bad CRC at PEB %d, calculated %#08x, read %#08x",
1050 pnum, crc, hdr_crc);
1051 if (!read_err)
1052 return UBI_IO_BAD_HDR;
1053 else
1054 return UBI_IO_BAD_HDR_EBADMSG;
1055 }
1056
1057 err = validate_vid_hdr(ubi, vid_hdr);
1058 if (err) {
1059 ubi_err(ubi, "validation failed for PEB %d", pnum);
1060 return -EINVAL;
1061 }
1062
1063 return read_err ? UBI_IO_BITFLIPS : 0;
1064}
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1082 struct ubi_vid_hdr *vid_hdr)
1083{
1084 int err;
1085 uint32_t crc;
1086 void *p;
1087
1088 dbg_io("write VID header to PEB %d", pnum);
1089 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1090
1091 err = self_check_peb_ec_hdr(ubi, pnum);
1092 if (err)
1093 return err;
1094
1095 vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1096 vid_hdr->version = UBI_VERSION;
1097 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1098 vid_hdr->hdr_crc = cpu_to_be32(crc);
1099
1100 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1101 if (err)
1102 return err;
1103
1104 if (ubi_dbg_power_cut(ubi, POWER_CUT_VID_WRITE))
1105 return -EROFS;
1106
1107 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1108 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1109 ubi->vid_hdr_alsize);
1110 return err;
1111}
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
1122{
1123 int err;
1124
1125 if (!ubi_dbg_chk_io(ubi))
1126 return 0;
1127
1128 err = ubi_io_is_bad(ubi, pnum);
1129 if (!err)
1130 return err;
1131
1132 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1133 dump_stack();
1134 return err > 0 ? -EINVAL : err;
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1147 const struct ubi_ec_hdr *ec_hdr)
1148{
1149 int err;
1150 uint32_t magic;
1151
1152 if (!ubi_dbg_chk_io(ubi))
1153 return 0;
1154
1155 magic = be32_to_cpu(ec_hdr->magic);
1156 if (magic != UBI_EC_HDR_MAGIC) {
1157 ubi_err(ubi, "bad magic %#08x, must be %#08x",
1158 magic, UBI_EC_HDR_MAGIC);
1159 goto fail;
1160 }
1161
1162 err = validate_ec_hdr(ubi, ec_hdr);
1163 if (err) {
1164 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1165 goto fail;
1166 }
1167
1168 return 0;
1169
1170fail:
1171 ubi_dump_ec_hdr(ec_hdr);
1172 dump_stack();
1173 return -EINVAL;
1174}
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
1185{
1186 int err;
1187 uint32_t crc, hdr_crc;
1188 struct ubi_ec_hdr *ec_hdr;
1189
1190 if (!ubi_dbg_chk_io(ubi))
1191 return 0;
1192
1193 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1194 if (!ec_hdr)
1195 return -ENOMEM;
1196
1197 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
1198 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1199 goto exit;
1200
1201 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1202 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1203 if (hdr_crc != crc) {
1204 ubi_err(ubi, "bad CRC, calculated %#08x, read %#08x",
1205 crc, hdr_crc);
1206 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1207 ubi_dump_ec_hdr(ec_hdr);
1208 dump_stack();
1209 err = -EINVAL;
1210 goto exit;
1211 }
1212
1213 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
1214
1215exit:
1216 kfree(ec_hdr);
1217 return err;
1218}
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1230 const struct ubi_vid_hdr *vid_hdr)
1231{
1232 int err;
1233 uint32_t magic;
1234
1235 if (!ubi_dbg_chk_io(ubi))
1236 return 0;
1237
1238 magic = be32_to_cpu(vid_hdr->magic);
1239 if (magic != UBI_VID_HDR_MAGIC) {
1240 ubi_err(ubi, "bad VID header magic %#08x at PEB %d, must be %#08x",
1241 magic, pnum, UBI_VID_HDR_MAGIC);
1242 goto fail;
1243 }
1244
1245 err = validate_vid_hdr(ubi, vid_hdr);
1246 if (err) {
1247 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1248 goto fail;
1249 }
1250
1251 return err;
1252
1253fail:
1254 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1255 ubi_dump_vid_hdr(vid_hdr);
1256 dump_stack();
1257 return -EINVAL;
1258
1259}
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
1270{
1271 int err;
1272 uint32_t crc, hdr_crc;
1273 struct ubi_vid_hdr *vid_hdr;
1274 void *p;
1275
1276 if (!ubi_dbg_chk_io(ubi))
1277 return 0;
1278
1279 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1280 if (!vid_hdr)
1281 return -ENOMEM;
1282
1283 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1284 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1285 ubi->vid_hdr_alsize);
1286 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
1287 goto exit;
1288
1289 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1290 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1291 if (hdr_crc != crc) {
1292 ubi_err(ubi, "bad VID header CRC at PEB %d, calculated %#08x, read %#08x",
1293 pnum, crc, hdr_crc);
1294 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1295 ubi_dump_vid_hdr(vid_hdr);
1296 dump_stack();
1297 err = -EINVAL;
1298 goto exit;
1299 }
1300
1301 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
1302
1303exit:
1304 ubi_free_vid_hdr(ubi, vid_hdr);
1305 return err;
1306}
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1321 int offset, int len)
1322{
1323 int err, i;
1324 size_t read;
1325 void *buf1;
1326 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1327
1328 if (!ubi_dbg_chk_io(ubi))
1329 return 0;
1330
1331 buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1332 if (!buf1) {
1333 ubi_err(ubi, "cannot allocate memory to check writes");
1334 return 0;
1335 }
1336
1337 err = mtd_read(ubi->mtd, addr, len, &read, buf1);
1338 if (err && !mtd_is_bitflip(err))
1339 goto out_free;
1340
1341 for (i = 0; i < len; i++) {
1342 uint8_t c = ((uint8_t *)buf)[i];
1343 uint8_t c1 = ((uint8_t *)buf1)[i];
1344#if !defined(CONFIG_UBI_SILENCE_MSG)
1345 int dump_len = max_t(int, 128, len - i);
1346#endif
1347
1348 if (c == c1)
1349 continue;
1350
1351 ubi_err(ubi, "self-check failed for PEB %d:%d, len %d",
1352 pnum, offset, len);
1353 ubi_msg(ubi, "data differ at position %d", i);
1354 ubi_msg(ubi, "hex dump of the original buffer from %d to %d",
1355 i, i + dump_len);
1356 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1357 buf + i, dump_len, 1);
1358 ubi_msg(ubi, "hex dump of the read buffer from %d to %d",
1359 i, i + dump_len);
1360 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1361 buf1 + i, dump_len, 1);
1362 dump_stack();
1363 err = -EINVAL;
1364 goto out_free;
1365 }
1366
1367 vfree(buf1);
1368 return 0;
1369
1370out_free:
1371 vfree(buf1);
1372 return err;
1373}
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
1387{
1388 size_t read;
1389 int err;
1390 void *buf;
1391 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1392
1393 if (!ubi_dbg_chk_io(ubi))
1394 return 0;
1395
1396 buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1397 if (!buf) {
1398 ubi_err(ubi, "cannot allocate memory to check for 0xFFs");
1399 return 0;
1400 }
1401
1402 err = mtd_read(ubi->mtd, addr, len, &read, buf);
1403 if (err && !mtd_is_bitflip(err)) {
1404 ubi_err(ubi, "err %d while reading %d bytes from PEB %d:%d, read %zd bytes",
1405 err, len, pnum, offset, read);
1406 goto error;
1407 }
1408
1409 err = ubi_check_pattern(buf, 0xFF, len);
1410 if (err == 0) {
1411 ubi_err(ubi, "flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",
1412 pnum, offset, len);
1413 goto fail;
1414 }
1415
1416 vfree(buf);
1417 return 0;
1418
1419fail:
1420 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1421 ubi_msg(ubi, "hex dump of the %d-%d region", offset, offset + len);
1422 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
1423 err = -EINVAL;
1424error:
1425 dump_stack();
1426 vfree(buf);
1427 return err;
1428}
1429