f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
/**
|
|
|
|
|
* fsck.h
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2013 Samsung Electronics Co., Ltd.
|
|
|
|
|
* http://www.samsung.com/
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _FSCK_H_
|
|
|
|
|
#define _FSCK_H_
|
|
|
|
|
|
|
|
|
|
#include "f2fs.h"
|
|
|
|
|
|
2017-10-30 23:21:09 +00:00
|
|
|
struct quota_ctx;
|
|
|
|
|
|
2016-03-16 03:07:07 +00:00
|
|
|
#define FSCK_UNMATCHED_EXTENT 0x00000001
|
|
|
|
|
|
2016-03-14 06:16:53 +00:00
|
|
|
enum {
|
|
|
|
|
PREEN_MODE_0,
|
|
|
|
|
PREEN_MODE_1,
|
|
|
|
|
PREEN_MODE_MAX
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-21 05:52:52 +00:00
|
|
|
enum {
|
|
|
|
|
NOERROR,
|
|
|
|
|
EWRONG_OPT,
|
|
|
|
|
ENEED_ARG,
|
|
|
|
|
EUNKNOWN_OPT,
|
|
|
|
|
EUNKNOWN_ARG,
|
|
|
|
|
};
|
|
|
|
|
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
/* fsck.c */
|
|
|
|
|
struct orphan_info {
|
|
|
|
|
u32 nr_inodes;
|
|
|
|
|
u32 *ino_list;
|
|
|
|
|
};
|
|
|
|
|
|
2016-03-16 03:07:07 +00:00
|
|
|
struct extent_info {
|
|
|
|
|
u32 fofs; /* start offset in a file */
|
|
|
|
|
u32 blk; /* start block address of the extent */
|
|
|
|
|
u32 len; /* length of the extent */
|
|
|
|
|
};
|
|
|
|
|
|
2015-03-30 19:57:10 +00:00
|
|
|
struct child_info {
|
2016-03-16 03:07:07 +00:00
|
|
|
u32 state;
|
2015-03-30 19:57:10 +00:00
|
|
|
u32 links;
|
|
|
|
|
u32 files;
|
2016-03-16 03:05:14 +00:00
|
|
|
u32 pgofs;
|
2015-03-30 20:09:16 +00:00
|
|
|
u8 dots;
|
2016-03-16 03:05:14 +00:00
|
|
|
u8 dir_level;
|
2016-02-26 06:42:13 +00:00
|
|
|
u32 p_ino; /*parent ino*/
|
|
|
|
|
u32 pp_ino; /*parent parent ino*/
|
2016-03-16 03:07:07 +00:00
|
|
|
struct extent_info ei;
|
|
|
|
|
u32 last_blk;
|
2015-12-08 22:53:21 +00:00
|
|
|
};
|
|
|
|
|
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
struct f2fs_fsck {
|
|
|
|
|
struct f2fs_sb_info sbi;
|
|
|
|
|
|
|
|
|
|
struct orphan_info orphani;
|
|
|
|
|
struct chk_result {
|
|
|
|
|
u64 valid_blk_cnt;
|
|
|
|
|
u32 valid_nat_entry_cnt;
|
|
|
|
|
u32 valid_node_cnt;
|
|
|
|
|
u32 valid_inode_cnt;
|
|
|
|
|
u32 multi_hard_link_files;
|
|
|
|
|
u64 sit_valid_blocks;
|
|
|
|
|
u32 sit_free_segs;
|
|
|
|
|
} chk;
|
|
|
|
|
|
|
|
|
|
struct hard_link_node *hard_link_list_head;
|
|
|
|
|
|
|
|
|
|
char *main_seg_usage;
|
|
|
|
|
char *main_area_bitmap;
|
|
|
|
|
char *nat_area_bitmap;
|
|
|
|
|
char *sit_area_bitmap;
|
|
|
|
|
|
|
|
|
|
u64 main_area_bitmap_sz;
|
|
|
|
|
u32 nat_area_bitmap_sz;
|
|
|
|
|
u32 sit_area_bitmap_sz;
|
|
|
|
|
|
|
|
|
|
u64 nr_main_blks;
|
|
|
|
|
u32 nr_nat_entries;
|
|
|
|
|
|
|
|
|
|
u32 dentry_depth;
|
2016-03-14 06:16:55 +00:00
|
|
|
struct f2fs_nat_entry *entries;
|
2016-03-14 06:16:54 +00:00
|
|
|
u32 nat_valid_inode_cnt;
|
2017-10-30 23:21:09 +00:00
|
|
|
|
|
|
|
|
struct quota_ctx *qctx;
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define BLOCK_SZ 4096
|
|
|
|
|
struct block {
|
|
|
|
|
unsigned char buf[BLOCK_SZ];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum NODE_TYPE {
|
|
|
|
|
TYPE_INODE = 37,
|
|
|
|
|
TYPE_DIRECT_NODE = 43,
|
|
|
|
|
TYPE_INDIRECT_NODE = 53,
|
2014-08-28 00:06:17 +00:00
|
|
|
TYPE_DOUBLE_INDIRECT_NODE = 67,
|
|
|
|
|
TYPE_XATTR = 77
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct hard_link_node {
|
|
|
|
|
u32 nid;
|
|
|
|
|
u32 links;
|
2015-03-26 01:26:44 +00:00
|
|
|
u32 actual_links;
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
struct hard_link_node *next;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum seg_type {
|
|
|
|
|
SEG_TYPE_DATA,
|
|
|
|
|
SEG_TYPE_CUR_DATA,
|
|
|
|
|
SEG_TYPE_NODE,
|
|
|
|
|
SEG_TYPE_CUR_NODE,
|
2013-07-18 02:20:05 +00:00
|
|
|
SEG_TYPE_MAX,
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
};
|
|
|
|
|
|
2015-12-10 00:18:44 +00:00
|
|
|
struct selabel_handle;
|
|
|
|
|
|
2016-11-19 13:24:40 +00:00
|
|
|
extern int fsck_chk_orphan_node(struct f2fs_sb_info *);
|
2017-10-30 23:21:09 +00:00
|
|
|
extern int fsck_chk_quota_node(struct f2fs_sb_info *);
|
|
|
|
|
extern int fsck_chk_quota_files(struct f2fs_sb_info *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern int fsck_chk_node_blk(struct f2fs_sb_info *, struct f2fs_inode *, u32,
|
2017-06-05 20:44:50 +00:00
|
|
|
enum FILE_TYPE, enum NODE_TYPE, u32 *,
|
2016-03-16 03:07:07 +00:00
|
|
|
struct child_info *);
|
2014-08-28 00:06:17 +00:00
|
|
|
extern void fsck_chk_inode_blk(struct f2fs_sb_info *, u32, enum FILE_TYPE,
|
2014-08-27 23:16:16 +00:00
|
|
|
struct f2fs_node *, u32 *, struct node_info *);
|
|
|
|
|
extern int fsck_chk_dnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
|
2015-03-30 19:57:10 +00:00
|
|
|
u32, enum FILE_TYPE, struct f2fs_node *, u32 *,
|
2016-03-16 03:07:07 +00:00
|
|
|
struct child_info *, struct node_info *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern int fsck_chk_idnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
|
2016-03-16 03:07:07 +00:00
|
|
|
enum FILE_TYPE, struct f2fs_node *, u32 *, struct child_info *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern int fsck_chk_didnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
|
2016-03-16 03:07:07 +00:00
|
|
|
enum FILE_TYPE, struct f2fs_node *, u32 *, struct child_info *);
|
2015-03-30 19:57:10 +00:00
|
|
|
extern int fsck_chk_data_blk(struct f2fs_sb_info *sbi, u32, struct child_info *,
|
2015-04-28 21:27:18 +00:00
|
|
|
int, enum FILE_TYPE, u32, u16, u8, int);
|
2015-03-30 19:57:10 +00:00
|
|
|
extern int fsck_chk_dentry_blk(struct f2fs_sb_info *, u32, struct child_info *,
|
2015-04-28 21:27:18 +00:00
|
|
|
int, int);
|
2014-10-14 22:15:40 +00:00
|
|
|
int fsck_chk_inline_dentries(struct f2fs_sb_info *, struct f2fs_node *,
|
2015-03-30 19:57:10 +00:00
|
|
|
struct child_info *);
|
2016-03-14 06:16:53 +00:00
|
|
|
int fsck_chk_meta(struct f2fs_sb_info *sbi);
|
2016-10-24 02:16:03 +00:00
|
|
|
int convert_encrypted_name(unsigned char *, int, unsigned char *, int);
|
2014-08-27 23:16:16 +00:00
|
|
|
|
2015-12-10 00:18:44 +00:00
|
|
|
extern void update_free_segments(struct f2fs_sb_info *);
|
2015-03-20 23:57:47 +00:00
|
|
|
void print_cp_state(u32);
|
2016-10-13 23:04:52 +00:00
|
|
|
extern void print_node_info(struct f2fs_node *, int);
|
2014-12-13 21:55:59 +00:00
|
|
|
extern void print_inode_info(struct f2fs_inode *, int);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern struct seg_entry *get_seg_entry(struct f2fs_sb_info *, unsigned int);
|
2015-03-27 04:27:56 +00:00
|
|
|
extern struct f2fs_summary_block *get_sum_block(struct f2fs_sb_info *,
|
|
|
|
|
unsigned int, int *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern int get_sum_entry(struct f2fs_sb_info *, u32, struct f2fs_summary *);
|
2015-10-23 18:45:36 +00:00
|
|
|
extern void update_sum_entry(struct f2fs_sb_info *, block_t,
|
|
|
|
|
struct f2fs_summary *);
|
2014-08-27 23:39:23 +00:00
|
|
|
extern void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
|
2014-08-28 21:55:07 +00:00
|
|
|
extern void nullify_nat_entry(struct f2fs_sb_info *, u32);
|
|
|
|
|
extern void rewrite_sit_area_bitmap(struct f2fs_sb_info *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern void build_nat_area_bitmap(struct f2fs_sb_info *);
|
2014-08-28 00:15:55 +00:00
|
|
|
extern void build_sit_area_bitmap(struct f2fs_sb_info *);
|
2017-10-30 23:21:09 +00:00
|
|
|
extern int f2fs_set_main_bitmap(struct f2fs_sb_info *, u32, int);
|
|
|
|
|
extern int f2fs_set_sit_bitmap(struct f2fs_sb_info *, u32);
|
2014-08-28 00:06:17 +00:00
|
|
|
extern void fsck_init(struct f2fs_sb_info *);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern int fsck_verify(struct f2fs_sb_info *);
|
|
|
|
|
extern void fsck_free(struct f2fs_sb_info *);
|
|
|
|
|
extern int f2fs_do_mount(struct f2fs_sb_info *);
|
|
|
|
|
extern void f2fs_do_umount(struct f2fs_sb_info *);
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
|
2015-10-23 18:45:36 +00:00
|
|
|
extern void flush_journal_entries(struct f2fs_sb_info *);
|
2015-12-17 01:43:34 +00:00
|
|
|
extern void zero_journal_entries(struct f2fs_sb_info *);
|
2015-10-23 18:45:36 +00:00
|
|
|
extern void flush_sit_entries(struct f2fs_sb_info *);
|
2015-12-10 04:30:41 +00:00
|
|
|
extern void move_curseg_info(struct f2fs_sb_info *, u64);
|
|
|
|
|
extern void write_curseg_info(struct f2fs_sb_info *);
|
|
|
|
|
extern int find_next_free_block(struct f2fs_sb_info *, u64 *, int, int);
|
2015-10-23 18:45:36 +00:00
|
|
|
extern void write_checkpoint(struct f2fs_sb_info *);
|
|
|
|
|
extern void update_data_blkaddr(struct f2fs_sb_info *, nid_t, u16, block_t);
|
2015-12-10 00:18:44 +00:00
|
|
|
extern void update_nat_blkaddr(struct f2fs_sb_info *, nid_t, nid_t, block_t);
|
2015-12-10 04:30:41 +00:00
|
|
|
|
2015-12-09 01:33:23 +00:00
|
|
|
extern void print_raw_sb_info(struct f2fs_super_block *);
|
|
|
|
|
|
2016-11-02 10:17:18 +00:00
|
|
|
extern u32 get_free_segments(struct f2fs_sb_info *);
|
2016-11-23 12:40:06 +00:00
|
|
|
extern struct f2fs_sit_block *get_current_sit_page(struct f2fs_sb_info *,
|
|
|
|
|
unsigned int);
|
|
|
|
|
extern void rewrite_current_sit_page(struct f2fs_sb_info *, unsigned int,
|
|
|
|
|
struct f2fs_sit_block *);
|
2016-11-02 10:17:18 +00:00
|
|
|
|
2017-02-09 02:55:43 +00:00
|
|
|
extern u32 update_nat_bits_flags(struct f2fs_super_block *,
|
|
|
|
|
struct f2fs_checkpoint *, u32);
|
|
|
|
|
extern void write_nat_bits(struct f2fs_sb_info *, struct f2fs_super_block *,
|
|
|
|
|
struct f2fs_checkpoint *, int);
|
|
|
|
|
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
/* dump.c */
|
|
|
|
|
struct dump_option {
|
|
|
|
|
nid_t nid;
|
2016-06-04 10:03:56 +00:00
|
|
|
int start_nat;
|
|
|
|
|
int end_nat;
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
int start_sit;
|
|
|
|
|
int end_sit;
|
|
|
|
|
int start_ssa;
|
|
|
|
|
int end_ssa;
|
2014-05-14 00:02:55 +00:00
|
|
|
int32_t blk_addr;
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
};
|
|
|
|
|
|
2016-10-12 21:11:19 +00:00
|
|
|
extern void nat_dump(struct f2fs_sb_info *);
|
|
|
|
|
extern void sit_dump(struct f2fs_sb_info *, unsigned int, unsigned int);
|
2014-08-27 23:16:16 +00:00
|
|
|
extern void ssa_dump(struct f2fs_sb_info *, int, int);
|
2016-10-13 23:04:52 +00:00
|
|
|
extern void dump_node(struct f2fs_sb_info *, nid_t, int);
|
2014-12-13 21:55:59 +00:00
|
|
|
extern int dump_info_from_blkaddr(struct f2fs_sb_info *, u32);
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
|
2015-10-23 18:45:36 +00:00
|
|
|
/* defrag.c */
|
|
|
|
|
int f2fs_defragment(struct f2fs_sb_info *, u64, u64, u64, int);
|
|
|
|
|
|
2015-12-09 00:05:09 +00:00
|
|
|
/* resize.c */
|
|
|
|
|
int f2fs_resize(struct f2fs_sb_info *);
|
2015-12-10 00:18:44 +00:00
|
|
|
|
|
|
|
|
/* sload.c */
|
|
|
|
|
int f2fs_sload(struct f2fs_sb_info *, const char *, const char *,
|
|
|
|
|
const char *, struct selabel_handle *);
|
2017-10-30 23:21:09 +00:00
|
|
|
|
|
|
|
|
/* segment.c */
|
2015-12-10 00:18:44 +00:00
|
|
|
void reserve_new_block(struct f2fs_sb_info *, block_t *,
|
|
|
|
|
struct f2fs_summary *, int);
|
|
|
|
|
void new_data_block(struct f2fs_sb_info *, void *,
|
|
|
|
|
struct dnode_of_data *, int);
|
|
|
|
|
int f2fs_build_file(struct f2fs_sb_info *, struct dentry *);
|
|
|
|
|
void f2fs_alloc_nid(struct f2fs_sb_info *, nid_t *, int);
|
|
|
|
|
void set_data_blkaddr(struct dnode_of_data *);
|
|
|
|
|
block_t new_node_block(struct f2fs_sb_info *,
|
|
|
|
|
struct dnode_of_data *, unsigned int);
|
2017-10-30 21:26:30 +00:00
|
|
|
|
|
|
|
|
/* segment.c */
|
2017-11-02 17:41:16 +00:00
|
|
|
u64 f2fs_read(struct f2fs_sb_info *, nid_t, u8 *, u64, pgoff_t);
|
|
|
|
|
u64 f2fs_write(struct f2fs_sb_info *, nid_t, u8 *, u64, pgoff_t);
|
2017-10-30 21:26:30 +00:00
|
|
|
void f2fs_filesize_update(struct f2fs_sb_info *, nid_t, u64);
|
|
|
|
|
|
2015-12-10 00:18:44 +00:00
|
|
|
void get_dnode_of_data(struct f2fs_sb_info *, struct dnode_of_data *,
|
|
|
|
|
pgoff_t, int);
|
2017-07-26 14:49:57 +00:00
|
|
|
void make_dentry_ptr(struct f2fs_dentry_ptr *, struct f2fs_node *, void *, int);
|
2015-12-10 00:18:44 +00:00
|
|
|
int f2fs_create(struct f2fs_sb_info *, struct dentry *);
|
|
|
|
|
int f2fs_mkdir(struct f2fs_sb_info *, struct dentry *);
|
|
|
|
|
int f2fs_symlink(struct f2fs_sb_info *, struct dentry *);
|
|
|
|
|
int inode_set_selinux(struct f2fs_sb_info *, u32, const char *);
|
|
|
|
|
int f2fs_find_path(struct f2fs_sb_info *, char *, nid_t *);
|
|
|
|
|
|
f2fs-tools: add fsck.f2fs and dump.f2fs
fsck.f2fs checks file system consistency, but does not repair a broken
file system yet.
dump.f2fs shows the information of a specific inode and makes dump file
of SSA and SIT.
f2fs checks file system consistency as follows:
o When data about used area and its metadata are identical,
f2fs is considered consistent. To verify such consistency, we use
three bitmaps: nat_area_bitmap, sit_area_bitmap, and main_area_bitmap.
First, each bit in nat_area_bitmap corresponds to a nid in NAT.
Second, each bit in sit_area_bitmap corresponds to a valid block in a
segment. This bitmap is same to the total valid_map of f2fs_sit_entries
in SIT.
Last, each bit in main_area_bitmap corresponds to a block in main area
except meta area.
After a consistency check of each block, we set or clear the
corresponding bit of each bitmap.
From the root node, we start consistency check. The verified
information varies according to block type.
1. NODE
- Read information of node block from NAT
- Check if block address is allocated using node info.
- Check if the type of f2fs_summary related to nid in SSA is NODE.
- Update the corresponding bit in nat_area_bitmap.
- Update the corresponding bit in sit_area_bitmap.
- Set the corresponding bit in main_area_bitmap to 1.
- Then, read node block. According to its attribute, explore
inode/direct node/indirect node/double indirect node
recursively.
- If it is an inode block, we also check its xattr and hard link.
2. DATA
- Check if the type of f2fs_summary related to nid in SSA is DATA.
- Set the corresponding bits of sit_area_bitmap and
main_area_bitmap to visited
- If it is a dentry block, traverse each dentries that may be
regular
file or directory. At this time, it will check inode block again.
Finally, we verify whether
- every nat_area_bitmap is visited
- any unreachable hard link exists
- values of sit_area_bitmap and main_area_bitmap are identical
- total_valid_block_count/node_count/inode_count are correct
Usage:
o fsck.f2fs
# fsck.f2fs /dev/sdx
options:
-d debug level [default:0]
o dump.f2fs
# dump.f2fs -i [ino] /dev/sdx
# dump.f2fs -s 0~-1 /dev/sdx (SIT dump)
# dump.f2fs -a 0~-1 /dev/sdx (SSA dump)
options:
-d debug level [default:0]
-i inode no (hex)
-s [SIT dump segno from #1~#2 (decimal), for all 0~-1]
-a [SSA dump segno from #1~#2 (decimal), for all 0~-1]
Note: To use dump.f2fs, please run make install or ln -s fsck.f2fs
dump.f2fs
Signed-off-by: Changman Lee <cm224.lee@samsung.com>
Signed-off-by: Byoung Geun Kim <bgbg.kim@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-07-04 08:11:32 +00:00
|
|
|
#endif /* _FSCK_H_ */
|