Blame view
fs/f2fs/inode.c
11.1 KB
0a8165d7c
|
1 |
/* |
19f99cee2
|
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
* fs/f2fs/inode.c * * Copyright (c) 2012 Samsung Electronics Co., Ltd. * http://www.samsung.com/ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include <linux/fs.h> #include <linux/f2fs_fs.h> #include <linux/buffer_head.h> #include <linux/writeback.h> #include "f2fs.h" #include "node.h" |
a2a4a7e4a
|
18 |
#include <trace/events/f2fs.h> |
19f99cee2
|
19 20 21 |
void f2fs_set_inode_flags(struct inode *inode) { unsigned int flags = F2FS_I(inode)->i_flags; |
8abfb36ab
|
22 |
unsigned int new_fl = 0; |
19f99cee2
|
23 24 |
if (flags & FS_SYNC_FL) |
8abfb36ab
|
25 |
new_fl |= S_SYNC; |
19f99cee2
|
26 |
if (flags & FS_APPEND_FL) |
8abfb36ab
|
27 |
new_fl |= S_APPEND; |
19f99cee2
|
28 |
if (flags & FS_IMMUTABLE_FL) |
8abfb36ab
|
29 |
new_fl |= S_IMMUTABLE; |
19f99cee2
|
30 |
if (flags & FS_NOATIME_FL) |
8abfb36ab
|
31 |
new_fl |= S_NOATIME; |
19f99cee2
|
32 |
if (flags & FS_DIRSYNC_FL) |
8abfb36ab
|
33 |
new_fl |= S_DIRSYNC; |
6a6788576
|
34 35 |
inode_set_flags(inode, new_fl, S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); |
19f99cee2
|
36 |
} |
3d1e38073
|
37 38 39 40 41 |
static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri) { if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { if (ri->i_addr[0]) |
6c311ec6c
|
42 43 |
inode->i_rdev = old_decode_dev(le32_to_cpu(ri->i_addr[0])); |
3d1e38073
|
44 |
else |
6c311ec6c
|
45 46 |
inode->i_rdev = new_decode_dev(le32_to_cpu(ri->i_addr[1])); |
3d1e38073
|
47 48 |
} } |
3c6c2bebe
|
49 50 |
static bool __written_first_block(struct f2fs_inode *ri) { |
adad81ed4
|
51 52 53 |
block_t addr = le32_to_cpu(ri->i_addr[0]); if (addr != NEW_ADDR && addr != NULL_ADDR) |
3c6c2bebe
|
54 55 56 |
return true; return false; } |
3d1e38073
|
57 58 59 60 |
static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri) { if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { if (old_valid_dev(inode->i_rdev)) { |
6c311ec6c
|
61 62 |
ri->i_addr[0] = cpu_to_le32(old_encode_dev(inode->i_rdev)); |
3d1e38073
|
63 64 65 |
ri->i_addr[1] = 0; } else { ri->i_addr[0] = 0; |
6c311ec6c
|
66 67 |
ri->i_addr[1] = cpu_to_le32(new_encode_dev(inode->i_rdev)); |
3d1e38073
|
68 69 70 71 |
ri->i_addr[2] = 0; } } } |
9e5ba77fd
|
72 |
static void __recover_inline_status(struct inode *inode, struct page *ipage) |
b3d208f96
|
73 74 |
{ void *inline_data = inline_data_addr(ipage); |
9e5ba77fd
|
75 76 |
__le32 *start = inline_data; __le32 *end = start + MAX_INLINE_DATA / sizeof(__le32); |
b3d208f96
|
77 |
|
9e5ba77fd
|
78 79 |
while (start < end) { if (*start++) { |
fec1d6576
|
80 |
f2fs_wait_on_page_writeback(ipage, NODE, true); |
b3d208f96
|
81 |
|
9e5ba77fd
|
82 83 84 85 86 |
set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage)); set_page_dirty(ipage); return; } |
b3d208f96
|
87 |
} |
9e5ba77fd
|
88 |
return; |
b3d208f96
|
89 |
} |
19f99cee2
|
90 91 |
static int do_read_inode(struct inode *inode) { |
4081363fb
|
92 |
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); |
19f99cee2
|
93 94 |
struct f2fs_inode_info *fi = F2FS_I(inode); struct page *node_page; |
19f99cee2
|
95 96 97 |
struct f2fs_inode *ri; /* Check if ino is within scope */ |
064e08232
|
98 99 100 |
if (check_nid_range(sbi, inode->i_ino)) { f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu", (unsigned long) inode->i_ino); |
d6b7d4b31
|
101 |
WARN_ON(1); |
064e08232
|
102 103 |
return -EINVAL; } |
19f99cee2
|
104 105 106 107 |
node_page = get_node_page(sbi, inode->i_ino); if (IS_ERR(node_page)) return PTR_ERR(node_page); |
58bfaf44d
|
108 |
ri = F2FS_INODE(node_page); |
19f99cee2
|
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
inode->i_mode = le16_to_cpu(ri->i_mode); i_uid_write(inode, le32_to_cpu(ri->i_uid)); i_gid_write(inode, le32_to_cpu(ri->i_gid)); set_nlink(inode, le32_to_cpu(ri->i_links)); inode->i_size = le64_to_cpu(ri->i_size); inode->i_blocks = le64_to_cpu(ri->i_blocks); inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime); inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime); inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime); inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec); inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec); inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec); inode->i_generation = le32_to_cpu(ri->i_generation); fi->i_current_depth = le32_to_cpu(ri->i_current_depth); fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid); fi->i_flags = le32_to_cpu(ri->i_flags); fi->flags = 0; |
19f99cee2
|
129 |
fi->i_advise = ri->i_advise; |
6666e6aa9
|
130 |
fi->i_pino = le32_to_cpu(ri->i_pino); |
384315459
|
131 |
fi->i_dir_level = ri->i_dir_level; |
3d1e38073
|
132 |
|
ed3d12561
|
133 134 |
if (f2fs_init_extent_tree(inode, &ri->i_ext)) set_page_dirty(node_page); |
0c872e2de
|
135 |
|
444c580f7
|
136 |
get_inline_info(fi, ri); |
3d1e38073
|
137 |
|
b3d208f96
|
138 139 |
/* check data exist */ if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode)) |
9e5ba77fd
|
140 |
__recover_inline_status(inode, node_page); |
b3d208f96
|
141 |
|
3d1e38073
|
142 143 |
/* get rdev by using inline_info */ __get_inode_rdev(inode, ri); |
3c6c2bebe
|
144 145 |
if (__written_first_block(ri)) set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN); |
19f99cee2
|
146 |
f2fs_put_page(node_page, 1); |
9d1015dd4
|
147 |
|
d5e8f6c98
|
148 |
stat_inc_inline_xattr(inode); |
9d1015dd4
|
149 150 |
stat_inc_inline_inode(inode); stat_inc_inline_dir(inode); |
9e5ba77fd
|
151 |
return 0; |
19f99cee2
|
152 153 154 155 156 157 |
} struct inode *f2fs_iget(struct super_block *sb, unsigned long ino) { struct f2fs_sb_info *sbi = F2FS_SB(sb); struct inode *inode; |
a2a4a7e4a
|
158 |
int ret = 0; |
19f99cee2
|
159 160 161 162 |
inode = iget_locked(sb, ino); if (!inode) return ERR_PTR(-ENOMEM); |
a2a4a7e4a
|
163 164 165 |
if (!(inode->i_state & I_NEW)) { trace_f2fs_iget(inode); |
19f99cee2
|
166 |
return inode; |
a2a4a7e4a
|
167 |
} |
19f99cee2
|
168 169 170 171 172 173 |
if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi)) goto make_now; ret = do_read_inode(inode); if (ret) goto bad_inode; |
19f99cee2
|
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 |
make_now: if (ino == F2FS_NODE_INO(sbi)) { inode->i_mapping->a_ops = &f2fs_node_aops; mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); } else if (ino == F2FS_META_INO(sbi)) { inode->i_mapping->a_ops = &f2fs_meta_aops; mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO); } else if (S_ISREG(inode->i_mode)) { inode->i_op = &f2fs_file_inode_operations; inode->i_fop = &f2fs_file_operations; inode->i_mapping->a_ops = &f2fs_dblock_aops; } else if (S_ISDIR(inode->i_mode)) { inode->i_op = &f2fs_dir_inode_operations; inode->i_fop = &f2fs_dir_operations; inode->i_mapping->a_ops = &f2fs_dblock_aops; |
a78186ebe
|
189 |
mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO); |
19f99cee2
|
190 |
} else if (S_ISLNK(inode->i_mode)) { |
cbaf042a3
|
191 192 193 194 |
if (f2fs_encrypted_inode(inode)) inode->i_op = &f2fs_encrypted_symlink_inode_operations; else inode->i_op = &f2fs_symlink_inode_operations; |
21fc61c73
|
195 |
inode_nohighmem(inode); |
19f99cee2
|
196 197 198 199 200 201 202 203 204 205 |
inode->i_mapping->a_ops = &f2fs_dblock_aops; } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations; init_special_inode(inode, inode->i_mode, inode->i_rdev); } else { ret = -EIO; goto bad_inode; } unlock_new_inode(inode); |
a2a4a7e4a
|
206 |
trace_f2fs_iget(inode); |
19f99cee2
|
207 208 209 210 |
return inode; bad_inode: iget_failed(inode); |
a2a4a7e4a
|
211 |
trace_f2fs_iget_exit(inode, ret); |
19f99cee2
|
212 213 |
return ERR_PTR(ret); } |
12719ae14
|
214 |
int update_inode(struct inode *inode, struct page *node_page) |
19f99cee2
|
215 |
{ |
19f99cee2
|
216 |
struct f2fs_inode *ri; |
fec1d6576
|
217 |
f2fs_wait_on_page_writeback(node_page, NODE, true); |
19f99cee2
|
218 |
|
58bfaf44d
|
219 |
ri = F2FS_INODE(node_page); |
19f99cee2
|
220 221 222 223 224 225 226 227 |
ri->i_mode = cpu_to_le16(inode->i_mode); ri->i_advise = F2FS_I(inode)->i_advise; ri->i_uid = cpu_to_le32(i_uid_read(inode)); ri->i_gid = cpu_to_le32(i_gid_read(inode)); ri->i_links = cpu_to_le32(inode->i_nlink); ri->i_size = cpu_to_le64(i_size_read(inode)); ri->i_blocks = cpu_to_le64(inode->i_blocks); |
0c872e2de
|
228 |
|
3e72f7213
|
229 230 231 232 233 |
if (F2FS_I(inode)->extent_tree) set_raw_extent(&F2FS_I(inode)->extent_tree->largest, &ri->i_ext); else memset(&ri->i_ext, 0, sizeof(ri->i_ext)); |
444c580f7
|
234 |
set_raw_inline(F2FS_I(inode), ri); |
19f99cee2
|
235 236 237 238 239 240 241 242 243 244 |
ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec); ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth); ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid); ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags); |
6666e6aa9
|
245 |
ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino); |
19f99cee2
|
246 |
ri->i_generation = cpu_to_le32(inode->i_generation); |
384315459
|
247 |
ri->i_dir_level = F2FS_I(inode)->i_dir_level; |
7d79e75f6
|
248 |
|
3d1e38073
|
249 |
__set_inode_rdev(inode, ri); |
398b1ac5a
|
250 |
set_cold_node(inode, node_page); |
b3783873c
|
251 |
clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE); |
12719ae14
|
252 |
|
2049d4fcb
|
253 254 255 |
/* deleted inode */ if (inode->i_nlink == 0) clear_inline_node(node_page); |
12719ae14
|
256 |
return set_page_dirty(node_page); |
19f99cee2
|
257 |
} |
12719ae14
|
258 |
int update_inode_page(struct inode *inode) |
19f99cee2
|
259 |
{ |
4081363fb
|
260 |
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); |
19f99cee2
|
261 |
struct page *node_page; |
12719ae14
|
262 |
int ret = 0; |
744602cf4
|
263 |
retry: |
19f99cee2
|
264 |
node_page = get_node_page(sbi, inode->i_ino); |
744602cf4
|
265 266 267 268 269 270 |
if (IS_ERR(node_page)) { int err = PTR_ERR(node_page); if (err == -ENOMEM) { cond_resched(); goto retry; } else if (err != -ENOENT) { |
38f91ca8c
|
271 |
f2fs_stop_checkpoint(sbi, false); |
744602cf4
|
272 |
} |
12719ae14
|
273 |
return 0; |
744602cf4
|
274 |
} |
12719ae14
|
275 |
ret = update_inode(inode, node_page); |
19f99cee2
|
276 |
f2fs_put_page(node_page, 1); |
12719ae14
|
277 |
return ret; |
19f99cee2
|
278 |
} |
399368372
|
279 280 |
int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc) { |
4081363fb
|
281 |
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); |
399368372
|
282 283 284 285 |
if (inode->i_ino == F2FS_NODE_INO(sbi) || inode->i_ino == F2FS_META_INO(sbi)) return 0; |
b3783873c
|
286 287 |
if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE)) return 0; |
399368372
|
288 |
/* |
c5cd29d21
|
289 |
* We need to balance fs here to prevent from producing dirty node pages |
399368372
|
290 291 |
* during the urgent cleaning time when runing out of free sections. */ |
12719ae14
|
292 |
if (update_inode_page(inode)) |
2c4db1a6f
|
293 |
f2fs_balance_fs(sbi, true); |
744602cf4
|
294 |
return 0; |
399368372
|
295 |
} |
0a8165d7c
|
296 |
/* |
19f99cee2
|
297 298 299 300 |
* Called at the last iput() if i_nlink is zero */ void f2fs_evict_inode(struct inode *inode) { |
4081363fb
|
301 |
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); |
c9b63bd01
|
302 303 |
struct f2fs_inode_info *fi = F2FS_I(inode); nid_t xnid = fi->i_xattr_nid; |
13ec7297e
|
304 |
int err = 0; |
19f99cee2
|
305 |
|
88b88a667
|
306 |
/* some remained atomic pages should discarded */ |
1e84371ff
|
307 |
if (f2fs_is_atomic_file(inode)) |
29b96b547
|
308 |
drop_inmem_pages(inode); |
88b88a667
|
309 |
|
a2a4a7e4a
|
310 |
trace_f2fs_evict_inode(inode); |
91b0abe36
|
311 |
truncate_inode_pages_final(&inode->i_data); |
19f99cee2
|
312 313 314 |
if (inode->i_ino == F2FS_NODE_INO(sbi) || inode->i_ino == F2FS_META_INO(sbi)) |
dbf20cb25
|
315 |
goto out_clear; |
19f99cee2
|
316 |
|
a7ffdbe22
|
317 |
f2fs_bug_on(sbi, get_dirty_pages(inode)); |
c227f9127
|
318 |
remove_dirty_inode(inode); |
19f99cee2
|
319 |
|
3e72f7213
|
320 |
f2fs_destroy_extent_tree(inode); |
19f99cee2
|
321 322 |
if (inode->i_nlink || is_bad_inode(inode)) goto no_delete; |
d6212a5f1
|
323 |
sb_start_intwrite(inode->i_sb); |
c9b63bd01
|
324 |
set_inode_flag(fi, FI_NO_ALLOC); |
19f99cee2
|
325 |
i_size_write(inode, 0); |
4c0c29493
|
326 |
retry: |
19f99cee2
|
327 |
if (F2FS_HAS_BLOCKS(inode)) |
13ec7297e
|
328 |
err = f2fs_truncate(inode, true); |
19f99cee2
|
329 |
|
13ec7297e
|
330 331 332 333 334 |
if (!err) { f2fs_lock_op(sbi); err = remove_inode_page(inode); f2fs_unlock_op(sbi); } |
399368372
|
335 |
|
4c0c29493
|
336 337 338 339 340 |
/* give more chances, if ENOMEM case */ if (err == -ENOMEM) { err = 0; goto retry; } |
d6212a5f1
|
341 |
sb_end_intwrite(inode->i_sb); |
19f99cee2
|
342 |
no_delete: |
d5e8f6c98
|
343 |
stat_dec_inline_xattr(inode); |
3289c061c
|
344 |
stat_dec_inline_dir(inode); |
e7a2bf228
|
345 |
stat_dec_inline_inode(inode); |
0bdee4825
|
346 |
|
8198899b9
|
347 |
invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino); |
002a41cab
|
348 349 |
if (xnid) invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid); |
c9b63bd01
|
350 |
if (is_inode_flag_set(fi, FI_APPEND_WRITE)) |
a49324f12
|
351 |
add_ino_entry(sbi, inode->i_ino, APPEND_INO); |
c9b63bd01
|
352 |
if (is_inode_flag_set(fi, FI_UPDATE_WRITE)) |
a49324f12
|
353 |
add_ino_entry(sbi, inode->i_ino, UPDATE_INO); |
c9b63bd01
|
354 |
if (is_inode_flag_set(fi, FI_FREE_NID)) { |
221149c00
|
355 |
alloc_nid_failed(sbi, inode->i_ino); |
c9b63bd01
|
356 357 |
clear_inode_flag(fi, FI_FREE_NID); } |
29234b1d6
|
358 359 |
f2fs_bug_on(sbi, err && !exist_written_data(sbi, inode->i_ino, ORPHAN_INO)); |
dbf20cb25
|
360 |
out_clear: |
0b81d0779
|
361 |
fscrypt_put_encryption_info(inode, NULL); |
dbf20cb25
|
362 |
clear_inode(inode); |
19f99cee2
|
363 |
} |
44c161565
|
364 365 366 367 368 |
/* caller should call f2fs_lock_op() */ void handle_failed_inode(struct inode *inode) { struct f2fs_sb_info *sbi = F2FS_I_SB(inode); |
221149c00
|
369 |
struct node_info ni; |
44c161565
|
370 |
|
221149c00
|
371 |
/* don't make bad inode, since it becomes a regular file. */ |
44c161565
|
372 |
unlock_new_inode(inode); |
13ec7297e
|
373 |
/* |
13ec7297e
|
374 375 376 377 |
* Note: we should add inode to orphan list before f2fs_unlock_op() * so we can prevent losing this orphan when encoutering checkpoint * and following suddenly power-off. */ |
221149c00
|
378 379 380 381 382 383 384 385 386 |
get_node_info(sbi, inode->i_ino, &ni); if (ni.blk_addr != NULL_ADDR) { int err = acquire_orphan_inode(sbi); if (err) { set_sbi_flag(sbi, SBI_NEED_FSCK); f2fs_msg(sbi->sb, KERN_WARNING, "Too many orphan inodes, run fsck to fix."); } else { |
13ec7297e
|
387 |
add_orphan_inode(sbi, inode->i_ino); |
221149c00
|
388 389 390 391 |
} alloc_nid_done(sbi, inode->i_ino); } else { set_inode_flag(F2FS_I(inode), FI_FREE_NID); |
13ec7297e
|
392 |
} |
44c161565
|
393 |
|
44c161565
|
394 395 396 397 398 |
f2fs_unlock_op(sbi); /* iput will drop the inode object */ iput(inode); } |