2 * Copyright (c) 2012 Linutronix GmbH
3 * Copyright (c) 2014 sigma star gmbh
4 * Author: Richard Weinberger <richard@nod.at>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU General Public License for more details.
17 #include <linux/crc32.h>
18 #include <linux/bitmap.h>
22 * init_seen - allocate memory for used for debugging.
23 * @ubi: UBI device description object
25 static inline unsigned long *init_seen(struct ubi_device
*ubi
)
29 if (!ubi_dbg_chk_fastmap(ubi
))
32 ret
= kcalloc(BITS_TO_LONGS(ubi
->peb_count
), sizeof(unsigned long),
35 return ERR_PTR(-ENOMEM
);
41 * free_seen - free the seen logic integer array.
42 * @seen: integer array of @ubi->peb_count size
44 static inline void free_seen(unsigned long *seen
)
50 * set_seen - mark a PEB as seen.
51 * @ubi: UBI device description object
52 * @pnum: The PEB to be makred as seen
53 * @seen: integer array of @ubi->peb_count size
55 static inline void set_seen(struct ubi_device
*ubi
, int pnum
, unsigned long *seen
)
57 if (!ubi_dbg_chk_fastmap(ubi
) || !seen
)
64 * self_check_seen - check whether all PEB have been seen by fastmap.
65 * @ubi: UBI device description object
66 * @seen: integer array of @ubi->peb_count size
68 static int self_check_seen(struct ubi_device
*ubi
, unsigned long *seen
)
72 if (!ubi_dbg_chk_fastmap(ubi
) || !seen
)
75 for (pnum
= 0; pnum
< ubi
->peb_count
; pnum
++) {
76 if (test_bit(pnum
, seen
) && ubi
->lookuptbl
[pnum
]) {
77 ubi_err(ubi
, "self-check failed for PEB %d, fastmap didn't see it", pnum
);
86 * ubi_calc_fm_size - calculates the fastmap size in bytes for an UBI device.
87 * @ubi: UBI device description object
89 size_t ubi_calc_fm_size(struct ubi_device
*ubi
)
93 size
= sizeof(struct ubi_fm_sb
) +
94 sizeof(struct ubi_fm_hdr
) +
95 sizeof(struct ubi_fm_scan_pool
) +
96 sizeof(struct ubi_fm_scan_pool
) +
97 (ubi
->peb_count
* sizeof(struct ubi_fm_ec
)) +
98 (sizeof(struct ubi_fm_eba
) +
99 (ubi
->peb_count
* sizeof(__be32
))) +
100 sizeof(struct ubi_fm_volhdr
) * UBI_MAX_VOLUMES
;
101 return roundup(size
, ubi
->leb_size
);
106 * new_fm_vhdr - allocate a new volume header for fastmap usage.
107 * @ubi: UBI device description object
108 * @vol_id: the VID of the new header
110 * Returns a new struct ubi_vid_hdr on success.
111 * NULL indicates out of memory.
113 static struct ubi_vid_hdr
*new_fm_vhdr(struct ubi_device
*ubi
, int vol_id
)
115 struct ubi_vid_hdr
*new;
117 new = ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
121 new->vol_type
= UBI_VID_DYNAMIC
;
122 new->vol_id
= cpu_to_be32(vol_id
);
124 /* UBI implementations without fastmap support have to delete the
127 new->compat
= UBI_COMPAT_DELETE
;
134 * add_aeb - create and add a attach erase block to a given list.
135 * @ai: UBI attach info object
136 * @list: the target list
137 * @pnum: PEB number of the new attach erase block
138 * @ec: erease counter of the new LEB
139 * @scrub: scrub this PEB after attaching
141 * Returns 0 on success, < 0 indicates an internal error.
143 static int add_aeb(struct ubi_attach_info
*ai
, struct list_head
*list
,
144 int pnum
, int ec
, int scrub
)
146 struct ubi_ainf_peb
*aeb
;
148 aeb
= kmem_cache_alloc(ai
->aeb_slab_cache
, GFP_KERNEL
);
156 aeb
->copy_flag
= aeb
->sqnum
= 0;
158 ai
->ec_sum
+= aeb
->ec
;
161 if (ai
->max_ec
< aeb
->ec
)
162 ai
->max_ec
= aeb
->ec
;
164 if (ai
->min_ec
> aeb
->ec
)
165 ai
->min_ec
= aeb
->ec
;
167 list_add_tail(&aeb
->u
.list
, list
);
173 * add_vol - create and add a new volume to ubi_attach_info.
174 * @ai: ubi_attach_info object
175 * @vol_id: VID of the new volume
176 * @used_ebs: number of used EBS
177 * @data_pad: data padding value of the new volume
178 * @vol_type: volume type
179 * @last_eb_bytes: number of bytes in the last LEB
181 * Returns the new struct ubi_ainf_volume on success.
182 * NULL indicates an error.
184 static struct ubi_ainf_volume
*add_vol(struct ubi_attach_info
*ai
, int vol_id
,
185 int used_ebs
, int data_pad
, u8 vol_type
,
188 struct ubi_ainf_volume
*av
;
189 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
193 av
= rb_entry(parent
, struct ubi_ainf_volume
, rb
);
195 if (vol_id
> av
->vol_id
)
197 else if (vol_id
< av
->vol_id
)
200 return ERR_PTR(-EINVAL
);
203 av
= kmalloc(sizeof(struct ubi_ainf_volume
), GFP_KERNEL
);
207 av
->highest_lnum
= av
->leb_count
= av
->used_ebs
= 0;
209 av
->data_pad
= data_pad
;
210 av
->last_data_size
= last_eb_bytes
;
212 av
->vol_type
= vol_type
;
214 if (av
->vol_type
== UBI_STATIC_VOLUME
)
215 av
->used_ebs
= used_ebs
;
217 dbg_bld("found volume (ID %i)", vol_id
);
219 rb_link_node(&av
->rb
, parent
, p
);
220 rb_insert_color(&av
->rb
, &ai
->volumes
);
227 * assign_aeb_to_av - assigns a SEB to a given ainf_volume and removes it
228 * from it's original list.
229 * @ai: ubi_attach_info object
230 * @aeb: the to be assigned SEB
231 * @av: target scan volume
233 static void assign_aeb_to_av(struct ubi_attach_info
*ai
,
234 struct ubi_ainf_peb
*aeb
,
235 struct ubi_ainf_volume
*av
)
237 struct ubi_ainf_peb
*tmp_aeb
;
238 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
240 p
= &av
->root
.rb_node
;
244 tmp_aeb
= rb_entry(parent
, struct ubi_ainf_peb
, u
.rb
);
245 if (aeb
->lnum
!= tmp_aeb
->lnum
) {
246 if (aeb
->lnum
< tmp_aeb
->lnum
)
256 list_del(&aeb
->u
.list
);
259 rb_link_node(&aeb
->u
.rb
, parent
, p
);
260 rb_insert_color(&aeb
->u
.rb
, &av
->root
);
264 * update_vol - inserts or updates a LEB which was found a pool.
265 * @ubi: the UBI device object
266 * @ai: attach info object
267 * @av: the volume this LEB belongs to
268 * @new_vh: the volume header derived from new_aeb
269 * @new_aeb: the AEB to be examined
271 * Returns 0 on success, < 0 indicates an internal error.
273 static int update_vol(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
274 struct ubi_ainf_volume
*av
, struct ubi_vid_hdr
*new_vh
,
275 struct ubi_ainf_peb
*new_aeb
)
277 struct rb_node
**p
= &av
->root
.rb_node
, *parent
= NULL
;
278 struct ubi_ainf_peb
*aeb
, *victim
;
283 aeb
= rb_entry(parent
, struct ubi_ainf_peb
, u
.rb
);
285 if (be32_to_cpu(new_vh
->lnum
) != aeb
->lnum
) {
286 if (be32_to_cpu(new_vh
->lnum
) < aeb
->lnum
)
294 /* This case can happen if the fastmap gets written
295 * because of a volume change (creation, deletion, ..).
296 * Then a PEB can be within the persistent EBA and the pool.
298 if (aeb
->pnum
== new_aeb
->pnum
) {
299 ubi_assert(aeb
->lnum
== new_aeb
->lnum
);
300 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
305 cmp_res
= ubi_compare_lebs(ubi
, aeb
, new_aeb
->pnum
, new_vh
);
309 /* new_aeb is newer */
311 victim
= kmem_cache_alloc(ai
->aeb_slab_cache
,
316 victim
->ec
= aeb
->ec
;
317 victim
->pnum
= aeb
->pnum
;
318 list_add_tail(&victim
->u
.list
, &ai
->erase
);
320 if (av
->highest_lnum
== be32_to_cpu(new_vh
->lnum
))
322 be32_to_cpu(new_vh
->data_size
);
324 dbg_bld("vol %i: AEB %i's PEB %i is the newer",
325 av
->vol_id
, aeb
->lnum
, new_aeb
->pnum
);
327 aeb
->ec
= new_aeb
->ec
;
328 aeb
->pnum
= new_aeb
->pnum
;
329 aeb
->copy_flag
= new_vh
->copy_flag
;
330 aeb
->scrub
= new_aeb
->scrub
;
331 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
333 /* new_aeb is older */
335 dbg_bld("vol %i: AEB %i's PEB %i is old, dropping it",
336 av
->vol_id
, aeb
->lnum
, new_aeb
->pnum
);
337 list_add_tail(&new_aeb
->u
.list
, &ai
->erase
);
342 /* This LEB is new, let's add it to the volume */
344 if (av
->highest_lnum
<= be32_to_cpu(new_vh
->lnum
)) {
345 av
->highest_lnum
= be32_to_cpu(new_vh
->lnum
);
346 av
->last_data_size
= be32_to_cpu(new_vh
->data_size
);
349 if (av
->vol_type
== UBI_STATIC_VOLUME
)
350 av
->used_ebs
= be32_to_cpu(new_vh
->used_ebs
);
354 rb_link_node(&new_aeb
->u
.rb
, parent
, p
);
355 rb_insert_color(&new_aeb
->u
.rb
, &av
->root
);
361 * process_pool_aeb - we found a non-empty PEB in a pool.
362 * @ubi: UBI device object
363 * @ai: attach info object
364 * @new_vh: the volume header derived from new_aeb
365 * @new_aeb: the AEB to be examined
367 * Returns 0 on success, < 0 indicates an internal error.
369 static int process_pool_aeb(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
370 struct ubi_vid_hdr
*new_vh
,
371 struct ubi_ainf_peb
*new_aeb
)
373 struct ubi_ainf_volume
*av
, *tmp_av
= NULL
;
374 struct rb_node
**p
= &ai
->volumes
.rb_node
, *parent
= NULL
;
377 if (be32_to_cpu(new_vh
->vol_id
) == UBI_FM_SB_VOLUME_ID
||
378 be32_to_cpu(new_vh
->vol_id
) == UBI_FM_DATA_VOLUME_ID
) {
379 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
384 /* Find the volume this SEB belongs to */
387 tmp_av
= rb_entry(parent
, struct ubi_ainf_volume
, rb
);
389 if (be32_to_cpu(new_vh
->vol_id
) > tmp_av
->vol_id
)
391 else if (be32_to_cpu(new_vh
->vol_id
) < tmp_av
->vol_id
)
402 ubi_err(ubi
, "orphaned volume in fastmap pool!");
403 kmem_cache_free(ai
->aeb_slab_cache
, new_aeb
);
404 return UBI_BAD_FASTMAP
;
407 ubi_assert(be32_to_cpu(new_vh
->vol_id
) == av
->vol_id
);
409 return update_vol(ubi
, ai
, av
, new_vh
, new_aeb
);
413 * unmap_peb - unmap a PEB.
414 * If fastmap detects a free PEB in the pool it has to check whether
415 * this PEB has been unmapped after writing the fastmap.
417 * @ai: UBI attach info object
418 * @pnum: The PEB to be unmapped
420 static void unmap_peb(struct ubi_attach_info
*ai
, int pnum
)
422 struct ubi_ainf_volume
*av
;
423 struct rb_node
*node
, *node2
;
424 struct ubi_ainf_peb
*aeb
;
426 for (node
= rb_first(&ai
->volumes
); node
; node
= rb_next(node
)) {
427 av
= rb_entry(node
, struct ubi_ainf_volume
, rb
);
429 for (node2
= rb_first(&av
->root
); node2
;
430 node2
= rb_next(node2
)) {
431 aeb
= rb_entry(node2
, struct ubi_ainf_peb
, u
.rb
);
432 if (aeb
->pnum
== pnum
) {
433 rb_erase(&aeb
->u
.rb
, &av
->root
);
435 kmem_cache_free(ai
->aeb_slab_cache
, aeb
);
443 * scan_pool - scans a pool for changed (no longer empty PEBs).
444 * @ubi: UBI device object
445 * @ai: attach info object
446 * @pebs: an array of all PEB numbers in the to be scanned pool
447 * @pool_size: size of the pool (number of entries in @pebs)
448 * @max_sqnum: pointer to the maximal sequence number
449 * @free: list of PEBs which are most likely free (and go into @ai->free)
451 * Returns 0 on success, if the pool is unusable UBI_BAD_FASTMAP is returned.
452 * < 0 indicates an internal error.
454 static int scan_pool(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
455 __be32
*pebs
, int pool_size
, unsigned long long *max_sqnum
,
456 struct list_head
*free
)
458 struct ubi_vid_hdr
*vh
;
459 struct ubi_ec_hdr
*ech
;
460 struct ubi_ainf_peb
*new_aeb
;
461 int i
, pnum
, err
, ret
= 0;
463 ech
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
467 vh
= ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
473 dbg_bld("scanning fastmap pool: size = %i", pool_size
);
476 * Now scan all PEBs in the pool to find changes which have been made
477 * after the creation of the fastmap
479 for (i
= 0; i
< pool_size
; i
++) {
483 pnum
= be32_to_cpu(pebs
[i
]);
485 if (ubi_io_is_bad(ubi
, pnum
)) {
486 ubi_err(ubi
, "bad PEB in fastmap pool!");
487 ret
= UBI_BAD_FASTMAP
;
491 err
= ubi_io_read_ec_hdr(ubi
, pnum
, ech
, 0);
492 if (err
&& err
!= UBI_IO_BITFLIPS
) {
493 ubi_err(ubi
, "unable to read EC header! PEB:%i err:%i",
495 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
497 } else if (err
== UBI_IO_BITFLIPS
)
501 * Older UBI implementations have image_seq set to zero, so
502 * we shouldn't fail if image_seq == 0.
504 image_seq
= be32_to_cpu(ech
->image_seq
);
506 if (image_seq
&& (image_seq
!= ubi
->image_seq
)) {
507 ubi_err(ubi
, "bad image seq: 0x%x, expected: 0x%x",
508 be32_to_cpu(ech
->image_seq
), ubi
->image_seq
);
509 ret
= UBI_BAD_FASTMAP
;
513 err
= ubi_io_read_vid_hdr(ubi
, pnum
, vh
, 0);
514 if (err
== UBI_IO_FF
|| err
== UBI_IO_FF_BITFLIPS
) {
515 unsigned long long ec
= be64_to_cpu(ech
->ec
);
517 dbg_bld("Adding PEB to free: %i", pnum
);
518 if (err
== UBI_IO_FF_BITFLIPS
)
519 add_aeb(ai
, free
, pnum
, ec
, 1);
521 add_aeb(ai
, free
, pnum
, ec
, 0);
523 } else if (err
== 0 || err
== UBI_IO_BITFLIPS
) {
524 dbg_bld("Found non empty PEB:%i in pool", pnum
);
526 if (err
== UBI_IO_BITFLIPS
)
529 new_aeb
= kmem_cache_alloc(ai
->aeb_slab_cache
,
536 new_aeb
->ec
= be64_to_cpu(ech
->ec
);
537 new_aeb
->pnum
= pnum
;
538 new_aeb
->lnum
= be32_to_cpu(vh
->lnum
);
539 new_aeb
->sqnum
= be64_to_cpu(vh
->sqnum
);
540 new_aeb
->copy_flag
= vh
->copy_flag
;
541 new_aeb
->scrub
= scrub
;
543 if (*max_sqnum
< new_aeb
->sqnum
)
544 *max_sqnum
= new_aeb
->sqnum
;
546 err
= process_pool_aeb(ubi
, ai
, vh
, new_aeb
);
548 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
552 /* We are paranoid and fall back to scanning mode */
553 ubi_err(ubi
, "fastmap pool PEBs contains damaged PEBs!");
554 ret
= err
> 0 ? UBI_BAD_FASTMAP
: err
;
561 ubi_free_vid_hdr(ubi
, vh
);
567 * count_fastmap_pebs - Counts the PEBs found by fastmap.
568 * @ai: The UBI attach info object
570 static int count_fastmap_pebs(struct ubi_attach_info
*ai
)
572 struct ubi_ainf_peb
*aeb
;
573 struct ubi_ainf_volume
*av
;
574 struct rb_node
*rb1
, *rb2
;
577 list_for_each_entry(aeb
, &ai
->erase
, u
.list
)
580 list_for_each_entry(aeb
, &ai
->free
, u
.list
)
583 ubi_rb_for_each_entry(rb1
, av
, &ai
->volumes
, rb
)
584 ubi_rb_for_each_entry(rb2
, aeb
, &av
->root
, u
.rb
)
591 * ubi_attach_fastmap - creates ubi_attach_info from a fastmap.
592 * @ubi: UBI device object
593 * @ai: UBI attach info object
594 * @fm: the fastmap to be attached
596 * Returns 0 on success, UBI_BAD_FASTMAP if the found fastmap was unusable.
597 * < 0 indicates an internal error.
599 static int ubi_attach_fastmap(struct ubi_device
*ubi
,
600 struct ubi_attach_info
*ai
,
601 struct ubi_fastmap_layout
*fm
)
603 struct list_head used
, free
;
604 struct ubi_ainf_volume
*av
;
605 struct ubi_ainf_peb
*aeb
, *tmp_aeb
, *_tmp_aeb
;
606 struct ubi_fm_sb
*fmsb
;
607 struct ubi_fm_hdr
*fmhdr
;
608 struct ubi_fm_scan_pool
*fmpl
, *fmpl_wl
;
609 struct ubi_fm_ec
*fmec
;
610 struct ubi_fm_volhdr
*fmvhdr
;
611 struct ubi_fm_eba
*fm_eba
;
612 int ret
, i
, j
, pool_size
, wl_pool_size
;
613 size_t fm_pos
= 0, fm_size
= ubi
->fm_size
;
614 unsigned long long max_sqnum
= 0;
615 void *fm_raw
= ubi
->fm_buf
;
617 INIT_LIST_HEAD(&used
);
618 INIT_LIST_HEAD(&free
);
619 ai
->min_ec
= UBI_MAX_ERASECOUNTER
;
621 fmsb
= (struct ubi_fm_sb
*)(fm_raw
);
622 ai
->max_sqnum
= fmsb
->sqnum
;
623 fm_pos
+= sizeof(struct ubi_fm_sb
);
624 if (fm_pos
>= fm_size
)
627 fmhdr
= (struct ubi_fm_hdr
*)(fm_raw
+ fm_pos
);
628 fm_pos
+= sizeof(*fmhdr
);
629 if (fm_pos
>= fm_size
)
632 if (be32_to_cpu(fmhdr
->magic
) != UBI_FM_HDR_MAGIC
) {
633 ubi_err(ubi
, "bad fastmap header magic: 0x%x, expected: 0x%x",
634 be32_to_cpu(fmhdr
->magic
), UBI_FM_HDR_MAGIC
);
638 fmpl
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
639 fm_pos
+= sizeof(*fmpl
);
640 if (fm_pos
>= fm_size
)
642 if (be32_to_cpu(fmpl
->magic
) != UBI_FM_POOL_MAGIC
) {
643 ubi_err(ubi
, "bad fastmap pool magic: 0x%x, expected: 0x%x",
644 be32_to_cpu(fmpl
->magic
), UBI_FM_POOL_MAGIC
);
648 fmpl_wl
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
649 fm_pos
+= sizeof(*fmpl_wl
);
650 if (fm_pos
>= fm_size
)
652 if (be32_to_cpu(fmpl_wl
->magic
) != UBI_FM_POOL_MAGIC
) {
653 ubi_err(ubi
, "bad fastmap WL pool magic: 0x%x, expected: 0x%x",
654 be32_to_cpu(fmpl_wl
->magic
), UBI_FM_POOL_MAGIC
);
658 pool_size
= be16_to_cpu(fmpl
->size
);
659 wl_pool_size
= be16_to_cpu(fmpl_wl
->size
);
660 fm
->max_pool_size
= be16_to_cpu(fmpl
->max_size
);
661 fm
->max_wl_pool_size
= be16_to_cpu(fmpl_wl
->max_size
);
663 if (pool_size
> UBI_FM_MAX_POOL_SIZE
|| pool_size
< 0) {
664 ubi_err(ubi
, "bad pool size: %i", pool_size
);
668 if (wl_pool_size
> UBI_FM_MAX_POOL_SIZE
|| wl_pool_size
< 0) {
669 ubi_err(ubi
, "bad WL pool size: %i", wl_pool_size
);
674 if (fm
->max_pool_size
> UBI_FM_MAX_POOL_SIZE
||
675 fm
->max_pool_size
< 0) {
676 ubi_err(ubi
, "bad maximal pool size: %i", fm
->max_pool_size
);
680 if (fm
->max_wl_pool_size
> UBI_FM_MAX_POOL_SIZE
||
681 fm
->max_wl_pool_size
< 0) {
682 ubi_err(ubi
, "bad maximal WL pool size: %i",
683 fm
->max_wl_pool_size
);
687 /* read EC values from free list */
688 for (i
= 0; i
< be32_to_cpu(fmhdr
->free_peb_count
); i
++) {
689 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
690 fm_pos
+= sizeof(*fmec
);
691 if (fm_pos
>= fm_size
)
694 add_aeb(ai
, &ai
->free
, be32_to_cpu(fmec
->pnum
),
695 be32_to_cpu(fmec
->ec
), 0);
698 /* read EC values from used list */
699 for (i
= 0; i
< be32_to_cpu(fmhdr
->used_peb_count
); i
++) {
700 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
701 fm_pos
+= sizeof(*fmec
);
702 if (fm_pos
>= fm_size
)
705 add_aeb(ai
, &used
, be32_to_cpu(fmec
->pnum
),
706 be32_to_cpu(fmec
->ec
), 0);
709 /* read EC values from scrub list */
710 for (i
= 0; i
< be32_to_cpu(fmhdr
->scrub_peb_count
); i
++) {
711 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
712 fm_pos
+= sizeof(*fmec
);
713 if (fm_pos
>= fm_size
)
716 add_aeb(ai
, &used
, be32_to_cpu(fmec
->pnum
),
717 be32_to_cpu(fmec
->ec
), 1);
720 /* read EC values from erase list */
721 for (i
= 0; i
< be32_to_cpu(fmhdr
->erase_peb_count
); i
++) {
722 fmec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
723 fm_pos
+= sizeof(*fmec
);
724 if (fm_pos
>= fm_size
)
727 add_aeb(ai
, &ai
->erase
, be32_to_cpu(fmec
->pnum
),
728 be32_to_cpu(fmec
->ec
), 1);
731 ai
->mean_ec
= div_u64(ai
->ec_sum
, ai
->ec_count
);
732 ai
->bad_peb_count
= be32_to_cpu(fmhdr
->bad_peb_count
);
734 /* Iterate over all volumes and read their EBA table */
735 for (i
= 0; i
< be32_to_cpu(fmhdr
->vol_count
); i
++) {
736 fmvhdr
= (struct ubi_fm_volhdr
*)(fm_raw
+ fm_pos
);
737 fm_pos
+= sizeof(*fmvhdr
);
738 if (fm_pos
>= fm_size
)
741 if (be32_to_cpu(fmvhdr
->magic
) != UBI_FM_VHDR_MAGIC
) {
742 ubi_err(ubi
, "bad fastmap vol header magic: 0x%x, expected: 0x%x",
743 be32_to_cpu(fmvhdr
->magic
), UBI_FM_VHDR_MAGIC
);
747 av
= add_vol(ai
, be32_to_cpu(fmvhdr
->vol_id
),
748 be32_to_cpu(fmvhdr
->used_ebs
),
749 be32_to_cpu(fmvhdr
->data_pad
),
751 be32_to_cpu(fmvhdr
->last_eb_bytes
));
755 if (PTR_ERR(av
) == -EINVAL
) {
756 ubi_err(ubi
, "volume (ID %i) already exists",
762 if (ai
->highest_vol_id
< be32_to_cpu(fmvhdr
->vol_id
))
763 ai
->highest_vol_id
= be32_to_cpu(fmvhdr
->vol_id
);
765 fm_eba
= (struct ubi_fm_eba
*)(fm_raw
+ fm_pos
);
766 fm_pos
+= sizeof(*fm_eba
);
767 fm_pos
+= (sizeof(__be32
) * be32_to_cpu(fm_eba
->reserved_pebs
));
768 if (fm_pos
>= fm_size
)
771 if (be32_to_cpu(fm_eba
->magic
) != UBI_FM_EBA_MAGIC
) {
772 ubi_err(ubi
, "bad fastmap EBA header magic: 0x%x, expected: 0x%x",
773 be32_to_cpu(fm_eba
->magic
), UBI_FM_EBA_MAGIC
);
777 for (j
= 0; j
< be32_to_cpu(fm_eba
->reserved_pebs
); j
++) {
778 int pnum
= be32_to_cpu(fm_eba
->pnum
[j
]);
784 list_for_each_entry(tmp_aeb
, &used
, u
.list
) {
785 if (tmp_aeb
->pnum
== pnum
) {
792 ubi_err(ubi
, "PEB %i is in EBA but not in used list", pnum
);
798 if (av
->highest_lnum
<= aeb
->lnum
)
799 av
->highest_lnum
= aeb
->lnum
;
801 assign_aeb_to_av(ai
, aeb
, av
);
803 dbg_bld("inserting PEB:%i (LEB %i) to vol %i",
804 aeb
->pnum
, aeb
->lnum
, av
->vol_id
);
808 ret
= scan_pool(ubi
, ai
, fmpl
->pebs
, pool_size
, &max_sqnum
, &free
);
812 ret
= scan_pool(ubi
, ai
, fmpl_wl
->pebs
, wl_pool_size
, &max_sqnum
, &free
);
816 if (max_sqnum
> ai
->max_sqnum
)
817 ai
->max_sqnum
= max_sqnum
;
819 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &free
, u
.list
)
820 list_move_tail(&tmp_aeb
->u
.list
, &ai
->free
);
822 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &used
, u
.list
)
823 list_move_tail(&tmp_aeb
->u
.list
, &ai
->erase
);
825 ubi_assert(list_empty(&free
));
828 * If fastmap is leaking PEBs (must not happen), raise a
829 * fat warning and fall back to scanning mode.
830 * We do this here because in ubi_wl_init() it's too late
831 * and we cannot fall back to scanning.
833 if (WARN_ON(count_fastmap_pebs(ai
) != ubi
->peb_count
-
834 ai
->bad_peb_count
- fm
->used_blocks
))
840 ret
= UBI_BAD_FASTMAP
;
842 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &used
, u
.list
) {
843 list_del(&tmp_aeb
->u
.list
);
844 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
846 list_for_each_entry_safe(tmp_aeb
, _tmp_aeb
, &free
, u
.list
) {
847 list_del(&tmp_aeb
->u
.list
);
848 kmem_cache_free(ai
->aeb_slab_cache
, tmp_aeb
);
855 * find_fm_anchor - find the most recent Fastmap superblock (anchor)
856 * @ai: UBI attach info to be filled
858 static int find_fm_anchor(struct ubi_attach_info
*ai
)
861 struct ubi_ainf_peb
*aeb
;
862 unsigned long long max_sqnum
= 0;
864 list_for_each_entry(aeb
, &ai
->fastmap
, u
.list
) {
865 if (aeb
->vol_id
== UBI_FM_SB_VOLUME_ID
&& aeb
->sqnum
> max_sqnum
) {
866 max_sqnum
= aeb
->sqnum
;
875 * ubi_scan_fastmap - scan the fastmap.
876 * @ubi: UBI device object
877 * @ai: UBI attach info to be filled
878 * @scan_ai: UBI attach info from the first 64 PEBs,
879 * used to find the most recent Fastmap data structure
881 * Returns 0 on success, UBI_NO_FASTMAP if no fastmap was found,
882 * UBI_BAD_FASTMAP if one was found but is not usable.
883 * < 0 indicates an internal error.
885 int ubi_scan_fastmap(struct ubi_device
*ubi
, struct ubi_attach_info
*ai
,
886 struct ubi_attach_info
*scan_ai
)
888 struct ubi_fm_sb
*fmsb
, *fmsb2
;
889 struct ubi_vid_hdr
*vh
;
890 struct ubi_ec_hdr
*ech
;
891 struct ubi_fastmap_layout
*fm
;
892 struct ubi_ainf_peb
*tmp_aeb
, *aeb
;
893 int i
, used_blocks
, pnum
, fm_anchor
, ret
= 0;
896 unsigned long long sqnum
= 0;
898 fm_anchor
= find_fm_anchor(scan_ai
);
900 return UBI_NO_FASTMAP
;
902 /* Move all (possible) fastmap blocks into our new attach structure. */
903 list_for_each_entry_safe(aeb
, tmp_aeb
, &scan_ai
->fastmap
, u
.list
)
904 list_move_tail(&aeb
->u
.list
, &ai
->fastmap
);
906 down_write(&ubi
->fm_protect
);
907 memset(ubi
->fm_buf
, 0, ubi
->fm_size
);
909 fmsb
= kmalloc(sizeof(*fmsb
), GFP_KERNEL
);
915 fm
= kzalloc(sizeof(*fm
), GFP_KERNEL
);
922 ret
= ubi_io_read(ubi
, fmsb
, fm_anchor
, ubi
->leb_start
, sizeof(*fmsb
));
923 if (ret
&& ret
!= UBI_IO_BITFLIPS
)
925 else if (ret
== UBI_IO_BITFLIPS
)
926 fm
->to_be_tortured
[0] = 1;
928 if (be32_to_cpu(fmsb
->magic
) != UBI_FM_SB_MAGIC
) {
929 ubi_err(ubi
, "bad super block magic: 0x%x, expected: 0x%x",
930 be32_to_cpu(fmsb
->magic
), UBI_FM_SB_MAGIC
);
931 ret
= UBI_BAD_FASTMAP
;
935 if (fmsb
->version
!= UBI_FM_FMT_VERSION
) {
936 ubi_err(ubi
, "bad fastmap version: %i, expected: %i",
937 fmsb
->version
, UBI_FM_FMT_VERSION
);
938 ret
= UBI_BAD_FASTMAP
;
942 used_blocks
= be32_to_cpu(fmsb
->used_blocks
);
943 if (used_blocks
> UBI_FM_MAX_BLOCKS
|| used_blocks
< 1) {
944 ubi_err(ubi
, "number of fastmap blocks is invalid: %i",
946 ret
= UBI_BAD_FASTMAP
;
950 fm_size
= ubi
->leb_size
* used_blocks
;
951 if (fm_size
!= ubi
->fm_size
) {
952 ubi_err(ubi
, "bad fastmap size: %zi, expected: %zi",
953 fm_size
, ubi
->fm_size
);
954 ret
= UBI_BAD_FASTMAP
;
958 ech
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
964 vh
= ubi_zalloc_vid_hdr(ubi
, GFP_KERNEL
);
970 for (i
= 0; i
< used_blocks
; i
++) {
973 pnum
= be32_to_cpu(fmsb
->block_loc
[i
]);
975 if (ubi_io_is_bad(ubi
, pnum
)) {
976 ret
= UBI_BAD_FASTMAP
;
980 if (i
== 0 && pnum
!= fm_anchor
) {
981 ubi_err(ubi
, "Fastmap anchor PEB mismatch: PEB: %i vs. %i",
983 ret
= UBI_BAD_FASTMAP
;
987 ret
= ubi_io_read_ec_hdr(ubi
, pnum
, ech
, 0);
988 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
989 ubi_err(ubi
, "unable to read fastmap block# %i EC (PEB: %i)",
992 ret
= UBI_BAD_FASTMAP
;
994 } else if (ret
== UBI_IO_BITFLIPS
)
995 fm
->to_be_tortured
[i
] = 1;
997 image_seq
= be32_to_cpu(ech
->image_seq
);
999 ubi
->image_seq
= image_seq
;
1002 * Older UBI implementations have image_seq set to zero, so
1003 * we shouldn't fail if image_seq == 0.
1005 if (image_seq
&& (image_seq
!= ubi
->image_seq
)) {
1006 ubi_err(ubi
, "wrong image seq:%d instead of %d",
1007 be32_to_cpu(ech
->image_seq
), ubi
->image_seq
);
1008 ret
= UBI_BAD_FASTMAP
;
1012 ret
= ubi_io_read_vid_hdr(ubi
, pnum
, vh
, 0);
1013 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
1014 ubi_err(ubi
, "unable to read fastmap block# %i (PEB: %i)",
1020 if (be32_to_cpu(vh
->vol_id
) != UBI_FM_SB_VOLUME_ID
) {
1021 ubi_err(ubi
, "bad fastmap anchor vol_id: 0x%x, expected: 0x%x",
1022 be32_to_cpu(vh
->vol_id
),
1023 UBI_FM_SB_VOLUME_ID
);
1024 ret
= UBI_BAD_FASTMAP
;
1028 if (be32_to_cpu(vh
->vol_id
) != UBI_FM_DATA_VOLUME_ID
) {
1029 ubi_err(ubi
, "bad fastmap data vol_id: 0x%x, expected: 0x%x",
1030 be32_to_cpu(vh
->vol_id
),
1031 UBI_FM_DATA_VOLUME_ID
);
1032 ret
= UBI_BAD_FASTMAP
;
1037 if (sqnum
< be64_to_cpu(vh
->sqnum
))
1038 sqnum
= be64_to_cpu(vh
->sqnum
);
1040 ret
= ubi_io_read(ubi
, ubi
->fm_buf
+ (ubi
->leb_size
* i
), pnum
,
1041 ubi
->leb_start
, ubi
->leb_size
);
1042 if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
1043 ubi_err(ubi
, "unable to read fastmap block# %i (PEB: %i, "
1044 "err: %i)", i
, pnum
, ret
);
1052 fmsb2
= (struct ubi_fm_sb
*)(ubi
->fm_buf
);
1053 tmp_crc
= be32_to_cpu(fmsb2
->data_crc
);
1054 fmsb2
->data_crc
= 0;
1055 crc
= crc32(UBI_CRC32_INIT
, ubi
->fm_buf
, fm_size
);
1056 if (crc
!= tmp_crc
) {
1057 ubi_err(ubi
, "fastmap data CRC is invalid");
1058 ubi_err(ubi
, "CRC should be: 0x%x, calc: 0x%x",
1060 ret
= UBI_BAD_FASTMAP
;
1064 fmsb2
->sqnum
= sqnum
;
1066 fm
->used_blocks
= used_blocks
;
1068 ret
= ubi_attach_fastmap(ubi
, ai
, fm
);
1071 ret
= UBI_BAD_FASTMAP
;
1075 for (i
= 0; i
< used_blocks
; i
++) {
1076 struct ubi_wl_entry
*e
;
1078 e
= kmem_cache_alloc(ubi_wl_entry_slab
, GFP_KERNEL
);
1087 e
->pnum
= be32_to_cpu(fmsb2
->block_loc
[i
]);
1088 e
->ec
= be32_to_cpu(fmsb2
->block_ec
[i
]);
1093 ubi
->fm_pool
.max_size
= ubi
->fm
->max_pool_size
;
1094 ubi
->fm_wl_pool
.max_size
= ubi
->fm
->max_wl_pool_size
;
1095 ubi_msg(ubi
, "attached by fastmap");
1096 ubi_msg(ubi
, "fastmap pool size: %d", ubi
->fm_pool
.max_size
);
1097 ubi_msg(ubi
, "fastmap WL pool size: %d",
1098 ubi
->fm_wl_pool
.max_size
);
1099 ubi
->fm_disabled
= 0;
1100 ubi
->fast_attach
= 1;
1102 ubi_free_vid_hdr(ubi
, vh
);
1105 up_write(&ubi
->fm_protect
);
1106 if (ret
== UBI_BAD_FASTMAP
)
1107 ubi_err(ubi
, "Attach by fastmap failed, doing a full scan!");
1111 ubi_free_vid_hdr(ubi
, vh
);
1120 * ubi_write_fastmap - writes a fastmap.
1121 * @ubi: UBI device object
1122 * @new_fm: the to be written fastmap
1124 * Returns 0 on success, < 0 indicates an internal error.
1126 static int ubi_write_fastmap(struct ubi_device
*ubi
,
1127 struct ubi_fastmap_layout
*new_fm
)
1131 struct ubi_fm_sb
*fmsb
;
1132 struct ubi_fm_hdr
*fmh
;
1133 struct ubi_fm_scan_pool
*fmpl
, *fmpl_wl
;
1134 struct ubi_fm_ec
*fec
;
1135 struct ubi_fm_volhdr
*fvh
;
1136 struct ubi_fm_eba
*feba
;
1137 struct ubi_wl_entry
*wl_e
;
1138 struct ubi_volume
*vol
;
1139 struct ubi_vid_hdr
*avhdr
, *dvhdr
;
1140 struct ubi_work
*ubi_wrk
;
1141 struct rb_node
*tmp_rb
;
1142 int ret
, i
, j
, free_peb_count
, used_peb_count
, vol_count
;
1143 int scrub_peb_count
, erase_peb_count
;
1144 unsigned long *seen_pebs
= NULL
;
1146 fm_raw
= ubi
->fm_buf
;
1147 memset(ubi
->fm_buf
, 0, ubi
->fm_size
);
1149 avhdr
= new_fm_vhdr(ubi
, UBI_FM_SB_VOLUME_ID
);
1155 dvhdr
= new_fm_vhdr(ubi
, UBI_FM_DATA_VOLUME_ID
);
1161 seen_pebs
= init_seen(ubi
);
1162 if (IS_ERR(seen_pebs
)) {
1163 ret
= PTR_ERR(seen_pebs
);
1167 spin_lock(&ubi
->volumes_lock
);
1168 spin_lock(&ubi
->wl_lock
);
1170 fmsb
= (struct ubi_fm_sb
*)fm_raw
;
1171 fm_pos
+= sizeof(*fmsb
);
1172 ubi_assert(fm_pos
<= ubi
->fm_size
);
1174 fmh
= (struct ubi_fm_hdr
*)(fm_raw
+ fm_pos
);
1175 fm_pos
+= sizeof(*fmh
);
1176 ubi_assert(fm_pos
<= ubi
->fm_size
);
1178 fmsb
->magic
= cpu_to_be32(UBI_FM_SB_MAGIC
);
1179 fmsb
->version
= UBI_FM_FMT_VERSION
;
1180 fmsb
->used_blocks
= cpu_to_be32(new_fm
->used_blocks
);
1181 /* the max sqnum will be filled in while *reading* the fastmap */
1184 fmh
->magic
= cpu_to_be32(UBI_FM_HDR_MAGIC
);
1187 scrub_peb_count
= 0;
1188 erase_peb_count
= 0;
1191 fmpl
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
1192 fm_pos
+= sizeof(*fmpl
);
1193 fmpl
->magic
= cpu_to_be32(UBI_FM_POOL_MAGIC
);
1194 fmpl
->size
= cpu_to_be16(ubi
->fm_pool
.size
);
1195 fmpl
->max_size
= cpu_to_be16(ubi
->fm_pool
.max_size
);
1197 for (i
= 0; i
< ubi
->fm_pool
.size
; i
++) {
1198 fmpl
->pebs
[i
] = cpu_to_be32(ubi
->fm_pool
.pebs
[i
]);
1199 set_seen(ubi
, ubi
->fm_pool
.pebs
[i
], seen_pebs
);
1202 fmpl_wl
= (struct ubi_fm_scan_pool
*)(fm_raw
+ fm_pos
);
1203 fm_pos
+= sizeof(*fmpl_wl
);
1204 fmpl_wl
->magic
= cpu_to_be32(UBI_FM_POOL_MAGIC
);
1205 fmpl_wl
->size
= cpu_to_be16(ubi
->fm_wl_pool
.size
);
1206 fmpl_wl
->max_size
= cpu_to_be16(ubi
->fm_wl_pool
.max_size
);
1208 for (i
= 0; i
< ubi
->fm_wl_pool
.size
; i
++) {
1209 fmpl_wl
->pebs
[i
] = cpu_to_be32(ubi
->fm_wl_pool
.pebs
[i
]);
1210 set_seen(ubi
, ubi
->fm_wl_pool
.pebs
[i
], seen_pebs
);
1213 ubi_for_each_free_peb(ubi
, wl_e
, tmp_rb
) {
1214 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1216 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1217 set_seen(ubi
, wl_e
->pnum
, seen_pebs
);
1218 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1221 fm_pos
+= sizeof(*fec
);
1222 ubi_assert(fm_pos
<= ubi
->fm_size
);
1224 fmh
->free_peb_count
= cpu_to_be32(free_peb_count
);
1226 ubi_for_each_used_peb(ubi
, wl_e
, tmp_rb
) {
1227 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1229 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1230 set_seen(ubi
, wl_e
->pnum
, seen_pebs
);
1231 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1234 fm_pos
+= sizeof(*fec
);
1235 ubi_assert(fm_pos
<= ubi
->fm_size
);
1238 ubi_for_each_protected_peb(ubi
, i
, wl_e
) {
1239 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1241 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1242 set_seen(ubi
, wl_e
->pnum
, seen_pebs
);
1243 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1246 fm_pos
+= sizeof(*fec
);
1247 ubi_assert(fm_pos
<= ubi
->fm_size
);
1249 fmh
->used_peb_count
= cpu_to_be32(used_peb_count
);
1251 ubi_for_each_scrub_peb(ubi
, wl_e
, tmp_rb
) {
1252 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1254 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1255 set_seen(ubi
, wl_e
->pnum
, seen_pebs
);
1256 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1259 fm_pos
+= sizeof(*fec
);
1260 ubi_assert(fm_pos
<= ubi
->fm_size
);
1262 fmh
->scrub_peb_count
= cpu_to_be32(scrub_peb_count
);
1265 list_for_each_entry(ubi_wrk
, &ubi
->works
, list
) {
1266 if (ubi_is_erase_work(ubi_wrk
)) {
1270 fec
= (struct ubi_fm_ec
*)(fm_raw
+ fm_pos
);
1272 fec
->pnum
= cpu_to_be32(wl_e
->pnum
);
1273 set_seen(ubi
, wl_e
->pnum
, seen_pebs
);
1274 fec
->ec
= cpu_to_be32(wl_e
->ec
);
1277 fm_pos
+= sizeof(*fec
);
1278 ubi_assert(fm_pos
<= ubi
->fm_size
);
1281 fmh
->erase_peb_count
= cpu_to_be32(erase_peb_count
);
1283 for (i
= 0; i
< UBI_MAX_VOLUMES
+ UBI_INT_VOL_COUNT
; i
++) {
1284 vol
= ubi
->volumes
[i
];
1291 fvh
= (struct ubi_fm_volhdr
*)(fm_raw
+ fm_pos
);
1292 fm_pos
+= sizeof(*fvh
);
1293 ubi_assert(fm_pos
<= ubi
->fm_size
);
1295 fvh
->magic
= cpu_to_be32(UBI_FM_VHDR_MAGIC
);
1296 fvh
->vol_id
= cpu_to_be32(vol
->vol_id
);
1297 fvh
->vol_type
= vol
->vol_type
;
1298 fvh
->used_ebs
= cpu_to_be32(vol
->used_ebs
);
1299 fvh
->data_pad
= cpu_to_be32(vol
->data_pad
);
1300 fvh
->last_eb_bytes
= cpu_to_be32(vol
->last_eb_bytes
);
1302 ubi_assert(vol
->vol_type
== UBI_DYNAMIC_VOLUME
||
1303 vol
->vol_type
== UBI_STATIC_VOLUME
);
1305 feba
= (struct ubi_fm_eba
*)(fm_raw
+ fm_pos
);
1306 fm_pos
+= sizeof(*feba
) + (sizeof(__be32
) * vol
->reserved_pebs
);
1307 ubi_assert(fm_pos
<= ubi
->fm_size
);
1309 for (j
= 0; j
< vol
->reserved_pebs
; j
++)
1310 feba
->pnum
[j
] = cpu_to_be32(vol
->eba_tbl
[j
]);
1312 feba
->reserved_pebs
= cpu_to_be32(j
);
1313 feba
->magic
= cpu_to_be32(UBI_FM_EBA_MAGIC
);
1315 fmh
->vol_count
= cpu_to_be32(vol_count
);
1316 fmh
->bad_peb_count
= cpu_to_be32(ubi
->bad_peb_count
);
1318 avhdr
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1321 spin_unlock(&ubi
->wl_lock
);
1322 spin_unlock(&ubi
->volumes_lock
);
1324 dbg_bld("writing fastmap SB to PEB %i", new_fm
->e
[0]->pnum
);
1325 ret
= ubi_io_write_vid_hdr(ubi
, new_fm
->e
[0]->pnum
, avhdr
);
1327 ubi_err(ubi
, "unable to write vid_hdr to fastmap SB!");
1331 for (i
= 0; i
< new_fm
->used_blocks
; i
++) {
1332 fmsb
->block_loc
[i
] = cpu_to_be32(new_fm
->e
[i
]->pnum
);
1333 set_seen(ubi
, new_fm
->e
[i
]->pnum
, seen_pebs
);
1334 fmsb
->block_ec
[i
] = cpu_to_be32(new_fm
->e
[i
]->ec
);
1338 fmsb
->data_crc
= cpu_to_be32(crc32(UBI_CRC32_INIT
, fm_raw
,
1341 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1342 dvhdr
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1343 dvhdr
->lnum
= cpu_to_be32(i
);
1344 dbg_bld("writing fastmap data to PEB %i sqnum %llu",
1345 new_fm
->e
[i
]->pnum
, be64_to_cpu(dvhdr
->sqnum
));
1346 ret
= ubi_io_write_vid_hdr(ubi
, new_fm
->e
[i
]->pnum
, dvhdr
);
1348 ubi_err(ubi
, "unable to write vid_hdr to PEB %i!",
1349 new_fm
->e
[i
]->pnum
);
1354 for (i
= 0; i
< new_fm
->used_blocks
; i
++) {
1355 ret
= ubi_io_write(ubi
, fm_raw
+ (i
* ubi
->leb_size
),
1356 new_fm
->e
[i
]->pnum
, ubi
->leb_start
, ubi
->leb_size
);
1358 ubi_err(ubi
, "unable to write fastmap to PEB %i!",
1359 new_fm
->e
[i
]->pnum
);
1367 ret
= self_check_seen(ubi
, seen_pebs
);
1368 dbg_bld("fastmap written!");
1371 ubi_free_vid_hdr(ubi
, avhdr
);
1372 ubi_free_vid_hdr(ubi
, dvhdr
);
1373 free_seen(seen_pebs
);
1379 * erase_block - Manually erase a PEB.
1380 * @ubi: UBI device object
1381 * @pnum: PEB to be erased
1383 * Returns the new EC value on success, < 0 indicates an internal error.
1385 static int erase_block(struct ubi_device
*ubi
, int pnum
)
1388 struct ubi_ec_hdr
*ec_hdr
;
1391 ec_hdr
= kzalloc(ubi
->ec_hdr_alsize
, GFP_KERNEL
);
1395 ret
= ubi_io_read_ec_hdr(ubi
, pnum
, ec_hdr
, 0);
1398 else if (ret
&& ret
!= UBI_IO_BITFLIPS
) {
1403 ret
= ubi_io_sync_erase(ubi
, pnum
, 0);
1407 ec
= be64_to_cpu(ec_hdr
->ec
);
1409 if (ec
> UBI_MAX_ERASECOUNTER
) {
1414 ec_hdr
->ec
= cpu_to_be64(ec
);
1415 ret
= ubi_io_write_ec_hdr(ubi
, pnum
, ec_hdr
);
1426 * invalidate_fastmap - destroys a fastmap.
1427 * @ubi: UBI device object
1429 * This function ensures that upon next UBI attach a full scan
1430 * is issued. We need this if UBI is about to write a new fastmap
1431 * but is unable to do so. In this case we have two options:
1432 * a) Make sure that the current fastmap will not be usued upon
1433 * attach time and contine or b) fall back to RO mode to have the
1434 * current fastmap in a valid state.
1435 * Returns 0 on success, < 0 indicates an internal error.
1437 static int invalidate_fastmap(struct ubi_device
*ubi
)
1440 struct ubi_fastmap_layout
*fm
;
1441 struct ubi_wl_entry
*e
;
1442 struct ubi_vid_hdr
*vh
= NULL
;
1450 fm
= kzalloc(sizeof(*fm
), GFP_KERNEL
);
1454 vh
= new_fm_vhdr(ubi
, UBI_FM_SB_VOLUME_ID
);
1459 e
= ubi_wl_get_fm_peb(ubi
, 1);
1464 * Create fake fastmap such that UBI will fall back
1467 vh
->sqnum
= cpu_to_be64(ubi_next_sqnum(ubi
));
1468 ret
= ubi_io_write_vid_hdr(ubi
, e
->pnum
, vh
);
1470 ubi_wl_put_fm_peb(ubi
, e
, 0, 0);
1474 fm
->used_blocks
= 1;
1480 ubi_free_vid_hdr(ubi
, vh
);
1489 * return_fm_pebs - returns all PEBs used by a fastmap back to the
1491 * @ubi: UBI device object
1492 * @fm: fastmap layout object
1494 static void return_fm_pebs(struct ubi_device
*ubi
,
1495 struct ubi_fastmap_layout
*fm
)
1502 for (i
= 0; i
< fm
->used_blocks
; i
++) {
1504 ubi_wl_put_fm_peb(ubi
, fm
->e
[i
], i
,
1505 fm
->to_be_tortured
[i
]);
1512 * ubi_update_fastmap - will be called by UBI if a volume changes or
1513 * a fastmap pool becomes full.
1514 * @ubi: UBI device object
1516 * Returns 0 on success, < 0 indicates an internal error.
1518 int ubi_update_fastmap(struct ubi_device
*ubi
)
1521 struct ubi_fastmap_layout
*new_fm
, *old_fm
;
1522 struct ubi_wl_entry
*tmp_e
;
1524 down_write(&ubi
->fm_protect
);
1526 ubi_refill_pools(ubi
);
1528 if (ubi
->ro_mode
|| ubi
->fm_disabled
) {
1529 up_write(&ubi
->fm_protect
);
1533 ret
= ubi_ensure_anchor_pebs(ubi
);
1535 up_write(&ubi
->fm_protect
);
1539 new_fm
= kzalloc(sizeof(*new_fm
), GFP_KERNEL
);
1541 up_write(&ubi
->fm_protect
);
1545 new_fm
->used_blocks
= ubi
->fm_size
/ ubi
->leb_size
;
1549 if (new_fm
->used_blocks
> UBI_FM_MAX_BLOCKS
) {
1550 ubi_err(ubi
, "fastmap too large");
1555 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1556 spin_lock(&ubi
->wl_lock
);
1557 tmp_e
= ubi_wl_get_fm_peb(ubi
, 0);
1558 spin_unlock(&ubi
->wl_lock
);
1561 if (old_fm
&& old_fm
->e
[i
]) {
1562 ret
= erase_block(ubi
, old_fm
->e
[i
]->pnum
);
1564 ubi_err(ubi
, "could not erase old fastmap PEB");
1566 for (j
= 1; j
< i
; j
++) {
1567 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[j
],
1569 new_fm
->e
[j
] = NULL
;
1573 new_fm
->e
[i
] = old_fm
->e
[i
];
1574 old_fm
->e
[i
] = NULL
;
1576 ubi_err(ubi
, "could not get any free erase block");
1578 for (j
= 1; j
< i
; j
++) {
1579 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[j
], j
, 0);
1580 new_fm
->e
[j
] = NULL
;
1587 new_fm
->e
[i
] = tmp_e
;
1589 if (old_fm
&& old_fm
->e
[i
]) {
1590 ubi_wl_put_fm_peb(ubi
, old_fm
->e
[i
], i
,
1591 old_fm
->to_be_tortured
[i
]);
1592 old_fm
->e
[i
] = NULL
;
1597 /* Old fastmap is larger than the new one */
1598 if (old_fm
&& new_fm
->used_blocks
< old_fm
->used_blocks
) {
1599 for (i
= new_fm
->used_blocks
; i
< old_fm
->used_blocks
; i
++) {
1600 ubi_wl_put_fm_peb(ubi
, old_fm
->e
[i
], i
,
1601 old_fm
->to_be_tortured
[i
]);
1602 old_fm
->e
[i
] = NULL
;
1606 spin_lock(&ubi
->wl_lock
);
1607 tmp_e
= ubi_wl_get_fm_peb(ubi
, 1);
1608 spin_unlock(&ubi
->wl_lock
);
1611 /* no fresh anchor PEB was found, reuse the old one */
1613 ret
= erase_block(ubi
, old_fm
->e
[0]->pnum
);
1615 ubi_err(ubi
, "could not erase old anchor PEB");
1617 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1618 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[i
],
1620 new_fm
->e
[i
] = NULL
;
1624 new_fm
->e
[0] = old_fm
->e
[0];
1625 new_fm
->e
[0]->ec
= ret
;
1626 old_fm
->e
[0] = NULL
;
1628 /* we've got a new anchor PEB, return the old one */
1629 ubi_wl_put_fm_peb(ubi
, old_fm
->e
[0], 0,
1630 old_fm
->to_be_tortured
[0]);
1631 new_fm
->e
[0] = tmp_e
;
1632 old_fm
->e
[0] = NULL
;
1636 ubi_err(ubi
, "could not find any anchor PEB");
1638 for (i
= 1; i
< new_fm
->used_blocks
; i
++) {
1639 ubi_wl_put_fm_peb(ubi
, new_fm
->e
[i
], i
, 0);
1640 new_fm
->e
[i
] = NULL
;
1646 new_fm
->e
[0] = tmp_e
;
1649 down_write(&ubi
->work_sem
);
1650 down_write(&ubi
->fm_eba_sem
);
1651 ret
= ubi_write_fastmap(ubi
, new_fm
);
1652 up_write(&ubi
->fm_eba_sem
);
1653 up_write(&ubi
->work_sem
);
1659 up_write(&ubi
->fm_protect
);
1664 ubi_warn(ubi
, "Unable to write new fastmap, err=%i", ret
);
1666 ret
= invalidate_fastmap(ubi
);
1668 ubi_err(ubi
, "Unable to invalidiate current fastmap!");
1671 return_fm_pebs(ubi
, old_fm
);
1672 return_fm_pebs(ubi
, new_fm
);
This page took 0.080249 seconds and 6 git commands to generate.