linux-next: manual merge of the fs-next tree with the mm tree

linux-next: manual merge of the fs-next tree with the mm tree

[Mark Brown]

[-- Attachment #1: Type: text/plain, Size: 19825 bytes --]

Hi all,


Today's linux-next merge of the fs-next tree got a conflict in:

  fs/f2fs/f2fs.h

between commit:

  08071592211dc ("f2fs: stop using PG_private")
  32e05e39cb443 ("f2fs: convert the ->private flag helpers to folio-only")

from the mm tree and commit:

  60105162524e9 ("f2fs: stop using PG_private")

from the fs-next tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --combined fs/f2fs/f2fs.h
index 85937de3d7016,ebc621f302e14..0000000000000
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@@ -466,6 -466,7 +466,7 @@@ struct discard_entry 
  #define MAX_PLIST_NUM		512
  #define plist_idx(blk_num)	((blk_num) >= MAX_PLIST_NUM ?		\
  					(MAX_PLIST_NUM - 1) : ((blk_num) - 1))
+ #define MAX_DISCARD_DROP_COUNT	512
  
  enum {
  	D_PREP,			/* initial */
@@@ -602,8 -603,9 +603,9 @@@ static inline int update_sits_in_cursum
  #define DEF_INLINE_RESERVED_SIZE	1
  static inline int get_extra_isize(struct inode *inode);
  static inline int get_inline_xattr_addrs(struct inode *inode);
+ static inline unsigned int cur_addrs_per_inode(struct inode *inode);
  #define MAX_INLINE_DATA(inode)	(sizeof(__le32) *			\
- 				(CUR_ADDRS_PER_INODE(inode) -		\
+ 				(cur_addrs_per_inode(inode) -		\
  				get_inline_xattr_addrs(inode) -	\
  				DEF_INLINE_RESERVED_SIZE))
  
@@@ -669,17 -671,6 +671,6 @@@ struct f2fs_dentry_ptr 
  	int nr_bitmap;
  };
  
- static inline void make_dentry_ptr_block(struct inode *inode,
- 		struct f2fs_dentry_ptr *d, struct f2fs_dentry_block *t)
- {
- 	d->inode = inode;
- 	d->max = NR_DENTRY_IN_BLOCK;
- 	d->nr_bitmap = SIZE_OF_DENTRY_BITMAP;
- 	d->bitmap = t->dentry_bitmap;
- 	d->dentry = t->dentry;
- 	d->filename = t->filename;
- }
- 
  static inline void make_dentry_ptr_inline(struct inode *inode,
  					struct f2fs_dentry_ptr *d, void *t)
  {
@@@ -1357,7 -1348,10 +1348,7 @@@ struct f2fs_io_info 
  	blk_opf_t op_flags;	/* req_flag_bits */
  	block_t new_blkaddr;	/* new block address to be written */
  	block_t old_blkaddr;	/* old block address before Cow */
 -	union {
 -		struct page *page;	/* page to be written */
 -		struct folio *folio;
 -	};
 +	struct folio *folio;	/* folio to be written */
  	struct page *encrypted_page;	/* encrypted page */
  	struct page *compressed_page;	/* compressed page */
  	struct list_head list;		/* serialize IOs */
@@@ -1610,27 -1604,27 +1601,27 @@@ static inline void f2fs_set_bit(unsigne
  static inline void f2fs_clear_bit(unsigned int nr, char *addr);
  
  /*
 - * Layout of f2fs page.private:
 + * Layout of f2fs folio->private:
   *
   * Layout A: lowest bit should be 1
   * | bit0 = 1 | bit1 | bit2 | ... | bit MAX | private data .... |
 - * bit 0	PAGE_PRIVATE_NOT_POINTER
 - * bit 1	PAGE_PRIVATE_ONGOING_MIGRATION
 - * bit 2	PAGE_PRIVATE_INLINE_INODE
 - * bit 3	PAGE_PRIVATE_REF_RESOURCE
 - * bit 4	PAGE_PRIVATE_ATOMIC_WRITE
 + * bit 0	F2FS_FOLIO_PRIVATE_NOT_POINTER
 + * bit 1	F2FS_FOLIO_PRIVATE_ONGOING_MIGRATION
 + * bit 2	F2FS_FOLIO_PRIVATE_INLINE_INODE
 + * bit 3	F2FS_FOLIO_PRIVATE_REF_RESOURCE
 + * bit 4	F2FS_FOLIO_PRIVATE_ATOMIC_WRITE
   * bit 5-	f2fs private data
   *
   * Layout B: lowest bit should be 0
 - * page.private is a wrapped pointer.
 + * folio->private is a wrapped pointer.
   */
  enum {
 -	PAGE_PRIVATE_NOT_POINTER,		/* private contains non-pointer data */
 -	PAGE_PRIVATE_ONGOING_MIGRATION,		/* data page which is on-going migrating */
 -	PAGE_PRIVATE_INLINE_INODE,		/* inode page contains inline data */
 -	PAGE_PRIVATE_REF_RESOURCE,		/* dirty page has referenced resources */
 -	PAGE_PRIVATE_ATOMIC_WRITE,		/* data page from atomic write path */
 -	PAGE_PRIVATE_MAX
 +	F2FS_FOLIO_PRIVATE_NOT_POINTER,		/* private contains non-pointer data */
 +	F2FS_FOLIO_PRIVATE_ONGOING_MIGRATION,		/* data page which is on-going migrating */
 +	F2FS_FOLIO_PRIVATE_INLINE_INODE,		/* inode page contains inline data */
 +	F2FS_FOLIO_PRIVATE_REF_RESOURCE,		/* dirty page has referenced resources */
 +	F2FS_FOLIO_PRIVATE_ATOMIC_WRITE,		/* data page from atomic write path */
 +	F2FS_FOLIO_PRIVATE_MAX
  };
  
  /* For compression */
@@@ -1859,6 -1853,15 +1850,15 @@@ struct f2fs_sb_info 
  	unsigned int log_sectors_per_block;	/* log2 sectors per block */
  	unsigned int log_blocksize;		/* log2 block size */
  	unsigned int blocksize;			/* block size */
+ 	unsigned int nat_entries_per_block;	/* NAT entries in a block */
+ 	unsigned int addrs_per_inode;		/* addresses in an inode block */
+ 	unsigned int addrs_per_block;		/* addresses in a direct node block */
+ 	unsigned int nids_per_block;		/* node IDs in an indirect node block */
+ 	unsigned int sit_entries_per_block;	/* SIT entries in a block */
+ 	unsigned int orphans_per_block;	/* orphan inodes in a block */
+ 	unsigned int dentries_per_block;	/* dentries in a block */
+ 	unsigned int dentry_bitmap_size;	/* dentry bitmap size in bytes */
+ 	unsigned int dentry_reserved_size;	/* dentry reserved bytes */
  	unsigned int root_ino_num;		/* root inode number*/
  	unsigned int node_ino_num;		/* node inode number*/
  	unsigned int meta_ino_num;		/* meta inode number*/
@@@ -2247,6 -2250,47 +2247,47 @@@ static inline struct f2fs_sb_info *F2FS
  	return F2FS_M_SB(folio->mapping);
  }
  
+ #define SIT_ENTRY_PER_BLOCK(sbi)	((sbi)->sit_entries_per_block)
+ #define NAT_ENTRY_PER_BLOCK(sbi)	((sbi)->nat_entries_per_block)
+ #define DEF_ADDRS_PER_INODE(sbi)	((sbi)->addrs_per_inode)
+ #define DEF_ADDRS_PER_BLOCK(sbi)	((sbi)->addrs_per_block)
+ #define NIDS_PER_BLOCK(sbi)		((sbi)->nids_per_block)
+ #define F2FS_ORPHANS_PER_BLOCK(sbi)	((sbi)->orphans_per_block)
+ #define GET_ORPHAN_BLOCKS(sbi, n)	DIV_ROUND_UP((n), \
+ 					F2FS_ORPHANS_PER_BLOCK(sbi))
+ #define CP_CHKSUM_OFFSET(sbi)		(F2FS_BLKSIZE(sbi) - sizeof(__le32))
+ 
+ #define NODE_DIR1_BLOCK(sbi)		(DEF_ADDRS_PER_INODE(sbi) + 1)
+ #define NODE_DIR2_BLOCK(sbi)		(DEF_ADDRS_PER_INODE(sbi) + 2)
+ #define NODE_IND1_BLOCK(sbi)		(DEF_ADDRS_PER_INODE(sbi) + 3)
+ #define NODE_IND2_BLOCK(sbi)		(DEF_ADDRS_PER_INODE(sbi) + 4)
+ #define NODE_DIND_BLOCK(sbi)		(DEF_ADDRS_PER_INODE(sbi) + 5)
+ 
+ static inline struct f2fs_orphan_footer *
+ f2fs_orphan_footer(void *orphan_block, struct f2fs_sb_info *sbi)
+ {
+ 	return (struct f2fs_orphan_footer *)
+ 		((char *)orphan_block + sbi->blocksize -
+ 		 sizeof(struct f2fs_orphan_footer));
+ }
+ 
+ static inline void make_dentry_ptr_block(struct inode *inode,
+ 				struct f2fs_dentry_ptr *d, void *t)
+ {
+ 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ 	unsigned int entries = sbi->dentries_per_block;
+ 	unsigned int bitmap_size = sbi->dentry_bitmap_size;
+ 	unsigned int reserved_size = sbi->dentry_reserved_size;
+ 
+ 	d->inode = inode;
+ 	d->max = entries;
+ 	d->nr_bitmap = bitmap_size;
+ 	d->bitmap = t;
+ 	d->dentry = t + bitmap_size + reserved_size;
+ 	d->filename = t + bitmap_size + reserved_size +
+ 					SIZE_OF_DIR_ENTRY * entries;
+ }
+ 
  static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
  {
  	return (struct f2fs_super_block *)(sbi->raw_super);
@@@ -2267,6 -2311,13 +2308,13 @@@ static inline struct f2fs_checkpoint *F
  	return (struct f2fs_checkpoint *)(sbi->ckpt);
  }
  
+ static inline struct node_footer *F2FS_NODE_FOOTER(struct f2fs_sb_info *sbi,
+ 						const struct folio *folio)
+ {
+ 	return folio_address(folio) + F2FS_BLKSIZE(sbi) -
+ 		sizeof(struct node_footer);
+ }
+ 
  static inline struct f2fs_node *F2FS_NODE(const struct folio *folio)
  {
  	return (struct f2fs_node *)folio_address(folio);
@@@ -2277,6 -2328,14 +2325,14 @@@ static inline struct f2fs_inode *F2FS_I
  	return &((struct f2fs_node *)folio_address(folio))->i;
  }
  
+ static inline __le32 *F2FS_INODE_NIDS(struct f2fs_sb_info *sbi,
+ 						const struct folio *folio)
+ {
+ 	return folio_address(folio) + F2FS_BLKSIZE(sbi) -
+ 		sizeof(struct node_footer) -
+ 		SIZE_OF_I_NID;
+ }
+ 
  static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
  {
  	return (struct f2fs_nm_info *)(sbi->nm_info);
@@@ -2312,14 -2371,14 +2368,14 @@@ static inline struct address_space *NOD
  	return sbi->node_inode->i_mapping;
  }
  
- static inline bool is_meta_folio(struct folio *folio)
+ static inline bool is_meta_folio(struct f2fs_sb_info *sbi, struct folio *folio)
  {
- 	return folio->mapping == META_MAPPING(F2FS_F_SB(folio));
+ 	return folio->mapping == META_MAPPING(sbi);
  }
  
- static inline bool is_node_folio(struct folio *folio)
+ static inline bool is_node_folio(struct f2fs_sb_info *sbi, struct folio *folio)
  {
- 	return folio->mapping == NODE_MAPPING(F2FS_F_SB(folio));
+ 	return folio->mapping == NODE_MAPPING(sbi);
  }
  
  static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
@@@ -2563,7 -2622,8 +2619,8 @@@ static inline int F2FS_HAS_BLOCKS(struc
  {
  	block_t xattr_block = F2FS_I(inode)->i_xattr_nid ? 1 : 0;
  
- 	return (inode->i_blocks >> F2FS_LOG_SECTORS_PER_BLOCK) > xattr_block;
+ 	return (inode->i_blocks >>
+ 		F2FS_LOG_SECTORS_PER_BLOCK(F2FS_I_SB(inode))) > xattr_block;
  }
  
  static inline bool f2fs_has_xattr_block(unsigned int ofs)
@@@ -2678,68 -2738,86 +2735,68 @@@ release_quota
  	return -ENOSPC;
  }
  
 -#define PAGE_PRIVATE_GET_FUNC(name, flagname) \
 +#define F2FS_FOLIO_PRIVATE_GET_FUNC(name, flagname) \
  static inline bool folio_test_f2fs_##name(const struct folio *folio)	\
  {									\
  	unsigned long priv = (unsigned long)folio->private;		\
 -	unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) |		\
 -			     (1UL << PAGE_PRIVATE_##flagname);		\
 +	unsigned long v = (1UL << F2FS_FOLIO_PRIVATE_NOT_POINTER) |	\
 +			     (1UL << F2FS_FOLIO_PRIVATE_##flagname);	\
  	return (priv & v) == v;						\
 -}									\
 -static inline bool page_private_##name(struct page *page) \
 -{ \
 -	return page_private(page) && \
 -		test_bit(PAGE_PRIVATE_NOT_POINTER, &page_private(page)) && \
 -		test_bit(PAGE_PRIVATE_##flagname, &page_private(page)); \
  }
  
 -#define PAGE_PRIVATE_SET_FUNC(name, flagname) \
 +#define F2FS_FOLIO_PRIVATE_SET_FUNC(name, flagname) \
  static inline void folio_set_f2fs_##name(struct folio *folio)		\
  {									\
 -	unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) |		\
 -			     (1UL << PAGE_PRIVATE_##flagname);		\
 +	unsigned long v = (1UL << F2FS_FOLIO_PRIVATE_NOT_POINTER) |	\
 +			     (1UL << F2FS_FOLIO_PRIVATE_##flagname);	\
  	if (!folio->private)						\
  		folio_attach_private(folio, (void *)v);			\
  	else {								\
  		v |= (unsigned long)folio->private;			\
  		folio->private = (void *)v;				\
  	}								\
 -}									\
 -static inline void set_page_private_##name(struct page *page) \
 -{ \
 -	if (!page_private(page)) \
 -		attach_page_private(page, \
 -				(void *)BIT(PAGE_PRIVATE_NOT_POINTER)); \
 -	set_bit(PAGE_PRIVATE_##flagname, &page_private(page)); \
  }
  
 -#define PAGE_PRIVATE_CLEAR_FUNC(name, flagname) \
 +#define F2FS_FOLIO_PRIVATE_CLEAR_FUNC(name, flagname) \
  static inline void folio_clear_f2fs_##name(struct folio *folio)		\
  {									\
  	unsigned long v = (unsigned long)folio->private;		\
  									\
 -	v &= ~(1UL << PAGE_PRIVATE_##flagname);				\
 -	if (v == (1UL << PAGE_PRIVATE_NOT_POINTER))			\
 +	v &= ~(1UL << F2FS_FOLIO_PRIVATE_##flagname);			\
 +	if (v == (1UL << F2FS_FOLIO_PRIVATE_NOT_POINTER))		\
  		folio_detach_private(folio);				\
  	else								\
  		folio->private = (void *)v;				\
 -}									\
 -static inline void clear_page_private_##name(struct page *page) \
 -{ \
 -	clear_bit(PAGE_PRIVATE_##flagname, &page_private(page)); \
 -	if (page_private(page) == BIT(PAGE_PRIVATE_NOT_POINTER)) \
 -		detach_page_private(page); \
  }
  
 -PAGE_PRIVATE_GET_FUNC(nonpointer, NOT_POINTER);
 -PAGE_PRIVATE_GET_FUNC(inline, INLINE_INODE);
 -PAGE_PRIVATE_GET_FUNC(gcing, ONGOING_MIGRATION);
 -PAGE_PRIVATE_GET_FUNC(atomic, ATOMIC_WRITE);
 +F2FS_FOLIO_PRIVATE_GET_FUNC(nonpointer, NOT_POINTER);
 +F2FS_FOLIO_PRIVATE_GET_FUNC(inline, INLINE_INODE);
 +F2FS_FOLIO_PRIVATE_GET_FUNC(gcing, ONGOING_MIGRATION);
 +F2FS_FOLIO_PRIVATE_GET_FUNC(atomic, ATOMIC_WRITE);
  
 -PAGE_PRIVATE_SET_FUNC(reference, REF_RESOURCE);
 -PAGE_PRIVATE_SET_FUNC(inline, INLINE_INODE);
 -PAGE_PRIVATE_SET_FUNC(gcing, ONGOING_MIGRATION);
 -PAGE_PRIVATE_SET_FUNC(atomic, ATOMIC_WRITE);
 +F2FS_FOLIO_PRIVATE_SET_FUNC(reference, REF_RESOURCE);
 +F2FS_FOLIO_PRIVATE_SET_FUNC(inline, INLINE_INODE);
 +F2FS_FOLIO_PRIVATE_SET_FUNC(gcing, ONGOING_MIGRATION);
 +F2FS_FOLIO_PRIVATE_SET_FUNC(atomic, ATOMIC_WRITE);
  
 -PAGE_PRIVATE_CLEAR_FUNC(reference, REF_RESOURCE);
 -PAGE_PRIVATE_CLEAR_FUNC(inline, INLINE_INODE);
 -PAGE_PRIVATE_CLEAR_FUNC(gcing, ONGOING_MIGRATION);
 -PAGE_PRIVATE_CLEAR_FUNC(atomic, ATOMIC_WRITE);
 +F2FS_FOLIO_PRIVATE_CLEAR_FUNC(reference, REF_RESOURCE);
 +F2FS_FOLIO_PRIVATE_CLEAR_FUNC(inline, INLINE_INODE);
 +F2FS_FOLIO_PRIVATE_CLEAR_FUNC(gcing, ONGOING_MIGRATION);
 +F2FS_FOLIO_PRIVATE_CLEAR_FUNC(atomic, ATOMIC_WRITE);
  
  static inline unsigned long folio_get_f2fs_data(struct folio *folio)
  {
  	unsigned long data = (unsigned long)folio->private;
  
 -	if (!test_bit(PAGE_PRIVATE_NOT_POINTER, &data))
 +	if (!test_bit(F2FS_FOLIO_PRIVATE_NOT_POINTER, &data))
  		return 0;
 -	return data >> PAGE_PRIVATE_MAX;
 +	return data >> F2FS_FOLIO_PRIVATE_MAX;
  }
  
  static inline void folio_set_f2fs_data(struct folio *folio, unsigned long data)
  {
 -	data = (1UL << PAGE_PRIVATE_NOT_POINTER) | (data << PAGE_PRIVATE_MAX);
 +	data = (1UL << F2FS_FOLIO_PRIVATE_NOT_POINTER) |
 +	       (data << F2FS_FOLIO_PRIVATE_MAX);
  
  	if (!folio_test_private(folio))
  		folio_attach_private(folio, (void *)data);
@@@ -2751,7 -2829,7 +2808,7 @@@ static inline void dec_valid_block_coun
  						struct inode *inode,
  						block_t count)
  {
- 	blkcnt_t sectors = count << F2FS_LOG_SECTORS_PER_BLOCK;
+ 	blkcnt_t sectors = count << F2FS_LOG_SECTORS_PER_BLOCK(sbi);
  
  	spin_lock(&sbi->stat_lock);
  	if (unlikely(sbi->total_valid_block_count < count)) {
@@@ -2903,7 -2981,7 +2960,7 @@@ static inline void *__bitmap_ptr(struc
  		if (flag == NAT_BITMAP)
  			return tmp_ptr;
  		else
- 			return (unsigned char *)ckpt + F2FS_BLKSIZE;
+ 			return (unsigned char *)ckpt + F2FS_BLKSIZE(sbi);
  	} else {
  		offset = (flag == NAT_BITMAP) ?
  			le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
@@@ -3229,13 -3307,11 +3286,11 @@@ static inline void f2fs_radix_tree_inse
  		cond_resched();
  }
  
- #define RAW_IS_INODE(p)	((p)->footer.nid == (p)->footer.ino)
- 
- static inline bool IS_INODE(const struct folio *folio)
+ static inline bool IS_INODE(struct f2fs_sb_info *sbi, const struct folio *folio)
  {
- 	struct f2fs_node *p = F2FS_NODE(folio);
+ 	struct node_footer *footer = F2FS_NODE_FOOTER(sbi, folio);
  
- 	return RAW_IS_INODE(p);
+ 	return footer->nid == footer->ino;
  }
  
  static inline int offset_in_addr(struct f2fs_inode *i)
@@@ -3244,16 -3320,22 +3299,22 @@@
  			(le16_to_cpu(i->i_extra_isize) / sizeof(__le32)) : 0;
  }
  
- static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
+ static inline __le32 *blkaddr_in_node(struct f2fs_sb_info *sbi,
+ 						const struct folio *folio)
  {
- 	return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
+ 	struct f2fs_node *node = F2FS_NODE(folio);
+ 
+ 	return IS_INODE(sbi, folio) ? node->i.i_addr : node->dn.addr;
  }
  
  static inline int f2fs_has_extra_attr(struct inode *inode);
  static inline unsigned int get_dnode_base(struct inode *inode,
  					struct folio *node_folio)
  {
- 	if (!IS_INODE(node_folio))
+ 	struct f2fs_sb_info *sbi = inode ? F2FS_I_SB(inode) :
+ 					F2FS_F_SB(node_folio);
+ 
+ 	if (!IS_INODE(sbi, node_folio))
  		return 0;
  
  	return inode ? get_extra_isize(inode) :
@@@ -3263,7 -3345,10 +3324,10 @@@
  static inline __le32 *get_dnode_addr(struct inode *inode,
  					struct folio *node_folio)
  {
- 	return blkaddr_in_node(F2FS_NODE(node_folio)) +
+ 	struct f2fs_sb_info *sbi = inode ? F2FS_I_SB(inode) :
+ 					F2FS_F_SB(node_folio);
+ 
+ 	return blkaddr_in_node(sbi, node_folio) +
  			get_dnode_base(inode, node_folio);
  }
  
@@@ -3578,20 -3663,26 +3642,26 @@@ static inline bool f2fs_need_compress_d
  static inline unsigned int addrs_per_page(struct inode *inode,
  							bool is_inode)
  {
- 	unsigned int addrs = is_inode ? (CUR_ADDRS_PER_INODE(inode) -
- 			get_inline_xattr_addrs(inode)) : DEF_ADDRS_PER_BLOCK;
+ 	unsigned int addrs = is_inode ? (cur_addrs_per_inode(inode) -
+ 			get_inline_xattr_addrs(inode)) :
+ 			DEF_ADDRS_PER_BLOCK(F2FS_I_SB(inode));
  
  	if (f2fs_compressed_file(inode))
  		return ALIGN_DOWN(addrs, F2FS_I(inode)->i_cluster_size);
  	return addrs;
  }
  
+ static inline unsigned int cur_addrs_per_inode(struct inode *inode)
+ {
+ 	return DEF_ADDRS_PER_INODE(F2FS_I_SB(inode)) - get_extra_isize(inode);
+ }
+ 
  static inline
  void *inline_xattr_addr(struct inode *inode, const struct folio *folio)
  {
  	struct f2fs_inode *ri = F2FS_INODE(folio);
  
- 	return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
+ 	return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE(F2FS_I_SB(inode)) -
  					get_inline_xattr_addrs(inode)]);
  }
  
@@@ -3951,7 -4042,7 +4021,7 @@@ void f2fs_inode_synced(struct inode *in
  int f2fs_dquot_initialize(struct inode *inode);
  int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);
  int f2fs_do_quota_sync(struct super_block *sb, int type);
- loff_t max_file_blocks(struct inode *inode);
+ loff_t max_file_blocks(struct f2fs_sb_info *sbi, struct inode *inode);
  void f2fs_quota_off_umount(struct super_block *sb);
  void f2fs_save_errors(struct f2fs_sb_info *sbi, unsigned char flag);
  void f2fs_handle_error(struct f2fs_sb_info *sbi, unsigned char error);
@@@ -3972,7 -4063,7 +4042,7 @@@ enum node_type
  
  int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid);
  bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type);
- bool f2fs_in_warm_node_list(struct folio *folio);
+ bool f2fs_in_warm_node_list(struct f2fs_sb_info *sbi, struct folio *folio);
  void f2fs_init_fsync_node_info(struct f2fs_sb_info *sbi);
  void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct folio *folio);
  void f2fs_reset_fsync_node_info(struct f2fs_sb_info *sbi);
@@@ -4043,6 -4134,8 +4113,8 @@@ void f2fs_reserve_device_alias(struct f
  bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
  int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
  void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
+ void f2fs_drop_discard_cmd_range(struct f2fs_sb_info *sbi,
+ 					block_t start, block_t len);
  void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi);
  bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi, bool need_check);
  void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
@@@ -5197,8 -5290,9 +5269,9 @@@ static inline void f2fs_truncate_meta_i
  							NULL, 0, DATA);
  
  	truncate_inode_pages_range(META_MAPPING(sbi),
- 			F2FS_BLK_TO_BYTES((loff_t)blkaddr),
- 			F2FS_BLK_END_BYTES((loff_t)(blkaddr + cnt - 1)));
+ 			F2FS_BLK_TO_BYTES(sbi, (loff_t)blkaddr),
+ 			F2FS_BLK_END_BYTES(sbi,
+ 					    (loff_t)(blkaddr + cnt - 1)));
  }
  
  static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi,

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

Re: linux-next: manual merge of the fs-next tree with the mm tree

[Andrew Morton]

On Thu, 17 Sep 2026 15:48:10 +0100 Mark Brown <broonie@kernel.org> wrote:

> Hi all,
> 
> 
> Today's linux-next merge of the fs-next tree got a conflict in:
> 
>   fs/f2fs/f2fs.h
> 
> between commit:
> 
>   08071592211dc ("f2fs: stop using PG_private")
>   32e05e39cb443 ("f2fs: convert the ->private flag helpers to folio-only")
> 
> from the mm tree and commit:
> 
>   60105162524e9 ("f2fs: stop using PG_private")
> 
> from the fs-next tree.

It's risky to cherrypick a couple of patches from a 16-patch series and
carry them in a separate tree.  It'll all end up OK in the end, but who
verifies that these two are OK as standalone things?

Also, as the changelogs say,

"It prepares for a future commit that removes PG_private"

and that removal is in mm.git as [16/16], so I'll need to retain these
patches so mm.git compiles.

It would have been preferable for the f2fs maintainers to have simply
sent along their acks so all this work can remain in the same place.

I'll continue to hold the f2fs patches in mm.git.  Which means they
might hit mainline before the f2fs tree is merged.  Or after. 
Hopefully Linus's git will figure it out.

Re: linux-next: manual merge of the fs-next tree with the mm tree

[Jaegeuk Kim]

On 09/17, Andrew Morton wrote:
> On Thu, 17 Sep 2026 15:48:10 +0100 Mark Brown <broonie@kernel.org> wrote:
> 
> > Hi all,
> > 
> > 
> > Today's linux-next merge of the fs-next tree got a conflict in:
> > 
> >   fs/f2fs/f2fs.h
> > 
> > between commit:
> > 
> >   08071592211dc ("f2fs: stop using PG_private")
> >   32e05e39cb443 ("f2fs: convert the ->private flag helpers to folio-only")
> > 
> > from the mm tree and commit:
> > 
> >   60105162524e9 ("f2fs: stop using PG_private")
> > 
> > from the fs-next tree.
> 
> It's risky to cherrypick a couple of patches from a 16-patch series and
> carry them in a separate tree.  It'll all end up OK in the end, but who
> verifies that these two are OK as standalone things?

I applied the first patch only which looked a standalone. Though, let me
drop it and see how it'll give the conflicts with other f2fs patches.

> 
> Also, as the changelogs say,
> 
> "It prepares for a future commit that removes PG_private"
> 
> and that removal is in mm.git as [16/16], so I'll need to retain these
> patches so mm.git compiles.
> 
> It would have been preferable for the f2fs maintainers to have simply
> sent along their acks so all this work can remain in the same place.
> 
> I'll continue to hold the f2fs patches in mm.git.  Which means they
> might hit mainline before the f2fs tree is merged.  Or after. 
> Hopefully Linus's git will figure it out.
> 

linux-next: manual merge of the fs-next tree with the mm tree

[Mark Brown]

[-- Attachment #1: Type: text/plain, Size: 1109 bytes --]

Hi all,

Today's linux-next merge of the fs-next tree got a conflict in:

  fs/fuse/dax.c

between commit:

  e0adb1736318a ("fuse: dax: do not set VM_MIXEDMAP")

from the mm tree and commit:

  c1f6e67c4fe74 ("fuse: mark DAX VMA page protections as decrypted")

from the fs-next tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --cc fs/fuse/dax.c
index a5994f1c637d9,32c88ef814340..0000000000000
--- a/fs/fuse/dax.c
+++ b/fs/fuse/dax.c
@@@ -826,7 -826,8 +826,8 @@@ int fuse_dax_mmap(struct file *file, st
  {
  	file_accessed(file);
  	vma->vm_ops = &fuse_dax_vm_ops;
 -	vm_flags_set(vma, VM_MIXEDMAP | VM_HUGEPAGE);
 +	vma_set_flags(vma, VMA_HUGEPAGE_BIT);
+ 	vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
  	return 0;
  }
  

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

linux-next: manual merge of the fs-next tree with the mm tree

[Mark Brown]

[-- Attachment #1: Type: text/plain, Size: 1397 bytes --]

Hi all,

Today's linux-next merge of the fs-next tree got a conflict in:

  fs/coredump.c

between commit:

  85082b509089a ("mm: rename is_vm_hugetlb_page() to vma_is_hugetlb()")

from the mm tree and commit:

  ed84b0b1d0bec ("coredump: select memory types to include")

from the fs-next tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --cc fs/coredump.c
index 4d03826dd2498,668debe0cb97f..0000000000000
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@@ -1608,10 -1831,12 +1831,12 @@@ static unsigned long vma_dump_size(stru
  	}
  
  	/* Hugetlb memory check */
 -	if (is_vm_hugetlb_page(vma)) {
 +	if (vma_is_hugetlb(vma)) {
- 		if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
+ 		if ((vma->vm_flags & VM_SHARED) &&
+ 		    COREDUMP_MEMORY_TYPE_INCLUDE(memory_types, HUGETLB_SHARED))
  			goto whole;
- 		if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
+ 		if (!(vma->vm_flags & VM_SHARED) &&
+ 		    COREDUMP_MEMORY_TYPE_INCLUDE(memory_types, HUGETLB_PRIVATE))
  			goto whole;
  		return 0;
  	}

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]