1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * fs/f2fs/inode.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8 #include <linux/fs.h>
9 #include <linux/f2fs_fs.h>
10 #include <linux/writeback.h>
11 #include <linux/sched/mm.h>
12 #include <linux/swap.h>
13 #include <linux/lz4.h>
14 #include <linux/zstd.h>
15 #include <linux/fserror.h>
16
17 #include "f2fs.h"
18 #include "node.h"
19 #include "segment.h"
20 #include "xattr.h"
21
22 #include <trace/events/f2fs.h>
23
24 #ifdef CONFIG_F2FS_FS_COMPRESSION
25 extern const struct address_space_operations f2fs_compress_aops;
26 #endif
27
28 #define NUM_PREALLOC_EVICT_INODE_WORK 8
29
30 static struct kmem_cache *evict_inode_work_cache;
31 static mempool_t *evict_inode_work_pool;
32
33 struct evict_inode_work {
34 struct work_struct work;
35 struct f2fs_sb_info *sbi;
36 nid_t ino;
37 unsigned int add_ino_entry_bits;
38 };
39
f2fs_mark_inode_dirty_sync(struct inode * inode,bool sync)40 void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
41 {
42 if (is_inode_flag_set(inode, FI_NEW_INODE))
43 return;
44
45 if (f2fs_readonly(F2FS_I_SB(inode)->sb))
46 return;
47
48 if (f2fs_inode_dirtied(inode, sync))
49 return;
50
51 /* only atomic file w/ FI_ATOMIC_COMMITTED can be set vfs dirty */
52 if (f2fs_is_atomic_file(inode) &&
53 !is_inode_flag_set(inode, FI_ATOMIC_COMMITTED))
54 return;
55
56 mark_inode_dirty_sync(inode);
57 }
58
f2fs_set_inode_flags(struct inode * inode)59 void f2fs_set_inode_flags(struct inode *inode)
60 {
61 unsigned int flags = F2FS_I(inode)->i_flags;
62 unsigned int new_fl = 0;
63
64 if (flags & F2FS_SYNC_FL)
65 new_fl |= S_SYNC;
66 if (flags & F2FS_APPEND_FL)
67 new_fl |= S_APPEND;
68 if (flags & F2FS_IMMUTABLE_FL)
69 new_fl |= S_IMMUTABLE;
70 if (flags & F2FS_NOATIME_FL)
71 new_fl |= S_NOATIME;
72 if (flags & F2FS_DIRSYNC_FL)
73 new_fl |= S_DIRSYNC;
74 if (file_is_encrypt(inode))
75 new_fl |= S_ENCRYPTED;
76 if (file_is_verity(inode))
77 new_fl |= S_VERITY;
78 if (flags & F2FS_CASEFOLD_FL)
79 new_fl |= S_CASEFOLD;
80 inode_set_flags(inode, new_fl,
81 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|
82 S_ENCRYPTED|S_VERITY|S_CASEFOLD);
83 }
84
__get_inode_rdev(struct inode * inode,struct folio * node_folio)85 static void __get_inode_rdev(struct inode *inode, struct folio *node_folio)
86 {
87 __le32 *addr = get_dnode_addr(inode, node_folio);
88
89 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
90 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
91 if (addr[0])
92 inode->i_rdev = old_decode_dev(le32_to_cpu(addr[0]));
93 else
94 inode->i_rdev = new_decode_dev(le32_to_cpu(addr[1]));
95 }
96 }
97
__set_inode_rdev(struct inode * inode,struct folio * node_folio)98 static void __set_inode_rdev(struct inode *inode, struct folio *node_folio)
99 {
100 __le32 *addr = get_dnode_addr(inode, node_folio);
101
102 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
103 if (old_valid_dev(inode->i_rdev)) {
104 addr[0] = cpu_to_le32(old_encode_dev(inode->i_rdev));
105 addr[1] = 0;
106 } else {
107 addr[0] = 0;
108 addr[1] = cpu_to_le32(new_encode_dev(inode->i_rdev));
109 addr[2] = 0;
110 }
111 }
112 }
113
__recover_inline_status(struct inode * inode,struct folio * ifolio)114 static void __recover_inline_status(struct inode *inode, struct folio *ifolio)
115 {
116 void *inline_data = inline_data_addr(inode, ifolio);
117 __le32 *start = inline_data;
118 __le32 *end = start + MAX_INLINE_DATA(inode) / sizeof(__le32);
119
120 while (start < end) {
121 if (*start++) {
122 f2fs_folio_wait_writeback(ifolio, NODE, true, true);
123
124 set_inode_flag(inode, FI_DATA_EXIST);
125 set_raw_inline(inode, F2FS_INODE(ifolio));
126 folio_mark_dirty(ifolio);
127 return;
128 }
129 }
130 return;
131 }
132
133 static
f2fs_enable_inode_chksum(struct f2fs_sb_info * sbi,struct folio * folio)134 bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)
135 {
136 struct f2fs_inode *ri = &F2FS_NODE(folio)->i;
137
138 if (!f2fs_sb_has_inode_chksum(sbi))
139 return false;
140
141 if (!IS_INODE(folio) || !(ri->i_inline & F2FS_EXTRA_ATTR))
142 return false;
143
144 if (!F2FS_FITS_IN_INODE(ri, le16_to_cpu(ri->i_extra_isize),
145 i_inode_checksum))
146 return false;
147
148 return true;
149 }
150
f2fs_inode_chksum(struct f2fs_sb_info * sbi,struct folio * folio)151 static __u32 f2fs_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)
152 {
153 struct f2fs_node *node = F2FS_NODE(folio);
154 struct f2fs_inode *ri = &node->i;
155 __le32 ino = node->footer.ino;
156 __le32 gen = ri->i_generation;
157 __u32 chksum, chksum_seed;
158 __u32 dummy_cs = 0;
159 unsigned int offset = offsetof(struct f2fs_inode, i_inode_checksum);
160 unsigned int cs_size = sizeof(dummy_cs);
161
162 chksum = f2fs_chksum(sbi->s_chksum_seed, (__u8 *)&ino, sizeof(ino));
163 chksum_seed = f2fs_chksum(chksum, (__u8 *)&gen, sizeof(gen));
164
165 chksum = f2fs_chksum(chksum_seed, (__u8 *)ri, offset);
166 chksum = f2fs_chksum(chksum, (__u8 *)&dummy_cs, cs_size);
167 offset += cs_size;
168 chksum = f2fs_chksum(chksum, (__u8 *)ri + offset,
169 F2FS_BLKSIZE - offset);
170 return chksum;
171 }
172
f2fs_inode_chksum_verify(struct f2fs_sb_info * sbi,struct folio * folio)173 bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct folio *folio)
174 {
175 struct f2fs_inode *ri;
176 __u32 provided, calculated;
177
178 if (unlikely(is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN)))
179 return true;
180
181 #ifdef CONFIG_F2FS_CHECK_FS
182 if (!f2fs_enable_inode_chksum(sbi, folio))
183 #else
184 if (!f2fs_enable_inode_chksum(sbi, folio) ||
185 folio_test_dirty(folio) ||
186 folio_test_writeback(folio))
187 #endif
188 return true;
189
190 ri = &F2FS_NODE(folio)->i;
191 provided = le32_to_cpu(ri->i_inode_checksum);
192 calculated = f2fs_inode_chksum(sbi, folio);
193
194 if (provided != calculated)
195 f2fs_warn(sbi, "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
196 folio->index, ino_of_node(folio),
197 provided, calculated);
198
199 return provided == calculated;
200 }
201
f2fs_inode_chksum_set(struct f2fs_sb_info * sbi,struct folio * folio)202 void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct folio *folio)
203 {
204 struct f2fs_inode *ri = &F2FS_NODE(folio)->i;
205
206 if (!f2fs_enable_inode_chksum(sbi, folio))
207 return;
208
209 ri->i_inode_checksum = cpu_to_le32(f2fs_inode_chksum(sbi, folio));
210 }
211
sanity_check_compress_inode(struct inode * inode,struct f2fs_inode * ri)212 static bool sanity_check_compress_inode(struct inode *inode,
213 struct f2fs_inode *ri)
214 {
215 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
216 unsigned char clevel;
217
218 if (ri->i_compress_algorithm >= COMPRESS_MAX) {
219 f2fs_warn(sbi,
220 "%s: inode (ino=%llx) has unsupported compress algorithm: %u, run fsck to fix",
221 __func__, inode->i_ino, ri->i_compress_algorithm);
222 return false;
223 }
224 if (le64_to_cpu(ri->i_compr_blocks) >
225 SECTOR_TO_BLOCK(inode->i_blocks)) {
226 f2fs_warn(sbi,
227 "%s: inode (ino=%llx) has inconsistent i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
228 __func__, inode->i_ino, le64_to_cpu(ri->i_compr_blocks),
229 SECTOR_TO_BLOCK(inode->i_blocks));
230 return false;
231 }
232 if (ri->i_log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
233 ri->i_log_cluster_size > MAX_COMPRESS_LOG_SIZE) {
234 f2fs_warn(sbi,
235 "%s: inode (ino=%llx) has unsupported log cluster size: %u, run fsck to fix",
236 __func__, inode->i_ino, ri->i_log_cluster_size);
237 return false;
238 }
239
240 clevel = le16_to_cpu(ri->i_compress_flag) >>
241 COMPRESS_LEVEL_OFFSET;
242 switch (ri->i_compress_algorithm) {
243 case COMPRESS_LZO:
244 #ifdef CONFIG_F2FS_FS_LZO
245 if (clevel)
246 goto err_level;
247 #endif
248 break;
249 case COMPRESS_LZORLE:
250 #ifdef CONFIG_F2FS_FS_LZORLE
251 if (clevel)
252 goto err_level;
253 #endif
254 break;
255 case COMPRESS_LZ4:
256 #ifdef CONFIG_F2FS_FS_LZ4
257 #ifdef CONFIG_F2FS_FS_LZ4HC
258 if (clevel &&
259 (clevel < LZ4HC_MIN_CLEVEL || clevel > LZ4HC_MAX_CLEVEL))
260 goto err_level;
261 #else
262 if (clevel)
263 goto err_level;
264 #endif
265 #endif
266 break;
267 case COMPRESS_ZSTD:
268 #ifdef CONFIG_F2FS_FS_ZSTD
269 if (clevel < zstd_min_clevel() || clevel > zstd_max_clevel())
270 goto err_level;
271 #endif
272 break;
273 default:
274 goto err_level;
275 }
276
277 return true;
278 err_level:
279 f2fs_warn(sbi, "%s: inode (ino=%llx) has unsupported compress level: %u, run fsck to fix",
280 __func__, inode->i_ino, clevel);
281 return false;
282 }
283
sanity_check_inode(struct inode * inode,struct folio * node_folio)284 static bool sanity_check_inode(struct inode *inode, struct folio *node_folio)
285 {
286 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
287 struct f2fs_inode_info *fi = F2FS_I(inode);
288 struct f2fs_inode *ri = F2FS_INODE(node_folio);
289 unsigned long long iblocks;
290
291 iblocks = le64_to_cpu(F2FS_INODE(node_folio)->i_blocks);
292 if (!iblocks) {
293 f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%llx iblocks=%llu, run fsck to fix.",
294 __func__, inode->i_ino, iblocks);
295 return false;
296 }
297
298 if (ino_of_node(node_folio) != nid_of_node(node_folio)) {
299 f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%llx, ino,nid: [%u, %u] run fsck to fix.",
300 __func__, inode->i_ino,
301 ino_of_node(node_folio), nid_of_node(node_folio));
302 return false;
303 }
304
305 if (ino_of_node(node_folio) == fi->i_xattr_nid) {
306 f2fs_warn(sbi, "%s: corrupted inode i_ino=%llx, xnid=%x, run fsck to fix.",
307 __func__, inode->i_ino, fi->i_xattr_nid);
308 return false;
309 }
310
311 if (S_ISDIR(inode->i_mode) && unlikely(inode->i_nlink == 1)) {
312 f2fs_warn(sbi, "%s: directory inode (ino=%llx) has a single i_nlink",
313 __func__, inode->i_ino);
314 return false;
315 }
316
317 if (f2fs_has_extra_attr(inode)) {
318 if (!f2fs_sb_has_extra_attr(sbi)) {
319 f2fs_warn(sbi, "%s: inode (ino=%llx) is with extra_attr, but extra_attr feature is off",
320 __func__, inode->i_ino);
321 return false;
322 }
323 if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
324 fi->i_extra_isize < F2FS_MIN_EXTRA_ATTR_SIZE ||
325 fi->i_extra_isize % sizeof(__le32)) {
326 f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_extra_isize: %d, max: %zu",
327 __func__, inode->i_ino, fi->i_extra_isize,
328 F2FS_TOTAL_EXTRA_ATTR_SIZE);
329 return false;
330 }
331 if (f2fs_sb_has_compression(sbi) &&
332 fi->i_flags & F2FS_COMPR_FL &&
333 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
334 i_compress_flag)) {
335 if (!sanity_check_compress_inode(inode, ri))
336 return false;
337 }
338 }
339
340 if (f2fs_sb_has_flexible_inline_xattr(sbi) &&
341 (fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE ||
342 (f2fs_has_inline_xattr(inode) &&
343 fi->i_inline_xattr_size < MIN_INLINE_XATTR_SIZE))) {
344 f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_inline_xattr_size: %d, min: %zu, max: %lu",
345 __func__, inode->i_ino, fi->i_inline_xattr_size,
346 MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
347 return false;
348 }
349
350 if (!f2fs_sb_has_extra_attr(sbi)) {
351 if (f2fs_sb_has_project_quota(sbi)) {
352 f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
353 __func__, inode->i_ino, F2FS_FEATURE_PRJQUOTA);
354 return false;
355 }
356 if (f2fs_sb_has_inode_chksum(sbi)) {
357 f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
358 __func__, inode->i_ino, F2FS_FEATURE_INODE_CHKSUM);
359 return false;
360 }
361 if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
362 f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
363 __func__, inode->i_ino, F2FS_FEATURE_FLEXIBLE_INLINE_XATTR);
364 return false;
365 }
366 if (f2fs_sb_has_inode_crtime(sbi)) {
367 f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
368 __func__, inode->i_ino, F2FS_FEATURE_INODE_CRTIME);
369 return false;
370 }
371 if (f2fs_sb_has_compression(sbi)) {
372 f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
373 __func__, inode->i_ino, F2FS_FEATURE_COMPRESSION);
374 return false;
375 }
376 }
377
378 if (f2fs_sanity_check_inline_data(inode, node_folio)) {
379 f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_data, run fsck to fix",
380 __func__, inode->i_ino, inode->i_mode);
381 return false;
382 }
383
384 if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
385 f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_dentry, run fsck to fix",
386 __func__, inode->i_ino, inode->i_mode);
387 return false;
388 }
389
390 if ((fi->i_flags & F2FS_CASEFOLD_FL) && !f2fs_sb_has_casefold(sbi)) {
391 f2fs_warn(sbi, "%s: inode (ino=%llx) has casefold flag, but casefold feature is off",
392 __func__, inode->i_ino);
393 return false;
394 }
395
396 if (fi->i_xattr_nid && f2fs_check_nid_range(sbi, fi->i_xattr_nid)) {
397 f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_xattr_nid: %u, run fsck to fix.",
398 __func__, inode->i_ino, fi->i_xattr_nid);
399 return false;
400 }
401
402 if (IS_DEVICE_ALIASING(inode)) {
403 if (!f2fs_sb_has_device_alias(sbi)) {
404 f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but the feature is off",
405 __func__, inode->i_ino);
406 return false;
407 }
408 if (!f2fs_is_pinned_file(inode)) {
409 f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but is not pinned",
410 __func__, inode->i_ino);
411 return false;
412 }
413 }
414
415 return true;
416 }
417
init_idisk_time(struct inode * inode)418 static void init_idisk_time(struct inode *inode)
419 {
420 struct f2fs_inode_info *fi = F2FS_I(inode);
421
422 fi->i_disk_time[0] = inode_get_atime(inode);
423 fi->i_disk_time[1] = inode_get_ctime(inode);
424 fi->i_disk_time[2] = inode_get_mtime(inode);
425 }
426
do_read_inode(struct inode * inode)427 static int do_read_inode(struct inode *inode)
428 {
429 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
430 struct f2fs_inode_info *fi = F2FS_I(inode);
431 struct folio *node_folio;
432 struct f2fs_inode *ri;
433 projid_t i_projid;
434
435 /* Check if ino is within scope */
436 if (f2fs_check_nid_range(sbi, inode->i_ino))
437 return -EINVAL;
438
439 node_folio = f2fs_get_inode_folio(sbi, inode->i_ino);
440 if (IS_ERR(node_folio))
441 return PTR_ERR(node_folio);
442
443 ri = F2FS_INODE(node_folio);
444
445 inode->i_mode = le16_to_cpu(ri->i_mode);
446 i_uid_write(inode, le32_to_cpu(ri->i_uid));
447 i_gid_write(inode, le32_to_cpu(ri->i_gid));
448 set_nlink(inode, le32_to_cpu(ri->i_links));
449 inode->i_size = le64_to_cpu(ri->i_size);
450 inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);
451
452 inode_set_atime(inode, le64_to_cpu(ri->i_atime),
453 le32_to_cpu(ri->i_atime_nsec));
454 inode_set_ctime(inode, le64_to_cpu(ri->i_ctime),
455 le32_to_cpu(ri->i_ctime_nsec));
456 inode_set_mtime(inode, le64_to_cpu(ri->i_mtime),
457 le32_to_cpu(ri->i_mtime_nsec));
458 inode->i_generation = le32_to_cpu(ri->i_generation);
459 if (S_ISDIR(inode->i_mode))
460 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
461 else if (S_ISREG(inode->i_mode))
462 fi->i_gc_failures = le16_to_cpu(ri->i_gc_failures);
463 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
464 fi->i_flags = le32_to_cpu(ri->i_flags);
465 if (S_ISREG(inode->i_mode))
466 fi->i_flags &= ~F2FS_PROJINHERIT_FL;
467 bitmap_zero(fi->flags, FI_MAX);
468 fi->i_advise = ri->i_advise;
469 fi->i_pino = le32_to_cpu(ri->i_pino);
470 fi->i_dir_level = ri->i_dir_level;
471
472 get_inline_info(inode, ri);
473
474 fi->i_extra_isize = f2fs_has_extra_attr(inode) ?
475 le16_to_cpu(ri->i_extra_isize) : 0;
476
477 if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
478 fi->i_inline_xattr_size = le16_to_cpu(ri->i_inline_xattr_size);
479 } else if (f2fs_has_inline_xattr(inode) ||
480 f2fs_has_inline_dentry(inode)) {
481 fi->i_inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
482 } else {
483
484 /*
485 * Previous inline data or directory always reserved 200 bytes
486 * in inode layout, even if inline_xattr is disabled. In order
487 * to keep inline_dentry's structure for backward compatibility,
488 * we get the space back only from inline_data.
489 */
490 fi->i_inline_xattr_size = 0;
491 }
492
493 if (!sanity_check_inode(inode, node_folio)) {
494 f2fs_folio_put(node_folio, true);
495 set_sbi_flag(sbi, SBI_NEED_FSCK);
496 f2fs_handle_error(sbi, ERROR_CORRUPTED_INODE);
497 fserror_report_file_metadata(inode, -EFSCORRUPTED, GFP_NOFS);
498 return -EFSCORRUPTED;
499 }
500
501 /* check data exist */
502 if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
503 __recover_inline_status(inode, node_folio);
504
505 /* try to recover cold bit for non-dir inode */
506 if (!S_ISDIR(inode->i_mode) && !is_cold_node(node_folio)) {
507 f2fs_folio_wait_writeback(node_folio, NODE, true, true);
508 set_cold_node(node_folio, false);
509 folio_mark_dirty(node_folio);
510 }
511
512 /* get rdev by using inline_info */
513 __get_inode_rdev(inode, node_folio);
514
515 if (!f2fs_need_inode_block_update(sbi, inode->i_ino))
516 fi->last_disk_size = inode->i_size;
517
518 if (fi->i_flags & F2FS_PROJINHERIT_FL)
519 set_inode_flag(inode, FI_PROJ_INHERIT);
520
521 if (f2fs_has_extra_attr(inode) && f2fs_sb_has_project_quota(sbi) &&
522 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid))
523 i_projid = (projid_t)le32_to_cpu(ri->i_projid);
524 else
525 i_projid = F2FS_DEF_PROJID;
526 fi->i_projid = make_kprojid(&init_user_ns, i_projid);
527
528 if (f2fs_has_extra_attr(inode) && f2fs_sb_has_inode_crtime(sbi) &&
529 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
530 fi->i_crtime.tv_sec = le64_to_cpu(ri->i_crtime);
531 fi->i_crtime.tv_nsec = le32_to_cpu(ri->i_crtime_nsec);
532 }
533
534 if (f2fs_has_extra_attr(inode) && f2fs_sb_has_compression(sbi) &&
535 (fi->i_flags & F2FS_COMPR_FL)) {
536 if (F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
537 i_compress_flag)) {
538 unsigned short compress_flag;
539
540 atomic_set(&fi->i_compr_blocks,
541 le64_to_cpu(ri->i_compr_blocks));
542 fi->i_compress_algorithm = ri->i_compress_algorithm;
543 fi->i_log_cluster_size = ri->i_log_cluster_size;
544 compress_flag = le16_to_cpu(ri->i_compress_flag);
545 fi->i_compress_level = compress_flag >>
546 COMPRESS_LEVEL_OFFSET;
547 fi->i_compress_flag = compress_flag &
548 GENMASK(COMPRESS_LEVEL_OFFSET - 1, 0);
549 fi->i_cluster_size = BIT(fi->i_log_cluster_size);
550 set_inode_flag(inode, FI_COMPRESSED_FILE);
551 }
552 }
553
554 init_idisk_time(inode);
555
556 if (!sanity_check_extent_cache(inode, node_folio)) {
557 f2fs_folio_put(node_folio, true);
558 f2fs_handle_error(sbi, ERROR_CORRUPTED_INODE);
559 fserror_report_file_metadata(inode, -EFSCORRUPTED, GFP_NOFS);
560 return -EFSCORRUPTED;
561 }
562
563 /* Need all the flag bits */
564 f2fs_init_read_extent_tree(inode, node_folio);
565 f2fs_init_age_extent_tree(inode);
566
567 f2fs_folio_put(node_folio, true);
568
569 stat_inc_inline_xattr(inode);
570 stat_inc_inline_inode(inode);
571 stat_inc_inline_dir(inode);
572 stat_inc_compr_inode(inode);
573 stat_add_compr_blocks(inode, atomic_read(&fi->i_compr_blocks));
574
575 return 0;
576 }
577
is_meta_ino(struct f2fs_sb_info * sbi,unsigned int ino)578 static bool is_meta_ino(struct f2fs_sb_info *sbi, unsigned int ino)
579 {
580 if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
581 return true;
582 #ifdef CONFIG_F2FS_FS_COMPRESSION
583 if (test_opt(sbi, COMPRESS_CACHE) && ino == F2FS_COMPRESS_INO(sbi))
584 return true;
585 #endif
586 return false;
587 }
588
f2fs_iget(struct super_block * sb,unsigned long ino)589 struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
590 {
591 struct f2fs_sb_info *sbi = F2FS_SB(sb);
592 struct inode *inode;
593 int ret = 0;
594
595 inode = iget_locked(sb, ino);
596 if (!inode)
597 return ERR_PTR(-ENOMEM);
598
599 if (!(inode_state_read_once(inode) & I_NEW)) {
600 if (is_meta_ino(sbi, ino)) {
601 f2fs_err(sbi, "inaccessible inode: %lu, run fsck to repair", ino);
602 set_sbi_flag(sbi, SBI_NEED_FSCK);
603 ret = -EFSCORRUPTED;
604 trace_f2fs_iget_exit(inode, ret);
605 iput(inode);
606 f2fs_handle_error(sbi, ERROR_CORRUPTED_INODE);
607 fserror_report_file_metadata(inode, ret, GFP_NOFS);
608 return ERR_PTR(ret);
609 }
610
611 trace_f2fs_iget(inode);
612 return inode;
613 }
614
615 if (is_meta_ino(sbi, ino))
616 goto make_now;
617
618 ret = do_read_inode(inode);
619 if (ret)
620 goto bad_inode;
621 make_now:
622 f2fs_set_inode_flags(inode);
623
624 if (ino == F2FS_NODE_INO(sbi)) {
625 inode->i_mapping->a_ops = &f2fs_node_aops;
626 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
627 } else if (ino == F2FS_META_INO(sbi)) {
628 inode->i_mapping->a_ops = &f2fs_meta_aops;
629 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
630 } else if (ino == F2FS_COMPRESS_INO(sbi)) {
631 #ifdef CONFIG_F2FS_FS_COMPRESSION
632 inode->i_mapping->a_ops = &f2fs_compress_aops;
633 /*
634 * generic_error_remove_folio only truncates pages of regular
635 * inode
636 */
637 inode->i_mode |= S_IFREG;
638 #endif
639 mapping_set_gfp_mask(inode->i_mapping,
640 GFP_NOFS | __GFP_HIGHMEM | __GFP_MOVABLE);
641 } else if (S_ISREG(inode->i_mode)) {
642 inode->i_op = &f2fs_file_inode_operations;
643 inode->i_fop = &f2fs_file_operations;
644 inode->i_mapping->a_ops = &f2fs_dblock_aops;
645 if (IS_IMMUTABLE(inode) && !f2fs_compressed_file(inode) &&
646 !f2fs_quota_file(sbi, inode->i_ino))
647 mapping_set_folio_min_order(inode->i_mapping, 0);
648 } else if (S_ISDIR(inode->i_mode)) {
649 inode->i_op = &f2fs_dir_inode_operations;
650 inode->i_fop = &f2fs_dir_operations;
651 inode->i_mapping->a_ops = &f2fs_dblock_aops;
652 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
653
654 /* Let's prepare APPEND/UPDATE_INO before future access. */
655 flush_workqueue(sbi->evict_wq);
656 } else if (S_ISLNK(inode->i_mode)) {
657 if (file_is_encrypt(inode))
658 inode->i_op = &f2fs_encrypted_symlink_inode_operations;
659 else
660 inode->i_op = &f2fs_symlink_inode_operations;
661 inode_nohighmem(inode);
662 inode->i_mapping->a_ops = &f2fs_dblock_aops;
663 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
664 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
665 inode->i_op = &f2fs_special_inode_operations;
666 init_special_inode(inode, inode->i_mode, inode->i_rdev);
667 } else {
668 ret = -EIO;
669 goto bad_inode;
670 }
671
672 unlock_new_inode(inode);
673 trace_f2fs_iget(inode);
674 return inode;
675
676 bad_inode:
677 f2fs_inode_synced(inode);
678 iget_failed(inode);
679 trace_f2fs_iget_exit(inode, ret);
680 return ERR_PTR(ret);
681 }
682
f2fs_iget_retry(struct super_block * sb,unsigned long ino)683 struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino)
684 {
685 struct inode *inode;
686 retry:
687 inode = f2fs_iget(sb, ino);
688 if (IS_ERR(inode)) {
689 if (PTR_ERR(inode) == -ENOMEM) {
690 memalloc_retry_wait(GFP_NOFS);
691 goto retry;
692 }
693 }
694 return inode;
695 }
696
f2fs_update_inode(struct inode * inode,struct folio * node_folio)697 void f2fs_update_inode(struct inode *inode, struct folio *node_folio)
698 {
699 struct f2fs_inode_info *fi = F2FS_I(inode);
700 struct f2fs_inode *ri;
701 struct extent_tree *et = fi->extent_tree[EX_READ];
702
703 f2fs_folio_wait_writeback(node_folio, NODE, true, true);
704 folio_mark_dirty(node_folio);
705
706 f2fs_inode_synced(inode);
707
708 ri = F2FS_INODE(node_folio);
709
710 ri->i_mode = cpu_to_le16(inode->i_mode);
711 ri->i_advise = fi->i_advise;
712 ri->i_uid = cpu_to_le32(i_uid_read(inode));
713 ri->i_gid = cpu_to_le32(i_gid_read(inode));
714 ri->i_links = cpu_to_le32(inode->i_nlink);
715 ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(READ_ONCE(inode->i_blocks)) + 1);
716
717 if (!f2fs_is_atomic_file(inode) ||
718 is_inode_flag_set(inode, FI_ATOMIC_COMMITTED))
719 ri->i_size = cpu_to_le64(i_size_read(inode));
720
721 if (et) {
722 read_lock(&et->lock);
723 set_raw_read_extent(&et->largest, &ri->i_ext);
724 read_unlock(&et->lock);
725 } else {
726 memset(&ri->i_ext, 0, sizeof(ri->i_ext));
727 }
728 set_raw_inline(inode, ri);
729
730 ri->i_atime = cpu_to_le64(inode_get_atime_sec(inode));
731 ri->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
732 ri->i_mtime = cpu_to_le64(inode_get_mtime_sec(inode));
733 ri->i_atime_nsec = cpu_to_le32(inode_get_atime_nsec(inode));
734 ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
735 ri->i_mtime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
736 if (S_ISDIR(inode->i_mode))
737 ri->i_current_depth = cpu_to_le32(fi->i_current_depth);
738 else if (S_ISREG(inode->i_mode))
739 ri->i_gc_failures = cpu_to_le16(fi->i_gc_failures);
740 ri->i_xattr_nid = cpu_to_le32(fi->i_xattr_nid);
741 ri->i_flags = cpu_to_le32(fi->i_flags);
742 ri->i_pino = cpu_to_le32(fi->i_pino);
743 ri->i_generation = cpu_to_le32(inode->i_generation);
744 ri->i_dir_level = fi->i_dir_level;
745
746 if (f2fs_has_extra_attr(inode)) {
747 ri->i_extra_isize = cpu_to_le16(fi->i_extra_isize);
748
749 if (f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(inode)))
750 ri->i_inline_xattr_size =
751 cpu_to_le16(fi->i_inline_xattr_size);
752
753 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
754 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) {
755 projid_t i_projid;
756
757 i_projid = from_kprojid(&init_user_ns, fi->i_projid);
758 ri->i_projid = cpu_to_le32(i_projid);
759 }
760
761 if (f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
762 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
763 ri->i_crtime = cpu_to_le64(fi->i_crtime.tv_sec);
764 ri->i_crtime_nsec = cpu_to_le32(fi->i_crtime.tv_nsec);
765 }
766
767 if (f2fs_sb_has_compression(F2FS_I_SB(inode)) &&
768 F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
769 i_compress_flag)) {
770 unsigned short compress_flag;
771
772 ri->i_compr_blocks = cpu_to_le64(
773 atomic_read(&fi->i_compr_blocks));
774 ri->i_compress_algorithm = fi->i_compress_algorithm;
775 compress_flag = fi->i_compress_flag |
776 fi->i_compress_level <<
777 COMPRESS_LEVEL_OFFSET;
778 ri->i_compress_flag = cpu_to_le16(compress_flag);
779 ri->i_log_cluster_size = fi->i_log_cluster_size;
780 }
781 }
782
783 __set_inode_rdev(inode, node_folio);
784
785 /* deleted inode */
786 if (inode->i_nlink == 0)
787 folio_clear_f2fs_inline(node_folio);
788
789 init_idisk_time(inode);
790 #ifdef CONFIG_F2FS_CHECK_FS
791 f2fs_inode_chksum_set(F2FS_I_SB(inode), node_folio);
792 #endif
793 }
794
f2fs_update_inode_page(struct inode * inode)795 void f2fs_update_inode_page(struct inode *inode)
796 {
797 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
798 struct folio *node_folio;
799 int count = 0;
800 retry:
801 node_folio = f2fs_get_inode_folio(sbi, inode->i_ino);
802 if (IS_ERR(node_folio)) {
803 int err = PTR_ERR(node_folio);
804
805 /* The node block was truncated. */
806 if (err == -ENOENT)
807 return;
808
809 if (err == -EFSCORRUPTED)
810 goto stop_checkpoint;
811
812 if (err == -ENOMEM || ++count <= DEFAULT_RETRY_IO_COUNT)
813 goto retry;
814 stop_checkpoint:
815 fserror_report_file_metadata(inode, -EFSCORRUPTED, GFP_NOFS);
816 f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_UPDATE_INODE);
817 return;
818 }
819 f2fs_update_inode(inode, node_folio);
820 f2fs_folio_put(node_folio, true);
821 }
822
f2fs_write_inode(struct inode * inode,struct writeback_control * wbc)823 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
824 {
825 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
826
827 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
828 inode->i_ino == F2FS_META_INO(sbi))
829 return 0;
830
831 /*
832 * atime could be updated without dirtying f2fs inode in lazytime mode
833 */
834 if (f2fs_is_time_consistent(inode) &&
835 !is_inode_flag_set(inode, FI_DIRTY_INODE))
836 return 0;
837
838 /*
839 * no need to update inode page, ultimately f2fs_evict_inode() will
840 * clear dirty status of inode.
841 */
842 if (f2fs_cp_error(sbi))
843 return -EIO;
844
845 if (!f2fs_is_checkpoint_ready(sbi)) {
846 f2fs_mark_inode_dirty_sync(inode, true);
847 return -ENOSPC;
848 }
849
850 /*
851 * We need to balance fs here to prevent from producing dirty node pages
852 * during the urgent cleaning time when running out of free sections.
853 */
854 f2fs_update_inode_page(inode);
855 if (wbc && wbc->nr_to_write)
856 f2fs_balance_fs(sbi, true);
857 return 0;
858 }
859
f2fs_remove_donate_inode(struct inode * inode)860 void f2fs_remove_donate_inode(struct inode *inode)
861 {
862 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
863
864 if (list_empty(&F2FS_I(inode)->gdonate_list))
865 return;
866
867 spin_lock(&sbi->inode_lock[DONATE_INODE]);
868 list_del_init(&F2FS_I(inode)->gdonate_list);
869 sbi->donate_files--;
870 spin_unlock(&sbi->inode_lock[DONATE_INODE]);
871 }
872
f2fs_record_inode_state(struct f2fs_sb_info * sbi,nid_t ino,unsigned int bits)873 static void f2fs_record_inode_state(struct f2fs_sb_info *sbi, nid_t ino,
874 unsigned int bits)
875 {
876 if (bits & BIT(APPEND_INO))
877 f2fs_add_ino_entry(sbi, ino, APPEND_INO);
878 if (bits & BIT(UPDATE_INO))
879 f2fs_add_ino_entry(sbi, ino, UPDATE_INO);
880 }
881
f2fs_evict_inode_work(struct work_struct * work)882 static void f2fs_evict_inode_work(struct work_struct *work)
883 {
884 struct evict_inode_work *ew =
885 container_of(work, struct evict_inode_work, work);
886
887 f2fs_record_inode_state(ew->sbi, ew->ino, ew->add_ino_entry_bits);
888
889 mempool_free(ew, evict_inode_work_pool);
890 }
891
892 /*
893 * Return true, if we shouldn't go through post_evict_inode.
894 */
f2fs_pre_evict_inode(struct inode * inode)895 static bool f2fs_pre_evict_inode(struct inode *inode)
896 {
897 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
898 struct f2fs_inode_info *fi = F2FS_I(inode);
899
900 f2fs_abort_atomic_write(inode, true);
901
902 if (fi->cow_inode && f2fs_is_cow_file(fi->cow_inode)) {
903 struct inode *cow_inode = fi->cow_inode;
904
905 f2fs_down_write(&F2FS_I(cow_inode)->i_sem);
906 clear_inode_flag(cow_inode, FI_COW_FILE);
907 F2FS_I(cow_inode)->atomic_inode = NULL;
908 fi->cow_inode = NULL;
909 f2fs_up_write(&F2FS_I(cow_inode)->i_sem);
910
911 iput(cow_inode);
912 }
913
914 trace_f2fs_evict_inode(inode);
915 truncate_inode_pages_final(&inode->i_data);
916
917 if ((inode->i_nlink || is_bad_inode(inode)) &&
918 test_opt(sbi, COMPRESS_CACHE) && f2fs_compressed_file(inode))
919 f2fs_invalidate_compress_pages(sbi, inode->i_ino);
920
921 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
922 inode->i_ino == F2FS_META_INO(sbi) ||
923 inode->i_ino == F2FS_COMPRESS_INO(sbi))
924 return true;
925
926 f2fs_bug_on(sbi, get_dirty_pages(inode));
927 f2fs_remove_dirty_inode(inode);
928 f2fs_remove_donate_inode(inode);
929
930 if (!IS_DEVICE_ALIASING(inode))
931 f2fs_destroy_extent_tree(inode);
932
933 return false;
934 }
935
f2fs_delete_inode(struct inode * inode)936 static void f2fs_delete_inode(struct inode *inode)
937 {
938 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
939 bool freeze_protected = false;
940 struct f2fs_lock_context lc;
941 int err = 0;
942
943 if (f2fs_dquot_initialize(inode))
944 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
945
946 f2fs_remove_ino_entry(sbi, inode->i_ino, APPEND_INO);
947 f2fs_remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
948 f2fs_remove_ino_entry(sbi, inode->i_ino, FLUSH_INO);
949
950 if (!is_sbi_flag_set(sbi, SBI_IS_FREEZING)) {
951 sb_start_intwrite(inode->i_sb);
952 freeze_protected = true;
953 }
954 set_inode_flag(inode, FI_NO_ALLOC);
955 i_size_write(inode, 0);
956 retry:
957 if (F2FS_HAS_BLOCKS(inode))
958 err = f2fs_truncate(inode);
959
960 if (time_to_inject(sbi, FAULT_EVICT_INODE))
961 err = -EIO;
962
963 if (err)
964 goto error_check;
965
966 f2fs_lock_op(sbi, &lc);
967 err = f2fs_remove_inode_page(inode);
968 f2fs_unlock_op(sbi, &lc);
969
970 if (err == -ENOENT) {
971 err = 0;
972
973 /*
974 * in fuzzed image, another node may has the same
975 * block address as inode's, if it was truncated
976 * previously, truncation of inode node will fail.
977 */
978 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
979 f2fs_warn(F2FS_I_SB(inode),
980 "f2fs_evict_inode: inconsistent node id, ino:%llu",
981 inode->i_ino);
982 f2fs_inode_synced(inode);
983 set_sbi_flag(sbi, SBI_NEED_FSCK);
984 }
985 }
986 error_check:
987 /* give more chances, if ENOMEM case */
988 if (err == -ENOMEM) {
989 err = 0;
990 goto retry;
991 }
992
993 if (IS_DEVICE_ALIASING(inode))
994 f2fs_destroy_extent_tree(inode);
995
996 if (!err)
997 goto unfreeze_out;
998
999 f2fs_update_inode_page(inode);
1000
1001 if (dquot_initialize_needed(inode))
1002 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
1003
1004 /*
1005 * If both f2fs_truncate() and f2fs_update_inode_page() failed
1006 * due to fuzzed corrupted inode, call f2fs_inode_synced() to
1007 * avoid triggering later f2fs_bug_on().
1008 */
1009 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1010 f2fs_warn(sbi,
1011 "f2fs_evict_inode: inode is dirty, ino:%llu",
1012 inode->i_ino);
1013 f2fs_inode_synced(inode);
1014 set_sbi_flag(sbi, SBI_NEED_FSCK);
1015 }
1016 unfreeze_out:
1017 if (freeze_protected)
1018 sb_end_intwrite(inode->i_sb);
1019 }
1020
f2fs_post_evict_inode(struct inode * inode)1021 static void f2fs_post_evict_inode(struct inode *inode)
1022 {
1023 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1024 struct f2fs_inode_info *fi = F2FS_I(inode);
1025 nid_t xnid = fi->i_xattr_nid;
1026 unsigned int record_bits = 0;
1027
1028 dquot_drop(inode);
1029
1030 stat_dec_inline_xattr(inode);
1031 stat_dec_inline_dir(inode);
1032 stat_dec_inline_inode(inode);
1033 stat_dec_compr_inode(inode);
1034 stat_sub_compr_blocks(inode,
1035 atomic_read(&fi->i_compr_blocks));
1036
1037 if (likely(!f2fs_cp_error(sbi) &&
1038 !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1039 f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
1040
1041 /*
1042 * anyway, it needs to remove the inode from sbi->inode_list[DIRTY_META]
1043 * list to avoid UAF in f2fs_sync_inode_meta() during checkpoint.
1044 */
1045 f2fs_inode_synced(inode);
1046
1047 /* for the case f2fs_new_inode() was failed, .i_ino is zero, skip it */
1048 if (inode->i_ino)
1049 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,
1050 inode->i_ino);
1051 if (xnid)
1052 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
1053
1054 if (!inode->i_nlink)
1055 goto skip_record;
1056
1057 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
1058 record_bits = BIT(APPEND_INO);
1059 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
1060 record_bits = BIT(UPDATE_INO);
1061
1062 if (!record_bits)
1063 goto skip_record;
1064
1065 /* Let's do this in workqueue out of the direct reclaim path. */
1066 if (current_is_kswapd()) {
1067 f2fs_record_inode_state(sbi, inode->i_ino, record_bits);
1068 } else {
1069 struct evict_inode_work *ew =
1070 mempool_alloc(evict_inode_work_pool, GFP_NOFS);
1071
1072 ew->sbi = sbi;
1073 ew->ino = inode->i_ino;
1074 ew->add_ino_entry_bits = record_bits;
1075 INIT_WORK(&ew->work, f2fs_evict_inode_work);
1076 queue_work(sbi->evict_wq, &ew->work);
1077 }
1078 skip_record:
1079 if (is_inode_flag_set(inode, FI_FREE_NID)) {
1080 f2fs_alloc_nid_failed(sbi, inode->i_ino);
1081 clear_inode_flag(inode, FI_FREE_NID);
1082 } else {
1083 /*
1084 * If xattr nid is corrupted, we can reach out error condition,
1085 * err & !f2fs_exist_written_data(sbi, inode->i_ino, ORPHAN_INO)).
1086 * In that case, f2fs_check_nid_range() is enough to give a clue.
1087 */
1088 }
1089 }
1090
1091 /*
1092 * Called at the last iput() if i_nlink is zero
1093 */
f2fs_evict_inode(struct inode * inode)1094 void f2fs_evict_inode(struct inode *inode)
1095 {
1096 if (f2fs_pre_evict_inode(inode))
1097 goto clear_out;
1098
1099 if (!inode->i_nlink && !is_bad_inode(inode))
1100 f2fs_delete_inode(inode);
1101
1102 f2fs_post_evict_inode(inode);
1103
1104 clear_out:
1105 fscrypt_put_encryption_info(inode);
1106 clear_inode(inode);
1107 }
1108
1109 /* caller should call f2fs_lock_op() */
f2fs_handle_failed_inode(struct inode * inode,struct f2fs_lock_context * lc,bool orphan_free)1110 void f2fs_handle_failed_inode(struct inode *inode,
1111 struct f2fs_lock_context *lc, bool orphan_free)
1112 {
1113 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1114 struct node_info ni;
1115 int err;
1116
1117 /*
1118 * clear nlink of inode in order to release resource of inode
1119 * immediately.
1120 */
1121 clear_nlink(inode);
1122
1123 /*
1124 * we must call this to avoid inode being remained as dirty, resulting
1125 * in a panic when flushing dirty inodes in gdirty_list.
1126 */
1127 f2fs_update_inode_page(inode);
1128 f2fs_inode_synced(inode);
1129
1130 /* don't make bad inode, since it becomes a regular file. */
1131 unlock_new_inode(inode);
1132
1133 if (!orphan_free)
1134 goto out;
1135
1136 /*
1137 * Note: we should add inode to orphan list before f2fs_unlock_op()
1138 * so we can prevent losing this orphan when encoutering checkpoint
1139 * and following suddenly power-off.
1140 */
1141 err = f2fs_get_node_info(sbi, inode->i_ino, &ni, false);
1142 if (err) {
1143 set_sbi_flag(sbi, SBI_NEED_FSCK);
1144 set_inode_flag(inode, FI_FREE_NID);
1145 f2fs_warn(sbi, "May loss orphan inode, run fsck to fix.");
1146 goto out;
1147 }
1148
1149 if (ni.blk_addr != NULL_ADDR) {
1150 err = f2fs_acquire_orphan_inode(sbi);
1151 if (err) {
1152 set_sbi_flag(sbi, SBI_NEED_FSCK);
1153 f2fs_warn(sbi, "Too many orphan inodes, run fsck to fix.");
1154 } else {
1155 f2fs_add_orphan_inode(inode);
1156 }
1157 f2fs_alloc_nid_done(sbi, inode->i_ino);
1158 } else {
1159 set_inode_flag(inode, FI_FREE_NID);
1160 }
1161
1162 out:
1163 f2fs_unlock_op(sbi, lc);
1164
1165 /* iput will drop the inode object */
1166 iput(inode);
1167 }
1168
f2fs_init_evict_inode_work(void)1169 int __init f2fs_init_evict_inode_work(void)
1170 {
1171 evict_inode_work_cache =
1172 kmem_cache_create("f2fs_evict_inode_work",
1173 sizeof(struct evict_inode_work), 0, 0, NULL);
1174 if (!evict_inode_work_cache)
1175 goto fail;
1176 evict_inode_work_pool =
1177 mempool_create_slab_pool(NUM_PREALLOC_EVICT_INODE_WORK,
1178 evict_inode_work_cache);
1179 if (!evict_inode_work_pool)
1180 goto fail_free_cache;
1181 return 0;
1182
1183 fail_free_cache:
1184 kmem_cache_destroy(evict_inode_work_cache);
1185 fail:
1186 return -ENOMEM;
1187 }
1188
f2fs_destroy_evict_inode_work(void)1189 void f2fs_destroy_evict_inode_work(void)
1190 {
1191 mempool_destroy(evict_inode_work_pool);
1192 kmem_cache_destroy(evict_inode_work_cache);
1193 }
1194