ubifs-utils/fsck.ubifs/load_fs.c \
ubifs-utils/fsck.ubifs/extract_files.c \
ubifs-utils/fsck.ubifs/rebuild_fs.c \
- ubifs-utils/fsck.ubifs/check_files.c
+ ubifs-utils/fsck.ubifs/check_files.c \
+ ubifs-utils/fsck.ubifs/check_space.c
fsck_ubifs_LDADD = libmtd.a libubi.a $(ZLIB_LIBS) $(LZO_LIBS) $(ZSTD_LIBS) $(UUID_LIBS) $(LIBSELINUX_LIBS) $(OPENSSL_LIBS) \
$(DUMP_STACK_LD) -lm -lpthread
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2024, Huawei Technologies Co, Ltd.
+ *
+ * Authors: Zhihao Cheng <chengzhihao1@huawei.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "linux_err.h"
+#include "bitops.h"
+#include "kmem.h"
+#include "ubifs.h"
+#include "defs.h"
+#include "debug.h"
+#include "key.h"
+#include "misc.h"
+#include "fsck.ubifs.h"
+
+/**
+ * get_free_leb - get a free LEB according to @FSCK(c)->used_lebs.
+ * @c: UBIFS file-system description object
+ *
+ * This function tries to find a free LEB, lnum is returned if found, otherwise
+ * %-ENOSPC is returned.
+ */
+int get_free_leb(struct ubifs_info *c)
+{
+ int lnum;
+
+ lnum = find_next_zero_bit(FSCK(c)->used_lebs, c->main_lebs, 0);
+ if (lnum >= c->main_lebs) {
+ ubifs_err(c, "No space left.");
+ return -ENOSPC;
+ }
+ set_bit(lnum, FSCK(c)->used_lebs);
+ lnum += c->main_first;
+
+ return lnum;
+}
+
+/**
+ * build_lpt - construct LPT and write it into flash.
+ * @c: UBIFS file-system description object
+ * @calculate_lp_cb: callback function to calculate the properties for given LEB
+ *
+ * This function builds LPT according to the calculated results by
+ * @calculate_lp_cb and writes LPT into flash. Returns zero in case of success,
+ * a negative error code in case of failure.
+ */
+int build_lpt(struct ubifs_info *c, calculate_lp_callback calculate_lp_cb)
+{
+ int i, err, lnum, free, dirty;
+ u8 hash_lpt[UBIFS_HASH_ARR_SZ];
+
+ memset(&c->lst, 0, sizeof(struct ubifs_lp_stats));
+ /* Set gc lnum. */
+ lnum = get_free_leb(c);
+ if (lnum < 0)
+ return lnum;
+ c->gc_lnum = lnum;
+
+ /* Update LPT. */
+ for (i = 0; i < c->main_lebs; i++) {
+ err = calculate_lp_cb(c, i, &free, &dirty);
+ if (err)
+ return err;
+
+ FSCK(c)->lpts[i].free = free;
+ FSCK(c)->lpts[i].dirty = dirty;
+ c->lst.total_free += free;
+ c->lst.total_dirty += dirty;
+
+ if (free == c->leb_size)
+ c->lst.empty_lebs++;
+
+ if (FSCK(c)->lpts[i].flags & LPROPS_INDEX) {
+ c->lst.idx_lebs += 1;
+ } else {
+ int spc;
+
+ spc = free + dirty;
+ if (spc < c->dead_wm)
+ c->lst.total_dead += spc;
+ else
+ c->lst.total_dark += ubifs_calc_dark(c, spc);
+ c->lst.total_used += c->leb_size - spc;
+ }
+ }
+
+ /* Write LPT. */
+ return ubifs_create_lpt(c, FSCK(c)->lpts, c->main_lebs, hash_lpt);
+}
enum { HAS_DATA_CORRUPTED = 1, HAS_TNC_CORRUPTED = 2 };
+typedef int (*calculate_lp_callback)(struct ubifs_info *c,
+ int index, int *free, int *dirty);
+
struct scanned_file;
/**
/**
* ubifs_rebuild_info - UBIFS rebuilding information.
- * @lpts: lprops table
* @write_buf: write buffer for LEB @head_lnum
* @head_lnum: current writing LEB number
* @head_offs: current writing position in LEB @head_lnum
* @need_update_lpt: whether to update lpt while writing index nodes
*/
struct ubifs_rebuild_info {
- struct ubifs_lprops *lpts;
void *write_buf;
int head_lnum;
int head_offs;
* @scanned_files: tree of all scanned files
* @used_lebs: a bitmap used for recording used lebs
* @disconnected_files: regular files without dentries
+ * @lpts: lprops table
* @try_rebuild: %true means that try to rebuild fs when fsck failed
* @rebuild: rebuilding-related information
*/
struct rb_root scanned_files;
unsigned long *used_lebs;
struct list_head disconnected_files;
+ struct ubifs_lprops *lpts;
bool try_rebuild;
struct ubifs_rebuild_info *rebuild;
};
int handle_dentry_tree(struct ubifs_info *c);
bool tnc_is_empty(struct ubifs_info *c);
+/* check_space.c */
+int get_free_leb(struct ubifs_info *c);
+int build_lpt(struct ubifs_info *c, calculate_lp_callback calculate_lp_cb);
+
#endif
log_err(c, errno, "can not allocate bitmap of used lebs");
goto free_rebuild;
}
- FSCK(c)->rebuild->lpts = kzalloc(sizeof(struct ubifs_lprops) * c->main_lebs,
- GFP_KERNEL);
- if (!FSCK(c)->rebuild->lpts) {
+ FSCK(c)->lpts = kzalloc(sizeof(struct ubifs_lprops) * c->main_lebs,
+ GFP_KERNEL);
+ if (!FSCK(c)->lpts) {
err = -ENOMEM;
log_err(c, errno, "can not allocate lpts");
goto free_used_lebs;
return 0;
free_lpts:
- kfree(FSCK(c)->rebuild->lpts);
+ kfree(FSCK(c)->lpts);
free_used_lebs:
kfree(FSCK(c)->used_lebs);
free_rebuild:
static void destroy_rebuild_info(struct ubifs_info *c)
{
vfree(FSCK(c)->rebuild->write_buf);
- kfree(FSCK(c)->rebuild->lpts);
+ kfree(FSCK(c)->lpts);
kfree(FSCK(c)->used_lebs);
kfree(FSCK(c)->rebuild);
vfree(c->sbuf);
int pos = sn->offs + ALIGN(sn->len, 8);
set_bit(index, FSCK(c)->used_lebs);
- FSCK(c)->rebuild->lpts[index].end = max_t(int,
- FSCK(c)->rebuild->lpts[index].end, pos);
+ FSCK(c)->lpts[index].end = max_t(int, FSCK(c)->lpts[index].end, pos);
if (deleted)
return;
- FSCK(c)->rebuild->lpts[index].used += ALIGN(sn->len, 8);
+ FSCK(c)->lpts[index].used += ALIGN(sn->len, 8);
}
/**
ino->flags = cpu_to_le32(UBIFS_COMPR_FL);
}
-/**
- * get_free_leb - get a free LEB according to @FSCK(c)->used_lebs.
- * @c: UBIFS file-system description object
- *
- * This function tries to find a free LEB, lnum is returned if found, otherwise
- * %-ENOSPC is returned.
- */
-static int get_free_leb(struct ubifs_info *c)
-{
- int lnum;
-
- lnum = find_next_zero_bit(FSCK(c)->used_lebs, c->main_lebs, 0);
- if (lnum >= c->main_lebs) {
- ubifs_err(c, "No space left.");
- return -ENOSPC;
- }
- set_bit(lnum, FSCK(c)->used_lebs);
- lnum += c->main_first;
-
- return lnum;
-}
-
/**
* flush_write_buf - flush write buffer.
* @c: UBIFS file-system description object
if (FSCK(c)->rebuild->need_update_lpt) {
int index = FSCK(c)->rebuild->head_lnum - c->main_first;
- FSCK(c)->rebuild->lpts[index].free = c->leb_size - len;
- FSCK(c)->rebuild->lpts[index].dirty = pad;
- FSCK(c)->rebuild->lpts[index].flags = LPROPS_INDEX;
+ FSCK(c)->lpts[index].free = c->leb_size - len;
+ FSCK(c)->lpts[index].dirty = pad;
+ FSCK(c)->lpts[index].flags = LPROPS_INDEX;
}
FSCK(c)->rebuild->head_lnum = -1;
lnum = i + c->main_first;
dbg_fsck("re-write LEB %d, in %s", lnum, c->dev_name);
- end = FSCK(c)->rebuild->lpts[i].end;
+ end = FSCK(c)->lpts[i].end;
len = ALIGN(end, c->min_io_size);
err = ubifs_leb_read(c, lnum, c->sbuf, 0, len, 0);
return err;
}
-/**
- * build_lpt - construct LPT and write it into flash.
- * @c: UBIFS file-system description object
- *
- * This function builds LPT according to @FSCK(c)->rebuild->lpts and writes
- * LPT into flash.
- */
-static int build_lpt(struct ubifs_info *c)
+static int calculate_lp(struct ubifs_info *c, int index, int *free, int *dirty)
{
- int i, len, free, dirty, lnum;
- u8 hash_lpt[UBIFS_HASH_ARR_SZ];
-
- memset(&c->lst, 0, sizeof(struct ubifs_lp_stats));
- /* Set gc lnum. */
- lnum = get_free_leb(c);
- if (lnum < 0)
- return lnum;
- c->gc_lnum = lnum;
-
- /* Update LPT. */
- for (i = 0; i < c->main_lebs; i++) {
- if (!test_bit(i, FSCK(c)->used_lebs) ||
- c->gc_lnum == i + c->main_first) {
- free = c->leb_size;
- dirty = 0;
- } else if (FSCK(c)->rebuild->lpts[i].flags & LPROPS_INDEX) {
- free = FSCK(c)->rebuild->lpts[i].free;
- dirty = FSCK(c)->rebuild->lpts[i].dirty;
- } else {
- len = ALIGN(FSCK(c)->rebuild->lpts[i].end, c->min_io_size);
- free = c->leb_size - len;
- dirty = len - FSCK(c)->rebuild->lpts[i].used;
-
- if (dirty == c->leb_size) {
- free = c->leb_size;
- dirty = 0;
- }
- }
-
- FSCK(c)->rebuild->lpts[i].free = free;
- FSCK(c)->rebuild->lpts[i].dirty = dirty;
- c->lst.total_free += free;
- c->lst.total_dirty += dirty;
-
- if (free == c->leb_size)
- c->lst.empty_lebs++;
-
- if (!(FSCK(c)->rebuild->lpts[i].flags & LPROPS_INDEX)) {
- int spc;
-
- spc = free + dirty;
- if (spc < c->dead_wm)
- c->lst.total_dead += spc;
- else
- c->lst.total_dark += ubifs_calc_dark(c, spc);
- c->lst.total_used += c->leb_size - spc;
- } else {
- c->lst.idx_lebs += 1;
+ if (!test_bit(index, FSCK(c)->used_lebs) ||
+ c->gc_lnum == index + c->main_first) {
+ *free = c->leb_size;
+ *dirty = 0;
+ } else if (FSCK(c)->lpts[index].flags & LPROPS_INDEX) {
+ *free = FSCK(c)->lpts[index].free;
+ *dirty = FSCK(c)->lpts[index].dirty;
+ } else {
+ int len = ALIGN(FSCK(c)->lpts[index].end, c->min_io_size);
+
+ *free = c->leb_size - len;
+ *dirty = len - FSCK(c)->lpts[index].used;
+
+ if (*dirty == c->leb_size) {
+ *free = c->leb_size;
+ *dirty = 0;
}
}
- /* Write LPT. */
- return ubifs_create_lpt(c, FSCK(c)->rebuild->lpts, c->main_lebs, hash_lpt);
+ return 0;
}
/**
/* Step 10. Build LPT. */
log_out(c, "Build LPT");
- err = build_lpt(c);
+ err = build_lpt(c, calculate_lp);
if (err) {
exit_code |= FSCK_ERROR;
goto out;
}
/**
- * calc_nnode_num - calculate nnode number.
+ * ubifs_calc_nnode_num - calculate nnode number.
* @row: the row in the tree (root is zero)
* @col: the column in the row (leftmost is zero)
*
* This function calculates and returns the nnode number for the nnode at @row
* and @col.
*/
-static int calc_nnode_num(int row, int col)
+int ubifs_calc_nnode_num(int row, int col)
{
int num, bits;
nnode->nbranch[j].offs = 0;
}
}
- nnode->num = calc_nnode_num(row, i);
+ nnode->num = ubifs_calc_nnode_num(row, i);
ubifs_pack_nnode(c, p, nnode);
p += c->nnode_sz;
len += c->nnode_sz;
}
/**
- * next_pnode_to_dirty - find next pnode to dirty.
+ * ubifs_find_next_pnode - find next pnode.
* @c: UBIFS file-system description object
* @pnode: pnode
*
- * This function returns the next pnode to dirty or %NULL if there are no more
- * pnodes. Note that pnodes that have never been written (lnum == 0) are
- * skipped.
+ * This function returns the next pnode or %NULL if there are no more pnodes.
+ * Note that pnodes that have never been written (lnum == 0) are skipped.
*/
-static struct ubifs_pnode *next_pnode_to_dirty(struct ubifs_info *c,
- struct ubifs_pnode *pnode)
+struct ubifs_pnode *ubifs_find_next_pnode(struct ubifs_info *c,
+ struct ubifs_pnode *pnode)
{
struct ubifs_nnode *nnode;
int iip;
}
/**
- * do_make_pnode_dirty - mark a pnode dirty.
+ * ubifs_make_nnode_dirty - mark a nnode dirty.
+ * @c: UBIFS file-system description object
+ * @nnode: nnode to mark dirty
+ */
+void ubifs_make_nnode_dirty(struct ubifs_info *c, struct ubifs_nnode *nnode)
+{
+ while (nnode) {
+ if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
+ c->dirty_nn_cnt += 1;
+ ubifs_add_nnode_dirt(c, nnode);
+ nnode = nnode->parent;
+ } else
+ break;
+ }
+}
+
+/**
+ * ubifs_make_pnode_dirty - mark a pnode dirty.
* @c: UBIFS file-system description object
* @pnode: pnode to mark dirty
*/
-static void do_make_pnode_dirty(struct ubifs_info *c, struct ubifs_pnode *pnode)
+void ubifs_make_pnode_dirty(struct ubifs_info *c, struct ubifs_pnode *pnode)
{
/* Assumes cnext list is empty i.e. not called during commit */
if (!test_and_set_bit(DIRTY_CNODE, &pnode->flags)) {
- struct ubifs_nnode *nnode;
-
c->dirty_pn_cnt += 1;
add_pnode_dirt(c, pnode);
/* Mark parent and ancestors dirty too */
- nnode = pnode->parent;
- while (nnode) {
- if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
- c->dirty_nn_cnt += 1;
- ubifs_add_nnode_dirt(c, nnode);
- nnode = nnode->parent;
- } else
- break;
- }
+ ubifs_make_nnode_dirty(c, pnode->parent);
}
}
return PTR_ERR(pnode);
while (pnode) {
- do_make_pnode_dirty(c, pnode);
- pnode = next_pnode_to_dirty(c, pnode);
+ ubifs_make_pnode_dirty(c, pnode);
+ pnode = ubifs_find_next_pnode(c, pnode);
if (IS_ERR(pnode))
return PTR_ERR(pnode);
}
} else if (c->lpt_lnum != lnum || c->lpt_offs != offs)
return 0; /* nnode is obsolete */
/* Assumes cnext list is empty i.e. not called during commit */
- if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
- c->dirty_nn_cnt += 1;
- ubifs_add_nnode_dirt(c, nnode);
- /* Mark parent and ancestors dirty too */
- nnode = nnode->parent;
- while (nnode) {
- if (!test_and_set_bit(DIRTY_CNODE, &nnode->flags)) {
- c->dirty_nn_cnt += 1;
- ubifs_add_nnode_dirt(c, nnode);
- nnode = nnode->parent;
- } else
- break;
- }
- }
+ ubifs_make_nnode_dirty(c, nnode);
return 0;
}
branch = &pnode->parent->nbranch[pnode->iip];
if (branch->lnum != lnum || branch->offs != offs)
return 0;
- do_make_pnode_dirty(c, pnode);
+ ubifs_make_pnode_dirty(c, pnode);
return 0;
}
return nnode;
}
+/**
+ * ubifs_free_lpt_nodes - free pnodes/nnodes in LPT.
+ * @c: UBIFS file-system description object
+ */
+void ubifs_free_lpt_nodes(struct ubifs_info *c)
+{
+ int i, hght;
+ struct ubifs_nnode *nnode;
+
+ nnode = first_nnode(c, &hght);
+ while (nnode) {
+ for (i = 0; i < UBIFS_LPT_FANOUT; i++)
+ kfree(nnode->nbranch[i].nnode);
+ nnode = next_nnode(c, nnode, &hght);
+ }
+
+ kfree(c->nroot);
+ c->nroot = NULL;
+}
+
/**
* ubifs_lpt_free - free resources owned by the LPT.
* @c: UBIFS file-system description object
*/
void ubifs_lpt_free(struct ubifs_info *c, int wr_only)
{
- struct ubifs_nnode *nnode;
- int i, hght;
+ int i;
/* Free write-only things first */
/* Now free the rest */
- nnode = first_nnode(c, &hght);
- while (nnode) {
- for (i = 0; i < UBIFS_LPT_FANOUT; i++)
- kfree(nnode->nbranch[i].nnode);
- nnode = next_nnode(c, nnode, &hght);
- }
+ ubifs_free_lpt_nodes(c);
for (i = 0; i < LPROPS_HEAP_CNT; i++)
kfree(c->lpt_heap[i].arr);
kfree(c->dirty_idx.arr);
- kfree(c->nroot);
vfree(c->ltab);
+ c->ltab = NULL;
kfree(c->lpt_nod_buf);
}
/**
* free_buds - free per-bud objects.
* @c: UBIFS file-system description object
+ * @delete_from_list: whether to delete the bud from list
*/
-static void free_buds(struct ubifs_info *c)
+void free_buds(struct ubifs_info *c, bool delete_from_list)
{
struct ubifs_bud *bud, *n;
rbtree_postorder_for_each_entry_safe(bud, n, &c->buds, rb) {
+ if (delete_from_list)
+ list_del(&bud->list);
kfree(bud->log_hash);
kfree(bud);
}
+
+ c->buds = RB_ROOT;
}
/**
ubifs_destroy_idx_gc(c);
ubifs_destroy_size_tree(c);
ubifs_tnc_close(c);
- free_buds(c);
+ free_buds(c, false);
}
void ubifs_add_lpt_dirt(struct ubifs_info *c, int lnum, int dirty);
void ubifs_add_nnode_dirt(struct ubifs_info *c, struct ubifs_nnode *nnode);
uint32_t ubifs_unpack_bits(const struct ubifs_info *c, uint8_t **addr, int *pos, int nrbits);
+int ubifs_calc_nnode_num(int row, int col);
struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght);
/* Needed only in debugging code in lpt_commit.c */
int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
int ubifs_lpt_calc_hash(struct ubifs_info *c, u8 *hash);
/* lpt_commit.c */
+struct ubifs_pnode *ubifs_find_next_pnode(struct ubifs_info *c,
+ struct ubifs_pnode *pnode);
+void ubifs_make_nnode_dirty(struct ubifs_info *c, struct ubifs_nnode *nnode);
+void ubifs_make_pnode_dirty(struct ubifs_info *c, struct ubifs_pnode *pnode);
int ubifs_lpt_start_commit(struct ubifs_info *c);
int ubifs_lpt_end_commit(struct ubifs_info *c);
int ubifs_lpt_post_commit(struct ubifs_info *c);
+void ubifs_free_lpt_nodes(struct ubifs_info *c);
void ubifs_lpt_free(struct ubifs_info *c, int wr_only);
/* lprops.c */
int alloc_wbufs(struct ubifs_info *c);
void free_wbufs(struct ubifs_info *c);
void free_orphans(struct ubifs_info *c);
+void free_buds(struct ubifs_info *c, bool delete_from_list);
void destroy_journal(struct ubifs_info *c);
/* recovery.c */
projects / mtd-utils.git / commitdiff