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>
19 #include <trace/events/f2fs.h>
21 void f2fs_set_inode_flags(struct inode
*inode
)
23 unsigned int flags
= F2FS_I(inode
)->i_flags
;
25 inode
->i_flags
&= ~(S_SYNC
| S_APPEND
| S_IMMUTABLE
|
26 S_NOATIME
| S_DIRSYNC
);
28 if (flags
& FS_SYNC_FL
)
29 inode
->i_flags
|= S_SYNC
;
30 if (flags
& FS_APPEND_FL
)
31 inode
->i_flags
|= S_APPEND
;
32 if (flags
& FS_IMMUTABLE_FL
)
33 inode
->i_flags
|= S_IMMUTABLE
;
34 if (flags
& FS_NOATIME_FL
)
35 inode
->i_flags
|= S_NOATIME
;
36 if (flags
& FS_DIRSYNC_FL
)
37 inode
->i_flags
|= S_DIRSYNC
;
40 static void __get_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
42 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
43 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
46 old_decode_dev(le32_to_cpu(ri
->i_addr
[0]));
49 new_decode_dev(le32_to_cpu(ri
->i_addr
[1]));
53 static void __set_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
55 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
56 if (old_valid_dev(inode
->i_rdev
)) {
58 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
63 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
69 static int do_read_inode(struct inode
*inode
)
71 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
72 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
73 struct page
*node_page
;
74 struct f2fs_inode
*ri
;
76 /* Check if ino is within scope */
77 if (check_nid_range(sbi
, inode
->i_ino
)) {
78 f2fs_msg(inode
->i_sb
, KERN_ERR
, "bad inode number: %lu",
79 (unsigned long) inode
->i_ino
);
83 node_page
= get_node_page(sbi
, inode
->i_ino
);
84 if (IS_ERR(node_page
))
85 return PTR_ERR(node_page
);
87 ri
= F2FS_INODE(node_page
);
89 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
90 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
91 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
92 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
93 inode
->i_size
= le64_to_cpu(ri
->i_size
);
94 inode
->i_blocks
= le64_to_cpu(ri
->i_blocks
);
96 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
97 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
98 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
99 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
100 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
101 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
102 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
104 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
105 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
106 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
108 fi
->i_advise
= ri
->i_advise
;
109 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
110 fi
->i_dir_level
= ri
->i_dir_level
;
112 get_extent_info(&fi
->ext
, ri
->i_ext
);
113 get_inline_info(fi
, ri
);
115 /* get rdev by using inline_info */
116 __get_inode_rdev(inode
, ri
);
118 f2fs_put_page(node_page
, 1);
122 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
124 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
128 inode
= iget_locked(sb
, ino
);
130 return ERR_PTR(-ENOMEM
);
132 if (!(inode
->i_state
& I_NEW
)) {
133 trace_f2fs_iget(inode
);
136 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
139 ret
= do_read_inode(inode
);
143 if (ino
== F2FS_NODE_INO(sbi
)) {
144 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
145 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
146 } else if (ino
== F2FS_META_INO(sbi
)) {
147 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
148 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
149 } else if (S_ISREG(inode
->i_mode
)) {
150 inode
->i_op
= &f2fs_file_inode_operations
;
151 inode
->i_fop
= &f2fs_file_operations
;
152 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
153 } else if (S_ISDIR(inode
->i_mode
)) {
154 inode
->i_op
= &f2fs_dir_inode_operations
;
155 inode
->i_fop
= &f2fs_dir_operations
;
156 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
157 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
158 } else if (S_ISLNK(inode
->i_mode
)) {
159 inode
->i_op
= &f2fs_symlink_inode_operations
;
160 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
161 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
162 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
163 inode
->i_op
= &f2fs_special_inode_operations
;
164 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
169 unlock_new_inode(inode
);
170 trace_f2fs_iget(inode
);
175 trace_f2fs_iget_exit(inode
, ret
);
179 void update_inode(struct inode
*inode
, struct page
*node_page
)
181 struct f2fs_inode
*ri
;
183 f2fs_wait_on_page_writeback(node_page
, NODE
);
185 ri
= F2FS_INODE(node_page
);
187 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
188 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
189 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
190 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
191 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
192 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
193 ri
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
194 set_raw_extent(&F2FS_I(inode
)->ext
, &ri
->i_ext
);
195 set_raw_inline(F2FS_I(inode
), ri
);
197 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
198 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
199 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
200 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
201 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
202 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
203 ri
->i_current_depth
= cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
204 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
205 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
206 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
207 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
208 ri
->i_dir_level
= F2FS_I(inode
)->i_dir_level
;
210 __set_inode_rdev(inode
, ri
);
211 set_cold_node(inode
, node_page
);
212 set_page_dirty(node_page
);
214 clear_inode_flag(F2FS_I(inode
), FI_DIRTY_INODE
);
217 void update_inode_page(struct inode
*inode
)
219 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
220 struct page
*node_page
;
222 node_page
= get_node_page(sbi
, inode
->i_ino
);
223 if (IS_ERR(node_page
)) {
224 int err
= PTR_ERR(node_page
);
225 if (err
== -ENOMEM
) {
228 } else if (err
!= -ENOENT
) {
229 f2fs_stop_checkpoint(sbi
);
233 update_inode(inode
, node_page
);
234 f2fs_put_page(node_page
, 1);
237 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
239 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
241 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
242 inode
->i_ino
== F2FS_META_INO(sbi
))
245 if (!is_inode_flag_set(F2FS_I(inode
), FI_DIRTY_INODE
))
249 * We need to lock here to prevent from producing dirty node pages
250 * during the urgent cleaning time when runing out of free sections.
253 update_inode_page(inode
);
257 f2fs_balance_fs(sbi
);
263 * Called at the last iput() if i_nlink is zero
265 void f2fs_evict_inode(struct inode
*inode
)
267 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
269 trace_f2fs_evict_inode(inode
);
270 truncate_inode_pages_final(&inode
->i_data
);
272 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
273 inode
->i_ino
== F2FS_META_INO(sbi
))
276 f2fs_bug_on(get_dirty_dents(inode
));
277 remove_dirty_dir_inode(inode
);
279 if (inode
->i_nlink
|| is_bad_inode(inode
))
282 sb_start_intwrite(inode
->i_sb
);
283 set_inode_flag(F2FS_I(inode
), FI_NO_ALLOC
);
284 i_size_write(inode
, 0);
286 if (F2FS_HAS_BLOCKS(inode
))
287 f2fs_truncate(inode
);
290 remove_inode_page(inode
);
291 stat_dec_inline_inode(inode
);
294 sb_end_intwrite(inode
->i_sb
);