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 int __recover_inline_status(struct inode
*inode
, struct page
*ipage
)
72 void *inline_data
= inline_data_addr(ipage
);
73 struct f2fs_inode
*ri
;
76 zbuf
= kzalloc(MAX_INLINE_DATA
, GFP_NOFS
);
80 if (!memcmp(zbuf
, inline_data
, MAX_INLINE_DATA
)) {
86 f2fs_wait_on_page_writeback(ipage
, NODE
);
87 set_inode_flag(F2FS_I(inode
), FI_DATA_EXIST
);
89 ri
= F2FS_INODE(ipage
);
90 set_raw_inline(F2FS_I(inode
), ri
);
91 set_page_dirty(ipage
);
95 static int do_read_inode(struct inode
*inode
)
97 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
98 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
99 struct page
*node_page
;
100 struct f2fs_inode
*ri
;
103 /* Check if ino is within scope */
104 if (check_nid_range(sbi
, inode
->i_ino
)) {
105 f2fs_msg(inode
->i_sb
, KERN_ERR
, "bad inode number: %lu",
106 (unsigned long) inode
->i_ino
);
111 node_page
= get_node_page(sbi
, inode
->i_ino
);
112 if (IS_ERR(node_page
))
113 return PTR_ERR(node_page
);
115 ri
= F2FS_INODE(node_page
);
117 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
118 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
119 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
120 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
121 inode
->i_size
= le64_to_cpu(ri
->i_size
);
122 inode
->i_blocks
= le64_to_cpu(ri
->i_blocks
);
124 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
125 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
126 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
127 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
128 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
129 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
130 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
132 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
133 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
134 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
136 fi
->i_advise
= ri
->i_advise
;
137 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
138 fi
->i_dir_level
= ri
->i_dir_level
;
140 get_extent_info(&fi
->ext
, ri
->i_ext
);
141 get_inline_info(fi
, ri
);
143 /* check data exist */
144 if (f2fs_has_inline_data(inode
) && !f2fs_exist_data(inode
))
145 err
= __recover_inline_status(inode
, node_page
);
147 /* get rdev by using inline_info */
148 __get_inode_rdev(inode
, ri
);
150 f2fs_put_page(node_page
, 1);
152 stat_inc_inline_inode(inode
);
153 stat_inc_inline_dir(inode
);
158 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
160 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
164 inode
= iget_locked(sb
, ino
);
166 return ERR_PTR(-ENOMEM
);
168 if (!(inode
->i_state
& I_NEW
)) {
169 trace_f2fs_iget(inode
);
172 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
175 ret
= do_read_inode(inode
);
179 if (ino
== F2FS_NODE_INO(sbi
)) {
180 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
181 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
182 } else if (ino
== F2FS_META_INO(sbi
)) {
183 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
184 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
185 } else if (S_ISREG(inode
->i_mode
)) {
186 inode
->i_op
= &f2fs_file_inode_operations
;
187 inode
->i_fop
= &f2fs_file_operations
;
188 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
189 } else if (S_ISDIR(inode
->i_mode
)) {
190 inode
->i_op
= &f2fs_dir_inode_operations
;
191 inode
->i_fop
= &f2fs_dir_operations
;
192 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
193 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_HIGH_ZERO
);
194 } else if (S_ISLNK(inode
->i_mode
)) {
195 inode
->i_op
= &f2fs_symlink_inode_operations
;
196 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
197 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
198 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
199 inode
->i_op
= &f2fs_special_inode_operations
;
200 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
205 unlock_new_inode(inode
);
206 trace_f2fs_iget(inode
);
211 trace_f2fs_iget_exit(inode
, ret
);
215 void update_inode(struct inode
*inode
, struct page
*node_page
)
217 struct f2fs_inode
*ri
;
219 f2fs_wait_on_page_writeback(node_page
, NODE
);
221 ri
= F2FS_INODE(node_page
);
223 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
224 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
225 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
226 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
227 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
228 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
229 ri
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
230 set_raw_extent(&F2FS_I(inode
)->ext
, &ri
->i_ext
);
231 set_raw_inline(F2FS_I(inode
), ri
);
233 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
234 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
235 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
236 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
237 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
238 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
239 ri
->i_current_depth
= cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
240 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
241 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
242 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
243 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
244 ri
->i_dir_level
= F2FS_I(inode
)->i_dir_level
;
246 __set_inode_rdev(inode
, ri
);
247 set_cold_node(inode
, node_page
);
248 set_page_dirty(node_page
);
250 clear_inode_flag(F2FS_I(inode
), FI_DIRTY_INODE
);
253 void update_inode_page(struct inode
*inode
)
255 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
256 struct page
*node_page
;
258 node_page
= get_node_page(sbi
, inode
->i_ino
);
259 if (IS_ERR(node_page
)) {
260 int err
= PTR_ERR(node_page
);
261 if (err
== -ENOMEM
) {
264 } else if (err
!= -ENOENT
) {
265 f2fs_stop_checkpoint(sbi
);
269 update_inode(inode
, node_page
);
270 f2fs_put_page(node_page
, 1);
273 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
275 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
277 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
278 inode
->i_ino
== F2FS_META_INO(sbi
))
281 if (!is_inode_flag_set(F2FS_I(inode
), FI_DIRTY_INODE
))
285 * We need to lock here to prevent from producing dirty node pages
286 * during the urgent cleaning time when runing out of free sections.
289 update_inode_page(inode
);
293 f2fs_balance_fs(sbi
);
299 * Called at the last iput() if i_nlink is zero
301 void f2fs_evict_inode(struct inode
*inode
)
303 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
304 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
306 /* some remained atomic pages should discarded */
307 if (f2fs_is_atomic_file(inode
) || f2fs_is_volatile_file(inode
))
308 commit_inmem_pages(inode
, true);
310 trace_f2fs_evict_inode(inode
);
311 truncate_inode_pages_final(&inode
->i_data
);
313 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
314 inode
->i_ino
== F2FS_META_INO(sbi
))
317 f2fs_bug_on(sbi
, get_dirty_pages(inode
));
318 remove_dirty_dir_inode(inode
);
320 if (inode
->i_nlink
|| is_bad_inode(inode
))
323 sb_start_intwrite(inode
->i_sb
);
324 set_inode_flag(F2FS_I(inode
), FI_NO_ALLOC
);
325 i_size_write(inode
, 0);
327 if (F2FS_HAS_BLOCKS(inode
))
328 f2fs_truncate(inode
);
331 remove_inode_page(inode
);
334 sb_end_intwrite(inode
->i_sb
);
336 stat_dec_inline_dir(inode
);
337 stat_dec_inline_inode(inode
);
338 invalidate_mapping_pages(NODE_MAPPING(sbi
), inode
->i_ino
, inode
->i_ino
);
340 invalidate_mapping_pages(NODE_MAPPING(sbi
), xnid
, xnid
);
341 if (is_inode_flag_set(F2FS_I(inode
), FI_APPEND_WRITE
))
342 add_dirty_inode(sbi
, inode
->i_ino
, APPEND_INO
);
343 if (is_inode_flag_set(F2FS_I(inode
), FI_UPDATE_WRITE
))
344 add_dirty_inode(sbi
, inode
->i_ino
, UPDATE_INO
);
349 /* caller should call f2fs_lock_op() */
350 void handle_failed_inode(struct inode
*inode
)
352 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
355 make_bad_inode(inode
);
356 unlock_new_inode(inode
);
358 i_size_write(inode
, 0);
359 if (F2FS_HAS_BLOCKS(inode
))
360 f2fs_truncate(inode
);
362 remove_inode_page(inode
);
364 clear_inode_flag(F2FS_I(inode
), FI_INLINE_DATA
);
365 clear_inode_flag(F2FS_I(inode
), FI_INLINE_DENTRY
);
366 alloc_nid_failed(sbi
, inode
->i_ino
);
369 /* iput will drop the inode object */