2 * This file is part of UBIFS.
4 * Copyright (C) 2006-2008 Nokia Corporation
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * Authors: Adrian Hunter
20 * Artem Bityutskiy (Битюцкий Артём)
24 * This file implements functions needed to recover from unclean un-mounts.
25 * When UBIFS is mounted, it checks a flag on the master node to determine if
26 * an un-mount was completed sucessfully. If not, the process of mounting
27 * incorparates additional checking and fixing of on-flash data structures.
28 * UBIFS always cleans away all remnants of an unclean un-mount, so that
29 * errors do not accumulate. However UBIFS defers recovery if it is mounted
30 * read-only, and the flash is not modified in that case.
33 #include <linux/crc32.h>
37 * is_empty - determine whether a buffer is empty (contains all 0xff).
38 * @buf: buffer to clean
39 * @len: length of buffer
41 * This function returns %1 if the buffer is empty (contains all 0xff) otherwise
44 static int is_empty(void *buf
, int len
)
49 for (i
= 0; i
< len
; i
++)
56 * get_master_node - get the last valid master node allowing for corruption.
57 * @c: UBIFS file-system description object
59 * @pbuf: buffer containing the LEB read, is returned here
60 * @mst: master node, if found, is returned here
61 * @cor: corruption, if found, is returned here
63 * This function allocates a buffer, reads the LEB into it, and finds and
64 * returns the last valid master node allowing for one area of corruption.
65 * The corrupt area, if there is one, must be consistent with the assumption
66 * that it is the result of an unclean unmount while the master node was being
67 * written. Under those circumstances, it is valid to use the previously written
70 * This function returns %0 on success and a negative error code on failure.
72 static int get_master_node(const struct ubifs_info
*c
, int lnum
, void **pbuf
,
73 struct ubifs_mst_node
**mst
, void **cor
)
75 const int sz
= c
->mst_node_alsz
;
79 sbuf
= vmalloc(c
->leb_size
);
83 err
= ubi_read(c
->ubi
, lnum
, sbuf
, 0, c
->leb_size
);
84 if (err
&& err
!= -EBADMSG
)
87 /* Find the first position that is definitely not a node */
91 while (offs
+ UBIFS_MST_NODE_SZ
<= c
->leb_size
) {
92 struct ubifs_ch
*ch
= buf
;
94 if (le32_to_cpu(ch
->magic
) != UBIFS_NODE_MAGIC
)
100 /* See if there was a valid master node before that */
107 ret
= ubifs_scan_a_node(c
, buf
, len
, lnum
, offs
, 1);
108 if (ret
!= SCANNED_A_NODE
&& offs
) {
109 /* Could have been corruption so check one place back */
113 ret
= ubifs_scan_a_node(c
, buf
, len
, lnum
, offs
, 1);
114 if (ret
!= SCANNED_A_NODE
)
116 * We accept only one area of corruption because
117 * we are assuming that it was caused while
118 * trying to write a master node.
122 if (ret
== SCANNED_A_NODE
) {
123 struct ubifs_ch
*ch
= buf
;
125 if (ch
->node_type
!= UBIFS_MST_NODE
)
127 dbg_rcvry("found a master node at %d:%d", lnum
, offs
);
134 /* Check for corruption */
135 if (offs
< c
->leb_size
) {
136 if (!is_empty(buf
, min_t(int, len
, sz
))) {
138 dbg_rcvry("found corruption at %d:%d", lnum
, offs
);
144 /* Check remaining empty space */
145 if (offs
< c
->leb_size
)
146 if (!is_empty(buf
, len
))
161 * write_rcvrd_mst_node - write recovered master node.
162 * @c: UBIFS file-system description object
165 * This function returns %0 on success and a negative error code on failure.
167 static int write_rcvrd_mst_node(struct ubifs_info
*c
,
168 struct ubifs_mst_node
*mst
)
170 int err
= 0, lnum
= UBIFS_MST_LNUM
, sz
= c
->mst_node_alsz
;
173 dbg_rcvry("recovery");
175 save_flags
= mst
->flags
;
176 mst
->flags
|= cpu_to_le32(UBIFS_MST_RCVRY
);
178 ubifs_prepare_node(c
, mst
, UBIFS_MST_NODE_SZ
, 1);
179 err
= ubi_leb_change(c
->ubi
, lnum
, mst
, sz
, UBI_SHORTTERM
);
182 err
= ubi_leb_change(c
->ubi
, lnum
+ 1, mst
, sz
, UBI_SHORTTERM
);
186 mst
->flags
= save_flags
;
191 * ubifs_recover_master_node - recover the master node.
192 * @c: UBIFS file-system description object
194 * This function recovers the master node from corruption that may occur due to
195 * an unclean unmount.
197 * This function returns %0 on success and a negative error code on failure.
199 int ubifs_recover_master_node(struct ubifs_info
*c
)
201 void *buf1
= NULL
, *buf2
= NULL
, *cor1
= NULL
, *cor2
= NULL
;
202 struct ubifs_mst_node
*mst1
= NULL
, *mst2
= NULL
, *mst
;
203 const int sz
= c
->mst_node_alsz
;
204 int err
, offs1
, offs2
;
206 dbg_rcvry("recovery");
208 err
= get_master_node(c
, UBIFS_MST_LNUM
, &buf1
, &mst1
, &cor1
);
212 err
= get_master_node(c
, UBIFS_MST_LNUM
+ 1, &buf2
, &mst2
, &cor2
);
217 offs1
= (void *)mst1
- buf1
;
218 if ((le32_to_cpu(mst1
->flags
) & UBIFS_MST_RCVRY
) &&
219 (offs1
== 0 && !cor1
)) {
221 * mst1 was written by recovery at offset 0 with no
224 dbg_rcvry("recovery recovery");
227 offs2
= (void *)mst2
- buf2
;
228 if (offs1
== offs2
) {
229 /* Same offset, so must be the same */
230 if (memcmp((void *)mst1
+ UBIFS_CH_SZ
,
231 (void *)mst2
+ UBIFS_CH_SZ
,
232 UBIFS_MST_NODE_SZ
- UBIFS_CH_SZ
))
235 } else if (offs2
+ sz
== offs1
) {
236 /* 1st LEB was written, 2nd was not */
240 } else if (offs1
== 0 && offs2
+ sz
>= c
->leb_size
) {
241 /* 1st LEB was unmapped and written, 2nd not */
249 * 2nd LEB was unmapped and about to be written, so
250 * there must be only one master node in the first LEB
253 if (offs1
!= 0 || cor1
)
261 * 1st LEB was unmapped and about to be written, so there must
262 * be no room left in 2nd LEB.
264 offs2
= (void *)mst2
- buf2
;
265 if (offs2
+ sz
+ sz
<= c
->leb_size
)
270 dbg_rcvry("recovered master node from LEB %d",
271 (mst
== mst1
? UBIFS_MST_LNUM
: UBIFS_MST_LNUM
+ 1));
273 memcpy(c
->mst_node
, mst
, UBIFS_MST_NODE_SZ
);
275 if ((c
->vfs_sb
->s_flags
& MS_RDONLY
)) {
276 /* Read-only mode. Keep a copy for switching to rw mode */
277 c
->rcvrd_mst_node
= kmalloc(sz
, GFP_KERNEL
);
278 if (!c
->rcvrd_mst_node
) {
282 memcpy(c
->rcvrd_mst_node
, c
->mst_node
, UBIFS_MST_NODE_SZ
);
284 /* Write the recovered master node */
285 c
->max_sqnum
= le64_to_cpu(mst
->ch
.sqnum
) - 1;
286 err
= write_rcvrd_mst_node(c
, c
->mst_node
);
299 ubifs_err("failed to recover master node");
301 dbg_err("dumping first master node");
302 dbg_dump_node(c
, mst1
);
305 dbg_err("dumping second master node");
306 dbg_dump_node(c
, mst2
);
314 * ubifs_write_rcvrd_mst_node - write the recovered master node.
315 * @c: UBIFS file-system description object
317 * This function writes the master node that was recovered during mounting in
318 * read-only mode and must now be written because we are remounting rw.
320 * This function returns %0 on success and a negative error code on failure.
322 int ubifs_write_rcvrd_mst_node(struct ubifs_info
*c
)
326 if (!c
->rcvrd_mst_node
)
328 c
->rcvrd_mst_node
->flags
|= cpu_to_le32(UBIFS_MST_DIRTY
);
329 c
->mst_node
->flags
|= cpu_to_le32(UBIFS_MST_DIRTY
);
330 err
= write_rcvrd_mst_node(c
, c
->rcvrd_mst_node
);
333 kfree(c
->rcvrd_mst_node
);
334 c
->rcvrd_mst_node
= NULL
;
339 * is_last_write - determine if an offset was in the last write to a LEB.
340 * @c: UBIFS file-system description object
341 * @buf: buffer to check
342 * @offs: offset to check
344 * This function returns %1 if @offs was in the last write to the LEB whose data
345 * is in @buf, otherwise %0 is returned. The determination is made by checking
346 * for subsequent empty space starting from the next @c->min_io_size boundary.
348 static int is_last_write(const struct ubifs_info
*c
, void *buf
, int offs
)
350 int empty_offs
, check_len
;
354 * Round up to the next @c->min_io_size boundary i.e. @offs is in the
355 * last wbuf written. After that should be empty space.
357 empty_offs
= ALIGN(offs
+ 1, c
->min_io_size
);
358 check_len
= c
->leb_size
- empty_offs
;
359 p
= buf
+ empty_offs
- offs
;
361 for (; check_len
> 0; check_len
--)
368 * clean_buf - clean the data from an LEB sitting in a buffer.
369 * @c: UBIFS file-system description object
370 * @buf: buffer to clean
371 * @lnum: LEB number to clean
372 * @offs: offset from which to clean
373 * @len: length of buffer
375 * This function pads up to the next min_io_size boundary (if there is one) and
376 * sets empty space to all 0xff. @buf, @offs and @len are updated to the next
377 * @c->min_io_size boundary.
379 static void clean_buf(const struct ubifs_info
*c
, void **buf
, int lnum
,
382 int empty_offs
, pad_len
;
385 dbg_rcvry("cleaning corruption at %d:%d", lnum
, *offs
);
387 ubifs_assert(!(*offs
& 7));
388 empty_offs
= ALIGN(*offs
, c
->min_io_size
);
389 pad_len
= empty_offs
- *offs
;
390 ubifs_pad(c
, *buf
, pad_len
);
394 memset(*buf
, 0xff, c
->leb_size
- empty_offs
);
398 * no_more_nodes - determine if there are no more nodes in a buffer.
399 * @c: UBIFS file-system description object
400 * @buf: buffer to check
401 * @len: length of buffer
402 * @lnum: LEB number of the LEB from which @buf was read
403 * @offs: offset from which @buf was read
405 * This function ensures that the corrupted node at @offs is the last thing
406 * written to a LEB. This function returns %1 if more data is not found and
407 * %0 if more data is found.
409 static int no_more_nodes(const struct ubifs_info
*c
, void *buf
, int len
,
412 struct ubifs_ch
*ch
= buf
;
413 int skip
, dlen
= le32_to_cpu(ch
->len
);
415 /* Check for empty space after the corrupt node's common header */
416 skip
= ALIGN(offs
+ UBIFS_CH_SZ
, c
->min_io_size
) - offs
;
417 if (is_empty(buf
+ skip
, len
- skip
))
420 * The area after the common header size is not empty, so the common
421 * header must be intact. Check it.
423 if (ubifs_check_node(c
, buf
, lnum
, offs
, 1, 0) != -EUCLEAN
) {
424 dbg_rcvry("unexpected bad common header at %d:%d", lnum
, offs
);
427 /* Now we know the corrupt node's length we can skip over it */
428 skip
= ALIGN(offs
+ dlen
, c
->min_io_size
) - offs
;
429 /* After which there should be empty space */
430 if (is_empty(buf
+ skip
, len
- skip
))
432 dbg_rcvry("unexpected data at %d:%d", lnum
, offs
+ skip
);
437 * fix_unclean_leb - fix an unclean LEB.
438 * @c: UBIFS file-system description object
439 * @sleb: scanned LEB information
440 * @start: offset where scan started
442 static int fix_unclean_leb(struct ubifs_info
*c
, struct ubifs_scan_leb
*sleb
,
445 int lnum
= sleb
->lnum
, endpt
= start
;
447 /* Get the end offset of the last node we are keeping */
448 if (!list_empty(&sleb
->nodes
)) {
449 struct ubifs_scan_node
*snod
;
451 snod
= list_entry(sleb
->nodes
.prev
,
452 struct ubifs_scan_node
, list
);
453 endpt
= snod
->offs
+ snod
->len
;
456 if ((c
->vfs_sb
->s_flags
& MS_RDONLY
) && !c
->remounting_rw
) {
457 /* Add to recovery list */
458 struct ubifs_unclean_leb
*ucleb
;
460 dbg_rcvry("need to fix LEB %d start %d endpt %d",
461 lnum
, start
, sleb
->endpt
);
462 ucleb
= kzalloc(sizeof(struct ubifs_unclean_leb
), GFP_NOFS
);
466 ucleb
->endpt
= endpt
;
467 list_add_tail(&ucleb
->list
, &c
->unclean_leb_list
);
469 /* Write the fixed LEB back to flash */
472 dbg_rcvry("fixing LEB %d start %d endpt %d",
473 lnum
, start
, sleb
->endpt
);
475 err
= ubifs_leb_unmap(c
, lnum
);
479 int len
= ALIGN(endpt
, c
->min_io_size
);
482 err
= ubi_read(c
->ubi
, lnum
, sleb
->buf
, 0,
487 /* Pad to min_io_size */
489 int pad_len
= len
- ALIGN(endpt
, 8);
492 void *buf
= sleb
->buf
+ len
- pad_len
;
494 ubifs_pad(c
, buf
, pad_len
);
497 err
= ubi_leb_change(c
->ubi
, lnum
, sleb
->buf
, len
,
507 * drop_incomplete_group - drop nodes from an incomplete group.
508 * @sleb: scanned LEB information
509 * @offs: offset of dropped nodes is returned here
511 * This function returns %1 if nodes are dropped and %0 otherwise.
513 static int drop_incomplete_group(struct ubifs_scan_leb
*sleb
, int *offs
)
517 while (!list_empty(&sleb
->nodes
)) {
518 struct ubifs_scan_node
*snod
;
521 snod
= list_entry(sleb
->nodes
.prev
, struct ubifs_scan_node
,
524 if (ch
->group_type
!= UBIFS_IN_NODE_GROUP
)
526 dbg_rcvry("dropping node at %d:%d", sleb
->lnum
, snod
->offs
);
528 list_del(&snod
->list
);
530 sleb
->nodes_cnt
-= 1;
537 * ubifs_recover_leb - scan and recover a LEB.
538 * @c: UBIFS file-system description object
541 * @sbuf: LEB-sized buffer to use
542 * @grouped: nodes may be grouped for recovery
544 * This function does a scan of a LEB, but caters for errors that might have
545 * been caused by the unclean unmount from which we are attempting to recover.
547 * This function returns %0 on success and a negative error code on failure.
549 struct ubifs_scan_leb
*ubifs_recover_leb(struct ubifs_info
*c
, int lnum
,
550 int offs
, void *sbuf
, int grouped
)
552 int err
, len
= c
->leb_size
- offs
, need_clean
= 0, quiet
= 1;
553 int empty_chkd
= 0, start
= offs
;
554 struct ubifs_scan_leb
*sleb
;
555 void *buf
= sbuf
+ offs
;
557 dbg_rcvry("%d:%d", lnum
, offs
);
559 sleb
= ubifs_start_scan(c
, lnum
, offs
, sbuf
);
569 dbg_scan("look at LEB %d:%d (%d bytes left)",
575 * Scan quietly until there is an error from which we cannot
578 ret
= ubifs_scan_a_node(c
, buf
, len
, lnum
, offs
, quiet
);
580 if (ret
== SCANNED_A_NODE
) {
581 /* A valid node, and not a padding node */
582 struct ubifs_ch
*ch
= buf
;
585 err
= ubifs_add_snod(c
, sleb
, buf
, offs
);
588 node_len
= ALIGN(le32_to_cpu(ch
->len
), 8);
596 /* Padding bytes or a valid padding node */
603 if (ret
== SCANNED_EMPTY_SPACE
) {
604 if (!is_empty(buf
, len
)) {
605 if (!is_last_write(c
, buf
, offs
))
607 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
614 if (ret
== SCANNED_GARBAGE
|| ret
== SCANNED_A_BAD_PAD_NODE
)
615 if (is_last_write(c
, buf
, offs
)) {
616 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
622 if (ret
== SCANNED_A_CORRUPT_NODE
)
623 if (no_more_nodes(c
, buf
, len
, lnum
, offs
)) {
624 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
631 /* Redo the last scan but noisily */
637 case SCANNED_GARBAGE
:
640 case SCANNED_A_CORRUPT_NODE
:
641 case SCANNED_A_BAD_PAD_NODE
:
650 if (!empty_chkd
&& !is_empty(buf
, len
)) {
651 if (is_last_write(c
, buf
, offs
)) {
652 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
655 ubifs_err("corrupt empty space at LEB %d:%d",
661 /* Drop nodes from incomplete group */
662 if (grouped
&& drop_incomplete_group(sleb
, &offs
)) {
664 len
= c
->leb_size
- offs
;
665 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
669 if (offs
% c
->min_io_size
) {
670 clean_buf(c
, &buf
, lnum
, &offs
, &len
);
674 ubifs_end_scan(c
, sleb
, lnum
, offs
);
677 err
= fix_unclean_leb(c
, sleb
, start
);
685 ubifs_scanned_corruption(c
, lnum
, offs
, buf
);
688 ubifs_err("LEB %d scanning failed", lnum
);
689 ubifs_scan_destroy(sleb
);
694 * get_cs_sqnum - get commit start sequence number.
695 * @c: UBIFS file-system description object
696 * @lnum: LEB number of commit start node
697 * @offs: offset of commit start node
698 * @cs_sqnum: commit start sequence number is returned here
700 * This function returns %0 on success and a negative error code on failure.
702 static int get_cs_sqnum(struct ubifs_info
*c
, int lnum
, int offs
,
703 unsigned long long *cs_sqnum
)
705 struct ubifs_cs_node
*cs_node
= NULL
;
708 dbg_rcvry("at %d:%d", lnum
, offs
);
709 cs_node
= kmalloc(UBIFS_CS_NODE_SZ
, GFP_KERNEL
);
712 if (c
->leb_size
- offs
< UBIFS_CS_NODE_SZ
)
714 err
= ubi_read(c
->ubi
, lnum
, (void *)cs_node
, offs
, UBIFS_CS_NODE_SZ
);
715 if (err
&& err
!= -EBADMSG
)
717 ret
= ubifs_scan_a_node(c
, cs_node
, UBIFS_CS_NODE_SZ
, lnum
, offs
, 0);
718 if (ret
!= SCANNED_A_NODE
) {
719 dbg_err("Not a valid node");
722 if (cs_node
->ch
.node_type
!= UBIFS_CS_NODE
) {
723 dbg_err("Node a CS node, type is %d", cs_node
->ch
.node_type
);
726 if (le64_to_cpu(cs_node
->cmt_no
) != c
->cmt_no
) {
727 dbg_err("CS node cmt_no %llu != current cmt_no %llu",
728 (unsigned long long)le64_to_cpu(cs_node
->cmt_no
),
732 *cs_sqnum
= le64_to_cpu(cs_node
->ch
.sqnum
);
733 dbg_rcvry("commit start sqnum %llu", *cs_sqnum
);
740 ubifs_err("failed to get CS sqnum");
746 * ubifs_recover_log_leb - scan and recover a log LEB.
747 * @c: UBIFS file-system description object
750 * @sbuf: LEB-sized buffer to use
752 * This function does a scan of a LEB, but caters for errors that might have
753 * been caused by the unclean unmount from which we are attempting to recover.
755 * This function returns %0 on success and a negative error code on failure.
757 struct ubifs_scan_leb
*ubifs_recover_log_leb(struct ubifs_info
*c
, int lnum
,
758 int offs
, void *sbuf
)
760 struct ubifs_scan_leb
*sleb
;
763 dbg_rcvry("LEB %d", lnum
);
764 next_lnum
= lnum
+ 1;
765 if (next_lnum
>= UBIFS_LOG_LNUM
+ c
->log_lebs
)
766 next_lnum
= UBIFS_LOG_LNUM
;
767 if (next_lnum
!= c
->ltail_lnum
) {
769 * We can only recover at the end of the log, so check that the
770 * next log LEB is empty or out of date.
772 sleb
= ubifs_scan(c
, next_lnum
, 0, sbuf
);
775 if (sleb
->nodes_cnt
) {
776 struct ubifs_scan_node
*snod
;
777 unsigned long long cs_sqnum
= c
->cs_sqnum
;
779 snod
= list_entry(sleb
->nodes
.next
,
780 struct ubifs_scan_node
, list
);
784 err
= get_cs_sqnum(c
, lnum
, offs
, &cs_sqnum
);
786 ubifs_scan_destroy(sleb
);
790 if (snod
->sqnum
> cs_sqnum
) {
791 ubifs_err("unrecoverable log corruption "
793 ubifs_scan_destroy(sleb
);
794 return ERR_PTR(-EUCLEAN
);
797 ubifs_scan_destroy(sleb
);
799 return ubifs_recover_leb(c
, lnum
, offs
, sbuf
, 0);
803 * recover_head - recover a head.
804 * @c: UBIFS file-system description object
805 * @lnum: LEB number of head to recover
806 * @offs: offset of head to recover
807 * @sbuf: LEB-sized buffer to use
809 * This function ensures that there is no data on the flash at a head location.
811 * This function returns %0 on success and a negative error code on failure.
813 static int recover_head(const struct ubifs_info
*c
, int lnum
, int offs
,
816 int len
, err
, need_clean
= 0;
818 if (c
->min_io_size
> 1)
819 len
= c
->min_io_size
;
822 if (offs
+ len
> c
->leb_size
)
823 len
= c
->leb_size
- offs
;
828 /* Read at the head location and check it is empty flash */
829 err
= ubi_read(c
->ubi
, lnum
, sbuf
, offs
, len
);
843 dbg_rcvry("cleaning head at %d:%d", lnum
, offs
);
845 return ubifs_leb_unmap(c
, lnum
);
846 err
= ubi_read(c
->ubi
, lnum
, sbuf
, 0, offs
);
849 return ubi_leb_change(c
->ubi
, lnum
, sbuf
, offs
, UBI_UNKNOWN
);
856 * ubifs_recover_inl_heads - recover index and LPT heads.
857 * @c: UBIFS file-system description object
858 * @sbuf: LEB-sized buffer to use
860 * This function ensures that there is no data on the flash at the index and
861 * LPT head locations.
863 * This deals with the recovery of a half-completed journal commit. UBIFS is
864 * careful never to overwrite the last version of the index or the LPT. Because
865 * the index and LPT are wandering trees, data from a half-completed commit will
866 * not be referenced anywhere in UBIFS. The data will be either in LEBs that are
867 * assumed to be empty and will be unmapped anyway before use, or in the index
870 * This function returns %0 on success and a negative error code on failure.
872 int ubifs_recover_inl_heads(const struct ubifs_info
*c
, void *sbuf
)
876 ubifs_assert(!(c
->vfs_sb
->s_flags
& MS_RDONLY
) || c
->remounting_rw
);
878 dbg_rcvry("checking index head at %d:%d", c
->ihead_lnum
, c
->ihead_offs
);
879 err
= recover_head(c
, c
->ihead_lnum
, c
->ihead_offs
, sbuf
);
883 dbg_rcvry("checking LPT head at %d:%d", c
->nhead_lnum
, c
->nhead_offs
);
884 err
= recover_head(c
, c
->nhead_lnum
, c
->nhead_offs
, sbuf
);
892 * clean_an_unclean_leb - read and write a LEB to remove corruption.
893 * @c: UBIFS file-system description object
894 * @ucleb: unclean LEB information
895 * @sbuf: LEB-sized buffer to use
897 * This function reads a LEB up to a point pre-determined by the mount recovery,
898 * checks the nodes, and writes the result back to the flash, thereby cleaning
899 * off any following corruption, or non-fatal ECC errors.
901 * This function returns %0 on success and a negative error code on failure.
903 static int clean_an_unclean_leb(const struct ubifs_info
*c
,
904 struct ubifs_unclean_leb
*ucleb
, void *sbuf
)
906 int err
, lnum
= ucleb
->lnum
, offs
= 0, len
= ucleb
->endpt
, quiet
= 1;
909 dbg_rcvry("LEB %d len %d", lnum
, len
);
912 /* Nothing to read, just unmap it */
913 err
= ubifs_leb_unmap(c
, lnum
);
919 err
= ubi_read(c
->ubi
, lnum
, buf
, offs
, len
);
920 if (err
&& err
!= -EBADMSG
)
928 /* Scan quietly until there is an error */
929 ret
= ubifs_scan_a_node(c
, buf
, len
, lnum
, offs
, quiet
);
931 if (ret
== SCANNED_A_NODE
) {
932 /* A valid node, and not a padding node */
933 struct ubifs_ch
*ch
= buf
;
936 node_len
= ALIGN(le32_to_cpu(ch
->len
), 8);
944 /* Padding bytes or a valid padding node */
951 if (ret
== SCANNED_EMPTY_SPACE
) {
952 ubifs_err("unexpected empty space at %d:%d",
958 /* Redo the last scan but noisily */
963 ubifs_scanned_corruption(c
, lnum
, offs
, buf
);
967 /* Pad to min_io_size */
968 len
= ALIGN(ucleb
->endpt
, c
->min_io_size
);
969 if (len
> ucleb
->endpt
) {
970 int pad_len
= len
- ALIGN(ucleb
->endpt
, 8);
973 buf
= c
->sbuf
+ len
- pad_len
;
974 ubifs_pad(c
, buf
, pad_len
);
978 /* Write back the LEB atomically */
979 err
= ubi_leb_change(c
->ubi
, lnum
, sbuf
, len
, UBI_UNKNOWN
);
983 dbg_rcvry("cleaned LEB %d", lnum
);
989 * ubifs_clean_lebs - clean LEBs recovered during read-only mount.
990 * @c: UBIFS file-system description object
991 * @sbuf: LEB-sized buffer to use
993 * This function cleans a LEB identified during recovery that needs to be
994 * written but was not because UBIFS was mounted read-only. This happens when
995 * remounting to read-write mode.
997 * This function returns %0 on success and a negative error code on failure.
999 int ubifs_clean_lebs(const struct ubifs_info
*c
, void *sbuf
)
1001 dbg_rcvry("recovery");
1002 while (!list_empty(&c
->unclean_leb_list
)) {
1003 struct ubifs_unclean_leb
*ucleb
;
1006 ucleb
= list_entry(c
->unclean_leb_list
.next
,
1007 struct ubifs_unclean_leb
, list
);
1008 err
= clean_an_unclean_leb(c
, ucleb
, sbuf
);
1011 list_del(&ucleb
->list
);
1018 * ubifs_rcvry_gc_commit - recover the GC LEB number and run the commit.
1019 * @c: UBIFS file-system description object
1021 * Out-of-place garbage collection requires always one empty LEB with which to
1022 * start garbage collection. The LEB number is recorded in c->gc_lnum and is
1023 * written to the master node on unmounting. In the case of an unclean unmount
1024 * the value of gc_lnum recorded in the master node is out of date and cannot
1025 * be used. Instead, recovery must allocate an empty LEB for this purpose.
1026 * However, there may not be enough empty space, in which case it must be
1027 * possible to GC the dirtiest LEB into the GC head LEB.
1029 * This function also runs the commit which causes the TNC updates from
1030 * size-recovery and orphans to be written to the flash. That is important to
1031 * ensure correct replay order for subsequent mounts.
1033 * This function returns %0 on success and a negative error code on failure.
1035 int ubifs_rcvry_gc_commit(struct ubifs_info
*c
)
1037 struct ubifs_wbuf
*wbuf
= &c
->jheads
[GCHD
].wbuf
;
1038 struct ubifs_lprops lp
;
1042 if (wbuf
->lnum
== -1) {
1043 dbg_rcvry("no GC head LEB");
1047 * See whether the used space in the dirtiest LEB fits in the GC head
1050 if (wbuf
->offs
== c
->leb_size
) {
1051 dbg_rcvry("no room in GC head LEB");
1054 err
= ubifs_find_dirty_leb(c
, &lp
, wbuf
->offs
, 2);
1057 dbg_err("could not find a dirty LEB");
1060 ubifs_assert(!(lp
.flags
& LPROPS_INDEX
));
1062 if (lp
.free
+ lp
.dirty
== c
->leb_size
) {
1063 /* An empty LEB was returned */
1064 if (lp
.free
!= c
->leb_size
) {
1065 err
= ubifs_change_one_lp(c
, lnum
, c
->leb_size
,
1070 err
= ubifs_leb_unmap(c
, lnum
);
1074 dbg_rcvry("allocated LEB %d for GC", lnum
);
1075 /* Run the commit */
1076 dbg_rcvry("committing");
1077 return ubifs_run_commit(c
);
1080 * There was no empty LEB so the used space in the dirtiest LEB must fit
1081 * in the GC head LEB.
1083 if (lp
.free
+ lp
.dirty
< wbuf
->offs
) {
1084 dbg_rcvry("LEB %d doesn't fit in GC head LEB %d:%d",
1085 lnum
, wbuf
->lnum
, wbuf
->offs
);
1086 err
= ubifs_return_leb(c
, lnum
);
1092 * We run the commit before garbage collection otherwise subsequent
1093 * mounts will see the GC and orphan deletion in a different order.
1095 dbg_rcvry("committing");
1096 err
= ubifs_run_commit(c
);
1100 * The data in the dirtiest LEB fits in the GC head LEB, so do the GC
1101 * - use locking to keep 'ubifs_assert()' happy.
1103 dbg_rcvry("GC'ing LEB %d", lnum
);
1104 mutex_lock_nested(&wbuf
->io_mutex
, wbuf
->jhead
);
1105 err
= ubifs_garbage_collect_leb(c
, &lp
);
1107 int err2
= ubifs_wbuf_sync_nolock(wbuf
);
1112 mutex_unlock(&wbuf
->io_mutex
);
1114 dbg_err("GC failed, error %d", err
);
1119 if (err
!= LEB_RETAINED
) {
1120 dbg_err("GC returned %d", err
);
1123 err
= ubifs_leb_unmap(c
, c
->gc_lnum
);
1126 dbg_rcvry("allocated LEB %d for GC", lnum
);
1131 * There is no GC head LEB or the free space in the GC head LEB is too
1132 * small. Allocate gc_lnum by calling 'ubifs_find_free_leb_for_idx()' so
1135 lnum
= ubifs_find_free_leb_for_idx(c
);
1137 dbg_err("could not find an empty LEB");
1140 /* And reset the index flag */
1141 err
= ubifs_change_one_lp(c
, lnum
, LPROPS_NC
, LPROPS_NC
, 0,
1146 dbg_rcvry("allocated LEB %d for GC", lnum
);
1147 /* Run the commit */
1148 dbg_rcvry("committing");
1149 return ubifs_run_commit(c
);
1153 * struct size_entry - inode size information for recovery.
1154 * @rb: link in the RB-tree of sizes
1155 * @inum: inode number
1156 * @i_size: size on inode
1157 * @d_size: maximum size based on data nodes
1158 * @exists: indicates whether the inode exists
1159 * @inode: inode if pinned in memory awaiting rw mode to fix it
1167 struct inode
*inode
;
1171 * add_ino - add an entry to the size tree.
1172 * @c: UBIFS file-system description object
1173 * @inum: inode number
1174 * @i_size: size on inode
1175 * @d_size: maximum size based on data nodes
1176 * @exists: indicates whether the inode exists
1178 static int add_ino(struct ubifs_info
*c
, ino_t inum
, loff_t i_size
,
1179 loff_t d_size
, int exists
)
1181 struct rb_node
**p
= &c
->size_tree
.rb_node
, *parent
= NULL
;
1182 struct size_entry
*e
;
1186 e
= rb_entry(parent
, struct size_entry
, rb
);
1190 p
= &(*p
)->rb_right
;
1193 e
= kzalloc(sizeof(struct size_entry
), GFP_KERNEL
);
1202 rb_link_node(&e
->rb
, parent
, p
);
1203 rb_insert_color(&e
->rb
, &c
->size_tree
);
1209 * find_ino - find an entry on the size tree.
1210 * @c: UBIFS file-system description object
1211 * @inum: inode number
1213 static struct size_entry
*find_ino(struct ubifs_info
*c
, ino_t inum
)
1215 struct rb_node
*p
= c
->size_tree
.rb_node
;
1216 struct size_entry
*e
;
1219 e
= rb_entry(p
, struct size_entry
, rb
);
1222 else if (inum
> e
->inum
)
1231 * remove_ino - remove an entry from the size tree.
1232 * @c: UBIFS file-system description object
1233 * @inum: inode number
1235 static void remove_ino(struct ubifs_info
*c
, ino_t inum
)
1237 struct size_entry
*e
= find_ino(c
, inum
);
1241 rb_erase(&e
->rb
, &c
->size_tree
);
1246 * ubifs_destroy_size_tree - free resources related to the size tree.
1247 * @c: UBIFS file-system description object
1249 void ubifs_destroy_size_tree(struct ubifs_info
*c
)
1251 struct rb_node
*this = c
->size_tree
.rb_node
;
1252 struct size_entry
*e
;
1255 if (this->rb_left
) {
1256 this = this->rb_left
;
1258 } else if (this->rb_right
) {
1259 this = this->rb_right
;
1262 e
= rb_entry(this, struct size_entry
, rb
);
1265 this = rb_parent(this);
1267 if (this->rb_left
== &e
->rb
)
1268 this->rb_left
= NULL
;
1270 this->rb_right
= NULL
;
1274 c
->size_tree
= RB_ROOT
;
1278 * ubifs_recover_size_accum - accumulate inode sizes for recovery.
1279 * @c: UBIFS file-system description object
1281 * @deletion: node is for a deletion
1282 * @new_size: inode size
1284 * This function has two purposes:
1285 * 1) to ensure there are no data nodes that fall outside the inode size
1286 * 2) to ensure there are no data nodes for inodes that do not exist
1287 * To accomplish those purposes, a rb-tree is constructed containing an entry
1288 * for each inode number in the journal that has not been deleted, and recording
1289 * the size from the inode node, the maximum size of any data node (also altered
1290 * by truncations) and a flag indicating a inode number for which no inode node
1291 * was present in the journal.
1293 * Note that there is still the possibility that there are data nodes that have
1294 * been committed that are beyond the inode size, however the only way to find
1295 * them would be to scan the entire index. Alternatively, some provision could
1296 * be made to record the size of inodes at the start of commit, which would seem
1297 * very cumbersome for a scenario that is quite unlikely and the only negative
1298 * consequence of which is wasted space.
1300 * This functions returns %0 on success and a negative error code on failure.
1302 int ubifs_recover_size_accum(struct ubifs_info
*c
, union ubifs_key
*key
,
1303 int deletion
, loff_t new_size
)
1305 ino_t inum
= key_inum(c
, key
);
1306 struct size_entry
*e
;
1309 switch (key_type(c
, key
)) {
1312 remove_ino(c
, inum
);
1314 e
= find_ino(c
, inum
);
1316 e
->i_size
= new_size
;
1319 err
= add_ino(c
, inum
, new_size
, 0, 1);
1325 case UBIFS_DATA_KEY
:
1326 e
= find_ino(c
, inum
);
1328 if (new_size
> e
->d_size
)
1329 e
->d_size
= new_size
;
1331 err
= add_ino(c
, inum
, 0, new_size
, 0);
1336 case UBIFS_TRUN_KEY
:
1337 e
= find_ino(c
, inum
);
1339 e
->d_size
= new_size
;
1346 * fix_size_in_place - fix inode size in place on flash.
1347 * @c: UBIFS file-system description object
1348 * @e: inode size information for recovery
1350 static int fix_size_in_place(struct ubifs_info
*c
, struct size_entry
*e
)
1352 struct ubifs_ino_node
*ino
= c
->sbuf
;
1354 union ubifs_key key
;
1355 int err
, lnum
, offs
, len
;
1359 /* Locate the inode node LEB number and offset */
1360 ino_key_init(c
, &key
, e
->inum
);
1361 err
= ubifs_tnc_locate(c
, &key
, ino
, &lnum
, &offs
);
1365 * If the size recorded on the inode node is greater than the size that
1366 * was calculated from nodes in the journal then don't change the inode.
1368 i_size
= le64_to_cpu(ino
->size
);
1369 if (i_size
>= e
->d_size
)
1372 err
= ubi_read(c
->ubi
, lnum
, c
->sbuf
, 0, c
->leb_size
);
1375 /* Change the size field and recalculate the CRC */
1376 ino
= c
->sbuf
+ offs
;
1377 ino
->size
= cpu_to_le64(e
->d_size
);
1378 len
= le32_to_cpu(ino
->ch
.len
);
1379 crc
= crc32(UBIFS_CRC32_INIT
, (void *)ino
+ 8, len
- 8);
1380 ino
->ch
.crc
= cpu_to_le32(crc
);
1381 /* Work out where data in the LEB ends and free space begins */
1383 len
= c
->leb_size
- 1;
1384 while (p
[len
] == 0xff)
1386 len
= ALIGN(len
+ 1, c
->min_io_size
);
1387 /* Atomically write the fixed LEB back again */
1388 err
= ubi_leb_change(c
->ubi
, lnum
, c
->sbuf
, len
, UBI_UNKNOWN
);
1391 dbg_rcvry("inode %lu at %d:%d size %lld -> %lld ",
1392 (unsigned long)e
->inum
, lnum
, offs
, i_size
, e
->d_size
);
1396 ubifs_warn("inode %lu failed to fix size %lld -> %lld error %d",
1397 (unsigned long)e
->inum
, e
->i_size
, e
->d_size
, err
);
1402 * ubifs_recover_size - recover inode size.
1403 * @c: UBIFS file-system description object
1405 * This function attempts to fix inode size discrepancies identified by the
1406 * 'ubifs_recover_size_accum()' function.
1408 * This functions returns %0 on success and a negative error code on failure.
1410 int ubifs_recover_size(struct ubifs_info
*c
)
1412 struct rb_node
*this = rb_first(&c
->size_tree
);
1415 struct size_entry
*e
;
1418 e
= rb_entry(this, struct size_entry
, rb
);
1420 union ubifs_key key
;
1422 ino_key_init(c
, &key
, e
->inum
);
1423 err
= ubifs_tnc_lookup(c
, &key
, c
->sbuf
);
1424 if (err
&& err
!= -ENOENT
)
1426 if (err
== -ENOENT
) {
1427 /* Remove data nodes that have no inode */
1428 dbg_rcvry("removing ino %lu",
1429 (unsigned long)e
->inum
);
1430 err
= ubifs_tnc_remove_ino(c
, e
->inum
);
1434 struct ubifs_ino_node
*ino
= c
->sbuf
;
1437 e
->i_size
= le64_to_cpu(ino
->size
);
1440 if (e
->exists
&& e
->i_size
< e
->d_size
) {
1441 if (!e
->inode
&& (c
->vfs_sb
->s_flags
& MS_RDONLY
)) {
1442 /* Fix the inode size and pin it in memory */
1443 struct inode
*inode
;
1445 inode
= ubifs_iget(c
->vfs_sb
, e
->inum
);
1447 return PTR_ERR(inode
);
1448 if (inode
->i_size
< e
->d_size
) {
1449 dbg_rcvry("ino %lu size %lld -> %lld",
1450 (unsigned long)e
->inum
,
1451 e
->d_size
, inode
->i_size
);
1452 inode
->i_size
= e
->d_size
;
1453 ubifs_inode(inode
)->ui_size
= e
->d_size
;
1455 this = rb_next(this);
1460 /* Fix the size in place */
1461 err
= fix_size_in_place(c
, e
);
1468 this = rb_next(this);
1469 rb_erase(&e
->rb
, &c
->size_tree
);