int fsck_chk_xattr_blk(struct f2fs_sb_info *sbi, u32 ino, u32 x_nid, u32 *blk_cnt)
{
struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
struct node_info ni;
if (x_nid == 0x0)
return 0;
if (f2fs_test_bit(x_nid, fsck->nat_area_bitmap) != 0x0) {
f2fs_clear_bit(x_nid, fsck->nat_area_bitmap);
} else {
ASSERT_MSG(0, "xattr_nid duplicated [0x%x]\n", x_nid);
}
*blk_cnt = *blk_cnt + 1;
fsck->chk.valid_blk_cnt++;
fsck->chk.valid_node_cnt++;
ASSERT(get_node_info(sbi, x_nid, &ni) >= 0);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->main_area_bitmap) != 0) {
ASSERT_MSG(0, "Duplicated node block for x_attr. "
"x_nid[0x%x] block addr[0x%x]\n",
x_nid, ni.blk_addr);
}
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->main_area_bitmap);
DBG(2, "ino[0x%x] x_nid[0x%x]\n", ino, x_nid);
return 0;
}
int fsck_chk_data_blk(struct f2fs_sb_info *sbi,
struct f2fs_inode *inode,
u32 blk_addr,
u32 *child_cnt,
u32 *child_files,
int last_blk,
enum FILE_TYPE ftype,
u32 parent_nid,
u16 idx_in_node,
u8 ver)
{
struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
/* Is it reserved block? */
if (blk_addr == NEW_ADDR) {
fsck->chk.valid_blk_cnt++;
return 0;
}
IS_VALID_BLK_ADDR(sbi, blk_addr);
is_valid_ssa_data_blk(sbi, blk_addr, parent_nid, idx_in_node, ver);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk_addr), fsck->sit_area_bitmap) == 0x0) {
ASSERT_MSG(0, "SIT bitmap is 0x0. blk_addr[0x%x]\n", blk_addr);
}
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk_addr), fsck->main_area_bitmap) != 0) {
ASSERT_MSG(0, "Duplicated data block. pnid[0x%x] idx[0x%x] blk_addr[0x%x]\n",
parent_nid, idx_in_node, blk_addr);
}
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk_addr), fsck->main_area_bitmap);
fsck->chk.valid_blk_cnt++;
if (ftype == F2FS_FT_DIR) {
fsck_chk_dentry_blk(sbi,
inode,
blk_addr,
child_cnt,
child_files,
last_blk);
}
return 0;
}
void f2fs_alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid, int inode)
{
struct f2fs_nm_info *nm_i = NM_I(sbi);
struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
nid_t i, inode_cnt, node_cnt;
for (i = 0; i < nm_i->max_nid; i++)
if(f2fs_test_bit(i, nm_i->nid_bitmap) == 0)
break;
ASSERT(i < nm_i->max_nid);
f2fs_set_bit(i, nm_i->nid_bitmap);
*nid = i;
inode_cnt = get_cp(valid_inode_count);
node_cnt = get_cp(valid_node_count);
if (inode)
set_cp(valid_inode_count, inode_cnt + 1);
set_cp(valid_node_count, node_cnt + 1);
}
int fsck_chk_inode_blk(struct f2fs_sb_info *sbi,
u32 nid,
enum FILE_TYPE ftype,
struct f2fs_node *node_blk,
u32 *blk_cnt,
struct node_info *ni)
{
struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
u32 child_cnt = 0, child_files = 0;
enum NODE_TYPE ntype;
u32 i_links = le32_to_cpu(node_blk->i.i_links);
u64 i_blocks = le64_to_cpu(node_blk->i.i_blocks);
int idx = 0;
int ret = 0;
ASSERT(node_blk->footer.nid == node_blk->footer.ino);
ASSERT(le32_to_cpu(node_blk->footer.nid) == nid);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) == 0x0)
fsck->chk.valid_inode_cnt++;
/* Orphan node. i_links should be 0 */
if (ftype == F2FS_FT_ORPHAN) {
ASSERT(i_links == 0);
} else {
ASSERT(i_links > 0);
}
if (ftype == F2FS_FT_DIR) {
/* not included '.' & '..' */
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) != 0) {
DBG(0, "Duplicated inode blk. ino[0x%x][0x%x]\n", nid, ni->blk_addr);
ASSERT(0);
}
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap);
} else {
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap) == 0x0) {
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni->blk_addr), fsck->main_area_bitmap);
if (i_links > 1) {
/* First time. Create new hard link node */
add_into_hard_link_list(sbi, nid, i_links);
fsck->chk.multi_hard_link_files++;
}
} else {
if (i_links <= 1) {
DBG(0, "Error. Node ID [0x%x]."
" There are one more hard links."
" But i_links is [0x%x]\n",
nid, i_links);
ASSERT(0);
}
DBG(3, "ino[0x%x] has hard links [0x%x]\n", nid, i_links);
ret = find_and_dec_hard_link_list(sbi, nid);
ASSERT(ret >= 0);
/* No need to go deep into the node */
goto out;
}
}
fsck_chk_xattr_blk(sbi, nid, le32_to_cpu(node_blk->i.i_xattr_nid), blk_cnt);
if (ftype == F2FS_FT_CHRDEV || ftype == F2FS_FT_BLKDEV ||
ftype == F2FS_FT_FIFO || ftype == F2FS_FT_SOCK)
goto check;
if((node_blk->i.i_inline & F2FS_INLINE_DATA)){
DBG(3, "ino[0x%x] has inline data!\n", nid);
goto check;
}
/* check data blocks in inode */
for (idx = 0; idx < ADDRS_PER_INODE(&node_blk->i); idx++) {
if (le32_to_cpu(node_blk->i.i_addr[idx]) != 0) {
*blk_cnt = *blk_cnt + 1;
ret = fsck_chk_data_blk(sbi,
&node_blk->i,
le32_to_cpu(node_blk->i.i_addr[idx]),
&child_cnt,
&child_files,
(i_blocks == *blk_cnt),
ftype,
nid,
idx,
ni->version);
ASSERT(ret >= 0);
}
}
/* check node blocks in inode */
for (idx = 0; idx < 5; idx++) {
if (idx == 0 || idx == 1)
ntype = TYPE_DIRECT_NODE;
else if (idx == 2 || idx == 3)
ntype = TYPE_INDIRECT_NODE;
else if (idx == 4)
ntype = TYPE_DOUBLE_INDIRECT_NODE;
else
ASSERT(0);
if (le32_to_cpu(node_blk->i.i_nid[idx]) != 0) {
*blk_cnt = *blk_cnt + 1;
ret = fsck_chk_node_blk(sbi,
&node_blk->i,
le32_to_cpu(node_blk->i.i_nid[idx]),
ftype,
ntype,
blk_cnt);
ASSERT(ret >= 0);
}
}
check:
if (ftype == F2FS_FT_DIR)
DBG(1, "Directory Inode: ino: %x name: %s depth: %d child files: %d\n\n",
le32_to_cpu(node_blk->footer.ino), node_blk->i.i_name,
le32_to_cpu(node_blk->i.i_current_depth), child_files);
if (ftype == F2FS_FT_ORPHAN)
DBG(1, "Orphan Inode: ino: %x name: %s i_blocks: %lu\n\n",
le32_to_cpu(node_blk->footer.ino), node_blk->i.i_name,
i_blocks);
if ((ftype == F2FS_FT_DIR && i_links != child_cnt) ||
(i_blocks != *blk_cnt)) {
print_node_info(node_blk);
DBG(1, "blk cnt [0x%x]\n", *blk_cnt);
DBG(1, "child cnt [0x%x]\n", child_cnt);
}
ASSERT(i_blocks == *blk_cnt);
if (ftype == F2FS_FT_DIR)
ASSERT(i_links == child_cnt);
out:
return 0;
}
int fsck_chk_node_blk(struct f2fs_sb_info *sbi,
struct f2fs_inode *inode,
u32 nid,
enum FILE_TYPE ftype,
enum NODE_TYPE ntype,
u32 *blk_cnt)
{
struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
struct node_info ni;
struct f2fs_node *node_blk = NULL;
int ret = 0;
IS_VALID_NID(sbi, nid);
if (ftype != F2FS_FT_ORPHAN ||
f2fs_test_bit(nid, fsck->nat_area_bitmap) != 0x0)
f2fs_clear_bit(nid, fsck->nat_area_bitmap);
else
ASSERT_MSG(0, "nid duplicated [0x%x]\n", nid);
ret = get_node_info(sbi, nid, &ni);
ASSERT(ret >= 0);
/* Is it reserved block?
* if block addresss was 0xffff,ffff,ffff,ffff
* it means that block was already allocated, but not stored in disk
*/
if (ni.blk_addr == NEW_ADDR) {
fsck->chk.valid_blk_cnt++;
fsck->chk.valid_node_cnt++;
if (ntype == TYPE_INODE)
fsck->chk.valid_inode_cnt++;
return 0;
}
IS_VALID_BLK_ADDR(sbi, ni.blk_addr);
is_valid_ssa_node_blk(sbi, nid, ni.blk_addr);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->sit_area_bitmap) == 0x0) {
DBG(0, "SIT bitmap is 0x0. blk_addr[0x%x] %i\n", ni.blk_addr, ni.blk_addr);
ASSERT(0);
}else{
DBG(0, "SIT bitmap is NOT 0x0. blk_addr[0x%x] %i\n", ni.blk_addr, ni.blk_addr);
//ASSERT(0);
}
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->main_area_bitmap) == 0x0) {
DBG(0, "SIT and main bitmap is 0x0. blk_addr[0x%x] %i\n", ni.blk_addr, ni.blk_addr);
fsck->chk.valid_blk_cnt++;
fsck->chk.valid_node_cnt++;
}else{
DBG(0, "SIT and main bitmap is NOT 0x0. blk_addr[0x%x] %i\n", ni.blk_addr, ni.blk_addr);
}
node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
ASSERT(node_blk != NULL);
ret = dev_read_block(node_blk, ni.blk_addr);
ASSERT(ret >= 0);
ASSERT_MSG(nid == le32_to_cpu(node_blk->footer.nid),
"nid[0x%x] blk_addr[0x%x] footer.nid[0x%x]\n",
nid, ni.blk_addr, le32_to_cpu(node_blk->footer.nid));
if (ntype == TYPE_INODE) {
ret = fsck_chk_inode_blk(sbi,
nid,
ftype,
node_blk,
blk_cnt,
&ni);
} else {
/* it's not inode */
ASSERT(node_blk->footer.nid != node_blk->footer.ino);
if (f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->main_area_bitmap) != 0) {
DBG(0, "Duplicated node block. ino[0x%x][0x%x]\n", nid, ni.blk_addr);
ASSERT(0);
}
f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, ni.blk_addr), fsck->main_area_bitmap);
switch (ntype) {
case TYPE_DIRECT_NODE:
ret = fsck_chk_dnode_blk(sbi,
inode,
nid,
ftype,
node_blk,
blk_cnt,
&ni);
break;
case TYPE_INDIRECT_NODE:
ret = fsck_chk_idnode_blk(sbi,
inode,
nid,
ftype,
node_blk,
blk_cnt);
break;
case TYPE_DOUBLE_INDIRECT_NODE:
ret = fsck_chk_didnode_blk(sbi,
inode,
nid,
ftype,
node_blk,
blk_cnt);
break;
default:
ASSERT(0);
}
}
ASSERT(ret >= 0);
free(node_blk);
return 0;
}
