]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/f2fs/node.h
1 /* SPDX-License-Identifier: GPL-2.0 */
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
8 /* start node id of a node block dedicated to the given node id */
9 #define START_NID(nid) (((nid) / NAT_ENTRY_PER_BLOCK) * NAT_ENTRY_PER_BLOCK)
11 /* node block offset on the NAT area dedicated to the given start node id */
12 #define NAT_BLOCK_OFFSET(start_nid) ((start_nid) / NAT_ENTRY_PER_BLOCK)
14 /* # of pages to perform synchronous readahead before building free nids */
15 #define FREE_NID_PAGES 8
16 #define MAX_FREE_NIDS (NAT_ENTRY_PER_BLOCK * FREE_NID_PAGES)
18 /* size of free nid batch when shrinking */
19 #define SHRINK_NID_BATCH_SIZE 8
21 #define DEF_RA_NID_PAGES 0 /* # of nid pages to be readaheaded */
23 /* maximum readahead size for node during getting data blocks */
24 #define MAX_RA_NODE 128
26 /* control the memory footprint threshold (10MB per 1GB ram) */
27 #define DEF_RAM_THRESHOLD 1
29 /* control dirty nats ratio threshold (default: 10% over max nid count) */
30 #define DEF_DIRTY_NAT_RATIO_THRESHOLD 10
31 /* control total # of nats */
32 #define DEF_NAT_CACHE_THRESHOLD 100000
34 /* vector size for gang look-up from nat cache that consists of radix tree */
35 #define NATVEC_SIZE 64
36 #define SETVEC_SIZE 32
38 /* return value for read_node_page */
41 /* check pinned file's alignment status of physical blocks */
42 #define FILE_NOT_ALIGNED 1
44 /* For flag in struct node_info */
46 IS_CHECKPOINTED
, /* is it checkpointed before? */
47 HAS_FSYNCED_INODE
, /* is the inode fsynced before? */
48 HAS_LAST_FSYNC
, /* has the latest node fsync mark? */
49 IS_DIRTY
, /* this nat entry is dirty? */
50 IS_PREALLOC
, /* nat entry is preallocated */
54 * For node information
57 nid_t nid
; /* node id */
58 nid_t ino
; /* inode number of the node's owner */
59 block_t blk_addr
; /* block address of the node */
60 unsigned char version
; /* version of the node */
61 unsigned char flag
; /* for node information bits */
65 struct list_head list
; /* for clean or dirty nat list */
66 struct node_info ni
; /* in-memory node information */
69 #define nat_get_nid(nat) ((nat)->ni.nid)
70 #define nat_set_nid(nat, n) ((nat)->ni.nid = (n))
71 #define nat_get_blkaddr(nat) ((nat)->ni.blk_addr)
72 #define nat_set_blkaddr(nat, b) ((nat)->ni.blk_addr = (b))
73 #define nat_get_ino(nat) ((nat)->ni.ino)
74 #define nat_set_ino(nat, i) ((nat)->ni.ino = (i))
75 #define nat_get_version(nat) ((nat)->ni.version)
76 #define nat_set_version(nat, v) ((nat)->ni.version = (v))
78 #define inc_node_version(version) (++(version))
80 static inline void copy_node_info(struct node_info
*dst
,
81 struct node_info
*src
)
85 dst
->blk_addr
= src
->blk_addr
;
86 dst
->version
= src
->version
;
87 /* should not copy flag here */
90 static inline void set_nat_flag(struct nat_entry
*ne
,
91 unsigned int type
, bool set
)
93 unsigned char mask
= 0x01 << type
;
100 static inline bool get_nat_flag(struct nat_entry
*ne
, unsigned int type
)
102 unsigned char mask
= 0x01 << type
;
103 return ne
->ni
.flag
& mask
;
106 static inline void nat_reset_flag(struct nat_entry
*ne
)
108 /* these states can be set only after checkpoint was done */
109 set_nat_flag(ne
, IS_CHECKPOINTED
, true);
110 set_nat_flag(ne
, HAS_FSYNCED_INODE
, false);
111 set_nat_flag(ne
, HAS_LAST_FSYNC
, true);
114 static inline void node_info_from_raw_nat(struct node_info
*ni
,
115 struct f2fs_nat_entry
*raw_ne
)
117 ni
->ino
= le32_to_cpu(raw_ne
->ino
);
118 ni
->blk_addr
= le32_to_cpu(raw_ne
->block_addr
);
119 ni
->version
= raw_ne
->version
;
122 static inline void raw_nat_from_node_info(struct f2fs_nat_entry
*raw_ne
,
123 struct node_info
*ni
)
125 raw_ne
->ino
= cpu_to_le32(ni
->ino
);
126 raw_ne
->block_addr
= cpu_to_le32(ni
->blk_addr
);
127 raw_ne
->version
= ni
->version
;
130 static inline bool excess_dirty_nats(struct f2fs_sb_info
*sbi
)
132 return NM_I(sbi
)->nat_cnt
[DIRTY_NAT
] >= NM_I(sbi
)->max_nid
*
133 NM_I(sbi
)->dirty_nats_ratio
/ 100;
136 static inline bool excess_cached_nats(struct f2fs_sb_info
*sbi
)
138 return NM_I(sbi
)->nat_cnt
[TOTAL_NAT
] >= DEF_NAT_CACHE_THRESHOLD
;
141 static inline bool excess_dirty_nodes(struct f2fs_sb_info
*sbi
)
143 return get_pages(sbi
, F2FS_DIRTY_NODES
) >= sbi
->blocks_per_seg
* 8;
147 FREE_NIDS
, /* indicates the free nid list */
148 NAT_ENTRIES
, /* indicates the cached nat entry */
149 DIRTY_DENTS
, /* indicates dirty dentry pages */
150 INO_ENTRIES
, /* indicates inode entries */
151 EXTENT_CACHE
, /* indicates extent cache */
152 INMEM_PAGES
, /* indicates inmemory pages */
153 DISCARD_CACHE
, /* indicates memory of cached discard cmds */
154 COMPRESS_PAGE
, /* indicates memory of cached compressed pages */
155 BASE_CHECK
, /* check kernel status */
158 struct nat_entry_set
{
159 struct list_head set_list
; /* link with other nat sets */
160 struct list_head entry_list
; /* link with dirty nat entries */
161 nid_t set
; /* set number*/
162 unsigned int entry_cnt
; /* the # of nat entries in set */
166 struct list_head list
; /* for free node id list */
167 nid_t nid
; /* node id */
168 int state
; /* in use or not: FREE_NID or PREALLOC_NID */
171 static inline void next_free_nid(struct f2fs_sb_info
*sbi
, nid_t
*nid
)
173 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
174 struct free_nid
*fnid
;
176 spin_lock(&nm_i
->nid_list_lock
);
177 if (nm_i
->nid_cnt
[FREE_NID
] <= 0) {
178 spin_unlock(&nm_i
->nid_list_lock
);
181 fnid
= list_first_entry(&nm_i
->free_nid_list
, struct free_nid
, list
);
183 spin_unlock(&nm_i
->nid_list_lock
);
189 static inline void get_nat_bitmap(struct f2fs_sb_info
*sbi
, void *addr
)
191 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
193 #ifdef CONFIG_F2FS_CHECK_FS
194 if (memcmp(nm_i
->nat_bitmap
, nm_i
->nat_bitmap_mir
,
198 memcpy(addr
, nm_i
->nat_bitmap
, nm_i
->bitmap_size
);
201 static inline pgoff_t
current_nat_addr(struct f2fs_sb_info
*sbi
, nid_t start
)
203 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
208 * block_off = segment_off * 512 + off_in_segment
209 * OLD = (segment_off * 512) * 2 + off_in_segment
210 * NEW = 2 * (segment_off * 512 + off_in_segment) - off_in_segment
212 block_off
= NAT_BLOCK_OFFSET(start
);
214 block_addr
= (pgoff_t
)(nm_i
->nat_blkaddr
+
216 (block_off
& (sbi
->blocks_per_seg
- 1)));
218 if (f2fs_test_bit(block_off
, nm_i
->nat_bitmap
))
219 block_addr
+= sbi
->blocks_per_seg
;
224 static inline pgoff_t
next_nat_addr(struct f2fs_sb_info
*sbi
,
227 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
229 block_addr
-= nm_i
->nat_blkaddr
;
230 block_addr
^= 1 << sbi
->log_blocks_per_seg
;
231 return block_addr
+ nm_i
->nat_blkaddr
;
234 static inline void set_to_next_nat(struct f2fs_nm_info
*nm_i
, nid_t start_nid
)
236 unsigned int block_off
= NAT_BLOCK_OFFSET(start_nid
);
238 f2fs_change_bit(block_off
, nm_i
->nat_bitmap
);
239 #ifdef CONFIG_F2FS_CHECK_FS
240 f2fs_change_bit(block_off
, nm_i
->nat_bitmap_mir
);
244 static inline nid_t
ino_of_node(struct page
*node_page
)
246 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
247 return le32_to_cpu(rn
->footer
.ino
);
250 static inline nid_t
nid_of_node(struct page
*node_page
)
252 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
253 return le32_to_cpu(rn
->footer
.nid
);
256 static inline unsigned int ofs_of_node(struct page
*node_page
)
258 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
259 unsigned flag
= le32_to_cpu(rn
->footer
.flag
);
260 return flag
>> OFFSET_BIT_SHIFT
;
263 static inline __u64
cpver_of_node(struct page
*node_page
)
265 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
266 return le64_to_cpu(rn
->footer
.cp_ver
);
269 static inline block_t
next_blkaddr_of_node(struct page
*node_page
)
271 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
272 return le32_to_cpu(rn
->footer
.next_blkaddr
);
275 static inline void fill_node_footer(struct page
*page
, nid_t nid
,
276 nid_t ino
, unsigned int ofs
, bool reset
)
278 struct f2fs_node
*rn
= F2FS_NODE(page
);
279 unsigned int old_flag
= 0;
282 memset(rn
, 0, sizeof(*rn
));
284 old_flag
= le32_to_cpu(rn
->footer
.flag
);
286 rn
->footer
.nid
= cpu_to_le32(nid
);
287 rn
->footer
.ino
= cpu_to_le32(ino
);
289 /* should remain old flag bits such as COLD_BIT_SHIFT */
290 rn
->footer
.flag
= cpu_to_le32((ofs
<< OFFSET_BIT_SHIFT
) |
291 (old_flag
& OFFSET_BIT_MASK
));
294 static inline void copy_node_footer(struct page
*dst
, struct page
*src
)
296 struct f2fs_node
*src_rn
= F2FS_NODE(src
);
297 struct f2fs_node
*dst_rn
= F2FS_NODE(dst
);
298 memcpy(&dst_rn
->footer
, &src_rn
->footer
, sizeof(struct node_footer
));
301 static inline void fill_node_footer_blkaddr(struct page
*page
, block_t blkaddr
)
303 struct f2fs_checkpoint
*ckpt
= F2FS_CKPT(F2FS_P_SB(page
));
304 struct f2fs_node
*rn
= F2FS_NODE(page
);
305 __u64 cp_ver
= cur_cp_version(ckpt
);
307 if (__is_set_ckpt_flags(ckpt
, CP_CRC_RECOVERY_FLAG
))
308 cp_ver
|= (cur_cp_crc(ckpt
) << 32);
310 rn
->footer
.cp_ver
= cpu_to_le64(cp_ver
);
311 rn
->footer
.next_blkaddr
= cpu_to_le32(blkaddr
);
314 static inline bool is_recoverable_dnode(struct page
*page
)
316 struct f2fs_checkpoint
*ckpt
= F2FS_CKPT(F2FS_P_SB(page
));
317 __u64 cp_ver
= cur_cp_version(ckpt
);
319 /* Don't care crc part, if fsck.f2fs sets it. */
320 if (__is_set_ckpt_flags(ckpt
, CP_NOCRC_RECOVERY_FLAG
))
321 return (cp_ver
<< 32) == (cpver_of_node(page
) << 32);
323 if (__is_set_ckpt_flags(ckpt
, CP_CRC_RECOVERY_FLAG
))
324 cp_ver
|= (cur_cp_crc(ckpt
) << 32);
326 return cp_ver
== cpver_of_node(page
);
330 * f2fs assigns the following node offsets described as (num).
336 * |- indirect node (3)
337 * | `- direct node (4 => 4 + N - 1)
338 * |- indirect node (4 + N)
339 * | `- direct node (5 + N => 5 + 2N - 1)
340 * `- double indirect node (5 + 2N)
341 * `- indirect node (6 + 2N)
344 * `- indirect node ((6 + 2N) + x(N + 1))
347 * `- indirect node ((6 + 2N) + (N - 1)(N + 1))
350 static inline bool IS_DNODE(struct page
*node_page
)
352 unsigned int ofs
= ofs_of_node(node_page
);
354 if (f2fs_has_xattr_block(ofs
))
357 if (ofs
== 3 || ofs
== 4 + NIDS_PER_BLOCK
||
358 ofs
== 5 + 2 * NIDS_PER_BLOCK
)
360 if (ofs
>= 6 + 2 * NIDS_PER_BLOCK
) {
361 ofs
-= 6 + 2 * NIDS_PER_BLOCK
;
362 if (!((long int)ofs
% (NIDS_PER_BLOCK
+ 1)))
368 static inline int set_nid(struct page
*p
, int off
, nid_t nid
, bool i
)
370 struct f2fs_node
*rn
= F2FS_NODE(p
);
372 f2fs_wait_on_page_writeback(p
, NODE
, true, true);
375 rn
->i
.i_nid
[off
- NODE_DIR1_BLOCK
] = cpu_to_le32(nid
);
377 rn
->in
.nid
[off
] = cpu_to_le32(nid
);
378 return set_page_dirty(p
);
381 static inline nid_t
get_nid(struct page
*p
, int off
, bool i
)
383 struct f2fs_node
*rn
= F2FS_NODE(p
);
386 return le32_to_cpu(rn
->i
.i_nid
[off
- NODE_DIR1_BLOCK
]);
387 return le32_to_cpu(rn
->in
.nid
[off
]);
391 * Coldness identification:
392 * - Mark cold files in f2fs_inode_info
393 * - Mark cold node blocks in their node footer
394 * - Mark cold data pages in page cache
397 static inline int is_node(struct page
*page
, int type
)
399 struct f2fs_node
*rn
= F2FS_NODE(page
);
400 return le32_to_cpu(rn
->footer
.flag
) & (1 << type
);
403 #define is_cold_node(page) is_node(page, COLD_BIT_SHIFT)
404 #define is_fsync_dnode(page) is_node(page, FSYNC_BIT_SHIFT)
405 #define is_dent_dnode(page) is_node(page, DENT_BIT_SHIFT)
407 static inline void set_cold_node(struct page
*page
, bool is_dir
)
409 struct f2fs_node
*rn
= F2FS_NODE(page
);
410 unsigned int flag
= le32_to_cpu(rn
->footer
.flag
);
413 flag
&= ~(0x1 << COLD_BIT_SHIFT
);
415 flag
|= (0x1 << COLD_BIT_SHIFT
);
416 rn
->footer
.flag
= cpu_to_le32(flag
);
419 static inline void set_mark(struct page
*page
, int mark
, int type
)
421 struct f2fs_node
*rn
= F2FS_NODE(page
);
422 unsigned int flag
= le32_to_cpu(rn
->footer
.flag
);
424 flag
|= (0x1 << type
);
426 flag
&= ~(0x1 << type
);
427 rn
->footer
.flag
= cpu_to_le32(flag
);
429 #ifdef CONFIG_F2FS_CHECK_FS
430 f2fs_inode_chksum_set(F2FS_P_SB(page
), page
);
433 #define set_dentry_mark(page, mark) set_mark(page, mark, DENT_BIT_SHIFT)
434 #define set_fsync_mark(page, mark) set_mark(page, mark, FSYNC_BIT_SHIFT)