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