UBI: fix LEB locking
[linux-2.6] / drivers / mtd / ubi / eba.c
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12  * the GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Artem Bityutskiy (Битюцкий Артём)
19  */
20
21 /*
22  * The UBI Eraseblock Association (EBA) unit.
23  *
24  * This unit is responsible for I/O to/from logical eraseblock.
25  *
26  * Although in this implementation the EBA table is fully kept and managed in
27  * RAM, which assumes poor scalability, it might be (partially) maintained on
28  * flash in future implementations.
29  *
30  * The EBA unit implements per-logical eraseblock locking. Before accessing a
31  * logical eraseblock it is locked for reading or writing. The per-logical
32  * eraseblock locking is implemented by means of the lock tree. The lock tree
33  * is an RB-tree which refers all the currently locked logical eraseblocks. The
34  * lock tree elements are &struct ubi_ltree_entry objects. They are indexed by
35  * (@vol_id, @lnum) pairs.
36  *
37  * EBA also maintains the global sequence counter which is incremented each
38  * time a logical eraseblock is mapped to a physical eraseblock and it is
39  * stored in the volume identifier header. This means that each VID header has
40  * a unique sequence number. The sequence number is only increased an we assume
41  * 64 bits is enough to never overflow.
42  */
43
44 #include <linux/slab.h>
45 #include <linux/crc32.h>
46 #include <linux/err.h>
47 #include "ubi.h"
48
49 /* Number of physical eraseblocks reserved for atomic LEB change operation */
50 #define EBA_RESERVED_PEBS 1
51
52 /**
53  * next_sqnum - get next sequence number.
54  * @ubi: UBI device description object
55  *
56  * This function returns next sequence number to use, which is just the current
57  * global sequence counter value. It also increases the global sequence
58  * counter.
59  */
60 static 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  */
79 static int ubi_get_compat(const struct ubi_device *ubi, int vol_id)
80 {
81         if (vol_id == UBI_LAYOUT_VOLUME_ID)
82                 return UBI_LAYOUT_VOLUME_COMPAT;
83         return 0;
84 }
85
86 /**
87  * ltree_lookup - look up the lock tree.
88  * @ubi: UBI device description object
89  * @vol_id: volume ID
90  * @lnum: logical eraseblock number
91  *
92  * This function returns a pointer to the corresponding &struct ubi_ltree_entry
93  * object if the logical eraseblock is locked and %NULL if it is not.
94  * @ubi->ltree_lock has to be locked.
95  */
96 static struct ubi_ltree_entry *ltree_lookup(struct ubi_device *ubi, int vol_id,
97                                             int lnum)
98 {
99         struct rb_node *p;
100
101         p = ubi->ltree.rb_node;
102         while (p) {
103                 struct ubi_ltree_entry *le;
104
105                 le = rb_entry(p, struct ubi_ltree_entry, rb);
106
107                 if (vol_id < le->vol_id)
108                         p = p->rb_left;
109                 else if (vol_id > le->vol_id)
110                         p = p->rb_right;
111                 else {
112                         if (lnum < le->lnum)
113                                 p = p->rb_left;
114                         else if (lnum > le->lnum)
115                                 p = p->rb_right;
116                         else
117                                 return le;
118                 }
119         }
120
121         return NULL;
122 }
123
124 /**
125  * ltree_add_entry - add new entry to the lock tree.
126  * @ubi: UBI device description object
127  * @vol_id: volume ID
128  * @lnum: logical eraseblock number
129  *
130  * This function adds new entry for logical eraseblock (@vol_id, @lnum) to the
131  * lock tree. If such entry is already there, its usage counter is increased.
132  * Returns pointer to the lock tree entry or %-ENOMEM if memory allocation
133  * failed.
134  */
135 static struct ubi_ltree_entry *ltree_add_entry(struct ubi_device *ubi,
136                                                int vol_id, int lnum)
137 {
138         struct ubi_ltree_entry *le, *le1, *le_free;
139
140         le = kmalloc(sizeof(struct ubi_ltree_entry), GFP_NOFS);
141         if (!le)
142                 return ERR_PTR(-ENOMEM);
143
144         le->users = 0;
145         init_rwsem(&le->mutex);
146         le->vol_id = vol_id;
147         le->lnum = lnum;
148
149         spin_lock(&ubi->ltree_lock);
150         le1 = ltree_lookup(ubi, vol_id, lnum);
151
152         if (le1) {
153                 /*
154                  * This logical eraseblock is already locked. The newly
155                  * allocated lock entry is not needed.
156                  */
157                 le_free = le;
158                 le = le1;
159         } else {
160                 struct rb_node **p, *parent = NULL;
161
162                 /*
163                  * No lock entry, add the newly allocated one to the
164                  * @ubi->ltree RB-tree.
165                  */
166                 le_free = NULL;
167
168                 p = &ubi->ltree.rb_node;
169                 while (*p) {
170                         parent = *p;
171                         le1 = rb_entry(parent, struct ubi_ltree_entry, rb);
172
173                         if (vol_id < le1->vol_id)
174                                 p = &(*p)->rb_left;
175                         else if (vol_id > le1->vol_id)
176                                 p = &(*p)->rb_right;
177                         else {
178                                 ubi_assert(lnum != le1->lnum);
179                                 if (lnum < le1->lnum)
180                                         p = &(*p)->rb_left;
181                                 else
182                                         p = &(*p)->rb_right;
183                         }
184                 }
185
186                 rb_link_node(&le->rb, parent, p);
187                 rb_insert_color(&le->rb, &ubi->ltree);
188         }
189         le->users += 1;
190         spin_unlock(&ubi->ltree_lock);
191
192         if (le_free)
193                 kfree(le_free);
194
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  */
207 static int leb_read_lock(struct ubi_device *ubi, int vol_id, int lnum)
208 {
209         struct ubi_ltree_entry *le;
210
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  */
224 static void leb_read_unlock(struct ubi_device *ubi, int vol_id, int lnum)
225 {
226         struct ubi_ltree_entry *le;
227
228         spin_lock(&ubi->ltree_lock);
229         le = ltree_lookup(ubi, vol_id, lnum);
230         le->users -= 1;
231         ubi_assert(le->users >= 0);
232         up_read(&le->mutex);
233         if (le->users == 0) {
234                 rb_erase(&le->rb, &ubi->ltree);
235                 kfree(le);
236         }
237         spin_unlock(&ubi->ltree_lock);
238 }
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  */
249 static int leb_write_lock(struct ubi_device *ubi, int vol_id, int lnum)
250 {
251         struct ubi_ltree_entry *le;
252
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 /**
261  * 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  */
271 static int leb_write_trylock(struct ubi_device *ubi, int vol_id, int lnum)
272 {
273         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);
287                 kfree(le);
288         }
289         spin_unlock(&ubi->ltree_lock);
290
291         return 1;
292 }
293
294 /**
295  * leb_write_unlock - unlock logical eraseblock.
296  * @ubi: UBI device description object
297  * @vol_id: volume ID
298  * @lnum: logical eraseblock number
299  */
300 static void leb_write_unlock(struct ubi_device *ubi, int vol_id, int lnum)
301 {
302         struct ubi_ltree_entry *le;
303
304         spin_lock(&ubi->ltree_lock);
305         le = ltree_lookup(ubi, vol_id, lnum);
306         le->users -= 1;
307         ubi_assert(le->users >= 0);
308         up_write(&le->mutex);
309         if (le->users == 0) {
310                 rb_erase(&le->rb, &ubi->ltree);
311                 kfree(le);
312         }
313         spin_unlock(&ubi->ltree_lock);
314 }
315
316 /**
317  * ubi_eba_unmap_leb - un-map logical eraseblock.
318  * @ubi: UBI device description object
319  * @vol: volume description object
320  * @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  */
326 int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
327                       int lnum)
328 {
329         int err, pnum, vol_id = vol->vol_id;
330
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
348 out_unlock:
349         leb_write_unlock(ubi, vol_id, lnum);
350         return err;
351 }
352
353 /**
354  * ubi_eba_read_leb - read data.
355  * @ubi: UBI device description object
356  * @vol: volume description object
357  * @lnum: logical eraseblock number
358  * @buf: buffer to store the read data
359  * @offset: offset from where to read
360  * @len: how many bytes to read
361  * @check: data CRC check flag
362  *
363  * If the logical eraseblock @lnum is unmapped, @buf is filled with 0xFF
364  * bytes. The @check flag only makes sense for static volumes and forces
365  * eraseblock data CRC checking.
366  *
367  * In case of success this function returns zero. In case of a static volume,
368  * if data CRC mismatches - %-EBADMSG is returned. %-EBADMSG may also be
369  * returned for any volume type if an ECC error was detected by the MTD device
370  * driver. Other negative error cored may be returned in case of other errors.
371  */
372 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
373                      void *buf, int offset, int len, int check)
374 {
375         int err, pnum, scrub = 0, vol_id = vol->vol_id;
376         struct ubi_vid_hdr *vid_hdr;
377         uint32_t uninitialized_var(crc);
378
379         err = leb_read_lock(ubi, vol_id, lnum);
380         if (err)
381                 return err;
382
383         pnum = vol->eba_tbl[lnum];
384         if (pnum < 0) {
385                 /*
386                  * The logical eraseblock is not mapped, fill the whole buffer
387                  * with 0xFF bytes. The exception is static volumes for which
388                  * it is an error to read unmapped logical eraseblocks.
389                  */
390                 dbg_eba("read %d bytes from offset %d of LEB %d:%d (unmapped)",
391                         len, offset, vol_id, lnum);
392                 leb_read_unlock(ubi, vol_id, lnum);
393                 ubi_assert(vol->vol_type != UBI_STATIC_VOLUME);
394                 memset(buf, 0xFF, len);
395                 return 0;
396         }
397
398         dbg_eba("read %d bytes from offset %d of LEB %d:%d, PEB %d",
399                 len, offset, vol_id, lnum, pnum);
400
401         if (vol->vol_type == UBI_DYNAMIC_VOLUME)
402                 check = 0;
403
404 retry:
405         if (check) {
406                 vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
407                 if (!vid_hdr) {
408                         err = -ENOMEM;
409                         goto out_unlock;
410                 }
411
412                 err = ubi_io_read_vid_hdr(ubi, pnum, vid_hdr, 1);
413                 if (err && err != UBI_IO_BITFLIPS) {
414                         if (err > 0) {
415                                 /*
416                                  * The header is either absent or corrupted.
417                                  * The former case means there is a bug -
418                                  * switch to read-only mode just in case.
419                                  * The latter case means a real corruption - we
420                                  * may try to recover data. FIXME: but this is
421                                  * not implemented.
422                                  */
423                                 if (err == UBI_IO_BAD_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
434                 ubi_assert(lnum < be32_to_cpu(vid_hdr->used_ebs));
435                 ubi_assert(len == be32_to_cpu(vid_hdr->data_size));
436
437                 crc = be32_to_cpu(vid_hdr->data_crc);
438                 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) {
460                 uint32_t crc1 = crc32(UBI_CRC32_INIT, buf, len);
461                 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
475 out_free:
476         ubi_free_vid_hdr(ubi, vid_hdr);
477 out_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  */
498 static 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;
504
505         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
506         if (!vid_hdr) {
507                 return -ENOMEM;
508         }
509
510         mutex_lock(&ubi->buf_mutex);
511
512 retry:
513         new_pnum = ubi_wl_get_peb(ubi, UBI_UNKNOWN);
514         if (new_pnum < 0) {
515                 mutex_unlock(&ubi->buf_mutex);
516                 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
529         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
530         err = ubi_io_write_vid_hdr(ubi, new_pnum, vid_hdr);
531         if (err)
532                 goto write_error;
533
534         data_size = offset + len;
535         memset(ubi->peb_buf1 + offset, 0xFF, len);
536
537         /* Read everything before the area where the write failure happened */
538         if (offset > 0) {
539                 err = ubi_io_read_data(ubi, ubi->peb_buf1, pnum, 0, offset);
540                 if (err && err != UBI_IO_BITFLIPS)
541                         goto out_put;
542         }
543
544         memcpy(ubi->peb_buf1 + offset, buf, len);
545
546         err = ubi_io_write_data(ubi, ubi->peb_buf1, new_pnum, 0, data_size);
547         if (err)
548                 goto write_error;
549
550         mutex_unlock(&ubi->buf_mutex);
551         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
559 out_put:
560         mutex_unlock(&ubi->buf_mutex);
561         ubi_wl_put_peb(ubi, new_pnum, 1);
562         ubi_free_vid_hdr(ubi, vid_hdr);
563         return err;
564
565 write_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) {
573                 mutex_unlock(&ubi->buf_mutex);
574                 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
584  * @vol: volume description object
585  * @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
592  * @vol. Returns zero in case of success and a negative error code in case
593  * 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  */
596 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
597                       const void *buf, int offset, int len, int dtype)
598 {
599         int err, pnum, tries = 0, vol_id = vol->vol_id;
600         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)
618                                 err = recover_peb(ubi, pnum, vol_id, lnum, buf,
619                                                   offset, len);
620                         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          */
631         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
632         if (!vid_hdr) {
633                 leb_write_unlock(ubi, vol_id, lnum);
634                 return -ENOMEM;
635         }
636
637         vid_hdr->vol_type = UBI_VID_DYNAMIC;
638         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);
641         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
642         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
643
644 retry:
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
662         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                 }
670         }
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
678 write_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
699         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
700         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
707  * @vol: volume description object
708  * @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
715  * @vol. The @used_ebs argument should contain total number of logical
716  * 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  */
727 int 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)
730 {
731         int err, pnum, tries = 0, data_size = len, vol_id = vol->vol_id;
732         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
742                 ubi_assert(!(len & (ubi->min_io_size - 1)));
743
744         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
745         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
754         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);
757         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
758         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
759
760         crc = crc32(UBI_CRC32_INIT, buf, data_size);
761         vid_hdr->vol_type = UBI_VID_STATIC;
762         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);
765
766 retry:
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
798 write_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
819         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
820         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
827  * @vol: volume description object
828  * @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.
838  *
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.
841  */
842 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
843                               int lnum, const void *buf, int len, int dtype)
844 {
845         int err, pnum, tries = 0, vol_id = vol->vol_id;
846         struct ubi_vid_hdr *vid_hdr;
847         uint32_t crc;
848
849         if (ubi->ro_mode)
850                 return -EROFS;
851
852         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
863         vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_NOFS);
864         if (!vid_hdr)
865                 return -ENOMEM;
866
867         mutex_lock(&ubi->alc_mutex);
868         err = leb_write_lock(ubi, vol_id, lnum);
869         if (err)
870                 goto out_mutex;
871
872         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);
875         vid_hdr->compat = ubi_get_compat(ubi, vol_id);
876         vid_hdr->data_pad = cpu_to_be32(vol->data_pad);
877
878         crc = crc32(UBI_CRC32_INIT, buf, len);
879         vid_hdr->vol_type = UBI_VID_DYNAMIC;
880         vid_hdr->data_size = cpu_to_be32(len);
881         vid_hdr->copy_flag = 1;
882         vid_hdr->data_crc = cpu_to_be32(crc);
883
884 retry:
885         pnum = ubi_wl_get_peb(ubi, dtype);
886         if (pnum < 0) {
887                 err = pnum;
888                 goto out_leb_unlock;
889         }
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
908         if (vol->eba_tbl[lnum] >= 0) {
909                 err = ubi_wl_put_peb(ubi, vol->eba_tbl[lnum], 1);
910                 if (err)
911                         goto out_leb_unlock;
912         }
913
914         vol->eba_tbl[lnum] = pnum;
915
916 out_leb_unlock:
917         leb_write_unlock(ubi, vol_id, lnum);
918 out_mutex:
919         mutex_unlock(&ubi->alc_mutex);
920         ubi_free_vid_hdr(ubi, vid_hdr);
921         return err;
922
923 write_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);
931                 goto out_leb_unlock;
932         }
933
934         err = ubi_wl_put_peb(ubi, pnum, 1);
935         if (err || ++tries > UBI_IO_RETRIES) {
936                 ubi_ro_mode(ubi);
937                 goto out_leb_unlock;
938         }
939
940         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
941         ubi_msg("try another PEB");
942         goto retry;
943 }
944
945 /**
946  * 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
954  * 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.
959  */
960 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
961                      struct ubi_vid_hdr *vid_hdr)
962 {
963         int err, vol_id, lnum, data_size, aldata_size, idx;
964         struct ubi_volume *vol;
965         uint32_t crc;
966
967         vol_id = be32_to_cpu(vid_hdr->vol_id);
968         lnum = be32_to_cpu(vid_hdr->lnum);
969
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) {
973                 data_size = be32_to_cpu(vid_hdr->data_size);
974                 aldata_size = ALIGN(data_size, ubi->min_io_size);
975         } else
976                 data_size = aldata_size =
977                             ubi->leb_size - be32_to_cpu(vid_hdr->data_pad);
978
979         idx = vol_id2idx(ubi, vol_id);
980         spin_lock(&ubi->volumes_lock);
981         /*
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          */
987         vol = ubi->volumes[idx];
988         if (!vol) {
989                 /* No need to do further work, cancel */
990                 dbg_eba("volume %d is being removed, cancel", vol_id);
991                 spin_unlock(&ubi->volumes_lock);
992                 return 2;
993         }
994         spin_unlock(&ubi->volumes_lock);
995
996         /*
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         }
1013
1014         /*
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);
1034         dbg_eba("read %d bytes of data", aldata_size);
1035         err = ubi_io_read_data(ubi, ubi->peb_buf1, from, 0, aldata_size);
1036         if (err && err != UBI_IO_BITFLIPS) {
1037                 ubi_warn("error %d while reading data from PEB %d",
1038                          err, from);
1039                 goto out_unlock_buf;
1040         }
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 =
1054                         ubi_calc_data_len(ubi, ubi->peb_buf1, data_size);
1055
1056         cond_resched();
1057         crc = crc32(UBI_CRC32_INIT, ubi->peb_buf1, data_size);
1058         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;
1068                 vid_hdr->data_size = cpu_to_be32(data_size);
1069                 vid_hdr->data_crc = cpu_to_be32(crc);
1070         }
1071         vid_hdr->sqnum = cpu_to_be64(next_sqnum(ubi));
1072
1073         err = ubi_io_write_vid_hdr(ubi, to, vid_hdr);
1074         if (err)
1075                 goto out_unlock_buf;
1076
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);
1084                 else
1085                         err = 1;
1086                 goto out_unlock_buf;
1087         }
1088
1089         if (data_size > 0) {
1090                 err = ubi_io_write_data(ubi, ubi->peb_buf1, to, 0, aldata_size);
1091                 if (err)
1092                         goto out_unlock_buf;
1093
1094                 cond_resched();
1095
1096                 /*
1097                  * We've written the data and are going to read it back to make
1098                  * sure it was written correctly.
1099                  */
1100
1101                 err = ubi_io_read_data(ubi, ubi->peb_buf2, to, 0, aldata_size);
1102                 if (err) {
1103                         if (err != UBI_IO_BITFLIPS)
1104                                 ubi_warn("cannot read data back from PEB %d",
1105                                          to);
1106                         else
1107                                 err = 1;
1108                         goto out_unlock_buf;
1109                 }
1110
1111                 cond_resched();
1112
1113                 if (memcmp(ubi->peb_buf1, ubi->peb_buf2, aldata_size)) {
1114                         ubi_warn("read data back from PEB %d - it is different",
1115                                  to);
1116                         goto out_unlock_buf;
1117                 }
1118         }
1119
1120         ubi_assert(vol->eba_tbl[lnum] == from);
1121         vol->eba_tbl[lnum] = to;
1122
1123 out_unlock_buf:
1124         mutex_unlock(&ubi->buf_mutex);
1125 out_unlock_leb:
1126         leb_write_unlock(ubi, vol_id, lnum);
1127         return err;
1128 }
1129
1130 /**
1131  * ubi_eba_init_scan - initialize the EBA unit using scanning information.
1132  * @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  */
1138 int 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
1146         dbg_eba("initialize EBA unit");
1147
1148         spin_lock_init(&ubi->ltree_lock);
1149         mutex_init(&ubi->alc_mutex);
1150         ubi->ltree = RB_ROOT;
1151
1152         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
1187         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
1196         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
1212         dbg_eba("EBA unit is initialized");
1213         return 0;
1214
1215 out_free:
1216         for (i = 0; i < num_volumes; i++) {
1217                 if (!ubi->volumes[i])
1218                         continue;
1219                 kfree(ubi->volumes[i]->eba_tbl);
1220         }
1221         return err;
1222 }