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#include <linux/slab.h>
45#include <linux/crc32.h>
46#include <linux/err.h>
47#include "ubi.h"
48
49
50#define EBA_RESERVED_PEBS 1
51
52
53
54
55
56
57
58
59
60static unsigned long long next_sqnum(struct ubi_device *ubi)
61{
62 unsigned long long sqnum;
63
64 spin_lock(&ubi->ltree_lock);
65 sqnum = ubi->global_sqnum++;
66 spin_unlock(&ubi->ltree_lock);
67
68 return sqnum;
69}
70
71
72
73
74
75
76
77
78
79static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
80{
81 if (vol_id == UBI_LAYOUT_VOLUME_ID)
82 return UBI_LAYOUT_VOLUME_COMPAT;
83 return 0;
84}
85
86
87
88
89
90
91
92
93
94
95
96static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
97 int lnum)
98{
99 struct rb_node *p;
100
101 p = ubi->ltree.rb_node;
102 while (p) {
103 struct ubi_ltree_entry *le;
104
105 le = rb_entry(p, struct ubi_ltree_entry, rb);
106
107 if (vol_id < le->vol_id)
108 p = p->rb_left;
109 else if (vol_id > le->vol_id)
110 p = p->rb_right;
111 else {
112 if (lnum < le->lnum)
113 p = p->rb_left;
114 else if (lnum > le->lnum)
115 p = p->rb_right;
116 else
117 return le;
118 }
119 }
120
121 return NULL;
122}
123
124
125
126
127
128
129
130
131
132
133
134
135static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
136 int vol_id, int lnum)
137{
138 struct ubi_ltree_entry *le, *le1, *le_free;
139
140 le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);
141 if (!le)
142 return ERR_PTR(-ENOMEM);
143
144 le->users = 0;
145 init_rwsem(&le->mutex);
146 le->vol_id = vol_id;
147 le->lnum = lnum;
148
149 spin_lock(&ubi->ltree_lock);
150 le1 = ltree_lookup(ubi, vol_id, lnum);
151
152 if (le1) {
153
154
155
156
157 le_free = le;
158 le = le1;
159 } else {
160 struct rb_node **p, *parent = NULL;
161
162
163
164
165
166 le_free = NULL;
167
168 p = &ubi->ltree.rb_node;
169 while (*p) {
170 parent = *p;
171 le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
172
173 if (vol_id < le1->vol_id)
174 p = &(*p)->rb_left;
175 else if (vol_id > le1->vol_id)
176 p = &(*p)->rb_right;
177 else {
178 ubi_assert(lnum != le1->lnum);
179 if (lnum < le1->lnum)
180 p = &(*p)->rb_left;
181 else
182 p = &(*p)->rb_right;
183 }
184 }
185
186 rb_link_node(&le->rb, parent, p);
187 rb_insert_color(&le->rb, &ubi->ltree);
188 }
189 le->users += 1;
190 spin_unlock(&ubi->ltree_lock);
191
192 kfree(le_free);
193 return le;
194}
195
196
197
198
199
200
201
202
203
204
205static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
206{
207 struct ubi_ltree_entry *le;
208
209 le = ltree_add_entry(ubi, vol_id, lnum);
210 if (IS_ERR(le))
211 return PTR_ERR(le);
212 down_read(&le->mutex);
213 return 0;
214}
215
216
217
218
219
220
221
222static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
223{
224 struct ubi_ltree_entry *le;
225
226 spin_lock(&ubi->ltree_lock);
227 le = ltree_lookup(ubi, vol_id, lnum);
228 le->users -= 1;
229 ubi_assert(le->users >= 0);
230 up_read(&le->mutex);
231 if (le->users == 0) {
232 rb_erase(&le->rb, &ubi->ltree);
233 kfree(le);
234 }
235 spin_unlock(&ubi->ltree_lock);
236}
237
238
239
240
241
242
243
244
245
246
247static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
248{
249 struct ubi_ltree_entry *le;
250
251 le = ltree_add_entry(ubi, vol_id, lnum);
252 if (IS_ERR(le))
253 return PTR_ERR(le);
254 down_write(&le->mutex);
255 return 0;
256}
257
258
259
260
261
262
263
264
265
266
267
268
269static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
270{
271 struct ubi_ltree_entry *le;
272
273 le = ltree_add_entry(ubi, vol_id, lnum);
274 if (IS_ERR(le))
275 return PTR_ERR(le);
276 if (down_write_trylock(&le->mutex))
277 return 0;
278
279
280 spin_lock(&ubi->ltree_lock);
281 le->users -= 1;
282 ubi_assert(le->users >= 0);
283 if (le->users == 0) {
284 rb_erase(&le->rb, &ubi->ltree);
285 kfree(le);
286 }
287 spin_unlock(&ubi->ltree_lock);
288
289 return 1;
290}
291
292
293
294
295
296
297
298static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
299{
300 struct ubi_ltree_entry *le;
301
302 spin_lock(&ubi->ltree_lock);
303 le = ltree_lookup(ubi, vol_id, lnum);
304 le->users -= 1;
305 ubi_assert(le->users >= 0);
306 up_write(&le->mutex);
307 if (le->users == 0) {
308 rb_erase(&le->rb, &ubi->ltree);
309 kfree(le);
310 }
311 spin_unlock(&ubi->ltree_lock);
312}
313
314
315
316
317
318
319
320
321
322
323
324int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
325 int lnum)
326{
327 int err, pnum, vol_id = vol->vol_id;
328
329 if (ubi->ro_mode)
330 return -EROFS;
331
332 err = leb_write_lock(ubi, vol_id, lnum);
333 if (err)
334 return err;
335
336 pnum = vol->eba_tbl[lnum];
337 if (pnum < 0)
338
339 goto out_unlock;
340
341 dbg_eba("erase LEB %d:%d, PEB %d", vol_id, lnum, pnum);
342
343 vol->eba_tbl[lnum] = UBI_LEB_UNMAPPED;
344 err = ubi_wl_put_peb(ubi, pnum, 0);
345
346out_unlock:
347 leb_write_unlock(ubi, vol_id, lnum);
348 return err;
349}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
371 void *buf, int offset, int len, int check)
372{
373 int err, pnum, scrub = 0, vol_id = vol->vol_id;
374 struct ubi_vid_hdr *vid_hdr;
375 uint32_t uninitialized_var(crc);
376
377 err = leb_read_lock(ubi, vol_id, lnum);
378 if (err)
379 return err;
380
381 pnum = vol->eba_tbl[lnum];
382 if (pnum < 0) {
383
384
385
386
387
388 dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",
389 len, offset, vol_id, lnum);
390 leb_read_unlock(ubi, vol_id, lnum);
391 ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);
392 memset(buf, 0xFF, len);
393 return 0;
394 }
395
396 dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",
397 len, offset, vol_id, lnum, pnum);
398
399 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
400 check = 0;
401
402retry:
403 if (check) {
404 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
405 if (!vid_hdr) {
406 err = -ENOMEM;
407 goto out_unlock;
408 }
409
410 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
411 if (err && err != UBI_IO_BITFLIPS) {
412 if (err > 0) {
413
414
415
416
417
418
419
420
421 if (err == UBI_IO_BAD_VID_HDR) {
422 ubi_warn("corrupted VID header at PEB "
423 "%d, LEB %d:%d", pnum, vol_id,
424 lnum);
425 err = -EBADMSG;
426 } else
427 ubi_ro_mode(ubi);
428 }
429 goto out_free;
430 } else if (err == UBI_IO_BITFLIPS)
431 scrub = 1;
432
433 ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs));
434 ubi_assert(len == be32_to_cpu(vid_hdr->data_size));
435
436 crc = be32_to_cpu(vid_hdr->data_crc);
437 ubi_free_vid_hdr(ubi, vid_hdr);
438 }
439
440 err = ubi_io_read_data(ubi, buf, pnum, offset, len);
441 if (err) {
442 if (err == UBI_IO_BITFLIPS) {
443 scrub = 1;
444 err = 0;
445 } else if (err == -EBADMSG) {
446 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
447 goto out_unlock;
448 scrub = 1;
449 if (!check) {
450 ubi_msg("force data checking");
451 check = 1;
452 goto retry;
453 }
454 } else
455 goto out_unlock;
456 }
457
458 if (check) {
459 uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);
460 if (crc1 != crc) {
461 ubi_warn("CRC error: calculated %#08x, must be %#08x",
462 crc1, crc);
463 err = -EBADMSG;
464 goto out_unlock;
465 }
466 }
467
468 if (scrub)
469 err = ubi_wl_scrub_peb(ubi, pnum);
470
471 leb_read_unlock(ubi, vol_id, lnum);
472 return err;
473
474out_free:
475 ubi_free_vid_hdr(ubi, vid_hdr);
476out_unlock:
477 leb_read_unlock(ubi, vol_id, lnum);
478 return err;
479}
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
498 const void *buf, int offset, int len)
499{
500 int err, idx = vol_id2idx(ubi, vol_id), new_pnum, data_size, tries = 0;
501 struct ubi_volume *vol = ubi->volumes[idx];
502 struct ubi_vid_hdr *vid_hdr;
503
504 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
505 if (!vid_hdr)
506 return -ENOMEM;
507
508retry:
509 new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
510 if (new_pnum < 0) {
511 ubi_free_vid_hdr(ubi, vid_hdr);
512 return new_pnum;
513 }
514
515 ubi_msg("recover PEB %d, move data to PEB %d", pnum, new_pnum);
516
517 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
518 if (err && err != UBI_IO_BITFLIPS) {
519 if (err > 0)
520 err = -EIO;
521 goto out_put;
522 }
523
524 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
525 err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
526 if (err)
527 goto write_error;
528
529 data_size = offset + len;
530 mutex_lock(&ubi->buf_mutex);
531 memset(ubi->peb_buf1 + offset, 0xFF, len);
532
533
534 if (offset > 0) {
535 err = ubi_io_read_data(ubi, ubi->peb_buf1, pnum, 0, offset);
536 if (err && err != UBI_IO_BITFLIPS)
537 goto out_unlock;
538 }
539
540 memcpy(ubi->peb_buf1 + offset, buf, len);
541
542 err = ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size);
543 if (err) {
544 mutex_unlock(&ubi->buf_mutex);
545 goto write_error;
546 }
547
548 mutex_unlock(&ubi->buf_mutex);
549 ubi_free_vid_hdr(ubi, vid_hdr);
550
551 vol->eba_tbl[lnum] = new_pnum;
552 ubi_wl_put_peb(ubi, pnum, 1);
553
554 ubi_msg("data was successfully recovered");
555 return 0;
556
557out_unlock:
558 mutex_unlock(&ubi->buf_mutex);
559out_put:
560 ubi_wl_put_peb(ubi, new_pnum, 1);
561 ubi_free_vid_hdr(ubi, vid_hdr);
562 return err;
563
564write_error:
565
566
567
568
569 ubi_warn("failed to write to PEB %d", new_pnum);
570 ubi_wl_put_peb(ubi, new_pnum, 1);
571 if (++tries > UBI_IO_RETRIES) {
572 ubi_free_vid_hdr(ubi, vid_hdr);
573 return err;
574 }
575 ubi_msg("try again");
576 goto retry;
577}
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
595 const void *buf, int offset, int len, int dtype)
596{
597 int err, pnum, tries = 0, vol_id = vol->vol_id;
598 struct ubi_vid_hdr *vid_hdr;
599
600 if (ubi->ro_mode)
601 return -EROFS;
602
603 err = leb_write_lock(ubi, vol_id, lnum);
604 if (err)
605 return err;
606
607 pnum = vol->eba_tbl[lnum];
608 if (pnum >= 0) {
609 dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d",
610 len, offset, vol_id, lnum, pnum);
611
612 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
613 if (err) {
614 ubi_warn("failed to write data to PEB %d", pnum);
615 if (err == -EIO && ubi->bad_allowed)
616 err = recover_peb(ubi, pnum, vol_id, lnum, buf,
617 offset, len);
618 if (err)
619 ubi_ro_mode(ubi);
620 }
621 leb_write_unlock(ubi, vol_id, lnum);
622 return err;
623 }
624
625
626
627
628
629 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
630 if (!vid_hdr) {
631 leb_write_unlock(ubi, vol_id, lnum);
632 return -ENOMEM;
633 }
634
635 vid_hdr->vol_type = UBI_VID_DYNAMIC;
636 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
637 vid_hdr->vol_id = cpu_to_be32(vol_id);
638 vid_hdr->lnum = cpu_to_be32(lnum);
639 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
640 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
641
642retry:
643 pnum = ubi_wl_get_peb(ubi, dtype);
644 if (pnum < 0) {
645 ubi_free_vid_hdr(ubi, vid_hdr);
646 leb_write_unlock(ubi, vol_id, lnum);
647 return pnum;
648 }
649
650 dbg_eba("write VID hdr and %d bytes at offset %d of LEB %d:%d, PEB %d",
651 len, offset, vol_id, lnum, pnum);
652
653 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
654 if (err) {
655 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
656 vol_id, lnum, pnum);
657 goto write_error;
658 }
659
660 if (len) {
661 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
662 if (err) {
663 ubi_warn("failed to write %d bytes at offset %d of "
664 "LEB %d:%d, PEB %d", len, offset, vol_id,
665 lnum, pnum);
666 goto write_error;
667 }
668 }
669
670 vol->eba_tbl[lnum] = pnum;
671
672 leb_write_unlock(ubi, vol_id, lnum);
673 ubi_free_vid_hdr(ubi, vid_hdr);
674 return 0;
675
676write_error:
677 if (err != -EIO || !ubi->bad_allowed) {
678 ubi_ro_mode(ubi);
679 leb_write_unlock(ubi, vol_id, lnum);
680 ubi_free_vid_hdr(ubi, vid_hdr);
681 return err;
682 }
683
684
685
686
687
688
689 err = ubi_wl_put_peb(ubi, pnum, 1);
690 if (err || ++tries > UBI_IO_RETRIES) {
691 ubi_ro_mode(ubi);
692 leb_write_unlock(ubi, vol_id, lnum);
693 ubi_free_vid_hdr(ubi, vid_hdr);
694 return err;
695 }
696
697 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
698 ubi_msg("try another PEB");
699 goto retry;
700}
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
726 int lnum, const void *buf, int len, int dtype,
727 int used_ebs)
728{
729 int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
730 struct ubi_vid_hdr *vid_hdr;
731 uint32_t crc;
732
733 if (ubi->ro_mode)
734 return -EROFS;
735
736 if (lnum == used_ebs - 1)
737
738 len = ALIGN(data_size, ubi->min_io_size);
739 else
740 ubi_assert(!(len & (ubi->min_io_size - 1)));
741
742 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
743 if (!vid_hdr)
744 return -ENOMEM;
745
746 err = leb_write_lock(ubi, vol_id, lnum);
747 if (err) {
748 ubi_free_vid_hdr(ubi, vid_hdr);
749 return err;
750 }
751
752 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
753 vid_hdr->vol_id = cpu_to_be32(vol_id);
754 vid_hdr->lnum = cpu_to_be32(lnum);
755 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
756 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
757
758 crc = crc32(UBI_CRC32_INIT, buf, data_size);
759 vid_hdr->vol_type = UBI_VID_STATIC;
760 vid_hdr->data_size = cpu_to_be32(data_size);
761 vid_hdr->used_ebs = cpu_to_be32(used_ebs);
762 vid_hdr->data_crc = cpu_to_be32(crc);
763
764retry:
765 pnum = ubi_wl_get_peb(ubi, dtype);
766 if (pnum < 0) {
767 ubi_free_vid_hdr(ubi, vid_hdr);
768 leb_write_unlock(ubi, vol_id, lnum);
769 return pnum;
770 }
771
772 dbg_eba("write VID hdr and %d bytes at LEB %d:%d, PEB %d, used_ebs %d",
773 len, vol_id, lnum, pnum, used_ebs);
774
775 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
776 if (err) {
777 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
778 vol_id, lnum, pnum);
779 goto write_error;
780 }
781
782 err = ubi_io_write_data(ubi, buf, pnum, 0, len);
783 if (err) {
784 ubi_warn("failed to write %d bytes of data to PEB %d",
785 len, pnum);
786 goto write_error;
787 }
788
789 ubi_assert(vol->eba_tbl[lnum] < 0);
790 vol->eba_tbl[lnum] = pnum;
791
792 leb_write_unlock(ubi, vol_id, lnum);
793 ubi_free_vid_hdr(ubi, vid_hdr);
794 return 0;
795
796write_error:
797 if (err != -EIO || !ubi->bad_allowed) {
798
799
800
801
802
803 ubi_ro_mode(ubi);
804 leb_write_unlock(ubi, vol_id, lnum);
805 ubi_free_vid_hdr(ubi, vid_hdr);
806 return err;
807 }
808
809 err = ubi_wl_put_peb(ubi, pnum, 1);
810 if (err || ++tries > UBI_IO_RETRIES) {
811 ubi_ro_mode(ubi);
812 leb_write_unlock(ubi, vol_id, lnum);
813 ubi_free_vid_hdr(ubi, vid_hdr);
814 return err;
815 }
816
817 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
818 ubi_msg("try another PEB");
819 goto retry;
820}
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
841 int lnum, const void *buf, int len, int dtype)
842{
843 int err, pnum, tries = 0, vol_id = vol->vol_id;
844 struct ubi_vid_hdr *vid_hdr;
845 uint32_t crc;
846
847 if (ubi->ro_mode)
848 return -EROFS;
849
850 if (len == 0) {
851
852
853
854
855 err = ubi_eba_unmap_leb(ubi, vol, lnum);
856 if (err)
857 return err;
858 return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
859 }
860
861 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
862 if (!vid_hdr)
863 return -ENOMEM;
864
865 mutex_lock(&ubi->alc_mutex);
866 err = leb_write_lock(ubi, vol_id, lnum);
867 if (err)
868 goto out_mutex;
869
870 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
871 vid_hdr->vol_id = cpu_to_be32(vol_id);
872 vid_hdr->lnum = cpu_to_be32(lnum);
873 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
874 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
875
876 crc = crc32(UBI_CRC32_INIT, buf, len);
877 vid_hdr->vol_type = UBI_VID_DYNAMIC;
878 vid_hdr->data_size = cpu_to_be32(len);
879 vid_hdr->copy_flag = 1;
880 vid_hdr->data_crc = cpu_to_be32(crc);
881
882retry:
883 pnum = ubi_wl_get_peb(ubi, dtype);
884 if (pnum < 0) {
885 err = pnum;
886 goto out_leb_unlock;
887 }
888
889 dbg_eba("change LEB %d:%d, PEB %d, write VID hdr to PEB %d",
890 vol_id, lnum, vol->eba_tbl[lnum], pnum);
891
892 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
893 if (err) {
894 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
895 vol_id, lnum, pnum);
896 goto write_error;
897 }
898
899 err = ubi_io_write_data(ubi, buf, pnum, 0, len);
900 if (err) {
901 ubi_warn("failed to write %d bytes of data to PEB %d",
902 len, pnum);
903 goto write_error;
904 }
905
906 if (vol->eba_tbl[lnum] >= 0) {
907 err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 0);
908 if (err)
909 goto out_leb_unlock;
910 }
911
912 vol->eba_tbl[lnum] = pnum;
913
914out_leb_unlock:
915 leb_write_unlock(ubi, vol_id, lnum);
916out_mutex:
917 mutex_unlock(&ubi->alc_mutex);
918 ubi_free_vid_hdr(ubi, vid_hdr);
919 return err;
920
921write_error:
922 if (err != -EIO || !ubi->bad_allowed) {
923
924
925
926
927
928 ubi_ro_mode(ubi);
929 goto out_leb_unlock;
930 }
931
932 err = ubi_wl_put_peb(ubi, pnum, 1);
933 if (err || ++tries > UBI_IO_RETRIES) {
934 ubi_ro_mode(ubi);
935 goto out_leb_unlock;
936 }
937
938 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
939 ubi_msg("try another PEB");
940 goto retry;
941}
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962static int is_error_sane(int err)
963{
964 if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_VID_HDR ||
965 err == -ETIMEDOUT)
966 return 0;
967 return 1;
968}
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
985 struct ubi_vid_hdr *vid_hdr)
986{
987 int err, vol_id, lnum, data_size, aldata_size, idx;
988 struct ubi_volume *vol;
989 uint32_t crc;
990
991 vol_id = be32_to_cpu(vid_hdr->vol_id);
992 lnum = be32_to_cpu(vid_hdr->lnum);
993
994 dbg_wl("copy LEB %d:%d, PEB %d to PEB %d", vol_id, lnum, from, to);
995
996 if (vid_hdr->vol_type == UBI_VID_STATIC) {
997 data_size = be32_to_cpu(vid_hdr->data_size);
998 aldata_size = ALIGN(data_size, ubi->min_io_size);
999 } else
1000 data_size = aldata_size =
1001 ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
1002
1003 idx = vol_id2idx(ubi, vol_id);
1004 spin_lock(&ubi->volumes_lock);
1005
1006
1007
1008
1009
1010
1011 vol = ubi->volumes[idx];
1012 spin_unlock(&ubi->volumes_lock);
1013 if (!vol) {
1014
1015 dbg_wl("volume %d is being removed, cancel", vol_id);
1016 return MOVE_CANCEL_RACE;
1017 }
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032 err = leb_write_trylock(ubi, vol_id, lnum);
1033 if (err) {
1034 dbg_wl("contention on LEB %d:%d, cancel", vol_id, lnum);
1035 return MOVE_CANCEL_RACE;
1036 }
1037
1038
1039
1040
1041
1042
1043 if (vol->eba_tbl[lnum] != from) {
1044 dbg_wl("LEB %d:%d is no longer mapped to PEB %d, mapped to "
1045 "PEB %d, cancel", vol_id, lnum, from,
1046 vol->eba_tbl[lnum]);
1047 err = MOVE_CANCEL_RACE;
1048 goto out_unlock_leb;
1049 }
1050
1051
1052
1053
1054
1055
1056
1057 mutex_lock(&ubi->buf_mutex);
1058 dbg_wl("read %d bytes of data", aldata_size);
1059 err = ubi_io_read_data(ubi, ubi->peb_buf1, from, 0, aldata_size);
1060 if (err && err != UBI_IO_BITFLIPS) {
1061 ubi_warn("error %d while reading data from PEB %d",
1062 err, from);
1063 err = MOVE_SOURCE_RD_ERR;
1064 goto out_unlock_buf;
1065 }
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077 if (vid_hdr->vol_type == UBI_VID_DYNAMIC)
1078 aldata_size = data_size =
1079 ubi_calc_data_len(ubi, ubi->peb_buf1, data_size);
1080
1081 cond_resched();
1082 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf1, data_size);
1083 cond_resched();
1084
1085
1086
1087
1088
1089
1090
1091 if (data_size > 0) {
1092 vid_hdr->copy_flag = 1;
1093 vid_hdr->data_size = cpu_to_be32(data_size);
1094 vid_hdr->data_crc = cpu_to_be32(crc);
1095 }
1096 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
1097
1098 err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
1099 if (err) {
1100 if (err == -EIO)
1101 err = MOVE_TARGET_WR_ERR;
1102 goto out_unlock_buf;
1103 }
1104
1105 cond_resched();
1106
1107
1108 err = ubi_io_read_vid_hdr(ubi, to, vid_hdr, 1);
1109 if (err) {
1110 if (err != UBI_IO_BITFLIPS) {
1111 ubi_warn("error %d while reading VID header back from "
1112 "PEB %d", err, to);
1113 if (is_error_sane(err))
1114 err = MOVE_TARGET_RD_ERR;
1115 } else
1116 err = MOVE_CANCEL_BITFLIPS;
1117 goto out_unlock_buf;
1118 }
1119
1120 if (data_size > 0) {
1121 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
1122 if (err) {
1123 if (err == -EIO)
1124 err = MOVE_TARGET_WR_ERR;
1125 goto out_unlock_buf;
1126 }
1127
1128 cond_resched();
1129
1130
1131
1132
1133
1134
1135 err = ubi_io_read_data(ubi, ubi->peb_buf2, to, 0, aldata_size);
1136 if (err) {
1137 if (err != UBI_IO_BITFLIPS) {
1138 ubi_warn("error %d while reading data back "
1139 "from PEB %d", err, to);
1140 if (is_error_sane(err))
1141 err = MOVE_TARGET_RD_ERR;
1142 } else
1143 err = MOVE_CANCEL_BITFLIPS;
1144 goto out_unlock_buf;
1145 }
1146
1147 cond_resched();
1148
1149 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
1150 ubi_warn("read data back from PEB %d and it is "
1151 "different", to);
1152 err = -EINVAL;
1153 goto out_unlock_buf;
1154 }
1155 }
1156
1157 ubi_assert(vol->eba_tbl[lnum] == from);
1158 vol->eba_tbl[lnum] = to;
1159
1160out_unlock_buf:
1161 mutex_unlock(&ubi->buf_mutex);
1162out_unlock_leb:
1163 leb_write_unlock(ubi, vol_id, lnum);
1164 return err;
1165}
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
1176{
1177 int i, j, err, num_volumes;
1178 struct ubi_scan_volume *sv;
1179 struct ubi_volume *vol;
1180 struct ubi_scan_leb *seb;
1181 struct rb_node *rb;
1182
1183 dbg_eba("initialize EBA sub-system");
1184
1185 spin_lock_init(&ubi->ltree_lock);
1186 mutex_init(&ubi->alc_mutex);
1187 ubi->ltree = RB_ROOT;
1188
1189 ubi->global_sqnum = si->max_sqnum + 1;
1190 num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1191
1192 for (i = 0; i < num_volumes; i++) {
1193 vol = ubi->volumes[i];
1194 if (!vol)
1195 continue;
1196
1197 cond_resched();
1198
1199 vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int),
1200 GFP_KERNEL);
1201 if (!vol->eba_tbl) {
1202 err = -ENOMEM;
1203 goto out_free;
1204 }
1205
1206 for (j = 0; j < vol->reserved_pebs; j++)
1207 vol->eba_tbl[j] = UBI_LEB_UNMAPPED;
1208
1209 sv = ubi_scan_find_sv(si, idx2vol_id(ubi, i));
1210 if (!sv)
1211 continue;
1212
1213 ubi_rb_for_each_entry(rb, seb, &sv->root, u.rb) {
1214 if (seb->lnum >= vol->reserved_pebs)
1215
1216
1217
1218
1219 ubi_scan_move_to_list(sv, seb, &si->erase);
1220 vol->eba_tbl[seb->lnum] = seb->pnum;
1221 }
1222 }
1223
1224 if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
1225 ubi_err("no enough physical eraseblocks (%d, need %d)",
1226 ubi->avail_pebs, EBA_RESERVED_PEBS);
1227 err = -ENOSPC;
1228 goto out_free;
1229 }
1230 ubi->avail_pebs -= EBA_RESERVED_PEBS;
1231 ubi->rsvd_pebs += EBA_RESERVED_PEBS;
1232
1233 if (ubi->bad_allowed) {
1234 ubi_calculate_reserved(ubi);
1235
1236 if (ubi->avail_pebs < ubi->beb_rsvd_level) {
1237
1238 ubi->beb_rsvd_pebs = ubi->avail_pebs;
1239 ubi_warn("cannot reserve enough PEBs for bad PEB "
1240 "handling, reserved %d, need %d",
1241 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
1242 } else
1243 ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
1244
1245 ubi->avail_pebs -= ubi->beb_rsvd_pebs;
1246 ubi->rsvd_pebs += ubi->beb_rsvd_pebs;
1247 }
1248
1249 dbg_eba("EBA sub-system is initialized");
1250 return 0;
1251
1252out_free:
1253 for (i = 0; i < num_volumes; i++) {
1254 if (!ubi->volumes[i])
1255 continue;
1256 kfree(ubi->volumes[i]->eba_tbl);
1257 ubi->volumes[i]->eba_tbl = NULL;
1258 }
1259 return err;
1260}
1261