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,
582 static int schedule_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, in schedule_erase() argument
603 __schedule_ubi_work(ubi, wl_wrk); in schedule_erase()
605 schedule_ubi_work(ubi, wl_wrk); in schedule_erase()
609 static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk);
619 static int do_sync_erase(struct ubi_device *ubi, struct ubi_wl_entry *e, in do_sync_erase() argument
631 return __erase_worker(ubi, &wl_wrk); in do_sync_erase()
634 static int ensure_wear_leveling(struct ubi_device *ubi, int nested);
646 static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk, argument
660 vidb = ubi_alloc_vid_buf(ubi, GFP_NOFS);
666 down_read(&ubi->fm_eba_sem);
667 mutex_lock(&ubi->move_mutex);
668 spin_lock(&ubi->wl_lock);
669 ubi_assert(!ubi->move_from && !ubi->move_to);
670 ubi_assert(!ubi->move_to_put);
672 if (!ubi->free.rb_node ||
673 (!ubi->used.rb_node && !ubi->scrub.rb_node)) {
685 !ubi->free.rb_node, !ubi->used.rb_node);
690 e1 = find_anchor_wl_entry(&ubi->used);
691 if (e1 && ubi->fm_next_anchor &&
692 (ubi->fm_next_anchor->ec - e1->ec >= UBI_WL_THRESHOLD)) {
693 ubi->fm_do_produce_anchor = 1;
699 wl_tree_add(ubi->fm_next_anchor, &ubi->free);
700 ubi->fm_next_anchor = NULL;
701 ubi->free_count++;
704 if (ubi->fm_do_produce_anchor) {
707 e2 = get_peb_for_wl(ubi);
711 self_check_in_wl_tree(ubi, e1, &ubi->used);
712 rb_erase(&e1->u.rb, &ubi->used);
714 ubi->fm_do_produce_anchor = 0;
715 } else if (!ubi->scrub.rb_node) {
717 if (!ubi->scrub.rb_node) {
724 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
725 e2 = get_peb_for_wl(ubi);
734 wl_tree_add(e2, &ubi->free);
735 ubi->free_count++;
738 self_check_in_wl_tree(ubi, e1, &ubi->used);
739 rb_erase(&e1->u.rb, &ubi->used);
745 e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, u.rb);
746 e2 = get_peb_for_wl(ubi);
750 self_check_in_wl_tree(ubi, e1, &ubi->scrub);
751 rb_erase(&e1->u.rb, &ubi->scrub);
755 ubi->move_from = e1;
756 ubi->move_to = e2;
757 spin_unlock(&ubi->wl_lock);
770 err = ubi_io_read_vid_hdr(ubi, e1->pnum, vidb, 0);
797 } else if (ubi->fast_attach && err == UBI_IO_BAD_HDR_EBADMSG) {
809 ubi_err(ubi, "error %d while reading VID header from PEB %d",
817 err = ubi_eba_copy_leb(ubi, e1->pnum, e2->pnum, vidb);
855 if (ubi->erroneous_peb_count > ubi->max_erroneous) {
856 ubi_err(ubi, "too many erroneous eraseblocks (%d)",
857 ubi->erroneous_peb_count);
873 ubi_msg(ubi, "scrubbed PEB %d (LEB %d:%d), data moved to PEB %d",
877 spin_lock(&ubi->wl_lock);
878 if (!ubi->move_to_put) {
879 wl_tree_add(e2, &ubi->used);
882 ubi->move_from = ubi->move_to = NULL;
883 ubi->move_to_put = ubi->wl_scheduled = 0;
884 spin_unlock(&ubi->wl_lock);
886 err = do_sync_erase(ubi, e1, vol_id, lnum, 0);
889 wl_entry_destroy(ubi, e2);
900 err = do_sync_erase(ubi, e2, vol_id, lnum, 0);
906 mutex_unlock(&ubi->move_mutex);
907 up_read(&ubi->fm_eba_sem);
922 spin_lock(&ubi->wl_lock);
924 prot_queue_add(ubi, e1);
926 wl_tree_add(e1, &ubi->erroneous);
927 ubi->erroneous_peb_count += 1;
929 wl_tree_add(e1, &ubi->scrub);
931 wl_tree_add(e1, &ubi->used);
933 wl_tree_add(e2, &ubi->free);
934 ubi->free_count++;
937 ubi_assert(!ubi->move_to_put);
938 ubi->move_from = ubi->move_to = NULL;
939 ubi->wl_scheduled = 0;
940 spin_unlock(&ubi->wl_lock);
944 ensure_wear_leveling(ubi, 1);
946 err = do_sync_erase(ubi, e2, vol_id, lnum, torture);
952 err = do_sync_erase(ubi, e1, vol_id, lnum, 1);
957 mutex_unlock(&ubi->move_mutex);
958 up_read(&ubi->fm_eba_sem);
963 ubi_err(ubi, "error %d while moving PEB %d to PEB %d",
966 ubi_err(ubi, "error %d while moving PEB %d (LEB %d:%d) to PEB %d",
968 spin_lock(&ubi->wl_lock);
969 ubi->move_from = ubi->move_to = NULL;
970 ubi->move_to_put = ubi->wl_scheduled = 0;
971 spin_unlock(&ubi->wl_lock);
974 wl_entry_destroy(ubi, e1);
975 wl_entry_destroy(ubi, e2);
978 ubi_ro_mode(ubi);
979 mutex_unlock(&ubi->move_mutex);
980 up_read(&ubi->fm_eba_sem);
985 ubi->wl_scheduled = 0;
986 spin_unlock(&ubi->wl_lock);
987 mutex_unlock(&ubi->move_mutex);
988 up_read(&ubi->fm_eba_sem);
1002 static int ensure_wear_leveling(struct ubi_device *ubi, int nested) argument
1009 spin_lock(&ubi->wl_lock);
1010 if (ubi->wl_scheduled)
1018 if (!ubi->scrub.rb_node) {
1019 if (!ubi->used.rb_node || !ubi->free.rb_node)
1029 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
1030 e2 = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
1038 ubi->wl_scheduled = 1;
1039 spin_unlock(&ubi->wl_lock);
1049 __schedule_ubi_work(ubi, wrk);
1051 schedule_ubi_work(ubi, wrk);
1055 spin_lock(&ubi->wl_lock);
1056 ubi->wl_scheduled = 0;
1058 spin_unlock(&ubi->wl_lock);
1074 static int __erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk) argument
1085 err = sync_erase(ubi, e, wl_wrk->torture);
1087 spin_lock(&ubi->wl_lock);
1089 if (!ubi->fm_disabled && !ubi->fm_next_anchor &&
1094 ubi->fm_next_anchor = e;
1095 ubi->fm_do_produce_anchor = 0;
1097 wl_tree_add(e, &ubi->free);
1098 ubi->free_count++;
1101 spin_unlock(&ubi->wl_lock);
1107 serve_prot_queue(ubi);
1110 err = ensure_wear_leveling(ubi, 1);
1114 ubi_err(ubi, "failed to erase PEB %d, error %d", pnum, err);
1121 err1 = schedule_erase(ubi, e, vol_id, lnum, 0, false);
1123 wl_entry_destroy(ubi, e);
1130 wl_entry_destroy(ubi, e);
1141 if (!ubi->bad_allowed) {
1142 ubi_err(ubi, "bad physical eraseblock %d detected", pnum);
1146 spin_lock(&ubi->volumes_lock);
1147 if (ubi->beb_rsvd_pebs == 0) {
1148 if (ubi->avail_pebs == 0) {
1149 spin_unlock(&ubi->volumes_lock);
1150 ubi_err(ubi, "no reserved/available physical eraseblocks");
1153 ubi->avail_pebs -= 1;
1156 spin_unlock(&ubi->volumes_lock);
1158 ubi_msg(ubi, "mark PEB %d as bad", pnum);
1159 err = ubi_io_mark_bad(ubi, pnum);
1163 spin_lock(&ubi->volumes_lock);
1164 if (ubi->beb_rsvd_pebs > 0) {
1170 ubi->avail_pebs += 1;
1173 ubi->beb_rsvd_pebs -= 1;
1175 ubi->bad_peb_count += 1;
1176 ubi->good_peb_count -= 1;
1177 ubi_calculate_reserved(ubi);
1179 ubi_warn(ubi, "no PEBs in the reserved pool, used an available PEB");
1180 else if (ubi->beb_rsvd_pebs)
1181 ubi_msg(ubi, "%d PEBs left in the reserve",
1182 ubi->beb_rsvd_pebs);
1184 ubi_warn(ubi, "last PEB from the reserve was used");
1185 spin_unlock(&ubi->volumes_lock);
1191 spin_lock(&ubi->volumes_lock);
1192 ubi->avail_pebs += 1;
1193 spin_unlock(&ubi->volumes_lock);
1195 ubi_ro_mode(ubi);
1199 static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk, argument
1209 wl_entry_destroy(ubi, e);
1213 ret = __erase_worker(ubi, wl_wrk);
1231 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum, argument
1239 ubi_assert(pnum < ubi->peb_count);
1241 down_read(&ubi->fm_protect);
1244 spin_lock(&ubi->wl_lock);
1245 e = ubi->lookuptbl[pnum];
1246 if (e == ubi->move_from) {
1253 spin_unlock(&ubi->wl_lock);
1256 mutex_lock(&ubi->move_mutex);
1257 mutex_unlock(&ubi->move_mutex);
1259 } else if (e == ubi->move_to) {
1270 ubi_assert(!ubi->move_to_put);
1271 ubi->move_to_put = 1;
1272 spin_unlock(&ubi->wl_lock);
1273 up_read(&ubi->fm_protect);
1276 if (in_wl_tree(e, &ubi->used)) {
1277 self_check_in_wl_tree(ubi, e, &ubi->used);
1278 rb_erase(&e->u.rb, &ubi->used);
1279 } else if (in_wl_tree(e, &ubi->scrub)) {
1280 self_check_in_wl_tree(ubi, e, &ubi->scrub);
1281 rb_erase(&e->u.rb, &ubi->scrub);
1282 } else if (in_wl_tree(e, &ubi->erroneous)) {
1283 self_check_in_wl_tree(ubi, e, &ubi->erroneous);
1284 rb_erase(&e->u.rb, &ubi->erroneous);
1285 ubi->erroneous_peb_count -= 1;
1286 ubi_assert(ubi->erroneous_peb_count >= 0);
1290 err = prot_queue_del(ubi, e->pnum);
1292 ubi_err(ubi, "PEB %d not found", pnum);
1293 ubi_ro_mode(ubi);
1294 spin_unlock(&ubi->wl_lock);
1295 up_read(&ubi->fm_protect);
1300 spin_unlock(&ubi->wl_lock);
1302 err = schedule_erase(ubi, e, vol_id, lnum, torture, false);
1304 spin_lock(&ubi->wl_lock);
1305 wl_tree_add(e, &ubi->used);
1306 spin_unlock(&ubi->wl_lock);
1309 up_read(&ubi->fm_protect);
1323 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum) argument
1327 ubi_msg(ubi, "schedule PEB %d for scrubbing", pnum);
1330 spin_lock(&ubi->wl_lock);
1331 e = ubi->lookuptbl[pnum];
1332 if (e == ubi->move_from || in_wl_tree(e, &ubi->scrub) ||
1333 in_wl_tree(e, &ubi->erroneous)) {
1334 spin_unlock(&ubi->wl_lock);
1338 if (e == ubi->move_to) {
1345 spin_unlock(&ubi->wl_lock);
1351 if (in_wl_tree(e, &ubi->used)) {
1352 self_check_in_wl_tree(ubi, e, &ubi->used);
1353 rb_erase(&e->u.rb, &ubi->used);
1357 err = prot_queue_del(ubi, e->pnum);
1359 ubi_err(ubi, "PEB %d not found", pnum);
1360 ubi_ro_mode(ubi);
1361 spin_unlock(&ubi->wl_lock);
1366 wl_tree_add(e, &ubi->scrub);
1367 spin_unlock(&ubi->wl_lock);
1373 return ensure_wear_leveling(ubi, 0);
1388 int ubi_wl_flush(struct ubi_device *ubi, int vol_id, int lnum) argument
1398 vol_id, lnum, ubi->works_count);
1404 down_read(&ubi->work_sem);
1405 spin_lock(&ubi->wl_lock);
1406 list_for_each_entry_safe(wrk, tmp, &ubi->works, list) {
1410 ubi->works_count -= 1;
1411 ubi_assert(ubi->works_count >= 0);
1412 spin_unlock(&ubi->wl_lock);
1414 err = wrk->func(ubi, wrk, 0);
1416 up_read(&ubi->work_sem);
1420 spin_lock(&ubi->wl_lock);
1425 spin_unlock(&ubi->wl_lock);
1426 up_read(&ubi->work_sem);
1433 down_write(&ubi->work_sem);
1434 up_write(&ubi->work_sem);
1439 static bool scrub_possible(struct ubi_device *ubi, struct ubi_wl_entry *e) argument
1441 if (in_wl_tree(e, &ubi->scrub))
1443 else if (in_wl_tree(e, &ubi->erroneous))
1445 else if (ubi->move_from == e)
1447 else if (ubi->move_to == e)
1472 int ubi_bitflip_check(struct ubi_device *ubi, int pnum, int force) argument
1477 if (pnum < 0 || pnum >= ubi->peb_count) {
1486 down_write(&ubi->work_sem);
1492 spin_lock(&ubi->wl_lock);
1493 e = ubi->lookuptbl[pnum];
1495 spin_unlock(&ubi->wl_lock);
1503 if (!scrub_possible(ubi, e)) {
1504 spin_unlock(&ubi->wl_lock);
1508 spin_unlock(&ubi->wl_lock);
1511 mutex_lock(&ubi->buf_mutex);
1512 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
1513 mutex_unlock(&ubi->buf_mutex);
1520 spin_lock(&ubi->wl_lock);
1526 e = ubi->lookuptbl[pnum];
1528 spin_unlock(&ubi->wl_lock);
1536 if (!scrub_possible(ubi, e)) {
1537 spin_unlock(&ubi->wl_lock);
1542 if (in_pq(ubi, e)) {
1543 prot_queue_del(ubi, e->pnum);
1544 wl_tree_add(e, &ubi->scrub);
1545 spin_unlock(&ubi->wl_lock);
1547 err = ensure_wear_leveling(ubi, 1);
1548 } else if (in_wl_tree(e, &ubi->used)) {
1549 rb_erase(&e->u.rb, &ubi->used);
1550 wl_tree_add(e, &ubi->scrub);
1551 spin_unlock(&ubi->wl_lock);
1553 err = ensure_wear_leveling(ubi, 1);
1554 } else if (in_wl_tree(e, &ubi->free)) {
1555 rb_erase(&e->u.rb, &ubi->free);
1556 ubi->free_count--;
1557 spin_unlock(&ubi->wl_lock);
1563 err = schedule_erase(ubi, e, UBI_UNKNOWN, UBI_UNKNOWN,
1566 spin_unlock(&ubi->wl_lock);
1577 up_write(&ubi->work_sem);
1588 static void tree_destroy(struct ubi_device *ubi, struct rb_root *root) argument
1610 wl_entry_destroy(ubi, e);
1622 struct ubi_device *ubi = u; local
1624 ubi_msg(ubi, "background thread \"%s\" started, PID %d",
1625 ubi->bgt_name, task_pid_nr(current));
1637 spin_lock(&ubi->wl_lock);
1638 if (list_empty(&ubi->works) || ubi->ro_mode ||
1639 !ubi->thread_enabled || ubi_dbg_is_bgt_disabled(ubi)) {
1641 spin_unlock(&ubi->wl_lock);
1658 spin_unlock(&ubi->wl_lock);
1660 err = do_work(ubi);
1662 ubi_err(ubi, "%s: work failed with error code %d",
1663 ubi->bgt_name, err);
1669 ubi_msg(ubi, "%s: %d consecutive failures",
1670 ubi->bgt_name, WL_MAX_FAILURES);
1671 ubi_ro_mode(ubi);
1672 ubi->thread_enabled = 0;
1681 dbg_wl("background thread \"%s\" is killed", ubi->bgt_name);
1682 ubi->thread_enabled = 0;
1690 static void shutdown_work(struct ubi_device *ubi) argument
1692 while (!list_empty(&ubi->works)) {
1695 wrk = list_entry(ubi->works.next, struct ubi_work, list);
1697 wrk->func(ubi, wrk, 1);
1698 ubi->works_count -= 1;
1699 ubi_assert(ubi->works_count >= 0);
1709 static int erase_aeb(struct ubi_device *ubi, struct ubi_ainf_peb *aeb, bool sync) argument
1720 ubi->lookuptbl[e->pnum] = e;
1723 err = sync_erase(ubi, e, false);
1727 wl_tree_add(e, &ubi->free);
1728 ubi->free_count++;
1730 err = schedule_erase(ubi, e, aeb->vol_id, aeb->lnum, 0, false);
1738 wl_entry_destroy(ubi, e);
1751 int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai) argument
1759 ubi->used = ubi->erroneous = ubi->free = ubi->scrub = RB_ROOT;
1760 spin_lock_init(&ubi->wl_lock);
1761 mutex_init(&ubi->move_mutex);
1762 init_rwsem(&ubi->work_sem);
1763 ubi->max_ec = ai->max_ec;
1764 INIT_LIST_HEAD(&ubi->works);
1766 sprintf(ubi->bgt_name, UBI_BGT_NAME_PATTERN, ubi->ubi_num);
1769 ubi->lookuptbl = kcalloc(ubi->peb_count, sizeof(void *), GFP_KERNEL);
1770 if (!ubi->lookuptbl)
1774 INIT_LIST_HEAD(&ubi->pq[i]);
1775 ubi->pq_head = 0;
1777 ubi->free_count = 0;
1781 err = erase_aeb(ubi, aeb, false);
1801 wl_tree_add(e, &ubi->free);
1802 ubi->free_count++;
1804 ubi->lookuptbl[e->pnum] = e;
1821 ubi->lookuptbl[e->pnum] = e;
1826 wl_tree_add(e, &ubi->used);
1830 wl_tree_add(e, &ubi->scrub);
1840 e = ubi_find_fm_block(ubi, aeb->pnum);
1843 ubi_assert(!ubi->lookuptbl[e->pnum]);
1844 ubi->lookuptbl[e->pnum] = e;
1854 if (ubi->lookuptbl[aeb->pnum])
1869 err = erase_aeb(ubi, aeb, sync);
1879 ubi_assert(ubi->good_peb_count == found_pebs);
1882 ubi_fastmap_init(ubi, &reserved_pebs);
1884 if (ubi->avail_pebs < reserved_pebs) {
1885 ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
1886 ubi->avail_pebs, reserved_pebs);
1887 if (ubi->corr_peb_count)
1888 ubi_err(ubi, "%d PEBs are corrupted and not used",
1889 ubi->corr_peb_count);
1893 ubi->avail_pebs -= reserved_pebs;
1894 ubi->rsvd_pebs += reserved_pebs;
1897 err = ensure_wear_leveling(ubi, 0);
1902 if (!ubi->ro_mode && !ubi->fm_disabled)
1903 ubi_ensure_anchor_pebs(ubi);
1908 shutdown_work(ubi);
1909 tree_destroy(ubi, &ubi->used);
1910 tree_destroy(ubi, &ubi->free);
1911 tree_destroy(ubi, &ubi->scrub);
1912 kfree(ubi->lookuptbl);
1920 static void protection_queue_destroy(struct ubi_device *ubi) argument
1926 list_for_each_entry_safe(e, tmp, &ubi->pq[i], u.list) {
1928 wl_entry_destroy(ubi, e);
1937 void ubi_wl_close(struct ubi_device *ubi) argument
1940 ubi_fastmap_close(ubi);
1941 shutdown_work(ubi);
1942 protection_queue_destroy(ubi);
1943 tree_destroy(ubi, &ubi->used);
1944 tree_destroy(ubi, &ubi->erroneous);
1945 tree_destroy(ubi, &ubi->free);
1946 tree_destroy(ubi, &ubi->scrub);
1947 kfree(ubi->lookuptbl);
1960 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec) argument
1966 if (!ubi_dbg_chk_gen(ubi))
1969 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1973 err = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
1982 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1983 ubi_err(ubi, "read EC is %lld, should be %d", read_ec, ec);
2003 static int self_check_in_wl_tree(const struct ubi_device *ubi, argument
2006 if (!ubi_dbg_chk_gen(ubi))
2012 ubi_err(ubi, "self-check failed for PEB %d, EC %d, RB-tree %p ",
2026 static int self_check_in_pq(const struct ubi_device *ubi, argument
2029 if (!ubi_dbg_chk_gen(ubi))
2032 if (in_pq(ubi, e))
2035 ubi_err(ubi, "self-check failed for PEB %d, EC %d, Protect queue",
2041 static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi) argument
2045 e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
2046 self_check_in_wl_tree(ubi, e, &ubi->free);
2047 ubi->free_count--;
2048 ubi_assert(ubi->free_count >= 0);
2049 rb_erase(&e->u.rb, &ubi->free);
2063 static int produce_free_peb(struct ubi_device *ubi) argument
2067 while (!ubi->free.rb_node && ubi->works_count) {
2068 spin_unlock(&ubi->wl_lock);
2071 err = do_work(ubi);
2073 spin_lock(&ubi->wl_lock);
2089 int ubi_wl_get_peb(struct ubi_device *ubi) argument
2095 down_read(&ubi->fm_eba_sem);
2096 spin_lock(&ubi->wl_lock);
2097 if (!ubi->free.rb_node) {
2098 if (ubi->works_count == 0) {
2099 ubi_err(ubi, "no free eraseblocks");
2100 ubi_assert(list_empty(&ubi->works));
2101 spin_unlock(&ubi->wl_lock);
2105 err = produce_free_peb(ubi);
2107 spin_unlock(&ubi->wl_lock);
2110 spin_unlock(&ubi->wl_lock);
2111 up_read(&ubi->fm_eba_sem);
2115 e = wl_get_wle(ubi);
2116 prot_queue_add(ubi, e);
2117 spin_unlock(&ubi->wl_lock);
2119 err = ubi_self_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
2120 ubi->peb_size - ubi->vid_hdr_aloffset);
2122 ubi_err(ubi, "new PEB %d does not contain all 0xFF bytes", e->pnum);