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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 */ 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() */ 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 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 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