db3defdfc3c0a1d4c888dcf22a76994cd9d87dca
2 * Copyright (c) 2012 Linutronix GmbH
3 * Author: Richard Weinberger <richard@nod.at>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2.
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.
16 #include <linux/crc32.h>
20 * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
21 * @ubi: UBI device description object
23 size_t ubi_calc_fm_size(struct ubi_device
*ubi
)
27 size
= sizeof(struct ubi_fm_sb
) + \
28 sizeof(struct ubi_fm_hdr
) + \
29 sizeof(struct ubi_fm_scan_pool
) + \
30 sizeof(struct ubi_fm_scan_pool
) + \
31 (ubi
->peb_count
* sizeof(struct ubi_fm_ec
)) + \
32 (sizeof(struct ubi_fm_eba
) + \
33 (ubi
->peb_count
* sizeof(__be32
))) + \
34 sizeof(struct ubi_fm_volhdr
) * UBI_MAX_VOLUMES
;
35 return roundup(size
, ubi
->leb_size
);
40 * new_fm_vhdr - allocate a new volume header for fastmap usage.
41 * @ubi: UBI device description object
42 * @vol_id: the VID of the new header
44 * Returns a new struct ubi_vid_hdr on success.
45 * NULL indicates out of memory.
47 static struct ubi_vid_hdr
*new_fm_vhdr(struct ubi_device
*ubi
, int vol_id
)
49 struct ubi_vid_hdr
*new;
51 new = ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
55 new->vol_type
= UBI_VID_DYNAMIC
;
56 new->vol_id
= cpu_to_be32(vol_id
);
58 /* UBI implementations without fastmap support have to delete the
61 new->compat
= UBI_COMPAT_DELETE
;
68 * add_aeb - create and add a attach erase block to a given list.
69 * @ai: UBI attach info object
70 * @list: the target list
71 * @pnum: PEB number of the new attach erase block
72 * @ec: erease counter of the new LEB
73 * @scrub: scrub this PEB after attaching
75 * Returns 0 on success, < 0 indicates an internal error.
77 static int add_aeb(struct ubi_attach_info
*ai
, struct list_head
*list
,
78 int pnum
, int ec
, int scrub
)
80 struct ubi_ainf_peb
*aeb
;
82 aeb
= kmem_cache_alloc(ai
->aeb_slab_cache
, GFP_KERNEL
);
90 aeb
->copy_flag
= aeb
->sqnum
= 0;
92 ai
->ec_sum
+= aeb
->ec
;
95 if (ai
->max_ec
< aeb
->ec
)
98 if (ai
->min_ec
> aeb
->ec
)
101 list_add_tail(&aeb
->u
.list
, list
);
107 * add_vol - create and add a new volume to ubi_attach_info.
108 * @ai: ubi_attach_info object
109 * @vol_id: VID of the new volume
110 * @used_ebs: number of used EBS
111 * @data_pad: data padding value of the new volume
112 * @vol_type: volume type
113 * @last_eb_bytes: number of bytes in the last LEB
115 * Returns the new struct ubi_ainf_volume on success.
116 * NULL indicates an error.
118 static struct ubi_ainf_volume
*add_vol(struct ubi_attach_info
*ai
, int vol_id
,
119 int used_ebs
, int data_pad
, u8 vol_type
,
122 struct ubi_ainf_volume
*av
;
123 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
127 av
= rb_entry(parent
, struct ubi_ainf_volume
, rb
);
129 if (vol_id
> av
->vol_id
)
135 av
= kmalloc(sizeof(struct ubi_ainf_volume
), GFP_KERNEL
);
139 av
->highest_lnum
= av
->leb_count
= 0;
141 av
->used_ebs
= used_ebs
;
142 av
->data_pad
= data_pad
;
143 av
->last_data_size
= last_eb_bytes
;
145 av
->vol_type
= vol_type
;
148 dbg_bld("found volume (ID %i)", vol_id
);
150 rb_link_node(&av
->rb
, parent
, p
);
151 rb_insert_color(&av
->rb
, &ai
->volumes
);
158 * assign_aeb_to_av - assigns a SEB to a given ainf_volume and removes it
159 * from it's original list.
160 * @ai: ubi_attach_info object
161 * @aeb: the to be assigned SEB
162 * @av: target scan volume
164 static void assign_aeb_to_av(struct ubi_attach_info
*ai
,
165 struct ubi_ainf_peb
*aeb
,
166 struct ubi_ainf_volume
*av
)
168 struct ubi_ainf_peb
*tmp_aeb
;
169 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
171 p
= &av
->root
.rb_node
;
175 tmp_aeb
= rb_entry(parent
, struct ubi_ainf_peb
, u
.rb
);
176 if (aeb
->lnum
!= tmp_aeb
->lnum
) {
177 if (aeb
->lnum
< tmp_aeb
->lnum
)
187 list_del(&aeb
->u
.list
);
190 rb_link_node(&aeb
->u
.rb
, parent
, p
);
191 rb_insert_color(&aeb
->u
.rb
, &av
->root
);
195 * update_vol - inserts or updates a LEB which was found a pool.
196 * @ubi: the UBI device object
197 * @ai: attach info object
198 * @av: the volume this LEB belongs to
199 * @new_vh: the volume header derived from new_aeb
200 * @new_aeb: the AEB to be examined
202 * Returns 0 on success, < 0 indicates an internal error.
204 static int update_vol(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
205 struct ubi_ainf_volume
*av
, struct ubi_vid_hdr
*new_vh
,
206 struct ubi_ainf_peb
*new_aeb
)
208 struct rb_node
**p
= &av
->root
.rb_node
, *parent
= NULL
;
209 struct ubi_ainf_peb
*aeb
, *victim
;
214 aeb
= rb_entry(parent
, struct ubi_ainf_peb
, u
.rb
);
216 if (be32_to_cpu(new_vh
->lnum
) != aeb
->lnum
) {
217 if (be32_to_cpu(new_vh
->lnum
) < aeb
->lnum
)
225 /* This case can happen if the fastmap gets written
226 * because of a volume change (creation, deletion, ..).
227 * Then a PEB can be within the persistent EBA and the pool.
229 if (aeb
->pnum
== new_aeb
->pnum
) {
230 ubi_assert(aeb
->lnum
== new_aeb
->lnum
);
231 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
236 cmp_res
= ubi_compare_lebs(ubi
, aeb
, new_aeb
->pnum
, new_vh
);
240 /* new_aeb is newer */
242 victim
= kmem_cache_alloc(ai
->aeb_slab_cache
,
247 victim
->ec
= aeb
->ec
;
248 victim
->pnum
= aeb
->pnum
;
249 list_add_tail(&victim
->u
.list
, &ai
->erase
);
251 if (av
->highest_lnum
== be32_to_cpu(new_vh
->lnum
))
252 av
->last_data_size
= \
253 be32_to_cpu(new_vh
->data_size
);
255 dbg_bld("vol %i: AEB %i's PEB %i is the newer",
256 av
->vol_id
, aeb
->lnum
, new_aeb
->pnum
);
258 aeb
->ec
= new_aeb
->ec
;
259 aeb
->pnum
= new_aeb
->pnum
;
260 aeb
->copy_flag
= new_vh
->copy_flag
;
261 aeb
->scrub
= new_aeb
->scrub
;
262 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
264 /* new_aeb is older */
266 dbg_bld("vol %i: AEB %i's PEB %i is old, dropping it",
267 av
->vol_id
, aeb
->lnum
, new_aeb
->pnum
);
268 list_add_tail(&new_aeb
->u
.list
, &ai
->erase
);
273 /* This LEB is new, let's add it to the volume */
275 if (av
->highest_lnum
<= be32_to_cpu(new_vh
->lnum
)) {
276 av
->highest_lnum
= be32_to_cpu(new_vh
->lnum
);
277 av
->last_data_size
= be32_to_cpu(new_vh
->data_size
);
280 if (av
->vol_type
== UBI_STATIC_VOLUME
)
281 av
->used_ebs
= be32_to_cpu(new_vh
->used_ebs
);
285 rb_link_node(&new_aeb
->u
.rb
, parent
, p
);
286 rb_insert_color(&new_aeb
->u
.rb
, &av
->root
);
292 * process_pool_aeb - we found a non-empty PEB in a pool.
293 * @ubi: UBI device object
294 * @ai: attach info object
295 * @new_vh: the volume header derived from new_aeb
296 * @new_aeb: the AEB to be examined
298 * Returns 0 on success, < 0 indicates an internal error.
300 static int process_pool_aeb(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
301 struct ubi_vid_hdr
*new_vh
,
302 struct ubi_ainf_peb
*new_aeb
)
304 struct ubi_ainf_volume
*av
, *tmp_av
= NULL
;
305 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
308 if (be32_to_cpu(new_vh
->vol_id
) == UBI_FM_SB_VOLUME_ID
||
309 be32_to_cpu(new_vh
->vol_id
) == UBI_FM_DATA_VOLUME_ID
) {
310 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
315 /* Find the volume this SEB belongs to */
318 tmp_av
= rb_entry(parent
, struct ubi_ainf_volume
, rb
);
320 if (be32_to_cpu(new_vh
->vol_id
) > tmp_av
->vol_id
)
322 else if (be32_to_cpu(new_vh
->vol_id
) < tmp_av
->vol_id
)
333 ubi_err(ubi
, "orphaned volume in fastmap pool!");
334 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
335 return UBI_BAD_FASTMAP
;
338 ubi_assert(be32_to_cpu(new_vh
->vol_id
) == av
->vol_id
);
340 return update_vol(ubi
, ai
, av
, new_vh
, new_aeb
);
344 * unmap_peb - unmap a PEB.
345 * If fastmap detects a free PEB in the pool it has to check whether
346 * this PEB has been unmapped after writing the fastmap.
348 * @ai: UBI attach info object
349 * @pnum: The PEB to be unmapped
351 static void unmap_peb(struct ubi_attach_info
*ai
, int pnum
)
353 struct ubi_ainf_volume
*av
;
354 struct rb_node
*node
, *node2
;
355 struct ubi_ainf_peb
*aeb
;
357 for (node
= rb_first(&ai
->volumes
); node
; node
= rb_next(node
)) {
358 av
= rb_entry(node
, struct ubi_ainf_volume
, rb
);
360 for (node2
= rb_first(&av
->root
); node2
;
361 node2
= rb_next(node2
)) {
362 aeb
= rb_entry(node2
, struct ubi_ainf_peb
, u
.rb
);
363 if (aeb
->pnum
== pnum
) {
364 rb_erase(&aeb
->u
.rb
, &av
->root
);
365 kmem_cache_free(ai
->aeb_slab_cache
, aeb
);
373 * scan_pool - scans a pool for changed (no longer empty PEBs).
374 * @ubi: UBI device object
375 * @ai: attach info object
376 * @pebs: an array of all PEB numbers in the to be scanned pool
377 * @pool_size: size of the pool (number of entries in @pebs)
378 * @max_sqnum: pointer to the maximal sequence number
379 * @eba_orphans: list of PEBs which need to be scanned
380 * @free: list of PEBs which are most likely free (and go into @ai->free)
382 * Returns 0 on success, if the pool is unusable UBI_BAD_FASTMAP is returned.
383 * < 0 indicates an internal error.
385 static int scan_pool(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
386 int *pebs
, int pool_size
, unsigned long long *max_sqnum
,
387 struct list_head
*eba_orphans
, struct list_head
*free
)
389 struct ubi_vid_hdr
*vh
;
390 struct ubi_ec_hdr
*ech
;
391 struct ubi_ainf_peb
*new_aeb
, *tmp_aeb
;
392 int i
, pnum
, err
, found_orphan
, ret
= 0;
394 ech
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
398 vh
= ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
404 dbg_bld("scanning fastmap pool: size = %i", pool_size
);
407 * Now scan all PEBs in the pool to find changes which have been made
408 * after the creation of the fastmap
410 for (i
= 0; i
< pool_size
; i
++) {
414 pnum
= be32_to_cpu(pebs
[i
]);
416 if (ubi_io_is_bad(ubi
, pnum
)) {
417 ubi_err(ubi
, "bad PEB in fastmap pool!");
418 ret
= UBI_BAD_FASTMAP
;
422 err
= ubi_io_read_ec_hdr(ubi
, pnum
, ech
, 0);
423 if (err
&& err
!= UBI_IO_BITFLIPS
) {
424 ubi_err(ubi
, "unable to read EC header! PEB:%i err:%i",
426 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
428 } else if (err
== UBI_IO_BITFLIPS
)
432 * Older UBI implementations have image_seq set to zero, so
433 * we shouldn't fail if image_seq == 0.
435 image_seq
= be32_to_cpu(ech
->image_seq
);
437 if (image_seq
&& (image_seq
!= ubi
->image_seq
)) {
438 ubi_err(ubi
, "bad image seq: 0x%x, expected: 0x%x",
439 be32_to_cpu(ech
->image_seq
), ubi
->image_seq
);
440 ret
= UBI_BAD_FASTMAP
;
444 err
= ubi_io_read_vid_hdr(ubi
, pnum
, vh
, 0);
445 if (err
== UBI_IO_FF
|| err
== UBI_IO_FF_BITFLIPS
) {
446 unsigned long long ec
= be64_to_cpu(ech
->ec
);
448 dbg_bld("Adding PEB to free: %i", pnum
);
449 if (err
== UBI_IO_FF_BITFLIPS
)
450 add_aeb(ai
, free
, pnum
, ec
, 1);
452 add_aeb(ai
, free
, pnum
, ec
, 0);
454 } else if (err
== 0 || err
== UBI_IO_BITFLIPS
) {
455 dbg_bld("Found non empty PEB:%i in pool", pnum
);
457 if (err
== UBI_IO_BITFLIPS
)
461 list_for_each_entry(tmp_aeb
, eba_orphans
, u
.list
) {
462 if (tmp_aeb
->pnum
== pnum
) {
468 list_del(&tmp_aeb
->u
.list
);
469 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
472 new_aeb
= kmem_cache_alloc(ai
->aeb_slab_cache
,
479 new_aeb
->ec
= be64_to_cpu(ech
->ec
);
480 new_aeb
->pnum
= pnum
;
481 new_aeb
->lnum
= be32_to_cpu(vh
->lnum
);
482 new_aeb
->sqnum
= be64_to_cpu(vh
->sqnum
);
483 new_aeb
->copy_flag
= vh
->copy_flag
;
484 new_aeb
->scrub
= scrub
;
486 if (*max_sqnum
< new_aeb
->sqnum
)
487 *max_sqnum
= new_aeb
->sqnum
;
489 err
= process_pool_aeb(ubi
, ai
, vh
, new_aeb
);
491 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
495 /* We are paranoid and fall back to scanning mode */
496 ubi_err(ubi
, "fastmap pool PEBs contains damaged PEBs!");
497 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
504 ubi_free_vid_hdr(ubi
, vh
);
510 * count_fastmap_pebs - Counts the PEBs found by fastmap.
511 * @ai: The UBI attach info object
513 static int count_fastmap_pebs(struct ubi_attach_info
*ai
)
515 struct ubi_ainf_peb
*aeb
;
516 struct ubi_ainf_volume
*av
;
517 struct rb_node
*rb1
, *rb2
;
520 list_for_each_entry(aeb
, &ai
->erase
, u
.list
)
523 list_for_each_entry(aeb
, &ai
->free
, u
.list
)
526 ubi_rb_for_each_entry(rb1
, av
, &ai
->volumes
, rb
)
527 ubi_rb_for_each_entry(rb2
, aeb
, &av
->root
, u
.rb
)
534 * ubi_attach_fastmap - creates ubi_attach_info from a fastmap.
535 * @ubi: UBI device object
536 * @ai: UBI attach info object
537 * @fm: the fastmap to be attached
539 * Returns 0 on success, UBI_BAD_FASTMAP if the found fastmap was unusable.
540 * < 0 indicates an internal error.
542 static int ubi_attach_fastmap(struct ubi_device
*ubi
,
543 struct ubi_attach_info
*ai
,
544 struct ubi_fastmap_layout
*fm
)
546 struct list_head used
, eba_orphans
, free
;
547 struct ubi_ainf_volume
*av
;
548 struct ubi_ainf_peb
*aeb
, *tmp_aeb
, *_tmp_aeb
;
549 struct ubi_ec_hdr
*ech
;
550 struct ubi_fm_sb
*fmsb
;
551 struct ubi_fm_hdr
*fmhdr
;
552 struct ubi_fm_scan_pool
*fmpl1
, *fmpl2
;
553 struct ubi_fm_ec
*fmec
;
554 struct ubi_fm_volhdr
*fmvhdr
;
555 struct ubi_fm_eba
*fm_eba
;
556 int ret
, i
, j
, pool_size
, wl_pool_size
;
557 size_t fm_pos
= 0, fm_size
= ubi
->fm_size
;
558 unsigned long long max_sqnum
= 0;
559 void *fm_raw
= ubi
->fm_buf
;
561 INIT_LIST_HEAD(&used
);
562 INIT_LIST_HEAD(&free
);
563 INIT_LIST_HEAD(&eba_orphans
);
564 INIT_LIST_HEAD(&ai
->corr
);
565 INIT_LIST_HEAD(&ai
->free
);
566 INIT_LIST_HEAD(&ai
->erase
);
567 INIT_LIST_HEAD(&ai
->alien
);
568 ai
->volumes
= RB_ROOT
;
569 ai
->min_ec
= UBI_MAX_ERASECOUNTER
;
571 ai
->aeb_slab_cache
= kmem_cache_create("ubi_ainf_peb_slab",
572 sizeof(struct ubi_ainf_peb
),
574 if (!ai
->aeb_slab_cache
) {
579 fmsb
= (struct ubi_fm_sb
*)(fm_raw
);
580 ai
->max_sqnum
= fmsb
->sqnum
;
581 fm_pos
+= sizeof(struct ubi_fm_sb
);
582 if (fm_pos
>= fm_size
)
585 fmhdr
= (struct ubi_fm_hdr
*)(fm_raw
+ fm_pos
);
586 fm_pos
+= sizeof(*fmhdr
);
587 if (fm_pos
>= fm_size
)
590 if (be32_to_cpu(fmhdr
->magic
) != UBI_FM_HDR_MAGIC
) {
591 ubi_err(ubi
, "bad fastmap header magic: 0x%x, expected: 0x%x",
592 be32_to_cpu(fmhdr
->magic
), UBI_FM_HDR_MAGIC
);
596 fmpl1
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
597 fm_pos
+= sizeof(*fmpl1
);
598 if (fm_pos
>= fm_size
)
600 if (be32_to_cpu(fmpl1
->magic
) != UBI_FM_POOL_MAGIC
) {
601 ubi_err(ubi
, "bad fastmap pool magic: 0x%x, expected: 0x%x",
602 be32_to_cpu(fmpl1
->magic
), UBI_FM_POOL_MAGIC
);
606 fmpl2
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
607 fm_pos
+= sizeof(*fmpl2
);
608 if (fm_pos
>= fm_size
)
610 if (be32_to_cpu(fmpl2
->magic
) != UBI_FM_POOL_MAGIC
) {
611 ubi_err(ubi
, "bad fastmap pool magic: 0x%x, expected: 0x%x",
612 be32_to_cpu(fmpl2
->magic
), UBI_FM_POOL_MAGIC
);
616 pool_size
= be16_to_cpu(fmpl1
->size
);
617 wl_pool_size
= be16_to_cpu(fmpl2
->size
);
618 fm
->max_pool_size
= be16_to_cpu(fmpl1
->max_size
);
619 fm
->max_wl_pool_size
= be16_to_cpu(fmpl2
->max_size
);
621 if (pool_size
> UBI_FM_MAX_POOL_SIZE
|| pool_size
< 0) {
622 ubi_err(ubi
, "bad pool size: %i", pool_size
);
626 if (wl_pool_size
> UBI_FM_MAX_POOL_SIZE
|| wl_pool_size
< 0) {
627 ubi_err(ubi
, "bad WL pool size: %i", wl_pool_size
);
632 if (fm
->max_pool_size
> UBI_FM_MAX_POOL_SIZE
||
633 fm
->max_pool_size
< 0) {
634 ubi_err(ubi
, "bad maximal pool size: %i", fm
->max_pool_size
);
638 if (fm
->max_wl_pool_size
> UBI_FM_MAX_POOL_SIZE
||
639 fm
->max_wl_pool_size
< 0) {
640 ubi_err(ubi
, "bad maximal WL pool size: %i",
641 fm
->max_wl_pool_size
);
645 /* read EC values from free list */
646 for (i
= 0; i
< be32_to_cpu(fmhdr
->free_peb_count
); i
++) {
647 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
648 fm_pos
+= sizeof(*fmec
);
649 if (fm_pos
>= fm_size
)
652 add_aeb(ai
, &ai
->free
, be32_to_cpu(fmec
->pnum
),
653 be32_to_cpu(fmec
->ec
), 0);
656 /* read EC values from used list */
657 for (i
= 0; i
< be32_to_cpu(fmhdr
->used_peb_count
); i
++) {
658 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
659 fm_pos
+= sizeof(*fmec
);
660 if (fm_pos
>= fm_size
)
663 add_aeb(ai
, &used
, be32_to_cpu(fmec
->pnum
),
664 be32_to_cpu(fmec
->ec
), 0);
667 /* read EC values from scrub list */
668 for (i
= 0; i
< be32_to_cpu(fmhdr
->scrub_peb_count
); i
++) {
669 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
670 fm_pos
+= sizeof(*fmec
);
671 if (fm_pos
>= fm_size
)
674 add_aeb(ai
, &used
, be32_to_cpu(fmec
->pnum
),
675 be32_to_cpu(fmec
->ec
), 1);
678 /* read EC values from erase list */
679 for (i
= 0; i
< be32_to_cpu(fmhdr
->erase_peb_count
); i
++) {
680 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
681 fm_pos
+= sizeof(*fmec
);
682 if (fm_pos
>= fm_size
)
685 add_aeb(ai
, &ai
->erase
, be32_to_cpu(fmec
->pnum
),
686 be32_to_cpu(fmec
->ec
), 1);
689 ai
->mean_ec
= div_u64(ai
->ec_sum
, ai
->ec_count
);
690 ai
->bad_peb_count
= be32_to_cpu(fmhdr
->bad_peb_count
);
692 /* Iterate over all volumes and read their EBA table */
693 for (i
= 0; i
< be32_to_cpu(fmhdr
->vol_count
); i
++) {
694 fmvhdr
= (struct ubi_fm_volhdr
*)(fm_raw
+ fm_pos
);
695 fm_pos
+= sizeof(*fmvhdr
);
696 if (fm_pos
>= fm_size
)
699 if (be32_to_cpu(fmvhdr
->magic
) != UBI_FM_VHDR_MAGIC
) {
700 ubi_err(ubi
, "bad fastmap vol header magic: 0x%x, expected: 0x%x",
701 be32_to_cpu(fmvhdr
->magic
), UBI_FM_VHDR_MAGIC
);
705 av
= add_vol(ai
, be32_to_cpu(fmvhdr
->vol_id
),
706 be32_to_cpu(fmvhdr
->used_ebs
),
707 be32_to_cpu(fmvhdr
->data_pad
),
709 be32_to_cpu(fmvhdr
->last_eb_bytes
));
715 if (ai
->highest_vol_id
< be32_to_cpu(fmvhdr
->vol_id
))
716 ai
->highest_vol_id
= be32_to_cpu(fmvhdr
->vol_id
);
718 fm_eba
= (struct ubi_fm_eba
*)(fm_raw
+ fm_pos
);
719 fm_pos
+= sizeof(*fm_eba
);
720 fm_pos
+= (sizeof(__be32
) * be32_to_cpu(fm_eba
->reserved_pebs
));
721 if (fm_pos
>= fm_size
)
724 if (be32_to_cpu(fm_eba
->magic
) != UBI_FM_EBA_MAGIC
) {
725 ubi_err(ubi
, "bad fastmap EBA header magic: 0x%x, expected: 0x%x",
726 be32_to_cpu(fm_eba
->magic
), UBI_FM_EBA_MAGIC
);
730 for (j
= 0; j
< be32_to_cpu(fm_eba
->reserved_pebs
); j
++) {
731 int pnum
= be32_to_cpu(fm_eba
->pnum
[j
]);
733 if ((int)be32_to_cpu(fm_eba
->pnum
[j
]) < 0)
737 list_for_each_entry(tmp_aeb
, &used
, u
.list
) {
738 if (tmp_aeb
->pnum
== pnum
) {
744 /* This can happen if a PEB is already in an EBA known
745 * by this fastmap but the PEB itself is not in the used
747 * In this case the PEB can be within the fastmap pool
748 * or while writing the fastmap it was in the protection
752 aeb
= kmem_cache_alloc(ai
->aeb_slab_cache
,
761 aeb
->pnum
= be32_to_cpu(fm_eba
->pnum
[j
]);
763 aeb
->scrub
= aeb
->copy_flag
= aeb
->sqnum
= 0;
764 list_add_tail(&aeb
->u
.list
, &eba_orphans
);
770 if (av
->highest_lnum
<= aeb
->lnum
)
771 av
->highest_lnum
= aeb
->lnum
;
773 assign_aeb_to_av(ai
, aeb
, av
);
775 dbg_bld("inserting PEB:%i (LEB %i) to vol %i",
776 aeb
->pnum
, aeb
->lnum
, av
->vol_id
);
779 ech
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
785 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &eba_orphans
,
789 if (ubi_io_is_bad(ubi
, tmp_aeb
->pnum
)) {
790 ubi_err(ubi
, "bad PEB in fastmap EBA orphan list");
791 ret
= UBI_BAD_FASTMAP
;
796 err
= ubi_io_read_ec_hdr(ubi
, tmp_aeb
->pnum
, ech
, 0);
797 if (err
&& err
!= UBI_IO_BITFLIPS
) {
798 ubi_err(ubi
, "unable to read EC header! PEB:%i err:%i",
800 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
804 } else if (err
== UBI_IO_BITFLIPS
)
807 tmp_aeb
->ec
= be64_to_cpu(ech
->ec
);
808 assign_aeb_to_av(ai
, tmp_aeb
, av
);
814 ret
= scan_pool(ubi
, ai
, fmpl1
->pebs
, pool_size
, &max_sqnum
,
815 &eba_orphans
, &free
);
819 ret
= scan_pool(ubi
, ai
, fmpl2
->pebs
, wl_pool_size
, &max_sqnum
,
820 &eba_orphans
, &free
);
824 if (max_sqnum
> ai
->max_sqnum
)
825 ai
->max_sqnum
= max_sqnum
;
827 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &free
, u
.list
)
828 list_move_tail(&tmp_aeb
->u
.list
, &ai
->free
);
830 ubi_assert(list_empty(&used
));
831 ubi_assert(list_empty(&eba_orphans
));
832 ubi_assert(list_empty(&free
));
835 * If fastmap is leaking PEBs (must not happen), raise a
836 * fat warning and fall back to scanning mode.
837 * We do this here because in ubi_wl_init() it's too late
838 * and we cannot fall back to scanning.
840 if (WARN_ON(count_fastmap_pebs(ai
) != ubi
->peb_count
-
841 ai
->bad_peb_count
- fm
->used_blocks
))
847 ret
= UBI_BAD_FASTMAP
;
849 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &used
, u
.list
) {
850 list_del(&tmp_aeb
->u
.list
);
851 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
853 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &eba_orphans
, u
.list
) {
854 list_del(&tmp_aeb
->u
.list
);
855 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
857 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &free
, u
.list
) {
858 list_del(&tmp_aeb
->u
.list
);
859 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
866 * ubi_scan_fastmap - scan the fastmap.
867 * @ubi: UBI device object
868 * @ai: UBI attach info to be filled
869 * @fm_anchor: The fastmap starts at this PEB
871 * Returns 0 on success, UBI_NO_FASTMAP if no fastmap was found,
872 * UBI_BAD_FASTMAP if one was found but is not usable.
873 * < 0 indicates an internal error.
875 int ubi_scan_fastmap(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
878 struct ubi_fm_sb
*fmsb
, *fmsb2
;
879 struct ubi_vid_hdr
*vh
;
880 struct ubi_ec_hdr
*ech
;
881 struct ubi_fastmap_layout
*fm
;
882 int i
, used_blocks
, pnum
, ret
= 0;
885 unsigned long long sqnum
= 0;
887 mutex_lock(&ubi
->fm_mutex
);
888 memset(ubi
->fm_buf
, 0, ubi
->fm_size
);
890 fmsb
= kmalloc(sizeof(*fmsb
), GFP_KERNEL
);
896 fm
= kzalloc(sizeof(*fm
), GFP_KERNEL
);
903 ret
= ubi_io_read(ubi
, fmsb
, fm_anchor
, ubi
->leb_start
, sizeof(*fmsb
));
904 if (ret
&& ret
!= UBI_IO_BITFLIPS
)
906 else if (ret
== UBI_IO_BITFLIPS
)
907 fm
->to_be_tortured
[0] = 1;
909 if (be32_to_cpu(fmsb
->magic
) != UBI_FM_SB_MAGIC
) {
910 ubi_err(ubi
, "bad super block magic: 0x%x, expected: 0x%x",
911 be32_to_cpu(fmsb
->magic
), UBI_FM_SB_MAGIC
);
912 ret
= UBI_BAD_FASTMAP
;
916 if (fmsb
->version
!= UBI_FM_FMT_VERSION
) {
917 ubi_err(ubi
, "bad fastmap version: %i, expected: %i",
918 fmsb
->version
, UBI_FM_FMT_VERSION
);
919 ret
= UBI_BAD_FASTMAP
;
923 used_blocks
= be32_to_cpu(fmsb
->used_blocks
);
924 if (used_blocks
> UBI_FM_MAX_BLOCKS
|| used_blocks
< 1) {
925 ubi_err(ubi
, "number of fastmap blocks is invalid: %i",
927 ret
= UBI_BAD_FASTMAP
;
931 fm_size
= ubi
->leb_size
* used_blocks
;
932 if (fm_size
!= ubi
->fm_size
) {
933 ubi_err(ubi
, "bad fastmap size: %zi, expected: %zi",
934 fm_size
, ubi
->fm_size
);
935 ret
= UBI_BAD_FASTMAP
;
939 ech
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
945 vh
= ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
951 for (i
= 0; i
< used_blocks
; i
++) {
954 pnum
= be32_to_cpu(fmsb
->block_loc
[i
]);
956 if (ubi_io_is_bad(ubi
, pnum
)) {
957 ret
= UBI_BAD_FASTMAP
;
961 ret
= ubi_io_read_ec_hdr(ubi
, pnum
, ech
, 0);
962 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
963 ubi_err(ubi
, "unable to read fastmap block# %i EC (PEB: %i)",
966 ret
= UBI_BAD_FASTMAP
;
968 } else if (ret
== UBI_IO_BITFLIPS
)
969 fm
->to_be_tortured
[i
] = 1;
971 image_seq
= be32_to_cpu(ech
->image_seq
);
973 ubi
->image_seq
= image_seq
;
976 * Older UBI implementations have image_seq set to zero, so
977 * we shouldn't fail if image_seq == 0.
979 if (image_seq
&& (image_seq
!= ubi
->image_seq
)) {
980 ubi_err(ubi
, "wrong image seq:%d instead of %d",
981 be32_to_cpu(ech
->image_seq
), ubi
->image_seq
);
982 ret
= UBI_BAD_FASTMAP
;
986 ret
= ubi_io_read_vid_hdr(ubi
, pnum
, vh
, 0);
987 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
988 ubi_err(ubi
, "unable to read fastmap block# %i (PEB: %i)",
994 if (be32_to_cpu(vh
->vol_id
) != UBI_FM_SB_VOLUME_ID
) {
995 ubi_err(ubi
, "bad fastmap anchor vol_id: 0x%x, expected: 0x%x",
996 be32_to_cpu(vh
->vol_id
),
997 UBI_FM_SB_VOLUME_ID
);
998 ret
= UBI_BAD_FASTMAP
;
1002 if (be32_to_cpu(vh
->vol_id
) != UBI_FM_DATA_VOLUME_ID
) {
1003 ubi_err(ubi
, "bad fastmap data vol_id: 0x%x, expected: 0x%x",
1004 be32_to_cpu(vh
->vol_id
),
1005 UBI_FM_DATA_VOLUME_ID
);
1006 ret
= UBI_BAD_FASTMAP
;
1011 if (sqnum
< be64_to_cpu(vh
->sqnum
))
1012 sqnum
= be64_to_cpu(vh
->sqnum
);
1014 ret
= ubi_io_read(ubi
, ubi
->fm_buf
+ (ubi
->leb_size
* i
), pnum
,
1015 ubi
->leb_start
, ubi
->leb_size
);
1016 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
1017 ubi_err(ubi
, "unable to read fastmap block# %i (PEB: %i, "
1018 "err: %i)", i
, pnum
, ret
);
1026 fmsb2
= (struct ubi_fm_sb
*)(ubi
->fm_buf
);
1027 tmp_crc
= be32_to_cpu(fmsb2
->data_crc
);
1028 fmsb2
->data_crc
= 0;
1029 crc
= crc32(UBI_CRC32_INIT
, ubi
->fm_buf
, fm_size
);
1030 if (crc
!= tmp_crc
) {
1031 ubi_err(ubi
, "fastmap data CRC is invalid");
1032 ubi_err(ubi
, "CRC should be: 0x%x, calc: 0x%x",
1034 ret
= UBI_BAD_FASTMAP
;
1038 fmsb2
->sqnum
= sqnum
;
1040 fm
->used_blocks
= used_blocks
;
1042 ret
= ubi_attach_fastmap(ubi
, ai
, fm
);
1045 ret
= UBI_BAD_FASTMAP
;
1049 for (i
= 0; i
< used_blocks
; i
++) {
1050 struct ubi_wl_entry
*e
;
1052 e
= kmem_cache_alloc(ubi_wl_entry_slab
, GFP_KERNEL
);
1061 e
->pnum
= be32_to_cpu(fmsb2
->block_loc
[i
]);
1062 e
->ec
= be32_to_cpu(fmsb2
->block_ec
[i
]);
1067 ubi
->fm_pool
.max_size
= ubi
->fm
->max_pool_size
;
1068 ubi
->fm_wl_pool
.max_size
= ubi
->fm
->max_wl_pool_size
;
1069 ubi_msg(ubi
, "attached by fastmap");
1070 ubi_msg(ubi
, "fastmap pool size: %d", ubi
->fm_pool
.max_size
);
1071 ubi_msg(ubi
, "fastmap WL pool size: %d",
1072 ubi
->fm_wl_pool
.max_size
);
1073 ubi
->fm_disabled
= 0;
1075 ubi_free_vid_hdr(ubi
, vh
);
1078 mutex_unlock(&ubi
->fm_mutex
);
1079 if (ret
== UBI_BAD_FASTMAP
)
1080 ubi_err(ubi
, "Attach by fastmap failed, doing a full scan!");
1084 ubi_free_vid_hdr(ubi
, vh
);
1093 * ubi_write_fastmap - writes a fastmap.
1094 * @ubi: UBI device object
1095 * @new_fm: the to be written fastmap
1097 * Returns 0 on success, < 0 indicates an internal error.
1099 static int ubi_write_fastmap(struct ubi_device
*ubi
,
1100 struct ubi_fastmap_layout
*new_fm
)
1104 struct ubi_fm_sb
*fmsb
;
1105 struct ubi_fm_hdr
*fmh
;
1106 struct ubi_fm_scan_pool
*fmpl1
, *fmpl2
;
1107 struct ubi_fm_ec
*fec
;
1108 struct ubi_fm_volhdr
*fvh
;
1109 struct ubi_fm_eba
*feba
;
1110 struct rb_node
*node
;
1111 struct ubi_wl_entry
*wl_e
;
1112 struct ubi_volume
*vol
;
1113 struct ubi_vid_hdr
*avhdr
, *dvhdr
;
1114 struct ubi_work
*ubi_wrk
;
1115 int ret
, i
, j
, free_peb_count
, used_peb_count
, vol_count
;
1116 int scrub_peb_count
, erase_peb_count
;
1118 fm_raw
= ubi
->fm_buf
;
1119 memset(ubi
->fm_buf
, 0, ubi
->fm_size
);
1121 avhdr
= new_fm_vhdr(ubi
, UBI_FM_SB_VOLUME_ID
);
1127 dvhdr
= new_fm_vhdr(ubi
, UBI_FM_DATA_VOLUME_ID
);
1133 spin_lock(&ubi
->volumes_lock
);
1134 spin_lock(&ubi
->wl_lock
);
1136 fmsb
= (struct ubi_fm_sb
*)fm_raw
;
1137 fm_pos
+= sizeof(*fmsb
);
1138 ubi_assert(fm_pos
<= ubi
->fm_size
);
1140 fmh
= (struct ubi_fm_hdr
*)(fm_raw
+ fm_pos
);
1141 fm_pos
+= sizeof(*fmh
);
1142 ubi_assert(fm_pos
<= ubi
->fm_size
);
1144 fmsb
->magic
= cpu_to_be32(UBI_FM_SB_MAGIC
);
1145 fmsb
->version
= UBI_FM_FMT_VERSION
;
1146 fmsb
->used_blocks
= cpu_to_be32(new_fm
->used_blocks
);
1147 /* the max sqnum will be filled in while *reading* the fastmap */
1150 fmh
->magic
= cpu_to_be32(UBI_FM_HDR_MAGIC
);
1153 scrub_peb_count
= 0;
1154 erase_peb_count
= 0;
1157 fmpl1
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
1158 fm_pos
+= sizeof(*fmpl1
);
1159 fmpl1
->magic
= cpu_to_be32(UBI_FM_POOL_MAGIC
);
1160 fmpl1
->size
= cpu_to_be16(ubi
->fm_pool
.size
);
1161 fmpl1
->max_size
= cpu_to_be16(ubi
->fm_pool
.max_size
);
1163 for (i
= 0; i
< ubi
->fm_pool
.size
; i
++)
1164 fmpl1
->pebs
[i
] = cpu_to_be32(ubi
->fm_pool
.pebs
[i
]);
1166 fmpl2
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
1167 fm_pos
+= sizeof(*fmpl2
);
1168 fmpl2
->magic
= cpu_to_be32(UBI_FM_POOL_MAGIC
);
1169 fmpl2
->size
= cpu_to_be16(ubi
->fm_wl_pool
.size
);
1170 fmpl2
->max_size
= cpu_to_be16(ubi
->fm_wl_pool
.max_size
);
1172 for (i
= 0; i
< ubi
->fm_wl_pool
.size
; i
++)
1173 fmpl2
->pebs
[i
] = cpu_to_be32(ubi
->fm_wl_pool
.pebs
[i
]);
1175 for (node
= rb_first(&ubi
->free
); node
; node
= rb_next(node
)) {
1176 wl_e
= rb_entry(node
, struct ubi_wl_entry
, u
.rb
);
1177 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1179 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1180 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1183 fm_pos
+= sizeof(*fec
);
1184 ubi_assert(fm_pos
<= ubi
->fm_size
);
1186 fmh
->free_peb_count
= cpu_to_be32(free_peb_count
);
1188 for (node
= rb_first(&ubi
->used
); node
; node
= rb_next(node
)) {
1189 wl_e
= rb_entry(node
, struct ubi_wl_entry
, u
.rb
);
1190 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1192 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1193 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1196 fm_pos
+= sizeof(*fec
);
1197 ubi_assert(fm_pos
<= ubi
->fm_size
);
1200 for (i
= 0; i
< UBI_PROT_QUEUE_LEN
; i
++) {
1201 list_for_each_entry(wl_e
, &ubi
->pq
[i
], u
.list
) {
1202 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1204 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1205 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1208 fm_pos
+= sizeof(*fec
);
1209 ubi_assert(fm_pos
<= ubi
->fm_size
);
1212 fmh
->used_peb_count
= cpu_to_be32(used_peb_count
);
1214 for (node
= rb_first(&ubi
->scrub
); node
; node
= rb_next(node
)) {
1215 wl_e
= rb_entry(node
, struct ubi_wl_entry
, u
.rb
);
1216 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1218 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1219 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1222 fm_pos
+= sizeof(*fec
);
1223 ubi_assert(fm_pos
<= ubi
->fm_size
);
1225 fmh
->scrub_peb_count
= cpu_to_be32(scrub_peb_count
);
1228 list_for_each_entry(ubi_wrk
, &ubi
->works
, list
) {
1229 if (ubi_is_erase_work(ubi_wrk
)) {
1233 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1235 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1236 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1239 fm_pos
+= sizeof(*fec
);
1240 ubi_assert(fm_pos
<= ubi
->fm_size
);
1243 fmh
->erase_peb_count
= cpu_to_be32(erase_peb_count
);
1245 for (i
= 0; i
< UBI_MAX_VOLUMES
+ UBI_INT_VOL_COUNT
; i
++) {
1246 vol
= ubi
->volumes
[i
];
1253 fvh
= (struct ubi_fm_volhdr
*)(fm_raw
+ fm_pos
);
1254 fm_pos
+= sizeof(*fvh
);
1255 ubi_assert(fm_pos
<= ubi
->fm_size
);
1257 fvh
->magic
= cpu_to_be32(UBI_FM_VHDR_MAGIC
);
1258 fvh
->vol_id
= cpu_to_be32(vol
->vol_id
);
1259 fvh
->vol_type
= vol
->vol_type
;
1260 fvh
->used_ebs
= cpu_to_be32(vol
->used_ebs
);
1261 fvh
->data_pad
= cpu_to_be32(vol
->data_pad
);
1262 fvh
->last_eb_bytes
= cpu_to_be32(vol
->last_eb_bytes
);
1264 ubi_assert(vol
->vol_type
== UBI_DYNAMIC_VOLUME
||
1265 vol
->vol_type
== UBI_STATIC_VOLUME
);
1267 feba
= (struct ubi_fm_eba
*)(fm_raw
+ fm_pos
);
1268 fm_pos
+= sizeof(*feba
) + (sizeof(__be32
) * vol
->reserved_pebs
);
1269 ubi_assert(fm_pos
<= ubi
->fm_size
);
1271 for (j
= 0; j
< vol
->reserved_pebs
; j
++)
1272 feba
->pnum
[j
] = cpu_to_be32(vol
->eba_tbl
[j
]);
1274 feba
->reserved_pebs
= cpu_to_be32(j
);
1275 feba
->magic
= cpu_to_be32(UBI_FM_EBA_MAGIC
);
1277 fmh
->vol_count
= cpu_to_be32(vol_count
);
1278 fmh
->bad_peb_count
= cpu_to_be32(ubi
->bad_peb_count
);
1280 avhdr
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1283 spin_unlock(&ubi
->wl_lock
);
1284 spin_unlock(&ubi
->volumes_lock
);
1286 dbg_bld("writing fastmap SB to PEB %i", new_fm
->e
[0]->pnum
);
1287 ret
= ubi_io_write_vid_hdr(ubi
, new_fm
->e
[0]->pnum
, avhdr
);
1289 ubi_err(ubi
, "unable to write vid_hdr to fastmap SB!");
1293 for (i
= 0; i
< new_fm
->used_blocks
; i
++) {
1294 fmsb
->block_loc
[i
] = cpu_to_be32(new_fm
->e
[i
]->pnum
);
1295 fmsb
->block_ec
[i
] = cpu_to_be32(new_fm
->e
[i
]->ec
);
1299 fmsb
->data_crc
= cpu_to_be32(crc32(UBI_CRC32_INIT
, fm_raw
,
1302 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1303 dvhdr
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1304 dvhdr
->lnum
= cpu_to_be32(i
);
1305 dbg_bld("writing fastmap data to PEB %i sqnum %llu",
1306 new_fm
->e
[i
]->pnum
, be64_to_cpu(dvhdr
->sqnum
));
1307 ret
= ubi_io_write_vid_hdr(ubi
, new_fm
->e
[i
]->pnum
, dvhdr
);
1309 ubi_err(ubi
, "unable to write vid_hdr to PEB %i!",
1310 new_fm
->e
[i
]->pnum
);
1315 for (i
= 0; i
< new_fm
->used_blocks
; i
++) {
1316 ret
= ubi_io_write(ubi
, fm_raw
+ (i
* ubi
->leb_size
),
1317 new_fm
->e
[i
]->pnum
, ubi
->leb_start
, ubi
->leb_size
);
1319 ubi_err(ubi
, "unable to write fastmap to PEB %i!",
1320 new_fm
->e
[i
]->pnum
);
1328 dbg_bld("fastmap written!");
1331 ubi_free_vid_hdr(ubi
, avhdr
);
1332 ubi_free_vid_hdr(ubi
, dvhdr
);
1338 * erase_block - Manually erase a PEB.
1339 * @ubi: UBI device object
1340 * @pnum: PEB to be erased
1342 * Returns the new EC value on success, < 0 indicates an internal error.
1344 static int erase_block(struct ubi_device
*ubi
, int pnum
)
1347 struct ubi_ec_hdr
*ec_hdr
;
1350 ec_hdr
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
1354 ret
= ubi_io_read_ec_hdr(ubi
, pnum
, ec_hdr
, 0);
1357 else if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
1362 ret
= ubi_io_sync_erase(ubi
, pnum
, 0);
1366 ec
= be64_to_cpu(ec_hdr
->ec
);
1368 if (ec
> UBI_MAX_ERASECOUNTER
) {
1373 ec_hdr
->ec
= cpu_to_be64(ec
);
1374 ret
= ubi_io_write_ec_hdr(ubi
, pnum
, ec_hdr
);
1385 * invalidate_fastmap - destroys a fastmap.
1386 * @ubi: UBI device object
1387 * @fm: the fastmap to be destroyed
1389 * Returns 0 on success, < 0 indicates an internal error.
1391 static int invalidate_fastmap(struct ubi_device
*ubi
,
1392 struct ubi_fastmap_layout
*fm
)
1395 struct ubi_vid_hdr
*vh
;
1397 ret
= erase_block(ubi
, fm
->e
[0]->pnum
);
1401 vh
= new_fm_vhdr(ubi
, UBI_FM_SB_VOLUME_ID
);
1405 /* deleting the current fastmap SB is not enough, an old SB may exist,
1406 * so create a (corrupted) SB such that fastmap will find it and fall
1407 * back to scanning mode in any case */
1408 vh
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1409 ret
= ubi_io_write_vid_hdr(ubi
, fm
->e
[0]->pnum
, vh
);
1415 * ubi_update_fastmap - will be called by UBI if a volume changes or
1416 * a fastmap pool becomes full.
1417 * @ubi: UBI device object
1419 * Returns 0 on success, < 0 indicates an internal error.
1421 int ubi_update_fastmap(struct ubi_device
*ubi
)
1424 struct ubi_fastmap_layout
*new_fm
, *old_fm
;
1425 struct ubi_wl_entry
*tmp_e
;
1427 mutex_lock(&ubi
->fm_mutex
);
1429 ubi_refill_pools(ubi
);
1431 if (ubi
->ro_mode
|| ubi
->fm_disabled
) {
1432 mutex_unlock(&ubi
->fm_mutex
);
1436 ret
= ubi_ensure_anchor_pebs(ubi
);
1438 mutex_unlock(&ubi
->fm_mutex
);
1442 new_fm
= kzalloc(sizeof(*new_fm
), GFP_KERNEL
);
1444 mutex_unlock(&ubi
->fm_mutex
);
1448 new_fm
->used_blocks
= ubi
->fm_size
/ ubi
->leb_size
;
1450 for (i
= 0; i
< new_fm
->used_blocks
; i
++) {
1451 new_fm
->e
[i
] = kmem_cache_alloc(ubi_wl_entry_slab
, GFP_KERNEL
);
1452 if (!new_fm
->e
[i
]) {
1454 kfree(new_fm
->e
[i
]);
1457 mutex_unlock(&ubi
->fm_mutex
);
1465 if (new_fm
->used_blocks
> UBI_FM_MAX_BLOCKS
) {
1466 ubi_err(ubi
, "fastmap too large");
1471 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1472 spin_lock(&ubi
->wl_lock
);
1473 tmp_e
= ubi_wl_get_fm_peb(ubi
, 0);
1474 spin_unlock(&ubi
->wl_lock
);
1476 if (!tmp_e
&& !old_fm
) {
1478 ubi_err(ubi
, "could not get any free erase block");
1480 for (j
= 1; j
< i
; j
++)
1481 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[j
], j
, 0);
1485 } else if (!tmp_e
&& old_fm
) {
1486 ret
= erase_block(ubi
, old_fm
->e
[i
]->pnum
);
1490 for (j
= 1; j
< i
; j
++)
1491 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[j
],
1494 ubi_err(ubi
, "could not erase old fastmap PEB");
1498 new_fm
->e
[i
]->pnum
= old_fm
->e
[i
]->pnum
;
1499 new_fm
->e
[i
]->ec
= old_fm
->e
[i
]->ec
;
1501 new_fm
->e
[i
]->pnum
= tmp_e
->pnum
;
1502 new_fm
->e
[i
]->ec
= tmp_e
->ec
;
1505 ubi_wl_put_fm_peb(ubi
, old_fm
->e
[i
], i
,
1506 old_fm
->to_be_tortured
[i
]);
1510 spin_lock(&ubi
->wl_lock
);
1511 tmp_e
= ubi_wl_get_fm_peb(ubi
, 1);
1512 spin_unlock(&ubi
->wl_lock
);
1515 /* no fresh anchor PEB was found, reuse the old one */
1517 ret
= erase_block(ubi
, old_fm
->e
[0]->pnum
);
1520 ubi_err(ubi
, "could not erase old anchor PEB");
1522 for (i
= 1; i
< new_fm
->used_blocks
; i
++)
1523 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[i
],
1528 new_fm
->e
[0]->pnum
= old_fm
->e
[0]->pnum
;
1529 new_fm
->e
[0]->ec
= ret
;
1531 /* we've got a new anchor PEB, return the old one */
1532 ubi_wl_put_fm_peb(ubi
, old_fm
->e
[0], 0,
1533 old_fm
->to_be_tortured
[0]);
1535 new_fm
->e
[0]->pnum
= tmp_e
->pnum
;
1536 new_fm
->e
[0]->ec
= tmp_e
->ec
;
1541 ubi_err(ubi
, "could not find any anchor PEB");
1543 for (i
= 1; i
< new_fm
->used_blocks
; i
++)
1544 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[i
], i
, 0);
1550 new_fm
->e
[0]->pnum
= tmp_e
->pnum
;
1551 new_fm
->e
[0]->ec
= tmp_e
->ec
;
1554 down_write(&ubi
->work_sem
);
1555 down_write(&ubi
->fm_sem
);
1556 ret
= ubi_write_fastmap(ubi
, new_fm
);
1557 up_write(&ubi
->fm_sem
);
1558 up_write(&ubi
->work_sem
);
1564 mutex_unlock(&ubi
->fm_mutex
);
1571 ubi_warn(ubi
, "Unable to write new fastmap, err=%i", ret
);
1575 ret
= invalidate_fastmap(ubi
, old_fm
);
1577 ubi_err(ubi
, "Unable to invalidiate current fastmap!");
This page took 0.120753 seconds and 4 git commands to generate.