Lines Matching refs:ubi
138 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec);
139 static int self_check_in_wl_tree(const struct ubi_device *ubi,
141 static int self_check_in_pq(const struct ubi_device *ubi,
188 static void wl_entry_destroy(struct ubi_device *ubi, struct ubi_wl_entry *e) in wl_entry_destroy() argument
190 ubi->lookuptbl[e->pnum] = NULL; in wl_entry_destroy()
201 static int do_work(struct ubi_device *ubi) in do_work() argument
214 down_read(&ubi->work_sem); in do_work()
215 spin_lock(&ubi->wl_lock); in do_work()
216 if (list_empty(&ubi->works)) { in do_work()
217 spin_unlock(&ubi->wl_lock); in do_work()
218 up_read(&ubi->work_sem); in do_work()
222 wrk = list_entry(ubi->works.next, struct ubi_work, list); in do_work()
224 ubi->works_count -= 1; in do_work()
225 ubi_assert(ubi->works_count >= 0); in do_work()
226 spin_unlock(&ubi->wl_lock); in do_work()
233 err = wrk->func(ubi, wrk, 0); in do_work()
235 ubi_err(ubi, "work failed with error code %d", err); in do_work()
236 up_read(&ubi->work_sem); in do_work()
290 static void prot_queue_add(struct ubi_device *ubi, struct ubi_wl_entry *e) in prot_queue_add() argument
292 int pq_tail = ubi->pq_head - 1; in prot_queue_add()
297 list_add_tail(&e->u.list, &ubi->pq[pq_tail]); in prot_queue_add()
310 static struct ubi_wl_entry *find_wl_entry(struct ubi_device *ubi, in find_wl_entry() argument
337 if (prev_e && !ubi->fm_disabled && in find_wl_entry()
338 !ubi->fm && e->pnum < UBI_FM_MAX_START) in find_wl_entry()
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
602 schedule_ubi_work(ubi, wl_wrk); in schedule_erase()
615 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, 0); in do_sync_erase()
645 static int wear_leveling_worker(struct ubi_device *ubi, struct ubi_work *wrk, argument
660 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
664 mutex_lock(&ubi->move_mutex);
665 spin_lock(&ubi->wl_lock);
666 ubi_assert(!ubi->move_from && !ubi->move_to);
667 ubi_assert(!ubi->move_to_put);
669 if (!ubi->free.rb_node ||
670 (!ubi->used.rb_node && !ubi->scrub.rb_node)) {
682 !ubi->free.rb_node, !ubi->used.rb_node);
689 anchor = !anchor_pebs_avalible(&ubi->free);
692 e1 = find_anchor_wl_entry(&ubi->used);
695 e2 = get_peb_for_wl(ubi);
699 self_check_in_wl_tree(ubi, e1, &ubi->used);
700 rb_erase(&e1->u.rb, &ubi->used);
702 } else if (!ubi->scrub.rb_node) {
704 if (!ubi->scrub.rb_node) {
711 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
712 e2 = get_peb_for_wl(ubi);
721 wl_tree_add(e2, &ubi->free);
722 ubi->free_count++;
725 self_check_in_wl_tree(ubi, e1, &ubi->used);
726 rb_erase(&e1->u.rb, &ubi->used);
732 e1 = rb_entry(rb_first(&ubi->scrub), struct ubi_wl_entry, u.rb);
733 e2 = get_peb_for_wl(ubi);
737 self_check_in_wl_tree(ubi, e1, &ubi->scrub);
738 rb_erase(&e1->u.rb, &ubi->scrub);
742 ubi->move_from = e1;
743 ubi->move_to = e2;
744 spin_unlock(&ubi->wl_lock);
757 err = ubi_io_read_vid_hdr(ubi, e1->pnum, vid_hdr, 0);
785 ubi_err(ubi, "error %d while reading VID header from PEB %d",
793 err = ubi_eba_copy_leb(ubi, e1->pnum, e2->pnum, vid_hdr);
828 if (ubi->erroneous_peb_count > ubi->max_erroneous) {
829 ubi_err(ubi, "too many erroneous eraseblocks (%d)",
830 ubi->erroneous_peb_count);
845 ubi_msg(ubi, "scrubbed PEB %d (LEB %d:%d), data moved to PEB %d",
847 ubi_free_vid_hdr(ubi, vid_hdr);
849 spin_lock(&ubi->wl_lock);
850 if (!ubi->move_to_put) {
851 wl_tree_add(e2, &ubi->used);
854 ubi->move_from = ubi->move_to = NULL;
855 ubi->move_to_put = ubi->wl_scheduled = 0;
856 spin_unlock(&ubi->wl_lock);
858 err = do_sync_erase(ubi, e1, vol_id, lnum, 0);
861 wl_entry_destroy(ubi, e2);
872 err = do_sync_erase(ubi, e2, vol_id, lnum, 0);
878 mutex_unlock(&ubi->move_mutex);
893 spin_lock(&ubi->wl_lock);
895 prot_queue_add(ubi, e1);
897 wl_tree_add(e1, &ubi->erroneous);
898 ubi->erroneous_peb_count += 1;
900 wl_tree_add(e1, &ubi->scrub);
902 wl_tree_add(e1, &ubi->used);
903 ubi_assert(!ubi->move_to_put);
904 ubi->move_from = ubi->move_to = NULL;
905 ubi->wl_scheduled = 0;
906 spin_unlock(&ubi->wl_lock);
908 ubi_free_vid_hdr(ubi, vid_hdr);
909 err = do_sync_erase(ubi, e2, vol_id, lnum, torture);
913 mutex_unlock(&ubi->move_mutex);
918 ubi_err(ubi, "error %d while moving PEB %d to PEB %d",
921 ubi_err(ubi, "error %d while moving PEB %d (LEB %d:%d) to PEB %d",
923 spin_lock(&ubi->wl_lock);
924 ubi->move_from = ubi->move_to = NULL;
925 ubi->move_to_put = ubi->wl_scheduled = 0;
926 spin_unlock(&ubi->wl_lock);
928 ubi_free_vid_hdr(ubi, vid_hdr);
929 wl_entry_destroy(ubi, e1);
930 wl_entry_destroy(ubi, e2);
933 ubi_ro_mode(ubi);
934 mutex_unlock(&ubi->move_mutex);
939 ubi->wl_scheduled = 0;
940 spin_unlock(&ubi->wl_lock);
941 mutex_unlock(&ubi->move_mutex);
942 ubi_free_vid_hdr(ubi, vid_hdr);
955 static int ensure_wear_leveling(struct ubi_device *ubi, int nested) argument
962 spin_lock(&ubi->wl_lock);
963 if (ubi->wl_scheduled)
971 if (!ubi->scrub.rb_node) {
972 if (!ubi->used.rb_node || !ubi->free.rb_node)
982 e1 = rb_entry(rb_first(&ubi->used), struct ubi_wl_entry, u.rb);
983 e2 = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
991 ubi->wl_scheduled = 1;
992 spin_unlock(&ubi->wl_lock);
1003 __schedule_ubi_work(ubi, wrk);
1005 schedule_ubi_work(ubi, wrk);
1009 spin_lock(&ubi->wl_lock);
1010 ubi->wl_scheduled = 0;
1012 spin_unlock(&ubi->wl_lock);
1028 static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk, argument
1040 wl_entry_destroy(ubi, e);
1047 err = sync_erase(ubi, e, wl_wrk->torture);
1052 spin_lock(&ubi->wl_lock);
1053 wl_tree_add(e, &ubi->free);
1054 ubi->free_count++;
1055 spin_unlock(&ubi->wl_lock);
1061 serve_prot_queue(ubi);
1064 err = ensure_wear_leveling(ubi, 1);
1068 ubi_err(ubi, "failed to erase PEB %d, error %d", pnum, err);
1076 err1 = schedule_erase(ubi, e, vol_id, lnum, 0);
1084 wl_entry_destroy(ubi, e);
1095 if (!ubi->bad_allowed) {
1096 ubi_err(ubi, "bad physical eraseblock %d detected", pnum);
1100 spin_lock(&ubi->volumes_lock);
1101 if (ubi->beb_rsvd_pebs == 0) {
1102 if (ubi->avail_pebs == 0) {
1103 spin_unlock(&ubi->volumes_lock);
1104 ubi_err(ubi, "no reserved/available physical eraseblocks");
1107 ubi->avail_pebs -= 1;
1110 spin_unlock(&ubi->volumes_lock);
1112 ubi_msg(ubi, "mark PEB %d as bad", pnum);
1113 err = ubi_io_mark_bad(ubi, pnum);
1117 spin_lock(&ubi->volumes_lock);
1118 if (ubi->beb_rsvd_pebs > 0) {
1124 ubi->avail_pebs += 1;
1127 ubi->beb_rsvd_pebs -= 1;
1129 ubi->bad_peb_count += 1;
1130 ubi->good_peb_count -= 1;
1131 ubi_calculate_reserved(ubi);
1133 ubi_warn(ubi, "no PEBs in the reserved pool, used an available PEB");
1134 else if (ubi->beb_rsvd_pebs)
1135 ubi_msg(ubi, "%d PEBs left in the reserve",
1136 ubi->beb_rsvd_pebs);
1138 ubi_warn(ubi, "last PEB from the reserve was used");
1139 spin_unlock(&ubi->volumes_lock);
1145 spin_lock(&ubi->volumes_lock);
1146 ubi->avail_pebs += 1;
1147 spin_unlock(&ubi->volumes_lock);
1149 ubi_ro_mode(ubi);
1166 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum, argument
1174 ubi_assert(pnum < ubi->peb_count);
1176 down_read(&ubi->fm_protect);
1179 spin_lock(&ubi->wl_lock);
1180 e = ubi->lookuptbl[pnum];
1181 if (e == ubi->move_from) {
1188 spin_unlock(&ubi->wl_lock);
1191 mutex_lock(&ubi->move_mutex);
1192 mutex_unlock(&ubi->move_mutex);
1194 } else if (e == ubi->move_to) {
1205 ubi_assert(!ubi->move_to_put);
1206 ubi->move_to_put = 1;
1207 spin_unlock(&ubi->wl_lock);
1208 up_read(&ubi->fm_protect);
1211 if (in_wl_tree(e, &ubi->used)) {
1212 self_check_in_wl_tree(ubi, e, &ubi->used);
1213 rb_erase(&e->u.rb, &ubi->used);
1214 } else if (in_wl_tree(e, &ubi->scrub)) {
1215 self_check_in_wl_tree(ubi, e, &ubi->scrub);
1216 rb_erase(&e->u.rb, &ubi->scrub);
1217 } else if (in_wl_tree(e, &ubi->erroneous)) {
1218 self_check_in_wl_tree(ubi, e, &ubi->erroneous);
1219 rb_erase(&e->u.rb, &ubi->erroneous);
1220 ubi->erroneous_peb_count -= 1;
1221 ubi_assert(ubi->erroneous_peb_count >= 0);
1225 err = prot_queue_del(ubi, e->pnum);
1227 ubi_err(ubi, "PEB %d not found", pnum);
1228 ubi_ro_mode(ubi);
1229 spin_unlock(&ubi->wl_lock);
1230 up_read(&ubi->fm_protect);
1235 spin_unlock(&ubi->wl_lock);
1237 err = schedule_erase(ubi, e, vol_id, lnum, torture);
1239 spin_lock(&ubi->wl_lock);
1240 wl_tree_add(e, &ubi->used);
1241 spin_unlock(&ubi->wl_lock);
1244 up_read(&ubi->fm_protect);
1258 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum) argument
1262 ubi_msg(ubi, "schedule PEB %d for scrubbing", pnum);
1265 spin_lock(&ubi->wl_lock);
1266 e = ubi->lookuptbl[pnum];
1267 if (e == ubi->move_from || in_wl_tree(e, &ubi->scrub) ||
1268 in_wl_tree(e, &ubi->erroneous)) {
1269 spin_unlock(&ubi->wl_lock);
1273 if (e == ubi->move_to) {
1280 spin_unlock(&ubi->wl_lock);
1286 if (in_wl_tree(e, &ubi->used)) {
1287 self_check_in_wl_tree(ubi, e, &ubi->used);
1288 rb_erase(&e->u.rb, &ubi->used);
1292 err = prot_queue_del(ubi, e->pnum);
1294 ubi_err(ubi, "PEB %d not found", pnum);
1295 ubi_ro_mode(ubi);
1296 spin_unlock(&ubi->wl_lock);
1301 wl_tree_add(e, &ubi->scrub);
1302 spin_unlock(&ubi->wl_lock);
1308 return ensure_wear_leveling(ubi, 0);
1323 int ubi_wl_flush(struct ubi_device *ubi, int vol_id, int lnum) argument
1333 vol_id, lnum, ubi->works_count);
1339 down_read(&ubi->work_sem);
1340 spin_lock(&ubi->wl_lock);
1341 list_for_each_entry_safe(wrk, tmp, &ubi->works, list) {
1345 ubi->works_count -= 1;
1346 ubi_assert(ubi->works_count >= 0);
1347 spin_unlock(&ubi->wl_lock);
1349 err = wrk->func(ubi, wrk, 0);
1351 up_read(&ubi->work_sem);
1355 spin_lock(&ubi->wl_lock);
1360 spin_unlock(&ubi->wl_lock);
1361 up_read(&ubi->work_sem);
1368 down_write(&ubi->work_sem);
1369 up_write(&ubi->work_sem);
1379 static void tree_destroy(struct ubi_device *ubi, struct rb_root *root) argument
1401 wl_entry_destroy(ubi, e);
1413 struct ubi_device *ubi = u; local
1415 ubi_msg(ubi, "background thread \"%s\" started, PID %d",
1416 ubi->bgt_name, task_pid_nr(current));
1428 spin_lock(&ubi->wl_lock);
1429 if (list_empty(&ubi->works) || ubi->ro_mode ||
1430 !ubi->thread_enabled || ubi_dbg_is_bgt_disabled(ubi)) {
1432 spin_unlock(&ubi->wl_lock);
1436 spin_unlock(&ubi->wl_lock);
1438 err = do_work(ubi);
1440 ubi_err(ubi, "%s: work failed with error code %d",
1441 ubi->bgt_name, err);
1447 ubi_msg(ubi, "%s: %d consecutive failures",
1448 ubi->bgt_name, WL_MAX_FAILURES);
1449 ubi_ro_mode(ubi);
1450 ubi->thread_enabled = 0;
1459 dbg_wl("background thread \"%s\" is killed", ubi->bgt_name);
1467 static void shutdown_work(struct ubi_device *ubi) argument
1470 flush_work(&ubi->fm_work);
1472 while (!list_empty(&ubi->works)) {
1475 wrk = list_entry(ubi->works.next, struct ubi_work, list);
1477 wrk->func(ubi, wrk, 1);
1478 ubi->works_count -= 1;
1479 ubi_assert(ubi->works_count >= 0);
1491 int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai) argument
1499 ubi->used = ubi->erroneous = ubi->free = ubi->scrub = RB_ROOT;
1500 spin_lock_init(&ubi->wl_lock);
1501 mutex_init(&ubi->move_mutex);
1502 init_rwsem(&ubi->work_sem);
1503 ubi->max_ec = ai->max_ec;
1504 INIT_LIST_HEAD(&ubi->works);
1506 sprintf(ubi->bgt_name, UBI_BGT_NAME_PATTERN, ubi->ubi_num);
1509 ubi->lookuptbl = kzalloc(ubi->peb_count * sizeof(void *), GFP_KERNEL);
1510 if (!ubi->lookuptbl)
1514 INIT_LIST_HEAD(&ubi->pq[i]);
1515 ubi->pq_head = 0;
1526 ubi->lookuptbl[e->pnum] = e;
1527 if (schedule_erase(ubi, e, aeb->vol_id, aeb->lnum, 0)) {
1528 wl_entry_destroy(ubi, e);
1535 ubi->free_count = 0;
1547 wl_tree_add(e, &ubi->free);
1548 ubi->free_count++;
1550 ubi->lookuptbl[e->pnum] = e;
1565 ubi->lookuptbl[e->pnum] = e;
1570 wl_tree_add(e, &ubi->used);
1574 wl_tree_add(e, &ubi->scrub);
1583 if (ubi->fm) {
1584 ubi_assert(ubi->good_peb_count == \
1585 found_pebs + ubi->fm->used_blocks);
1587 for (i = 0; i < ubi->fm->used_blocks; i++) {
1588 e = ubi->fm->e[i];
1589 ubi->lookuptbl[e->pnum] = e;
1593 ubi_assert(ubi->good_peb_count == found_pebs);
1596 ubi_fastmap_init(ubi, &reserved_pebs);
1598 if (ubi->avail_pebs < reserved_pebs) {
1599 ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
1600 ubi->avail_pebs, reserved_pebs);
1601 if (ubi->corr_peb_count)
1602 ubi_err(ubi, "%d PEBs are corrupted and not used",
1603 ubi->corr_peb_count);
1607 ubi->avail_pebs -= reserved_pebs;
1608 ubi->rsvd_pebs += reserved_pebs;
1611 err = ensure_wear_leveling(ubi, 0);
1618 shutdown_work(ubi);
1619 tree_destroy(ubi, &ubi->used);
1620 tree_destroy(ubi, &ubi->free);
1621 tree_destroy(ubi, &ubi->scrub);
1622 kfree(ubi->lookuptbl);
1630 static void protection_queue_destroy(struct ubi_device *ubi) argument
1636 list_for_each_entry_safe(e, tmp, &ubi->pq[i], u.list) {
1638 wl_entry_destroy(ubi, e);
1647 void ubi_wl_close(struct ubi_device *ubi) argument
1650 ubi_fastmap_close(ubi);
1651 shutdown_work(ubi);
1652 protection_queue_destroy(ubi);
1653 tree_destroy(ubi, &ubi->used);
1654 tree_destroy(ubi, &ubi->erroneous);
1655 tree_destroy(ubi, &ubi->free);
1656 tree_destroy(ubi, &ubi->scrub);
1657 kfree(ubi->lookuptbl);
1670 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec) argument
1676 if (!ubi_dbg_chk_gen(ubi))
1679 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1683 err = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
1692 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1693 ubi_err(ubi, "read EC is %lld, should be %d", read_ec, ec);
1713 static int self_check_in_wl_tree(const struct ubi_device *ubi, argument
1716 if (!ubi_dbg_chk_gen(ubi))
1722 ubi_err(ubi, "self-check failed for PEB %d, EC %d, RB-tree %p ",
1736 static int self_check_in_pq(const struct ubi_device *ubi, argument
1742 if (!ubi_dbg_chk_gen(ubi))
1746 list_for_each_entry(p, &ubi->pq[i], u.list)
1750 ubi_err(ubi, "self-check failed for PEB %d, EC %d, Protect queue",
1756 static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi) argument
1760 e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
1761 self_check_in_wl_tree(ubi, e, &ubi->free);
1762 ubi->free_count--;
1763 ubi_assert(ubi->free_count >= 0);
1764 rb_erase(&e->u.rb, &ubi->free);
1778 static int produce_free_peb(struct ubi_device *ubi) argument
1782 while (!ubi->free.rb_node && ubi->works_count) {
1783 spin_unlock(&ubi->wl_lock);
1786 err = do_work(ubi);
1788 spin_lock(&ubi->wl_lock);
1804 int ubi_wl_get_peb(struct ubi_device *ubi) argument
1810 down_read(&ubi->fm_eba_sem);
1811 spin_lock(&ubi->wl_lock);
1812 if (!ubi->free.rb_node) {
1813 if (ubi->works_count == 0) {
1814 ubi_err(ubi, "no free eraseblocks");
1815 ubi_assert(list_empty(&ubi->works));
1816 spin_unlock(&ubi->wl_lock);
1820 err = produce_free_peb(ubi);
1822 spin_unlock(&ubi->wl_lock);
1825 spin_unlock(&ubi->wl_lock);
1826 up_read(&ubi->fm_eba_sem);
1830 e = wl_get_wle(ubi);
1831 prot_queue_add(ubi, e);
1832 spin_unlock(&ubi->wl_lock);
1834 err = ubi_self_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
1835 ubi->peb_size - ubi->vid_hdr_aloffset);
1837 ubi_err(ubi, "new PEB %d does not contain all 0xFF bytes", e->pnum);