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/backing-dev.h>
15 #include <linux/writeback.h>
20 #include <trace/events/f2fs.h>
22 void f2fs_mark_inode_dirty_sync(struct inode
*inode
, bool sync
)
24 if (f2fs_inode_dirtied(inode
, sync
))
27 mark_inode_dirty_sync(inode
);
30 void f2fs_set_inode_flags(struct inode
*inode
)
32 unsigned int flags
= F2FS_I(inode
)->i_flags
;
33 unsigned int new_fl
= 0;
35 if (flags
& FS_SYNC_FL
)
37 if (flags
& FS_APPEND_FL
)
39 if (flags
& FS_IMMUTABLE_FL
)
40 new_fl
|= S_IMMUTABLE
;
41 if (flags
& FS_NOATIME_FL
)
43 if (flags
& FS_DIRSYNC_FL
)
45 inode_set_flags(inode
, new_fl
,
46 S_SYNC
|S_APPEND
|S_IMMUTABLE
|S_NOATIME
|S_DIRSYNC
);
47 f2fs_mark_inode_dirty_sync(inode
, false);
50 static void __get_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
52 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
53 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
56 old_decode_dev(le32_to_cpu(ri
->i_addr
[0]));
59 new_decode_dev(le32_to_cpu(ri
->i_addr
[1]));
63 static bool __written_first_block(struct f2fs_inode
*ri
)
65 block_t addr
= le32_to_cpu(ri
->i_addr
[0]);
67 if (addr
!= NEW_ADDR
&& addr
!= NULL_ADDR
)
72 static void __set_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
74 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
75 if (old_valid_dev(inode
->i_rdev
)) {
77 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
82 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
88 static void __recover_inline_status(struct inode
*inode
, struct page
*ipage
)
90 void *inline_data
= inline_data_addr(ipage
);
91 __le32
*start
= inline_data
;
92 __le32
*end
= start
+ MAX_INLINE_DATA
/ sizeof(__le32
);
96 f2fs_wait_on_page_writeback(ipage
, NODE
, true);
98 set_inode_flag(inode
, FI_DATA_EXIST
);
99 set_raw_inline(inode
, F2FS_INODE(ipage
));
100 set_page_dirty(ipage
);
107 static int do_read_inode(struct inode
*inode
)
109 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
110 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
111 struct page
*node_page
;
112 struct f2fs_inode
*ri
;
114 /* Check if ino is within scope */
115 if (check_nid_range(sbi
, inode
->i_ino
)) {
116 f2fs_msg(inode
->i_sb
, KERN_ERR
, "bad inode number: %lu",
117 (unsigned long) inode
->i_ino
);
122 node_page
= get_node_page(sbi
, inode
->i_ino
);
123 if (IS_ERR(node_page
))
124 return PTR_ERR(node_page
);
126 ri
= F2FS_INODE(node_page
);
128 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
129 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
130 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
131 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
132 inode
->i_size
= le64_to_cpu(ri
->i_size
);
133 inode
->i_blocks
= le64_to_cpu(ri
->i_blocks
);
135 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
136 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
137 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
138 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
139 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
140 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
141 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
143 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
144 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
145 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
147 fi
->i_advise
= ri
->i_advise
;
148 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
149 fi
->i_dir_level
= ri
->i_dir_level
;
151 if (f2fs_init_extent_tree(inode
, &ri
->i_ext
))
152 set_page_dirty(node_page
);
154 get_inline_info(inode
, ri
);
156 /* check data exist */
157 if (f2fs_has_inline_data(inode
) && !f2fs_exist_data(inode
))
158 __recover_inline_status(inode
, node_page
);
160 /* get rdev by using inline_info */
161 __get_inode_rdev(inode
, ri
);
163 if (__written_first_block(ri
))
164 set_inode_flag(inode
, FI_FIRST_BLOCK_WRITTEN
);
166 if (!need_inode_block_update(sbi
, inode
->i_ino
))
167 fi
->last_disk_size
= inode
->i_size
;
169 f2fs_put_page(node_page
, 1);
171 stat_inc_inline_xattr(inode
);
172 stat_inc_inline_inode(inode
);
173 stat_inc_inline_dir(inode
);
178 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
180 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
184 inode
= iget_locked(sb
, ino
);
186 return ERR_PTR(-ENOMEM
);
188 if (!(inode
->i_state
& I_NEW
)) {
189 trace_f2fs_iget(inode
);
192 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
195 ret
= do_read_inode(inode
);
199 if (ino
== F2FS_NODE_INO(sbi
)) {
200 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
201 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
202 } else if (ino
== F2FS_META_INO(sbi
)) {
203 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
204 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
205 } else if (S_ISREG(inode
->i_mode
)) {
206 inode
->i_op
= &f2fs_file_inode_operations
;
207 inode
->i_fop
= &f2fs_file_operations
;
208 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
209 } else if (S_ISDIR(inode
->i_mode
)) {
210 inode
->i_op
= &f2fs_dir_inode_operations
;
211 inode
->i_fop
= &f2fs_dir_operations
;
212 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
213 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_HIGH_ZERO
);
214 } else if (S_ISLNK(inode
->i_mode
)) {
215 if (f2fs_encrypted_inode(inode
))
216 inode
->i_op
= &f2fs_encrypted_symlink_inode_operations
;
218 inode
->i_op
= &f2fs_symlink_inode_operations
;
219 inode_nohighmem(inode
);
220 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
221 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
222 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
223 inode
->i_op
= &f2fs_special_inode_operations
;
224 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
229 unlock_new_inode(inode
);
230 trace_f2fs_iget(inode
);
235 trace_f2fs_iget_exit(inode
, ret
);
239 struct inode
*f2fs_iget_retry(struct super_block
*sb
, unsigned long ino
)
243 inode
= f2fs_iget(sb
, ino
);
245 if (PTR_ERR(inode
) == -ENOMEM
) {
246 congestion_wait(BLK_RW_ASYNC
, HZ
/50);
253 int update_inode(struct inode
*inode
, struct page
*node_page
)
255 struct f2fs_inode
*ri
;
256 struct extent_tree
*et
= F2FS_I(inode
)->extent_tree
;
258 f2fs_inode_synced(inode
);
260 f2fs_wait_on_page_writeback(node_page
, NODE
, true);
262 ri
= F2FS_INODE(node_page
);
264 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
265 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
266 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
267 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
268 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
269 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
270 ri
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
273 read_lock(&et
->lock
);
274 set_raw_extent(&et
->largest
, &ri
->i_ext
);
275 read_unlock(&et
->lock
);
277 memset(&ri
->i_ext
, 0, sizeof(ri
->i_ext
));
279 set_raw_inline(inode
, ri
);
281 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
282 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
283 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
284 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
285 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
286 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
287 ri
->i_current_depth
= cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
288 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
289 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
290 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
291 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
292 ri
->i_dir_level
= F2FS_I(inode
)->i_dir_level
;
294 __set_inode_rdev(inode
, ri
);
295 set_cold_node(inode
, node_page
);
298 if (inode
->i_nlink
== 0)
299 clear_inline_node(node_page
);
301 return set_page_dirty(node_page
);
304 int update_inode_page(struct inode
*inode
)
306 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
307 struct page
*node_page
;
310 node_page
= get_node_page(sbi
, inode
->i_ino
);
311 if (IS_ERR(node_page
)) {
312 int err
= PTR_ERR(node_page
);
313 if (err
== -ENOMEM
) {
316 } else if (err
!= -ENOENT
) {
317 f2fs_stop_checkpoint(sbi
, false);
321 ret
= update_inode(inode
, node_page
);
322 f2fs_put_page(node_page
, 1);
326 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
328 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
330 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
331 inode
->i_ino
== F2FS_META_INO(sbi
))
334 if (!is_inode_flag_set(inode
, FI_DIRTY_INODE
))
338 * We need to balance fs here to prevent from producing dirty node pages
339 * during the urgent cleaning time when runing out of free sections.
341 if (update_inode_page(inode
) && wbc
&& wbc
->nr_to_write
)
342 f2fs_balance_fs(sbi
, true);
347 * Called at the last iput() if i_nlink is zero
349 void f2fs_evict_inode(struct inode
*inode
)
351 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
352 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
355 /* some remained atomic pages should discarded */
356 if (f2fs_is_atomic_file(inode
))
357 drop_inmem_pages(inode
);
359 trace_f2fs_evict_inode(inode
);
360 truncate_inode_pages_final(&inode
->i_data
);
362 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
363 inode
->i_ino
== F2FS_META_INO(sbi
))
366 f2fs_bug_on(sbi
, get_dirty_pages(inode
));
367 remove_dirty_inode(inode
);
369 f2fs_destroy_extent_tree(inode
);
371 if (inode
->i_nlink
|| is_bad_inode(inode
))
374 #ifdef CONFIG_F2FS_FAULT_INJECTION
375 if (time_to_inject(sbi
, FAULT_EVICT_INODE
)) {
376 f2fs_show_injection_info(FAULT_EVICT_INODE
);
381 remove_ino_entry(sbi
, inode
->i_ino
, APPEND_INO
);
382 remove_ino_entry(sbi
, inode
->i_ino
, UPDATE_INO
);
384 sb_start_intwrite(inode
->i_sb
);
385 set_inode_flag(inode
, FI_NO_ALLOC
);
386 i_size_write(inode
, 0);
388 if (F2FS_HAS_BLOCKS(inode
))
389 err
= f2fs_truncate(inode
);
393 err
= remove_inode_page(inode
);
399 /* give more chances, if ENOMEM case */
400 if (err
== -ENOMEM
) {
406 update_inode_page(inode
);
407 sb_end_intwrite(inode
->i_sb
);
409 stat_dec_inline_xattr(inode
);
410 stat_dec_inline_dir(inode
);
411 stat_dec_inline_inode(inode
);
413 invalidate_mapping_pages(NODE_MAPPING(sbi
), inode
->i_ino
, inode
->i_ino
);
415 invalidate_mapping_pages(NODE_MAPPING(sbi
), xnid
, xnid
);
416 if (inode
->i_nlink
) {
417 if (is_inode_flag_set(inode
, FI_APPEND_WRITE
))
418 add_ino_entry(sbi
, inode
->i_ino
, APPEND_INO
);
419 if (is_inode_flag_set(inode
, FI_UPDATE_WRITE
))
420 add_ino_entry(sbi
, inode
->i_ino
, UPDATE_INO
);
422 if (is_inode_flag_set(inode
, FI_FREE_NID
)) {
423 alloc_nid_failed(sbi
, inode
->i_ino
);
424 clear_inode_flag(inode
, FI_FREE_NID
);
426 f2fs_bug_on(sbi
, err
&&
427 !exist_written_data(sbi
, inode
->i_ino
, ORPHAN_INO
));
429 fscrypt_put_encryption_info(inode
, NULL
);
433 /* caller should call f2fs_lock_op() */
434 void handle_failed_inode(struct inode
*inode
)
436 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
440 * clear nlink of inode in order to release resource of inode
446 * we must call this to avoid inode being remained as dirty, resulting
447 * in a panic when flushing dirty inodes in gdirty_list.
449 update_inode_page(inode
);
450 f2fs_inode_synced(inode
);
452 /* don't make bad inode, since it becomes a regular file. */
453 unlock_new_inode(inode
);
456 * Note: we should add inode to orphan list before f2fs_unlock_op()
457 * so we can prevent losing this orphan when encoutering checkpoint
458 * and following suddenly power-off.
460 get_node_info(sbi
, inode
->i_ino
, &ni
);
462 if (ni
.blk_addr
!= NULL_ADDR
) {
463 int err
= acquire_orphan_inode(sbi
);
465 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
466 f2fs_msg(sbi
->sb
, KERN_WARNING
,
467 "Too many orphan inodes, run fsck to fix.");
469 add_orphan_inode(inode
);
471 alloc_nid_done(sbi
, inode
->i_ino
);
473 set_inode_flag(inode
, FI_FREE_NID
);
478 /* iput will drop the inode object */