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_anchor &&
692 	    (ubi->fm_anchor->ec - e1->ec >= UBI_WL_THRESHOLD)) {
693 		ubi->fm_do_produce_anchor = 1;
699 		wl_tree_add(ubi->fm_anchor, &ubi->free);
700 		ubi->fm_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_anchor &&
1095 			ubi->fm_anchor = e;
1096 			ubi->fm_do_produce_anchor = 0;
1098 			wl_tree_add(e, &ubi->free);
1099 			ubi->free_count++;
1102 		spin_unlock(&ubi->wl_lock);
1108 		serve_prot_queue(ubi);
1111 		err = ensure_wear_leveling(ubi, 1);
1115 	ubi_err(ubi, "failed to erase PEB %d, error %d", pnum, err);
1122 		err1 = schedule_erase(ubi, e, vol_id, lnum, 0, false);
1124 			wl_entry_destroy(ubi, e);
1131 	wl_entry_destroy(ubi, e);
1142 	if (!ubi->bad_allowed) {
1143 		ubi_err(ubi, "bad physical eraseblock %d detected", pnum);
1147 	spin_lock(&ubi->volumes_lock);
1148 	if (ubi->beb_rsvd_pebs == 0) {
1149 		if (ubi->avail_pebs == 0) {
1150 			spin_unlock(&ubi->volumes_lock);
1151 			ubi_err(ubi, "no reserved/available physical eraseblocks");
1154 		ubi->avail_pebs -= 1;
1157 	spin_unlock(&ubi->volumes_lock);
1159 	ubi_msg(ubi, "mark PEB %d as bad", pnum);
1160 	err = ubi_io_mark_bad(ubi, pnum);
1164 	spin_lock(&ubi->volumes_lock);
1165 	if (ubi->beb_rsvd_pebs > 0) {
1171 			ubi->avail_pebs += 1;
1174 		ubi->beb_rsvd_pebs -= 1;
1176 	ubi->bad_peb_count += 1;
1177 	ubi->good_peb_count -= 1;
1178 	ubi_calculate_reserved(ubi);
1180 		ubi_warn(ubi, "no PEBs in the reserved pool, used an available PEB");
1181 	else if (ubi->beb_rsvd_pebs)
1182 		ubi_msg(ubi, "%d PEBs left in the reserve",
1183 			ubi->beb_rsvd_pebs);
1185 		ubi_warn(ubi, "last PEB from the reserve was used");
1186 	spin_unlock(&ubi->volumes_lock);
1192 		spin_lock(&ubi->volumes_lock);
1193 		ubi->avail_pebs += 1;
1194 		spin_unlock(&ubi->volumes_lock);
1196 	ubi_ro_mode(ubi);
1200 static int erase_worker(struct ubi_device *ubi, struct ubi_work *wl_wrk,  argument
1210 		wl_entry_destroy(ubi, e);
1214 	ret = __erase_worker(ubi, wl_wrk);
1232 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum,  argument
1240 	ubi_assert(pnum < ubi->peb_count);
1242 	down_read(&ubi->fm_protect);
1245 	spin_lock(&ubi->wl_lock);
1246 	e = ubi->lookuptbl[pnum];
1247 	if (e == ubi->move_from) {
1254 		spin_unlock(&ubi->wl_lock);
1257 		mutex_lock(&ubi->move_mutex);
1258 		mutex_unlock(&ubi->move_mutex);
1260 	} else if (e == ubi->move_to) {
1271 		ubi_assert(!ubi->move_to_put);
1272 		ubi->move_to_put = 1;
1273 		spin_unlock(&ubi->wl_lock);
1274 		up_read(&ubi->fm_protect);
1277 		if (in_wl_tree(e, &ubi->used)) {
1278 			self_check_in_wl_tree(ubi, e, &ubi->used);
1279 			rb_erase(&e->u.rb, &ubi->used);
1280 		} else if (in_wl_tree(e, &ubi->scrub)) {
1281 			self_check_in_wl_tree(ubi, e, &ubi->scrub);
1282 			rb_erase(&e->u.rb, &ubi->scrub);
1283 		} else if (in_wl_tree(e, &ubi->erroneous)) {
1284 			self_check_in_wl_tree(ubi, e, &ubi->erroneous);
1285 			rb_erase(&e->u.rb, &ubi->erroneous);
1286 			ubi->erroneous_peb_count -= 1;
1287 			ubi_assert(ubi->erroneous_peb_count >= 0);
1291 			err = prot_queue_del(ubi, e->pnum);
1293 				ubi_err(ubi, "PEB %d not found", pnum);
1294 				ubi_ro_mode(ubi);
1295 				spin_unlock(&ubi->wl_lock);
1296 				up_read(&ubi->fm_protect);
1301 	spin_unlock(&ubi->wl_lock);
1303 	err = schedule_erase(ubi, e, vol_id, lnum, torture, false);
1305 		spin_lock(&ubi->wl_lock);
1306 		wl_tree_add(e, &ubi->used);
1307 		spin_unlock(&ubi->wl_lock);
1310 	up_read(&ubi->fm_protect);
1324 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum)  argument
1328 	ubi_msg(ubi, "schedule PEB %d for scrubbing", pnum);
1331 	spin_lock(&ubi->wl_lock);
1332 	e = ubi->lookuptbl[pnum];
1333 	if (e == ubi->move_from || in_wl_tree(e, &ubi->scrub) ||
1334 				   in_wl_tree(e, &ubi->erroneous)) {
1335 		spin_unlock(&ubi->wl_lock);
1339 	if (e == ubi->move_to) {
1346 		spin_unlock(&ubi->wl_lock);
1352 	if (in_wl_tree(e, &ubi->used)) {
1353 		self_check_in_wl_tree(ubi, e, &ubi->used);
1354 		rb_erase(&e->u.rb, &ubi->used);
1358 		err = prot_queue_del(ubi, e->pnum);
1360 			ubi_err(ubi, "PEB %d not found", pnum);
1361 			ubi_ro_mode(ubi);
1362 			spin_unlock(&ubi->wl_lock);
1367 	wl_tree_add(e, &ubi->scrub);
1368 	spin_unlock(&ubi->wl_lock);
1374 	return ensure_wear_leveling(ubi, 0);
1389 int ubi_wl_flush(struct ubi_device *ubi, int vol_id, int lnum)  argument
1399 	       vol_id, lnum, ubi->works_count);
1405 		down_read(&ubi->work_sem);
1406 		spin_lock(&ubi->wl_lock);
1407 		list_for_each_entry_safe(wrk, tmp, &ubi->works, list) {
1411 				ubi->works_count -= 1;
1412 				ubi_assert(ubi->works_count >= 0);
1413 				spin_unlock(&ubi->wl_lock);
1415 				err = wrk->func(ubi, wrk, 0);
1417 					up_read(&ubi->work_sem);
1421 				spin_lock(&ubi->wl_lock);
1426 		spin_unlock(&ubi->wl_lock);
1427 		up_read(&ubi->work_sem);
1434 	down_write(&ubi->work_sem);
1435 	up_write(&ubi->work_sem);
1440 static bool scrub_possible(struct ubi_device *ubi, struct ubi_wl_entry *e)  argument
1442 	if (in_wl_tree(e, &ubi->scrub))
1444 	else if (in_wl_tree(e, &ubi->erroneous))
1446 	else if (ubi->move_from == e)
1448 	else if (ubi->move_to == e)
1473 int ubi_bitflip_check(struct ubi_device *ubi, int pnum, int force)  argument
1478 	if (pnum < 0 || pnum >= ubi->peb_count) {
1487 	down_write(&ubi->work_sem);
1493 	spin_lock(&ubi->wl_lock);
1494 	e = ubi->lookuptbl[pnum];
1496 		spin_unlock(&ubi->wl_lock);
1504 	if (!scrub_possible(ubi, e)) {
1505 		spin_unlock(&ubi->wl_lock);
1509 	spin_unlock(&ubi->wl_lock);
1512 		mutex_lock(&ubi->buf_mutex);
1513 		err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
1514 		mutex_unlock(&ubi->buf_mutex);
1521 		spin_lock(&ubi->wl_lock);
1527 		e = ubi->lookuptbl[pnum];
1529 			spin_unlock(&ubi->wl_lock);
1537 		if (!scrub_possible(ubi, e)) {
1538 			spin_unlock(&ubi->wl_lock);
1543 		if (in_pq(ubi, e)) {
1544 			prot_queue_del(ubi, e->pnum);
1545 			wl_tree_add(e, &ubi->scrub);
1546 			spin_unlock(&ubi->wl_lock);
1548 			err = ensure_wear_leveling(ubi, 1);
1549 		} else if (in_wl_tree(e, &ubi->used)) {
1550 			rb_erase(&e->u.rb, &ubi->used);
1551 			wl_tree_add(e, &ubi->scrub);
1552 			spin_unlock(&ubi->wl_lock);
1554 			err = ensure_wear_leveling(ubi, 1);
1555 		} else if (in_wl_tree(e, &ubi->free)) {
1556 			rb_erase(&e->u.rb, &ubi->free);
1557 			ubi->free_count--;
1558 			spin_unlock(&ubi->wl_lock);
1564 			err = schedule_erase(ubi, e, UBI_UNKNOWN, UBI_UNKNOWN,
1567 			spin_unlock(&ubi->wl_lock);
1578 	up_write(&ubi->work_sem);
1589 static void tree_destroy(struct ubi_device *ubi, struct rb_root *root)  argument
1611 			wl_entry_destroy(ubi, e);
1623 	struct ubi_device *ubi = u;  local
1625 	ubi_msg(ubi, "background thread \"%s\" started, PID %d",
1626 		ubi->bgt_name, task_pid_nr(current));
1638 		spin_lock(&ubi->wl_lock);
1639 		if (list_empty(&ubi->works) || ubi->ro_mode ||
1640 		    !ubi->thread_enabled || ubi_dbg_is_bgt_disabled(ubi)) {
1642 			spin_unlock(&ubi->wl_lock);
1659 		spin_unlock(&ubi->wl_lock);
1661 		err = do_work(ubi);
1663 			ubi_err(ubi, "%s: work failed with error code %d",
1664 				ubi->bgt_name, err);
1670 				ubi_msg(ubi, "%s: %d consecutive failures",
1671 					ubi->bgt_name, WL_MAX_FAILURES);
1672 				ubi_ro_mode(ubi);
1673 				ubi->thread_enabled = 0;
1682 	dbg_wl("background thread \"%s\" is killed", ubi->bgt_name);
1683 	ubi->thread_enabled = 0;
1691 static void shutdown_work(struct ubi_device *ubi)  argument
1693 	while (!list_empty(&ubi->works)) {
1696 		wrk = list_entry(ubi->works.next, struct ubi_work, list);
1698 		wrk->func(ubi, wrk, 1);
1699 		ubi->works_count -= 1;
1700 		ubi_assert(ubi->works_count >= 0);
1710 static int erase_aeb(struct ubi_device *ubi, struct ubi_ainf_peb *aeb, bool sync)  argument
1721 	ubi->lookuptbl[e->pnum] = e;
1724 		err = sync_erase(ubi, e, false);
1728 		wl_tree_add(e, &ubi->free);
1729 		ubi->free_count++;
1731 		err = schedule_erase(ubi, e, aeb->vol_id, aeb->lnum, 0, false);
1739 	wl_entry_destroy(ubi, e);
1752 int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai)  argument
1760 	ubi->used = ubi->erroneous = ubi->free = ubi->scrub = RB_ROOT;
1761 	spin_lock_init(&ubi->wl_lock);
1762 	mutex_init(&ubi->move_mutex);
1763 	init_rwsem(&ubi->work_sem);
1764 	ubi->max_ec = ai->max_ec;
1765 	INIT_LIST_HEAD(&ubi->works);
1767 	sprintf(ubi->bgt_name, UBI_BGT_NAME_PATTERN, ubi->ubi_num);
1770 	ubi->lookuptbl = kcalloc(ubi->peb_count, sizeof(void *), GFP_KERNEL);
1771 	if (!ubi->lookuptbl)
1775 		INIT_LIST_HEAD(&ubi->pq[i]);
1776 	ubi->pq_head = 0;
1778 	ubi->free_count = 0;
1782 		err = erase_aeb(ubi, aeb, false);
1802 		wl_tree_add(e, &ubi->free);
1803 		ubi->free_count++;
1805 		ubi->lookuptbl[e->pnum] = e;
1822 			ubi->lookuptbl[e->pnum] = e;
1827 				wl_tree_add(e, &ubi->used);
1831 				wl_tree_add(e, &ubi->scrub);
1841 		e = ubi_find_fm_block(ubi, aeb->pnum);
1844 			ubi_assert(!ubi->lookuptbl[e->pnum]);
1845 			ubi->lookuptbl[e->pnum] = e;
1855 			if (ubi->lookuptbl[aeb->pnum])
1870 			err = erase_aeb(ubi, aeb, sync);
1880 	ubi_assert(ubi->good_peb_count == found_pebs);
1883 	ubi_fastmap_init(ubi, &reserved_pebs);
1885 	if (ubi->avail_pebs < reserved_pebs) {
1886 		ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
1887 			ubi->avail_pebs, reserved_pebs);
1888 		if (ubi->corr_peb_count)
1889 			ubi_err(ubi, "%d PEBs are corrupted and not used",
1890 				ubi->corr_peb_count);
1894 	ubi->avail_pebs -= reserved_pebs;
1895 	ubi->rsvd_pebs += reserved_pebs;
1898 	err = ensure_wear_leveling(ubi, 0);
1903 	if (!ubi->ro_mode && !ubi->fm_disabled)
1904 		ubi_ensure_anchor_pebs(ubi);
1909 	shutdown_work(ubi);
1910 	tree_destroy(ubi, &ubi->used);
1911 	tree_destroy(ubi, &ubi->free);
1912 	tree_destroy(ubi, &ubi->scrub);
1913 	kfree(ubi->lookuptbl);
1921 static void protection_queue_destroy(struct ubi_device *ubi)  argument
1927 		list_for_each_entry_safe(e, tmp, &ubi->pq[i], u.list) {
1929 			wl_entry_destroy(ubi, e);
1938 void ubi_wl_close(struct ubi_device *ubi)  argument
1941 	ubi_fastmap_close(ubi);
1942 	shutdown_work(ubi);
1943 	protection_queue_destroy(ubi);
1944 	tree_destroy(ubi, &ubi->used);
1945 	tree_destroy(ubi, &ubi->erroneous);
1946 	tree_destroy(ubi, &ubi->free);
1947 	tree_destroy(ubi, &ubi->scrub);
1948 	kfree(ubi->lookuptbl);
1961 static int self_check_ec(struct ubi_device *ubi, int pnum, int ec)  argument
1967 	if (!ubi_dbg_chk_gen(ubi))
1970 	ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1974 	err = ubi_io_read_ec_hdr(ubi, pnum, ec_hdr, 0);
1983 		ubi_err(ubi, "self-check failed for PEB %d", pnum);
1984 		ubi_err(ubi, "read EC is %lld, should be %d", read_ec, ec);
2004 static int self_check_in_wl_tree(const struct ubi_device *ubi,  argument
2007 	if (!ubi_dbg_chk_gen(ubi))
2013 	ubi_err(ubi, "self-check failed for PEB %d, EC %d, RB-tree %p ",
2027 static int self_check_in_pq(const struct ubi_device *ubi,  argument
2030 	if (!ubi_dbg_chk_gen(ubi))
2033 	if (in_pq(ubi, e))
2036 	ubi_err(ubi, "self-check failed for PEB %d, EC %d, Protect queue",
2042 static struct ubi_wl_entry *get_peb_for_wl(struct ubi_device *ubi)  argument
2046 	e = find_wl_entry(ubi, &ubi->free, WL_FREE_MAX_DIFF);
2047 	self_check_in_wl_tree(ubi, e, &ubi->free);
2048 	ubi->free_count--;
2049 	ubi_assert(ubi->free_count >= 0);
2050 	rb_erase(&e->u.rb, &ubi->free);
2064 static int produce_free_peb(struct ubi_device *ubi)  argument
2068 	while (!ubi->free.rb_node && ubi->works_count) {
2069 		spin_unlock(&ubi->wl_lock);
2072 		err = do_work(ubi);
2074 		spin_lock(&ubi->wl_lock);
2090 int ubi_wl_get_peb(struct ubi_device *ubi)  argument
2096 	down_read(&ubi->fm_eba_sem);
2097 	spin_lock(&ubi->wl_lock);
2098 	if (!ubi->free.rb_node) {
2099 		if (ubi->works_count == 0) {
2100 			ubi_err(ubi, "no free eraseblocks");
2101 			ubi_assert(list_empty(&ubi->works));
2102 			spin_unlock(&ubi->wl_lock);
2106 		err = produce_free_peb(ubi);
2108 			spin_unlock(&ubi->wl_lock);
2111 		spin_unlock(&ubi->wl_lock);
2112 		up_read(&ubi->fm_eba_sem);
2116 	e = wl_get_wle(ubi);
2117 	prot_queue_add(ubi, e);
2118 	spin_unlock(&ubi->wl_lock);
2120 	err = ubi_self_check_all_ff(ubi, e->pnum, ubi->vid_hdr_aloffset,
2121 				    ubi->peb_size - ubi->vid_hdr_aloffset);
2123 		ubi_err(ubi, "new PEB %d does not contain all 0xFF bytes", e->pnum);