blob: 613cd1e51648db44283920df488a782a59209310 [file] [log] [blame]
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001/*
2 * Copyright (c) International Business Machines Corp., 2006
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12 * the GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * Author: Artem Bityutskiy (Битюцкий Артём)
19 */
20
21/*
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030022 * The UBI Eraseblock Association (EBA) sub-system.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040023 *
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030024 * This sub-system is responsible for I/O to/from logical eraseblock.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040025 *
26 * Although in this implementation the EBA table is fully kept and managed in
27 * RAM, which assumes poor scalability, it might be (partially) maintained on
28 * flash in future implementations.
29 *
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +030030 * The EBA sub-system implements per-logical eraseblock locking. Before
31 * accessing a logical eraseblock it is locked for reading or writing. The
32 * per-logical eraseblock locking is implemented by means of the lock tree. The
33 * lock tree is an RB-tree which refers all the currently locked logical
34 * eraseblocks. The lock tree elements are &struct ubi_ltree_entry objects.
35 * They are indexed by (@vol_id, @lnum) pairs.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040036 *
37 * EBA also maintains the global sequence counter which is incremented each
38 * time a logical eraseblock is mapped to a physical eraseblock and it is
39 * stored in the volume identifier header. This means that each VID header has
40 * a unique sequence number. The sequence number is only increased an we assume
41 * 64 bits is enough to never overflow.
42 */
43
44#include <linux/slab.h>
45#include <linux/crc32.h>
46#include <linux/err.h>
47#include "ubi.h"
48
Artem Bityutskiye8823bd2007-09-13 14:28:14 +030049/* Number of physical eraseblocks reserved for atomic LEB change operation */
50#define EBA_RESERVED_PEBS 1
51
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040052/**
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040053 * next_sqnum - get next sequence number.
54 * @ubi: UBI device description object
55 *
56 * This function returns next sequence number to use, which is just the current
57 * global sequence counter value. It also increases the global sequence
58 * counter.
59 */
60static unsigned long long next_sqnum(struct ubi_device *ubi)
61{
62 unsigned long long sqnum;
63
64 spin_lock(&ubi->ltree_lock);
65 sqnum = ubi->global_sqnum++;
66 spin_unlock(&ubi->ltree_lock);
67
68 return sqnum;
69}
70
71/**
72 * ubi_get_compat - get compatibility flags of a volume.
73 * @ubi: UBI device description object
74 * @vol_id: volume ID
75 *
76 * This function returns compatibility flags for an internal volume. User
77 * volumes have no compatibility flags, so %0 is returned.
78 */
79static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
80{
Artem Bityutskiy91f2d532008-01-24 11:23:23 +020081 if (vol_id == UBI_LAYOUT_VOLUME_ID)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040082 return UBI_LAYOUT_VOLUME_COMPAT;
83 return 0;
84}
85
86/**
87 * ltree_lookup - look up the lock tree.
88 * @ubi: UBI device description object
89 * @vol_id: volume ID
90 * @lnum: logical eraseblock number
91 *
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +020092 * This function returns a pointer to the corresponding &struct ubi_ltree_entry
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040093 * object if the logical eraseblock is locked and %NULL if it is not.
94 * @ubi->ltree_lock has to be locked.
95 */
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +020096static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
97 int lnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +040098{
99 struct rb_node *p;
100
101 p = ubi->ltree.rb_node;
102 while (p) {
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200103 struct ubi_ltree_entry *le;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400104
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200105 le = rb_entry(p, struct ubi_ltree_entry, rb);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400106
107 if (vol_id < le->vol_id)
108 p = p->rb_left;
109 else if (vol_id > le->vol_id)
110 p = p->rb_right;
111 else {
112 if (lnum < le->lnum)
113 p = p->rb_left;
114 else if (lnum > le->lnum)
115 p = p->rb_right;
116 else
117 return le;
118 }
119 }
120
121 return NULL;
122}
123
124/**
125 * ltree_add_entry - add new entry to the lock tree.
126 * @ubi: UBI device description object
127 * @vol_id: volume ID
128 * @lnum: logical eraseblock number
129 *
130 * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the
131 * lock tree. If such entry is already there, its usage counter is increased.
132 * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation
133 * failed.
134 */
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200135static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
136 int vol_id, int lnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400137{
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200138 struct ubi_ltree_entry *le, *le1, *le_free;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400139
Artem Bityutskiyb9a06622008-01-16 12:11:54 +0200140 le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400141 if (!le)
142 return ERR_PTR(-ENOMEM);
143
Artem Bityutskiyb9a06622008-01-16 12:11:54 +0200144 le->users = 0;
145 init_rwsem(&le->mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400146 le->vol_id = vol_id;
147 le->lnum = lnum;
148
149 spin_lock(&ubi->ltree_lock);
150 le1 = ltree_lookup(ubi, vol_id, lnum);
151
152 if (le1) {
153 /*
154 * This logical eraseblock is already locked. The newly
155 * allocated lock entry is not needed.
156 */
157 le_free = le;
158 le = le1;
159 } else {
160 struct rb_node **p, *parent = NULL;
161
162 /*
163 * No lock entry, add the newly allocated one to the
164 * @ubi->ltree RB-tree.
165 */
166 le_free = NULL;
167
168 p = &ubi->ltree.rb_node;
169 while (*p) {
170 parent = *p;
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200171 le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400172
173 if (vol_id < le1->vol_id)
174 p = &(*p)->rb_left;
175 else if (vol_id > le1->vol_id)
176 p = &(*p)->rb_right;
177 else {
178 ubi_assert(lnum != le1->lnum);
179 if (lnum < le1->lnum)
180 p = &(*p)->rb_left;
181 else
182 p = &(*p)->rb_right;
183 }
184 }
185
186 rb_link_node(&le->rb, parent, p);
187 rb_insert_color(&le->rb, &ubi->ltree);
188 }
189 le->users += 1;
190 spin_unlock(&ubi->ltree_lock);
191
192 if (le_free)
Artem Bityutskiyb9a06622008-01-16 12:11:54 +0200193 kfree(le_free);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400194
195 return le;
196}
197
198/**
199 * leb_read_lock - lock logical eraseblock for reading.
200 * @ubi: UBI device description object
201 * @vol_id: volume ID
202 * @lnum: logical eraseblock number
203 *
204 * This function locks a logical eraseblock for reading. Returns zero in case
205 * of success and a negative error code in case of failure.
206 */
207static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
208{
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200209 struct ubi_ltree_entry *le;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400210
211 le = ltree_add_entry(ubi, vol_id, lnum);
212 if (IS_ERR(le))
213 return PTR_ERR(le);
214 down_read(&le->mutex);
215 return 0;
216}
217
218/**
219 * leb_read_unlock - unlock logical eraseblock.
220 * @ubi: UBI device description object
221 * @vol_id: volume ID
222 * @lnum: logical eraseblock number
223 */
224static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
225{
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200226 struct ubi_ltree_entry *le;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400227
228 spin_lock(&ubi->ltree_lock);
229 le = ltree_lookup(ubi, vol_id, lnum);
230 le->users -= 1;
231 ubi_assert(le->users >= 0);
Artem Bityutskiy23add742008-06-16 13:35:23 +0300232 up_read(&le->mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400233 if (le->users == 0) {
234 rb_erase(&le->rb, &ubi->ltree);
Artem Bityutskiy23add742008-06-16 13:35:23 +0300235 kfree(le);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400236 }
237 spin_unlock(&ubi->ltree_lock);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400238}
239
240/**
241 * leb_write_lock - lock logical eraseblock for writing.
242 * @ubi: UBI device description object
243 * @vol_id: volume ID
244 * @lnum: logical eraseblock number
245 *
246 * This function locks a logical eraseblock for writing. Returns zero in case
247 * of success and a negative error code in case of failure.
248 */
249static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
250{
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200251 struct ubi_ltree_entry *le;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400252
253 le = ltree_add_entry(ubi, vol_id, lnum);
254 if (IS_ERR(le))
255 return PTR_ERR(le);
256 down_write(&le->mutex);
257 return 0;
258}
259
260/**
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200261 * leb_write_lock - lock logical eraseblock for writing.
262 * @ubi: UBI device description object
263 * @vol_id: volume ID
264 * @lnum: logical eraseblock number
265 *
266 * This function locks a logical eraseblock for writing if there is no
267 * contention and does nothing if there is contention. Returns %0 in case of
268 * success, %1 in case of contention, and and a negative error code in case of
269 * failure.
270 */
271static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
272{
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200273 struct ubi_ltree_entry *le;
274
275 le = ltree_add_entry(ubi, vol_id, lnum);
276 if (IS_ERR(le))
277 return PTR_ERR(le);
278 if (down_write_trylock(&le->mutex))
279 return 0;
280
281 /* Contention, cancel */
282 spin_lock(&ubi->ltree_lock);
283 le->users -= 1;
284 ubi_assert(le->users >= 0);
285 if (le->users == 0) {
286 rb_erase(&le->rb, &ubi->ltree);
Artem Bityutskiyb9a06622008-01-16 12:11:54 +0200287 kfree(le);
Artem Bityutskiy23add742008-06-16 13:35:23 +0300288 }
289 spin_unlock(&ubi->ltree_lock);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200290
291 return 1;
292}
293
294/**
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400295 * leb_write_unlock - unlock logical eraseblock.
296 * @ubi: UBI device description object
297 * @vol_id: volume ID
298 * @lnum: logical eraseblock number
299 */
300static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
301{
Artem Bityutskiy3a8d4642007-12-16 12:32:51 +0200302 struct ubi_ltree_entry *le;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400303
304 spin_lock(&ubi->ltree_lock);
305 le = ltree_lookup(ubi, vol_id, lnum);
306 le->users -= 1;
307 ubi_assert(le->users >= 0);
Artem Bityutskiy23add742008-06-16 13:35:23 +0300308 up_write(&le->mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400309 if (le->users == 0) {
310 rb_erase(&le->rb, &ubi->ltree);
Artem Bityutskiyb9a06622008-01-16 12:11:54 +0200311 kfree(le);
Artem Bityutskiy23add742008-06-16 13:35:23 +0300312 }
313 spin_unlock(&ubi->ltree_lock);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400314}
315
316/**
317 * ubi_eba_unmap_leb - un-map logical eraseblock.
318 * @ubi: UBI device description object
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200319 * @vol: volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400320 * @lnum: logical eraseblock number
321 *
322 * This function un-maps logical eraseblock @lnum and schedules corresponding
323 * physical eraseblock for erasure. Returns zero in case of success and a
324 * negative error code in case of failure.
325 */
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200326int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
327 int lnum)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400328{
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200329 int err, pnum, vol_id = vol->vol_id;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400330
331 if (ubi->ro_mode)
332 return -EROFS;
333
334 err = leb_write_lock(ubi, vol_id, lnum);
335 if (err)
336 return err;
337
338 pnum = vol->eba_tbl[lnum];
339 if (pnum < 0)
340 /* This logical eraseblock is already unmapped */
341 goto out_unlock;
342
343 dbg_eba("erase LEB %d:%d, PEB %d", vol_id, lnum, pnum);
344
345 vol->eba_tbl[lnum] = UBI_LEB_UNMAPPED;
346 err = ubi_wl_put_peb(ubi, pnum, 0);
347
348out_unlock:
349 leb_write_unlock(ubi, vol_id, lnum);
350 return err;
351}
352
353/**
354 * ubi_eba_read_leb - read data.
355 * @ubi: UBI device description object
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200356 * @vol: volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400357 * @lnum: logical eraseblock number
358 * @buf: buffer to store the read data
359 * @offset: offset from where to read
360 * @len: how many bytes to read
361 * @check: data CRC check flag
362 *
363 * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF
364 * bytes. The @check flag only makes sense for static volumes and forces
365 * eraseblock data CRC checking.
366 *
367 * In case of success this function returns zero. In case of a static volume,
368 * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be
369 * returned for any volume type if an ECC error was detected by the MTD device
370 * driver. Other negative error cored may be returned in case of other errors.
371 */
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200372int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
373 void *buf, int offset, int len, int check)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400374{
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200375 int err, pnum, scrub = 0, vol_id = vol->vol_id;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400376 struct ubi_vid_hdr *vid_hdr;
Jeff Garzika6343af2007-07-17 05:39:58 -0400377 uint32_t uninitialized_var(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400378
379 err = leb_read_lock(ubi, vol_id, lnum);
380 if (err)
381 return err;
382
383 pnum = vol->eba_tbl[lnum];
384 if (pnum < 0) {
385 /*
386 * The logical eraseblock is not mapped, fill the whole buffer
387 * with 0xFF bytes. The exception is static volumes for which
388 * it is an error to read unmapped logical eraseblocks.
389 */
390 dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",
391 len, offset, vol_id, lnum);
392 leb_read_unlock(ubi, vol_id, lnum);
393 ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);
394 memset(buf, 0xFF, len);
395 return 0;
396 }
397
398 dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",
399 len, offset, vol_id, lnum, pnum);
400
401 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
402 check = 0;
403
404retry:
405 if (check) {
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300406 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400407 if (!vid_hdr) {
408 err = -ENOMEM;
409 goto out_unlock;
410 }
411
412 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
413 if (err && err != UBI_IO_BITFLIPS) {
414 if (err > 0) {
415 /*
416 * The header is either absent or corrupted.
417 * The former case means there is a bug -
418 * switch to read-only mode just in case.
419 * The latter case means a real corruption - we
420 * may try to recover data. FIXME: but this is
421 * not implemented.
422 */
423 if (err == UBI_IO_BAD_VID_HDR) {
424 ubi_warn("bad VID header at PEB %d, LEB"
425 "%d:%d", pnum, vol_id, lnum);
426 err = -EBADMSG;
427 } else
428 ubi_ro_mode(ubi);
429 }
430 goto out_free;
431 } else if (err == UBI_IO_BITFLIPS)
432 scrub = 1;
433
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300434 ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs));
435 ubi_assert(len == be32_to_cpu(vid_hdr->data_size));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400436
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300437 crc = be32_to_cpu(vid_hdr->data_crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400438 ubi_free_vid_hdr(ubi, vid_hdr);
439 }
440
441 err = ubi_io_read_data(ubi, buf, pnum, offset, len);
442 if (err) {
443 if (err == UBI_IO_BITFLIPS) {
444 scrub = 1;
445 err = 0;
446 } else if (err == -EBADMSG) {
447 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
448 goto out_unlock;
449 scrub = 1;
450 if (!check) {
451 ubi_msg("force data checking");
452 check = 1;
453 goto retry;
454 }
455 } else
456 goto out_unlock;
457 }
458
459 if (check) {
Jeff Garzik2ab934b2007-07-17 01:49:56 -0400460 uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400461 if (crc1 != crc) {
462 ubi_warn("CRC error: calculated %#08x, must be %#08x",
463 crc1, crc);
464 err = -EBADMSG;
465 goto out_unlock;
466 }
467 }
468
469 if (scrub)
470 err = ubi_wl_scrub_peb(ubi, pnum);
471
472 leb_read_unlock(ubi, vol_id, lnum);
473 return err;
474
475out_free:
476 ubi_free_vid_hdr(ubi, vid_hdr);
477out_unlock:
478 leb_read_unlock(ubi, vol_id, lnum);
479 return err;
480}
481
482/**
483 * recover_peb - recover from write failure.
484 * @ubi: UBI device description object
485 * @pnum: the physical eraseblock to recover
486 * @vol_id: volume ID
487 * @lnum: logical eraseblock number
488 * @buf: data which was not written because of the write failure
489 * @offset: offset of the failed write
490 * @len: how many bytes should have been written
491 *
492 * This function is called in case of a write failure and moves all good data
493 * from the potentially bad physical eraseblock to a good physical eraseblock.
494 * This function also writes the data which was not written due to the failure.
495 * Returns new physical eraseblock number in case of success, and a negative
496 * error code in case of failure.
497 */
498static int recover_peb(struct ubi_device *ubi, int pnum, int vol_id, int lnum,
499 const void *buf, int offset, int len)
500{
501 int err, idx = vol_id2idx(ubi, vol_id), new_pnum, data_size, tries = 0;
502 struct ubi_volume *vol = ubi->volumes[idx];
503 struct ubi_vid_hdr *vid_hdr;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400504
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300505 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400506 if (!vid_hdr) {
507 return -ENOMEM;
508 }
509
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300510 mutex_lock(&ubi->buf_mutex);
511
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400512retry:
513 new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
514 if (new_pnum < 0) {
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300515 mutex_unlock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400516 ubi_free_vid_hdr(ubi, vid_hdr);
517 return new_pnum;
518 }
519
520 ubi_msg("recover PEB %d, move data to PEB %d", pnum, new_pnum);
521
522 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
523 if (err && err != UBI_IO_BITFLIPS) {
524 if (err > 0)
525 err = -EIO;
526 goto out_put;
527 }
528
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300529 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400530 err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
531 if (err)
532 goto write_error;
533
534 data_size = offset + len;
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300535 memset(ubi->peb_buf1 + offset, 0xFF, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400536
537 /* Read everything before the area where the write failure happened */
538 if (offset > 0) {
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300539 err = ubi_io_read_data(ubi, ubi->peb_buf1, pnum, 0, offset);
540 if (err && err != UBI_IO_BITFLIPS)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400541 goto out_put;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400542 }
543
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300544 memcpy(ubi->peb_buf1 + offset, buf, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400545
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300546 err = ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size);
547 if (err)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400548 goto write_error;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400549
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300550 mutex_unlock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400551 ubi_free_vid_hdr(ubi, vid_hdr);
552
553 vol->eba_tbl[lnum] = new_pnum;
554 ubi_wl_put_peb(ubi, pnum, 1);
555
556 ubi_msg("data was successfully recovered");
557 return 0;
558
559out_put:
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300560 mutex_unlock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400561 ubi_wl_put_peb(ubi, new_pnum, 1);
562 ubi_free_vid_hdr(ubi, vid_hdr);
563 return err;
564
565write_error:
566 /*
567 * Bad luck? This physical eraseblock is bad too? Crud. Let's try to
568 * get another one.
569 */
570 ubi_warn("failed to write to PEB %d", new_pnum);
571 ubi_wl_put_peb(ubi, new_pnum, 1);
572 if (++tries > UBI_IO_RETRIES) {
Artem Bityutskiye88d6e102007-08-29 14:51:52 +0300573 mutex_unlock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400574 ubi_free_vid_hdr(ubi, vid_hdr);
575 return err;
576 }
577 ubi_msg("try again");
578 goto retry;
579}
580
581/**
582 * ubi_eba_write_leb - write data to dynamic volume.
583 * @ubi: UBI device description object
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200584 * @vol: volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400585 * @lnum: logical eraseblock number
586 * @buf: the data to write
587 * @offset: offset within the logical eraseblock where to write
588 * @len: how many bytes to write
589 * @dtype: data type
590 *
591 * This function writes data to logical eraseblock @lnum of a dynamic volume
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200592 * @vol. Returns zero in case of success and a negative error code in case
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400593 * of failure. In case of error, it is possible that something was still
594 * written to the flash media, but may be some garbage.
595 */
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200596int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400597 const void *buf, int offset, int len, int dtype)
598{
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200599 int err, pnum, tries = 0, vol_id = vol->vol_id;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400600 struct ubi_vid_hdr *vid_hdr;
601
602 if (ubi->ro_mode)
603 return -EROFS;
604
605 err = leb_write_lock(ubi, vol_id, lnum);
606 if (err)
607 return err;
608
609 pnum = vol->eba_tbl[lnum];
610 if (pnum >= 0) {
611 dbg_eba("write %d bytes at offset %d of LEB %d:%d, PEB %d",
612 len, offset, vol_id, lnum, pnum);
613
614 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
615 if (err) {
616 ubi_warn("failed to write data to PEB %d", pnum);
617 if (err == -EIO && ubi->bad_allowed)
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200618 err = recover_peb(ubi, pnum, vol_id, lnum, buf,
619 offset, len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400620 if (err)
621 ubi_ro_mode(ubi);
622 }
623 leb_write_unlock(ubi, vol_id, lnum);
624 return err;
625 }
626
627 /*
628 * The logical eraseblock is not mapped. We have to get a free physical
629 * eraseblock and write the volume identifier header there first.
630 */
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300631 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400632 if (!vid_hdr) {
633 leb_write_unlock(ubi, vol_id, lnum);
634 return -ENOMEM;
635 }
636
637 vid_hdr->vol_type = UBI_VID_DYNAMIC;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300638 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
639 vid_hdr->vol_id = cpu_to_be32(vol_id);
640 vid_hdr->lnum = cpu_to_be32(lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400641 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300642 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400643
644retry:
645 pnum = ubi_wl_get_peb(ubi, dtype);
646 if (pnum < 0) {
647 ubi_free_vid_hdr(ubi, vid_hdr);
648 leb_write_unlock(ubi, vol_id, lnum);
649 return pnum;
650 }
651
652 dbg_eba("write VID hdr and %d bytes at offset %d of LEB %d:%d, PEB %d",
653 len, offset, vol_id, lnum, pnum);
654
655 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
656 if (err) {
657 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
658 vol_id, lnum, pnum);
659 goto write_error;
660 }
661
Artem Bityutskiy393852e2007-12-06 18:47:30 +0200662 if (len) {
663 err = ubi_io_write_data(ubi, buf, pnum, offset, len);
664 if (err) {
665 ubi_warn("failed to write %d bytes at offset %d of "
666 "LEB %d:%d, PEB %d", len, offset, vol_id,
667 lnum, pnum);
668 goto write_error;
669 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400670 }
671
672 vol->eba_tbl[lnum] = pnum;
673
674 leb_write_unlock(ubi, vol_id, lnum);
675 ubi_free_vid_hdr(ubi, vid_hdr);
676 return 0;
677
678write_error:
679 if (err != -EIO || !ubi->bad_allowed) {
680 ubi_ro_mode(ubi);
681 leb_write_unlock(ubi, vol_id, lnum);
682 ubi_free_vid_hdr(ubi, vid_hdr);
683 return err;
684 }
685
686 /*
687 * Fortunately, this is the first write operation to this physical
688 * eraseblock, so just put it and request a new one. We assume that if
689 * this physical eraseblock went bad, the erase code will handle that.
690 */
691 err = ubi_wl_put_peb(ubi, pnum, 1);
692 if (err || ++tries > UBI_IO_RETRIES) {
693 ubi_ro_mode(ubi);
694 leb_write_unlock(ubi, vol_id, lnum);
695 ubi_free_vid_hdr(ubi, vid_hdr);
696 return err;
697 }
698
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300699 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400700 ubi_msg("try another PEB");
701 goto retry;
702}
703
704/**
705 * ubi_eba_write_leb_st - write data to static volume.
706 * @ubi: UBI device description object
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200707 * @vol: volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400708 * @lnum: logical eraseblock number
709 * @buf: data to write
710 * @len: how many bytes to write
711 * @dtype: data type
712 * @used_ebs: how many logical eraseblocks will this volume contain
713 *
714 * This function writes data to logical eraseblock @lnum of static volume
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200715 * @vol. The @used_ebs argument should contain total number of logical
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400716 * eraseblock in this static volume.
717 *
718 * When writing to the last logical eraseblock, the @len argument doesn't have
719 * to be aligned to the minimal I/O unit size. Instead, it has to be equivalent
720 * to the real data size, although the @buf buffer has to contain the
721 * alignment. In all other cases, @len has to be aligned.
722 *
723 * It is prohibited to write more then once to logical eraseblocks of static
724 * volumes. This function returns zero in case of success and a negative error
725 * code in case of failure.
726 */
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200727int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
728 int lnum, const void *buf, int len, int dtype,
729 int used_ebs)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400730{
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200731 int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400732 struct ubi_vid_hdr *vid_hdr;
733 uint32_t crc;
734
735 if (ubi->ro_mode)
736 return -EROFS;
737
738 if (lnum == used_ebs - 1)
739 /* If this is the last LEB @len may be unaligned */
740 len = ALIGN(data_size, ubi->min_io_size);
741 else
Kyungmin Parkcadb40c2008-05-22 10:32:18 +0900742 ubi_assert(!(len & (ubi->min_io_size - 1)));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400743
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300744 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400745 if (!vid_hdr)
746 return -ENOMEM;
747
748 err = leb_write_lock(ubi, vol_id, lnum);
749 if (err) {
750 ubi_free_vid_hdr(ubi, vid_hdr);
751 return err;
752 }
753
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300754 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
755 vid_hdr->vol_id = cpu_to_be32(vol_id);
756 vid_hdr->lnum = cpu_to_be32(lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400757 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300758 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400759
760 crc = crc32(UBI_CRC32_INIT, buf, data_size);
761 vid_hdr->vol_type = UBI_VID_STATIC;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300762 vid_hdr->data_size = cpu_to_be32(data_size);
763 vid_hdr->used_ebs = cpu_to_be32(used_ebs);
764 vid_hdr->data_crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400765
766retry:
767 pnum = ubi_wl_get_peb(ubi, dtype);
768 if (pnum < 0) {
769 ubi_free_vid_hdr(ubi, vid_hdr);
770 leb_write_unlock(ubi, vol_id, lnum);
771 return pnum;
772 }
773
774 dbg_eba("write VID hdr and %d bytes at LEB %d:%d, PEB %d, used_ebs %d",
775 len, vol_id, lnum, pnum, used_ebs);
776
777 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
778 if (err) {
779 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
780 vol_id, lnum, pnum);
781 goto write_error;
782 }
783
784 err = ubi_io_write_data(ubi, buf, pnum, 0, len);
785 if (err) {
786 ubi_warn("failed to write %d bytes of data to PEB %d",
787 len, pnum);
788 goto write_error;
789 }
790
791 ubi_assert(vol->eba_tbl[lnum] < 0);
792 vol->eba_tbl[lnum] = pnum;
793
794 leb_write_unlock(ubi, vol_id, lnum);
795 ubi_free_vid_hdr(ubi, vid_hdr);
796 return 0;
797
798write_error:
799 if (err != -EIO || !ubi->bad_allowed) {
800 /*
801 * This flash device does not admit of bad eraseblocks or
802 * something nasty and unexpected happened. Switch to read-only
803 * mode just in case.
804 */
805 ubi_ro_mode(ubi);
806 leb_write_unlock(ubi, vol_id, lnum);
807 ubi_free_vid_hdr(ubi, vid_hdr);
808 return err;
809 }
810
811 err = ubi_wl_put_peb(ubi, pnum, 1);
812 if (err || ++tries > UBI_IO_RETRIES) {
813 ubi_ro_mode(ubi);
814 leb_write_unlock(ubi, vol_id, lnum);
815 ubi_free_vid_hdr(ubi, vid_hdr);
816 return err;
817 }
818
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300819 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400820 ubi_msg("try another PEB");
821 goto retry;
822}
823
824/*
825 * ubi_eba_atomic_leb_change - change logical eraseblock atomically.
826 * @ubi: UBI device description object
Artem Bityutskiyc63a4912007-12-17 13:21:07 +0200827 * @vol: volume description object
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400828 * @lnum: logical eraseblock number
829 * @buf: data to write
830 * @len: how many bytes to write
831 * @dtype: data type
832 *
833 * This function changes the contents of a logical eraseblock atomically. @buf
834 * has to contain new logical eraseblock data, and @len - the length of the
835 * data, which has to be aligned. This function guarantees that in case of an
836 * unclean reboot the old contents is preserved. Returns zero in case of
837 * success and a negative error code in case of failure.
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300838 *
839 * UBI reserves one LEB for the "atomic LEB change" operation, so only one
840 * LEB change may be done at a time. This is ensured by @ubi->alc_mutex.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400841 */
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200842int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
843 int lnum, const void *buf, int len, int dtype)
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400844{
Artem Bityutskiy89b96b62007-12-16 20:00:38 +0200845 int err, pnum, tries = 0, vol_id = vol->vol_id;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400846 struct ubi_vid_hdr *vid_hdr;
847 uint32_t crc;
848
849 if (ubi->ro_mode)
850 return -EROFS;
851
Artem Bityutskiy60c03152008-01-24 17:56:14 +0200852 if (len == 0) {
853 /*
854 * Special case when data length is zero. In this case the LEB
855 * has to be unmapped and mapped somewhere else.
856 */
857 err = ubi_eba_unmap_leb(ubi, vol, lnum);
858 if (err)
859 return err;
860 return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
861 }
862
Artem Bityutskiy33818bb2007-08-28 21:29:32 +0300863 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400864 if (!vid_hdr)
865 return -ENOMEM;
866
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300867 mutex_lock(&ubi->alc_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400868 err = leb_write_lock(ubi, vol_id, lnum);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300869 if (err)
870 goto out_mutex;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400871
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300872 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
873 vid_hdr->vol_id = cpu_to_be32(vol_id);
874 vid_hdr->lnum = cpu_to_be32(lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400875 vid_hdr->compat = ubi_get_compat(ubi, vol_id);
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300876 vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400877
878 crc = crc32(UBI_CRC32_INIT, buf, len);
Artem Bityutskiy84a92582007-07-04 16:16:51 +0300879 vid_hdr->vol_type = UBI_VID_DYNAMIC;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300880 vid_hdr->data_size = cpu_to_be32(len);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400881 vid_hdr->copy_flag = 1;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300882 vid_hdr->data_crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400883
884retry:
885 pnum = ubi_wl_get_peb(ubi, dtype);
886 if (pnum < 0) {
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300887 err = pnum;
888 goto out_leb_unlock;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400889 }
890
891 dbg_eba("change LEB %d:%d, PEB %d, write VID hdr to PEB %d",
892 vol_id, lnum, vol->eba_tbl[lnum], pnum);
893
894 err = ubi_io_write_vid_hdr(ubi, pnum, vid_hdr);
895 if (err) {
896 ubi_warn("failed to write VID header to LEB %d:%d, PEB %d",
897 vol_id, lnum, pnum);
898 goto write_error;
899 }
900
901 err = ubi_io_write_data(ubi, buf, pnum, 0, len);
902 if (err) {
903 ubi_warn("failed to write %d bytes of data to PEB %d",
904 len, pnum);
905 goto write_error;
906 }
907
Artem Bityutskiya443db42007-05-21 20:26:05 +0300908 if (vol->eba_tbl[lnum] >= 0) {
909 err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 1);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300910 if (err)
911 goto out_leb_unlock;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400912 }
913
914 vol->eba_tbl[lnum] = pnum;
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300915
916out_leb_unlock:
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400917 leb_write_unlock(ubi, vol_id, lnum);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300918out_mutex:
919 mutex_unlock(&ubi->alc_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400920 ubi_free_vid_hdr(ubi, vid_hdr);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300921 return err;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400922
923write_error:
924 if (err != -EIO || !ubi->bad_allowed) {
925 /*
926 * This flash device does not admit of bad eraseblocks or
927 * something nasty and unexpected happened. Switch to read-only
928 * mode just in case.
929 */
930 ubi_ro_mode(ubi);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300931 goto out_leb_unlock;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400932 }
933
934 err = ubi_wl_put_peb(ubi, pnum, 1);
935 if (err || ++tries > UBI_IO_RETRIES) {
936 ubi_ro_mode(ubi);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +0300937 goto out_leb_unlock;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400938 }
939
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300940 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400941 ubi_msg("try another PEB");
942 goto retry;
943}
944
945/**
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400946 * ubi_eba_copy_leb - copy logical eraseblock.
947 * @ubi: UBI device description object
948 * @from: physical eraseblock number from where to copy
949 * @to: physical eraseblock number where to copy
950 * @vid_hdr: VID header of the @from physical eraseblock
951 *
952 * This function copies logical eraseblock from physical eraseblock @from to
953 * physical eraseblock @to. The @vid_hdr buffer may be changed by this
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200954 * function. Returns:
955 * o %0 in case of success;
956 * o %1 if the operation was canceled and should be tried later (e.g.,
957 * because a bit-flip was detected at the target PEB);
958 * o %2 if the volume is being deleted and this LEB should not be moved.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400959 */
960int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
961 struct ubi_vid_hdr *vid_hdr)
962{
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200963 int err, vol_id, lnum, data_size, aldata_size, idx;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400964 struct ubi_volume *vol;
965 uint32_t crc;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400966
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300967 vol_id = be32_to_cpu(vid_hdr->vol_id);
968 lnum = be32_to_cpu(vid_hdr->lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400969
970 dbg_eba("copy LEB %d:%d, PEB %d to PEB %d", vol_id, lnum, from, to);
971
972 if (vid_hdr->vol_type == UBI_VID_STATIC) {
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300973 data_size = be32_to_cpu(vid_hdr->data_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400974 aldata_size = ALIGN(data_size, ubi->min_io_size);
975 } else
976 data_size = aldata_size =
Christoph Hellwig3261ebd2007-05-21 17:41:46 +0300977 ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400978
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400979 idx = vol_id2idx(ubi, vol_id);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400980 spin_lock(&ubi->volumes_lock);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200981 /*
982 * Note, we may race with volume deletion, which means that the volume
983 * this logical eraseblock belongs to might be being deleted. Since the
984 * volume deletion unmaps all the volume's logical eraseblocks, it will
985 * be locked in 'ubi_wl_put_peb()' and wait for the WL worker to finish.
986 */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400987 vol = ubi->volumes[idx];
988 if (!vol) {
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200989 /* No need to do further work, cancel */
990 dbg_eba("volume %d is being removed, cancel", vol_id);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400991 spin_unlock(&ubi->volumes_lock);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200992 return 2;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +0400993 }
994 spin_unlock(&ubi->volumes_lock);
995
Artem Bityutskiy43f9b252007-12-18 15:06:55 +0200996 /*
997 * We do not want anybody to write to this logical eraseblock while we
998 * are moving it, so lock it.
999 *
1000 * Note, we are using non-waiting locking here, because we cannot sleep
1001 * on the LEB, since it may cause deadlocks. Indeed, imagine a task is
1002 * unmapping the LEB which is mapped to the PEB we are going to move
1003 * (@from). This task locks the LEB and goes sleep in the
1004 * 'ubi_wl_put_peb()' function on the @ubi->move_mutex. In turn, we are
1005 * holding @ubi->move_mutex and go sleep on the LEB lock. So, if the
1006 * LEB is already locked, we just do not move it and return %1.
1007 */
1008 err = leb_write_trylock(ubi, vol_id, lnum);
1009 if (err) {
1010 dbg_eba("contention on LEB %d:%d, cancel", vol_id, lnum);
1011 return err;
1012 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001013
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001014 /*
1015 * The LEB might have been put meanwhile, and the task which put it is
1016 * probably waiting on @ubi->move_mutex. No need to continue the work,
1017 * cancel it.
1018 */
1019 if (vol->eba_tbl[lnum] != from) {
1020 dbg_eba("LEB %d:%d is no longer mapped to PEB %d, mapped to "
1021 "PEB %d, cancel", vol_id, lnum, from,
1022 vol->eba_tbl[lnum]);
1023 err = 1;
1024 goto out_unlock_leb;
1025 }
1026
1027 /*
1028 * OK, now the LEB is locked and we can safely start moving iy. Since
1029 * this function utilizes thie @ubi->peb1_buf buffer which is shared
1030 * with some other functions, so lock the buffer by taking the
1031 * @ubi->buf_mutex.
1032 */
1033 mutex_lock(&ubi->buf_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001034 dbg_eba("read %d bytes of data", aldata_size);
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001035 err = ubi_io_read_data(ubi, ubi->peb_buf1, from, 0, aldata_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001036 if (err && err != UBI_IO_BITFLIPS) {
1037 ubi_warn("error %d while reading data from PEB %d",
1038 err, from);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001039 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001040 }
1041
1042 /*
1043 * Now we have got to calculate how much data we have to to copy. In
1044 * case of a static volume it is fairly easy - the VID header contains
1045 * the data size. In case of a dynamic volume it is more difficult - we
1046 * have to read the contents, cut 0xFF bytes from the end and copy only
1047 * the first part. We must do this to avoid writing 0xFF bytes as it
1048 * may have some side-effects. And not only this. It is important not
1049 * to include those 0xFFs to CRC because later the they may be filled
1050 * by data.
1051 */
1052 if (vid_hdr->vol_type == UBI_VID_DYNAMIC)
1053 aldata_size = data_size =
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001054 ubi_calc_data_len(ubi, ubi->peb_buf1, data_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001055
1056 cond_resched();
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001057 crc = crc32(UBI_CRC32_INIT, ubi->peb_buf1, data_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001058 cond_resched();
1059
1060 /*
1061 * It may turn out to me that the whole @from physical eraseblock
1062 * contains only 0xFF bytes. Then we have to only write the VID header
1063 * and do not write any data. This also means we should not set
1064 * @vid_hdr->copy_flag, @vid_hdr->data_size, and @vid_hdr->data_crc.
1065 */
1066 if (data_size > 0) {
1067 vid_hdr->copy_flag = 1;
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001068 vid_hdr->data_size = cpu_to_be32(data_size);
1069 vid_hdr->data_crc = cpu_to_be32(crc);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001070 }
Christoph Hellwig3261ebd2007-05-21 17:41:46 +03001071 vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001072
1073 err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
1074 if (err)
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001075 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001076
1077 cond_resched();
1078
1079 /* Read the VID header back and check if it was written correctly */
1080 err = ubi_io_read_vid_hdr(ubi, to, vid_hdr, 1);
1081 if (err) {
1082 if (err != UBI_IO_BITFLIPS)
1083 ubi_warn("cannot read VID header back from PEB %d", to);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001084 else
1085 err = 1;
1086 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001087 }
1088
1089 if (data_size > 0) {
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001090 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001091 if (err)
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001092 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001093
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001094 cond_resched();
1095
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001096 /*
1097 * We've written the data and are going to read it back to make
1098 * sure it was written correctly.
1099 */
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001100
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001101 err = ubi_io_read_data(ubi, ubi->peb_buf2, to, 0, aldata_size);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001102 if (err) {
1103 if (err != UBI_IO_BITFLIPS)
1104 ubi_warn("cannot read data back from PEB %d",
1105 to);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001106 else
1107 err = 1;
1108 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001109 }
1110
1111 cond_resched();
1112
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001113 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001114 ubi_warn("read data back from PEB %d - it is different",
1115 to);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001116 goto out_unlock_buf;
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001117 }
1118 }
1119
1120 ubi_assert(vol->eba_tbl[lnum] == from);
1121 vol->eba_tbl[lnum] = to;
1122
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001123out_unlock_buf:
Artem Bityutskiye88d6e102007-08-29 14:51:52 +03001124 mutex_unlock(&ubi->buf_mutex);
Artem Bityutskiy43f9b252007-12-18 15:06:55 +02001125out_unlock_leb:
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001126 leb_write_unlock(ubi, vol_id, lnum);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001127 return err;
1128}
1129
1130/**
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +03001131 * ubi_eba_init_scan - initialize the EBA sub-system using scanning information.
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001132 * @ubi: UBI device description object
1133 * @si: scanning information
1134 *
1135 * This function returns zero in case of success and a negative error code in
1136 * case of failure.
1137 */
1138int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
1139{
1140 int i, j, err, num_volumes;
1141 struct ubi_scan_volume *sv;
1142 struct ubi_volume *vol;
1143 struct ubi_scan_leb *seb;
1144 struct rb_node *rb;
1145
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +03001146 dbg_eba("initialize EBA sub-system");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001147
1148 spin_lock_init(&ubi->ltree_lock);
Artem Bityutskiye8823bd2007-09-13 14:28:14 +03001149 mutex_init(&ubi->alc_mutex);
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001150 ubi->ltree = RB_ROOT;
1151
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001152 ubi->global_sqnum = si->max_sqnum + 1;
1153 num_volumes = ubi->vtbl_slots + UBI_INT_VOL_COUNT;
1154
1155 for (i = 0; i < num_volumes; i++) {
1156 vol = ubi->volumes[i];
1157 if (!vol)
1158 continue;
1159
1160 cond_resched();
1161
1162 vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int),
1163 GFP_KERNEL);
1164 if (!vol->eba_tbl) {
1165 err = -ENOMEM;
1166 goto out_free;
1167 }
1168
1169 for (j = 0; j < vol->reserved_pebs; j++)
1170 vol->eba_tbl[j] = UBI_LEB_UNMAPPED;
1171
1172 sv = ubi_scan_find_sv(si, idx2vol_id(ubi, i));
1173 if (!sv)
1174 continue;
1175
1176 ubi_rb_for_each_entry(rb, seb, &sv->root, u.rb) {
1177 if (seb->lnum >= vol->reserved_pebs)
1178 /*
1179 * This may happen in case of an unclean reboot
1180 * during re-size.
1181 */
1182 ubi_scan_move_to_list(sv, seb, &si->erase);
1183 vol->eba_tbl[seb->lnum] = seb->pnum;
1184 }
1185 }
1186
Artem Bityutskiy94780d42007-12-04 21:36:12 +02001187 if (ubi->avail_pebs < EBA_RESERVED_PEBS) {
1188 ubi_err("no enough physical eraseblocks (%d, need %d)",
1189 ubi->avail_pebs, EBA_RESERVED_PEBS);
1190 err = -ENOSPC;
1191 goto out_free;
1192 }
1193 ubi->avail_pebs -= EBA_RESERVED_PEBS;
1194 ubi->rsvd_pebs += EBA_RESERVED_PEBS;
1195
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001196 if (ubi->bad_allowed) {
1197 ubi_calculate_reserved(ubi);
1198
1199 if (ubi->avail_pebs < ubi->beb_rsvd_level) {
1200 /* No enough free physical eraseblocks */
1201 ubi->beb_rsvd_pebs = ubi->avail_pebs;
1202 ubi_warn("cannot reserve enough PEBs for bad PEB "
1203 "handling, reserved %d, need %d",
1204 ubi->beb_rsvd_pebs, ubi->beb_rsvd_level);
1205 } else
1206 ubi->beb_rsvd_pebs = ubi->beb_rsvd_level;
1207
1208 ubi->avail_pebs -= ubi->beb_rsvd_pebs;
1209 ubi->rsvd_pebs += ubi->beb_rsvd_pebs;
1210 }
1211
Artem Bityutskiy85c6e6e2008-07-16 10:25:56 +03001212 dbg_eba("EBA sub-system is initialized");
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001213 return 0;
1214
1215out_free:
1216 for (i = 0; i < num_volumes; i++) {
1217 if (!ubi->volumes[i])
1218 continue;
1219 kfree(ubi->volumes[i]->eba_tbl);
1220 }
Artem B. Bityutskiy801c1352006-06-27 12:22:22 +04001221 return err;
1222}