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.
12 #include <linux/f2fs_fs.h>
13 #include <linux/buffer_head.h>
14 #include <linux/writeback.h>
15 #include <linux/bitops.h>
20 #include <trace/events/f2fs.h>
22 void f2fs_set_inode_flags(struct inode
*inode
)
24 unsigned int flags
= F2FS_I(inode
)->i_flags
;
25 unsigned int new_fl
= 0;
27 if (flags
& FS_SYNC_FL
)
29 if (flags
& FS_APPEND_FL
)
31 if (flags
& FS_IMMUTABLE_FL
)
32 new_fl
|= S_IMMUTABLE
;
33 if (flags
& FS_NOATIME_FL
)
35 if (flags
& FS_DIRSYNC_FL
)
37 set_mask_bits(&inode
->i_flags
,
38 S_SYNC
|S_APPEND
|S_IMMUTABLE
|S_NOATIME
|S_DIRSYNC
, new_fl
);
41 static void __get_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
43 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
44 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
47 old_decode_dev(le32_to_cpu(ri
->i_addr
[0]));
50 new_decode_dev(le32_to_cpu(ri
->i_addr
[1]));
54 static void __set_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
56 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
57 if (old_valid_dev(inode
->i_rdev
)) {
59 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
64 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
70 static void __recover_inline_status(struct inode
*inode
, struct page
*ipage
)
72 void *inline_data
= inline_data_addr(ipage
);
73 __le32
*start
= inline_data
;
74 __le32
*end
= start
+ MAX_INLINE_DATA
/ sizeof(__le32
);
78 f2fs_wait_on_page_writeback(ipage
, NODE
);
80 set_inode_flag(F2FS_I(inode
), FI_DATA_EXIST
);
81 set_raw_inline(F2FS_I(inode
), F2FS_INODE(ipage
));
82 set_page_dirty(ipage
);
89 static int do_read_inode(struct inode
*inode
)
91 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
92 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
93 struct page
*node_page
;
94 struct f2fs_inode
*ri
;
96 /* Check if ino is within scope */
97 if (check_nid_range(sbi
, inode
->i_ino
)) {
98 f2fs_msg(inode
->i_sb
, KERN_ERR
, "bad inode number: %lu",
99 (unsigned long) inode
->i_ino
);
104 node_page
= get_node_page(sbi
, inode
->i_ino
);
105 if (IS_ERR(node_page
))
106 return PTR_ERR(node_page
);
108 ri
= F2FS_INODE(node_page
);
110 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
111 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
112 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
113 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
114 inode
->i_size
= le64_to_cpu(ri
->i_size
);
115 inode
->i_blocks
= le64_to_cpu(ri
->i_blocks
);
117 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
118 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
119 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
120 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
121 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
122 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
123 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
125 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
126 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
127 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
129 fi
->i_advise
= ri
->i_advise
;
130 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
131 fi
->i_dir_level
= ri
->i_dir_level
;
133 get_extent_info(&fi
->ext
, ri
->i_ext
);
134 get_inline_info(fi
, ri
);
136 /* check data exist */
137 if (f2fs_has_inline_data(inode
) && !f2fs_exist_data(inode
))
138 __recover_inline_status(inode
, node_page
);
140 /* get rdev by using inline_info */
141 __get_inode_rdev(inode
, ri
);
143 f2fs_put_page(node_page
, 1);
145 stat_inc_inline_inode(inode
);
146 stat_inc_inline_dir(inode
);
151 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
153 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
157 inode
= iget_locked(sb
, ino
);
159 return ERR_PTR(-ENOMEM
);
161 if (!(inode
->i_state
& I_NEW
)) {
162 trace_f2fs_iget(inode
);
165 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
168 ret
= do_read_inode(inode
);
172 if (ino
== F2FS_NODE_INO(sbi
)) {
173 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
174 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
175 } else if (ino
== F2FS_META_INO(sbi
)) {
176 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
177 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
178 } else if (S_ISREG(inode
->i_mode
)) {
179 inode
->i_op
= &f2fs_file_inode_operations
;
180 inode
->i_fop
= &f2fs_file_operations
;
181 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
182 } else if (S_ISDIR(inode
->i_mode
)) {
183 inode
->i_op
= &f2fs_dir_inode_operations
;
184 inode
->i_fop
= &f2fs_dir_operations
;
185 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
186 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_HIGH_ZERO
);
187 } else if (S_ISLNK(inode
->i_mode
)) {
188 inode
->i_op
= &f2fs_symlink_inode_operations
;
189 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
190 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
191 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
192 inode
->i_op
= &f2fs_special_inode_operations
;
193 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
198 unlock_new_inode(inode
);
199 trace_f2fs_iget(inode
);
204 trace_f2fs_iget_exit(inode
, ret
);
208 void update_inode(struct inode
*inode
, struct page
*node_page
)
210 struct f2fs_inode
*ri
;
212 f2fs_wait_on_page_writeback(node_page
, NODE
);
214 ri
= F2FS_INODE(node_page
);
216 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
217 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
218 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
219 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
220 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
221 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
222 ri
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
223 set_raw_extent(&F2FS_I(inode
)->ext
, &ri
->i_ext
);
224 set_raw_inline(F2FS_I(inode
), ri
);
226 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
227 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
228 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
229 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
230 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
231 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
232 ri
->i_current_depth
= cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
233 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
234 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
235 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
236 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
237 ri
->i_dir_level
= F2FS_I(inode
)->i_dir_level
;
239 __set_inode_rdev(inode
, ri
);
240 set_cold_node(inode
, node_page
);
241 set_page_dirty(node_page
);
243 clear_inode_flag(F2FS_I(inode
), FI_DIRTY_INODE
);
246 void update_inode_page(struct inode
*inode
)
248 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
249 struct page
*node_page
;
251 node_page
= get_node_page(sbi
, inode
->i_ino
);
252 if (IS_ERR(node_page
)) {
253 int err
= PTR_ERR(node_page
);
254 if (err
== -ENOMEM
) {
257 } else if (err
!= -ENOENT
) {
258 f2fs_stop_checkpoint(sbi
);
262 update_inode(inode
, node_page
);
263 f2fs_put_page(node_page
, 1);
266 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
268 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
270 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
271 inode
->i_ino
== F2FS_META_INO(sbi
))
274 if (!is_inode_flag_set(F2FS_I(inode
), FI_DIRTY_INODE
))
278 * We need to lock here to prevent from producing dirty node pages
279 * during the urgent cleaning time when runing out of free sections.
282 update_inode_page(inode
);
286 f2fs_balance_fs(sbi
);
292 * Called at the last iput() if i_nlink is zero
294 void f2fs_evict_inode(struct inode
*inode
)
296 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
297 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
299 /* some remained atomic pages should discarded */
300 if (f2fs_is_atomic_file(inode
))
301 commit_inmem_pages(inode
, true);
303 trace_f2fs_evict_inode(inode
);
304 truncate_inode_pages_final(&inode
->i_data
);
306 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
307 inode
->i_ino
== F2FS_META_INO(sbi
))
310 f2fs_bug_on(sbi
, get_dirty_pages(inode
));
311 remove_dirty_dir_inode(inode
);
313 if (inode
->i_nlink
|| is_bad_inode(inode
))
316 sb_start_intwrite(inode
->i_sb
);
317 set_inode_flag(F2FS_I(inode
), FI_NO_ALLOC
);
318 i_size_write(inode
, 0);
320 if (F2FS_HAS_BLOCKS(inode
))
321 f2fs_truncate(inode
);
324 remove_inode_page(inode
);
327 sb_end_intwrite(inode
->i_sb
);
329 stat_dec_inline_dir(inode
);
330 stat_dec_inline_inode(inode
);
331 invalidate_mapping_pages(NODE_MAPPING(sbi
), inode
->i_ino
, inode
->i_ino
);
333 invalidate_mapping_pages(NODE_MAPPING(sbi
), xnid
, xnid
);
334 if (is_inode_flag_set(F2FS_I(inode
), FI_APPEND_WRITE
))
335 add_dirty_inode(sbi
, inode
->i_ino
, APPEND_INO
);
336 if (is_inode_flag_set(F2FS_I(inode
), FI_UPDATE_WRITE
))
337 add_dirty_inode(sbi
, inode
->i_ino
, UPDATE_INO
);
342 /* caller should call f2fs_lock_op() */
343 void handle_failed_inode(struct inode
*inode
)
345 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
348 make_bad_inode(inode
);
349 unlock_new_inode(inode
);
351 i_size_write(inode
, 0);
352 if (F2FS_HAS_BLOCKS(inode
))
353 f2fs_truncate(inode
);
355 remove_inode_page(inode
);
357 clear_inode_flag(F2FS_I(inode
), FI_INLINE_DATA
);
358 clear_inode_flag(F2FS_I(inode
), FI_INLINE_DENTRY
);
359 alloc_nid_failed(sbi
, inode
->i_ino
);
362 /* iput will drop the inode object */