Lines Matching refs:inode
263 nid_t ino; /* inode number */
270 struct inode *inode; /* vfs inode pointer */
395 struct inode *inode; /* vfs inode pointer */
437 static inline int get_extra_isize(struct inode *inode);
438 static inline int get_inline_xattr_addrs(struct inode *inode);
439 #define MAX_INLINE_DATA(inode) (sizeof(__le32) * \
440 (CUR_ADDRS_PER_INODE(inode) - \
441 get_inline_xattr_addrs(inode) - \
445 #define NR_INLINE_DENTRY(inode) (MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \
448 #define INLINE_DENTRY_BITMAP_SIZE(inode) \
449 DIV_ROUND_UP(NR_INLINE_DENTRY(inode), BITS_PER_BYTE)
450 #define INLINE_RESERVED_SIZE(inode) (MAX_INLINE_DATA(inode) - \
452 NR_INLINE_DENTRY(inode) + \
453 INLINE_DENTRY_BITMAP_SIZE(inode)))
496 struct inode *inode;
504 static inline void make_dentry_ptr_block(struct inode *inode,
507 d->inode = inode;
515 static inline void make_dentry_ptr_inline(struct inode *inode,
518 int entry_cnt = NR_INLINE_DENTRY(inode);
519 int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);
520 int reserved_size = INLINE_RESERVED_SIZE(inode);
522 d->inode = inode;
590 nid_t ino; /* inode number */
646 #define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
647 #define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
648 #define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
649 #define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
650 #define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
651 #define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
652 #define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
653 #define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
654 #define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
655 #define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
656 #define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
657 #define file_keep_isize(inode) is_file(inode, FADVISE_KEEP_SIZE_BIT)
658 #define file_set_keep_isize(inode) set_file(inode, FADVISE_KEEP_SIZE_BIT)
659 #define file_is_hot(inode) is_file(inode, FADVISE_HOT_BIT)
660 #define file_set_hot(inode) set_file(inode, FADVISE_HOT_BIT)
661 #define file_clear_hot(inode) clear_file(inode, FADVISE_HOT_BIT)
662 #define file_is_verity(inode) is_file(inode, FADVISE_VERITY_BIT)
663 #define file_set_verity(inode) set_file(inode, FADVISE_VERITY_BIT)
675 FI_NEW_INODE, /* indicate newly allocated inode */
676 FI_DIRTY_INODE, /* indicate inode is dirty or not */
677 FI_AUTO_RECOVER, /* indicate inode is recoverable */
687 FI_APPEND_WRITE, /* inode has appended data */
688 FI_UPDATE_WRITE, /* inode has in-place-update data */
712 struct inode vfs_inode; /* serve a vfs inode */
713 unsigned long i_flags; /* keep an inode flags for ioctl */
719 unsigned int i_pino; /* parent inode number */
730 struct task_struct *wb_task; /* indicate inode is in context of writeback */
758 struct timespec64 i_crtime; /* inode creation time */
759 struct timespec64 i_disk_time[4];/* inode disk times */
830 extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
903 struct inode *inode; /* vfs inode pointer */
904 struct page *inode_page; /* its inode page, NULL is possible */
908 bool inode_page_locked; /* inode page is locked or not */
915 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
919 dn->inode = inode;
1128 nid_t ino; /* inode number */
1186 DIR_INODE, /* for dirty dir inode */
1187 FILE_INODE, /* for dirty regular/symlink inode */
1188 DIRTY_META, /* for all dirtied inode metadata */
1193 /* for inner inode cache management */
1197 struct list_head ino_list; /* inode list head */
1323 struct inode *inode; /* inode the context belong to */
1342 struct inode *inode; /* inode the context belong to */
1351 struct inode *inode; /* inode the context belong to */
1406 struct inode *node_inode; /* cache node blocks */
1421 struct inode *meta_inode; /* cache meta blocks */
1430 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */
1437 /* for orphan inode, use 0'th array */
1440 /* for inode management */
1441 struct list_head inode_list[NR_INODE_TYPE]; /* dirty inode list */
1442 spinlock_t inode_lock[NR_INODE_TYPE]; /* for dirty inode list lock */
1459 unsigned int root_ino_num; /* root inode number*/
1460 unsigned int node_ino_num; /* node inode number*/
1461 unsigned int meta_ino_num; /* meta inode number*/
1472 int readdir_ra; /* readahead inode in readdir */
1495 /* valid inode count */
1604 struct inode *inode;
1734 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
1736 return container_of(inode, struct f2fs_inode_info, vfs_inode);
1744 static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
1746 return F2FS_SB(inode->i_sb);
1973 * Check whether the inode has blocks or not
1975 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
1977 block_t xattr_block = F2FS_I(inode)->i_xattr_nid ? 1 : 0;
1979 return (inode->i_blocks >> F2FS_LOG_SECTORS_PER_BLOCK) > xattr_block;
1988 struct inode *inode, bool cap)
1990 if (!inode)
1994 if (IS_NOQUOTA(inode))
2006 static inline void f2fs_i_blocks_write(struct inode *, block_t, bool, bool);
2008 struct inode *inode, blkcnt_t *count)
2014 ret = dquot_reserve_block(inode, *count);
2035 if (!__allow_reserved_blocks(sbi, inode, true))
2064 dquot_release_reservation_block(inode, release);
2066 f2fs_i_blocks_write(inode, *count, true, true);
2072 dquot_release_reservation_block(inode, release);
2091 struct inode *inode,
2104 if (unlikely(inode->i_blocks < sectors)) {
2106 inode->i_ino,
2107 (unsigned long long)inode->i_blocks,
2112 f2fs_i_blocks_write(inode, count, false, true);
2127 static inline void inode_inc_dirty_pages(struct inode *inode)
2129 atomic_inc(&F2FS_I(inode)->dirty_pages);
2130 inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
2132 if (IS_NOQUOTA(inode))
2133 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
2141 static inline void inode_dec_dirty_pages(struct inode *inode)
2143 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
2144 !S_ISLNK(inode->i_mode))
2147 atomic_dec(&F2FS_I(inode)->dirty_pages);
2148 dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
2150 if (IS_NOQUOTA(inode))
2151 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
2159 static inline int get_dirty_pages(struct inode *inode)
2161 return atomic_read(&F2FS_I(inode)->dirty_pages);
2257 struct inode *inode, bool is_inode)
2264 if (inode) {
2265 err = dquot_alloc_inode(inode);
2270 err = dquot_reserve_block(inode, 1);
2285 if (!__allow_reserved_blocks(sbi, inode, false))
2311 if (inode) {
2313 f2fs_mark_inode_dirty_sync(inode, true);
2315 f2fs_i_blocks_write(inode, 1, true, true);
2323 if (inode)
2324 dquot_free_inode(inode);
2326 dquot_release_reservation_block(inode, 1);
2332 struct inode *inode, bool is_inode)
2354 dquot_free_inode(inode);
2356 if (unlikely(inode->i_blocks == 0)) {
2358 inode->i_ino,
2359 (unsigned long long)inode->i_blocks);
2363 f2fs_i_blocks_write(inode, 1, false, true);
2535 static inline int f2fs_has_extra_attr(struct inode *inode);
2536 static inline block_t data_blkaddr(struct inode *inode,
2547 if (!inode)
2550 else if (f2fs_has_extra_attr(inode))
2551 base = get_extra_isize(inode);
2560 return data_blkaddr(dn->inode, dn->node_page, dn->ofs_in_node);
2624 * On-disk inode flags (f2fs_inode::i_flags)
2660 static inline void __mark_inode_dirty_flag(struct inode *inode,
2674 f2fs_mark_inode_dirty_sync(inode, true);
2678 static inline void set_inode_flag(struct inode *inode, int flag)
2680 set_bit(flag, F2FS_I(inode)->flags);
2681 __mark_inode_dirty_flag(inode, flag, true);
2684 static inline int is_inode_flag_set(struct inode *inode, int flag)
2686 return test_bit(flag, F2FS_I(inode)->flags);
2689 static inline void clear_inode_flag(struct inode *inode, int flag)
2691 clear_bit(flag, F2FS_I(inode)->flags);
2692 __mark_inode_dirty_flag(inode, flag, false);
2695 static inline bool f2fs_verity_in_progress(struct inode *inode)
2698 is_inode_flag_set(inode, FI_VERITY_IN_PROGRESS);
2701 static inline void set_acl_inode(struct inode *inode, umode_t mode)
2703 F2FS_I(inode)->i_acl_mode = mode;
2704 set_inode_flag(inode, FI_ACL_MODE);
2705 f2fs_mark_inode_dirty_sync(inode, false);
2708 static inline void f2fs_i_links_write(struct inode *inode, bool inc)
2711 inc_nlink(inode);
2713 drop_nlink(inode);
2714 f2fs_mark_inode_dirty_sync(inode, true);
2717 static inline void f2fs_i_blocks_write(struct inode *inode,
2720 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2721 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2726 dquot_claim_block(inode, diff);
2728 dquot_alloc_block_nofail(inode, diff);
2730 dquot_free_block(inode, diff);
2733 f2fs_mark_inode_dirty_sync(inode, true);
2735 set_inode_flag(inode, FI_AUTO_RECOVER);
2738 static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
2740 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2741 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2743 if (i_size_read(inode) == i_size)
2746 i_size_write(inode, i_size);
2747 f2fs_mark_inode_dirty_sync(inode, true);
2749 set_inode_flag(inode, FI_AUTO_RECOVER);
2752 static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
2754 F2FS_I(inode)->i_current_depth = depth;
2755 f2fs_mark_inode_dirty_sync(inode, true);
2758 static inline void f2fs_i_gc_failures_write(struct inode *inode,
2761 F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] = count;
2762 f2fs_mark_inode_dirty_sync(inode, true);
2765 static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
2767 F2FS_I(inode)->i_xattr_nid = xnid;
2768 f2fs_mark_inode_dirty_sync(inode, true);
2771 static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
2773 F2FS_I(inode)->i_pino = pino;
2774 f2fs_mark_inode_dirty_sync(inode, true);
2777 static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
2779 struct f2fs_inode_info *fi = F2FS_I(inode);
2797 static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
2801 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
2803 if (is_inode_flag_set(inode, FI_INLINE_DATA))
2805 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
2807 if (is_inode_flag_set(inode, FI_DATA_EXIST))
2809 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
2811 if (is_inode_flag_set(inode, FI_EXTRA_ATTR))
2813 if (is_inode_flag_set(inode, FI_PIN_FILE))
2817 static inline int f2fs_has_extra_attr(struct inode *inode)
2819 return is_inode_flag_set(inode, FI_EXTRA_ATTR);
2822 static inline int f2fs_has_inline_xattr(struct inode *inode)
2824 return is_inode_flag_set(inode, FI_INLINE_XATTR);
2827 static inline int f2fs_compressed_file(struct inode *inode)
2829 return S_ISREG(inode->i_mode) &&
2830 is_inode_flag_set(inode, FI_COMPRESSED_FILE);
2833 static inline unsigned int addrs_per_inode(struct inode *inode)
2835 unsigned int addrs = CUR_ADDRS_PER_INODE(inode) -
2836 get_inline_xattr_addrs(inode);
2838 if (!f2fs_compressed_file(inode))
2840 return ALIGN_DOWN(addrs, F2FS_I(inode)->i_cluster_size);
2843 static inline unsigned int addrs_per_block(struct inode *inode)
2845 if (!f2fs_compressed_file(inode))
2847 return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, F2FS_I(inode)->i_cluster_size);
2850 static inline void *inline_xattr_addr(struct inode *inode, struct page *page)
2855 get_inline_xattr_addrs(inode)]);
2858 static inline int inline_xattr_size(struct inode *inode)
2860 if (f2fs_has_inline_xattr(inode))
2861 return get_inline_xattr_addrs(inode) * sizeof(__le32);
2865 static inline int f2fs_has_inline_data(struct inode *inode)
2867 return is_inode_flag_set(inode, FI_INLINE_DATA);
2870 static inline int f2fs_exist_data(struct inode *inode)
2872 return is_inode_flag_set(inode, FI_DATA_EXIST);
2875 static inline int f2fs_has_inline_dots(struct inode *inode)
2877 return is_inode_flag_set(inode, FI_INLINE_DOTS);
2880 static inline int f2fs_is_mmap_file(struct inode *inode)
2882 return is_inode_flag_set(inode, FI_MMAP_FILE);
2885 static inline bool f2fs_is_pinned_file(struct inode *inode)
2887 return is_inode_flag_set(inode, FI_PIN_FILE);
2890 static inline bool f2fs_is_atomic_file(struct inode *inode)
2892 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
2895 static inline bool f2fs_is_commit_atomic_write(struct inode *inode)
2897 return is_inode_flag_set(inode, FI_ATOMIC_COMMIT);
2900 static inline bool f2fs_is_volatile_file(struct inode *inode)
2902 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
2905 static inline bool f2fs_is_first_block_written(struct inode *inode)
2907 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
2910 static inline bool f2fs_is_drop_cache(struct inode *inode)
2912 return is_inode_flag_set(inode, FI_DROP_CACHE);
2915 static inline void *inline_data_addr(struct inode *inode, struct page *page)
2918 int extra_size = get_extra_isize(inode);
2923 static inline int f2fs_has_inline_dentry(struct inode *inode)
2925 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
2928 static inline int is_file(struct inode *inode, int type)
2930 return F2FS_I(inode)->i_advise & type;
2933 static inline void set_file(struct inode *inode, int type)
2935 F2FS_I(inode)->i_advise |= type;
2936 f2fs_mark_inode_dirty_sync(inode, true);
2939 static inline void clear_file(struct inode *inode, int type)
2941 F2FS_I(inode)->i_advise &= ~type;
2942 f2fs_mark_inode_dirty_sync(inode, true);
2945 static inline bool f2fs_is_time_consistent(struct inode *inode)
2947 if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime))
2949 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &inode->i_ctime))
2951 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime))
2953 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 3,
2954 &F2FS_I(inode)->i_crtime))
2959 static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
2964 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2967 ret = list_empty(&F2FS_I(inode)->gdirty_list);
2971 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER) ||
2972 file_keep_isize(inode) ||
2973 i_size_read(inode) & ~PAGE_MASK)
2976 if (!f2fs_is_time_consistent(inode))
2979 spin_lock(&F2FS_I(inode)->i_size_lock);
2980 ret = F2FS_I(inode)->last_disk_size == i_size_read(inode);
2981 spin_unlock(&F2FS_I(inode)->i_size_lock);
3007 static inline bool f2fs_may_extent_tree(struct inode *inode)
3009 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3012 is_inode_flag_set(inode, FI_NO_EXTENT) ||
3013 is_inode_flag_set(inode, FI_COMPRESSED_FILE))
3023 return S_ISREG(inode->i_mode);
3060 static inline int get_extra_isize(struct inode *inode)
3062 return F2FS_I(inode)->i_extra_isize / sizeof(__le32);
3065 static inline int get_inline_xattr_addrs(struct inode *inode)
3067 return F2FS_I(inode)->i_inline_xattr_size;
3180 int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock);
3181 int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock);
3182 int f2fs_truncate(struct inode *inode);
3186 int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end);
3188 int f2fs_precache_extents(struct inode *inode);
3191 int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid);
3192 int f2fs_pin_file_control(struct inode *inode, bool inc);
3195 * inode.c
3197 void f2fs_set_inode_flags(struct inode *inode);
3200 struct inode *f2fs_iget(struct super_block *sb, unsigned long ino);
3201 struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino);
3203 void f2fs_update_inode(struct inode *inode, struct page *node_page);
3204 void f2fs_update_inode_page(struct inode *inode);
3205 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
3206 void f2fs_evict_inode(struct inode *inode);
3207 void f2fs_handle_failed_inode(struct inode *inode);
3220 int f2fs_init_casefolded_name(const struct inode *dir,
3222 int f2fs_setup_filename(struct inode *dir, const struct qstr *iname,
3224 int f2fs_prepare_lookup(struct inode *dir, struct dentry *dentry,
3231 void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
3233 struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
3235 void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
3238 void f2fs_drop_nlink(struct inode *dir, struct inode *inode);
3239 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
3242 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
3244 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p);
3245 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
3247 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
3248 struct page *page, struct inode *inode);
3249 bool f2fs_has_enough_room(struct inode *dir, struct page *ipage,
3254 int f2fs_add_regular_entry(struct inode *dir, const struct f2fs_filename *fname,
3255 struct inode *inode, nid_t ino, umode_t mode);
3256 int f2fs_add_dentry(struct inode *dir, const struct f2fs_filename *fname,
3257 struct inode *inode, nid_t ino, umode_t mode);
3258 int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
3259 struct inode *inode, nid_t ino, umode_t mode);
3261 struct inode *dir, struct inode *inode);
3262 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir);
3263 bool f2fs_empty_dir(struct inode *dir);
3265 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
3270 inode, inode->i_ino, inode->i_mode);
3276 int f2fs_inode_dirtied(struct inode *inode, bool sync);
3277 void f2fs_inode_synced(struct inode *inode);
3288 void f2fs_hash_filename(const struct inode *dir, struct f2fs_filename *fname);
3309 int f2fs_truncate_inode_blocks(struct inode *inode, pgoff_t from);
3310 int f2fs_truncate_xattr_node(struct inode *inode);
3313 int f2fs_remove_inode_page(struct inode *inode);
3314 struct page *f2fs_new_inode_page(struct inode *inode);
3321 int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
3332 int f2fs_recover_inline_xattr(struct inode *inode, struct page *page);
3333 int f2fs_recover_xattr_data(struct inode *inode, struct page *page);
3351 void f2fs_register_inmem_page(struct inode *inode, struct page *page);
3353 void f2fs_drop_inmem_pages(struct inode *inode);
3354 void f2fs_drop_inmem_page(struct inode *inode, struct page *page);
3355 int f2fs_commit_inmem_pages(struct inode *inode);
3410 void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr);
3411 void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
3458 void f2fs_add_orphan_inode(struct inode *inode);
3462 void f2fs_update_dirty_page(struct inode *inode, struct page *page);
3463 void f2fs_remove_dirty_inode(struct inode *inode);
3484 struct inode *inode, struct page *page,
3502 struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
3504 struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index);
3505 struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
3507 struct page *f2fs_get_new_data_page(struct inode *inode,
3511 int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
3513 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3516 bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio);
3517 bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio);
3530 bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len);
3542 block_t f2fs_start_bidx_of_node(unsigned int node_ofs, struct inode *inode);
3631 #define stat_inc_inline_xattr(inode) \
3633 if (f2fs_has_inline_xattr(inode)) \
3634 (atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
3636 #define stat_dec_inline_xattr(inode) \
3638 if (f2fs_has_inline_xattr(inode)) \
3639 (atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
3641 #define stat_inc_inline_inode(inode) \
3643 if (f2fs_has_inline_data(inode)) \
3644 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
3646 #define stat_dec_inline_inode(inode) \
3648 if (f2fs_has_inline_data(inode)) \
3649 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
3651 #define stat_inc_inline_dir(inode) \
3653 if (f2fs_has_inline_dentry(inode)) \
3654 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
3656 #define stat_dec_inline_dir(inode) \
3658 if (f2fs_has_inline_dentry(inode)) \
3659 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
3661 #define stat_inc_compr_inode(inode) \
3663 if (f2fs_compressed_file(inode)) \
3664 (atomic_inc(&F2FS_I_SB(inode)->compr_inode)); \
3666 #define stat_dec_compr_inode(inode) \
3668 if (f2fs_compressed_file(inode)) \
3669 (atomic_dec(&F2FS_I_SB(inode)->compr_inode)); \
3671 #define stat_add_compr_blocks(inode, blocks) \
3672 (atomic64_add(blocks, &F2FS_I_SB(inode)->compr_blocks))
3673 #define stat_sub_compr_blocks(inode, blocks) \
3674 (atomic64_sub(blocks, &F2FS_I_SB(inode)->compr_blocks))
3692 #define stat_update_max_atomic_write(inode) \
3694 int cur = F2FS_I_SB(inode)->atomic_files; \
3695 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
3697 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
3699 #define stat_inc_volatile_write(inode) \
3700 (atomic_inc(&F2FS_I_SB(inode)->vw_cnt))
3701 #define stat_dec_volatile_write(inode) \
3702 (atomic_dec(&F2FS_I_SB(inode)->vw_cnt))
3703 #define stat_update_max_volatile_write(inode) \
3705 int cur = atomic_read(&F2FS_I_SB(inode)->vw_cnt); \
3706 int max = atomic_read(&F2FS_I_SB(inode)->max_vw_cnt); \
3708 atomic_set(&F2FS_I_SB(inode)->max_vw_cnt, cur); \
3760 #define stat_inc_inline_xattr(inode) do { } while (0)
3761 #define stat_dec_inline_xattr(inode) do { } while (0)
3762 #define stat_inc_inline_inode(inode) do { } while (0)
3763 #define stat_dec_inline_inode(inode) do { } while (0)
3764 #define stat_inc_inline_dir(inode) do { } while (0)
3765 #define stat_dec_inline_dir(inode) do { } while (0)
3766 #define stat_inc_compr_inode(inode) do { } while (0)
3767 #define stat_dec_compr_inode(inode) do { } while (0)
3768 #define stat_add_compr_blocks(inode, blocks) do { } while (0)
3769 #define stat_sub_compr_blocks(inode, blocks) do { } while (0)
3770 #define stat_inc_atomic_write(inode) do { } while (0)
3771 #define stat_dec_atomic_write(inode) do { } while (0)
3772 #define stat_update_max_atomic_write(inode) do { } while (0)
3773 #define stat_inc_volatile_write(inode) do { } while (0)
3774 #define stat_dec_volatile_write(inode) do { } while (0)
3775 #define stat_update_max_volatile_write(inode) do { } while (0)
3810 bool f2fs_may_inline_data(struct inode *inode);
3811 bool f2fs_sanity_check_inline_data(struct inode *inode);
3812 bool f2fs_may_inline_dentry(struct inode *inode);
3814 void f2fs_truncate_inline_inode(struct inode *inode,
3816 int f2fs_read_inline_data(struct inode *inode, struct page *page);
3818 int f2fs_convert_inline_inode(struct inode *inode);
3819 int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry);
3820 int f2fs_write_inline_data(struct inode *inode, struct page *page);
3821 int f2fs_recover_inline_data(struct inode *inode, struct page *npage);
3822 struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
3825 int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
3827 int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname,
3828 struct inode *inode, nid_t ino, umode_t mode);
3830 struct page *page, struct inode *dir,
3831 struct inode *inode);
3832 bool f2fs_empty_inline_dir(struct inode *dir);
3835 int f2fs_inline_data_fiemap(struct inode *inode,
3870 void f2fs_init_extent_tree(struct inode *inode, struct page *ipage);
3871 void f2fs_drop_extent_tree(struct inode *inode);
3872 unsigned int f2fs_destroy_extent_node(struct inode *inode);
3873 void f2fs_destroy_extent_tree(struct inode *inode);
3874 bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
3897 static inline bool f2fs_encrypted_file(struct inode *inode)
3899 return IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
3902 static inline void f2fs_set_encrypted_inode(struct inode *inode)
3905 file_set_encrypt(inode);
3906 f2fs_set_inode_flags(inode);
3911 * Returns true if the reads of the inode's data need to undergo some
3914 static inline bool f2fs_post_read_required(struct inode *inode)
3916 return f2fs_encrypted_file(inode) || fsverity_active(inode) ||
3917 f2fs_compressed_file(inode);
3926 int f2fs_prepare_compress_overwrite(struct inode *inode,
3928 bool f2fs_compress_write_end(struct inode *inode, void *fsdata,
3930 int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock);
3932 bool f2fs_is_compress_backend_ready(struct inode *inode);
3943 int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index);
3960 static inline bool f2fs_is_compress_backend_ready(struct inode *inode)
3962 if (!f2fs_compressed_file(inode))
3980 static inline void set_compress_context(struct inode *inode)
3982 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3984 F2FS_I(inode)->i_compress_algorithm =
3986 F2FS_I(inode)->i_log_cluster_size =
3988 F2FS_I(inode)->i_cluster_size =
3989 1 << F2FS_I(inode)->i_log_cluster_size;
3990 F2FS_I(inode)->i_flags |= F2FS_COMPR_FL;
3991 set_inode_flag(inode, FI_COMPRESSED_FILE);
3992 stat_inc_compr_inode(inode);
3993 f2fs_mark_inode_dirty_sync(inode, true);
3996 static inline bool f2fs_disable_compressed_file(struct inode *inode)
3998 struct f2fs_inode_info *fi = F2FS_I(inode);
4000 if (!f2fs_compressed_file(inode))
4002 if (S_ISREG(inode->i_mode) && F2FS_HAS_BLOCKS(inode))
4006 stat_dec_compr_inode(inode);
4007 clear_inode_flag(inode, FI_COMPRESSED_FILE);
4008 f2fs_mark_inode_dirty_sync(inode, true);
4090 static inline bool f2fs_may_compress(struct inode *inode)
4092 if (IS_SWAPFILE(inode) || f2fs_is_pinned_file(inode) ||
4093 f2fs_is_atomic_file(inode) ||
4094 f2fs_is_volatile_file(inode))
4096 return S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode);
4099 static inline void f2fs_i_compr_blocks_update(struct inode *inode,
4102 int diff = F2FS_I(inode)->i_cluster_size - blocks;
4103 struct f2fs_inode_info *fi = F2FS_I(inode);
4111 stat_add_compr_blocks(inode, diff);
4114 stat_sub_compr_blocks(inode, diff);
4116 f2fs_mark_inode_dirty_sync(inode, true);
4119 static inline int block_unaligned_IO(struct inode *inode,
4122 unsigned int i_blkbits = READ_ONCE(inode->i_blkbits);
4130 static inline int allow_outplace_dio(struct inode *inode,
4133 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4137 !block_unaligned_IO(inode, iocb, iter));
4140 static inline bool f2fs_force_buffered_io(struct inode *inode,
4143 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4146 if (f2fs_post_read_required(inode))
4157 if (block_unaligned_IO(inode, iocb, iter))
4162 if (is_sbi_flag_set(F2FS_I_SB(inode), SBI_CP_DISABLED) &&
4163 !IS_SWAPFILE(inode))