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 void f2fs_set_inode_flags(struct inode
*inode
)
21 unsigned int flags
= F2FS_I(inode
)->i_flags
;
23 inode
->i_flags
&= ~(S_SYNC
| S_APPEND
| S_IMMUTABLE
|
24 S_NOATIME
| S_DIRSYNC
);
26 if (flags
& FS_SYNC_FL
)
27 inode
->i_flags
|= S_SYNC
;
28 if (flags
& FS_APPEND_FL
)
29 inode
->i_flags
|= S_APPEND
;
30 if (flags
& FS_IMMUTABLE_FL
)
31 inode
->i_flags
|= S_IMMUTABLE
;
32 if (flags
& FS_NOATIME_FL
)
33 inode
->i_flags
|= S_NOATIME
;
34 if (flags
& FS_DIRSYNC_FL
)
35 inode
->i_flags
|= S_DIRSYNC
;
38 static int do_read_inode(struct inode
*inode
)
40 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
41 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
42 struct page
*node_page
;
44 struct f2fs_inode
*ri
;
46 /* Check if ino is within scope */
47 if (check_nid_range(sbi
, inode
->i_ino
)) {
48 f2fs_msg(inode
->i_sb
, KERN_ERR
, "bad inode number: %lu",
49 (unsigned long) inode
->i_ino
);
53 node_page
= get_node_page(sbi
, inode
->i_ino
);
54 if (IS_ERR(node_page
))
55 return PTR_ERR(node_page
);
57 rn
= page_address(node_page
);
60 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
61 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
62 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
63 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
64 inode
->i_size
= le64_to_cpu(ri
->i_size
);
65 inode
->i_blocks
= le64_to_cpu(ri
->i_blocks
);
67 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
68 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
69 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
70 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
71 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
72 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
73 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
75 inode
->i_rdev
= old_decode_dev(le32_to_cpu(ri
->i_addr
[0]));
77 inode
->i_rdev
= new_decode_dev(le32_to_cpu(ri
->i_addr
[1]));
79 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
80 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
81 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
83 fi
->i_advise
= ri
->i_advise
;
84 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
85 get_extent_info(&fi
->ext
, ri
->i_ext
);
86 f2fs_put_page(node_page
, 1);
90 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
92 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
96 inode
= iget_locked(sb
, ino
);
98 return ERR_PTR(-ENOMEM
);
99 if (!(inode
->i_state
& I_NEW
))
101 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
104 ret
= do_read_inode(inode
);
108 if (!sbi
->por_doing
&& inode
->i_nlink
== 0) {
114 if (ino
== F2FS_NODE_INO(sbi
)) {
115 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
116 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
117 } else if (ino
== F2FS_META_INO(sbi
)) {
118 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
119 mapping_set_gfp_mask(inode
->i_mapping
, GFP_F2FS_ZERO
);
120 } else if (S_ISREG(inode
->i_mode
)) {
121 inode
->i_op
= &f2fs_file_inode_operations
;
122 inode
->i_fop
= &f2fs_file_operations
;
123 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
124 } else if (S_ISDIR(inode
->i_mode
)) {
125 inode
->i_op
= &f2fs_dir_inode_operations
;
126 inode
->i_fop
= &f2fs_dir_operations
;
127 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
128 mapping_set_gfp_mask(inode
->i_mapping
, GFP_HIGHUSER_MOVABLE
|
130 } else if (S_ISLNK(inode
->i_mode
)) {
131 inode
->i_op
= &f2fs_symlink_inode_operations
;
132 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
133 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
134 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
135 inode
->i_op
= &f2fs_special_inode_operations
;
136 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
141 unlock_new_inode(inode
);
150 void update_inode(struct inode
*inode
, struct page
*node_page
)
152 struct f2fs_node
*rn
;
153 struct f2fs_inode
*ri
;
155 wait_on_page_writeback(node_page
);
157 rn
= page_address(node_page
);
160 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
161 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
162 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
163 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
164 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
165 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
166 ri
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
167 set_raw_extent(&F2FS_I(inode
)->ext
, &ri
->i_ext
);
169 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
170 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
171 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
172 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
173 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
174 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
175 ri
->i_current_depth
= cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
176 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
177 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
178 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
179 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
181 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
182 if (old_valid_dev(inode
->i_rdev
)) {
184 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
189 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
194 set_cold_node(inode
, node_page
);
195 set_page_dirty(node_page
);
198 int update_inode_page(struct inode
*inode
)
200 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
201 struct page
*node_page
;
203 node_page
= get_node_page(sbi
, inode
->i_ino
);
204 if (IS_ERR(node_page
))
205 return PTR_ERR(node_page
);
207 update_inode(inode
, node_page
);
208 f2fs_put_page(node_page
, 1);
212 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
214 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
217 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
218 inode
->i_ino
== F2FS_META_INO(sbi
))
222 f2fs_balance_fs(sbi
);
225 * We need to lock here to prevent from producing dirty node pages
226 * during the urgent cleaning time when runing out of free sections.
228 ilock
= mutex_lock_op(sbi
);
229 ret
= update_inode_page(inode
);
230 mutex_unlock_op(sbi
, ilock
);
235 * Called at the last iput() if i_nlink is zero
237 void f2fs_evict_inode(struct inode
*inode
)
239 struct f2fs_sb_info
*sbi
= F2FS_SB(inode
->i_sb
);
242 truncate_inode_pages(&inode
->i_data
, 0);
244 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
245 inode
->i_ino
== F2FS_META_INO(sbi
))
248 BUG_ON(atomic_read(&F2FS_I(inode
)->dirty_dents
));
249 remove_dirty_dir_inode(inode
);
251 if (inode
->i_nlink
|| is_bad_inode(inode
))
254 sb_start_intwrite(inode
->i_sb
);
255 set_inode_flag(F2FS_I(inode
), FI_NO_ALLOC
);
256 i_size_write(inode
, 0);
258 if (F2FS_HAS_BLOCKS(inode
))
259 f2fs_truncate(inode
);
261 ilock
= mutex_lock_op(sbi
);
262 remove_inode_page(inode
);
263 mutex_unlock_op(sbi
, ilock
);
265 sb_end_intwrite(inode
->i_sb
);