]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/f2fs/inode.c
Merge remote-tracking branches 'asoc/topic/tlv320aic3x', 'asoc/topic/width', 'asoc...
[mirror_ubuntu-bionic-kernel.git] / fs / f2fs / inode.c
CommitLineData
0a8165d7 1/*
19f99cee
JK
2 * fs/f2fs/inode.c
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
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.
10 */
11#include <linux/fs.h>
12#include <linux/f2fs_fs.h>
13#include <linux/buffer_head.h>
14#include <linux/writeback.h>
8abfb36a 15#include <linux/bitops.h>
19f99cee
JK
16
17#include "f2fs.h"
18#include "node.h"
19
a2a4a7e4
NJ
20#include <trace/events/f2fs.h>
21
19f99cee
JK
22void f2fs_set_inode_flags(struct inode *inode)
23{
24 unsigned int flags = F2FS_I(inode)->i_flags;
8abfb36a 25 unsigned int new_fl = 0;
19f99cee
JK
26
27 if (flags & FS_SYNC_FL)
8abfb36a 28 new_fl |= S_SYNC;
19f99cee 29 if (flags & FS_APPEND_FL)
8abfb36a 30 new_fl |= S_APPEND;
19f99cee 31 if (flags & FS_IMMUTABLE_FL)
8abfb36a 32 new_fl |= S_IMMUTABLE;
19f99cee 33 if (flags & FS_NOATIME_FL)
8abfb36a 34 new_fl |= S_NOATIME;
19f99cee 35 if (flags & FS_DIRSYNC_FL)
8abfb36a
ZZ
36 new_fl |= S_DIRSYNC;
37 set_mask_bits(&inode->i_flags,
38 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC, new_fl);
19f99cee
JK
39}
40
3d1e3807
JK
41static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
42{
43 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
44 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
45 if (ri->i_addr[0])
6c311ec6
CF
46 inode->i_rdev =
47 old_decode_dev(le32_to_cpu(ri->i_addr[0]));
3d1e3807 48 else
6c311ec6
CF
49 inode->i_rdev =
50 new_decode_dev(le32_to_cpu(ri->i_addr[1]));
3d1e3807
JK
51 }
52}
53
54static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
55{
56 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
57 if (old_valid_dev(inode->i_rdev)) {
6c311ec6
CF
58 ri->i_addr[0] =
59 cpu_to_le32(old_encode_dev(inode->i_rdev));
3d1e3807
JK
60 ri->i_addr[1] = 0;
61 } else {
62 ri->i_addr[0] = 0;
6c311ec6
CF
63 ri->i_addr[1] =
64 cpu_to_le32(new_encode_dev(inode->i_rdev));
3d1e3807
JK
65 ri->i_addr[2] = 0;
66 }
67 }
68}
69
19f99cee
JK
70static int do_read_inode(struct inode *inode)
71{
72 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
73 struct f2fs_inode_info *fi = F2FS_I(inode);
74 struct page *node_page;
19f99cee
JK
75 struct f2fs_inode *ri;
76
77 /* Check if ino is within scope */
064e0823
NJ
78 if (check_nid_range(sbi, inode->i_ino)) {
79 f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
80 (unsigned long) inode->i_ino);
d6b7d4b3 81 WARN_ON(1);
064e0823
NJ
82 return -EINVAL;
83 }
19f99cee
JK
84
85 node_page = get_node_page(sbi, inode->i_ino);
86 if (IS_ERR(node_page))
87 return PTR_ERR(node_page);
88
58bfaf44 89 ri = F2FS_INODE(node_page);
19f99cee
JK
90
91 inode->i_mode = le16_to_cpu(ri->i_mode);
92 i_uid_write(inode, le32_to_cpu(ri->i_uid));
93 i_gid_write(inode, le32_to_cpu(ri->i_gid));
94 set_nlink(inode, le32_to_cpu(ri->i_links));
95 inode->i_size = le64_to_cpu(ri->i_size);
96 inode->i_blocks = le64_to_cpu(ri->i_blocks);
97
98 inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
99 inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
100 inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
101 inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
102 inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
103 inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
104 inode->i_generation = le32_to_cpu(ri->i_generation);
105
106 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
107 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
108 fi->i_flags = le32_to_cpu(ri->i_flags);
109 fi->flags = 0;
19f99cee 110 fi->i_advise = ri->i_advise;
6666e6aa 111 fi->i_pino = le32_to_cpu(ri->i_pino);
38431545 112 fi->i_dir_level = ri->i_dir_level;
3d1e3807 113
19f99cee 114 get_extent_info(&fi->ext, ri->i_ext);
444c580f 115 get_inline_info(fi, ri);
3d1e3807
JK
116
117 /* get rdev by using inline_info */
118 __get_inode_rdev(inode, ri);
119
19f99cee
JK
120 f2fs_put_page(node_page, 1);
121 return 0;
122}
123
124struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
125{
126 struct f2fs_sb_info *sbi = F2FS_SB(sb);
127 struct inode *inode;
a2a4a7e4 128 int ret = 0;
19f99cee
JK
129
130 inode = iget_locked(sb, ino);
131 if (!inode)
132 return ERR_PTR(-ENOMEM);
a2a4a7e4
NJ
133
134 if (!(inode->i_state & I_NEW)) {
135 trace_f2fs_iget(inode);
19f99cee 136 return inode;
a2a4a7e4 137 }
19f99cee
JK
138 if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
139 goto make_now;
140
141 ret = do_read_inode(inode);
142 if (ret)
143 goto bad_inode;
19f99cee
JK
144make_now:
145 if (ino == F2FS_NODE_INO(sbi)) {
146 inode->i_mapping->a_ops = &f2fs_node_aops;
147 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
148 } else if (ino == F2FS_META_INO(sbi)) {
149 inode->i_mapping->a_ops = &f2fs_meta_aops;
150 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
151 } else if (S_ISREG(inode->i_mode)) {
152 inode->i_op = &f2fs_file_inode_operations;
153 inode->i_fop = &f2fs_file_operations;
154 inode->i_mapping->a_ops = &f2fs_dblock_aops;
155 } else if (S_ISDIR(inode->i_mode)) {
156 inode->i_op = &f2fs_dir_inode_operations;
157 inode->i_fop = &f2fs_dir_operations;
158 inode->i_mapping->a_ops = &f2fs_dblock_aops;
6f85b352 159 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
19f99cee
JK
160 } else if (S_ISLNK(inode->i_mode)) {
161 inode->i_op = &f2fs_symlink_inode_operations;
162 inode->i_mapping->a_ops = &f2fs_dblock_aops;
163 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
164 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
165 inode->i_op = &f2fs_special_inode_operations;
166 init_special_inode(inode, inode->i_mode, inode->i_rdev);
167 } else {
168 ret = -EIO;
169 goto bad_inode;
170 }
171 unlock_new_inode(inode);
a2a4a7e4 172 trace_f2fs_iget(inode);
19f99cee
JK
173 return inode;
174
175bad_inode:
176 iget_failed(inode);
a2a4a7e4 177 trace_f2fs_iget_exit(inode, ret);
19f99cee
JK
178 return ERR_PTR(ret);
179}
180
181void update_inode(struct inode *inode, struct page *node_page)
182{
19f99cee
JK
183 struct f2fs_inode *ri;
184
5514f0aa 185 f2fs_wait_on_page_writeback(node_page, NODE);
19f99cee 186
58bfaf44 187 ri = F2FS_INODE(node_page);
19f99cee
JK
188
189 ri->i_mode = cpu_to_le16(inode->i_mode);
190 ri->i_advise = F2FS_I(inode)->i_advise;
191 ri->i_uid = cpu_to_le32(i_uid_read(inode));
192 ri->i_gid = cpu_to_le32(i_gid_read(inode));
193 ri->i_links = cpu_to_le32(inode->i_nlink);
194 ri->i_size = cpu_to_le64(i_size_read(inode));
195 ri->i_blocks = cpu_to_le64(inode->i_blocks);
196 set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);
444c580f 197 set_raw_inline(F2FS_I(inode), ri);
19f99cee
JK
198
199 ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
200 ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
201 ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
202 ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
203 ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
204 ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
205 ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
206 ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
207 ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
6666e6aa 208 ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
19f99cee 209 ri->i_generation = cpu_to_le32(inode->i_generation);
38431545 210 ri->i_dir_level = F2FS_I(inode)->i_dir_level;
7d79e75f 211
3d1e3807 212 __set_inode_rdev(inode, ri);
398b1ac5 213 set_cold_node(inode, node_page);
19f99cee 214 set_page_dirty(node_page);
3d1e3807 215
b3783873 216 clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
19f99cee
JK
217}
218
744602cf 219void update_inode_page(struct inode *inode)
19f99cee
JK
220{
221 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
222 struct page *node_page;
744602cf 223retry:
19f99cee 224 node_page = get_node_page(sbi, inode->i_ino);
744602cf
JK
225 if (IS_ERR(node_page)) {
226 int err = PTR_ERR(node_page);
227 if (err == -ENOMEM) {
228 cond_resched();
229 goto retry;
230 } else if (err != -ENOENT) {
231 f2fs_stop_checkpoint(sbi);
232 }
233 return;
234 }
19f99cee
JK
235 update_inode(inode, node_page);
236 f2fs_put_page(node_page, 1);
19f99cee
JK
237}
238
39936837
JK
239int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
240{
241 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
39936837
JK
242
243 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
244 inode->i_ino == F2FS_META_INO(sbi))
245 return 0;
246
b3783873
JK
247 if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))
248 return 0;
249
39936837
JK
250 /*
251 * We need to lock here to prevent from producing dirty node pages
252 * during the urgent cleaning time when runing out of free sections.
253 */
e479556b 254 f2fs_lock_op(sbi);
744602cf 255 update_inode_page(inode);
e479556b 256 f2fs_unlock_op(sbi);
92c4342f
JX
257
258 if (wbc)
259 f2fs_balance_fs(sbi);
260
744602cf 261 return 0;
39936837
JK
262}
263
0a8165d7 264/*
19f99cee
JK
265 * Called at the last iput() if i_nlink is zero
266 */
267void f2fs_evict_inode(struct inode *inode)
268{
269 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
270
a2a4a7e4 271 trace_f2fs_evict_inode(inode);
91b0abe3 272 truncate_inode_pages_final(&inode->i_data);
19f99cee
JK
273
274 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
275 inode->i_ino == F2FS_META_INO(sbi))
276 goto no_delete;
277
f8b2c1f9 278 f2fs_bug_on(get_dirty_dents(inode));
19f99cee
JK
279 remove_dirty_dir_inode(inode);
280
281 if (inode->i_nlink || is_bad_inode(inode))
282 goto no_delete;
283
d6212a5f 284 sb_start_intwrite(inode->i_sb);
19f99cee
JK
285 set_inode_flag(F2FS_I(inode), FI_NO_ALLOC);
286 i_size_write(inode, 0);
287
288 if (F2FS_HAS_BLOCKS(inode))
289 f2fs_truncate(inode);
290
e479556b 291 f2fs_lock_op(sbi);
19f99cee 292 remove_inode_page(inode);
0dbdc2ae 293 stat_dec_inline_inode(inode);
e479556b 294 f2fs_unlock_op(sbi);
39936837 295
d6212a5f 296 sb_end_intwrite(inode->i_sb);
19f99cee
JK
297no_delete:
298 clear_inode(inode);
8198899b 299 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
19f99cee 300}