xref: /openbmc/linux/drivers/mtd/ubi/eba.c (revision 92a2c6b2)
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12  * the GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Artem Bityutskiy (Битюцкий Артём)
19  */
20 
21 /*
22  * The UBI Eraseblock Association (EBA) sub-system.
23  *
24  * This sub-system is responsible for I/O to/from logical eraseblock.
25  *
26  * Although in this implementation the EBA table is fully kept and managed in
27  * RAM, which assumes poor scalability, it might be (partially) maintained on
28  * flash in future implementations.
29  *
30  * The EBA sub-system implements per-logical eraseblock locking. Before
31  * accessing a logical eraseblock it is locked for reading or writing. The
32  * per-logical eraseblock locking is implemented by means of the lock tree. The
33  * lock tree is an RB-tree which refers all the currently locked logical
34  * eraseblocks. The lock tree elements are &struct ubi_ltree_entry objects.
35  * They are indexed by (@vol_id, @lnum) pairs.
36  *
37  * EBA also maintains the global sequence counter which is incremented each
38  * time a logical eraseblock is mapped to a physical eraseblock and it is
39  * stored in the volume identifier header. This means that each VID header has
40  * a unique sequence number. The sequence number is only increased an we assume
41  * 64 bits is enough to never overflow.
42  */
43 
44 #include <linux/slab.h>
45 #include <linux/crc32.h>
46 #include <linux/err.h>
47 #include "ubi.h"
48 
49 /* Number of physical eraseblocks reserved for atomic LEB change operation */
50 #define EBA_RESERVED_PEBS 1
51 
52 /**
53  * next_sqnum - get next sequence number.
54  * @ubi: UBI device description object
55  *
56  * This function returns next sequence number to use, which is just the current
57  * global sequence counter value. It also increases the global sequence
58  * counter.
59  */
60 unsigned long long ubi_next_sqnum(struct ubi_device *ubi)
61 {
62 	unsigned long long sqnum;
63 
64 	spin_lock(&ubi->ltree_lock);
65 	sqnum = ubi->global_sqnum++;
66 	spin_unlock(&ubi->ltree_lock);
67 
68 	return sqnum;
69 }
70 
71 /**
72  * ubi_get_compat - get compatibility flags of a volume.
73  * @ubi: UBI device description object
74  * @vol_id: volume ID
75  *
76  * This function returns compatibility flags for an internal volume. User
77  * volumes have no compatibility flags, so %0 is returned.
78  */
79 static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
80 {
81 	if (vol_id == UBI_LAYOUT_VOLUME_ID)
82 		return UBI_LAYOUT_VOLUME_COMPAT;
83 	return 0;
84 }
85 
86 /**
87  * ltree_lookup - look up the lock tree.
88  * @ubi: UBI device description object
89  * @vol_id: volume ID
90  * @lnum: logical eraseblock number
91  *
92  * This function returns a pointer to the corresponding &struct ubi_ltree_entry
93  * object if the logical eraseblock is locked and %NULL if it is not.
94  * @ubi->ltree_lock has to be locked.
95  */
96 static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
97 					    int lnum)
98 {
99 	struct rb_node *p;
100 
101 	p = ubi->ltree.rb_node;
102 	while (p) {
103 		struct ubi_ltree_entry *le;
104 
105 		le = rb_entry(p, struct ubi_ltree_entry, rb);
106 
107 		if (vol_id < le->vol_id)
108 			p = p->rb_left;
109 		else if (vol_id > le->vol_id)
110 			p = p->rb_right;
111 		else {
112 			if (lnum < le->lnum)
113 				p = p->rb_left;
114 			else if (lnum > le->lnum)
115 				p = p->rb_right;
116 			else
117 				return le;
118 		}
119 	}
120 
121 	return NULL;
122 }
123 
124 /**
125  * ltree_add_entry - add new entry to the lock tree.
126  * @ubi: UBI device description object
127  * @vol_id: volume ID
128  * @lnum: logical eraseblock number
129  *
130  * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the
131  * lock tree. If such entry is already there, its usage counter is increased.
132  * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation
133  * failed.
134  */
135 static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
136 					       int vol_id, int lnum)
137 {
138 	struct ubi_ltree_entry *le, *le1, *le_free;
139 
140 	le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);
141 	if (!le)
142 		return ERR_PTR(-ENOMEM);
143 
144 	le->users = 0;
145 	init_rwsem(&le->mutex);
146 	le->vol_id = vol_id;
147 	le->lnum = lnum;
148 
149 	spin_lock(&ubi->ltree_lock);
150 	le1 = ltree_lookup(ubi, vol_id, lnum);
151 
152 	if (le1) {
153 		/*
154 		 * This logical eraseblock is already locked. The newly
155 		 * allocated lock entry is not needed.
156 		 */
157 		le_free = le;
158 		le = le1;
159 	} else {
160 		struct rb_node **p, *parent = NULL;
161 
162 		/*
163 		 * No lock entry, add the newly allocated one to the
164 		 * @ubi->ltree RB-tree.
165 		 */
166 		le_free = NULL;
167 
168 		p = &ubi->ltree.rb_node;
169 		while (*p) {
170 			parent = *p;
171 			le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
172 
173 			if (vol_id < le1->vol_id)
174 				p = &(*p)->rb_left;
175 			else if (vol_id > le1->vol_id)
176 				p = &(*p)->rb_right;
177 			else {
178 				ubi_assert(lnum != le1->lnum);
179 				if (lnum < le1->lnum)
180 					p = &(*p)->rb_left;
181 				else
182 					p = &(*p)->rb_right;
183 			}
184 		}
185 
186 		rb_link_node(&le->rb, parent, p);
187 		rb_insert_color(&le->rb, &ubi->ltree);
188 	}
189 	le->users += 1;
190 	spin_unlock(&ubi->ltree_lock);
191 
192 	kfree(le_free);
193 	return le;
194 }
195 
196 /**
197  * leb_read_lock - lock logical eraseblock for reading.
198  * @ubi: UBI device description object
199  * @vol_id: volume ID
200  * @lnum: logical eraseblock number
201  *
202  * This function locks a logical eraseblock for reading. Returns zero in case
203  * of success and a negative error code in case of failure.
204  */
205 static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
206 {
207 	struct ubi_ltree_entry *le;
208 
209 	le = ltree_add_entry(ubi, vol_id, lnum);
210 	if (IS_ERR(le))
211 		return PTR_ERR(le);
212 	down_read(&le->mutex);
213 	return 0;
214 }
215 
216 /**
217  * leb_read_unlock - unlock logical eraseblock.
218  * @ubi: UBI device description object
219  * @vol_id: volume ID
220  * @lnum: logical eraseblock number
221  */
222 static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
223 {
224 	struct ubi_ltree_entry *le;
225 
226 	spin_lock(&ubi->ltree_lock);
227 	le = ltree_lookup(ubi, vol_id, lnum);
228 	le->users -= 1;
229 	ubi_assert(le->users >= 0);
230 	up_read(&le->mutex);
231 	if (le->users == 0) {
232 		rb_erase(&le->rb, &ubi->ltree);
233 		kfree(le);
234 	}
235 	spin_unlock(&ubi->ltree_lock);
236 }
237 
238 /**
239  * leb_write_lock - lock logical eraseblock for writing.
240  * @ubi: UBI device description object
241  * @vol_id: volume ID
242  * @lnum: logical eraseblock number
243  *
244  * This function locks a logical eraseblock for writing. Returns zero in case
245  * of success and a negative error code in case of failure.
246  */
247 static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
248 {
249 	struct ubi_ltree_entry *le;
250 
251 	le = ltree_add_entry(ubi, vol_id, lnum);
252 	if (IS_ERR(le))
253 		return PTR_ERR(le);
254 	down_write(&le->mutex);
255 	return 0;
256 }
257 
258 /**
259  * leb_write_lock - lock logical eraseblock for writing.
260  * @ubi: UBI device description object
261  * @vol_id: volume ID
262  * @lnum: logical eraseblock number
263  *
264  * This function locks a logical eraseblock for writing if there is no
265  * contention and does nothing if there is contention. Returns %0 in case of
266  * success, %1 in case of contention, and and a negative error code in case of
267  * failure.
268  */
269 static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
270 {
271 	struct ubi_ltree_entry *le;
272 
273 	le = ltree_add_entry(ubi, vol_id, lnum);
274 	if (IS_ERR(le))
275 		return PTR_ERR(le);
276 	if (down_write_trylock(&le->mutex))
277 		return 0;
278 
279 	/* Contention, cancel */
280 	spin_lock(&ubi->ltree_lock);
281 	le->users -= 1;
282 	ubi_assert(le->users >= 0);
283 	if (le->users == 0) {
284 		rb_erase(&le->rb, &ubi->ltree);
285 		kfree(le);
286 	}
287 	spin_unlock(&ubi->ltree_lock);
288 
289 	return 1;
290 }
291 
292 /**
293  * leb_write_unlock - unlock logical eraseblock.
294  * @ubi: UBI device description object
295  * @vol_id: volume ID
296  * @lnum: logical eraseblock number
297  */
298 static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
299 {
300 	struct ubi_ltree_entry *le;
301 
302 	spin_lock(&ubi->ltree_lock);
303 	le = ltree_lookup(ubi, vol_id, lnum);
304 	le->users -= 1;
305 	ubi_assert(le->users >= 0);
306 	up_write(&le->mutex);
307 	if (le->users == 0) {
308 		rb_erase(&le->rb, &ubi->ltree);
309 		kfree(le);
310 	}
311 	spin_unlock(&ubi->ltree_lock);
312 }
313 
314 /**
315  * ubi_eba_unmap_leb - un-map logical eraseblock.
316  * @ubi: UBI device description object
317  * @vol: volume description object
318  * @lnum: logical eraseblock number
319  *
320  * This function un-maps logical eraseblock @lnum and schedules corresponding
321  * physical eraseblock for erasure. Returns zero in case of success and a
322  * negative error code in case of failure.
323  */
324 int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
325 		      int lnum)
326 {
327 	int err, pnum, vol_id = vol->vol_id;
328 
329 	if (ubi->ro_mode)
330 		return -EROFS;
331 
332 	err = leb_write_lock(ubi, vol_id, lnum);
333 	if (err)
334 		return err;
335 
336 	pnum = vol->eba_tbl[lnum];
337 	if (pnum < 0)
338 		/* This logical eraseblock is already unmapped */
339 		goto out_unlock;
340 
341 	dbg_eba("erase LEB %d:%d, PEB %d", vol_id, lnum, pnum);
342 
343 	down_read(&ubi->fm_sem);
344 	vol->eba_tbl[lnum] = UBI_LEB_UNMAPPED;
345 	up_read(&ubi->fm_sem);
346 	err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 0);
347 
348 out_unlock:
349 	leb_write_unlock(ubi, vol_id, lnum);
350 	return err;
351 }
352 
353 /**
354  * ubi_eba_read_leb - read data.
355  * @ubi: UBI device description object
356  * @vol: volume description object
357  * @lnum: logical eraseblock number
358  * @buf: buffer to store the read data
359  * @offset: offset from where to read
360  * @len: how many bytes to read
361  * @check: data CRC check flag
362  *
363  * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF
364  * bytes. The @check flag only makes sense for static volumes and forces
365  * eraseblock data CRC checking.
366  *
367  * In case of success this function returns zero. In case of a static volume,
368  * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be
369  * returned for any volume type if an ECC error was detected by the MTD device
370  * driver. Other negative error cored may be returned in case of other errors.
371  */
372 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
373 		     void *buf, int offset, int len, int check)
374 {
375 	int err, pnum, scrub = 0, vol_id = vol->vol_id;
376 	struct ubi_vid_hdr *vid_hdr;
377 	uint32_t uninitialized_var(crc);
378 
379 	err = leb_read_lock(ubi, vol_id, lnum);
380 	if (err)
381 		return err;
382 
383 	pnum = vol->eba_tbl[lnum];
384 	if (pnum < 0) {
385 		/*
386 		 * The logical eraseblock is not mapped, fill the whole buffer
387 		 * with 0xFF bytes. The exception is static volumes for which
388 		 * it is an error to read unmapped logical eraseblocks.
389 		 */
390 		dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",
391 			len, offset, vol_id, lnum);
392 		leb_read_unlock(ubi, vol_id, lnum);
393 		ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);
394 		memset(buf, 0xFF, len);
395 		return 0;
396 	}
397 
398 	dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",
399 		len, offset, vol_id, lnum, pnum);
400 
401 	if (vol->vol_type == UBI_DYNAMIC_VOLUME)
402 		check = 0;
403 
404 retry:
405 	if (check) {
406 		vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
407 		if (!vid_hdr) {
408 			err = -ENOMEM;
409 			goto out_unlock;
410 		}
411 
412 		err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
413 		if (err && err != UBI_IO_BITFLIPS) {
414 			if (err > 0) {
415 				/*
416 				 * The header is either absent or corrupted.
417 				 * The former case means there is a bug -
418 				 * switch to read-only mode just in case.
419 				 * The latter case means a real corruption - we
420 				 * may try to recover data. FIXME: but this is
421 				 * not implemented.
422 				 */
423 				if (err == UBI_IO_BAD_HDR_EBADMSG ||
424 				    err == UBI_IO_BAD_HDR) {
425 					ubi_warn(ubi, "corrupted VID header at PEB %d, LEB %d:%d",
426 						 pnum, vol_id, lnum);
427 					err = -EBADMSG;
428 				} else
429 					err = -EINVAL;
430 					ubi_ro_mode(ubi);
431 			}
432 			goto out_free;
433 		} else if (err == UBI_IO_BITFLIPS)
434 			scrub = 1;
435 
436 		ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs));
437 		ubi_assert(len == be32_to_cpu(vid_hdr->data_size));
438 
439 		crc = be32_to_cpu(vid_hdr->data_crc);
440 		ubi_free_vid_hdr(ubi, vid_hdr);
441 	}
442 
443 	err = ubi_io_read_data(ubi, buf, pnum, offset, len);
444 	if (err) {
445 		if (err == UBI_IO_BITFLIPS)
446 			scrub = 1;
447 		else if (mtd_is_eccerr(err)) {
448 			if (vol->vol_type == UBI_DYNAMIC_VOLUME)
449 				goto out_unlock;
450 			scrub = 1;
451 			if (!check) {
452 				ubi_msg(ubi, "force data checking");
453 				check = 1;
454 				goto retry;
455 			}
456 		} else
457 			goto out_unlock;
458 	}
459 
460 	if (check) {
461 		uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);
462 		if (crc1 != crc) {
463 			ubi_warn(ubi, "CRC error: calculated %#08x, must be %#08x",
464 				 crc1, crc);
465 			err = -EBADMSG;
466 			goto out_unlock;
467 		}
468 	}
469 
470 	if (scrub)
471 		err = ubi_wl_scrub_peb(ubi, pnum);
472 
473 	leb_read_unlock(ubi, vol_id, lnum);
474 	return err;
475 
476 out_free:
477 	ubi_free_vid_hdr(ubi, vid_hdr);
478 out_unlock:
479 	leb_read_unlock(ubi, vol_id, lnum);
480 	return err;
481 }
482 
483 /**
484  * ubi_eba_read_leb_sg - read data into a scatter gather list.
485  * @ubi: UBI device description object
486  * @vol: volume description object
487  * @lnum: logical eraseblock number
488  * @sgl: UBI scatter gather list to store the read data
489  * @offset: offset from where to read
490  * @len: how many bytes to read
491  * @check: data CRC check flag
492  *
493  * This function works exactly like ubi_eba_read_leb(). But instead of
494  * storing the read data into a buffer it writes to an UBI scatter gather
495  * list.
496  */
497 int ubi_eba_read_leb_sg(struct ubi_device *ubi, struct ubi_volume *vol,
498 			struct ubi_sgl *sgl, int lnum, int offset, int len,
499 			int check)
500 {
501 	int to_read;
502 	int ret;
503 	struct scatterlist *sg;
504 
505 	for (;;) {
506 		ubi_assert(sgl->list_pos < UBI_MAX_SG_COUNT);
507 		sg = &sgl->sg[sgl->list_pos];
508 		if (len < sg->length - sgl->page_pos)
509 			to_read = len;
510 		else
511 			to_read = sg->length - sgl->page_pos;
512 
513 		ret = ubi_eba_read_leb(ubi, vol, lnum,
514 				       sg_virt(sg) + sgl->page_pos, offset,
515 				       to_read, check);
516 		if (ret < 0)
517 			return ret;
518 
519 		offset += to_read;
520 		len -= to_read;
521 		if (!len) {
522 			sgl->page_pos += to_read;
523 			if (sgl->page_pos == sg->length) {
524 				sgl->list_pos++;
525 				sgl->page_pos = 0;
526 			}
527 
528 			break;
529 		}
530 
531 		sgl->list_pos++;
532 		sgl->page_pos = 0;
533 	}
534 
535 	return ret;
536 }
537 
538 /**
539  * recover_peb - recover from write failure.
540  * @ubi: UBI device description object
541  * @pnum: the physical eraseblock to recover
542  * @vol_id: volume ID
543  * @lnum: logical eraseblock number
544  * @buf: data which was not written because of the write failure
545  * @offset: offset of the failed write
546  * @len: how many bytes should have been written
547  *
548  * This function is called in case of a write failure and moves all good data
549  * from the potentially bad physical eraseblock to a good physical eraseblock.
550  * This function also writes the data which was not written due to the failure.
551  * Returns new physical eraseblock number in case of success, and a negative
552  * error code in case of failure.
553  */
554 static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
555 		       const void *buf, int offset, int len)
556 {
557 	int err, idx = vol_id2idx(ubi, vol_id), new_pnum, data_size, tries = 0;
558 	struct ubi_volume *vol = ubi->volumes[idx];
559 	struct ubi_vid_hdr *vid_hdr;
560 
561 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
562 	if (!vid_hdr)
563 		return -ENOMEM;
564 
565 retry:
566 	new_pnum = ubi_wl_get_peb(ubi);
567 	if (new_pnum < 0) {
568 		ubi_free_vid_hdr(ubi, vid_hdr);
569 		return new_pnum;
570 	}
571 
572 	ubi_msg(ubi, "recover PEB %d, move data to PEB %d",
573 		pnum, new_pnum);
574 
575 	err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
576 	if (err && err != UBI_IO_BITFLIPS) {
577 		if (err > 0)
578 			err = -EIO;
579 		goto out_put;
580 	}
581 
582 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
583 	err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
584 	if (err)
585 		goto write_error;
586 
587 	data_size = offset + len;
588 	mutex_lock(&ubi->buf_mutex);
589 	memset(ubi->peb_buf + offset, 0xFF, len);
590 
591 	/* Read everything before the area where the write failure happened */
592 	if (offset > 0) {
593 		err = ubi_io_read_data(ubi, ubi->peb_buf, pnum, 0, offset);
594 		if (err && err != UBI_IO_BITFLIPS)
595 			goto out_unlock;
596 	}
597 
598 	memcpy(ubi->peb_buf + offset, buf, len);
599 
600 	err = ubi_io_write_data(ubi, ubi->peb_buf, new_pnum, 0, data_size);
601 	if (err) {
602 		mutex_unlock(&ubi->buf_mutex);
603 		goto write_error;
604 	}
605 
606 	mutex_unlock(&ubi->buf_mutex);
607 	ubi_free_vid_hdr(ubi, vid_hdr);
608 
609 	down_read(&ubi->fm_sem);
610 	vol->eba_tbl[lnum] = new_pnum;
611 	up_read(&ubi->fm_sem);
612 	ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1);
613 
614 	ubi_msg(ubi, "data was successfully recovered");
615 	return 0;
616 
617 out_unlock:
618 	mutex_unlock(&ubi->buf_mutex);
619 out_put:
620 	ubi_wl_put_peb(ubi, vol_id, lnum, new_pnum, 1);
621 	ubi_free_vid_hdr(ubi, vid_hdr);
622 	return err;
623 
624 write_error:
625 	/*
626 	 * Bad luck? This physical eraseblock is bad too? Crud. Let's try to
627 	 * get another one.
628 	 */
629 	ubi_warn(ubi, "failed to write to PEB %d", new_pnum);
630 	ubi_wl_put_peb(ubi, vol_id, lnum, new_pnum, 1);
631 	if (++tries > UBI_IO_RETRIES) {
632 		ubi_free_vid_hdr(ubi, vid_hdr);
633 		return err;
634 	}
635 	ubi_msg(ubi, "try again");
636 	goto retry;
637 }
638 
639 /**
640  * ubi_eba_write_leb - write data to dynamic volume.
641  * @ubi: UBI device description object
642  * @vol: volume description object
643  * @lnum: logical eraseblock number
644  * @buf: the data to write
645  * @offset: offset within the logical eraseblock where to write
646  * @len: how many bytes to write
647  *
648  * This function writes data to logical eraseblock @lnum of a dynamic volume
649  * @vol. Returns zero in case of success and a negative error code in case
650  * of failure. In case of error, it is possible that something was still
651  * written to the flash media, but may be some garbage.
652  */
653 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
654 		      const void *buf, int offset, int len)
655 {
656 	int err, pnum, tries = 0, vol_id = vol->vol_id;
657 	struct ubi_vid_hdr *vid_hdr;
658 
659 	if (ubi->ro_mode)
660 		return -EROFS;
661 
662 	err = leb_write_lock(ubi, vol_id, lnum);
663 	if (err)
664 		return err;
665 
666 	pnum = vol->eba_tbl[lnum];
667 	if (pnum >= 0) {
668 		dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d",
669 			len, offset, vol_id, lnum, pnum);
670 
671 		err = ubi_io_write_data(ubi, buf, pnum, offset, len);
672 		if (err) {
673 			ubi_warn(ubi, "failed to write data to PEB %d", pnum);
674 			if (err == -EIO && ubi->bad_allowed)
675 				err = recover_peb(ubi, pnum, vol_id, lnum, buf,
676 						  offset, len);
677 			if (err)
678 				ubi_ro_mode(ubi);
679 		}
680 		leb_write_unlock(ubi, vol_id, lnum);
681 		return err;
682 	}
683 
684 	/*
685 	 * The logical eraseblock is not mapped. We have to get a free physical
686 	 * eraseblock and write the volume identifier header there first.
687 	 */
688 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
689 	if (!vid_hdr) {
690 		leb_write_unlock(ubi, vol_id, lnum);
691 		return -ENOMEM;
692 	}
693 
694 	vid_hdr->vol_type = UBI_VID_DYNAMIC;
695 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
696 	vid_hdr->vol_id = cpu_to_be32(vol_id);
697 	vid_hdr->lnum = cpu_to_be32(lnum);
698 	vid_hdr->compat = ubi_get_compat(ubi, vol_id);
699 	vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
700 
701 retry:
702 	pnum = ubi_wl_get_peb(ubi);
703 	if (pnum < 0) {
704 		ubi_free_vid_hdr(ubi, vid_hdr);
705 		leb_write_unlock(ubi, vol_id, lnum);
706 		return pnum;
707 	}
708 
709 	dbg_eba("write VID hdr and %d bytes at offset %d of LEB %d:%d, PEB %d",
710 		len, offset, vol_id, lnum, pnum);
711 
712 	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
713 	if (err) {
714 		ubi_warn(ubi, "failed to write VID header to LEB %d:%d, PEB %d",
715 			 vol_id, lnum, pnum);
716 		goto write_error;
717 	}
718 
719 	if (len) {
720 		err = ubi_io_write_data(ubi, buf, pnum, offset, len);
721 		if (err) {
722 			ubi_warn(ubi, "failed to write %d bytes at offset %d of LEB %d:%d, PEB %d",
723 				 len, offset, vol_id, lnum, pnum);
724 			goto write_error;
725 		}
726 	}
727 
728 	down_read(&ubi->fm_sem);
729 	vol->eba_tbl[lnum] = pnum;
730 	up_read(&ubi->fm_sem);
731 
732 	leb_write_unlock(ubi, vol_id, lnum);
733 	ubi_free_vid_hdr(ubi, vid_hdr);
734 	return 0;
735 
736 write_error:
737 	if (err != -EIO || !ubi->bad_allowed) {
738 		ubi_ro_mode(ubi);
739 		leb_write_unlock(ubi, vol_id, lnum);
740 		ubi_free_vid_hdr(ubi, vid_hdr);
741 		return err;
742 	}
743 
744 	/*
745 	 * Fortunately, this is the first write operation to this physical
746 	 * eraseblock, so just put it and request a new one. We assume that if
747 	 * this physical eraseblock went bad, the erase code will handle that.
748 	 */
749 	err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1);
750 	if (err || ++tries > UBI_IO_RETRIES) {
751 		ubi_ro_mode(ubi);
752 		leb_write_unlock(ubi, vol_id, lnum);
753 		ubi_free_vid_hdr(ubi, vid_hdr);
754 		return err;
755 	}
756 
757 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
758 	ubi_msg(ubi, "try another PEB");
759 	goto retry;
760 }
761 
762 /**
763  * ubi_eba_write_leb_st - write data to static volume.
764  * @ubi: UBI device description object
765  * @vol: volume description object
766  * @lnum: logical eraseblock number
767  * @buf: data to write
768  * @len: how many bytes to write
769  * @used_ebs: how many logical eraseblocks will this volume contain
770  *
771  * This function writes data to logical eraseblock @lnum of static volume
772  * @vol. The @used_ebs argument should contain total number of logical
773  * eraseblock in this static volume.
774  *
775  * When writing to the last logical eraseblock, the @len argument doesn't have
776  * to be aligned to the minimal I/O unit size. Instead, it has to be equivalent
777  * to the real data size, although the @buf buffer has to contain the
778  * alignment. In all other cases, @len has to be aligned.
779  *
780  * It is prohibited to write more than once to logical eraseblocks of static
781  * volumes. This function returns zero in case of success and a negative error
782  * code in case of failure.
783  */
784 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
785 			 int lnum, const void *buf, int len, int used_ebs)
786 {
787 	int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
788 	struct ubi_vid_hdr *vid_hdr;
789 	uint32_t crc;
790 
791 	if (ubi->ro_mode)
792 		return -EROFS;
793 
794 	if (lnum == used_ebs - 1)
795 		/* If this is the last LEB @len may be unaligned */
796 		len = ALIGN(data_size, ubi->min_io_size);
797 	else
798 		ubi_assert(!(len & (ubi->min_io_size - 1)));
799 
800 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
801 	if (!vid_hdr)
802 		return -ENOMEM;
803 
804 	err = leb_write_lock(ubi, vol_id, lnum);
805 	if (err) {
806 		ubi_free_vid_hdr(ubi, vid_hdr);
807 		return err;
808 	}
809 
810 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
811 	vid_hdr->vol_id = cpu_to_be32(vol_id);
812 	vid_hdr->lnum = cpu_to_be32(lnum);
813 	vid_hdr->compat = ubi_get_compat(ubi, vol_id);
814 	vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
815 
816 	crc = crc32(UBI_CRC32_INIT, buf, data_size);
817 	vid_hdr->vol_type = UBI_VID_STATIC;
818 	vid_hdr->data_size = cpu_to_be32(data_size);
819 	vid_hdr->used_ebs = cpu_to_be32(used_ebs);
820 	vid_hdr->data_crc = cpu_to_be32(crc);
821 
822 retry:
823 	pnum = ubi_wl_get_peb(ubi);
824 	if (pnum < 0) {
825 		ubi_free_vid_hdr(ubi, vid_hdr);
826 		leb_write_unlock(ubi, vol_id, lnum);
827 		return pnum;
828 	}
829 
830 	dbg_eba("write VID hdr and %d bytes at LEB %d:%d, PEB %d, used_ebs %d",
831 		len, vol_id, lnum, pnum, used_ebs);
832 
833 	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
834 	if (err) {
835 		ubi_warn(ubi, "failed to write VID header to LEB %d:%d, PEB %d",
836 			 vol_id, lnum, pnum);
837 		goto write_error;
838 	}
839 
840 	err = ubi_io_write_data(ubi, buf, pnum, 0, len);
841 	if (err) {
842 		ubi_warn(ubi, "failed to write %d bytes of data to PEB %d",
843 			 len, pnum);
844 		goto write_error;
845 	}
846 
847 	ubi_assert(vol->eba_tbl[lnum] < 0);
848 	down_read(&ubi->fm_sem);
849 	vol->eba_tbl[lnum] = pnum;
850 	up_read(&ubi->fm_sem);
851 
852 	leb_write_unlock(ubi, vol_id, lnum);
853 	ubi_free_vid_hdr(ubi, vid_hdr);
854 	return 0;
855 
856 write_error:
857 	if (err != -EIO || !ubi->bad_allowed) {
858 		/*
859 		 * This flash device does not admit of bad eraseblocks or
860 		 * something nasty and unexpected happened. Switch to read-only
861 		 * mode just in case.
862 		 */
863 		ubi_ro_mode(ubi);
864 		leb_write_unlock(ubi, vol_id, lnum);
865 		ubi_free_vid_hdr(ubi, vid_hdr);
866 		return err;
867 	}
868 
869 	err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1);
870 	if (err || ++tries > UBI_IO_RETRIES) {
871 		ubi_ro_mode(ubi);
872 		leb_write_unlock(ubi, vol_id, lnum);
873 		ubi_free_vid_hdr(ubi, vid_hdr);
874 		return err;
875 	}
876 
877 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
878 	ubi_msg(ubi, "try another PEB");
879 	goto retry;
880 }
881 
882 /*
883  * ubi_eba_atomic_leb_change - change logical eraseblock atomically.
884  * @ubi: UBI device description object
885  * @vol: volume description object
886  * @lnum: logical eraseblock number
887  * @buf: data to write
888  * @len: how many bytes to write
889  *
890  * This function changes the contents of a logical eraseblock atomically. @buf
891  * has to contain new logical eraseblock data, and @len - the length of the
892  * data, which has to be aligned. This function guarantees that in case of an
893  * unclean reboot the old contents is preserved. Returns zero in case of
894  * success and a negative error code in case of failure.
895  *
896  * UBI reserves one LEB for the "atomic LEB change" operation, so only one
897  * LEB change may be done at a time. This is ensured by @ubi->alc_mutex.
898  */
899 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
900 			      int lnum, const void *buf, int len)
901 {
902 	int err, pnum, tries = 0, vol_id = vol->vol_id;
903 	struct ubi_vid_hdr *vid_hdr;
904 	uint32_t crc;
905 
906 	if (ubi->ro_mode)
907 		return -EROFS;
908 
909 	if (len == 0) {
910 		/*
911 		 * Special case when data length is zero. In this case the LEB
912 		 * has to be unmapped and mapped somewhere else.
913 		 */
914 		err = ubi_eba_unmap_leb(ubi, vol, lnum);
915 		if (err)
916 			return err;
917 		return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0);
918 	}
919 
920 	vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
921 	if (!vid_hdr)
922 		return -ENOMEM;
923 
924 	mutex_lock(&ubi->alc_mutex);
925 	err = leb_write_lock(ubi, vol_id, lnum);
926 	if (err)
927 		goto out_mutex;
928 
929 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
930 	vid_hdr->vol_id = cpu_to_be32(vol_id);
931 	vid_hdr->lnum = cpu_to_be32(lnum);
932 	vid_hdr->compat = ubi_get_compat(ubi, vol_id);
933 	vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
934 
935 	crc = crc32(UBI_CRC32_INIT, buf, len);
936 	vid_hdr->vol_type = UBI_VID_DYNAMIC;
937 	vid_hdr->data_size = cpu_to_be32(len);
938 	vid_hdr->copy_flag = 1;
939 	vid_hdr->data_crc = cpu_to_be32(crc);
940 
941 retry:
942 	pnum = ubi_wl_get_peb(ubi);
943 	if (pnum < 0) {
944 		err = pnum;
945 		goto out_leb_unlock;
946 	}
947 
948 	dbg_eba("change LEB %d:%d, PEB %d, write VID hdr to PEB %d",
949 		vol_id, lnum, vol->eba_tbl[lnum], pnum);
950 
951 	err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
952 	if (err) {
953 		ubi_warn(ubi, "failed to write VID header to LEB %d:%d, PEB %d",
954 			 vol_id, lnum, pnum);
955 		goto write_error;
956 	}
957 
958 	err = ubi_io_write_data(ubi, buf, pnum, 0, len);
959 	if (err) {
960 		ubi_warn(ubi, "failed to write %d bytes of data to PEB %d",
961 			 len, pnum);
962 		goto write_error;
963 	}
964 
965 	if (vol->eba_tbl[lnum] >= 0) {
966 		err = ubi_wl_put_peb(ubi, vol_id, lnum, vol->eba_tbl[lnum], 0);
967 		if (err)
968 			goto out_leb_unlock;
969 	}
970 
971 	down_read(&ubi->fm_sem);
972 	vol->eba_tbl[lnum] = pnum;
973 	up_read(&ubi->fm_sem);
974 
975 out_leb_unlock:
976 	leb_write_unlock(ubi, vol_id, lnum);
977 out_mutex:
978 	mutex_unlock(&ubi->alc_mutex);
979 	ubi_free_vid_hdr(ubi, vid_hdr);
980 	return err;
981 
982 write_error:
983 	if (err != -EIO || !ubi->bad_allowed) {
984 		/*
985 		 * This flash device does not admit of bad eraseblocks or
986 		 * something nasty and unexpected happened. Switch to read-only
987 		 * mode just in case.
988 		 */
989 		ubi_ro_mode(ubi);
990 		goto out_leb_unlock;
991 	}
992 
993 	err = ubi_wl_put_peb(ubi, vol_id, lnum, pnum, 1);
994 	if (err || ++tries > UBI_IO_RETRIES) {
995 		ubi_ro_mode(ubi);
996 		goto out_leb_unlock;
997 	}
998 
999 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
1000 	ubi_msg(ubi, "try another PEB");
1001 	goto retry;
1002 }
1003 
1004 /**
1005  * is_error_sane - check whether a read error is sane.
1006  * @err: code of the error happened during reading
1007  *
1008  * This is a helper function for 'ubi_eba_copy_leb()' which is called when we
1009  * cannot read data from the target PEB (an error @err happened). If the error
1010  * code is sane, then we treat this error as non-fatal. Otherwise the error is
1011  * fatal and UBI will be switched to R/O mode later.
1012  *
1013  * The idea is that we try not to switch to R/O mode if the read error is
1014  * something which suggests there was a real read problem. E.g., %-EIO. Or a
1015  * memory allocation failed (-%ENOMEM). Otherwise, it is safer to switch to R/O
1016  * mode, simply because we do not know what happened at the MTD level, and we
1017  * cannot handle this. E.g., the underlying driver may have become crazy, and
1018  * it is safer to switch to R/O mode to preserve the data.
1019  *
1020  * And bear in mind, this is about reading from the target PEB, i.e. the PEB
1021  * which we have just written.
1022  */
1023 static int is_error_sane(int err)
1024 {
1025 	if (err == -EIO || err == -ENOMEM || err == UBI_IO_BAD_HDR ||
1026 	    err == UBI_IO_BAD_HDR_EBADMSG || err == -ETIMEDOUT)
1027 		return 0;
1028 	return 1;
1029 }
1030 
1031 /**
1032  * ubi_eba_copy_leb - copy logical eraseblock.
1033  * @ubi: UBI device description object
1034  * @from: physical eraseblock number from where to copy
1035  * @to: physical eraseblock number where to copy
1036  * @vid_hdr: VID header of the @from physical eraseblock
1037  *
1038  * This function copies logical eraseblock from physical eraseblock @from to
1039  * physical eraseblock @to. The @vid_hdr buffer may be changed by this
1040  * function. Returns:
1041  *   o %0 in case of success;
1042  *   o %MOVE_CANCEL_RACE, %MOVE_TARGET_WR_ERR, %MOVE_TARGET_BITFLIPS, etc;
1043  *   o a negative error code in case of failure.
1044  */
1045 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
1046 		     struct ubi_vid_hdr *vid_hdr)
1047 {
1048 	int err, vol_id, lnum, data_size, aldata_size, idx;
1049 	struct ubi_volume *vol;
1050 	uint32_t crc;
1051 
1052 	vol_id = be32_to_cpu(vid_hdr->vol_id);
1053 	lnum = be32_to_cpu(vid_hdr->lnum);
1054 
1055 	dbg_wl("copy LEB %d:%d, PEB %d to PEB %d", vol_id, lnum, from, to);
1056 
1057 	if (vid_hdr->vol_type == UBI_VID_STATIC) {
1058 		data_size = be32_to_cpu(vid_hdr->data_size);
1059 		aldata_size = ALIGN(data_size, ubi->min_io_size);
1060 	} else
1061 		data_size = aldata_size =
1062 			    ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
1063 
1064 	idx = vol_id2idx(ubi, vol_id);
1065 	spin_lock(&ubi->volumes_lock);
1066 	/*
1067 	 * Note, we may race with volume deletion, which means that the volume
1068 	 * this logical eraseblock belongs to might be being deleted. Since the
1069 	 * volume deletion un-maps all the volume's logical eraseblocks, it will
1070 	 * be locked in 'ubi_wl_put_peb()' and wait for the WL worker to finish.
1071 	 */
1072 	vol = ubi->volumes[idx];
1073 	spin_unlock(&ubi->volumes_lock);
1074 	if (!vol) {
1075 		/* No need to do further work, cancel */
1076 		dbg_wl("volume %d is being removed, cancel", vol_id);
1077 		return MOVE_CANCEL_RACE;
1078 	}
1079 
1080 	/*
1081 	 * We do not want anybody to write to this logical eraseblock while we
1082 	 * are moving it, so lock it.
1083 	 *
1084 	 * Note, we are using non-waiting locking here, because we cannot sleep
1085 	 * on the LEB, since it may cause deadlocks. Indeed, imagine a task is
1086 	 * unmapping the LEB which is mapped to the PEB we are going to move
1087 	 * (@from). This task locks the LEB and goes sleep in the
1088 	 * 'ubi_wl_put_peb()' function on the @ubi->move_mutex. In turn, we are
1089 	 * holding @ubi->move_mutex and go sleep on the LEB lock. So, if the
1090 	 * LEB is already locked, we just do not move it and return
1091 	 * %MOVE_RETRY. Note, we do not return %MOVE_CANCEL_RACE here because
1092 	 * we do not know the reasons of the contention - it may be just a
1093 	 * normal I/O on this LEB, so we want to re-try.
1094 	 */
1095 	err = leb_write_trylock(ubi, vol_id, lnum);
1096 	if (err) {
1097 		dbg_wl("contention on LEB %d:%d, cancel", vol_id, lnum);
1098 		return MOVE_RETRY;
1099 	}
1100 
1101 	/*
1102 	 * The LEB might have been put meanwhile, and the task which put it is
1103 	 * probably waiting on @ubi->move_mutex. No need to continue the work,
1104 	 * cancel it.
1105 	 */
1106 	if (vol->eba_tbl[lnum] != from) {
1107 		dbg_wl("LEB %d:%d is no longer mapped to PEB %d, mapped to PEB %d, cancel",
1108 		       vol_id, lnum, from, vol->eba_tbl[lnum]);
1109 		err = MOVE_CANCEL_RACE;
1110 		goto out_unlock_leb;
1111 	}
1112 
1113 	/*
1114 	 * OK, now the LEB is locked and we can safely start moving it. Since
1115 	 * this function utilizes the @ubi->peb_buf buffer which is shared
1116 	 * with some other functions - we lock the buffer by taking the
1117 	 * @ubi->buf_mutex.
1118 	 */
1119 	mutex_lock(&ubi->buf_mutex);
1120 	dbg_wl("read %d bytes of data", aldata_size);
1121 	err = ubi_io_read_data(ubi, ubi->peb_buf, from, 0, aldata_size);
1122 	if (err && err != UBI_IO_BITFLIPS) {
1123 		ubi_warn(ubi, "error %d while reading data from PEB %d",
1124 			 err, from);
1125 		err = MOVE_SOURCE_RD_ERR;
1126 		goto out_unlock_buf;
1127 	}
1128 
1129 	/*
1130 	 * Now we have got to calculate how much data we have to copy. In
1131 	 * case of a static volume it is fairly easy - the VID header contains
1132 	 * the data size. In case of a dynamic volume it is more difficult - we
1133 	 * have to read the contents, cut 0xFF bytes from the end and copy only
1134 	 * the first part. We must do this to avoid writing 0xFF bytes as it
1135 	 * may have some side-effects. And not only this. It is important not
1136 	 * to include those 0xFFs to CRC because later the they may be filled
1137 	 * by data.
1138 	 */
1139 	if (vid_hdr->vol_type == UBI_VID_DYNAMIC)
1140 		aldata_size = data_size =
1141 			ubi_calc_data_len(ubi, ubi->peb_buf, data_size);
1142 
1143 	cond_resched();
1144 	crc = crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size);
1145 	cond_resched();
1146 
1147 	/*
1148 	 * It may turn out to be that the whole @from physical eraseblock
1149 	 * contains only 0xFF bytes. Then we have to only write the VID header
1150 	 * and do not write any data. This also means we should not set
1151 	 * @vid_hdr->copy_flag, @vid_hdr->data_size, and @vid_hdr->data_crc.
1152 	 */
1153 	if (data_size > 0) {
1154 		vid_hdr->copy_flag = 1;
1155 		vid_hdr->data_size = cpu_to_be32(data_size);
1156 		vid_hdr->data_crc = cpu_to_be32(crc);
1157 	}
1158 	vid_hdr->sqnum = cpu_to_be64(ubi_next_sqnum(ubi));
1159 
1160 	err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
1161 	if (err) {
1162 		if (err == -EIO)
1163 			err = MOVE_TARGET_WR_ERR;
1164 		goto out_unlock_buf;
1165 	}
1166 
1167 	cond_resched();
1168 
1169 	/* Read the VID header back and check if it was written correctly */
1170 	err = ubi_io_read_vid_hdr(ubi, to, vid_hdr, 1);
1171 	if (err) {
1172 		if (err != UBI_IO_BITFLIPS) {
1173 			ubi_warn(ubi, "error %d while reading VID header back from PEB %d",
1174 				 err, to);
1175 			if (is_error_sane(err))
1176 				err = MOVE_TARGET_RD_ERR;
1177 		} else
1178 			err = MOVE_TARGET_BITFLIPS;
1179 		goto out_unlock_buf;
1180 	}
1181 
1182 	if (data_size > 0) {
1183 		err = ubi_io_write_data(ubi, ubi->peb_buf, to, 0, aldata_size);
1184 		if (err) {
1185 			if (err == -EIO)
1186 				err = MOVE_TARGET_WR_ERR;
1187 			goto out_unlock_buf;
1188 		}
1189 
1190 		cond_resched();
1191 
1192 		/*
1193 		 * We've written the data and are going to read it back to make
1194 		 * sure it was written correctly.
1195 		 */
1196 		memset(ubi->peb_buf, 0xFF, aldata_size);
1197 		err = ubi_io_read_data(ubi, ubi->peb_buf, to, 0, aldata_size);
1198 		if (err) {
1199 			if (err != UBI_IO_BITFLIPS) {
1200 				ubi_warn(ubi, "error %d while reading data back from PEB %d",
1201 					 err, to);
1202 				if (is_error_sane(err))
1203 					err = MOVE_TARGET_RD_ERR;
1204 			} else
1205 				err = MOVE_TARGET_BITFLIPS;
1206 			goto out_unlock_buf;
1207 		}
1208 
1209 		cond_resched();
1210 
1211 		if (crc != crc32(UBI_CRC32_INIT, ubi->peb_buf, data_size)) {
1212 			ubi_warn(ubi, "read data back from PEB %d and it is different",
1213 				 to);
1214 			err = -EINVAL;
1215 			goto out_unlock_buf;
1216 		}
1217 	}
1218 
1219 	ubi_assert(vol->eba_tbl[lnum] == from);
1220 	down_read(&ubi->fm_sem);
1221 	vol->eba_tbl[lnum] = to;
1222 	up_read(&ubi->fm_sem);
1223 
1224 out_unlock_buf:
1225 	mutex_unlock(&ubi->buf_mutex);
1226 out_unlock_leb:
1227 	leb_write_unlock(ubi, vol_id, lnum);
1228 	return err;
1229 }
1230 
1231 /**
1232  * print_rsvd_warning - warn about not having enough reserved PEBs.
1233  * @ubi: UBI device description object
1234  *
1235  * This is a helper function for 'ubi_eba_init()' which is called when UBI
1236  * cannot reserve enough PEBs for bad block handling. This function makes a
1237  * decision whether we have to print a warning or not. The algorithm is as
1238  * follows:
1239  *   o if this is a new UBI image, then just print the warning
1240  *   o if this is an UBI image which has already been used for some time, print
1241  *     a warning only if we can reserve less than 10% of the expected amount of
1242  *     the reserved PEB.
1243  *
1244  * The idea is that when UBI is used, PEBs become bad, and the reserved pool
1245  * of PEBs becomes smaller, which is normal and we do not want to scare users
1246  * with a warning every time they attach the MTD device. This was an issue
1247  * reported by real users.
1248  */
1249 static void print_rsvd_warning(struct ubi_device *ubi,
1250 			       struct ubi_attach_info *ai)
1251 {
1252 	/*
1253 	 * The 1 << 18 (256KiB) number is picked randomly, just a reasonably
1254 	 * large number to distinguish between newly flashed and used images.
1255 	 */
1256 	if (ai->max_sqnum > (1 << 18)) {
1257 		int min = ubi->beb_rsvd_level / 10;
1258 
1259 		if (!min)
1260 			min = 1;
1261 		if (ubi->beb_rsvd_pebs > min)
1262 			return;
1263 	}
1264 
1265 	ubi_warn(ubi, "cannot reserve enough PEBs for bad PEB handling, reserved %d, need %d",
1266 		 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
1267 	if (ubi->corr_peb_count)
1268 		ubi_warn(ubi, "%d PEBs are corrupted and not used",
1269 			 ubi->corr_peb_count);
1270 }
1271 
1272 /**
1273  * self_check_eba - run a self check on the EBA table constructed by fastmap.
1274  * @ubi: UBI device description object
1275  * @ai_fastmap: UBI attach info object created by fastmap
1276  * @ai_scan: UBI attach info object created by scanning
1277  *
1278  * Returns < 0 in case of an internal error, 0 otherwise.
1279  * If a bad EBA table entry was found it will be printed out and
1280  * ubi_assert() triggers.
1281  */
1282 int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap,
1283 		   struct ubi_attach_info *ai_scan)
1284 {
1285 	int i, j, num_volumes, ret = 0;
1286 	int **scan_eba, **fm_eba;
1287 	struct ubi_ainf_volume *av;
1288 	struct ubi_volume *vol;
1289 	struct ubi_ainf_peb *aeb;
1290 	struct rb_node *rb;
1291 
1292 	num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1293 
1294 	scan_eba = kmalloc(sizeof(*scan_eba) * num_volumes, GFP_KERNEL);
1295 	if (!scan_eba)
1296 		return -ENOMEM;
1297 
1298 	fm_eba = kmalloc(sizeof(*fm_eba) * num_volumes, GFP_KERNEL);
1299 	if (!fm_eba) {
1300 		kfree(scan_eba);
1301 		return -ENOMEM;
1302 	}
1303 
1304 	for (i = 0; i < num_volumes; i++) {
1305 		vol = ubi->volumes[i];
1306 		if (!vol)
1307 			continue;
1308 
1309 		scan_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**scan_eba),
1310 				      GFP_KERNEL);
1311 		if (!scan_eba[i]) {
1312 			ret = -ENOMEM;
1313 			goto out_free;
1314 		}
1315 
1316 		fm_eba[i] = kmalloc(vol->reserved_pebs * sizeof(**fm_eba),
1317 				    GFP_KERNEL);
1318 		if (!fm_eba[i]) {
1319 			ret = -ENOMEM;
1320 			goto out_free;
1321 		}
1322 
1323 		for (j = 0; j < vol->reserved_pebs; j++)
1324 			scan_eba[i][j] = fm_eba[i][j] = UBI_LEB_UNMAPPED;
1325 
1326 		av = ubi_find_av(ai_scan, idx2vol_id(ubi, i));
1327 		if (!av)
1328 			continue;
1329 
1330 		ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb)
1331 			scan_eba[i][aeb->lnum] = aeb->pnum;
1332 
1333 		av = ubi_find_av(ai_fastmap, idx2vol_id(ubi, i));
1334 		if (!av)
1335 			continue;
1336 
1337 		ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb)
1338 			fm_eba[i][aeb->lnum] = aeb->pnum;
1339 
1340 		for (j = 0; j < vol->reserved_pebs; j++) {
1341 			if (scan_eba[i][j] != fm_eba[i][j]) {
1342 				if (scan_eba[i][j] == UBI_LEB_UNMAPPED ||
1343 					fm_eba[i][j] == UBI_LEB_UNMAPPED)
1344 					continue;
1345 
1346 				ubi_err(ubi, "LEB:%i:%i is PEB:%i instead of %i!",
1347 					vol->vol_id, i, fm_eba[i][j],
1348 					scan_eba[i][j]);
1349 				ubi_assert(0);
1350 			}
1351 		}
1352 	}
1353 
1354 out_free:
1355 	for (i = 0; i < num_volumes; i++) {
1356 		if (!ubi->volumes[i])
1357 			continue;
1358 
1359 		kfree(scan_eba[i]);
1360 		kfree(fm_eba[i]);
1361 	}
1362 
1363 	kfree(scan_eba);
1364 	kfree(fm_eba);
1365 	return ret;
1366 }
1367 
1368 /**
1369  * ubi_eba_init - initialize the EBA sub-system using attaching information.
1370  * @ubi: UBI device description object
1371  * @ai: attaching information
1372  *
1373  * This function returns zero in case of success and a negative error code in
1374  * case of failure.
1375  */
1376 int ubi_eba_init(struct ubi_device *ubi, struct ubi_attach_info *ai)
1377 {
1378 	int i, j, err, num_volumes;
1379 	struct ubi_ainf_volume *av;
1380 	struct ubi_volume *vol;
1381 	struct ubi_ainf_peb *aeb;
1382 	struct rb_node *rb;
1383 
1384 	dbg_eba("initialize EBA sub-system");
1385 
1386 	spin_lock_init(&ubi->ltree_lock);
1387 	mutex_init(&ubi->alc_mutex);
1388 	ubi->ltree = RB_ROOT;
1389 
1390 	ubi->global_sqnum = ai->max_sqnum + 1;
1391 	num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1392 
1393 	for (i = 0; i < num_volumes; i++) {
1394 		vol = ubi->volumes[i];
1395 		if (!vol)
1396 			continue;
1397 
1398 		cond_resched();
1399 
1400 		vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int),
1401 				       GFP_KERNEL);
1402 		if (!vol->eba_tbl) {
1403 			err = -ENOMEM;
1404 			goto out_free;
1405 		}
1406 
1407 		for (j = 0; j < vol->reserved_pebs; j++)
1408 			vol->eba_tbl[j] = UBI_LEB_UNMAPPED;
1409 
1410 		av = ubi_find_av(ai, idx2vol_id(ubi, i));
1411 		if (!av)
1412 			continue;
1413 
1414 		ubi_rb_for_each_entry(rb, aeb, &av->root, u.rb) {
1415 			if (aeb->lnum >= vol->reserved_pebs)
1416 				/*
1417 				 * This may happen in case of an unclean reboot
1418 				 * during re-size.
1419 				 */
1420 				ubi_move_aeb_to_list(av, aeb, &ai->erase);
1421 			vol->eba_tbl[aeb->lnum] = aeb->pnum;
1422 		}
1423 	}
1424 
1425 	if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
1426 		ubi_err(ubi, "no enough physical eraseblocks (%d, need %d)",
1427 			ubi->avail_pebs, EBA_RESERVED_PEBS);
1428 		if (ubi->corr_peb_count)
1429 			ubi_err(ubi, "%d PEBs are corrupted and not used",
1430 				ubi->corr_peb_count);
1431 		err = -ENOSPC;
1432 		goto out_free;
1433 	}
1434 	ubi->avail_pebs -= EBA_RESERVED_PEBS;
1435 	ubi->rsvd_pebs += EBA_RESERVED_PEBS;
1436 
1437 	if (ubi->bad_allowed) {
1438 		ubi_calculate_reserved(ubi);
1439 
1440 		if (ubi->avail_pebs < ubi->beb_rsvd_level) {
1441 			/* No enough free physical eraseblocks */
1442 			ubi->beb_rsvd_pebs = ubi->avail_pebs;
1443 			print_rsvd_warning(ubi, ai);
1444 		} else
1445 			ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
1446 
1447 		ubi->avail_pebs -= ubi->beb_rsvd_pebs;
1448 		ubi->rsvd_pebs  += ubi->beb_rsvd_pebs;
1449 	}
1450 
1451 	dbg_eba("EBA sub-system is initialized");
1452 	return 0;
1453 
1454 out_free:
1455 	for (i = 0; i < num_volumes; i++) {
1456 		if (!ubi->volumes[i])
1457 			continue;
1458 		kfree(ubi->volumes[i]->eba_tbl);
1459 		ubi->volumes[i]->eba_tbl = NULL;
1460 	}
1461 	return err;
1462 }
1463