1 /**
2 * node.h
3 *
4 * Many parts of codes are copied from Linux kernel/fs/f2fs.
5 *
6 * Copyright (C) 2015 Huawei Ltd.
7 * Witten by:
8 * Hou Pengyang <[email protected]>
9 * Liu Shuoran <[email protected]>
10 * Jaegeuk Kim <[email protected]>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 */
16 #ifndef _NODE_H_
17 #define _NODE_H_
18
19 #include "fsck.h"
20
IS_INODE(struct f2fs_node * node)21 static inline bool IS_INODE(struct f2fs_node *node)
22 {
23 return F2FS_NODE_FOOTER(node)->nid == F2FS_NODE_FOOTER(node)->ino;
24 }
25
ADDRS_PER_PAGE(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk,struct f2fs_node * inode_blk)26 static inline unsigned int ADDRS_PER_PAGE(struct f2fs_sb_info *sbi,
27 struct f2fs_node *node_blk, struct f2fs_node *inode_blk)
28 {
29 nid_t ino = le32_to_cpu(F2FS_NODE_FOOTER(node_blk)->ino);
30 unsigned int nblocks;
31
32 if (IS_INODE(node_blk))
33 return ADDRS_PER_INODE(&node_blk->i);
34
35 if (!inode_blk) {
36 struct node_info ni;
37
38 inode_blk = calloc(F2FS_BLKSIZE, 2);
39 ASSERT(inode_blk);
40
41 get_node_info(sbi, ino, &ni);
42 ASSERT(dev_read_block(inode_blk, ni.blk_addr) >= 0);
43 nblocks = ADDRS_PER_BLOCK(&inode_blk->i);
44 free(inode_blk);
45 } else {
46 nblocks = ADDRS_PER_BLOCK(&inode_blk->i);
47 }
48 return nblocks;
49 }
50
blkaddr_in_inode(struct f2fs_node * node)51 static inline __le32 *blkaddr_in_inode(struct f2fs_node *node)
52 {
53 return node->i.i_addr + get_extra_isize(node);
54 }
55
blkaddr_in_node(struct f2fs_node * node)56 static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
57 {
58 return IS_INODE(node) ? blkaddr_in_inode(node) : node->dn.addr;
59 }
60
datablock_addr(struct f2fs_node * node_page,unsigned int offset)61 static inline block_t datablock_addr(struct f2fs_node *node_page,
62 unsigned int offset)
63 {
64 __le32 *addr_array;
65
66 ASSERT(node_page);
67 addr_array = blkaddr_in_node(node_page);
68 return le32_to_cpu(addr_array[offset]);
69 }
70
set_nid(struct f2fs_node * rn,int off,nid_t nid,int i)71 static inline void set_nid(struct f2fs_node * rn, int off, nid_t nid, int i)
72 {
73 if (i)
74 F2FS_INODE_I_NID(&rn->i, off - NODE_DIR1_BLOCK) = cpu_to_le32(nid);
75 else
76 rn->in.nid[off] = cpu_to_le32(nid);
77 }
78
get_nid(struct f2fs_node * rn,int off,int i)79 static inline nid_t get_nid(struct f2fs_node * rn, int off, int i)
80 {
81 if (i)
82 return le32_to_cpu(F2FS_INODE_I_NID(&rn->i, off - NODE_DIR1_BLOCK));
83 else
84 return le32_to_cpu(rn->in.nid[off]);
85 }
86
87 enum {
88 ALLOC_NODE, /* allocate a new node page if needed */
89 LOOKUP_NODE, /* lookup up a node without readahead */
90 LOOKUP_NODE_RA,
91 };
92
set_new_dnode(struct dnode_of_data * dn,struct f2fs_node * iblk,struct f2fs_node * nblk,nid_t nid)93 static inline void set_new_dnode(struct dnode_of_data *dn,
94 struct f2fs_node *iblk, struct f2fs_node *nblk, nid_t nid)
95 {
96 memset(dn, 0, sizeof(*dn));
97 dn->inode_blk = iblk;
98 dn->node_blk = nblk;
99 dn->nid = nid;
100 dn->idirty = 0;
101 dn->ndirty = 0;
102 dn->alloced = 0;
103 }
104
inc_inode_blocks(struct dnode_of_data * dn)105 static inline void inc_inode_blocks(struct dnode_of_data *dn)
106 {
107 u64 blocks = le64_to_cpu(dn->inode_blk->i.i_blocks);
108
109 dn->inode_blk->i.i_blocks = cpu_to_le64(blocks + 1);
110 dn->idirty = 1;
111 }
112
IS_DNODE(struct f2fs_node * node_page)113 static inline int IS_DNODE(struct f2fs_node *node_page)
114 {
115 unsigned int ofs = ofs_of_node(node_page);
116
117 if (ofs == 3 || ofs == 4 + NIDS_PER_BLOCK ||
118 ofs == 5 + 2 * NIDS_PER_BLOCK)
119 return 0;
120
121 if (ofs >= 6 + 2 * NIDS_PER_BLOCK) {
122 ofs -= 6 + 2 * NIDS_PER_BLOCK;
123 if (!((long int)ofs % (NIDS_PER_BLOCK + 1)))
124 return 0;
125 }
126 return 1;
127 }
128
ino_of_node(struct f2fs_node * node_blk)129 static inline nid_t ino_of_node(struct f2fs_node *node_blk)
130 {
131 return le32_to_cpu(F2FS_NODE_FOOTER(node_blk)->ino);
132 }
133
cpver_of_node(struct f2fs_node * node_blk)134 static inline __u64 cpver_of_node(struct f2fs_node *node_blk)
135 {
136 return le64_to_cpu(F2FS_NODE_FOOTER(node_blk)->cp_ver);
137 }
138
is_recoverable_dnode(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk)139 static inline bool is_recoverable_dnode(struct f2fs_sb_info *sbi,
140 struct f2fs_node *node_blk)
141 {
142 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
143 __u64 cp_ver = cur_cp_version(ckpt);
144
145 /* Don't care crc part, if fsck.f2fs sets it. */
146 if (is_set_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG))
147 return (cp_ver << 32) == (cpver_of_node(node_blk) << 32);
148
149 if (is_set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG))
150 cp_ver |= (cur_cp_crc(ckpt) << 32);
151
152 return cp_ver == cpver_of_node(node_blk);
153 }
154
next_blkaddr_of_node(struct f2fs_node * node_blk)155 static inline block_t next_blkaddr_of_node(struct f2fs_node *node_blk)
156 {
157 return le32_to_cpu(F2FS_NODE_FOOTER(node_blk)->next_blkaddr);
158 }
159
is_node(struct f2fs_node * node_blk,int type)160 static inline int is_node(struct f2fs_node *node_blk, int type)
161 {
162 return le32_to_cpu(F2FS_NODE_FOOTER(node_blk)->flag) & (1 << type);
163 }
164
set_cold_node(struct f2fs_node * rn,bool is_dir)165 static inline void set_cold_node(struct f2fs_node *rn, bool is_dir)
166 {
167 unsigned int flag = le32_to_cpu(F2FS_NODE_FOOTER(rn)->flag);
168
169 if (is_dir)
170 flag &= ~(0x1 << COLD_BIT_SHIFT);
171 else
172 flag |= (0x1 << COLD_BIT_SHIFT);
173 F2FS_NODE_FOOTER(rn)->flag = cpu_to_le32(flag);
174 }
175
176 #define is_fsync_dnode(node_blk) is_node(node_blk, FSYNC_BIT_SHIFT)
177 #define is_dent_dnode(node_blk) is_node(node_blk, DENT_BIT_SHIFT)
178
179 #endif
180