Lines Matching refs:ubi
125 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec);
126 static int self_check_in_wl_tree(const struct ubi_device *ubi,
128 static int self_check_in_pq(const struct ubi_device *ubi,
175 static void wl_entry_destroy(struct ubi_device *ubi, struct ubi_wl_entry *e) in wl_entry_destroy() argument
177 ubi->lookuptbl[e->pnum] = NULL; in wl_entry_destroy()
188 static int do_work(struct ubi_device *ubi) in do_work() argument
201 down_read(&ubi->work_sem); in do_work()
202 spin_lock(&ubi->wl_lock); in do_work()
203 if (list_empty(&ubi->works)) { in do_work()
204 spin_unlock(&ubi->wl_lock); in do_work()
205 up_read(&ubi->work_sem); in do_work()
209 wrk = list_entry(ubi->works.next, struct ubi_work, list); in do_work()
211 ubi->works_count -= 1; in do_work()
212 ubi_assert(ubi->works_count >= 0); in do_work()
213 spin_unlock(&ubi->wl_lock); in do_work()
220 err = wrk->func(ubi, wrk, 0); in do_work()
222 ubi_err(ubi, "work failed with error code %d", err); in do_work()
223 up_read(&ubi->work_sem); in do_work()
275 static inline int in_pq(const struct ubi_device *ubi, struct ubi_wl_entry *e) in in_pq() argument
281 list_for_each_entry(p, &ubi->pq[i], u.list) in in_pq()
298 static void prot_queue_add(struct ubi_device *ubi, struct ubi_wl_entry *e) in prot_queue_add() argument
300 int pq_tail = ubi->pq_head - 1; in prot_queue_add()
305 list_add_tail(&e->u.list, &ubi->pq[pq_tail]); in prot_queue_add()
318 static struct ubi_wl_entry *find_wl_entry(struct ubi_device *ubi, in find_wl_entry() argument
353 static struct ubi_wl_entry *find_mean_wl_entry(struct ubi_device *ubi, in find_mean_wl_entry() argument
367 e = may_reserve_for_fm(ubi, e, root); in find_mean_wl_entry()
369 e = find_wl_entry(ubi, root, WL_FREE_MAX_DIFF/2); in find_mean_wl_entry()
382 static struct ubi_wl_entry *wl_get_wle(struct ubi_device *ubi) in wl_get_wle() argument
386 e = find_mean_wl_entry(ubi, &ubi->free); in wl_get_wle()
388 ubi_err(ubi, "no free eraseblocks"); in wl_get_wle()
392 self_check_in_wl_tree(ubi, e, &ubi->free); in wl_get_wle()
398 rb_erase(&e->u.rb, &ubi->free); in wl_get_wle()
399 ubi->free_count--; in wl_get_wle()
413 static int prot_queue_del(struct ubi_device *ubi, int pnum) in prot_queue_del() argument
417 e = ubi->lookuptbl[pnum]; in prot_queue_del()
421 if (self_check_in_pq(ubi, e)) in prot_queue_del()
438 static int sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, in sync_erase() argument
447 err = self_check_ec(ubi, e->pnum, e->ec); in sync_erase()
451 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS); in sync_erase()
455 err = ubi_io_sync_erase(ubi, e->pnum, torture); in sync_erase()
465 ubi_err(ubi, "erase counter overflow at PEB %d, EC %llu", in sync_erase()
475 err = ubi_io_write_ec_hdr(ubi, e->pnum, ec_hdr); in sync_erase()
480 spin_lock(&ubi->wl_lock); in sync_erase()
481 if (e->ec > ubi->max_ec) in sync_erase()
482 ubi->max_ec = e->ec; in sync_erase()
483 spin_unlock(&ubi->wl_lock); in sync_erase()
498 static void serve_prot_queue(struct ubi_device *ubi) in serve_prot_queue() argument
509 spin_lock(&ubi->wl_lock); in serve_prot_queue()
510 list_for_each_entry_safe(e, tmp, &ubi->pq[ubi->pq_head], u.list) { in serve_prot_queue()
515 wl_tree_add(e, &ubi->used); in serve_prot_queue()
521 spin_unlock(&ubi->wl_lock); in serve_prot_queue()
527 ubi->pq_head += 1; in serve_prot_queue()
528 if (ubi->pq_head == UBI_PROT_QUEUE_LEN) in serve_prot_queue()
529 ubi->pq_head = 0; in serve_prot_queue()
530 ubi_assert(ubi->pq_head >= 0 && ubi->pq_head < UBI_PROT_QUEUE_LEN); in serve_prot_queue()
531 spin_unlock(&ubi->wl_lock); in serve_prot_queue()
542 static void __schedule_ubi_work(struct ubi_device *ubi, struct ubi_work *wrk) in __schedule_ubi_work() argument
544 spin_lock(&ubi->wl_lock); in __schedule_ubi_work()
545 list_add_tail(&wrk->list, &ubi->works); in __schedule_ubi_work()
546 ubi_assert(ubi->works_count >= 0); in __schedule_ubi_work()
547 ubi->works_count += 1; in __schedule_ubi_work()
548 if (ubi->thread_enabled && !ubi_dbg_is_bgt_disabled(ubi)) in __schedule_ubi_work()
549 wake_up_process(ubi->bgt_thread); in __schedule_ubi_work()
550 spin_unlock(&ubi->wl_lock); in __schedule_ubi_work()
561 static void schedule_ubi_work(struct ubi_device *ubi, struct ubi_work *wrk) in schedule_ubi_work() argument
563 down_read(&ubi->work_sem); in schedule_ubi_work()
564 __schedule_ubi_work(ubi, wrk); in schedule_ubi_work()
565 up_read(&ubi->work_sem); in schedule_ubi_work()
568 static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,
583 static int schedule_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, in schedule_erase() argument
604 __schedule_ubi_work(ubi, wl_wrk); in schedule_erase()
606 schedule_ubi_work(ubi, wl_wrk); in schedule_erase()
610 static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk);
620 static int do_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, in do_sync_erase() argument
632 return __erase_worker(ubi, &wl_wrk); in do_sync_erase()
635 static int ensure_wear_leveling(struct ubi_device *ubi, int nested);
647 static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk, argument
661 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS);
667 down_read(&ubi->fm_eba_sem);
668 mutex_lock(&ubi->move_mutex);
669 spin_lock(&ubi->wl_lock);
670 ubi_assert(!ubi->move_from && !ubi->move_to);
671 ubi_assert(!ubi->move_to_put);
673 if (!ubi->free.rb_node ||
674 (!ubi->used.rb_node && !ubi->scrub.rb_node)) {
686 !ubi->free.rb_node, !ubi->used.rb_node);
691 e1 = find_anchor_wl_entry(&ubi->used);
692 if (e1 && ubi->fm_next_anchor &&
693 (ubi->fm_next_anchor->ec - e1->ec >= UBI_WL_THRESHOLD)) {
694 ubi->fm_do_produce_anchor = 1;
700 wl_tree_add(ubi->fm_next_anchor, &ubi->free);
701 ubi->fm_next_anchor = NULL;
702 ubi->free_count++;
705 if (ubi->fm_do_produce_anchor) {
708 e2 = get_peb_for_wl(ubi);
712 self_check_in_wl_tree(ubi, e1, &ubi->used);
713 rb_erase(&e1->u.rb, &ubi->used);
715 ubi->fm_do_produce_anchor = 0;
716 } else if (!ubi->scrub.rb_node) {
718 if (!ubi->scrub.rb_node) {
725 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
726 e2 = get_peb_for_wl(ubi);
735 wl_tree_add(e2, &ubi->free);
736 ubi->free_count++;
739 self_check_in_wl_tree(ubi, e1, &ubi->used);
740 rb_erase(&e1->u.rb, &ubi->used);
746 e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, u.rb);
747 e2 = get_peb_for_wl(ubi);
751 self_check_in_wl_tree(ubi, e1, &ubi->scrub);
752 rb_erase(&e1->u.rb, &ubi->scrub);
756 ubi->move_from = e1;
757 ubi->move_to = e2;
758 spin_unlock(&ubi->wl_lock);
771 err = ubi_io_read_vid_hdr(ubi, e1->pnum, vidb, 0);
798 } else if (ubi->fast_attach && err == UBI_IO_BAD_HDR_EBADMSG) {
810 ubi_err(ubi, "error %d while reading VID header from PEB %d",
818 err = ubi_eba_copy_leb(ubi, e1->pnum, e2->pnum, vidb);
856 if (ubi->erroneous_peb_count > ubi->max_erroneous) {
857 ubi_err(ubi, "too many erroneous eraseblocks (%d)",
858 ubi->erroneous_peb_count);
874 ubi_msg(ubi, "scrubbed PEB %d (LEB %d:%d), data moved to PEB %d",
878 spin_lock(&ubi->wl_lock);
879 if (!ubi->move_to_put) {
880 wl_tree_add(e2, &ubi->used);
883 ubi->move_from = ubi->move_to = NULL;
884 ubi->move_to_put = ubi->wl_scheduled = 0;
885 spin_unlock(&ubi->wl_lock);
887 err = do_sync_erase(ubi, e1, vol_id, lnum, 0);
890 wl_entry_destroy(ubi, e2);
901 err = do_sync_erase(ubi, e2, vol_id, lnum, 0);
907 mutex_unlock(&ubi->move_mutex);
908 up_read(&ubi->fm_eba_sem);
923 spin_lock(&ubi->wl_lock);
925 prot_queue_add(ubi, e1);
927 wl_tree_add(e1, &ubi->erroneous);
928 ubi->erroneous_peb_count += 1;
930 wl_tree_add(e1, &ubi->scrub);
932 wl_tree_add(e1, &ubi->used);
934 wl_tree_add(e2, &ubi->free);
935 ubi->free_count++;
938 ubi_assert(!ubi->move_to_put);
939 ubi->move_from = ubi->move_to = NULL;
940 ubi->wl_scheduled = 0;
941 spin_unlock(&ubi->wl_lock);
945 ensure_wear_leveling(ubi, 1);
947 err = do_sync_erase(ubi, e2, vol_id, lnum, torture);
953 err = do_sync_erase(ubi, e1, vol_id, lnum, 1);
958 mutex_unlock(&ubi->move_mutex);
959 up_read(&ubi->fm_eba_sem);
964 ubi_err(ubi, "error %d while moving PEB %d to PEB %d",
967 ubi_err(ubi, "error %d while moving PEB %d (LEB %d:%d) to PEB %d",
969 spin_lock(&ubi->wl_lock);
970 ubi->move_from = ubi->move_to = NULL;
971 ubi->move_to_put = ubi->wl_scheduled = 0;
972 spin_unlock(&ubi->wl_lock);
975 wl_entry_destroy(ubi, e1);
976 wl_entry_destroy(ubi, e2);
979 ubi_ro_mode(ubi);
980 mutex_unlock(&ubi->move_mutex);
981 up_read(&ubi->fm_eba_sem);
986 ubi->wl_scheduled = 0;
987 spin_unlock(&ubi->wl_lock);
988 mutex_unlock(&ubi->move_mutex);
989 up_read(&ubi->fm_eba_sem);
1003 static int ensure_wear_leveling(struct ubi_device *ubi, int nested) argument
1010 spin_lock(&ubi->wl_lock);
1011 if (ubi->wl_scheduled)
1019 if (!ubi->scrub.rb_node) {
1020 if (!ubi->used.rb_node || !ubi->free.rb_node)
1030 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
1031 e2 = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
1039 ubi->wl_scheduled = 1;
1040 spin_unlock(&ubi->wl_lock);
1050 __schedule_ubi_work(ubi, wrk);
1052 schedule_ubi_work(ubi, wrk);
1056 spin_lock(&ubi->wl_lock);
1057 ubi->wl_scheduled = 0;
1059 spin_unlock(&ubi->wl_lock);
1073 static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk) argument
1084 err = sync_erase(ubi, e, wl_wrk->torture);
1086 spin_lock(&ubi->wl_lock);
1088 if (!ubi->fm_disabled && !ubi->fm_next_anchor &&
1093 ubi->fm_next_anchor = e;
1094 ubi->fm_do_produce_anchor = 0;
1096 wl_tree_add(e, &ubi->free);
1097 ubi->free_count++;
1100 spin_unlock(&ubi->wl_lock);
1106 serve_prot_queue(ubi);
1109 err = ensure_wear_leveling(ubi, 1);
1113 ubi_err(ubi, "failed to erase PEB %d, error %d", pnum, err);
1120 err1 = schedule_erase(ubi, e, vol_id, lnum, 0, false);
1122 wl_entry_destroy(ubi, e);
1129 wl_entry_destroy(ubi, e);
1140 if (!ubi->bad_allowed) {
1141 ubi_err(ubi, "bad physical eraseblock %d detected", pnum);
1145 spin_lock(&ubi->volumes_lock);
1146 if (ubi->beb_rsvd_pebs == 0) {
1147 if (ubi->avail_pebs == 0) {
1148 spin_unlock(&ubi->volumes_lock);
1149 ubi_err(ubi, "no reserved/available physical eraseblocks");
1152 ubi->avail_pebs -= 1;
1155 spin_unlock(&ubi->volumes_lock);
1157 ubi_msg(ubi, "mark PEB %d as bad", pnum);
1158 err = ubi_io_mark_bad(ubi, pnum);
1162 spin_lock(&ubi->volumes_lock);
1163 if (ubi->beb_rsvd_pebs > 0) {
1169 ubi->avail_pebs += 1;
1172 ubi->beb_rsvd_pebs -= 1;
1174 ubi->bad_peb_count += 1;
1175 ubi->good_peb_count -= 1;
1176 ubi_calculate_reserved(ubi);
1178 ubi_warn(ubi, "no PEBs in the reserved pool, used an available PEB");
1179 else if (ubi->beb_rsvd_pebs)
1180 ubi_msg(ubi, "%d PEBs left in the reserve",
1181 ubi->beb_rsvd_pebs);
1183 ubi_warn(ubi, "last PEB from the reserve was used");
1184 spin_unlock(&ubi->volumes_lock);
1190 spin_lock(&ubi->volumes_lock);
1191 ubi->avail_pebs += 1;
1192 spin_unlock(&ubi->volumes_lock);
1194 ubi_ro_mode(ubi);
1198 static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk, argument
1208 wl_entry_destroy(ubi, e);
1212 ret = __erase_worker(ubi, wl_wrk);
1230 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum, argument
1238 ubi_assert(pnum < ubi->peb_count);
1240 down_read(&ubi->fm_protect);
1243 spin_lock(&ubi->wl_lock);
1244 e = ubi->lookuptbl[pnum];
1245 if (e == ubi->move_from) {
1252 spin_unlock(&ubi->wl_lock);
1255 mutex_lock(&ubi->move_mutex);
1256 mutex_unlock(&ubi->move_mutex);
1258 } else if (e == ubi->move_to) {
1269 ubi_assert(!ubi->move_to_put);
1270 ubi->move_to_put = 1;
1271 spin_unlock(&ubi->wl_lock);
1272 up_read(&ubi->fm_protect);
1275 if (in_wl_tree(e, &ubi->used)) {
1276 self_check_in_wl_tree(ubi, e, &ubi->used);
1277 rb_erase(&e->u.rb, &ubi->used);
1278 } else if (in_wl_tree(e, &ubi->scrub)) {
1279 self_check_in_wl_tree(ubi, e, &ubi->scrub);
1280 rb_erase(&e->u.rb, &ubi->scrub);
1281 } else if (in_wl_tree(e, &ubi->erroneous)) {
1282 self_check_in_wl_tree(ubi, e, &ubi->erroneous);
1283 rb_erase(&e->u.rb, &ubi->erroneous);
1284 ubi->erroneous_peb_count -= 1;
1285 ubi_assert(ubi->erroneous_peb_count >= 0);
1289 err = prot_queue_del(ubi, e->pnum);
1291 ubi_err(ubi, "PEB %d not found", pnum);
1292 ubi_ro_mode(ubi);
1293 spin_unlock(&ubi->wl_lock);
1294 up_read(&ubi->fm_protect);
1299 spin_unlock(&ubi->wl_lock);
1301 err = schedule_erase(ubi, e, vol_id, lnum, torture, false);
1303 spin_lock(&ubi->wl_lock);
1304 wl_tree_add(e, &ubi->used);
1305 spin_unlock(&ubi->wl_lock);
1308 up_read(&ubi->fm_protect);
1322 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum) argument
1326 ubi_msg(ubi, "schedule PEB %d for scrubbing", pnum);
1329 spin_lock(&ubi->wl_lock);
1330 e = ubi->lookuptbl[pnum];
1331 if (e == ubi->move_from || in_wl_tree(e, &ubi->scrub) ||
1332 in_wl_tree(e, &ubi->erroneous)) {
1333 spin_unlock(&ubi->wl_lock);
1337 if (e == ubi->move_to) {
1344 spin_unlock(&ubi->wl_lock);
1350 if (in_wl_tree(e, &ubi->used)) {
1351 self_check_in_wl_tree(ubi, e, &ubi->used);
1352 rb_erase(&e->u.rb, &ubi->used);
1356 err = prot_queue_del(ubi, e->pnum);
1358 ubi_err(ubi, "PEB %d not found", pnum);
1359 ubi_ro_mode(ubi);
1360 spin_unlock(&ubi->wl_lock);
1365 wl_tree_add(e, &ubi->scrub);
1366 spin_unlock(&ubi->wl_lock);
1372 return ensure_wear_leveling(ubi, 0);
1387 int ubi_wl_flush(struct ubi_device *ubi, int vol_id, int lnum) argument
1397 vol_id, lnum, ubi->works_count);
1403 down_read(&ubi->work_sem);
1404 spin_lock(&ubi->wl_lock);
1405 list_for_each_entry_safe(wrk, tmp, &ubi->works, list) {
1409 ubi->works_count -= 1;
1410 ubi_assert(ubi->works_count >= 0);
1411 spin_unlock(&ubi->wl_lock);
1413 err = wrk->func(ubi, wrk, 0);
1415 up_read(&ubi->work_sem);
1419 spin_lock(&ubi->wl_lock);
1424 spin_unlock(&ubi->wl_lock);
1425 up_read(&ubi->work_sem);
1432 down_write(&ubi->work_sem);
1433 up_write(&ubi->work_sem);
1438 static bool scrub_possible(struct ubi_device *ubi, struct ubi_wl_entry *e) argument
1440 if (in_wl_tree(e, &ubi->scrub))
1442 else if (in_wl_tree(e, &ubi->erroneous))
1444 else if (ubi->move_from == e)
1446 else if (ubi->move_to == e)
1471 int ubi_bitflip_check(struct ubi_device *ubi, int pnum, int force) argument
1476 if (pnum < 0 || pnum >= ubi->peb_count) {
1485 down_write(&ubi->work_sem);
1491 spin_lock(&ubi->wl_lock);
1492 e = ubi->lookuptbl[pnum];
1494 spin_unlock(&ubi->wl_lock);
1502 if (!scrub_possible(ubi, e)) {
1503 spin_unlock(&ubi->wl_lock);
1507 spin_unlock(&ubi->wl_lock);
1510 mutex_lock(&ubi->buf_mutex);
1511 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
1512 mutex_unlock(&ubi->buf_mutex);
1519 spin_lock(&ubi->wl_lock);
1525 e = ubi->lookuptbl[pnum];
1527 spin_unlock(&ubi->wl_lock);
1535 if (!scrub_possible(ubi, e)) {
1536 spin_unlock(&ubi->wl_lock);
1541 if (in_pq(ubi, e)) {
1542 prot_queue_del(ubi, e->pnum);
1543 wl_tree_add(e, &ubi->scrub);
1544 spin_unlock(&ubi->wl_lock);
1546 err = ensure_wear_leveling(ubi, 1);
1547 } else if (in_wl_tree(e, &ubi->used)) {
1548 rb_erase(&e->u.rb, &ubi->used);
1549 wl_tree_add(e, &ubi->scrub);
1550 spin_unlock(&ubi->wl_lock);
1552 err = ensure_wear_leveling(ubi, 1);
1553 } else if (in_wl_tree(e, &ubi->free)) {
1554 rb_erase(&e->u.rb, &ubi->free);
1555 ubi->free_count--;
1556 spin_unlock(&ubi->wl_lock);
1562 err = schedule_erase(ubi, e, UBI_UNKNOWN, UBI_UNKNOWN,
1565 spin_unlock(&ubi->wl_lock);
1576 up_write(&ubi->work_sem);
1587 static void tree_destroy(struct ubi_device *ubi, struct rb_root *root) argument
1609 wl_entry_destroy(ubi, e);
1621 struct ubi_device *ubi = u; local
1623 ubi_msg(ubi, "background thread \"%s\" started, PID %d",
1624 ubi->bgt_name, task_pid_nr(current));
1636 spin_lock(&ubi->wl_lock);
1637 if (list_empty(&ubi->works) || ubi->ro_mode ||
1638 !ubi->thread_enabled || ubi_dbg_is_bgt_disabled(ubi)) {
1640 spin_unlock(&ubi->wl_lock);
1657 spin_unlock(&ubi->wl_lock);
1659 err = do_work(ubi);
1661 ubi_err(ubi, "%s: work failed with error code %d",
1662 ubi->bgt_name, err);
1668 ubi_msg(ubi, "%s: %d consecutive failures",
1669 ubi->bgt_name, WL_MAX_FAILURES);
1670 ubi_ro_mode(ubi);
1671 ubi->thread_enabled = 0;
1680 dbg_wl("background thread \"%s\" is killed", ubi->bgt_name);
1681 ubi->thread_enabled = 0;
1689 static void shutdown_work(struct ubi_device *ubi) argument
1691 while (!list_empty(&ubi->works)) {
1694 wrk = list_entry(ubi->works.next, struct ubi_work, list);
1696 wrk->func(ubi, wrk, 1);
1697 ubi->works_count -= 1;
1698 ubi_assert(ubi->works_count >= 0);
1708 static int erase_aeb(struct ubi_device *ubi, struct ubi_ainf_peb *aeb, bool sync) argument
1719 ubi->lookuptbl[e->pnum] = e;
1722 err = sync_erase(ubi, e, false);
1726 wl_tree_add(e, &ubi->free);
1727 ubi->free_count++;
1729 err = schedule_erase(ubi, e, aeb->vol_id, aeb->lnum, 0, false);
1737 wl_entry_destroy(ubi, e);
1750 int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai) argument
1758 ubi->used = ubi->erroneous = ubi->free = ubi->scrub = RB_ROOT;
1759 spin_lock_init(&ubi->wl_lock);
1760 mutex_init(&ubi->move_mutex);
1761 init_rwsem(&ubi->work_sem);
1762 ubi->max_ec = ai->max_ec;
1763 INIT_LIST_HEAD(&ubi->works);
1765 sprintf(ubi->bgt_name, UBI_BGT_NAME_PATTERN, ubi->ubi_num);
1768 ubi->lookuptbl = kcalloc(ubi->peb_count, sizeof(void *), GFP_KERNEL);
1769 if (!ubi->lookuptbl)
1773 INIT_LIST_HEAD(&ubi->pq[i]);
1774 ubi->pq_head = 0;
1776 ubi->free_count = 0;
1780 err = erase_aeb(ubi, aeb, false);
1800 wl_tree_add(e, &ubi->free);
1801 ubi->free_count++;
1803 ubi->lookuptbl[e->pnum] = e;
1820 ubi->lookuptbl[e->pnum] = e;
1825 wl_tree_add(e, &ubi->used);
1829 wl_tree_add(e, &ubi->scrub);
1839 e = ubi_find_fm_block(ubi, aeb->pnum);
1842 ubi_assert(!ubi->lookuptbl[e->pnum]);
1843 ubi->lookuptbl[e->pnum] = e;
1853 if (ubi->lookuptbl[aeb->pnum])
1868 err = erase_aeb(ubi, aeb, sync);
1878 ubi_assert(ubi->good_peb_count == found_pebs);
1881 ubi_fastmap_init(ubi, &reserved_pebs);
1883 if (ubi->avail_pebs < reserved_pebs) {
1884 ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
1885 ubi->avail_pebs, reserved_pebs);
1886 if (ubi->corr_peb_count)
1887 ubi_err(ubi, "%d PEBs are corrupted and not used",
1888 ubi->corr_peb_count);
1892 ubi->avail_pebs -= reserved_pebs;
1893 ubi->rsvd_pebs += reserved_pebs;
1896 err = ensure_wear_leveling(ubi, 0);
1901 if (!ubi->ro_mode && !ubi->fm_disabled)
1902 ubi_ensure_anchor_pebs(ubi);
1907 shutdown_work(ubi);
1908 tree_destroy(ubi, &ubi->used);
1909 tree_destroy(ubi, &ubi->free);
1910 tree_destroy(ubi, &ubi->scrub);
1911 kfree(ubi->lookuptbl);
1919 static void protection_queue_destroy(struct ubi_device *ubi) argument
1925 list_for_each_entry_safe(e, tmp, &ubi->pq[i], u.list) {
1927 wl_entry_destroy(ubi, e);
1936 void ubi_wl_close(struct ubi_device *ubi) argument
1939 ubi_fastmap_close(ubi);
1940 shutdown_work(ubi);
1941 protection_queue_destroy(ubi);
1942 tree_destroy(ubi, &ubi->used);
1943 tree_destroy(ubi, &ubi->erroneous);
1944 tree_destroy(ubi, &ubi->free);
1945 tree_destroy(ubi, &ubi->scrub);
1946 kfree(ubi->lookuptbl);
1959 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec) argument
1965 if (!ubi_dbg_chk_gen(ubi))
1968 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1972 err = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
1981 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1982 ubi_err(ubi, "read EC is %lld, should be %d", read_ec, ec);
2002 static int self_check_in_wl_tree(const struct ubi_device *ubi, argument
2005 if (!ubi_dbg_chk_gen(ubi))
2011 ubi_err(ubi, "self-check failed for PEB %d, EC %d, RB-tree %p ",
2025 static int self_check_in_pq(const struct ubi_device *ubi, argument
2028 if (!ubi_dbg_chk_gen(ubi))
2031 if (in_pq(ubi, e))
2034 ubi_err(ubi, "self-check failed for PEB %d, EC %d, Protect queue",
2040 static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi) argument
2044 e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
2045 self_check_in_wl_tree(ubi, e, &ubi->free);
2046 ubi->free_count--;
2047 ubi_assert(ubi->free_count >= 0);
2048 rb_erase(&e->u.rb, &ubi->free);
2062 static int produce_free_peb(struct ubi_device *ubi) argument
2066 while (!ubi->free.rb_node && ubi->works_count) {
2067 spin_unlock(&ubi->wl_lock);
2070 err = do_work(ubi);
2072 spin_lock(&ubi->wl_lock);
2088 int ubi_wl_get_peb(struct ubi_device *ubi) argument
2094 down_read(&ubi->fm_eba_sem);
2095 spin_lock(&ubi->wl_lock);
2096 if (!ubi->free.rb_node) {
2097 if (ubi->works_count == 0) {
2098 ubi_err(ubi, "no free eraseblocks");
2099 ubi_assert(list_empty(&ubi->works));
2100 spin_unlock(&ubi->wl_lock);
2104 err = produce_free_peb(ubi);
2106 spin_unlock(&ubi->wl_lock);
2109 spin_unlock(&ubi->wl_lock);
2110 up_read(&ubi->fm_eba_sem);
2114 e = wl_get_wle(ubi);
2115 prot_queue_add(ubi, e);
2116 spin_unlock(&ubi->wl_lock);
2118 err = ubi_self_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
2119 ubi->peb_size - ubi->vid_hdr_aloffset);
2121 ubi_err(ubi, "new PEB %d does not contain all 0xFF bytes", e->pnum);