blob: 78a1dcbf210758536ac3da2ebf83419ef6af8de0 [file] [log] [blame]
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001/*
2 * Copyright (c) International Business Machines Corp., 2006
3 * Copyright (c) Nokia Corporation, 2006, 2007
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * Author: Artem Bityutskiy (Битюцкий Артём)
20 */
21
22/*
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030023 * UBI input/output sub-system.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040024 *
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030025 * This sub-system provides a uniform way to work with all kinds of the
26 * underlying MTD devices. It also implements handy functions for reading and
27 * writing UBI headers.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040028 *
29 * We are trying to have a paranoid mindset and not to trust to what we read
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030030 * from the flash media in order to be more secure and robust. So this
31 * sub-system validates every single header it reads from the flash media.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040032 *
33 * Some words about how the eraseblock headers are stored.
34 *
35 * The erase counter header is always stored at offset zero. By default, the
36 * VID header is stored after the EC header at the closest aligned offset
37 * (i.e. aligned to the minimum I/O unit size). Data starts next to the VID
38 * header at the closest aligned offset. But this default layout may be
39 * changed. For example, for different reasons (e.g., optimization) UBI may be
40 * asked to put the VID header at further offset, and even at an unaligned
41 * offset. Of course, if the offset of the VID header is unaligned, UBI adds
42 * proper padding in front of it. Data offset may also be changed but it has to
43 * be aligned.
44 *
45 * About minimal I/O units. In general, UBI assumes flash device model where
46 * there is only one minimal I/O unit size. E.g., in case of NOR flash it is 1,
47 * in case of NAND flash it is a NAND page, etc. This is reported by MTD in the
48 * @ubi->mtd->writesize field. But as an exception, UBI admits of using another
49 * (smaller) minimal I/O unit size for EC and VID headers to make it possible
50 * to do different optimizations.
51 *
52 * This is extremely useful in case of NAND flashes which admit of several
53 * write operations to one NAND page. In this case UBI can fit EC and VID
54 * headers at one NAND page. Thus, UBI may use "sub-page" size as the minimal
55 * I/O unit for the headers (the @ubi->hdrs_min_io_size field). But it still
56 * reports NAND page size (@ubi->min_io_size) as a minimal I/O unit for the UBI
57 * users.
58 *
59 * Example: some Samsung NANDs with 2KiB pages allow 4x 512-byte writes, so
60 * although the minimal I/O unit is 2K, UBI uses 512 bytes for EC and VID
61 * headers.
62 *
63 * Q: why not just to treat sub-page as a minimal I/O unit of this flash
64 * device, e.g., make @ubi->min_io_size = 512 in the example above?
65 *
66 * A: because when writing a sub-page, MTD still writes a full 2K page but the
Shinya Kuribayashibe436f62010-05-06 19:22:09 +090067 * bytes which are not relevant to the sub-page are 0xFF. So, basically,
68 * writing 4x512 sub-pages is 4 times slower than writing one 2KiB NAND page.
69 * Thus, we prefer to use sub-pages only for EC and VID headers.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040070 *
71 * As it was noted above, the VID header may start at a non-aligned offset.
72 * For example, in case of a 2KiB page NAND flash with a 512 bytes sub-page,
73 * the VID header may reside at offset 1984 which is the last 64 bytes of the
74 * last sub-page (EC header is always at offset zero). This causes some
75 * difficulties when reading and writing VID headers.
76 *
77 * Suppose we have a 64-byte buffer and we read a VID header at it. We change
78 * the data and want to write this VID header out. As we can only write in
79 * 512-byte chunks, we have to allocate one more buffer and copy our VID header
80 * to offset 448 of this buffer.
81 *
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030082 * The I/O sub-system does the following trick in order to avoid this extra
83 * copy. It always allocates a @ubi->vid_hdr_alsize bytes buffer for the VID
84 * header and returns a pointer to offset @ubi->vid_hdr_shift of this buffer.
85 * When the VID header is being written out, it shifts the VID header pointer
86 * back and writes the whole sub-page.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040087 */
88
89#include <linux/crc32.h>
90#include <linux/err.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090091#include <linux/slab.h>
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040092#include "ubi.h"
93
Artem Bityutskiy8056eb42012-05-16 18:24:09 +030094static int self_check_not_bad(const struct ubi_device *ubi, int pnum);
95static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum);
96static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
97 const struct ubi_ec_hdr *ec_hdr);
98static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum);
99static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
100 const struct ubi_vid_hdr *vid_hdr);
Artem Bityutskiy97d61042012-05-16 19:29:04 +0300101static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
102 int offset, int len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400103
104/**
105 * ubi_io_read - read data from a physical eraseblock.
106 * @ubi: UBI device description object
107 * @buf: buffer where to store the read data
108 * @pnum: physical eraseblock number to read from
109 * @offset: offset within the physical eraseblock from where to read
110 * @len: how many bytes to read
111 *
112 * This function reads data from offset @offset of physical eraseblock @pnum
113 * and stores the read data in the @buf buffer. The following return codes are
114 * possible:
115 *
116 * o %0 if all the requested data were successfully read;
117 * o %UBI_IO_BITFLIPS if all the requested data were successfully read, but
118 * correctable bit-flips were detected; this is harmless but may indicate
119 * that this eraseblock may become bad soon (but do not have to);
Artem Bityutskiy63b6c1e2007-07-17 15:04:20 +0300120 * o %-EBADMSG if the MTD subsystem reported about data integrity problems, for
121 * example it can be an ECC error in case of NAND; this most probably means
122 * that the data is corrupted;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400123 * o %-EIO if some I/O error occurred;
124 * o other negative error codes in case of other errors.
125 */
126int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
127 int len)
128{
129 int err, retries = 0;
130 size_t read;
131 loff_t addr;
132
133 dbg_io("read %d bytes from PEB %d:%d", len, pnum, offset);
134
135 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
136 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
137 ubi_assert(len > 0);
138
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300139 err = self_check_not_bad(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400140 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200141 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400142
Artem Bityutskiy276832d2010-11-13 15:08:29 +0200143 /*
144 * Deliberately corrupt the buffer to improve robustness. Indeed, if we
145 * do not do this, the following may happen:
146 * 1. The buffer contains data from previous operation, e.g., read from
147 * another PEB previously. The data looks like expected, e.g., if we
148 * just do not read anything and return - the caller would not
149 * notice this. E.g., if we are reading a VID header, the buffer may
150 * contain a valid VID header from another PEB.
151 * 2. The driver is buggy and returns us success or -EBADMSG or
152 * -EUCLEAN, but it does not actually put any data to the buffer.
153 *
154 * This may confuse UBI or upper layers - they may think the buffer
155 * contains valid data while in fact it is just old data. This is
156 * especially possible because UBI (and UBIFS) relies on CRC, and
157 * treats data as correct even in case of ECC errors if the CRC is
158 * correct.
159 *
160 * Try to prevent this situation by changing the first byte of the
161 * buffer.
162 */
163 *((uint8_t *)buf) ^= 0xFF;
164
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400165 addr = (loff_t)pnum * ubi->peb_size + offset;
166retry:
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200167 err = mtd_read(ubi->mtd, addr, len, &read, buf);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400168 if (err) {
Brian Norrisd57f40542011-09-20 18:34:25 -0700169 const char *errstr = mtd_is_eccerr(err) ? " (ECC error)" : "";
Artem Bityutskiy1a49af22010-06-08 10:59:07 +0300170
Brian Norrisd57f40542011-09-20 18:34:25 -0700171 if (mtd_is_bitflip(err)) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400172 /*
173 * -EUCLEAN is reported if there was a bit-flip which
174 * was corrected, so this is harmless.
Artem Bityutskiy8c1e6ee2008-07-18 12:20:23 +0300175 *
176 * We do not report about it here unless debugging is
177 * enabled. A corresponding message will be printed
178 * later, when it is has been scrubbed.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400179 */
Artem Bityutskiy719bb842012-08-27 17:14:58 +0300180 ubi_msg("fixable bit-flip detected at PEB %d", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400181 ubi_assert(len == read);
182 return UBI_IO_BITFLIPS;
183 }
184
Artem Bityutskiya87f29c2010-10-31 18:55:30 +0200185 if (retries++ < UBI_IO_RETRIES) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300186 ubi_warn("error %d%s while reading %d bytes from PEB %d:%d, read only %zd bytes, retry",
Artem Bityutskiyf01e2d12012-04-25 09:15:38 +0300187 err, errstr, len, pnum, offset, read);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400188 yield();
189 goto retry;
190 }
191
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300192 ubi_err("error %d%s while reading %d bytes from PEB %d:%d, read %zd bytes",
193 err, errstr, len, pnum, offset, read);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300194 dump_stack();
Artem Bityutskiy2362a532007-10-18 20:09:41 +0300195
196 /*
197 * The driver should never return -EBADMSG if it failed to read
198 * all the requested data. But some buggy drivers might do
199 * this, so we change it to -EIO.
200 */
Brian Norrisd57f40542011-09-20 18:34:25 -0700201 if (read != len && mtd_is_eccerr(err)) {
Artem Bityutskiy2362a532007-10-18 20:09:41 +0300202 ubi_assert(0);
203 err = -EIO;
204 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400205 } else {
206 ubi_assert(len == read);
207
Artem Bityutskiy27a0f2a2011-05-18 16:03:23 +0300208 if (ubi_dbg_is_bitflip(ubi)) {
Artem Bityutskiyc8566352008-07-16 17:40:22 +0300209 dbg_gen("bit-flip (emulated)");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400210 err = UBI_IO_BITFLIPS;
211 }
212 }
213
214 return err;
215}
216
217/**
218 * ubi_io_write - write data to a physical eraseblock.
219 * @ubi: UBI device description object
220 * @buf: buffer with the data to write
221 * @pnum: physical eraseblock number to write to
222 * @offset: offset within the physical eraseblock where to write
223 * @len: how many bytes to write
224 *
225 * This function writes @len bytes of data from buffer @buf to offset @offset
226 * of physical eraseblock @pnum. If all the data were successfully written,
227 * zero is returned. If an error occurred, this function returns a negative
228 * error code. If %-EIO is returned, the physical eraseblock most probably went
229 * bad.
230 *
231 * Note, in case of an error, it is possible that something was still written
232 * to the flash media, but may be some garbage.
233 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300234int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
235 int len)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400236{
237 int err;
238 size_t written;
239 loff_t addr;
240
241 dbg_io("write %d bytes to PEB %d:%d", len, pnum, offset);
242
243 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
244 ubi_assert(offset >= 0 && offset + len <= ubi->peb_size);
245 ubi_assert(offset % ubi->hdrs_min_io_size == 0);
246 ubi_assert(len > 0 && len % ubi->hdrs_min_io_size == 0);
247
248 if (ubi->ro_mode) {
249 ubi_err("read-only mode");
250 return -EROFS;
251 }
252
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300253 err = self_check_not_bad(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400254 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200255 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400256
257 /* The area we are writing to has to contain all 0xFF bytes */
Artem Bityutskiy97d61042012-05-16 19:29:04 +0300258 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400259 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200260 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400261
262 if (offset >= ubi->leb_start) {
263 /*
264 * We write to the data area of the physical eraseblock. Make
265 * sure it has valid EC and VID headers.
266 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300267 err = self_check_peb_ec_hdr(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400268 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200269 return err;
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300270 err = self_check_peb_vid_hdr(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400271 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200272 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400273 }
274
Artem Bityutskiy27a0f2a2011-05-18 16:03:23 +0300275 if (ubi_dbg_is_write_failure(ubi)) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300276 ubi_err("cannot write %d bytes to PEB %d:%d (emulated)",
277 len, pnum, offset);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300278 dump_stack();
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400279 return -EIO;
280 }
281
282 addr = (loff_t)pnum * ubi->peb_size + offset;
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200283 err = mtd_write(ubi->mtd, addr, len, &written, buf);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400284 if (err) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300285 ubi_err("error %d while writing %d bytes to PEB %d:%d, written %zd bytes",
286 err, len, pnum, offset, written);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300287 dump_stack();
Artem Bityutskiyef7088e2012-04-24 07:10:33 +0300288 ubi_dump_flash(ubi, pnum, offset, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400289 } else
290 ubi_assert(written == len);
291
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +0200292 if (!err) {
Artem Bityutskiy97d61042012-05-16 19:29:04 +0300293 err = self_check_write(ubi, buf, pnum, offset, len);
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +0200294 if (err)
295 return err;
296
297 /*
298 * Since we always write sequentially, the rest of the PEB has
299 * to contain only 0xFF bytes.
300 */
301 offset += len;
302 len = ubi->peb_size - offset;
303 if (len)
Artem Bityutskiy97d61042012-05-16 19:29:04 +0300304 err = ubi_self_check_all_ff(ubi, pnum, offset, len);
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +0200305 }
306
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400307 return err;
308}
309
310/**
311 * erase_callback - MTD erasure call-back.
312 * @ei: MTD erase information object.
313 *
314 * Note, even though MTD erase interface is asynchronous, all the current
315 * implementations are synchronous anyway.
316 */
317static void erase_callback(struct erase_info *ei)
318{
319 wake_up_interruptible((wait_queue_head_t *)ei->priv);
320}
321
322/**
323 * do_sync_erase - synchronously erase a physical eraseblock.
324 * @ubi: UBI device description object
325 * @pnum: the physical eraseblock number to erase
326 *
327 * This function synchronously erases physical eraseblock @pnum and returns
328 * zero in case of success and a negative error code in case of failure. If
329 * %-EIO is returned, the physical eraseblock most probably went bad.
330 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300331static int do_sync_erase(struct ubi_device *ubi, int pnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400332{
333 int err, retries = 0;
334 struct erase_info ei;
335 wait_queue_head_t wq;
336
337 dbg_io("erase PEB %d", pnum);
Artem Bityutskiy3efe5092011-03-18 18:11:42 +0200338 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
339
340 if (ubi->ro_mode) {
341 ubi_err("read-only mode");
342 return -EROFS;
343 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400344
345retry:
346 init_waitqueue_head(&wq);
347 memset(&ei, 0, sizeof(struct erase_info));
348
349 ei.mtd = ubi->mtd;
Brijesh Singh2f176f72007-07-05 15:07:35 +0530350 ei.addr = (loff_t)pnum * ubi->peb_size;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400351 ei.len = ubi->peb_size;
352 ei.callback = erase_callback;
353 ei.priv = (unsigned long)&wq;
354
Artem Bityutskiy7e1f0dc2011-12-23 15:25:39 +0200355 err = mtd_erase(ubi->mtd, &ei);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400356 if (err) {
357 if (retries++ < UBI_IO_RETRIES) {
Artem Bityutskiyf01e2d12012-04-25 09:15:38 +0300358 ubi_warn("error %d while erasing PEB %d, retry",
359 err, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400360 yield();
361 goto retry;
362 }
363 ubi_err("cannot erase PEB %d, error %d", pnum, err);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300364 dump_stack();
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400365 return err;
366 }
367
368 err = wait_event_interruptible(wq, ei.state == MTD_ERASE_DONE ||
369 ei.state == MTD_ERASE_FAILED);
370 if (err) {
371 ubi_err("interrupted PEB %d erasure", pnum);
372 return -EINTR;
373 }
374
375 if (ei.state == MTD_ERASE_FAILED) {
376 if (retries++ < UBI_IO_RETRIES) {
Artem Bityutskiyf01e2d12012-04-25 09:15:38 +0300377 ubi_warn("error while erasing PEB %d, retry", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400378 yield();
379 goto retry;
380 }
381 ubi_err("cannot erase PEB %d", pnum);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300382 dump_stack();
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400383 return -EIO;
384 }
385
Artem Bityutskiy97d61042012-05-16 19:29:04 +0300386 err = ubi_self_check_all_ff(ubi, pnum, 0, ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400387 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200388 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400389
Artem Bityutskiy27a0f2a2011-05-18 16:03:23 +0300390 if (ubi_dbg_is_erase_failure(ubi)) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300391 ubi_err("cannot erase PEB %d (emulated)", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400392 return -EIO;
393 }
394
395 return 0;
396}
397
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400398/* Patterns to write to a physical eraseblock when torturing it */
399static uint8_t patterns[] = {0xa5, 0x5a, 0x0};
400
401/**
402 * torture_peb - test a supposedly bad physical eraseblock.
403 * @ubi: UBI device description object
404 * @pnum: the physical eraseblock number to test
405 *
406 * This function returns %-EIO if the physical eraseblock did not pass the
407 * test, a positive number of erase operations done if the test was
408 * successfully passed, and other negative error codes in case of other errors.
409 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300410static int torture_peb(struct ubi_device *ubi, int pnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400411{
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400412 int err, i, patt_count;
413
Artem Bityutskiy8c1e6ee2008-07-18 12:20:23 +0300414 ubi_msg("run torture test for PEB %d", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400415 patt_count = ARRAY_SIZE(patterns);
416 ubi_assert(patt_count > 0);
417
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300418 mutex_lock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400419 for (i = 0; i < patt_count; i++) {
420 err = do_sync_erase(ubi, pnum);
421 if (err)
422 goto out;
423
424 /* Make sure the PEB contains only 0xFF bytes */
Artem Bityutskiy0ca39d72012-03-08 15:29:37 +0200425 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400426 if (err)
427 goto out;
428
Artem Bityutskiy0ca39d72012-03-08 15:29:37 +0200429 err = ubi_check_pattern(ubi->peb_buf, 0xFF, ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400430 if (err == 0) {
431 ubi_err("erased PEB %d, but a non-0xFF byte found",
432 pnum);
433 err = -EIO;
434 goto out;
435 }
436
437 /* Write a pattern and check it */
Artem Bityutskiy0ca39d72012-03-08 15:29:37 +0200438 memset(ubi->peb_buf, patterns[i], ubi->peb_size);
439 err = ubi_io_write(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400440 if (err)
441 goto out;
442
Artem Bityutskiy0ca39d72012-03-08 15:29:37 +0200443 memset(ubi->peb_buf, ~patterns[i], ubi->peb_size);
444 err = ubi_io_read(ubi, ubi->peb_buf, pnum, 0, ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400445 if (err)
446 goto out;
447
Artem Bityutskiy0ca39d72012-03-08 15:29:37 +0200448 err = ubi_check_pattern(ubi->peb_buf, patterns[i],
Artem Bityutskiybb00e182010-07-31 09:37:34 +0300449 ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400450 if (err == 0) {
451 ubi_err("pattern %x checking failed for PEB %d",
452 patterns[i], pnum);
453 err = -EIO;
454 goto out;
455 }
456 }
457
458 err = patt_count;
Artem Bityutskiy14264142011-04-14 11:36:31 +0300459 ubi_msg("PEB %d passed torture test, do not mark it as bad", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400460
461out:
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300462 mutex_unlock(&ubi->buf_mutex);
Brian Norrisd57f40542011-09-20 18:34:25 -0700463 if (err == UBI_IO_BITFLIPS || mtd_is_eccerr(err)) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400464 /*
465 * If a bit-flip or data integrity error was detected, the test
466 * has not passed because it happened on a freshly erased
467 * physical eraseblock which means something is wrong with it.
468 */
Artem Bityutskiy8d2d4012007-07-22 22:32:51 +0300469 ubi_err("read problems on freshly erased PEB %d, must be bad",
470 pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400471 err = -EIO;
Artem Bityutskiy8d2d4012007-07-22 22:32:51 +0300472 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400473 return err;
474}
475
476/**
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300477 * nor_erase_prepare - prepare a NOR flash PEB for erasure.
478 * @ubi: UBI device description object
479 * @pnum: physical eraseblock number to prepare
480 *
481 * NOR flash, or at least some of them, have peculiar embedded PEB erasure
482 * algorithm: the PEB is first filled with zeroes, then it is erased. And
483 * filling with zeroes starts from the end of the PEB. This was observed with
484 * Spansion S29GL512N NOR flash.
485 *
486 * This means that in case of a power cut we may end up with intact data at the
487 * beginning of the PEB, and all zeroes at the end of PEB. In other words, the
488 * EC and VID headers are OK, but a large chunk of data at the end of PEB is
489 * zeroed. This makes UBI mistakenly treat this PEB as used and associate it
490 * with an LEB, which leads to subsequent failures (e.g., UBIFS fails).
491 *
492 * This function is called before erasing NOR PEBs and it zeroes out EC and VID
493 * magic numbers in order to invalidate them and prevent the failures. Returns
494 * zero in case of success and a negative error code in case of failure.
495 */
496static int nor_erase_prepare(struct ubi_device *ubi, int pnum)
497{
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300498 int err, err1;
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300499 size_t written;
500 loff_t addr;
501 uint32_t data = 0;
Artem Bityutskiy2fff5702010-12-03 15:32:21 +0200502 /*
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 */
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300509 struct ubi_vid_hdr vid_hdr;
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300510
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200511 /*
512 * It is important to first invalidate the EC header, and then the VID
513 * header. Otherwise a power cut may lead to valid EC header and
514 * invalid VID header, in which case UBI will treat this PEB as
Artem Bityutskiyfbd01072012-05-17 16:12:26 +0300515 * corrupted and will try to preserve it, and print scary warnings.
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200516 */
517 addr = (loff_t)pnum * ubi->peb_size;
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200518 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300519 if (!err) {
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200520 addr += ubi->vid_hdr_aloffset;
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200521 err = mtd_write(ubi->mtd, addr, 4, &written, (void *)&data);
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300522 if (!err)
523 return 0;
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300524 }
525
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300526 /*
527 * We failed to write to the media. This was observed with Spansion
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200528 * S29GL512N NOR flash. Most probably the previously eraseblock erasure
529 * was interrupted at a very inappropriate moment, so it became
530 * unwritable. In this case we probably anyway have garbage in this
531 * PEB.
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300532 */
533 err1 = ubi_io_read_vid_hdr(ubi, pnum, &vid_hdr, 0);
Holger Brunckd4c63812011-01-25 13:04:11 +0200534 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
535 err1 == UBI_IO_FF) {
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200536 struct ubi_ec_hdr ec_hdr;
537
538 err1 = ubi_io_read_ec_hdr(ubi, pnum, &ec_hdr, 0);
Holger Brunckd4c63812011-01-25 13:04:11 +0200539 if (err1 == UBI_IO_BAD_HDR_EBADMSG || err1 == UBI_IO_BAD_HDR ||
540 err1 == UBI_IO_FF)
Artem Bityutskiy7ac760c2010-12-02 06:34:01 +0200541 /*
542 * Both VID and EC headers are corrupted, so we can
543 * safely erase this PEB and not afraid that it will be
544 * treated as a valid PEB in case of an unclean reboot.
545 */
546 return 0;
547 }
Artem Bityutskiy5b289b52009-07-19 14:09:46 +0300548
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300549 /*
550 * The PEB contains a valid VID header, but we cannot invalidate it.
551 * Supposedly the flash media or the driver is screwed up, so return an
552 * error.
553 */
554 ubi_err("cannot invalidate PEB %d, write returned %d read returned %d",
555 pnum, err, err1);
Artem Bityutskiyef7088e2012-04-24 07:10:33 +0300556 ubi_dump_flash(ubi, pnum, 0, ubi->peb_size);
Artem Bityutskiyde75c772009-07-24 16:18:04 +0300557 return -EIO;
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300558}
559
560/**
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400561 * ubi_io_sync_erase - synchronously erase a physical eraseblock.
562 * @ubi: UBI device description object
563 * @pnum: physical eraseblock number to erase
564 * @torture: if this physical eraseblock has to be tortured
565 *
566 * This function synchronously erases physical eraseblock @pnum. If @torture
567 * flag is not zero, the physical eraseblock is checked by means of writing
568 * different patterns to it and reading them back. If the torturing is enabled,
Frederik Schwarzer025dfda2008-10-16 19:02:37 +0200569 * the physical eraseblock is erased more than once.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400570 *
571 * This function returns the number of erasures made in case of success, %-EIO
572 * if the erasure failed or the torturing test failed, and other negative error
573 * codes in case of other errors. Note, %-EIO means that the physical
574 * eraseblock is bad.
575 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300576int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400577{
578 int err, ret = 0;
579
580 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
581
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300582 err = self_check_not_bad(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400583 if (err != 0)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200584 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400585
586 if (ubi->ro_mode) {
587 ubi_err("read-only mode");
588 return -EROFS;
589 }
590
Artem Bityutskiyebf53f42009-07-06 08:57:53 +0300591 if (ubi->nor_flash) {
592 err = nor_erase_prepare(ubi, pnum);
593 if (err)
594 return err;
595 }
596
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400597 if (torture) {
598 ret = torture_peb(ubi, pnum);
599 if (ret < 0)
600 return ret;
601 }
602
603 err = do_sync_erase(ubi, pnum);
604 if (err)
605 return err;
606
607 return ret + 1;
608}
609
610/**
611 * ubi_io_is_bad - check if a physical eraseblock is bad.
612 * @ubi: UBI device description object
613 * @pnum: the physical eraseblock number to check
614 *
615 * This function returns a positive number if the physical eraseblock is bad,
616 * zero if not, and a negative error code if an error occurred.
617 */
618int ubi_io_is_bad(const struct ubi_device *ubi, int pnum)
619{
620 struct mtd_info *mtd = ubi->mtd;
621
622 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
623
624 if (ubi->bad_allowed) {
625 int ret;
626
Artem Bityutskiy7086c192011-12-23 19:35:30 +0200627 ret = mtd_block_isbad(mtd, (loff_t)pnum * ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400628 if (ret < 0)
629 ubi_err("error %d while checking if PEB %d is bad",
630 ret, pnum);
631 else if (ret)
632 dbg_io("PEB %d is bad", pnum);
633 return ret;
634 }
635
636 return 0;
637}
638
639/**
640 * ubi_io_mark_bad - mark a physical eraseblock as bad.
641 * @ubi: UBI device description object
642 * @pnum: the physical eraseblock number to mark
643 *
644 * This function returns zero in case of success and a negative error code in
645 * case of failure.
646 */
647int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum)
648{
649 int err;
650 struct mtd_info *mtd = ubi->mtd;
651
652 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
653
654 if (ubi->ro_mode) {
655 ubi_err("read-only mode");
656 return -EROFS;
657 }
658
659 if (!ubi->bad_allowed)
660 return 0;
661
Artem Bityutskiy5942ddb2011-12-23 19:37:38 +0200662 err = mtd_block_markbad(mtd, (loff_t)pnum * ubi->peb_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400663 if (err)
664 ubi_err("cannot mark PEB %d bad, error %d", pnum, err);
665 return err;
666}
667
668/**
669 * validate_ec_hdr - validate an erase counter header.
670 * @ubi: UBI device description object
671 * @ec_hdr: the erase counter header to check
672 *
673 * This function returns zero if the erase counter header is OK, and %1 if
674 * not.
675 */
Artem Bityutskiyfe96efc2009-06-30 16:11:59 +0300676static int validate_ec_hdr(const struct ubi_device *ubi,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400677 const struct ubi_ec_hdr *ec_hdr)
678{
679 long long ec;
Artem Bityutskiyfe96efc2009-06-30 16:11:59 +0300680 int vid_hdr_offset, leb_start;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400681
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300682 ec = be64_to_cpu(ec_hdr->ec);
683 vid_hdr_offset = be32_to_cpu(ec_hdr->vid_hdr_offset);
684 leb_start = be32_to_cpu(ec_hdr->data_offset);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400685
686 if (ec_hdr->version != UBI_VERSION) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300687 ubi_err("node with incompatible UBI version found: this UBI version is %d, image version is %d",
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400688 UBI_VERSION, (int)ec_hdr->version);
689 goto bad;
690 }
691
692 if (vid_hdr_offset != ubi->vid_hdr_offset) {
693 ubi_err("bad VID header offset %d, expected %d",
694 vid_hdr_offset, ubi->vid_hdr_offset);
695 goto bad;
696 }
697
698 if (leb_start != ubi->leb_start) {
699 ubi_err("bad data offset %d, expected %d",
700 leb_start, ubi->leb_start);
701 goto bad;
702 }
703
704 if (ec < 0 || ec > UBI_MAX_ERASECOUNTER) {
705 ubi_err("bad erase counter %lld", ec);
706 goto bad;
707 }
708
709 return 0;
710
711bad:
712 ubi_err("bad EC header");
Artem Bityutskiya904e3f2012-04-25 09:02:44 +0300713 ubi_dump_ec_hdr(ec_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300714 dump_stack();
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400715 return 1;
716}
717
718/**
719 * ubi_io_read_ec_hdr - read and check an erase counter header.
720 * @ubi: UBI device description object
721 * @pnum: physical eraseblock to read from
722 * @ec_hdr: a &struct ubi_ec_hdr object where to store the read erase counter
723 * header
724 * @verbose: be verbose if the header is corrupted or was not found
725 *
726 * This function reads erase counter header from physical eraseblock @pnum and
727 * stores it in @ec_hdr. This function also checks CRC checksum of the read
728 * erase counter header. The following codes may be returned:
729 *
730 * o %0 if the CRC checksum is correct and the header was successfully read;
731 * o %UBI_IO_BITFLIPS if the CRC is correct, but bit-flips were detected
732 * and corrected by the flash driver; this is harmless but may indicate that
733 * this eraseblock may become bad soon (but may be not);
Artem Bityutskiy786d7832010-04-30 16:50:22 +0300734 * o %UBI_IO_BAD_HDR if the erase counter header is corrupted (a CRC error);
Artem Bityutskiy756e1df2010-09-03 01:30:16 +0300735 * o %UBI_IO_BAD_HDR_EBADMSG is the same as %UBI_IO_BAD_HDR, but there also was
736 * a data integrity error (uncorrectable ECC error in case of NAND);
Artem Bityutskiy74d82d22010-09-03 02:11:20 +0300737 * o %UBI_IO_FF if only 0xFF bytes were read (the PEB is supposedly empty)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400738 * o a negative error code in case of failure.
739 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300740int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400741 struct ubi_ec_hdr *ec_hdr, int verbose)
742{
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300743 int err, read_err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400744 uint32_t crc, magic, hdr_crc;
745
746 dbg_io("read EC header from PEB %d", pnum);
747 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
748
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300749 read_err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
750 if (read_err) {
Brian Norrisd57f40542011-09-20 18:34:25 -0700751 if (read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300752 return read_err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400753
754 /*
755 * We read all the data, but either a correctable bit-flip
Artem Bityutskiy756e1df2010-09-03 01:30:16 +0300756 * occurred, or MTD reported a data integrity error
757 * (uncorrectable ECC error in case of NAND). The former is
758 * harmless, the later may mean that the read data is
759 * corrupted. But we have a CRC check-sum and we will detect
760 * this. If the EC header is still OK, we just report this as
761 * there was a bit-flip, to force scrubbing.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400762 */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400763 }
764
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300765 magic = be32_to_cpu(ec_hdr->magic);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400766 if (magic != UBI_EC_HDR_MAGIC) {
Brian Norrisd57f40542011-09-20 18:34:25 -0700767 if (mtd_is_eccerr(read_err))
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300768 return UBI_IO_BAD_HDR_EBADMSG;
Artem Bityutskiyeb895802010-05-03 09:04:39 +0300769
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400770 /*
771 * The magic field is wrong. Let's check if we have read all
772 * 0xFF. If yes, this physical eraseblock is assumed to be
773 * empty.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400774 */
Artem Bityutskiybb00e182010-07-31 09:37:34 +0300775 if (ubi_check_pattern(ec_hdr, 0xFF, UBI_EC_HDR_SIZE)) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400776 /* The physical eraseblock is supposedly empty */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400777 if (verbose)
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300778 ubi_warn("no EC header found at PEB %d, only 0xFF bytes",
779 pnum);
780 dbg_bld("no EC header found at PEB %d, only 0xFF bytes",
781 pnum);
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300782 if (!read_err)
783 return UBI_IO_FF;
784 else
785 return UBI_IO_FF_BITFLIPS;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400786 }
787
788 /*
789 * This is not a valid erase counter header, and these are not
790 * 0xFF bytes. Report that the header is corrupted.
791 */
792 if (verbose) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300793 ubi_warn("bad magic number at PEB %d: %08x instead of %08x",
794 pnum, magic, UBI_EC_HDR_MAGIC);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +0300795 ubi_dump_ec_hdr(ec_hdr);
Artem Bityutskiy6f9fdf62011-03-11 13:08:51 +0200796 }
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300797 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
798 pnum, magic, UBI_EC_HDR_MAGIC);
Artem Bityutskiy786d7832010-04-30 16:50:22 +0300799 return UBI_IO_BAD_HDR;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400800 }
801
802 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300803 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400804
805 if (hdr_crc != crc) {
806 if (verbose) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300807 ubi_warn("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
808 pnum, crc, hdr_crc);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +0300809 ubi_dump_ec_hdr(ec_hdr);
Artem Bityutskiy6f9fdf62011-03-11 13:08:51 +0200810 }
Artem Bityutskiy049333c2012-08-27 14:43:54 +0300811 dbg_bld("bad EC header CRC at PEB %d, calculated %#08x, read %#08x",
812 pnum, crc, hdr_crc);
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +0300813
814 if (!read_err)
815 return UBI_IO_BAD_HDR;
816 else
817 return UBI_IO_BAD_HDR_EBADMSG;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400818 }
819
820 /* And of course validate what has just been read from the media */
821 err = validate_ec_hdr(ubi, ec_hdr);
822 if (err) {
823 ubi_err("validation failed for PEB %d", pnum);
824 return -EINVAL;
825 }
826
Artem Bityutskiyeb895802010-05-03 09:04:39 +0300827 /*
828 * If there was %-EBADMSG, but the header CRC is still OK, report about
829 * a bit-flip to force scrubbing on this PEB.
830 */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400831 return read_err ? UBI_IO_BITFLIPS : 0;
832}
833
834/**
835 * ubi_io_write_ec_hdr - write an erase counter header.
836 * @ubi: UBI device description object
837 * @pnum: physical eraseblock to write to
838 * @ec_hdr: the erase counter header to write
839 *
840 * This function writes erase counter header described by @ec_hdr to physical
841 * eraseblock @pnum. It also fills most fields of @ec_hdr before writing, so
842 * the caller do not have to fill them. Callers must only fill the @ec_hdr->ec
843 * field.
844 *
845 * This function returns zero in case of success and a negative error code in
846 * case of failure. If %-EIO is returned, the physical eraseblock most probably
847 * went bad.
848 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300849int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400850 struct ubi_ec_hdr *ec_hdr)
851{
852 int err;
853 uint32_t crc;
854
855 dbg_io("write EC header to PEB %d", pnum);
856 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
857
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300858 ec_hdr->magic = cpu_to_be32(UBI_EC_HDR_MAGIC);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400859 ec_hdr->version = UBI_VERSION;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300860 ec_hdr->vid_hdr_offset = cpu_to_be32(ubi->vid_hdr_offset);
861 ec_hdr->data_offset = cpu_to_be32(ubi->leb_start);
Adrian Hunter0c6c7fa2009-06-26 14:58:01 +0300862 ec_hdr->image_seq = cpu_to_be32(ubi->image_seq);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400863 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300864 ec_hdr->hdr_crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400865
Artem Bityutskiy8056eb42012-05-16 18:24:09 +0300866 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400867 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +0200868 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400869
870 err = ubi_io_write(ubi, ec_hdr, pnum, 0, ubi->ec_hdr_alsize);
871 return err;
872}
873
874/**
875 * validate_vid_hdr - validate a volume identifier header.
876 * @ubi: UBI device description object
877 * @vid_hdr: the volume identifier header to check
878 *
879 * This function checks that data stored in the volume identifier header
880 * @vid_hdr. Returns zero if the VID header is OK and %1 if not.
881 */
882static int validate_vid_hdr(const struct ubi_device *ubi,
883 const struct ubi_vid_hdr *vid_hdr)
884{
885 int vol_type = vid_hdr->vol_type;
886 int copy_flag = vid_hdr->copy_flag;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300887 int vol_id = be32_to_cpu(vid_hdr->vol_id);
888 int lnum = be32_to_cpu(vid_hdr->lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400889 int compat = vid_hdr->compat;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300890 int data_size = be32_to_cpu(vid_hdr->data_size);
891 int used_ebs = be32_to_cpu(vid_hdr->used_ebs);
892 int data_pad = be32_to_cpu(vid_hdr->data_pad);
893 int data_crc = be32_to_cpu(vid_hdr->data_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400894 int usable_leb_size = ubi->leb_size - data_pad;
895
896 if (copy_flag != 0 && copy_flag != 1) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300897 ubi_err("bad copy_flag");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400898 goto bad;
899 }
900
901 if (vol_id < 0 || lnum < 0 || data_size < 0 || used_ebs < 0 ||
902 data_pad < 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300903 ubi_err("negative values");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400904 goto bad;
905 }
906
907 if (vol_id >= UBI_MAX_VOLUMES && vol_id < UBI_INTERNAL_VOL_START) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300908 ubi_err("bad vol_id");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400909 goto bad;
910 }
911
912 if (vol_id < UBI_INTERNAL_VOL_START && compat != 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300913 ubi_err("bad compat");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400914 goto bad;
915 }
916
917 if (vol_id >= UBI_INTERNAL_VOL_START && compat != UBI_COMPAT_DELETE &&
918 compat != UBI_COMPAT_RO && compat != UBI_COMPAT_PRESERVE &&
919 compat != UBI_COMPAT_REJECT) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300920 ubi_err("bad compat");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400921 goto bad;
922 }
923
924 if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300925 ubi_err("bad vol_type");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400926 goto bad;
927 }
928
929 if (data_pad >= ubi->leb_size / 2) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300930 ubi_err("bad data_pad");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400931 goto bad;
932 }
933
934 if (vol_type == UBI_VID_STATIC) {
935 /*
936 * Although from high-level point of view static volumes may
937 * contain zero bytes of data, but no VID headers can contain
938 * zero at these fields, because they empty volumes do not have
939 * mapped logical eraseblocks.
940 */
941 if (used_ebs == 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300942 ubi_err("zero used_ebs");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400943 goto bad;
944 }
945 if (data_size == 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300946 ubi_err("zero data_size");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400947 goto bad;
948 }
949 if (lnum < used_ebs - 1) {
950 if (data_size != usable_leb_size) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300951 ubi_err("bad data_size");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400952 goto bad;
953 }
954 } else if (lnum == used_ebs - 1) {
955 if (data_size == 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300956 ubi_err("bad data_size at last LEB");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400957 goto bad;
958 }
959 } else {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300960 ubi_err("too high lnum");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400961 goto bad;
962 }
963 } else {
964 if (copy_flag == 0) {
965 if (data_crc != 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300966 ubi_err("non-zero data CRC");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400967 goto bad;
968 }
969 if (data_size != 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300970 ubi_err("non-zero data_size");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400971 goto bad;
972 }
973 } else {
974 if (data_size == 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300975 ubi_err("zero data_size of copy");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400976 goto bad;
977 }
978 }
979 if (used_ebs != 0) {
Artem Bityutskiye2986822012-05-16 18:39:56 +0300980 ubi_err("bad used_ebs");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400981 goto bad;
982 }
983 }
984
985 return 0;
986
987bad:
988 ubi_err("bad VID header");
Artem Bityutskiya904e3f2012-04-25 09:02:44 +0300989 ubi_dump_vid_hdr(vid_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +0300990 dump_stack();
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400991 return 1;
992}
993
994/**
995 * ubi_io_read_vid_hdr - read and check a volume identifier header.
996 * @ubi: UBI device description object
997 * @pnum: physical eraseblock number to read from
998 * @vid_hdr: &struct ubi_vid_hdr object where to store the read volume
999 * identifier header
1000 * @verbose: be verbose if the header is corrupted or wasn't found
1001 *
1002 * This function reads the volume identifier header from physical eraseblock
1003 * @pnum and stores it in @vid_hdr. It also checks CRC checksum of the read
Artem Bityutskiy74d82d22010-09-03 02:11:20 +03001004 * volume identifier header. The error codes are the same as in
1005 * 'ubi_io_read_ec_hdr()'.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001006 *
Artem Bityutskiy74d82d22010-09-03 02:11:20 +03001007 * Note, the implementation of this function is also very similar to
1008 * 'ubi_io_read_ec_hdr()', so refer commentaries in 'ubi_io_read_ec_hdr()'.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001009 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001010int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001011 struct ubi_vid_hdr *vid_hdr, int verbose)
1012{
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001013 int err, read_err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001014 uint32_t crc, magic, hdr_crc;
1015 void *p;
1016
1017 dbg_io("read VID header from PEB %d", pnum);
1018 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1019
1020 p = (char *)vid_hdr - ubi->vid_hdr_shift;
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001021 read_err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001022 ubi->vid_hdr_alsize);
Brian Norrisd57f40542011-09-20 18:34:25 -07001023 if (read_err && read_err != UBI_IO_BITFLIPS && !mtd_is_eccerr(read_err))
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001024 return read_err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001025
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001026 magic = be32_to_cpu(vid_hdr->magic);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001027 if (magic != UBI_VID_HDR_MAGIC) {
Brian Norrisd57f40542011-09-20 18:34:25 -07001028 if (mtd_is_eccerr(read_err))
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001029 return UBI_IO_BAD_HDR_EBADMSG;
Artem Bityutskiyeb895802010-05-03 09:04:39 +03001030
Artem Bityutskiybb00e182010-07-31 09:37:34 +03001031 if (ubi_check_pattern(vid_hdr, 0xFF, UBI_VID_HDR_SIZE)) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001032 if (verbose)
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001033 ubi_warn("no VID header found at PEB %d, only 0xFF bytes",
1034 pnum);
1035 dbg_bld("no VID header found at PEB %d, only 0xFF bytes",
1036 pnum);
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001037 if (!read_err)
1038 return UBI_IO_FF;
1039 else
1040 return UBI_IO_FF_BITFLIPS;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001041 }
1042
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001043 if (verbose) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001044 ubi_warn("bad magic number at PEB %d: %08x instead of %08x",
1045 pnum, magic, UBI_VID_HDR_MAGIC);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001046 ubi_dump_vid_hdr(vid_hdr);
Artem Bityutskiy6f9fdf62011-03-11 13:08:51 +02001047 }
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001048 dbg_bld("bad magic number at PEB %d: %08x instead of %08x",
1049 pnum, magic, UBI_VID_HDR_MAGIC);
Artem Bityutskiy786d7832010-04-30 16:50:22 +03001050 return UBI_IO_BAD_HDR;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001051 }
1052
1053 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001054 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001055
1056 if (hdr_crc != crc) {
1057 if (verbose) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001058 ubi_warn("bad CRC at PEB %d, calculated %#08x, read %#08x",
1059 pnum, crc, hdr_crc);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001060 ubi_dump_vid_hdr(vid_hdr);
Artem Bityutskiy6f9fdf62011-03-11 13:08:51 +02001061 }
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001062 dbg_bld("bad CRC at PEB %d, calculated %#08x, read %#08x",
1063 pnum, crc, hdr_crc);
Artem Bityutskiy92e1a7d2010-09-03 14:22:17 +03001064 if (!read_err)
1065 return UBI_IO_BAD_HDR;
1066 else
1067 return UBI_IO_BAD_HDR_EBADMSG;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001068 }
1069
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001070 err = validate_vid_hdr(ubi, vid_hdr);
1071 if (err) {
1072 ubi_err("validation failed for PEB %d", pnum);
1073 return -EINVAL;
1074 }
1075
1076 return read_err ? UBI_IO_BITFLIPS : 0;
1077}
1078
1079/**
1080 * ubi_io_write_vid_hdr - write a volume identifier header.
1081 * @ubi: UBI device description object
1082 * @pnum: the physical eraseblock number to write to
1083 * @vid_hdr: the volume identifier header to write
1084 *
1085 * This function writes the volume identifier header described by @vid_hdr to
1086 * physical eraseblock @pnum. This function automatically fills the
1087 * @vid_hdr->magic and the @vid_hdr->version fields, as well as calculates
1088 * header CRC checksum and stores it at vid_hdr->hdr_crc.
1089 *
1090 * This function returns zero in case of success and a negative error code in
1091 * case of failure. If %-EIO is returned, the physical eraseblock probably went
1092 * bad.
1093 */
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001094int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001095 struct ubi_vid_hdr *vid_hdr)
1096{
1097 int err;
1098 uint32_t crc;
1099 void *p;
1100
1101 dbg_io("write VID header to PEB %d", pnum);
1102 ubi_assert(pnum >= 0 && pnum < ubi->peb_count);
1103
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001104 err = self_check_peb_ec_hdr(ubi, pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001105 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001106 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001107
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001108 vid_hdr->magic = cpu_to_be32(UBI_VID_HDR_MAGIC);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001109 vid_hdr->version = UBI_VERSION;
1110 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_VID_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001111 vid_hdr->hdr_crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001112
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001113 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001114 if (err)
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001115 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001116
1117 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1118 err = ubi_io_write(ubi, p, pnum, ubi->vid_hdr_aloffset,
1119 ubi->vid_hdr_alsize);
1120 return err;
1121}
1122
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001123/**
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001124 * self_check_not_bad - ensure that a physical eraseblock is not bad.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001125 * @ubi: UBI device description object
1126 * @pnum: physical eraseblock number to check
1127 *
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001128 * This function returns zero if the physical eraseblock is good, %-EINVAL if
1129 * it is bad and a negative error code if an error occurred.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001130 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001131static int self_check_not_bad(const struct ubi_device *ubi, int pnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001132{
1133 int err;
1134
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001135 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001136 return 0;
1137
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001138 err = ubi_io_is_bad(ubi, pnum);
1139 if (!err)
1140 return err;
1141
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001142 ubi_err("self-check failed for PEB %d", pnum);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001143 dump_stack();
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001144 return err > 0 ? -EINVAL : err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001145}
1146
1147/**
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001148 * self_check_ec_hdr - check if an erase counter header is all right.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001149 * @ubi: UBI device description object
1150 * @pnum: physical eraseblock number the erase counter header belongs to
1151 * @ec_hdr: the erase counter header to check
1152 *
1153 * This function returns zero if the erase counter header contains valid
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001154 * values, and %-EINVAL if not.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001155 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001156static int self_check_ec_hdr(const struct ubi_device *ubi, int pnum,
1157 const struct ubi_ec_hdr *ec_hdr)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001158{
1159 int err;
1160 uint32_t magic;
1161
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001162 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001163 return 0;
1164
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001165 magic = be32_to_cpu(ec_hdr->magic);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001166 if (magic != UBI_EC_HDR_MAGIC) {
1167 ubi_err("bad magic %#08x, must be %#08x",
1168 magic, UBI_EC_HDR_MAGIC);
1169 goto fail;
1170 }
1171
1172 err = validate_ec_hdr(ubi, ec_hdr);
1173 if (err) {
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001174 ubi_err("self-check failed for PEB %d", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001175 goto fail;
1176 }
1177
1178 return 0;
1179
1180fail:
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001181 ubi_dump_ec_hdr(ec_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001182 dump_stack();
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001183 return -EINVAL;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001184}
1185
1186/**
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001187 * self_check_peb_ec_hdr - check erase counter header.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001188 * @ubi: UBI device description object
1189 * @pnum: the physical eraseblock number to check
1190 *
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001191 * This function returns zero if the erase counter header is all right and and
1192 * a negative error code if not or if an error occurred.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001193 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001194static int self_check_peb_ec_hdr(const struct ubi_device *ubi, int pnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001195{
1196 int err;
1197 uint32_t crc, hdr_crc;
1198 struct ubi_ec_hdr *ec_hdr;
1199
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001200 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001201 return 0;
1202
Artem Bityutskiy33818bb2007-08-28 21:29:32 +03001203 ec_hdr = kzalloc(ubi->ec_hdr_alsize, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001204 if (!ec_hdr)
1205 return -ENOMEM;
1206
1207 err = ubi_io_read(ubi, ec_hdr, pnum, 0, UBI_EC_HDR_SIZE);
Brian Norrisd57f40542011-09-20 18:34:25 -07001208 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001209 goto exit;
1210
1211 crc = crc32(UBI_CRC32_INIT, ec_hdr, UBI_EC_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001212 hdr_crc = be32_to_cpu(ec_hdr->hdr_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001213 if (hdr_crc != crc) {
1214 ubi_err("bad CRC, calculated %#08x, read %#08x", crc, hdr_crc);
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001215 ubi_err("self-check failed for PEB %d", pnum);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001216 ubi_dump_ec_hdr(ec_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001217 dump_stack();
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001218 err = -EINVAL;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001219 goto exit;
1220 }
1221
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001222 err = self_check_ec_hdr(ubi, pnum, ec_hdr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001223
1224exit:
1225 kfree(ec_hdr);
1226 return err;
1227}
1228
1229/**
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001230 * self_check_vid_hdr - check that a volume identifier header is all right.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001231 * @ubi: UBI device description object
1232 * @pnum: physical eraseblock number the volume identifier header belongs to
1233 * @vid_hdr: the volume identifier header to check
1234 *
1235 * This function returns zero if the volume identifier header is all right, and
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001236 * %-EINVAL if not.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001237 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001238static int self_check_vid_hdr(const struct ubi_device *ubi, int pnum,
1239 const struct ubi_vid_hdr *vid_hdr)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001240{
1241 int err;
1242 uint32_t magic;
1243
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001244 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001245 return 0;
1246
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001247 magic = be32_to_cpu(vid_hdr->magic);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001248 if (magic != UBI_VID_HDR_MAGIC) {
1249 ubi_err("bad VID header magic %#08x at PEB %d, must be %#08x",
1250 magic, pnum, UBI_VID_HDR_MAGIC);
1251 goto fail;
1252 }
1253
1254 err = validate_vid_hdr(ubi, vid_hdr);
1255 if (err) {
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001256 ubi_err("self-check failed for PEB %d", pnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001257 goto fail;
1258 }
1259
1260 return err;
1261
1262fail:
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001263 ubi_err("self-check failed for PEB %d", pnum);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001264 ubi_dump_vid_hdr(vid_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001265 dump_stack();
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001266 return -EINVAL;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001267
1268}
1269
1270/**
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001271 * self_check_peb_vid_hdr - check volume identifier header.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001272 * @ubi: UBI device description object
1273 * @pnum: the physical eraseblock number to check
1274 *
1275 * This function returns zero if the volume identifier header is all right,
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001276 * and a negative error code if not or if an error occurred.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001277 */
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001278static int self_check_peb_vid_hdr(const struct ubi_device *ubi, int pnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001279{
1280 int err;
1281 uint32_t crc, hdr_crc;
1282 struct ubi_vid_hdr *vid_hdr;
1283 void *p;
1284
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001285 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001286 return 0;
1287
Artem Bityutskiy33818bb2007-08-28 21:29:32 +03001288 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001289 if (!vid_hdr)
1290 return -ENOMEM;
1291
1292 p = (char *)vid_hdr - ubi->vid_hdr_shift;
1293 err = ubi_io_read(ubi, p, pnum, ubi->vid_hdr_aloffset,
1294 ubi->vid_hdr_alsize);
Brian Norrisd57f40542011-09-20 18:34:25 -07001295 if (err && err != UBI_IO_BITFLIPS && !mtd_is_eccerr(err))
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001296 goto exit;
1297
1298 crc = crc32(UBI_CRC32_INIT, vid_hdr, UBI_EC_HDR_SIZE_CRC);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001299 hdr_crc = be32_to_cpu(vid_hdr->hdr_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001300 if (hdr_crc != crc) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001301 ubi_err("bad VID header CRC at PEB %d, calculated %#08x, read %#08x",
1302 pnum, crc, hdr_crc);
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001303 ubi_err("self-check failed for PEB %d", pnum);
Artem Bityutskiya904e3f2012-04-25 09:02:44 +03001304 ubi_dump_vid_hdr(vid_hdr);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001305 dump_stack();
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001306 err = -EINVAL;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001307 goto exit;
1308 }
1309
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001310 err = self_check_vid_hdr(ubi, pnum, vid_hdr);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001311
1312exit:
1313 ubi_free_vid_hdr(ubi, vid_hdr);
1314 return err;
1315}
1316
1317/**
Artem Bityutskiy97d61042012-05-16 19:29:04 +03001318 * self_check_write - make sure write succeeded.
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001319 * @ubi: UBI device description object
1320 * @buf: buffer with data which were written
1321 * @pnum: physical eraseblock number the data were written to
1322 * @offset: offset within the physical eraseblock the data were written to
1323 * @len: how many bytes were written
1324 *
1325 * This functions reads data which were recently written and compares it with
1326 * the original data buffer - the data have to match. Returns zero if the data
1327 * match and a negative error code if not or in case of failure.
1328 */
Artem Bityutskiy97d61042012-05-16 19:29:04 +03001329static int self_check_write(struct ubi_device *ubi, const void *buf, int pnum,
1330 int offset, int len)
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001331{
1332 int err, i;
Artem Bityutskiy7950d022010-11-19 17:05:36 +02001333 size_t read;
Artem Bityutskiya7586742011-03-14 17:06:52 +02001334 void *buf1;
Artem Bityutskiy7950d022010-11-19 17:05:36 +02001335 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001336
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001337 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001338 return 0;
1339
Artem Bityutskiy3d46b312011-03-24 16:09:56 +02001340 buf1 = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
Artem Bityutskiya7586742011-03-14 17:06:52 +02001341 if (!buf1) {
1342 ubi_err("cannot allocate memory to check writes");
1343 return 0;
1344 }
1345
Artem Bityutskiy329ad392011-12-23 17:30:16 +02001346 err = mtd_read(ubi->mtd, addr, len, &read, buf1);
Brian Norrisd57f40542011-09-20 18:34:25 -07001347 if (err && !mtd_is_bitflip(err))
Artem Bityutskiya7586742011-03-14 17:06:52 +02001348 goto out_free;
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001349
1350 for (i = 0; i < len; i++) {
1351 uint8_t c = ((uint8_t *)buf)[i];
Artem Bityutskiya7586742011-03-14 17:06:52 +02001352 uint8_t c1 = ((uint8_t *)buf1)[i];
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001353 int dump_len;
1354
1355 if (c == c1)
1356 continue;
1357
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001358 ubi_err("self-check failed for PEB %d:%d, len %d",
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001359 pnum, offset, len);
1360 ubi_msg("data differ at position %d", i);
1361 dump_len = max_t(int, 128, len - i);
1362 ubi_msg("hex dump of the original buffer from %d to %d",
1363 i, i + dump_len);
1364 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
1365 buf + i, dump_len, 1);
1366 ubi_msg("hex dump of the read buffer from %d to %d",
1367 i, i + dump_len);
1368 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
Artem Bityutskiya7586742011-03-14 17:06:52 +02001369 buf1 + i, dump_len, 1);
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001370 dump_stack();
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001371 err = -EINVAL;
Artem Bityutskiya7586742011-03-14 17:06:52 +02001372 goto out_free;
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001373 }
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001374
Artem Bityutskiya7586742011-03-14 17:06:52 +02001375 vfree(buf1);
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001376 return 0;
1377
Artem Bityutskiya7586742011-03-14 17:06:52 +02001378out_free:
1379 vfree(buf1);
Artem Bityutskiy6e9065d2010-01-25 17:09:30 +02001380 return err;
1381}
1382
1383/**
Artem Bityutskiy97d61042012-05-16 19:29:04 +03001384 * ubi_self_check_all_ff - check that a region of flash is empty.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001385 * @ubi: UBI device description object
1386 * @pnum: the physical eraseblock number to check
1387 * @offset: the starting offset within the physical eraseblock to check
1388 * @len: the length of the region to check
1389 *
1390 * This function returns zero if only 0xFF bytes are present at offset
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001391 * @offset of the physical eraseblock @pnum, and a negative error code if not
1392 * or if an error occurred.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001393 */
Artem Bityutskiy97d61042012-05-16 19:29:04 +03001394int ubi_self_check_all_ff(struct ubi_device *ubi, int pnum, int offset, int len)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001395{
1396 size_t read;
1397 int err;
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001398 void *buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001399 loff_t addr = (loff_t)pnum * ubi->peb_size + offset;
1400
Artem Bityutskiy2a734bb2011-05-18 14:53:05 +03001401 if (!ubi->dbg->chk_io)
Artem Bityutskiy92d124f2011-03-14 18:17:40 +02001402 return 0;
1403
Artem Bityutskiy3d46b312011-03-24 16:09:56 +02001404 buf = __vmalloc(len, GFP_NOFS, PAGE_KERNEL);
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001405 if (!buf) {
1406 ubi_err("cannot allocate memory to check for 0xFFs");
1407 return 0;
1408 }
1409
Artem Bityutskiy329ad392011-12-23 17:30:16 +02001410 err = mtd_read(ubi->mtd, addr, len, &read, buf);
Brian Norrisd57f40542011-09-20 18:34:25 -07001411 if (err && !mtd_is_bitflip(err)) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001412 ubi_err("error %d while reading %d bytes from PEB %d:%d, read %zd bytes",
1413 err, len, pnum, offset, read);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001414 goto error;
1415 }
1416
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001417 err = ubi_check_pattern(buf, 0xFF, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001418 if (err == 0) {
Artem Bityutskiy049333c2012-08-27 14:43:54 +03001419 ubi_err("flash region at PEB %d:%d, length %d does not contain all 0xFF bytes",
1420 pnum, offset, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001421 goto fail;
1422 }
1423
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001424 vfree(buf);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001425 return 0;
1426
1427fail:
Artem Bityutskiy8056eb42012-05-16 18:24:09 +03001428 ubi_err("self-check failed for PEB %d", pnum);
Artem Bityutskiyc8566352008-07-16 17:40:22 +03001429 ubi_msg("hex dump of the %d-%d region", offset, offset + len);
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001430 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1, buf, len, 1);
Artem Bityutskiyadbf05e2010-01-20 10:28:58 +02001431 err = -EINVAL;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001432error:
Artem Bityutskiy25886a32012-04-24 06:59:49 +03001433 dump_stack();
Artem Bityutskiy332873d2011-03-14 17:09:40 +02001434 vfree(buf);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001435 return err;
1436}