Lines Matching defs:inode
292 nid_t ino; /* inode number */
299 struct inode *inode; /* vfs inode pointer */
427 struct inode *inode; /* vfs inode pointer */
469 static inline int get_extra_isize(struct inode *inode);
470 static inline int get_inline_xattr_addrs(struct inode *inode);
471 #define MAX_INLINE_DATA(inode) (sizeof(__le32) * \
472 (CUR_ADDRS_PER_INODE(inode) - \
473 get_inline_xattr_addrs(inode) - \
477 #define NR_INLINE_DENTRY(inode) (MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \
480 #define INLINE_DENTRY_BITMAP_SIZE(inode) \
481 DIV_ROUND_UP(NR_INLINE_DENTRY(inode), BITS_PER_BYTE)
482 #define INLINE_RESERVED_SIZE(inode) (MAX_INLINE_DATA(inode) - \
484 NR_INLINE_DENTRY(inode) + \
485 INLINE_DENTRY_BITMAP_SIZE(inode)))
530 struct inode *inode;
538 static inline void make_dentry_ptr_block(struct inode *inode,
541 d->inode = inode;
549 static inline void make_dentry_ptr_inline(struct inode *inode,
552 int entry_cnt = NR_INLINE_DENTRY(inode);
553 int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);
554 int reserved_size = INLINE_RESERVED_SIZE(inode);
556 d->inode = inode;
660 nid_t ino; /* inode number */
729 #define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
730 #define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
731 #define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
733 #define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
734 #define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
735 #define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
737 #define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
738 #define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
740 #define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
741 #define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
743 #define file_keep_isize(inode) is_file(inode, FADVISE_KEEP_SIZE_BIT)
744 #define file_set_keep_isize(inode) set_file(inode, FADVISE_KEEP_SIZE_BIT)
746 #define file_is_hot(inode) is_file(inode, FADVISE_HOT_BIT)
747 #define file_set_hot(inode) set_file(inode, FADVISE_HOT_BIT)
748 #define file_clear_hot(inode) clear_file(inode, FADVISE_HOT_BIT)
750 #define file_is_verity(inode) is_file(inode, FADVISE_VERITY_BIT)
751 #define file_set_verity(inode) set_file(inode, FADVISE_VERITY_BIT)
753 #define file_should_truncate(inode) is_file(inode, FADVISE_TRUNC_BIT)
754 #define file_need_truncate(inode) set_file(inode, FADVISE_TRUNC_BIT)
755 #define file_dont_truncate(inode) clear_file(inode, FADVISE_TRUNC_BIT)
766 FI_NEW_INODE, /* indicate newly allocated inode */
767 FI_DIRTY_INODE, /* indicate inode is dirty or not */
768 FI_AUTO_RECOVER, /* indicate inode is recoverable */
778 FI_APPEND_WRITE, /* inode has appended data */
779 FI_UPDATE_WRITE, /* inode has in-place-update data */
806 struct inode vfs_inode; /* serve a vfs inode */
807 unsigned long i_flags; /* keep an inode flags for ioctl */
813 unsigned int i_pino; /* parent inode number */
824 struct task_struct *wb_task; /* indicate inode is in context of writeback */
840 struct inode *cow_inode; /* copy-on-write inode for atomic write */
849 struct timespec64 i_crtime; /* inode creation time */
850 struct timespec64 i_disk_time[3];/* inode disk times */
963 struct inode *inode; /* vfs inode pointer */
964 struct page *inode_page; /* its inode page, NULL is possible */
968 bool inode_page_locked; /* inode page is locked or not */
975 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
979 dn->inode = inode;
1189 nid_t ino; /* inode number */
1253 DIR_INODE, /* for dirty dir inode */
1254 FILE_INODE, /* for dirty regular/symlink inode */
1255 DIRTY_META, /* for all dirtied inode metadata */
1259 /* for inner inode cache management */
1263 struct list_head ino_list; /* inode list head */
1420 PAGE_PRIVATE_INLINE_INODE, /* inode page contains inline data */
1460 struct inode *inode; /* inode the context belong to */
1480 struct inode *inode; /* inode the context belong to */
1489 struct inode *inode; /* inode the context belong to */
1556 struct inode *node_inode; /* cache node blocks */
1573 struct inode *meta_inode; /* cache meta blocks */
1583 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */
1590 /* for orphan inode, use 0'th array */
1593 /* for inode management */
1594 struct list_head inode_list[NR_INODE_TYPE]; /* dirty inode list */
1595 spinlock_t inode_lock[NR_INODE_TYPE]; /* for dirty inode list lock */
1611 unsigned int root_ino_num; /* root inode number*/
1612 unsigned int node_ino_num; /* node inode number*/
1613 unsigned int meta_ino_num; /* meta inode number*/
1623 bool readdir_ra; /* readahead inode in readdir */
1649 /* valid inode count */
1789 struct inode *compress_inode; /* cache compressed blocks */
1928 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
1930 return container_of(inode, struct f2fs_inode_info, vfs_inode);
1938 static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
1940 return F2FS_SB(inode->i_sb);
2217 * Check whether the inode has blocks or not
2219 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
2221 block_t xattr_block = F2FS_I(inode)->i_xattr_nid ? 1 : 0;
2223 return (inode->i_blocks >> F2FS_LOG_SECTORS_PER_BLOCK) > xattr_block;
2232 struct inode *inode, bool cap)
2234 if (!inode)
2238 if (IS_NOQUOTA(inode))
2250 static inline void f2fs_i_blocks_write(struct inode *, block_t, bool, bool);
2252 struct inode *inode, blkcnt_t *count, bool partial)
2258 ret = dquot_reserve_block(inode, *count);
2278 if (!__allow_reserved_blocks(sbi, inode, true))
2312 dquot_release_reservation_block(inode, release);
2314 f2fs_i_blocks_write(inode, *count, true, true);
2320 dquot_release_reservation_block(inode, release);
2413 struct inode *inode,
2426 if (unlikely(inode->i_blocks < sectors)) {
2428 inode->i_ino,
2429 (unsigned long long)inode->i_blocks,
2434 f2fs_i_blocks_write(inode, count, false, true);
2449 static inline void inode_inc_dirty_pages(struct inode *inode)
2451 atomic_inc(&F2FS_I(inode)->dirty_pages);
2452 inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
2454 if (IS_NOQUOTA(inode))
2455 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
2463 static inline void inode_dec_dirty_pages(struct inode *inode)
2465 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
2466 !S_ISLNK(inode->i_mode))
2469 atomic_dec(&F2FS_I(inode)->dirty_pages);
2470 dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
2472 if (IS_NOQUOTA(inode))
2473 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
2476 static inline void inc_atomic_write_cnt(struct inode *inode)
2478 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2479 struct f2fs_inode_info *fi = F2FS_I(inode);
2489 static inline void release_atomic_write_cnt(struct inode *inode)
2491 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2492 struct f2fs_inode_info *fi = F2FS_I(inode);
2503 static inline int get_dirty_pages(struct inode *inode)
2505 return atomic_read(&F2FS_I(inode)->dirty_pages);
2601 extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
2603 struct inode *inode, bool is_inode)
2610 if (inode) {
2611 err = dquot_alloc_inode(inode);
2616 err = dquot_reserve_block(inode, 1);
2629 if (!__allow_reserved_blocks(sbi, inode, false))
2655 if (inode) {
2657 f2fs_mark_inode_dirty_sync(inode, true);
2659 f2fs_i_blocks_write(inode, 1, true, true);
2667 if (inode)
2668 dquot_free_inode(inode);
2670 dquot_release_reservation_block(inode, 1);
2676 struct inode *inode, bool is_inode)
2698 dquot_free_inode(inode);
2700 if (unlikely(inode->i_blocks == 0)) {
2702 inode->i_ino,
2703 (unsigned long long)inode->i_blocks);
2707 f2fs_i_blocks_write(inode, 1, false, true);
2885 static inline int f2fs_has_extra_attr(struct inode *inode);
2886 static inline block_t data_blkaddr(struct inode *inode,
2897 if (!inode)
2900 else if (f2fs_has_extra_attr(inode))
2901 base = get_extra_isize(inode);
2910 return data_blkaddr(dn->inode, dn->node_page, dn->ofs_in_node);
2974 * On-disk inode flags (f2fs_inode::i_flags)
3012 static inline void __mark_inode_dirty_flag(struct inode *inode,
3027 f2fs_mark_inode_dirty_sync(inode, true);
3031 static inline void set_inode_flag(struct inode *inode, int flag)
3033 set_bit(flag, F2FS_I(inode)->flags);
3034 __mark_inode_dirty_flag(inode, flag, true);
3037 static inline int is_inode_flag_set(struct inode *inode, int flag)
3039 return test_bit(flag, F2FS_I(inode)->flags);
3042 static inline void clear_inode_flag(struct inode *inode, int flag)
3044 clear_bit(flag, F2FS_I(inode)->flags);
3045 __mark_inode_dirty_flag(inode, flag, false);
3048 static inline bool f2fs_verity_in_progress(struct inode *inode)
3051 is_inode_flag_set(inode, FI_VERITY_IN_PROGRESS);
3054 static inline void set_acl_inode(struct inode *inode, umode_t mode)
3056 F2FS_I(inode)->i_acl_mode = mode;
3057 set_inode_flag(inode, FI_ACL_MODE);
3058 f2fs_mark_inode_dirty_sync(inode, false);
3061 static inline void f2fs_i_links_write(struct inode *inode, bool inc)
3064 inc_nlink(inode);
3066 drop_nlink(inode);
3067 f2fs_mark_inode_dirty_sync(inode, true);
3070 static inline void f2fs_i_blocks_write(struct inode *inode,
3073 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
3074 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
3079 dquot_claim_block(inode, diff);
3081 dquot_alloc_block_nofail(inode, diff);
3083 dquot_free_block(inode, diff);
3086 f2fs_mark_inode_dirty_sync(inode, true);
3088 set_inode_flag(inode, FI_AUTO_RECOVER);
3091 static inline bool f2fs_is_atomic_file(struct inode *inode);
3093 static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
3095 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
3096 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
3098 if (i_size_read(inode) == i_size)
3101 i_size_write(inode, i_size);
3103 if (f2fs_is_atomic_file(inode))
3106 f2fs_mark_inode_dirty_sync(inode, true);
3108 set_inode_flag(inode, FI_AUTO_RECOVER);
3111 static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
3113 F2FS_I(inode)->i_current_depth = depth;
3114 f2fs_mark_inode_dirty_sync(inode, true);
3117 static inline void f2fs_i_gc_failures_write(struct inode *inode,
3120 F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] = count;
3121 f2fs_mark_inode_dirty_sync(inode, true);
3124 static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
3126 F2FS_I(inode)->i_xattr_nid = xnid;
3127 f2fs_mark_inode_dirty_sync(inode, true);
3130 static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
3132 F2FS_I(inode)->i_pino = pino;
3133 f2fs_mark_inode_dirty_sync(inode, true);
3136 static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
3138 struct f2fs_inode_info *fi = F2FS_I(inode);
3158 static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
3162 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
3164 if (is_inode_flag_set(inode, FI_INLINE_DATA))
3166 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
3168 if (is_inode_flag_set(inode, FI_DATA_EXIST))
3170 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
3172 if (is_inode_flag_set(inode, FI_EXTRA_ATTR))
3174 if (is_inode_flag_set(inode, FI_PIN_FILE))
3176 if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED))
3180 static inline int f2fs_has_extra_attr(struct inode *inode)
3182 return is_inode_flag_set(inode, FI_EXTRA_ATTR);
3185 static inline int f2fs_has_inline_xattr(struct inode *inode)
3187 return is_inode_flag_set(inode, FI_INLINE_XATTR);
3190 static inline int f2fs_compressed_file(struct inode *inode)
3192 return S_ISREG(inode->i_mode) &&
3193 is_inode_flag_set(inode, FI_COMPRESSED_FILE);
3196 static inline bool f2fs_need_compress_data(struct inode *inode)
3198 int compress_mode = F2FS_OPTION(F2FS_I_SB(inode)).compress_mode;
3200 if (!f2fs_compressed_file(inode))
3206 is_inode_flag_set(inode, FI_ENABLE_COMPRESS))
3212 static inline unsigned int addrs_per_inode(struct inode *inode)
3214 unsigned int addrs = CUR_ADDRS_PER_INODE(inode) -
3215 get_inline_xattr_addrs(inode);
3217 if (!f2fs_compressed_file(inode))
3219 return ALIGN_DOWN(addrs, F2FS_I(inode)->i_cluster_size);
3222 static inline unsigned int addrs_per_block(struct inode *inode)
3224 if (!f2fs_compressed_file(inode))
3226 return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, F2FS_I(inode)->i_cluster_size);
3229 static inline void *inline_xattr_addr(struct inode *inode, struct page *page)
3234 get_inline_xattr_addrs(inode)]);
3237 static inline int inline_xattr_size(struct inode *inode)
3239 if (f2fs_has_inline_xattr(inode))
3240 return get_inline_xattr_addrs(inode) * sizeof(__le32);
3245 * Notice: check inline_data flag without inode page lock is unsafe.
3248 static inline int f2fs_has_inline_data(struct inode *inode)
3250 return is_inode_flag_set(inode, FI_INLINE_DATA);
3253 static inline int f2fs_exist_data(struct inode *inode)
3255 return is_inode_flag_set(inode, FI_DATA_EXIST);
3258 static inline int f2fs_has_inline_dots(struct inode *inode)
3260 return is_inode_flag_set(inode, FI_INLINE_DOTS);
3263 static inline int f2fs_is_mmap_file(struct inode *inode)
3265 return is_inode_flag_set(inode, FI_MMAP_FILE);
3268 static inline bool f2fs_is_pinned_file(struct inode *inode)
3270 return is_inode_flag_set(inode, FI_PIN_FILE);
3273 static inline bool f2fs_is_atomic_file(struct inode *inode)
3275 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
3278 static inline bool f2fs_is_cow_file(struct inode *inode)
3280 return is_inode_flag_set(inode, FI_COW_FILE);
3283 static inline __le32 *get_dnode_addr(struct inode *inode,
3285 static inline void *inline_data_addr(struct inode *inode, struct page *page)
3287 __le32 *addr = get_dnode_addr(inode, page);
3292 static inline int f2fs_has_inline_dentry(struct inode *inode)
3294 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
3297 static inline int is_file(struct inode *inode, int type)
3299 return F2FS_I(inode)->i_advise & type;
3302 static inline void set_file(struct inode *inode, int type)
3304 if (is_file(inode, type))
3306 F2FS_I(inode)->i_advise |= type;
3307 f2fs_mark_inode_dirty_sync(inode, true);
3310 static inline void clear_file(struct inode *inode, int type)
3312 if (!is_file(inode, type))
3314 F2FS_I(inode)->i_advise &= ~type;
3315 f2fs_mark_inode_dirty_sync(inode, true);
3318 static inline bool f2fs_is_time_consistent(struct inode *inode)
3320 struct timespec64 ctime = inode_get_ctime(inode);
3322 if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime))
3324 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &ctime))
3326 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime))
3331 static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
3336 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3339 ret = list_empty(&F2FS_I(inode)->gdirty_list);
3343 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER) ||
3344 file_keep_isize(inode) ||
3345 i_size_read(inode) & ~PAGE_MASK)
3348 if (!f2fs_is_time_consistent(inode))
3351 spin_lock(&F2FS_I(inode)->i_size_lock);
3352 ret = F2FS_I(inode)->last_disk_size == i_size_read(inode);
3353 spin_unlock(&F2FS_I(inode)->i_size_lock);
3422 static inline int get_extra_isize(struct inode *inode)
3424 return F2FS_I(inode)->i_extra_isize / sizeof(__le32);
3427 static inline int get_inline_xattr_addrs(struct inode *inode)
3429 return F2FS_I(inode)->i_inline_xattr_size;
3432 static inline __le32 *get_dnode_addr(struct inode *inode,
3437 if (IS_INODE(node_page) && f2fs_has_extra_attr(inode))
3438 base = get_extra_isize(inode);
3485 int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock);
3486 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock);
3487 int f2fs_truncate(struct inode *inode);
3492 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end);
3494 int f2fs_precache_extents(struct inode *inode);
3500 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid);
3501 int f2fs_pin_file_control(struct inode *inode, bool inc);
3504 * inode.c
3506 void f2fs_set_inode_flags(struct inode *inode);
3509 struct inode *f2fs_iget(struct super_block *sb, unsigned long ino);
3510 struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino);
3512 void f2fs_update_inode(struct inode *inode, struct page *node_page);
3513 void f2fs_update_inode_page(struct inode *inode);
3514 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
3515 void f2fs_evict_inode(struct inode *inode);
3516 void f2fs_handle_failed_inode(struct inode *inode);
3524 int f2fs_get_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
3525 struct inode **new_inode);
3530 int f2fs_init_casefolded_name(const struct inode *dir,
3532 int f2fs_setup_filename(struct inode *dir, const struct qstr *iname,
3534 int f2fs_prepare_lookup(struct inode *dir, struct dentry *dentry,
3541 void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
3543 struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
3545 void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
3548 void f2fs_drop_nlink(struct inode *dir, struct inode *inode);
3549 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
3552 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
3554 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p);
3555 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
3557 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
3558 struct page *page, struct inode *inode);
3559 bool f2fs_has_enough_room(struct inode *dir, struct page *ipage,
3564 int f2fs_add_regular_entry(struct inode *dir, const struct f2fs_filename *fname,
3565 struct inode *inode, nid_t ino, umode_t mode);
3566 int f2fs_add_dentry(struct inode *dir, const struct f2fs_filename *fname,
3567 struct inode *inode, nid_t ino, umode_t mode);
3568 int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
3569 struct inode *inode, nid_t ino, umode_t mode);
3571 struct inode *dir, struct inode *inode);
3572 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir,
3574 bool f2fs_empty_dir(struct inode *dir);
3576 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
3581 inode, inode->i_ino, inode->i_mode);
3587 int f2fs_inode_dirtied(struct inode *inode, bool sync);
3588 void f2fs_inode_synced(struct inode *inode);
3589 int f2fs_dquot_initialize(struct inode *inode);
3592 loff_t max_file_blocks(struct inode *inode);
3606 void f2fs_hash_filename(const struct inode *dir, struct f2fs_filename *fname);
3626 int f2fs_truncate_inode_blocks(struct inode *inode, pgoff_t from);
3627 int f2fs_truncate_xattr_node(struct inode *inode);
3631 int f2fs_remove_inode_page(struct inode *inode);
3632 struct page *f2fs_new_inode_page(struct inode *inode);
3639 int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
3650 int f2fs_recover_inline_xattr(struct inode *inode, struct page *page);
3651 int f2fs_recover_xattr_data(struct inode *inode, struct page *page);
3666 int f2fs_commit_atomic_write(struct inode *inode);
3667 void f2fs_abort_atomic_write(struct inode *inode, bool clean);
3725 void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr);
3726 void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
3783 void f2fs_add_orphan_inode(struct inode *inode);
3787 void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio);
3788 void f2fs_remove_dirty_inode(struct inode *inode);
3815 struct inode *inode, struct page *page,
3832 struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
3834 struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index,
3836 struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
3838 struct page *f2fs_get_new_data_page(struct inode *inode,
3841 int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, int flag);
3842 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3845 bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio);
3846 bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio);
3852 void f2fs_write_failed(struct inode *inode, loff_t to);
3855 bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len);
3868 block_t f2fs_start_bidx_of_node(unsigned int node_ofs, struct inode *inode);
3972 #define stat_inc_inline_xattr(inode) \
3974 if (f2fs_has_inline_xattr(inode)) \
3975 (atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
3977 #define stat_dec_inline_xattr(inode) \
3979 if (f2fs_has_inline_xattr(inode)) \
3980 (atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
3982 #define stat_inc_inline_inode(inode) \
3984 if (f2fs_has_inline_data(inode)) \
3985 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
3987 #define stat_dec_inline_inode(inode) \
3989 if (f2fs_has_inline_data(inode)) \
3990 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
3992 #define stat_inc_inline_dir(inode) \
3994 if (f2fs_has_inline_dentry(inode)) \
3995 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
3997 #define stat_dec_inline_dir(inode) \
3999 if (f2fs_has_inline_dentry(inode)) \
4000 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
4002 #define stat_inc_compr_inode(inode) \
4004 if (f2fs_compressed_file(inode)) \
4005 (atomic_inc(&F2FS_I_SB(inode)->compr_inode)); \
4007 #define stat_dec_compr_inode(inode) \
4009 if (f2fs_compressed_file(inode)) \
4010 (atomic_dec(&F2FS_I_SB(inode)->compr_inode)); \
4012 #define stat_add_compr_blocks(inode, blocks) \
4013 (atomic64_add(blocks, &F2FS_I_SB(inode)->compr_blocks))
4014 #define stat_sub_compr_blocks(inode, blocks) \
4015 (atomic64_sub(blocks, &F2FS_I_SB(inode)->compr_blocks))
4016 #define stat_inc_swapfile_inode(inode) \
4017 (atomic_inc(&F2FS_I_SB(inode)->swapfile_inode))
4018 #define stat_dec_swapfile_inode(inode) \
4019 (atomic_dec(&F2FS_I_SB(inode)->swapfile_inode))
4020 #define stat_inc_atomic_inode(inode) \
4021 (atomic_inc(&F2FS_I_SB(inode)->atomic_files))
4022 #define stat_dec_atomic_inode(inode) \
4023 (atomic_dec(&F2FS_I_SB(inode)->atomic_files))
4041 #define stat_update_max_atomic_write(inode) \
4043 int cur = atomic_read(&F2FS_I_SB(inode)->atomic_files); \
4044 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
4046 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
4090 #define stat_inc_inline_xattr(inode) do { } while (0)
4091 #define stat_dec_inline_xattr(inode) do { } while (0)
4092 #define stat_inc_inline_inode(inode) do { } while (0)
4093 #define stat_dec_inline_inode(inode) do { } while (0)
4094 #define stat_inc_inline_dir(inode) do { } while (0)
4095 #define stat_dec_inline_dir(inode) do { } while (0)
4096 #define stat_inc_compr_inode(inode) do { } while (0)
4097 #define stat_dec_compr_inode(inode) do { } while (0)
4098 #define stat_add_compr_blocks(inode, blocks) do { } while (0)
4099 #define stat_sub_compr_blocks(inode, blocks) do { } while (0)
4100 #define stat_inc_swapfile_inode(inode) do { } while (0)
4101 #define stat_dec_swapfile_inode(inode) do { } while (0)
4102 #define stat_inc_atomic_inode(inode) do { } while (0)
4103 #define stat_dec_atomic_inode(inode) do { } while (0)
4104 #define stat_update_max_atomic_write(inode) do { } while (0)
4138 bool f2fs_may_inline_data(struct inode *inode);
4139 bool f2fs_sanity_check_inline_data(struct inode *inode);
4140 bool f2fs_may_inline_dentry(struct inode *inode);
4142 void f2fs_truncate_inline_inode(struct inode *inode,
4144 int f2fs_read_inline_data(struct inode *inode, struct page *page);
4146 int f2fs_convert_inline_inode(struct inode *inode);
4147 int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry);
4148 int f2fs_write_inline_data(struct inode *inode, struct page *page);
4149 int f2fs_recover_inline_data(struct inode *inode, struct page *npage);
4150 struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
4153 int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
4155 int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname,
4156 struct inode *inode, nid_t ino, umode_t mode);
4158 struct page *page, struct inode *dir,
4159 struct inode *inode);
4160 bool f2fs_empty_inline_dir(struct inode *dir);
4163 int f2fs_inline_data_fiemap(struct inode *inode,
4180 bool sanity_check_extent_cache(struct inode *inode);
4181 void f2fs_init_extent_tree(struct inode *inode);
4182 void f2fs_drop_extent_tree(struct inode *inode);
4183 void f2fs_destroy_extent_node(struct inode *inode);
4184 void f2fs_destroy_extent_tree(struct inode *inode);
4190 void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage);
4191 bool f2fs_lookup_read_extent_cache(struct inode *inode, pgoff_t pgofs,
4193 bool f2fs_lookup_read_extent_cache_block(struct inode *inode, pgoff_t index,
4202 void f2fs_init_age_extent_tree(struct inode *inode);
4203 bool f2fs_lookup_age_extent_cache(struct inode *inode, pgoff_t pgofs,
4228 static inline bool f2fs_encrypted_file(struct inode *inode)
4230 return IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
4233 static inline void f2fs_set_encrypted_inode(struct inode *inode)
4236 file_set_encrypt(inode);
4237 f2fs_set_inode_flags(inode);
4242 * Returns true if the reads of the inode's data need to undergo some
4245 static inline bool f2fs_post_read_required(struct inode *inode)
4247 return f2fs_encrypted_file(inode) || fsverity_active(inode) ||
4248 f2fs_compressed_file(inode);
4257 int f2fs_prepare_compress_overwrite(struct inode *inode,
4259 bool f2fs_compress_write_end(struct inode *inode, void *fsdata,
4261 int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock);
4263 bool f2fs_is_compress_backend_ready(struct inode *inode);
4280 int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index);
4281 void f2fs_update_read_extent_tree_range_compressed(struct inode *inode,
4309 #define inc_compr_inode_stat(inode) \
4311 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); \
4314 #define add_compr_block_stat(inode, blocks) \
4316 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); \
4317 int diff = F2FS_I(inode)->i_cluster_size - blocks; \
4323 static inline bool f2fs_is_compress_backend_ready(struct inode *inode)
4325 if (!f2fs_compressed_file(inode))
4366 #define inc_compr_inode_stat(inode) do { } while (0)
4368 struct inode *inode,
4373 static inline int set_compress_context(struct inode *inode)
4376 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4378 F2FS_I(inode)->i_compress_algorithm =
4380 F2FS_I(inode)->i_log_cluster_size =
4382 F2FS_I(inode)->i_compress_flag =
4385 F2FS_I(inode)->i_cluster_size =
4386 BIT(F2FS_I(inode)->i_log_cluster_size);
4387 if ((F2FS_I(inode)->i_compress_algorithm == COMPRESS_LZ4 ||
4388 F2FS_I(inode)->i_compress_algorithm == COMPRESS_ZSTD) &&
4390 F2FS_I(inode)->i_compress_level =
4392 F2FS_I(inode)->i_flags |= F2FS_COMPR_FL;
4393 set_inode_flag(inode, FI_COMPRESSED_FILE);
4394 stat_inc_compr_inode(inode);
4395 inc_compr_inode_stat(inode);
4396 f2fs_mark_inode_dirty_sync(inode, true);
4403 static inline bool f2fs_disable_compressed_file(struct inode *inode)
4405 struct f2fs_inode_info *fi = F2FS_I(inode);
4407 f2fs_down_write(&F2FS_I(inode)->i_sem);
4409 if (!f2fs_compressed_file(inode)) {
4410 f2fs_up_write(&F2FS_I(inode)->i_sem);
4413 if (f2fs_is_mmap_file(inode) ||
4414 (S_ISREG(inode->i_mode) && F2FS_HAS_BLOCKS(inode))) {
4415 f2fs_up_write(&F2FS_I(inode)->i_sem);
4420 stat_dec_compr_inode(inode);
4421 clear_inode_flag(inode, FI_COMPRESSED_FILE);
4422 f2fs_mark_inode_dirty_sync(inode, true);
4424 f2fs_up_write(&F2FS_I(inode)->i_sem);
4532 static inline bool f2fs_may_compress(struct inode *inode)
4534 if (IS_SWAPFILE(inode) || f2fs_is_pinned_file(inode) ||
4535 f2fs_is_atomic_file(inode) || f2fs_has_inline_data(inode) ||
4536 f2fs_is_mmap_file(inode))
4538 return S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode);
4541 static inline void f2fs_i_compr_blocks_update(struct inode *inode,
4544 struct f2fs_inode_info *fi = F2FS_I(inode);
4553 stat_add_compr_blocks(inode, diff);
4556 stat_sub_compr_blocks(inode, diff);
4558 f2fs_mark_inode_dirty_sync(inode, true);
4571 static inline bool f2fs_need_verity(const struct inode *inode, pgoff_t idx)
4573 return fsverity_active(inode) && (idx <
4574 DIV_ROUND_UP(fsverity_get_verified_data_size(inode), PAGE_SIZE));