blob: b8b878b9182d852cf54f504bb7ad1824d5fbdd8d [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Kyungmin Park2d262c42008-11-19 16:26:54 +01002/*
3 * Copyright (c) International Business Machines Corp., 2006
4 * Copyright (c) Nokia Corporation, 2006, 2007
Kyungmin Park2d262c42008-11-19 16:26:54 +01005 *
6 * Author: Artem Bityutskiy (Битюцкий Артём)
7 */
8
9/*
Heiko Schocherff94bc42014-06-24 10:10:04 +020010 * UBI input/output sub-system.
Kyungmin Park2d262c42008-11-19 16:26:54 +010011 *
Heiko Schocherff94bc42014-06-24 10:10:04 +020012 * This sub-system provides a uniform way to work with all kinds of the
13 * underlying MTD devices. It also implements handy functions for reading and
14 * writing UBI headers.
Kyungmin Park2d262c42008-11-19 16:26:54 +010015 *
16 * We are trying to have a paranoid mindset and not to trust to what we read
Heiko Schocherff94bc42014-06-24 10:10:04 +020017 * from the flash media in order to be more secure and robust. So this
18 * sub-system validates every single header it reads from the flash media.
Kyungmin Park2d262c42008-11-19 16:26:54 +010019 *
20 * Some words about how the eraseblock headers are stored.
21 *
22 * The erase counter header is always stored at offset zero. By default, the
23 * VID header is stored after the EC header at the closest aligned offset
24 * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID
25 * header at the closest aligned offset. But this default layout may be
26 * changed. For example, for different reasons (e.g., optimization) UBI may be
27 * asked to put the VID header at further offset, and even at an unaligned
28 * offset. Of course, if the offset of the VID header is unaligned, UBI adds
29 * proper padding in front of it. Data offset may also be changed but it has to
30 * be aligned.
31 *
32 * About minimal I/O units. In general, UBI assumes flash device model where
33 * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,
34 * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the
35 * @ubi->mtd->writesize field. But as an exception, UBI admits of using another
36 * (smaller) minimal I/O unit size for EC and VID headers to make it possible
37 * to do different optimizations.
38 *
39 * This is extremely useful in case of NAND flashes which admit of several
40 * write operations to one NAND page. In this case UBI can fit EC and VID
41 * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal
42 * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still
43 * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI
44 * users.
45 *
46 * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so
47 * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID
48 * headers.
49 *
50 * Q: why not just to treat sub-page as a minimal I/O unit of this flash
51 * device, e.g., make @ubi->min_io_size = 512 in the example above?
52 *
53 * A: because when writing a sub-page, MTD still writes a full 2K page but the
Heiko Schocherff94bc42014-06-24 10:10:04 +020054 * bytes which are not relevant to the sub-page are 0xFF. So, basically,
55 * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page.
56 * Thus, we prefer to use sub-pages only for EC and VID headers.
Kyungmin Park2d262c42008-11-19 16:26:54 +010057 *
58 * As it was noted above, the VID header may start at a non-aligned offset.
59 * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page,
60 * the VID header may reside at offset 1984 which is the last 64 bytes of the
61 * last sub-page (EC header is always at offset zero). This causes some
62 * difficulties when reading and writing VID headers.
63 *
64 * Suppose we have a 64-byte buffer and we read a VID header at it. We change
65 * the data and want to write this VID header out. As we can only write in
66 * 512-byte chunks, we have to allocate one more buffer and copy our VID header
67 * to offset 448 of this buffer.
68 *
Heiko Schocherff94bc42014-06-24 10:10:04 +020069 * The I/O sub-system does the following trick in order to avoid this extra
70 * copy. It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID
71 * header and returns a pointer to offset @ubi->vid_hdr_shift of this buffer.
72 * When the VID header is being written out, it shifts the VID header pointer
73 * back and writes the whole sub-page.
Kyungmin Park2d262c42008-11-19 16:26:54 +010074 */
75
Heiko Schocherff94bc42014-06-24 10:10:04 +020076#ifndef __UBOOT__
Simon Glassf7ae49f2020-05-10 11:40:05 -060077#include <log.h>
Simon Glass61b29b82020-02-03 07:36:15 -070078#include <dm/devres.h>
Kyungmin Park2d262c42008-11-19 16:26:54 +010079#include <linux/crc32.h>
80#include <linux/err.h>
Heiko Schocherff94bc42014-06-24 10:10:04 +020081#include <linux/slab.h>
Simon Glass3db71102019-11-14 12:57:16 -070082#include <u-boot/crc.h>
Heiko Schocherff94bc42014-06-24 10:10:04 +020083#else
Alexey Brodkinf8c987f2018-06-05 17:17:57 +030084#include <hexdump.h>
Heiko Schocherff94bc42014-06-24 10:10:04 +020085#include <ubi_uboot.h>
Kyungmin Park2d262c42008-11-19 16:26:54 +010086#endif
87
Kyungmin Park2d262c42008-11-19 16:26:54 +010088#include "ubi.h"
89
Heiko Schocherff94bc42014-06-24 10:10:04 +020090static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
91static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
92static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
93 const struct ubi_ec_hdr *ec_hdr);
94static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
95static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
96 const struct ubi_vid_hdr *vid_hdr);
97static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
98 int offset, int len);
Kyungmin Park2d262c42008-11-19 16:26:54 +010099
100/**
101 * ubi_io_read - read data from a physical eraseblock.
102 * @ubi: UBI device description object
103 * @buf: buffer where to store the read data
104 * @pnum: physical eraseblock number to read from
105 * @offset: offset within the physical eraseblock from where to read
106 * @len: how many bytes to read
107 *
108 * This function reads data from offset @offset of physical eraseblock @pnum
109 * and stores the read data in the @buf buffer. The following return codes are
110 * possible:
111 *
112 * o %0 if all the requested data were successfully read;
113 * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
114 * correctable bit-flips were detected; this is harmless but may indicate
115 * that this eraseblock may become bad soon (but do not have to);
116 * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
117 * example it can be an ECC error in case of NAND; this most probably means
118 * that the data is corrupted;
119 * o %-EIO if some I/O error occurred;
120 * o other negative error codes in case of other errors.
121 */
122int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
123 int len)
124{
125 int err, retries = 0;
126 size_t read;
127 loff_t addr;
128
129 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
130
131 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
132 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
133 ubi_assert(len > 0);
134
Heiko Schocherff94bc42014-06-24 10:10:04 +0200135 err = self_check_not_bad(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100136 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200137 return err;
138
139 /*
140 * Deliberately corrupt the buffer to improve robustness. Indeed, if we
141 * do not do this, the following may happen:
142 * 1. The buffer contains data from previous operation, e.g., read from
143 * another PEB previously. The data looks like expected, e.g., if we
144 * just do not read anything and return - the caller would not
145 * notice this. E.g., if we are reading a VID header, the buffer may
146 * contain a valid VID header from another PEB.
147 * 2. The driver is buggy and returns us success or -EBADMSG or
148 * -EUCLEAN, but it does not actually put any data to the buffer.
149 *
150 * This may confuse UBI or upper layers - they may think the buffer
151 * contains valid data while in fact it is just old data. This is
152 * especially possible because UBI (and UBIFS) relies on CRC, and
153 * treats data as correct even in case of ECC errors if the CRC is
154 * correct.
155 *
156 * Try to prevent this situation by changing the first byte of the
157 * buffer.
158 */
159 *((uint8_t *)buf) ^= 0xFF;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100160
161 addr = (loff_t)pnum * ubi->peb_size + offset;
162retry:
Sergey Lapindfe64e22013-01-14 03:46:50 +0000163 err = mtd_read(ubi->mtd, addr, len, &read, buf);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100164 if (err) {
Heiko Schocherff94bc42014-06-24 10:10:04 +0200165 const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
166
167 if (mtd_is_bitflip(err)) {
Kyungmin Park2d262c42008-11-19 16:26:54 +0100168 /*
169 * -EUCLEAN is reported if there was a bit-flip which
170 * was corrected, so this is harmless.
Heiko Schocherff94bc42014-06-24 10:10:04 +0200171 *
172 * We do not report about it here unless debugging is
173 * enabled. A corresponding message will be printed
174 * later, when it is has been scrubbed.
Kyungmin Park2d262c42008-11-19 16:26:54 +0100175 */
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200176 ubi_msg(ubi, "fixable bit-flip detected at PEB %d",
177 pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100178 ubi_assert(len == read);
179 return UBI_IO_BITFLIPS;
180 }
181
Heiko Schocherff94bc42014-06-24 10:10:04 +0200182 if (retries++ < UBI_IO_RETRIES) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200183 ubi_warn(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200184 err, errstr, len, pnum, offset, read);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100185 yield();
186 goto retry;
187 }
188
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200189 ubi_err(ubi, "error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200190 err, errstr, len, pnum, offset, read);
191 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100192
193 /*
194 * The driver should never return -EBADMSG if it failed to read
195 * all the requested data. But some buggy drivers might do
196 * this, so we change it to -EIO.
197 */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200198 if (read != len && mtd_is_eccerr(err)) {
Kyungmin Park2d262c42008-11-19 16:26:54 +0100199 ubi_assert(0);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200200 err = -EIO;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100201 }
202 } else {
203 ubi_assert(len == read);
204
Heiko Schocherff94bc42014-06-24 10:10:04 +0200205 if (ubi_dbg_is_bitflip(ubi)) {
206 dbg_gen("bit-flip (emulated)");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100207 err = UBI_IO_BITFLIPS;
208 }
209 }
210
211 return err;
212}
213
214/**
215 * ubi_io_write - write data to a physical eraseblock.
216 * @ubi: UBI device description object
217 * @buf: buffer with the data to write
218 * @pnum: physical eraseblock number to write to
219 * @offset: offset within the physical eraseblock where to write
220 * @len: how many bytes to write
221 *
222 * This function writes @len bytes of data from buffer @buf to offset @offset
223 * of physical eraseblock @pnum. If all the data were successfully written,
224 * zero is returned. If an error occurred, this function returns a negative
225 * error code. If %-EIO is returned, the physical eraseblock most probably went
226 * bad.
227 *
228 * Note, in case of an error, it is possible that something was still written
229 * to the flash media, but may be some garbage.
230 */
231int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
232 int len)
233{
234 int err;
235 size_t written;
236 loff_t addr;
237
238 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
239
240 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
241 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
242 ubi_assert(offset % ubi->hdrs_min_io_size == 0);
243 ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
244
245 if (ubi->ro_mode) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200246 ubi_err(ubi, "read-only mode");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100247 return -EROFS;
248 }
249
Heiko Schocherff94bc42014-06-24 10:10:04 +0200250 err = self_check_not_bad(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100251 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200252 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100253
254 /* The area we are writing to has to contain all 0xFF bytes */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200255 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100256 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200257 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100258
259 if (offset >= ubi->leb_start) {
260 /*
261 * We write to the data area of the physical eraseblock. Make
262 * sure it has valid EC and VID headers.
263 */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200264 err = self_check_peb_ec_hdr(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100265 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200266 return err;
267 err = self_check_peb_vid_hdr(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100268 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200269 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100270 }
271
Heiko Schocherff94bc42014-06-24 10:10:04 +0200272 if (ubi_dbg_is_write_failure(ubi)) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200273 ubi_err(ubi, "cannot write %d bytes to PEB %d:%d (emulated)",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200274 len, pnum, offset);
275 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100276 return -EIO;
277 }
278
279 addr = (loff_t)pnum * ubi->peb_size + offset;
Sergey Lapindfe64e22013-01-14 03:46:50 +0000280 err = mtd_write(ubi->mtd, addr, len, &written, buf);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100281 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200282 ubi_err(ubi, "error %d while writing %d bytes to PEB %d:%d, written %zd bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200283 err, len, pnum, offset, written);
284 dump_stack();
285 ubi_dump_flash(ubi, pnum, offset, len);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100286 } else
287 ubi_assert(written == len);
288
Heiko Schocherff94bc42014-06-24 10:10:04 +0200289 if (!err) {
290 err = self_check_write(ubi, buf, pnum, offset, len);
291 if (err)
292 return err;
293
294 /*
295 * Since we always write sequentially, the rest of the PEB has
296 * to contain only 0xFF bytes.
297 */
298 offset += len;
299 len = ubi->peb_size - offset;
300 if (len)
301 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
302 }
303
Kyungmin Park2d262c42008-11-19 16:26:54 +0100304 return err;
305}
306
307/**
308 * erase_callback - MTD erasure call-back.
309 * @ei: MTD erase information object.
310 *
311 * Note, even though MTD erase interface is asynchronous, all the current
312 * implementations are synchronous anyway.
313 */
314static void erase_callback(struct erase_info *ei)
315{
316 wake_up_interruptible((wait_queue_head_t *)ei->priv);
317}
318
319/**
320 * do_sync_erase - synchronously erase a physical eraseblock.
321 * @ubi: UBI device description object
322 * @pnum: the physical eraseblock number to erase
323 *
324 * This function synchronously erases physical eraseblock @pnum and returns
325 * zero in case of success and a negative error code in case of failure. If
326 * %-EIO is returned, the physical eraseblock most probably went bad.
327 */
328static int do_sync_erase(struct ubi_device *ubi, int pnum)
329{
330 int err, retries = 0;
331 struct erase_info ei;
332 wait_queue_head_t wq;
333
334 dbg_io("erase PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200335 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
336
337 if (ubi->ro_mode) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200338 ubi_err(ubi, "read-only mode");
Heiko Schocherff94bc42014-06-24 10:10:04 +0200339 return -EROFS;
340 }
Kyungmin Park2d262c42008-11-19 16:26:54 +0100341
342retry:
343 init_waitqueue_head(&wq);
344 memset(&ei, 0, sizeof(struct erase_info));
345
346 ei.mtd = ubi->mtd;
347 ei.addr = (loff_t)pnum * ubi->peb_size;
348 ei.len = ubi->peb_size;
349 ei.callback = erase_callback;
350 ei.priv = (unsigned long)&wq;
351
Sergey Lapindfe64e22013-01-14 03:46:50 +0000352 err = mtd_erase(ubi->mtd, &ei);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100353 if (err) {
354 if (retries++ < UBI_IO_RETRIES) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200355 ubi_warn(ubi, "error %d while erasing PEB %d, retry",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200356 err, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100357 yield();
358 goto retry;
359 }
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200360 ubi_err(ubi, "cannot erase PEB %d, error %d", pnum, err);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200361 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100362 return err;
363 }
364
365 err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
366 ei.state == MTD_ERASE_FAILED);
367 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200368 ubi_err(ubi, "interrupted PEB %d erasure", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100369 return -EINTR;
370 }
371
372 if (ei.state == MTD_ERASE_FAILED) {
373 if (retries++ < UBI_IO_RETRIES) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200374 ubi_warn(ubi, "error while erasing PEB %d, retry",
375 pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100376 yield();
377 goto retry;
378 }
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200379 ubi_err(ubi, "cannot erase PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200380 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100381 return -EIO;
382 }
383
Heiko Schocherff94bc42014-06-24 10:10:04 +0200384 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100385 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200386 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100387
Heiko Schocherff94bc42014-06-24 10:10:04 +0200388 if (ubi_dbg_is_erase_failure(ubi)) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200389 ubi_err(ubi, "cannot erase PEB %d (emulated)", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100390 return -EIO;
391 }
392
393 return 0;
394}
395
Kyungmin Park2d262c42008-11-19 16:26:54 +0100396/* Patterns to write to a physical eraseblock when torturing it */
397static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
398
399/**
400 * torture_peb - test a supposedly bad physical eraseblock.
401 * @ubi: UBI device description object
402 * @pnum: the physical eraseblock number to test
403 *
404 * This function returns %-EIO if the physical eraseblock did not pass the
405 * test, a positive number of erase operations done if the test was
406 * successfully passed, and other negative error codes in case of other errors.
407 */
408static int torture_peb(struct ubi_device *ubi, int pnum)
409{
410 int err, i, patt_count;
411
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200412 ubi_msg(ubi, "run torture test for PEB %d", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100413 patt_count = ARRAY_SIZE(patterns);
414 ubi_assert(patt_count > 0);
415
416 mutex_lock(&ubi->buf_mutex);
417 for (i = 0; i < patt_count; i++) {
418 err = do_sync_erase(ubi, pnum);
419 if (err)
420 goto out;
421
422 /* Make sure the PEB contains only 0xFF bytes */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200423 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100424 if (err)
425 goto out;
426
Heiko Schocherff94bc42014-06-24 10:10:04 +0200427 err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100428 if (err == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200429 ubi_err(ubi, "erased PEB %d, but a non-0xFF byte found",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100430 pnum);
431 err = -EIO;
432 goto out;
433 }
434
435 /* Write a pattern and check it */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200436 memset(ubi->peb_buf, patterns[i], ubi->peb_size);
437 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100438 if (err)
439 goto out;
440
Heiko Schocherff94bc42014-06-24 10:10:04 +0200441 memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);
442 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100443 if (err)
444 goto out;
445
Heiko Schocherff94bc42014-06-24 10:10:04 +0200446 err = ubi_check_pattern(ubi->peb_buf, patterns[i],
447 ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100448 if (err == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200449 ubi_err(ubi, "pattern %x checking failed for PEB %d",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100450 patterns[i], pnum);
451 err = -EIO;
452 goto out;
453 }
454 }
455
456 err = patt_count;
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200457 ubi_msg(ubi, "PEB %d passed torture test, do not mark it as bad", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100458
459out:
460 mutex_unlock(&ubi->buf_mutex);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200461 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
Kyungmin Park2d262c42008-11-19 16:26:54 +0100462 /*
463 * If a bit-flip or data integrity error was detected, the test
464 * has not passed because it happened on a freshly erased
465 * physical eraseblock which means something is wrong with it.
466 */
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200467 ubi_err(ubi, "read problems on freshly erased PEB %d, must be bad",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100468 pnum);
469 err = -EIO;
470 }
471 return err;
472}
473
474/**
Heiko Schocherff94bc42014-06-24 10:10:04 +0200475 * nor_erase_prepare - prepare a NOR flash PEB for erasure.
476 * @ubi: UBI device description object
477 * @pnum: physical eraseblock number to prepare
478 *
479 * NOR flash, or at least some of them, have peculiar embedded PEB erasure
480 * algorithm: the PEB is first filled with zeroes, then it is erased. And
481 * filling with zeroes starts from the end of the PEB. This was observed with
482 * Spansion S29GL512N NOR flash.
483 *
484 * This means that in case of a power cut we may end up with intact data at the
485 * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
486 * EC and VID headers are OK, but a large chunk of data at the end of PEB is
487 * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
488 * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
489 *
490 * This function is called before erasing NOR PEBs and it zeroes out EC and VID
491 * magic numbers in order to invalidate them and prevent the failures. Returns
492 * zero in case of success and a negative error code in case of failure.
493 */
494static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
495{
496 int err;
497 size_t written;
498 loff_t addr;
499 uint32_t data = 0;
500 struct ubi_ec_hdr ec_hdr;
501
502 /*
503 * Note, we cannot generally define VID header buffers on stack,
504 * because of the way we deal with these buffers (see the header
505 * comment in this file). But we know this is a NOR-specific piece of
506 * code, so we can do this. But yes, this is error-prone and we should
507 * (pre-)allocate VID header buffer instead.
508 */
509 struct ubi_vid_hdr vid_hdr;
510
511 /*
512 * If VID or EC is valid, we have to corrupt them before erasing.
513 * It is important to first invalidate the EC header, and then the VID
514 * header. Otherwise a power cut may lead to valid EC header and
515 * invalid VID header, in which case UBI will treat this PEB as
516 * corrupted and will try to preserve it, and print scary warnings.
517 */
518 addr = (loff_t)pnum * ubi->peb_size;
519 err = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
520 if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
521 err != UBI_IO_FF){
522 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
523 if(err)
524 goto error;
525 }
526
527 err = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
528 if (err != UBI_IO_BAD_HDR_EBADMSG && err != UBI_IO_BAD_HDR &&
529 err != UBI_IO_FF){
530 addr += ubi->vid_hdr_aloffset;
531 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
532 if (err)
533 goto error;
534 }
535 return 0;
536
537error:
538 /*
539 * The PEB contains a valid VID or EC header, but we cannot invalidate
540 * it. Supposedly the flash media or the driver is screwed up, so
541 * return an error.
542 */
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200543 ubi_err(ubi, "cannot invalidate PEB %d, write returned %d", pnum, err);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200544 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
545 return -EIO;
546}
547
548/**
Kyungmin Park2d262c42008-11-19 16:26:54 +0100549 * ubi_io_sync_erase - synchronously erase a physical eraseblock.
550 * @ubi: UBI device description object
551 * @pnum: physical eraseblock number to erase
552 * @torture: if this physical eraseblock has to be tortured
553 *
554 * This function synchronously erases physical eraseblock @pnum. If @torture
555 * flag is not zero, the physical eraseblock is checked by means of writing
556 * different patterns to it and reading them back. If the torturing is enabled,
Heiko Schocherff94bc42014-06-24 10:10:04 +0200557 * the physical eraseblock is erased more than once.
Kyungmin Park2d262c42008-11-19 16:26:54 +0100558 *
559 * This function returns the number of erasures made in case of success, %-EIO
560 * if the erasure failed or the torturing test failed, and other negative error
561 * codes in case of other errors. Note, %-EIO means that the physical
562 * eraseblock is bad.
563 */
564int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
565{
566 int err, ret = 0;
567
568 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
569
Heiko Schocherff94bc42014-06-24 10:10:04 +0200570 err = self_check_not_bad(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100571 if (err != 0)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200572 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100573
574 if (ubi->ro_mode) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200575 ubi_err(ubi, "read-only mode");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100576 return -EROFS;
577 }
578
Heiko Schocherff94bc42014-06-24 10:10:04 +0200579 if (ubi->nor_flash) {
580 err = nor_erase_prepare(ubi, pnum);
581 if (err)
582 return err;
583 }
584
Kyungmin Park2d262c42008-11-19 16:26:54 +0100585 if (torture) {
586 ret = torture_peb(ubi, pnum);
587 if (ret < 0)
588 return ret;
589 }
590
591 err = do_sync_erase(ubi, pnum);
592 if (err)
593 return err;
594
595 return ret + 1;
596}
597
598/**
599 * ubi_io_is_bad - check if a physical eraseblock is bad.
600 * @ubi: UBI device description object
601 * @pnum: the physical eraseblock number to check
602 *
603 * This function returns a positive number if the physical eraseblock is bad,
604 * zero if not, and a negative error code if an error occurred.
605 */
606int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
607{
608 struct mtd_info *mtd = ubi->mtd;
609
610 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
611
612 if (ubi->bad_allowed) {
613 int ret;
614
Sergey Lapindfe64e22013-01-14 03:46:50 +0000615 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100616 if (ret < 0)
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200617 ubi_err(ubi, "error %d while checking if PEB %d is bad",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100618 ret, pnum);
619 else if (ret)
620 dbg_io("PEB %d is bad", pnum);
621 return ret;
622 }
623
624 return 0;
625}
626
627/**
628 * ubi_io_mark_bad - mark a physical eraseblock as bad.
629 * @ubi: UBI device description object
630 * @pnum: the physical eraseblock number to mark
631 *
632 * This function returns zero in case of success and a negative error code in
633 * case of failure.
634 */
635int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
636{
637 int err;
638 struct mtd_info *mtd = ubi->mtd;
639
640 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
641
642 if (ubi->ro_mode) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200643 ubi_err(ubi, "read-only mode");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100644 return -EROFS;
645 }
646
647 if (!ubi->bad_allowed)
648 return 0;
649
Sergey Lapindfe64e22013-01-14 03:46:50 +0000650 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100651 if (err)
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200652 ubi_err(ubi, "cannot mark PEB %d bad, error %d", pnum, err);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100653 return err;
654}
655
656/**
657 * validate_ec_hdr - validate an erase counter header.
658 * @ubi: UBI device description object
659 * @ec_hdr: the erase counter header to check
660 *
661 * This function returns zero if the erase counter header is OK, and %1 if
662 * not.
663 */
664static int validate_ec_hdr(const struct ubi_device *ubi,
665 const struct ubi_ec_hdr *ec_hdr)
666{
667 long long ec;
668 int vid_hdr_offset, leb_start;
669
670 ec = be64_to_cpu(ec_hdr->ec);
671 vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
672 leb_start = be32_to_cpu(ec_hdr->data_offset);
673
674 if (ec_hdr->version != UBI_VERSION) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200675 ubi_err(ubi, "node with incompatible UBI version found: this UBI version is %d, image version is %d",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100676 UBI_VERSION, (int)ec_hdr->version);
677 goto bad;
678 }
679
680 if (vid_hdr_offset != ubi->vid_hdr_offset) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200681 ubi_err(ubi, "bad VID header offset %d, expected %d",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100682 vid_hdr_offset, ubi->vid_hdr_offset);
683 goto bad;
684 }
685
686 if (leb_start != ubi->leb_start) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200687 ubi_err(ubi, "bad data offset %d, expected %d",
Kyungmin Park2d262c42008-11-19 16:26:54 +0100688 leb_start, ubi->leb_start);
689 goto bad;
690 }
691
692 if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200693 ubi_err(ubi, "bad erase counter %lld", ec);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100694 goto bad;
695 }
696
697 return 0;
698
699bad:
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200700 ubi_err(ubi, "bad EC header");
Heiko Schocherff94bc42014-06-24 10:10:04 +0200701 ubi_dump_ec_hdr(ec_hdr);
702 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100703 return 1;
704}
705
706/**
707 * ubi_io_read_ec_hdr - read and check an erase counter header.
708 * @ubi: UBI device description object
709 * @pnum: physical eraseblock to read from
710 * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
711 * header
712 * @verbose: be verbose if the header is corrupted or was not found
713 *
714 * This function reads erase counter header from physical eraseblock @pnum and
715 * stores it in @ec_hdr. This function also checks CRC checksum of the read
716 * erase counter header. The following codes may be returned:
717 *
718 * o %0 if the CRC checksum is correct and the header was successfully read;
719 * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
720 * and corrected by the flash driver; this is harmless but may indicate that
721 * this eraseblock may become bad soon (but may be not);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200722 * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
723 * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
724 * a data integrity error (uncorrectable ECC error in case of NAND);
725 * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
Kyungmin Park2d262c42008-11-19 16:26:54 +0100726 * o a negative error code in case of failure.
727 */
728int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
729 struct ubi_ec_hdr *ec_hdr, int verbose)
730{
Heiko Schocherff94bc42014-06-24 10:10:04 +0200731 int err, read_err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100732 uint32_t crc, magic, hdr_crc;
733
734 dbg_io("read EC header from PEB %d", pnum);
735 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100736
Heiko Schocherff94bc42014-06-24 10:10:04 +0200737 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
738 if (read_err) {
739 if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
740 return read_err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100741
742 /*
743 * We read all the data, but either a correctable bit-flip
Heiko Schocherff94bc42014-06-24 10:10:04 +0200744 * occurred, or MTD reported a data integrity error
745 * (uncorrectable ECC error in case of NAND). The former is
746 * harmless, the later may mean that the read data is
747 * corrupted. But we have a CRC check-sum and we will detect
748 * this. If the EC header is still OK, we just report this as
749 * there was a bit-flip, to force scrubbing.
Kyungmin Park2d262c42008-11-19 16:26:54 +0100750 */
Kyungmin Park2d262c42008-11-19 16:26:54 +0100751 }
752
753 magic = be32_to_cpu(ec_hdr->magic);
754 if (magic != UBI_EC_HDR_MAGIC) {
Heiko Schocherff94bc42014-06-24 10:10:04 +0200755 if (mtd_is_eccerr(read_err))
756 return UBI_IO_BAD_HDR_EBADMSG;
757
Kyungmin Park2d262c42008-11-19 16:26:54 +0100758 /*
759 * The magic field is wrong. Let's check if we have read all
760 * 0xFF. If yes, this physical eraseblock is assumed to be
761 * empty.
Kyungmin Park2d262c42008-11-19 16:26:54 +0100762 */
Heiko Schocherff94bc42014-06-24 10:10:04 +0200763 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
Kyungmin Park2d262c42008-11-19 16:26:54 +0100764 /* The physical eraseblock is supposedly empty */
Kyungmin Park2d262c42008-11-19 16:26:54 +0100765 if (verbose)
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200766 ubi_warn(ubi, "no EC header found at PEB %d, only 0xFF bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200767 pnum);
768 dbg_bld("no EC header found at PEB %d, only 0xFF bytes",
769 pnum);
770 if (!read_err)
771 return UBI_IO_FF;
772 else
773 return UBI_IO_FF_BITFLIPS;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100774 }
775
776 /*
777 * This is not a valid erase counter header, and these are not
778 * 0xFF bytes. Report that the header is corrupted.
779 */
780 if (verbose) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200781 ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200782 pnum, magic, UBI_EC_HDR_MAGIC);
783 ubi_dump_ec_hdr(ec_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100784 }
Heiko Schocherff94bc42014-06-24 10:10:04 +0200785 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
786 pnum, magic, UBI_EC_HDR_MAGIC);
787 return UBI_IO_BAD_HDR;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100788 }
789
790 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
791 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
792
793 if (hdr_crc != crc) {
794 if (verbose) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200795 ubi_warn(ubi, "bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
Heiko Schocherff94bc42014-06-24 10:10:04 +0200796 pnum, crc, hdr_crc);
797 ubi_dump_ec_hdr(ec_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100798 }
Heiko Schocherff94bc42014-06-24 10:10:04 +0200799 dbg_bld("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
800 pnum, crc, hdr_crc);
801
802 if (!read_err)
803 return UBI_IO_BAD_HDR;
804 else
805 return UBI_IO_BAD_HDR_EBADMSG;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100806 }
807
808 /* And of course validate what has just been read from the media */
809 err = validate_ec_hdr(ubi, ec_hdr);
810 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200811 ubi_err(ubi, "validation failed for PEB %d", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100812 return -EINVAL;
813 }
814
Heiko Schocherff94bc42014-06-24 10:10:04 +0200815 /*
816 * If there was %-EBADMSG, but the header CRC is still OK, report about
817 * a bit-flip to force scrubbing on this PEB.
818 */
Kyungmin Park2d262c42008-11-19 16:26:54 +0100819 return read_err ? UBI_IO_BITFLIPS : 0;
820}
821
822/**
823 * ubi_io_write_ec_hdr - write an erase counter header.
824 * @ubi: UBI device description object
825 * @pnum: physical eraseblock to write to
826 * @ec_hdr: the erase counter header to write
827 *
828 * This function writes erase counter header described by @ec_hdr to physical
829 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
830 * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
831 * field.
832 *
833 * This function returns zero in case of success and a negative error code in
834 * case of failure. If %-EIO is returned, the physical eraseblock most probably
835 * went bad.
836 */
837int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
838 struct ubi_ec_hdr *ec_hdr)
839{
840 int err;
841 uint32_t crc;
842
843 dbg_io("write EC header to PEB %d", pnum);
844 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
845
846 ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
847 ec_hdr->version = UBI_VERSION;
848 ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
849 ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
Heiko Schocherff94bc42014-06-24 10:10:04 +0200850 ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100851 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
852 ec_hdr->hdr_crc = cpu_to_be32(crc);
853
Heiko Schocherff94bc42014-06-24 10:10:04 +0200854 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +0100855 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +0200856 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +0100857
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200858 if (ubi_dbg_power_cut(ubi, POWER_CUT_EC_WRITE))
859 return -EROFS;
860
Kyungmin Park2d262c42008-11-19 16:26:54 +0100861 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
862 return err;
863}
864
865/**
866 * validate_vid_hdr - validate a volume identifier header.
867 * @ubi: UBI device description object
868 * @vid_hdr: the volume identifier header to check
869 *
870 * This function checks that data stored in the volume identifier header
871 * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
872 */
873static int validate_vid_hdr(const struct ubi_device *ubi,
874 const struct ubi_vid_hdr *vid_hdr)
875{
876 int vol_type = vid_hdr->vol_type;
877 int copy_flag = vid_hdr->copy_flag;
878 int vol_id = be32_to_cpu(vid_hdr->vol_id);
879 int lnum = be32_to_cpu(vid_hdr->lnum);
880 int compat = vid_hdr->compat;
881 int data_size = be32_to_cpu(vid_hdr->data_size);
882 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
883 int data_pad = be32_to_cpu(vid_hdr->data_pad);
884 int data_crc = be32_to_cpu(vid_hdr->data_crc);
885 int usable_leb_size = ubi->leb_size - data_pad;
886
887 if (copy_flag != 0 && copy_flag != 1) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200888 ubi_err(ubi, "bad copy_flag");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100889 goto bad;
890 }
891
892 if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
893 data_pad < 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200894 ubi_err(ubi, "negative values");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100895 goto bad;
896 }
897
898 if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200899 ubi_err(ubi, "bad vol_id");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100900 goto bad;
901 }
902
903 if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200904 ubi_err(ubi, "bad compat");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100905 goto bad;
906 }
907
908 if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
909 compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
910 compat != UBI_COMPAT_REJECT) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200911 ubi_err(ubi, "bad compat");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100912 goto bad;
913 }
914
915 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200916 ubi_err(ubi, "bad vol_type");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100917 goto bad;
918 }
919
920 if (data_pad >= ubi->leb_size / 2) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200921 ubi_err(ubi, "bad data_pad");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100922 goto bad;
923 }
924
925 if (vol_type == UBI_VID_STATIC) {
926 /*
927 * Although from high-level point of view static volumes may
928 * contain zero bytes of data, but no VID headers can contain
929 * zero at these fields, because they empty volumes do not have
930 * mapped logical eraseblocks.
931 */
932 if (used_ebs == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200933 ubi_err(ubi, "zero used_ebs");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100934 goto bad;
935 }
936 if (data_size == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200937 ubi_err(ubi, "zero data_size");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100938 goto bad;
939 }
940 if (lnum < used_ebs - 1) {
941 if (data_size != usable_leb_size) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200942 ubi_err(ubi, "bad data_size");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100943 goto bad;
944 }
945 } else if (lnum == used_ebs - 1) {
946 if (data_size == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200947 ubi_err(ubi, "bad data_size at last LEB");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100948 goto bad;
949 }
950 } else {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200951 ubi_err(ubi, "too high lnum");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100952 goto bad;
953 }
954 } else {
955 if (copy_flag == 0) {
956 if (data_crc != 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200957 ubi_err(ubi, "non-zero data CRC");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100958 goto bad;
959 }
960 if (data_size != 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200961 ubi_err(ubi, "non-zero data_size");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100962 goto bad;
963 }
964 } else {
965 if (data_size == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200966 ubi_err(ubi, "zero data_size of copy");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100967 goto bad;
968 }
969 }
970 if (used_ebs != 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200971 ubi_err(ubi, "bad used_ebs");
Kyungmin Park2d262c42008-11-19 16:26:54 +0100972 goto bad;
973 }
974 }
975
976 return 0;
977
978bad:
Heiko Schocher0195a7b2015-10-22 06:19:21 +0200979 ubi_err(ubi, "bad VID header");
Heiko Schocherff94bc42014-06-24 10:10:04 +0200980 ubi_dump_vid_hdr(vid_hdr);
981 dump_stack();
Kyungmin Park2d262c42008-11-19 16:26:54 +0100982 return 1;
983}
984
985/**
986 * ubi_io_read_vid_hdr - read and check a volume identifier header.
987 * @ubi: UBI device description object
988 * @pnum: physical eraseblock number to read from
989 * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
990 * identifier header
991 * @verbose: be verbose if the header is corrupted or wasn't found
992 *
993 * This function reads the volume identifier header from physical eraseblock
994 * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
Heiko Schocherff94bc42014-06-24 10:10:04 +0200995 * volume identifier header. The error codes are the same as in
996 * 'ubi_io_read_ec_hdr()'.
Kyungmin Park2d262c42008-11-19 16:26:54 +0100997 *
Heiko Schocherff94bc42014-06-24 10:10:04 +0200998 * Note, the implementation of this function is also very similar to
999 * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001000 */
1001int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
1002 struct ubi_vid_hdr *vid_hdr, int verbose)
1003{
Heiko Schocherff94bc42014-06-24 10:10:04 +02001004 int err, read_err;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001005 uint32_t crc, magic, hdr_crc;
1006 void *p;
1007
1008 dbg_io("read VID header from PEB %d", pnum);
1009 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001010
1011 p = (char *)vid_hdr - ubi->vid_hdr_shift;
Heiko Schocherff94bc42014-06-24 10:10:04 +02001012 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
Kyungmin Park2d262c42008-11-19 16:26:54 +01001013 ubi->vid_hdr_alsize);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001014 if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
1015 return read_err;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001016
1017 magic = be32_to_cpu(vid_hdr->magic);
1018 if (magic != UBI_VID_HDR_MAGIC) {
Heiko Schocherff94bc42014-06-24 10:10:04 +02001019 if (mtd_is_eccerr(read_err))
1020 return UBI_IO_BAD_HDR_EBADMSG;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001021
Heiko Schocherff94bc42014-06-24 10:10:04 +02001022 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
Kyungmin Park2d262c42008-11-19 16:26:54 +01001023 if (verbose)
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001024 ubi_warn(ubi, "no VID header found at PEB %d, only 0xFF bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001025 pnum);
1026 dbg_bld("no VID header found at PEB %d, only 0xFF bytes",
1027 pnum);
1028 if (!read_err)
1029 return UBI_IO_FF;
1030 else
1031 return UBI_IO_FF_BITFLIPS;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001032 }
1033
Kyungmin Park2d262c42008-11-19 16:26:54 +01001034 if (verbose) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001035 ubi_warn(ubi, "bad magic number at PEB %d: %08x instead of %08x",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001036 pnum, magic, UBI_VID_HDR_MAGIC);
1037 ubi_dump_vid_hdr(vid_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001038 }
Heiko Schocherff94bc42014-06-24 10:10:04 +02001039 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
1040 pnum, magic, UBI_VID_HDR_MAGIC);
1041 return UBI_IO_BAD_HDR;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001042 }
1043
1044 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1045 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1046
1047 if (hdr_crc != crc) {
1048 if (verbose) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001049 ubi_warn(ubi, "bad CRC at PEB %d, calculated %#08x, read %#08x",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001050 pnum, crc, hdr_crc);
1051 ubi_dump_vid_hdr(vid_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001052 }
Heiko Schocherff94bc42014-06-24 10:10:04 +02001053 dbg_bld("bad CRC at PEB %d, calculated %#08x, read %#08x",
1054 pnum, crc, hdr_crc);
1055 if (!read_err)
1056 return UBI_IO_BAD_HDR;
1057 else
1058 return UBI_IO_BAD_HDR_EBADMSG;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001059 }
1060
Kyungmin Park2d262c42008-11-19 16:26:54 +01001061 err = validate_vid_hdr(ubi, vid_hdr);
1062 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001063 ubi_err(ubi, "validation failed for PEB %d", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001064 return -EINVAL;
1065 }
1066
1067 return read_err ? UBI_IO_BITFLIPS : 0;
1068}
1069
1070/**
1071 * ubi_io_write_vid_hdr - write a volume identifier header.
1072 * @ubi: UBI device description object
1073 * @pnum: the physical eraseblock number to write to
1074 * @vid_hdr: the volume identifier header to write
1075 *
1076 * This function writes the volume identifier header described by @vid_hdr to
1077 * physical eraseblock @pnum. This function automatically fills the
1078 * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1079 * header CRC checksum and stores it at vid_hdr->hdr_crc.
1080 *
1081 * This function returns zero in case of success and a negative error code in
1082 * case of failure. If %-EIO is returned, the physical eraseblock probably went
1083 * bad.
1084 */
1085int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
1086 struct ubi_vid_hdr *vid_hdr)
1087{
1088 int err;
1089 uint32_t crc;
1090 void *p;
1091
1092 dbg_io("write VID header to PEB %d", pnum);
1093 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1094
Heiko Schocherff94bc42014-06-24 10:10:04 +02001095 err = self_check_peb_ec_hdr(ubi, pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001096 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +02001097 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001098
1099 vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
1100 vid_hdr->version = UBI_VERSION;
1101 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
1102 vid_hdr->hdr_crc = cpu_to_be32(crc);
1103
Heiko Schocherff94bc42014-06-24 10:10:04 +02001104 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001105 if (err)
Heiko Schocherff94bc42014-06-24 10:10:04 +02001106 return err;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001107
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001108 if (ubi_dbg_power_cut(ubi, POWER_CUT_VID_WRITE))
1109 return -EROFS;
1110
Kyungmin Park2d262c42008-11-19 16:26:54 +01001111 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1112 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1113 ubi->vid_hdr_alsize);
1114 return err;
1115}
1116
Kyungmin Park2d262c42008-11-19 16:26:54 +01001117/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001118 * self_check_not_bad - ensure that a physical eraseblock is not bad.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001119 * @ubi: UBI device description object
1120 * @pnum: physical eraseblock number to check
1121 *
Heiko Schocherff94bc42014-06-24 10:10:04 +02001122 * This function returns zero if the physical eraseblock is good, %-EINVAL if
1123 * it is bad and a negative error code if an error occurred.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001124 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001125static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001126{
1127 int err;
1128
Heiko Schocherff94bc42014-06-24 10:10:04 +02001129 if (!ubi_dbg_chk_io(ubi))
1130 return 0;
1131
Kyungmin Park2d262c42008-11-19 16:26:54 +01001132 err = ubi_io_is_bad(ubi, pnum);
1133 if (!err)
1134 return err;
1135
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001136 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001137 dump_stack();
1138 return err > 0 ? -EINVAL : err;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001139}
1140
1141/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001142 * self_check_ec_hdr - check if an erase counter header is all right.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001143 * @ubi: UBI device description object
1144 * @pnum: physical eraseblock number the erase counter header belongs to
1145 * @ec_hdr: the erase counter header to check
1146 *
1147 * This function returns zero if the erase counter header contains valid
Heiko Schocherff94bc42014-06-24 10:10:04 +02001148 * values, and %-EINVAL if not.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001149 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001150static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1151 const struct ubi_ec_hdr *ec_hdr)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001152{
1153 int err;
1154 uint32_t magic;
1155
Heiko Schocherff94bc42014-06-24 10:10:04 +02001156 if (!ubi_dbg_chk_io(ubi))
1157 return 0;
1158
Kyungmin Park2d262c42008-11-19 16:26:54 +01001159 magic = be32_to_cpu(ec_hdr->magic);
1160 if (magic != UBI_EC_HDR_MAGIC) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001161 ubi_err(ubi, "bad magic %#08x, must be %#08x",
Kyungmin Park2d262c42008-11-19 16:26:54 +01001162 magic, UBI_EC_HDR_MAGIC);
1163 goto fail;
1164 }
1165
1166 err = validate_ec_hdr(ubi, ec_hdr);
1167 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001168 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001169 goto fail;
1170 }
1171
1172 return 0;
1173
1174fail:
Heiko Schocherff94bc42014-06-24 10:10:04 +02001175 ubi_dump_ec_hdr(ec_hdr);
1176 dump_stack();
1177 return -EINVAL;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001178}
1179
1180/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001181 * self_check_peb_ec_hdr - check erase counter header.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001182 * @ubi: UBI device description object
1183 * @pnum: the physical eraseblock number to check
1184 *
Heiko Schocherff94bc42014-06-24 10:10:04 +02001185 * This function returns zero if the erase counter header is all right and and
1186 * a negative error code if not or if an error occurred.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001187 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001188static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001189{
1190 int err;
1191 uint32_t crc, hdr_crc;
1192 struct ubi_ec_hdr *ec_hdr;
1193
Heiko Schocherff94bc42014-06-24 10:10:04 +02001194 if (!ubi_dbg_chk_io(ubi))
1195 return 0;
1196
Kyungmin Park2d262c42008-11-19 16:26:54 +01001197 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
1198 if (!ec_hdr)
1199 return -ENOMEM;
1200
1201 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001202 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
Kyungmin Park2d262c42008-11-19 16:26:54 +01001203 goto exit;
1204
1205 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
1206 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
1207 if (hdr_crc != crc) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001208 ubi_err(ubi, "bad CRC, calculated %#08x, read %#08x",
1209 crc, hdr_crc);
1210 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001211 ubi_dump_ec_hdr(ec_hdr);
1212 dump_stack();
1213 err = -EINVAL;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001214 goto exit;
1215 }
1216
Heiko Schocherff94bc42014-06-24 10:10:04 +02001217 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001218
1219exit:
1220 kfree(ec_hdr);
1221 return err;
1222}
1223
1224/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001225 * self_check_vid_hdr - check that a volume identifier header is all right.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001226 * @ubi: UBI device description object
1227 * @pnum: physical eraseblock number the volume identifier header belongs to
1228 * @vid_hdr: the volume identifier header to check
1229 *
1230 * This function returns zero if the volume identifier header is all right, and
Heiko Schocherff94bc42014-06-24 10:10:04 +02001231 * %-EINVAL if not.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001232 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001233static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1234 const struct ubi_vid_hdr *vid_hdr)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001235{
1236 int err;
1237 uint32_t magic;
1238
Heiko Schocherff94bc42014-06-24 10:10:04 +02001239 if (!ubi_dbg_chk_io(ubi))
1240 return 0;
1241
Kyungmin Park2d262c42008-11-19 16:26:54 +01001242 magic = be32_to_cpu(vid_hdr->magic);
1243 if (magic != UBI_VID_HDR_MAGIC) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001244 ubi_err(ubi, "bad VID header magic %#08x at PEB %d, must be %#08x",
Kyungmin Park2d262c42008-11-19 16:26:54 +01001245 magic, pnum, UBI_VID_HDR_MAGIC);
1246 goto fail;
1247 }
1248
1249 err = validate_vid_hdr(ubi, vid_hdr);
1250 if (err) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001251 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001252 goto fail;
1253 }
1254
1255 return err;
1256
1257fail:
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001258 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001259 ubi_dump_vid_hdr(vid_hdr);
1260 dump_stack();
1261 return -EINVAL;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001262
1263}
1264
1265/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001266 * self_check_peb_vid_hdr - check volume identifier header.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001267 * @ubi: UBI device description object
1268 * @pnum: the physical eraseblock number to check
1269 *
1270 * This function returns zero if the volume identifier header is all right,
Heiko Schocherff94bc42014-06-24 10:10:04 +02001271 * and a negative error code if not or if an error occurred.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001272 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001273static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001274{
1275 int err;
1276 uint32_t crc, hdr_crc;
1277 struct ubi_vid_hdr *vid_hdr;
1278 void *p;
1279
Heiko Schocherff94bc42014-06-24 10:10:04 +02001280 if (!ubi_dbg_chk_io(ubi))
1281 return 0;
1282
Kyungmin Park2d262c42008-11-19 16:26:54 +01001283 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
1284 if (!vid_hdr)
1285 return -ENOMEM;
1286
1287 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1288 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1289 ubi->vid_hdr_alsize);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001290 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
Kyungmin Park2d262c42008-11-19 16:26:54 +01001291 goto exit;
1292
1293 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
1294 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
1295 if (hdr_crc != crc) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001296 ubi_err(ubi, "bad VID header CRC at PEB %d, calculated %#08x, read %#08x",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001297 pnum, crc, hdr_crc);
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001298 ubi_err(ubi, "self-check failed for PEB %d", pnum);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001299 ubi_dump_vid_hdr(vid_hdr);
1300 dump_stack();
1301 err = -EINVAL;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001302 goto exit;
1303 }
1304
Heiko Schocherff94bc42014-06-24 10:10:04 +02001305 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001306
1307exit:
1308 ubi_free_vid_hdr(ubi, vid_hdr);
1309 return err;
1310}
1311
1312/**
Heiko Schocherff94bc42014-06-24 10:10:04 +02001313 * self_check_write - make sure write succeeded.
1314 * @ubi: UBI device description object
1315 * @buf: buffer with data which were written
1316 * @pnum: physical eraseblock number the data were written to
1317 * @offset: offset within the physical eraseblock the data were written to
1318 * @len: how many bytes were written
1319 *
1320 * This functions reads data which were recently written and compares it with
1321 * the original data buffer - the data have to match. Returns zero if the data
1322 * match and a negative error code if not or in case of failure.
1323 */
1324static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1325 int offset, int len)
1326{
1327 int err, i;
1328 size_t read;
1329 void *buf1;
1330 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1331
1332 if (!ubi_dbg_chk_io(ubi))
1333 return 0;
1334
1335 buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1336 if (!buf1) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001337 ubi_err(ubi, "cannot allocate memory to check writes");
Heiko Schocherff94bc42014-06-24 10:10:04 +02001338 return 0;
1339 }
1340
1341 err = mtd_read(ubi->mtd, addr, len, &read, buf1);
1342 if (err && !mtd_is_bitflip(err))
1343 goto out_free;
1344
1345 for (i = 0; i < len; i++) {
1346 uint8_t c = ((uint8_t *)buf)[i];
1347 uint8_t c1 = ((uint8_t *)buf1)[i];
1348#if !defined(CONFIG_UBI_SILENCE_MSG)
1349 int dump_len = max_t(int, 128, len - i);
1350#endif
1351
1352 if (c == c1)
1353 continue;
1354
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001355 ubi_err(ubi, "self-check failed for PEB %d:%d, len %d",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001356 pnum, offset, len);
Markus Klotzbuecher5ebd3df2019-05-15 15:15:56 +02001357#if !defined(CONFIG_UBI_SILENCE_MSG)
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001358 ubi_msg(ubi, "data differ at position %d", i);
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001359 ubi_msg(ubi, "hex dump of the original buffer from %d to %d",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001360 i, i + dump_len);
Alexey Brodkinf8c987f2018-06-05 17:17:57 +03001361 print_hex_dump("", DUMP_PREFIX_OFFSET, 32, 1,
Heiko Schocherff94bc42014-06-24 10:10:04 +02001362 buf + i, dump_len, 1);
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001363 ubi_msg(ubi, "hex dump of the read buffer from %d to %d",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001364 i, i + dump_len);
Alexey Brodkinf8c987f2018-06-05 17:17:57 +03001365 print_hex_dump("", DUMP_PREFIX_OFFSET, 32, 1,
Heiko Schocherff94bc42014-06-24 10:10:04 +02001366 buf1 + i, dump_len, 1);
Markus Klotzbuecher5ebd3df2019-05-15 15:15:56 +02001367#endif
Heiko Schocherff94bc42014-06-24 10:10:04 +02001368 dump_stack();
1369 err = -EINVAL;
1370 goto out_free;
1371 }
1372
1373 vfree(buf1);
1374 return 0;
1375
1376out_free:
1377 vfree(buf1);
1378 return err;
1379}
1380
1381/**
1382 * ubi_self_check_all_ff - check that a region of flash is empty.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001383 * @ubi: UBI device description object
1384 * @pnum: the physical eraseblock number to check
1385 * @offset: the starting offset within the physical eraseblock to check
1386 * @len: the length of the region to check
1387 *
1388 * This function returns zero if only 0xFF bytes are present at offset
Heiko Schocherff94bc42014-06-24 10:10:04 +02001389 * @offset of the physical eraseblock @pnum, and a negative error code if not
1390 * or if an error occurred.
Kyungmin Park2d262c42008-11-19 16:26:54 +01001391 */
Heiko Schocherff94bc42014-06-24 10:10:04 +02001392int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
Kyungmin Park2d262c42008-11-19 16:26:54 +01001393{
1394 size_t read;
1395 int err;
Heiko Schocherff94bc42014-06-24 10:10:04 +02001396 void *buf;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001397 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1398
Heiko Schocherff94bc42014-06-24 10:10:04 +02001399 if (!ubi_dbg_chk_io(ubi))
1400 return 0;
1401
1402 buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
1403 if (!buf) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001404 ubi_err(ubi, "cannot allocate memory to check for 0xFFs");
Heiko Schocherff94bc42014-06-24 10:10:04 +02001405 return 0;
1406 }
1407
1408 err = mtd_read(ubi->mtd, addr, len, &read, buf);
1409 if (err && !mtd_is_bitflip(err)) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001410 ubi_err(ubi, "err %d while reading %d bytes from PEB %d:%d, read %zd bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001411 err, len, pnum, offset, read);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001412 goto error;
1413 }
1414
Heiko Schocherff94bc42014-06-24 10:10:04 +02001415 err = ubi_check_pattern(buf, 0xFF, len);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001416 if (err == 0) {
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001417 ubi_err(ubi, "flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",
Heiko Schocherff94bc42014-06-24 10:10:04 +02001418 pnum, offset, len);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001419 goto fail;
1420 }
Kyungmin Park2d262c42008-11-19 16:26:54 +01001421
Heiko Schocherff94bc42014-06-24 10:10:04 +02001422 vfree(buf);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001423 return 0;
1424
1425fail:
Heiko Schocher0195a7b2015-10-22 06:19:21 +02001426 ubi_err(ubi, "self-check failed for PEB %d", pnum);
1427 ubi_msg(ubi, "hex dump of the %d-%d region", offset, offset + len);
Alexey Brodkinf8c987f2018-06-05 17:17:57 +03001428 print_hex_dump("", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
Heiko Schocherff94bc42014-06-24 10:10:04 +02001429 err = -EINVAL;
Kyungmin Park2d262c42008-11-19 16:26:54 +01001430error:
Heiko Schocherff94bc42014-06-24 10:10:04 +02001431 dump_stack();
1432 vfree(buf);
Kyungmin Park2d262c42008-11-19 16:26:54 +01001433 return err;
1434}