| 1 | |
| 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 |
|
| 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 |
|
| 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 |
|
| 502 | if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
|
| 503 | __recover_inline_status(inode, node_folio);
|
| 504 |
|
| 505 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 | }
|