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