4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 /* start node id of a node block dedicated to the given node id */
12 #define START_NID(nid) ((nid / NAT_ENTRY_PER_BLOCK) * NAT_ENTRY_PER_BLOCK)
14 /* node block offset on the NAT area dedicated to the given start node id */
15 #define NAT_BLOCK_OFFSET(start_nid) (start_nid / NAT_ENTRY_PER_BLOCK)
17 /* # of pages to perform readahead before building free nids */
18 #define FREE_NID_PAGES 4
20 /* maximum readahead size for node during getting data blocks */
21 #define MAX_RA_NODE 128
23 /* control the memory footprint threshold (10MB per 1GB ram) */
24 #define DEF_RAM_THRESHOLD 10
26 /* vector size for gang look-up from nat cache that consists of radix tree */
27 #define NATVEC_SIZE 64
29 /* return value for read_node_page */
33 * For node information
36 nid_t nid
; /* node id */
37 nid_t ino
; /* inode number of the node's owner */
38 block_t blk_addr
; /* block address of the node */
39 unsigned char version
; /* version of the node */
43 struct list_head list
; /* for clean or dirty nat list */
44 bool checkpointed
; /* whether it is checkpointed or not */
45 bool fsync_done
; /* whether the latest node has fsync mark */
46 struct node_info ni
; /* in-memory node information */
49 #define nat_get_nid(nat) (nat->ni.nid)
50 #define nat_set_nid(nat, n) (nat->ni.nid = n)
51 #define nat_get_blkaddr(nat) (nat->ni.blk_addr)
52 #define nat_set_blkaddr(nat, b) (nat->ni.blk_addr = b)
53 #define nat_get_ino(nat) (nat->ni.ino)
54 #define nat_set_ino(nat, i) (nat->ni.ino = i)
55 #define nat_get_version(nat) (nat->ni.version)
56 #define nat_set_version(nat, v) (nat->ni.version = v)
58 #define __set_nat_cache_dirty(nm_i, ne) \
60 ne->checkpointed = false; \
61 list_move_tail(&ne->list, &nm_i->dirty_nat_entries); \
63 #define __clear_nat_cache_dirty(nm_i, ne) \
65 ne->checkpointed = true; \
66 list_move_tail(&ne->list, &nm_i->nat_entries); \
68 #define inc_node_version(version) (++version)
70 static inline void node_info_from_raw_nat(struct node_info
*ni
,
71 struct f2fs_nat_entry
*raw_ne
)
73 ni
->ino
= le32_to_cpu(raw_ne
->ino
);
74 ni
->blk_addr
= le32_to_cpu(raw_ne
->block_addr
);
75 ni
->version
= raw_ne
->version
;
79 FREE_NIDS
, /* indicates the free nid list */
80 NAT_ENTRIES
/* indicates the cached nat entry */
84 * For free nid mangement
87 NID_NEW
, /* newly added to free nid list */
88 NID_ALLOC
/* it is allocated */
92 struct list_head list
; /* for free node id list */
93 nid_t nid
; /* node id */
94 int state
; /* in use or not: NID_NEW or NID_ALLOC */
97 static inline int next_free_nid(struct f2fs_sb_info
*sbi
, nid_t
*nid
)
99 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
100 struct free_nid
*fnid
;
104 spin_lock(&nm_i
->free_nid_list_lock
);
105 fnid
= list_entry(nm_i
->free_nid_list
.next
, struct free_nid
, list
);
107 spin_unlock(&nm_i
->free_nid_list_lock
);
114 static inline void get_nat_bitmap(struct f2fs_sb_info
*sbi
, void *addr
)
116 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
117 memcpy(addr
, nm_i
->nat_bitmap
, nm_i
->bitmap_size
);
120 static inline pgoff_t
current_nat_addr(struct f2fs_sb_info
*sbi
, nid_t start
)
122 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
127 block_off
= NAT_BLOCK_OFFSET(start
);
128 seg_off
= block_off
>> sbi
->log_blocks_per_seg
;
130 block_addr
= (pgoff_t
)(nm_i
->nat_blkaddr
+
131 (seg_off
<< sbi
->log_blocks_per_seg
<< 1) +
132 (block_off
& ((1 << sbi
->log_blocks_per_seg
) - 1)));
134 if (f2fs_test_bit(block_off
, nm_i
->nat_bitmap
))
135 block_addr
+= sbi
->blocks_per_seg
;
140 static inline pgoff_t
next_nat_addr(struct f2fs_sb_info
*sbi
,
143 struct f2fs_nm_info
*nm_i
= NM_I(sbi
);
145 block_addr
-= nm_i
->nat_blkaddr
;
146 if ((block_addr
>> sbi
->log_blocks_per_seg
) % 2)
147 block_addr
-= sbi
->blocks_per_seg
;
149 block_addr
+= sbi
->blocks_per_seg
;
151 return block_addr
+ nm_i
->nat_blkaddr
;
154 static inline void set_to_next_nat(struct f2fs_nm_info
*nm_i
, nid_t start_nid
)
156 unsigned int block_off
= NAT_BLOCK_OFFSET(start_nid
);
158 if (f2fs_test_bit(block_off
, nm_i
->nat_bitmap
))
159 f2fs_clear_bit(block_off
, nm_i
->nat_bitmap
);
161 f2fs_set_bit(block_off
, nm_i
->nat_bitmap
);
164 static inline void fill_node_footer(struct page
*page
, nid_t nid
,
165 nid_t ino
, unsigned int ofs
, bool reset
)
167 struct f2fs_node
*rn
= F2FS_NODE(page
);
169 memset(rn
, 0, sizeof(*rn
));
170 rn
->footer
.nid
= cpu_to_le32(nid
);
171 rn
->footer
.ino
= cpu_to_le32(ino
);
172 rn
->footer
.flag
= cpu_to_le32(ofs
<< OFFSET_BIT_SHIFT
);
175 static inline void copy_node_footer(struct page
*dst
, struct page
*src
)
177 struct f2fs_node
*src_rn
= F2FS_NODE(src
);
178 struct f2fs_node
*dst_rn
= F2FS_NODE(dst
);
179 memcpy(&dst_rn
->footer
, &src_rn
->footer
, sizeof(struct node_footer
));
182 static inline void fill_node_footer_blkaddr(struct page
*page
, block_t blkaddr
)
184 struct f2fs_sb_info
*sbi
= F2FS_SB(page
->mapping
->host
->i_sb
);
185 struct f2fs_checkpoint
*ckpt
= F2FS_CKPT(sbi
);
186 struct f2fs_node
*rn
= F2FS_NODE(page
);
188 rn
->footer
.cp_ver
= ckpt
->checkpoint_ver
;
189 rn
->footer
.next_blkaddr
= cpu_to_le32(blkaddr
);
192 static inline nid_t
ino_of_node(struct page
*node_page
)
194 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
195 return le32_to_cpu(rn
->footer
.ino
);
198 static inline nid_t
nid_of_node(struct page
*node_page
)
200 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
201 return le32_to_cpu(rn
->footer
.nid
);
204 static inline unsigned int ofs_of_node(struct page
*node_page
)
206 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
207 unsigned flag
= le32_to_cpu(rn
->footer
.flag
);
208 return flag
>> OFFSET_BIT_SHIFT
;
211 static inline unsigned long long cpver_of_node(struct page
*node_page
)
213 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
214 return le64_to_cpu(rn
->footer
.cp_ver
);
217 static inline block_t
next_blkaddr_of_node(struct page
*node_page
)
219 struct f2fs_node
*rn
= F2FS_NODE(node_page
);
220 return le32_to_cpu(rn
->footer
.next_blkaddr
);
224 * f2fs assigns the following node offsets described as (num).
230 * |- indirect node (3)
231 * | `- direct node (4 => 4 + N - 1)
232 * |- indirect node (4 + N)
233 * | `- direct node (5 + N => 5 + 2N - 1)
234 * `- double indirect node (5 + 2N)
235 * `- indirect node (6 + 2N)
238 * `- indirect node ((6 + 2N) + x(N + 1))
241 * `- indirect node ((6 + 2N) + (N - 1)(N + 1))
244 static inline bool IS_DNODE(struct page
*node_page
)
246 unsigned int ofs
= ofs_of_node(node_page
);
248 if (f2fs_has_xattr_block(ofs
))
251 if (ofs
== 3 || ofs
== 4 + NIDS_PER_BLOCK
||
252 ofs
== 5 + 2 * NIDS_PER_BLOCK
)
254 if (ofs
>= 6 + 2 * NIDS_PER_BLOCK
) {
255 ofs
-= 6 + 2 * NIDS_PER_BLOCK
;
256 if (!((long int)ofs
% (NIDS_PER_BLOCK
+ 1)))
262 static inline void set_nid(struct page
*p
, int off
, nid_t nid
, bool i
)
264 struct f2fs_node
*rn
= F2FS_NODE(p
);
266 wait_on_page_writeback(p
);
269 rn
->i
.i_nid
[off
- NODE_DIR1_BLOCK
] = cpu_to_le32(nid
);
271 rn
->in
.nid
[off
] = cpu_to_le32(nid
);
275 static inline nid_t
get_nid(struct page
*p
, int off
, bool i
)
277 struct f2fs_node
*rn
= F2FS_NODE(p
);
280 return le32_to_cpu(rn
->i
.i_nid
[off
- NODE_DIR1_BLOCK
]);
281 return le32_to_cpu(rn
->in
.nid
[off
]);
285 * Coldness identification:
286 * - Mark cold files in f2fs_inode_info
287 * - Mark cold node blocks in their node footer
288 * - Mark cold data pages in page cache
290 static inline int is_file(struct inode
*inode
, int type
)
292 return F2FS_I(inode
)->i_advise
& type
;
295 static inline void set_file(struct inode
*inode
, int type
)
297 F2FS_I(inode
)->i_advise
|= type
;
300 static inline void clear_file(struct inode
*inode
, int type
)
302 F2FS_I(inode
)->i_advise
&= ~type
;
305 #define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
306 #define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
307 #define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
308 #define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
309 #define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
310 #define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
312 static inline int is_cold_data(struct page
*page
)
314 return PageChecked(page
);
317 static inline void set_cold_data(struct page
*page
)
319 SetPageChecked(page
);
322 static inline void clear_cold_data(struct page
*page
)
324 ClearPageChecked(page
);
327 static inline int is_node(struct page
*page
, int type
)
329 struct f2fs_node
*rn
= F2FS_NODE(page
);
330 return le32_to_cpu(rn
->footer
.flag
) & (1 << type
);
333 #define is_cold_node(page) is_node(page, COLD_BIT_SHIFT)
334 #define is_fsync_dnode(page) is_node(page, FSYNC_BIT_SHIFT)
335 #define is_dent_dnode(page) is_node(page, DENT_BIT_SHIFT)
337 static inline void set_cold_node(struct inode
*inode
, struct page
*page
)
339 struct f2fs_node
*rn
= F2FS_NODE(page
);
340 unsigned int flag
= le32_to_cpu(rn
->footer
.flag
);
342 if (S_ISDIR(inode
->i_mode
))
343 flag
&= ~(0x1 << COLD_BIT_SHIFT
);
345 flag
|= (0x1 << COLD_BIT_SHIFT
);
346 rn
->footer
.flag
= cpu_to_le32(flag
);
349 static inline void set_mark(struct page
*page
, int mark
, int type
)
351 struct f2fs_node
*rn
= F2FS_NODE(page
);
352 unsigned int flag
= le32_to_cpu(rn
->footer
.flag
);
354 flag
|= (0x1 << type
);
356 flag
&= ~(0x1 << type
);
357 rn
->footer
.flag
= cpu_to_le32(flag
);
359 #define set_dentry_mark(page, mark) set_mark(page, mark, DENT_BIT_SHIFT)
360 #define set_fsync_mark(page, mark) set_mark(page, mark, FSYNC_BIT_SHIFT)
This page took 0.043258 seconds and 5 git commands to generate.