5.5 20200203

Signed-off-by: J. R. Okajima <hooanon05g@gmail.com>

aufs5-base.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 base patch
+
+diff --git a/MAINTAINERS b/MAINTAINERS
+index 56765f542244..edbd784b8a87 100644
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -2877,6 +2877,19 @@ F:	include/linux/audit.h
+ F:	include/uapi/linux/audit.h
+ F:	kernel/audit*
+ 
++AUFS (advanced multi layered unification filesystem) FILESYSTEM
++M:	"J. R. Okajima" <hooanon05g@gmail.com>
++L:	aufs-users@lists.sourceforge.net (members only)
++L:	linux-unionfs@vger.kernel.org
++W:	http://aufs.sourceforge.net
++T:	git://github.com/sfjro/aufs4-linux.git
++S:	Supported
++F:	Documentation/filesystems/aufs/
++F:	Documentation/ABI/testing/debugfs-aufs
++F:	Documentation/ABI/testing/sysfs-aufs
++F:	fs/aufs/
++F:	include/uapi/linux/aufs_type.h
++
+ AUXILIARY DISPLAY DRIVERS
+ M:	Miguel Ojeda Sandonis <miguel.ojeda.sandonis@gmail.com>
+ S:	Maintained
+diff --git a/drivers/block/loop.c b/drivers/block/loop.c
+index 739b372a5112..872e3b3a7693 100644
+--- a/drivers/block/loop.c
++++ b/drivers/block/loop.c
+@@ -750,6 +750,24 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 	return error;
+ }
+ 
++/*
++ * for AUFS
++ * no get/put for file.
++ */
++struct file *loop_backing_file(struct super_block *sb)
++{
++	struct file *ret;
++	struct loop_device *l;
++
++	ret = NULL;
++	if (MAJOR(sb->s_dev) == LOOP_MAJOR) {
++		l = sb->s_bdev->bd_disk->private_data;
++		ret = l->lo_backing_file;
++	}
++	return ret;
++}
++EXPORT_SYMBOL_GPL(loop_backing_file);
++
+ /* loop sysfs attributes */
+ 
+ static ssize_t loop_attr_show(struct device *dev, char *page,
+diff --git a/fs/dcache.c b/fs/dcache.c
+index b280e07e162b..046000653e4d 100644
+--- a/fs/dcache.c
++++ b/fs/dcache.c
+@@ -1266,7 +1266,7 @@ enum d_walk_ret {
+  *
+  * The @enter() callbacks are called with d_lock held.
+  */
+-static void d_walk(struct dentry *parent, void *data,
++void d_walk(struct dentry *parent, void *data,
+ 		   enum d_walk_ret (*enter)(void *, struct dentry *))
+ {
+ 	struct dentry *this_parent;
+diff --git a/fs/fcntl.c b/fs/fcntl.c
+index 9bc167562ee8..b0935c67bd1e 100644
+--- a/fs/fcntl.c
++++ b/fs/fcntl.c
+@@ -32,7 +32,7 @@
+ 
+ #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
+ 
+-static int setfl(int fd, struct file * filp, unsigned long arg)
++int setfl(int fd, struct file *filp, unsigned long arg)
+ {
+ 	struct inode * inode = file_inode(filp);
+ 	int error = 0;
+@@ -63,6 +63,8 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
+ 
+ 	if (filp->f_op->check_flags)
+ 		error = filp->f_op->check_flags(arg);
++	if (!error && filp->f_op->setfl)
++		error = filp->f_op->setfl(filp, arg);
+ 	if (error)
+ 		return error;
+ 
+diff --git a/fs/inode.c b/fs/inode.c
+index 96d62d97694e..31796c1040d6 100644
+--- a/fs/inode.c
++++ b/fs/inode.c
+@@ -1680,7 +1680,7 @@ EXPORT_SYMBOL(generic_update_time);
+  * This does the actual work of updating an inodes time or version.  Must have
+  * had called mnt_want_write() before calling this.
+  */
+-static int update_time(struct inode *inode, struct timespec64 *time, int flags)
++int update_time(struct inode *inode, struct timespec64 *time, int flags)
+ {
+ 	int (*update_time)(struct inode *, struct timespec64 *, int);
+ 
+diff --git a/fs/namespace.c b/fs/namespace.c
+index 5e1bf611a9eb..c05ac2488abb 100644
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -776,6 +776,12 @@ static inline int check_mnt(struct mount *mnt)
+ 	return mnt->mnt_ns == current->nsproxy->mnt_ns;
+ }
+ 
++/* for aufs, CONFIG_AUFS_BR_FUSE */
++int is_current_mnt_ns(struct vfsmount *mnt)
++{
++	return check_mnt(real_mount(mnt));
++}
++
+ /*
+  * vfsmount lock must be held for write
+  */
+diff --git a/fs/read_write.c b/fs/read_write.c
+index 5bbf587f5bc1..fa9b3994b34c 100644
+--- a/fs/read_write.c
++++ b/fs/read_write.c
+@@ -498,6 +498,28 @@ static ssize_t __vfs_write(struct file *file, const char __user *p,
+ 		return -EINVAL;
+ }
+ 
++vfs_readf_t vfs_readf(struct file *file)
++{
++	const struct file_operations *fop = file->f_op;
++
++	if (fop->read)
++		return fop->read;
++	if (fop->read_iter)
++		return new_sync_read;
++	return ERR_PTR(-ENOSYS); /* doesn't have ->read(|_iter)() op */
++}
++
++vfs_writef_t vfs_writef(struct file *file)
++{
++	const struct file_operations *fop = file->f_op;
++
++	if (fop->write)
++		return fop->write;
++	if (fop->write_iter)
++		return new_sync_write;
++	return ERR_PTR(-ENOSYS); /* doesn't have ->write(|_iter)() op */
++}
++
+ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
+ {
+ 	mm_segment_t old_fs;
+diff --git a/fs/splice.c b/fs/splice.c
+index 3009652a41c8..d9bcc4a71a0a 100644
+--- a/fs/splice.c
++++ b/fs/splice.c
+@@ -849,8 +849,8 @@ EXPORT_SYMBOL(generic_splice_sendpage);
+ /*
+  * Attempt to initiate a splice from pipe to file.
+  */
+-static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
+-			   loff_t *ppos, size_t len, unsigned int flags)
++long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
++		    loff_t *ppos, size_t len, unsigned int flags)
+ {
+ 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
+ 				loff_t *, size_t, unsigned int);
+@@ -866,9 +866,9 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
+ /*
+  * Attempt to initiate a splice from a file to a pipe.
+  */
+-static long do_splice_to(struct file *in, loff_t *ppos,
+-			 struct pipe_inode_info *pipe, size_t len,
+-			 unsigned int flags)
++long do_splice_to(struct file *in, loff_t *ppos,
++		  struct pipe_inode_info *pipe, size_t len,
++		  unsigned int flags)
+ {
+ 	ssize_t (*splice_read)(struct file *, loff_t *,
+ 			       struct pipe_inode_info *, size_t, unsigned int);
+diff --git a/fs/sync.c b/fs/sync.c
+index 4d1ff010bc5a..457f4e4a5cc1 100644
+--- a/fs/sync.c
++++ b/fs/sync.c
+@@ -28,7 +28,7 @@
+  * wait == 1 case since in that case write_inode() functions do
+  * sync_dirty_buffer() and thus effectively write one block at a time.
+  */
+-static int __sync_filesystem(struct super_block *sb, int wait)
++int __sync_filesystem(struct super_block *sb, int wait)
+ {
+ 	if (wait)
+ 		sync_inodes_sb(sb);
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index 98e0349adb52..5fc7807f7c2e 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -1349,6 +1349,7 @@ extern void fasync_free(struct fasync_struct *);
+ /* can be called from interrupts */
+ extern void kill_fasync(struct fasync_struct **, int, int);
+ 
++extern int setfl(int fd, struct file *filp, unsigned long arg);
+ extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
+ extern int f_setown(struct file *filp, unsigned long arg, int force);
+ extern void f_delown(struct file *filp);
+@@ -1842,6 +1843,7 @@ struct file_operations {
+ 	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
+ 	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
+ 	int (*check_flags)(int);
++	int (*setfl)(struct file *, unsigned long);
+ 	int (*flock) (struct file *, int, struct file_lock *);
+ 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
+ 	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
+@@ -1912,6 +1914,12 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
+ 			      struct iovec *fast_pointer,
+ 			      struct iovec **ret_pointer);
+ 
++typedef ssize_t (*vfs_readf_t)(struct file *, char __user *, size_t, loff_t *);
++typedef ssize_t (*vfs_writef_t)(struct file *, const char __user *, size_t,
++				loff_t *);
++vfs_readf_t vfs_readf(struct file *file);
++vfs_writef_t vfs_writef(struct file *file);
++
+ extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
+ extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
+ extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
+@@ -2332,6 +2340,7 @@ extern int current_umask(void);
+ extern void ihold(struct inode * inode);
+ extern void iput(struct inode *);
+ extern int generic_update_time(struct inode *, struct timespec64 *, int);
++extern int update_time(struct inode *, struct timespec64 *, int);
+ 
+ /* /sys/fs */
+ extern struct kobject *fs_kobj;
+@@ -2620,6 +2629,7 @@ static inline bool sb_is_blkdev_sb(struct super_block *sb)
+ 	return false;
+ }
+ #endif
++extern int __sync_filesystem(struct super_block *, int);
+ extern int sync_filesystem(struct super_block *);
+ extern const struct file_operations def_blk_fops;
+ extern const struct file_operations def_chr_fops;
+diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
+index c50d01ef1414..4f4677020360 100644
+--- a/include/linux/lockdep.h
++++ b/include/linux/lockdep.h
+@@ -331,6 +331,8 @@ static inline int lockdep_match_key(struct lockdep_map *lock,
+ 	return lock->key == key;
+ }
+ 
++struct lock_class *lockdep_hlock_class(struct held_lock *hlock);
++
+ /*
+  * Acquire a lock.
+  *
+@@ -472,6 +474,7 @@ struct lockdep_map { };
+ 
+ #define lockdep_depth(tsk)	(0)
+ 
++#define lockdep_is_held(lock)			(1)
+ #define lockdep_is_held_type(l, r)		(1)
+ 
+ #define lockdep_assert_held(l)			do { (void)(l); } while (0)
+diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
+index 35942084cd40..24f5fd1a789d 100644
+--- a/include/linux/mnt_namespace.h
++++ b/include/linux/mnt_namespace.h
+@@ -6,11 +6,14 @@
+ struct mnt_namespace;
+ struct fs_struct;
+ struct user_namespace;
++struct vfsmount;
+ 
+ extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *,
+ 		struct user_namespace *, struct fs_struct *);
+ extern void put_mnt_ns(struct mnt_namespace *ns);
+ 
++extern int is_current_mnt_ns(struct vfsmount *mnt);
++
+ extern const struct file_operations proc_mounts_operations;
+ extern const struct file_operations proc_mountinfo_operations;
+ extern const struct file_operations proc_mountstats_operations;
+diff --git a/include/linux/splice.h b/include/linux/splice.h
+index 74b4911ac16d..19789fbea567 100644
+--- a/include/linux/splice.h
++++ b/include/linux/splice.h
+@@ -87,4 +87,10 @@ extern void splice_shrink_spd(struct splice_pipe_desc *);
+ 
+ extern const struct pipe_buf_operations page_cache_pipe_buf_ops;
+ extern const struct pipe_buf_operations default_pipe_buf_ops;
++
++extern long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
++			   loff_t *ppos, size_t len, unsigned int flags);
++extern long do_splice_to(struct file *in, loff_t *ppos,
++			 struct pipe_inode_info *pipe, size_t len,
++			 unsigned int flags);
+ #endif
+diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
+index 32406ef0d6a2..e52169c2086b 100644
+--- a/kernel/locking/lockdep.c
++++ b/kernel/locking/lockdep.c
+@@ -153,7 +153,7 @@ static
+ struct lock_class lock_classes[MAX_LOCKDEP_KEYS];
+ static DECLARE_BITMAP(lock_classes_in_use, MAX_LOCKDEP_KEYS);
+ 
+-static inline struct lock_class *hlock_class(struct held_lock *hlock)
++inline struct lock_class *lockdep_hlock_class(struct held_lock *hlock)
+ {
+ 	unsigned int class_idx = hlock->class_idx;
+ 
+@@ -174,6 +174,7 @@ static inline struct lock_class *hlock_class(struct held_lock *hlock)
+ 	 */
+ 	return lock_classes + class_idx;
+ }
++#define hlock_class(hlock) lockdep_hlock_class(hlock)
+ 
+ #ifdef CONFIG_LOCK_STAT
+ static DEFINE_PER_CPU(struct lock_class_stats[MAX_LOCKDEP_KEYS], cpu_lock_stats);

aufs5-kbuild.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 kbuild patch
+
+diff --git a/fs/Kconfig b/fs/Kconfig
+index 7b623e9fc1b0..9070b9159188 100644
+--- a/fs/Kconfig
++++ b/fs/Kconfig
+@@ -264,6 +264,7 @@ source "fs/pstore/Kconfig"
+ source "fs/sysv/Kconfig"
+ source "fs/ufs/Kconfig"
+ source "fs/erofs/Kconfig"
++source "fs/aufs/Kconfig"
+ 
+ endif # MISC_FILESYSTEMS
+ 
+diff --git a/fs/Makefile b/fs/Makefile
+index 1148c555c4d3..ed6ff7ddc478 100644
+--- a/fs/Makefile
++++ b/fs/Makefile
+@@ -133,3 +133,4 @@ obj-$(CONFIG_CEPH_FS)		+= ceph/
+ obj-$(CONFIG_PSTORE)		+= pstore/
+ obj-$(CONFIG_EFIVAR_FS)		+= efivarfs/
+ obj-$(CONFIG_EROFS_FS)		+= erofs/
++obj-$(CONFIG_AUFS_FS)           += aufs/

aufs5-loopback.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 loopback patch
+
+diff --git a/drivers/block/loop.c b/drivers/block/loop.c
+index 872e3b3a7693..768100025129 100644
+--- a/drivers/block/loop.c
++++ b/drivers/block/loop.c
+@@ -635,6 +635,15 @@ static inline void loop_update_dio(struct loop_device *lo)
+ 			lo->use_dio);
+ }
+ 
++static struct file *loop_real_file(struct file *file)
++{
++	struct file *f = NULL;
++
++	if (file->f_path.dentry->d_sb->s_op->real_loop)
++		f = file->f_path.dentry->d_sb->s_op->real_loop(file);
++	return f;
++}
++
+ static void loop_reread_partitions(struct loop_device *lo,
+ 				   struct block_device *bdev)
+ {
+@@ -690,6 +699,7 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 			  unsigned int arg)
+ {
+ 	struct file	*file = NULL, *old_file;
++	struct file	*f, *virt_file = NULL, *old_virt_file;
+ 	int		error;
+ 	bool		partscan;
+ 
+@@ -709,12 +719,19 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 	file = fget(arg);
+ 	if (!file)
+ 		goto out_err;
++	f = loop_real_file(file);
++	if (f) {
++		virt_file = file;
++		file = f;
++		get_file(file);
++	}
+ 
+ 	error = loop_validate_file(file, bdev);
+ 	if (error)
+ 		goto out_err;
+ 
+ 	old_file = lo->lo_backing_file;
++	old_virt_file = lo->lo_backing_virt_file;
+ 
+ 	error = -EINVAL;
+ 
+@@ -726,6 +743,7 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 	blk_mq_freeze_queue(lo->lo_queue);
+ 	mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask);
+ 	lo->lo_backing_file = file;
++	lo->lo_backing_virt_file = virt_file;
+ 	lo->old_gfp_mask = mapping_gfp_mask(file->f_mapping);
+ 	mapping_set_gfp_mask(file->f_mapping,
+ 			     lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
+@@ -739,6 +757,8 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 	 * dependency.
+ 	 */
+ 	fput(old_file);
++	if (old_virt_file)
++		fput(old_virt_file);
+ 	if (partscan)
+ 		loop_reread_partitions(lo, bdev);
+ 	return 0;
+@@ -747,6 +767,8 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
+ 	mutex_unlock(&loop_ctl_mutex);
+ 	if (file)
+ 		fput(file);
++	if (virt_file)
++		fput(virt_file);
+ 	return error;
+ }
+ 
+@@ -951,7 +973,7 @@ static void loop_update_rotational(struct loop_device *lo)
+ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
+ 		       struct block_device *bdev, unsigned int arg)
+ {
+-	struct file	*file;
++	struct file	*file, *f, *virt_file = NULL;
+ 	struct inode	*inode;
+ 	struct address_space *mapping;
+ 	struct block_device *claimed_bdev = NULL;
+@@ -967,6 +989,12 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
+ 	file = fget(arg);
+ 	if (!file)
+ 		goto out;
++	f = loop_real_file(file);
++	if (f) {
++		virt_file = file;
++		file = f;
++		get_file(file);
++	}
+ 
+ 	/*
+ 	 * If we don't hold exclusive handle for the device, upgrade to it
+@@ -1015,6 +1043,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
+ 	lo->lo_device = bdev;
+ 	lo->lo_flags = lo_flags;
+ 	lo->lo_backing_file = file;
++	lo->lo_backing_virt_file = virt_file;
+ 	lo->transfer = NULL;
+ 	lo->ioctl = NULL;
+ 	lo->lo_sizelimit = 0;
+@@ -1068,6 +1097,8 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
+ 		bd_abort_claiming(bdev, claimed_bdev, loop_set_fd);
+ out_putf:
+ 	fput(file);
++	if (virt_file)
++		fput(virt_file);
+ out:
+ 	/* This is safe: open() is still holding a reference. */
+ 	module_put(THIS_MODULE);
+@@ -1114,6 +1145,7 @@ loop_init_xfer(struct loop_device *lo, struct loop_func_table *xfer,
+ static int __loop_clr_fd(struct loop_device *lo, bool release)
+ {
+ 	struct file *filp = NULL;
++	struct file *virt_filp = lo->lo_backing_virt_file;
+ 	gfp_t gfp = lo->old_gfp_mask;
+ 	struct block_device *bdev = lo->lo_device;
+ 	int err = 0;
+@@ -1137,6 +1169,7 @@ static int __loop_clr_fd(struct loop_device *lo, bool release)
+ 
+ 	spin_lock_irq(&lo->lo_lock);
+ 	lo->lo_backing_file = NULL;
++	lo->lo_backing_virt_file = NULL;
+ 	spin_unlock_irq(&lo->lo_lock);
+ 
+ 	loop_release_xfer(lo);
+@@ -1220,6 +1253,8 @@ static int __loop_clr_fd(struct loop_device *lo, bool release)
+ 	 */
+ 	if (filp)
+ 		fput(filp);
++	if (virt_filp)
++		fput(virt_filp);
+ 	return err;
+ }
+ 
+diff --git a/drivers/block/loop.h b/drivers/block/loop.h
+index af75a5ee4094..1d847cb194ff 100644
+--- a/drivers/block/loop.h
++++ b/drivers/block/loop.h
+@@ -46,7 +46,7 @@ struct loop_device {
+ 	int		(*ioctl)(struct loop_device *, int cmd, 
+ 				 unsigned long arg); 
+ 
+-	struct file *	lo_backing_file;
++	struct file	*lo_backing_file, *lo_backing_virt_file;
+ 	struct block_device *lo_device;
+ 	void		*key_data; 
+ 
+diff --git a/fs/aufs/f_op.c b/fs/aufs/f_op.c
+index 6fb4a4ed8cc7..ba9a959f2db2 100644
+--- a/fs/aufs/f_op.c
++++ b/fs/aufs/f_op.c
+@@ -359,7 +359,7 @@ static ssize_t aufs_read_iter(struct kiocb *kio, struct iov_iter *iov_iter)
+ 	if (IS_ERR(h_file))
+ 		goto out;
+ 
+-	if (au_test_loopback_kthread()) {
++	if (0 && au_test_loopback_kthread()) {
+ 		au_warn_loopback(h_file->f_path.dentry->d_sb);
+ 		if (file->f_mapping != h_file->f_mapping) {
+ 			file->f_mapping = h_file->f_mapping;
+diff --git a/fs/aufs/loop.c b/fs/aufs/loop.c
+index a8b63acc6204..9d97c3af5686 100644
+--- a/fs/aufs/loop.c
++++ b/fs/aufs/loop.c
+@@ -133,3 +133,19 @@ void au_loopback_fin(void)
+ 		symbol_put(loop_backing_file);
+ 	au_kfree_try_rcu(au_warn_loopback_array);
+ }
++
++/* ---------------------------------------------------------------------- */
++
++/* support the loopback block device insude aufs */
++
++struct file *aufs_real_loop(struct file *file)
++{
++	struct file *f;
++
++	BUG_ON(!au_test_aufs(file->f_path.dentry->d_sb));
++	fi_read_lock(file);
++	f = au_hf_top(file);
++	fi_read_unlock(file);
++	AuDebugOn(!f);
++	return f;
++}
+diff --git a/fs/aufs/loop.h b/fs/aufs/loop.h
+index 94f4f80ae33b..ca1194354aff 100644
+--- a/fs/aufs/loop.h
++++ b/fs/aufs/loop.h
+@@ -26,6 +26,8 @@ void au_warn_loopback(struct super_block *h_sb);
+ 
+ int au_loopback_init(void);
+ void au_loopback_fin(void);
++
++struct file *aufs_real_loop(struct file *file);
+ #else
+ AuStub(struct file *, loop_backing_file, return NULL, struct super_block *sb)
+ 
+@@ -36,6 +38,8 @@ AuStubVoid(au_warn_loopback, struct super_block *h_sb)
+ 
+ AuStubInt0(au_loopback_init, void)
+ AuStubVoid(au_loopback_fin, void)
++
++AuStub(struct file *, aufs_real_loop, return NULL, struct file *file)
+ #endif /* BLK_DEV_LOOP */
+ 
+ #endif /* __KERNEL__ */
+diff --git a/fs/aufs/super.c b/fs/aufs/super.c
+index 589dd0122020..801e0a7faec5 100644
+--- a/fs/aufs/super.c
++++ b/fs/aufs/super.c
+@@ -844,7 +844,10 @@ static const struct super_operations aufs_sop = {
+ 	.statfs		= aufs_statfs,
+ 	.put_super	= aufs_put_super,
+ 	.sync_fs	= aufs_sync_fs,
+-	.remount_fs	= aufs_remount_fs
++	.remount_fs	= aufs_remount_fs,
++#ifdef CONFIG_AUFS_BDEV_LOOP
++	.real_loop	= aufs_real_loop
++#endif
+ };
+ 
+ /* ---------------------------------------------------------------------- */
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index 5fc7807f7c2e..07e24e72706e 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -1980,6 +1980,10 @@ struct super_operations {
+ 				  struct shrink_control *);
+ 	long (*free_cached_objects)(struct super_block *,
+ 				    struct shrink_control *);
++#if IS_ENABLED(CONFIG_BLK_DEV_LOOP) || IS_ENABLED(CONFIG_BLK_DEV_LOOP_MODULE)
++	/* and aufs */
++	struct file *(*real_loop)(struct file *);
++#endif
+ };
+ 
+ /*

aufs5-mmap.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 mmap patch
+
+diff --git a/fs/proc/base.c b/fs/proc/base.c
+index ebea9501afb8..dc7edc5f7267 100644
+--- a/fs/proc/base.c
++++ b/fs/proc/base.c
+@@ -2037,7 +2037,7 @@ static int map_files_get_link(struct dentry *dentry, struct path *path)
+ 	rc = -ENOENT;
+ 	vma = find_exact_vma(mm, vm_start, vm_end);
+ 	if (vma && vma->vm_file) {
+-		*path = vma->vm_file->f_path;
++		*path = vma_pr_or_file(vma)->f_path;
+ 		path_get(path);
+ 		rc = 0;
+ 	}
+diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
+index 14c2badb8fd9..65afe5287e43 100644
+--- a/fs/proc/nommu.c
++++ b/fs/proc/nommu.c
+@@ -41,7 +41,10 @@ static int nommu_region_show(struct seq_file *m, struct vm_region *region)
+ 	file = region->vm_file;
+ 
+ 	if (file) {
+-		struct inode *inode = file_inode(region->vm_file);
++		struct inode *inode;
++
++		file = vmr_pr_or_file(region);
++		inode = file_inode(file);
+ 		dev = inode->i_sb->s_dev;
+ 		ino = inode->i_ino;
+ 	}
+diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
+index 9442631fd4af..1fa8a5fcdeee 100644
+--- a/fs/proc/task_mmu.c
++++ b/fs/proc/task_mmu.c
+@@ -309,7 +309,10 @@ show_map_vma(struct seq_file *m, struct vm_area_struct *vma)
+ 	const char *name = NULL;
+ 
+ 	if (file) {
+-		struct inode *inode = file_inode(vma->vm_file);
++		struct inode *inode;
++
++		file = vma_pr_or_file(vma);
++		inode = file_inode(file);
+ 		dev = inode->i_sb->s_dev;
+ 		ino = inode->i_ino;
+ 		pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT;
+@@ -1819,7 +1822,7 @@ static int show_numa_map(struct seq_file *m, void *v)
+ 	struct proc_maps_private *proc_priv = &numa_priv->proc_maps;
+ 	struct vm_area_struct *vma = v;
+ 	struct numa_maps *md = &numa_priv->md;
+-	struct file *file = vma->vm_file;
++	struct file *file = vma_pr_or_file(vma);
+ 	struct mm_struct *mm = vma->vm_mm;
+ 	struct mempolicy *pol;
+ 	char buffer[64];
+diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
+index 7907e6419e57..d17209cf52bc 100644
+--- a/fs/proc/task_nommu.c
++++ b/fs/proc/task_nommu.c
+@@ -155,7 +155,10 @@ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma)
+ 	file = vma->vm_file;
+ 
+ 	if (file) {
+-		struct inode *inode = file_inode(vma->vm_file);
++		struct inode *inode;
++
++		file = vma_pr_or_file(vma);
++		inode = file_inode(file);
+ 		dev = inode->i_sb->s_dev;
+ 		ino = inode->i_ino;
+ 		pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
+diff --git a/include/linux/mm.h b/include/linux/mm.h
+index cfaa8feecfe8..b66c4c536ac5 100644
+--- a/include/linux/mm.h
++++ b/include/linux/mm.h
+@@ -1495,6 +1495,28 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
+ 	unmap_mapping_range(mapping, holebegin, holelen, 0);
+ }
+ 
++extern void vma_do_file_update_time(struct vm_area_struct *, const char[], int);
++extern struct file *vma_do_pr_or_file(struct vm_area_struct *, const char[],
++				      int);
++extern void vma_do_get_file(struct vm_area_struct *, const char[], int);
++extern void vma_do_fput(struct vm_area_struct *, const char[], int);
++
++#define vma_file_update_time(vma)	vma_do_file_update_time(vma, __func__, \
++								__LINE__)
++#define vma_pr_or_file(vma)		vma_do_pr_or_file(vma, __func__, \
++							  __LINE__)
++#define vma_get_file(vma)		vma_do_get_file(vma, __func__, __LINE__)
++#define vma_fput(vma)			vma_do_fput(vma, __func__, __LINE__)
++
++#ifndef CONFIG_MMU
++extern struct file *vmr_do_pr_or_file(struct vm_region *, const char[], int);
++extern void vmr_do_fput(struct vm_region *, const char[], int);
++
++#define vmr_pr_or_file(region)		vmr_do_pr_or_file(region, __func__, \
++							  __LINE__)
++#define vmr_fput(region)		vmr_do_fput(region, __func__, __LINE__)
++#endif /* !CONFIG_MMU */
++
+ extern int access_process_vm(struct task_struct *tsk, unsigned long addr,
+ 		void *buf, int len, unsigned int gup_flags);
+ extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
+diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
+index 270aa8fd2800..33848c2165e2 100644
+--- a/include/linux/mm_types.h
++++ b/include/linux/mm_types.h
+@@ -267,6 +267,7 @@ struct vm_region {
+ 	unsigned long	vm_top;		/* region allocated to here */
+ 	unsigned long	vm_pgoff;	/* the offset in vm_file corresponding to vm_start */
+ 	struct file	*vm_file;	/* the backing file or NULL */
++	struct file	*vm_prfile;	/* the virtual backing file or NULL */
+ 
+ 	int		vm_usage;	/* region usage count (access under nommu_region_sem) */
+ 	bool		vm_icache_flushed : 1; /* true if the icache has been flushed for
+@@ -341,6 +342,7 @@ struct vm_area_struct {
+ 	unsigned long vm_pgoff;		/* Offset (within vm_file) in PAGE_SIZE
+ 					   units */
+ 	struct file * vm_file;		/* File we map to (can be NULL). */
++	struct file *vm_prfile;		/* shadow of vm_file */
+ 	void * vm_private_data;		/* was vm_pte (shared mem) */
+ 
+ #ifdef CONFIG_SWAP
+diff --git a/kernel/fork.c b/kernel/fork.c
+index 080809560072..968e4dc2279f 100644
+--- a/kernel/fork.c
++++ b/kernel/fork.c
+@@ -565,7 +565,7 @@ static __latent_entropy int dup_mmap(struct mm_struct *mm,
+ 			struct inode *inode = file_inode(file);
+ 			struct address_space *mapping = file->f_mapping;
+ 
+-			get_file(file);
++			vma_get_file(tmp);
+ 			if (tmp->vm_flags & VM_DENYWRITE)
+ 				atomic_dec(&inode->i_writecount);
+ 			i_mmap_lock_write(mapping);
+diff --git a/mm/Makefile b/mm/Makefile
+index 1937cc251883..778c1e399903 100644
+--- a/mm/Makefile
++++ b/mm/Makefile
+@@ -42,7 +42,7 @@ obj-y			:= filemap.o mempool.o oom_kill.o fadvise.o \
+ 			   mm_init.o mmu_context.o percpu.o slab_common.o \
+ 			   compaction.o vmacache.o \
+ 			   interval_tree.o list_lru.o workingset.o \
+-			   debug.o gup.o $(mmu-y)
++			   prfile.o debug.o gup.o $(mmu-y)
+ 
+ # Give 'page_alloc' its own module-parameter namespace
+ page-alloc-y := page_alloc.o
+diff --git a/mm/filemap.c b/mm/filemap.c
+index bf6aa30be58d..32ca075c0c8b 100644
+--- a/mm/filemap.c
++++ b/mm/filemap.c
+@@ -2675,7 +2675,7 @@ vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf)
+ 	vm_fault_t ret = VM_FAULT_LOCKED;
+ 
+ 	sb_start_pagefault(inode->i_sb);
+-	file_update_time(vmf->vma->vm_file);
++	vma_file_update_time(vmf->vma);
+ 	lock_page(page);
+ 	if (page->mapping != inode->i_mapping) {
+ 		unlock_page(page);
+diff --git a/mm/mmap.c b/mm/mmap.c
+index 71e4ffc83bcd..7256e8b985eb 100644
+--- a/mm/mmap.c
++++ b/mm/mmap.c
+@@ -176,7 +176,7 @@ static struct vm_area_struct *remove_vma(struct vm_area_struct *vma)
+ 	if (vma->vm_ops && vma->vm_ops->close)
+ 		vma->vm_ops->close(vma);
+ 	if (vma->vm_file)
+-		fput(vma->vm_file);
++		vma_fput(vma);
+ 	mpol_put(vma_policy(vma));
+ 	vm_area_free(vma);
+ 	return next;
+@@ -909,7 +909,7 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
+ 	if (remove_next) {
+ 		if (file) {
+ 			uprobe_munmap(next, next->vm_start, next->vm_end);
+-			fput(file);
++			vma_fput(vma);
+ 		}
+ 		if (next->anon_vma)
+ 			anon_vma_merge(vma, next);
+@@ -1837,8 +1837,8 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
+ 	return addr;
+ 
+ unmap_and_free_vma:
++	vma_fput(vma);
+ 	vma->vm_file = NULL;
+-	fput(file);
+ 
+ 	/* Undo any partial mapping done by a device driver. */
+ 	unmap_region(mm, vma, prev, vma->vm_start, vma->vm_end);
+@@ -2667,7 +2667,7 @@ int __split_vma(struct mm_struct *mm, struct vm_area_struct *vma,
+ 		goto out_free_mpol;
+ 
+ 	if (new->vm_file)
+-		get_file(new->vm_file);
++		vma_get_file(new);
+ 
+ 	if (new->vm_ops && new->vm_ops->open)
+ 		new->vm_ops->open(new);
+@@ -2686,7 +2686,7 @@ int __split_vma(struct mm_struct *mm, struct vm_area_struct *vma,
+ 	if (new->vm_ops && new->vm_ops->close)
+ 		new->vm_ops->close(new);
+ 	if (new->vm_file)
+-		fput(new->vm_file);
++		vma_fput(new);
+ 	unlink_anon_vmas(new);
+  out_free_mpol:
+ 	mpol_put(vma_policy(new));
+@@ -2878,7 +2878,7 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size,
+ 	struct vm_area_struct *vma;
+ 	unsigned long populate = 0;
+ 	unsigned long ret = -EINVAL;
+-	struct file *file;
++	struct file *file, *prfile;
+ 
+ 	pr_warn_once("%s (%d) uses deprecated remap_file_pages() syscall. See Documentation/vm/remap_file_pages.rst.\n",
+ 		     current->comm, current->pid);
+@@ -2953,10 +2953,27 @@ SYSCALL_DEFINE5(remap_file_pages, unsigned long, start, unsigned long, size,
+ 		}
+ 	}
+ 
+-	file = get_file(vma->vm_file);
++	vma_get_file(vma);
++	file = vma->vm_file;
++	prfile = vma->vm_prfile;
+ 	ret = do_mmap_pgoff(vma->vm_file, start, size,
+ 			prot, flags, pgoff, &populate, NULL);
++	if (!IS_ERR_VALUE(ret) && file && prfile) {
++		struct vm_area_struct *new_vma;
++
++		new_vma = find_vma(mm, ret);
++		if (!new_vma->vm_prfile)
++			new_vma->vm_prfile = prfile;
++		if (new_vma != vma)
++			get_file(prfile);
++	}
++	/*
++	 * two fput()s instead of vma_fput(vma),
++	 * coz vma may not be available anymore.
++	 */
+ 	fput(file);
++	if (prfile)
++		fput(prfile);
+ out:
+ 	up_write(&mm->mmap_sem);
+ 	if (populate)
+@@ -3247,7 +3264,7 @@ struct vm_area_struct *copy_vma(struct vm_area_struct **vmap,
+ 		if (anon_vma_clone(new_vma, vma))
+ 			goto out_free_mempol;
+ 		if (new_vma->vm_file)
+-			get_file(new_vma->vm_file);
++			vma_get_file(new_vma);
+ 		if (new_vma->vm_ops && new_vma->vm_ops->open)
+ 			new_vma->vm_ops->open(new_vma);
+ 		vma_link(mm, new_vma, prev, rb_link, rb_parent);
+diff --git a/mm/nommu.c b/mm/nommu.c
+index bd2b4e5ef144..acdab5253263 100644
+--- a/mm/nommu.c
++++ b/mm/nommu.c
+@@ -563,7 +563,7 @@ static void __put_nommu_region(struct vm_region *region)
+ 		up_write(&nommu_region_sem);
+ 
+ 		if (region->vm_file)
+-			fput(region->vm_file);
++			vmr_fput(region);
+ 
+ 		/* IO memory and memory shared directly out of the pagecache
+ 		 * from ramfs/tmpfs mustn't be released here */
+@@ -695,7 +695,7 @@ static void delete_vma(struct mm_struct *mm, struct vm_area_struct *vma)
+ 	if (vma->vm_ops && vma->vm_ops->close)
+ 		vma->vm_ops->close(vma);
+ 	if (vma->vm_file)
+-		fput(vma->vm_file);
++		vma_fput(vma);
+ 	put_nommu_region(vma->vm_region);
+ 	vm_area_free(vma);
+ }
+@@ -1218,7 +1218,7 @@ unsigned long do_mmap(struct file *file,
+ 					goto error_just_free;
+ 				}
+ 			}
+-			fput(region->vm_file);
++			vmr_fput(region);
+ 			kmem_cache_free(vm_region_jar, region);
+ 			region = pregion;
+ 			result = start;
+@@ -1295,10 +1295,10 @@ unsigned long do_mmap(struct file *file,
+ 	up_write(&nommu_region_sem);
+ error:
+ 	if (region->vm_file)
+-		fput(region->vm_file);
++		vmr_fput(region);
+ 	kmem_cache_free(vm_region_jar, region);
+ 	if (vma->vm_file)
+-		fput(vma->vm_file);
++		vma_fput(vma);
+ 	vm_area_free(vma);
+ 	return ret;
+ 
+diff --git a/mm/prfile.c b/mm/prfile.c
+new file mode 100644
+index 000000000000..00d51187c325
+--- /dev/null
++++ b/mm/prfile.c
+@@ -0,0 +1,86 @@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * Mainly for aufs which mmap(2) different file and wants to print different
++ * path in /proc/PID/maps.
++ * Call these functions via macros defined in linux/mm.h.
++ *
++ * See Documentation/filesystems/aufs/design/06mmap.txt
++ *
++ * Copyright (c) 2014-2020 Junjro R. Okajima
++ * Copyright (c) 2014 Ian Campbell
++ */
++
++#include <linux/mm.h>
++#include <linux/file.h>
++#include <linux/fs.h>
++
++/* #define PRFILE_TRACE */
++static inline void prfile_trace(struct file *f, struct file *pr,
++			      const char func[], int line, const char func2[])
++{
++#ifdef PRFILE_TRACE
++	if (pr)
++		pr_info("%s:%d: %s, %pD2\n", func, line, func2, f);
++#endif
++}
++
++void vma_do_file_update_time(struct vm_area_struct *vma, const char func[],
++			     int line)
++{
++	struct file *f = vma->vm_file, *pr = vma->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	file_update_time(f);
++	if (f && pr)
++		file_update_time(pr);
++}
++
++struct file *vma_do_pr_or_file(struct vm_area_struct *vma, const char func[],
++			       int line)
++{
++	struct file *f = vma->vm_file, *pr = vma->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	return (f && pr) ? pr : f;
++}
++
++void vma_do_get_file(struct vm_area_struct *vma, const char func[], int line)
++{
++	struct file *f = vma->vm_file, *pr = vma->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	get_file(f);
++	if (f && pr)
++		get_file(pr);
++}
++
++void vma_do_fput(struct vm_area_struct *vma, const char func[], int line)
++{
++	struct file *f = vma->vm_file, *pr = vma->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	fput(f);
++	if (f && pr)
++		fput(pr);
++}
++
++#ifndef CONFIG_MMU
++struct file *vmr_do_pr_or_file(struct vm_region *region, const char func[],
++			       int line)
++{
++	struct file *f = region->vm_file, *pr = region->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	return (f && pr) ? pr : f;
++}
++
++void vmr_do_fput(struct vm_region *region, const char func[], int line)
++{
++	struct file *f = region->vm_file, *pr = region->vm_prfile;
++
++	prfile_trace(f, pr, func, line, __func__);
++	fput(f);
++	if (f && pr)
++		fput(pr);
++}
++#endif /* !CONFIG_MMU */

aufs5-standalone.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 standalone patch
+
+diff --git a/fs/dcache.c b/fs/dcache.c
+index 046000653e4d..15aa871d1b45 100644
+--- a/fs/dcache.c
++++ b/fs/dcache.c
+@@ -1371,6 +1371,7 @@ void d_walk(struct dentry *parent, void *data,
+ 	seq = 1;
+ 	goto again;
+ }
++EXPORT_SYMBOL_GPL(d_walk);
+ 
+ struct check_mount {
+ 	struct vfsmount *mnt;
+@@ -2916,6 +2917,7 @@ void d_exchange(struct dentry *dentry1, struct dentry *dentry2)
+ 
+ 	write_sequnlock(&rename_lock);
+ }
++EXPORT_SYMBOL_GPL(d_exchange);
+ 
+ /**
+  * d_ancestor - search for an ancestor
+diff --git a/fs/exec.c b/fs/exec.c
+index 74d88dab98dd..71eb4fcace94 100644
+--- a/fs/exec.c
++++ b/fs/exec.c
+@@ -109,6 +109,7 @@ bool path_noexec(const struct path *path)
+ 	return (path->mnt->mnt_flags & MNT_NOEXEC) ||
+ 	       (path->mnt->mnt_sb->s_iflags & SB_I_NOEXEC);
+ }
++EXPORT_SYMBOL_GPL(path_noexec);
+ 
+ #ifdef CONFIG_USELIB
+ /*
+diff --git a/fs/fcntl.c b/fs/fcntl.c
+index b0935c67bd1e..07251ba86c31 100644
+--- a/fs/fcntl.c
++++ b/fs/fcntl.c
+@@ -85,6 +85,7 @@ int setfl(int fd, struct file *filp, unsigned long arg)
+  out:
+ 	return error;
+ }
++EXPORT_SYMBOL_GPL(setfl);
+ 
+ static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
+                      int force)
+diff --git a/fs/file_table.c b/fs/file_table.c
+index 30d55c9a1744..34b9bbf4c556 100644
+--- a/fs/file_table.c
++++ b/fs/file_table.c
+@@ -162,6 +162,7 @@ struct file *alloc_empty_file(int flags, const struct cred *cred)
+ 	}
+ 	return ERR_PTR(-ENFILE);
+ }
++EXPORT_SYMBOL_GPL(alloc_empty_file);
+ 
+ /*
+  * Variant of alloc_empty_file() that doesn't check and modify nr_files.
+@@ -375,6 +376,7 @@ void __fput_sync(struct file *file)
+ }
+ 
+ EXPORT_SYMBOL(fput);
++EXPORT_SYMBOL_GPL(__fput_sync);
+ 
+ void __init files_init(void)
+ {
+diff --git a/fs/inode.c b/fs/inode.c
+index 31796c1040d6..217169541ac4 100644
+--- a/fs/inode.c
++++ b/fs/inode.c
+@@ -1689,6 +1689,7 @@ int update_time(struct inode *inode, struct timespec64 *time, int flags)
+ 
+ 	return update_time(inode, time, flags);
+ }
++EXPORT_SYMBOL_GPL(update_time);
+ 
+ /**
+  *	touch_atime	-	update the access time
+diff --git a/fs/namespace.c b/fs/namespace.c
+index c05ac2488abb..100b7839c8b0 100644
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -431,6 +431,7 @@ void __mnt_drop_write(struct vfsmount *mnt)
+ 	mnt_dec_writers(real_mount(mnt));
+ 	preempt_enable();
+ }
++EXPORT_SYMBOL_GPL(__mnt_drop_write);
+ 
+ /**
+  * mnt_drop_write - give up write access to a mount
+@@ -781,6 +782,7 @@ int is_current_mnt_ns(struct vfsmount *mnt)
+ {
+ 	return check_mnt(real_mount(mnt));
+ }
++EXPORT_SYMBOL_GPL(is_current_mnt_ns);
+ 
+ /*
+  * vfsmount lock must be held for write
+@@ -1903,6 +1905,7 @@ int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
+ 	}
+ 	return 0;
+ }
++EXPORT_SYMBOL_GPL(iterate_mounts);
+ 
+ static void lock_mnt_tree(struct mount *mnt)
+ {
+diff --git a/fs/notify/group.c b/fs/notify/group.c
+index 133f723aca07..0b9f7f6d8390 100644
+--- a/fs/notify/group.c
++++ b/fs/notify/group.c
+@@ -99,6 +99,7 @@ void fsnotify_get_group(struct fsnotify_group *group)
+ {
+ 	refcount_inc(&group->refcnt);
+ }
++EXPORT_SYMBOL_GPL(fsnotify_get_group);
+ 
+ /*
+  * Drop a reference to a group.  Free it if it's through.
+diff --git a/fs/open.c b/fs/open.c
+index b62f5c0923a8..89af4b9c7319 100644
+--- a/fs/open.c
++++ b/fs/open.c
+@@ -65,6 +65,7 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
+ 	inode_unlock(dentry->d_inode);
+ 	return ret;
+ }
++EXPORT_SYMBOL_GPL(do_truncate);
+ 
+ long vfs_truncate(const struct path *path, loff_t length)
+ {
+diff --git a/fs/read_write.c b/fs/read_write.c
+index fa9b3994b34c..eb0e2c6ebaff 100644
+--- a/fs/read_write.c
++++ b/fs/read_write.c
+@@ -468,6 +468,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
+ 
+ 	return ret;
+ }
++EXPORT_SYMBOL_GPL(vfs_read);
+ 
+ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
+ {
+@@ -508,6 +509,7 @@ vfs_readf_t vfs_readf(struct file *file)
+ 		return new_sync_read;
+ 	return ERR_PTR(-ENOSYS); /* doesn't have ->read(|_iter)() op */
+ }
++EXPORT_SYMBOL_GPL(vfs_readf);
+ 
+ vfs_writef_t vfs_writef(struct file *file)
+ {
+@@ -519,6 +521,7 @@ vfs_writef_t vfs_writef(struct file *file)
+ 		return new_sync_write;
+ 	return ERR_PTR(-ENOSYS); /* doesn't have ->write(|_iter)() op */
+ }
++EXPORT_SYMBOL_GPL(vfs_writef);
+ 
+ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos)
+ {
+@@ -588,6 +591,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
+ 
+ 	return ret;
+ }
++EXPORT_SYMBOL_GPL(vfs_write);
+ 
+ /* file_ppos returns &file->f_pos or NULL if file is stream */
+ static inline loff_t *file_ppos(struct file *file)
+diff --git a/fs/splice.c b/fs/splice.c
+index d9bcc4a71a0a..bf8725e99070 100644
+--- a/fs/splice.c
++++ b/fs/splice.c
+@@ -862,6 +862,7 @@ long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
+ 
+ 	return splice_write(pipe, out, ppos, len, flags);
+ }
++EXPORT_SYMBOL_GPL(do_splice_from);
+ 
+ /*
+  * Attempt to initiate a splice from a file to a pipe.
+@@ -891,6 +892,7 @@ long do_splice_to(struct file *in, loff_t *ppos,
+ 
+ 	return splice_read(in, ppos, pipe, len, flags);
+ }
++EXPORT_SYMBOL_GPL(do_splice_to);
+ 
+ /**
+  * splice_direct_to_actor - splices data directly between two non-pipes
+diff --git a/fs/sync.c b/fs/sync.c
+index 457f4e4a5cc1..67c66358f3fe 100644
+--- a/fs/sync.c
++++ b/fs/sync.c
+@@ -39,6 +39,7 @@ int __sync_filesystem(struct super_block *sb, int wait)
+ 		sb->s_op->sync_fs(sb, wait);
+ 	return __sync_blockdev(sb->s_bdev, wait);
+ }
++EXPORT_SYMBOL_GPL(__sync_filesystem);
+ 
+ /*
+  * Write out and wait upon all dirty data associated with this
+diff --git a/fs/xattr.c b/fs/xattr.c
+index 90dd78f0eb27..40b01dd1b14a 100644
+--- a/fs/xattr.c
++++ b/fs/xattr.c
+@@ -296,6 +296,7 @@ vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
+ 	*xattr_value = value;
+ 	return error;
+ }
++EXPORT_SYMBOL_GPL(vfs_getxattr_alloc);
+ 
+ ssize_t
+ __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name,
+diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
+index e52169c2086b..d9bc5cbe9078 100644
+--- a/kernel/locking/lockdep.c
++++ b/kernel/locking/lockdep.c
+@@ -174,6 +174,7 @@ inline struct lock_class *lockdep_hlock_class(struct held_lock *hlock)
+ 	 */
+ 	return lock_classes + class_idx;
+ }
++EXPORT_SYMBOL_GPL(lockdep_hlock_class);
+ #define hlock_class(hlock) lockdep_hlock_class(hlock)
+ 
+ #ifdef CONFIG_LOCK_STAT
+diff --git a/kernel/task_work.c b/kernel/task_work.c
+index 0fef395662a6..83fb1ecfc33d 100644
+--- a/kernel/task_work.c
++++ b/kernel/task_work.c
+@@ -116,3 +116,4 @@ void task_work_run(void)
+ 		} while (work);
+ 	}
+ }
++EXPORT_SYMBOL_GPL(task_work_run);
+diff --git a/security/security.c b/security/security.c
+index cd2d18d2d279..fbf716450399 100644
+--- a/security/security.c
++++ b/security/security.c
+@@ -1036,6 +1036,7 @@ int security_path_rmdir(const struct path *dir, struct dentry *dentry)
+ 		return 0;
+ 	return call_int_hook(path_rmdir, 0, dir, dentry);
+ }
++EXPORT_SYMBOL_GPL(security_path_rmdir);
+ 
+ int security_path_unlink(const struct path *dir, struct dentry *dentry)
+ {
+@@ -1052,6 +1053,7 @@ int security_path_symlink(const struct path *dir, struct dentry *dentry,
+ 		return 0;
+ 	return call_int_hook(path_symlink, 0, dir, dentry, old_name);
+ }
++EXPORT_SYMBOL_GPL(security_path_symlink);
+ 
+ int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
+ 		       struct dentry *new_dentry)
+@@ -1060,6 +1062,7 @@ int security_path_link(struct dentry *old_dentry, const struct path *new_dir,
+ 		return 0;
+ 	return call_int_hook(path_link, 0, old_dentry, new_dir, new_dentry);
+ }
++EXPORT_SYMBOL_GPL(security_path_link);
+ 
+ int security_path_rename(const struct path *old_dir, struct dentry *old_dentry,
+ 			 const struct path *new_dir, struct dentry *new_dentry,
+@@ -1087,6 +1090,7 @@ int security_path_truncate(const struct path *path)
+ 		return 0;
+ 	return call_int_hook(path_truncate, 0, path);
+ }
++EXPORT_SYMBOL_GPL(security_path_truncate);
+ 
+ int security_path_chmod(const struct path *path, umode_t mode)
+ {
+@@ -1094,6 +1098,7 @@ int security_path_chmod(const struct path *path, umode_t mode)
+ 		return 0;
+ 	return call_int_hook(path_chmod, 0, path, mode);
+ }
++EXPORT_SYMBOL_GPL(security_path_chmod);
+ 
+ int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
+ {
+@@ -1101,6 +1106,7 @@ int security_path_chown(const struct path *path, kuid_t uid, kgid_t gid)
+ 		return 0;
+ 	return call_int_hook(path_chown, 0, path, uid, gid);
+ }
++EXPORT_SYMBOL_GPL(security_path_chown);
+ 
+ int security_path_chroot(const struct path *path)
+ {
+@@ -1201,6 +1207,7 @@ int security_inode_permission(struct inode *inode, int mask)
+ 		return 0;
+ 	return call_int_hook(inode_permission, 0, inode, mask);
+ }
++EXPORT_SYMBOL_GPL(security_inode_permission);
+ 
+ int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
+ {
+@@ -1378,6 +1385,7 @@ int security_file_permission(struct file *file, int mask)
+ 
+ 	return fsnotify_perm(file, mask);
+ }
++EXPORT_SYMBOL_GPL(security_file_permission);
+ 
+ int security_file_alloc(struct file *file)
+ {

include/uapi/linux/aufs_type.h

@@ -40,7 +40,7 @@
 #include <limits.h>
 #endif /* __KERNEL__ */
 
-#define AUFS_VERSION	"5.5"
+#define AUFS_VERSION	"5.5-20200203"
 
 /* todo? move this to linux-2.6.19/include/magic.h */
 #define AUFS_SUPER_MAGIC	('a' << 24 | 'u' << 16 | 'f' << 8 | 's')

lockdep-debug.patch

+SPDX-License-Identifier: GPL-2.0
+aufs5.5 lockdep patch
+
+diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
+index 4f4677020360..1aef2c1047a3 100644
+--- a/include/linux/lockdep.h
++++ b/include/linux/lockdep.h
+@@ -17,7 +17,7 @@ struct lockdep_map;
+ extern int prove_locking;
+ extern int lock_stat;
+ 
+-#define MAX_LOCKDEP_SUBCLASSES		8UL
++#define MAX_LOCKDEP_SUBCLASSES		(8UL + 4)
+ 
+ #include <linux/types.h>
+ 
+diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
+index d9bc5cbe9078..30cdce225406 100644
+--- a/kernel/locking/lockdep.c
++++ b/kernel/locking/lockdep.c
+diff --git a/kernel/locking/lockdep_internals.h b/kernel/locking/lockdep_internals.h
+index 18d85aebbb57..1fe552a33fb1 100644
+--- a/kernel/locking/lockdep_internals.h
++++ b/kernel/locking/lockdep_internals.h
+@@ -94,15 +94,15 @@ static const unsigned long LOCKF_USED_IN_IRQ_READ =
+ #define MAX_STACK_TRACE_ENTRIES	262144UL
+ #define STACK_TRACE_HASH_SIZE	8192
+ #else
+-#define MAX_LOCKDEP_ENTRIES	32768UL
++#define MAX_LOCKDEP_ENTRIES	(32768UL << 5)
+ 
+-#define MAX_LOCKDEP_CHAINS_BITS	16
++#define MAX_LOCKDEP_CHAINS_BITS	(16 + 5)
+ 
+ /*
+  * Stack-trace: tightly packed array of stack backtrace
+  * addresses. Protected by the hash_lock.
+  */
+-#define MAX_STACK_TRACE_ENTRIES	524288UL
++#define MAX_STACK_TRACE_ENTRIES	(524288UL << 5)
+ #define STACK_TRACE_HASH_SIZE	16384
+ #endif
+ 

proc_mounts.patch

+SPDX-License-Identifier: GPL-2.0
+
+diff --git a/fs/mount.h b/fs/mount.h
+index 711a4093e475..a5703d5c7205 100644
+--- a/fs/mount.h
++++ b/fs/mount.h
+@@ -133,9 +133,7 @@ struct proc_mounts {
+ 	struct mnt_namespace *ns;
+ 	struct path root;
+ 	int (*show)(struct seq_file *, struct vfsmount *);
+-	void *cached_mount;
+-	u64 cached_event;
+-	loff_t cached_index;
++	size_t filled;
+ };
+ 
+ extern const struct seq_operations mounts_op;
+diff --git a/fs/namespace.c b/fs/namespace.c
+index 5e1bf611a9eb..a4cc7a494f32 100644
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -1246,46 +1246,80 @@ struct vfsmount *mnt_clone_internal(const struct path *path)
+ 
+ #ifdef CONFIG_PROC_FS
+ /* iterator; we want it to have access to namespace_sem, thus here... */
+-static void *m_start(struct seq_file *m, loff_t *pos)
++static int m_start_fill(struct seq_file *m)
+ {
++	int err;
++	size_t last_count;
++	char *buf;
++	struct mount *r;
+ 	struct proc_mounts *p = m->private;
+ 
++	err = -ENODATA;
++	m->count = 0;
+ 	down_read(&namespace_sem);
+-	if (p->cached_event == p->ns->event) {
+-		void *v = p->cached_mount;
+-		if (*pos == p->cached_index)
+-			return v;
+-		if (*pos == p->cached_index + 1) {
+-			v = seq_list_next(v, &p->ns->list, &p->cached_index);
+-			return p->cached_mount = v;
++	list_for_each_entry(r, &p->ns->list, mnt_list) {
++		last_count = m->count;
++		err = p->show(m, &r->mnt);
++		if (unlikely(err < 0))
++			break;
++		if (!seq_has_overflowed(m))
++			continue;
++
++		/* expand the buffer */
++		buf = kvmalloc(m->size + PAGE_SIZE, GFP_KERNEL);
++		if (unlikely(!buf)) {
++			err = -ENOMEM;
++			break;
++		}
++		memcpy(buf, m->buf, last_count);
++		kvfree(m->buf);
++		m->buf = buf;
++		m->size += PAGE_SIZE;
++		m->count = last_count;
++
++#if 0 /* todo: consider the limit */
++		err = p->show(m, &r->mnt);
++		if (unlikely(err < 0))
++			break;
++		else if (unlikely(seq_has_overflowed(m))) {
++			err = -EOVERFLOW;
++			break;
+ 		}
++#endif
+ 	}
++	up_read(&namespace_sem);
+ 
+-	p->cached_event = p->ns->event;
+-	p->cached_mount = seq_list_start(&p->ns->list, *pos);
+-	p->cached_index = *pos;
+-	return p->cached_mount;
++	if (!err)
++		p->filled = m->count;
++	return err;
+ }
+ 
+-static void *m_next(struct seq_file *m, void *v, loff_t *pos)
++static void *m_start(struct seq_file *m, loff_t *pos)
+ {
+-	struct proc_mounts *p = m->private;
++	int err;
+ 
+-	p->cached_mount = seq_list_next(v, &p->ns->list, pos);
+-	p->cached_index = *pos;
+-	return p->cached_mount;
++	if (!*pos) {
++		err = m_start_fill(m);
++		if (unlikely(err))
++			return ERR_PTR(err);
++	}
++
++	return m_start; /* any valid pointer */
++}
++
++static void *m_next(struct seq_file *m, void *v, loff_t *pos)
++{
++	return NULL;
+ }
+ 
+ static void m_stop(struct seq_file *m, void *v)
+ {
+-	up_read(&namespace_sem);
++	/* empty */
+ }
+ 
+ static int m_show(struct seq_file *m, void *v)
+ {
+-	struct proc_mounts *p = m->private;
+-	struct mount *r = list_entry(v, struct mount, mnt_list);
+-	return p->show(m, &r->mnt);
++	return 0;
+ }
+ 
+ const struct seq_operations mounts_op = {
+diff --git a/fs/proc_namespace.c b/fs/proc_namespace.c
+index 273ee82d8aa9..e5b22c50ca59 100644
+--- a/fs/proc_namespace.c
++++ b/fs/proc_namespace.c
+@@ -279,7 +279,6 @@ static int mounts_open_common(struct inode *inode, struct file *file,
+ 	p->ns = ns;
+ 	p->root = root;
+ 	p->show = show;
+-	p->cached_event = ~0ULL;
+ 
+ 	return 0;
+ 

tmpfs-idr.patch

+SPDX-License-Identifier: GPL-2.0
+
+diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
+index de8e4b71e3ba..ae8c9fcaea91 100644
+--- a/include/linux/shmem_fs.h
++++ b/include/linux/shmem_fs.h
+@@ -26,10 +26,13 @@ struct shmem_inode_info {
+ };
+ 
+ struct shmem_sb_info {
++	struct mutex idr_lock;
++	bool idr_nouse;
++	struct idr idr;		    /* manages inode-number */
+ 	unsigned long max_blocks;   /* How many blocks are allowed */
+ 	struct percpu_counter used_blocks;  /* How many are allocated */
+-	unsigned long max_inodes;   /* How many inodes are allowed */
+-	unsigned long free_inodes;  /* How many are left for allocation */
++	int max_inodes;		    /* How many inodes are allowed */
++	int free_inodes;	    /* How many are left for allocation */
+ 	spinlock_t stat_lock;	    /* Serialize shmem_sb_info changes */
+ 	umode_t mode;		    /* Mount mode for root directory */
+ 	unsigned char huge;	    /* Whether to try for hugepages */
+diff --git a/mm/shmem.c b/mm/shmem.c
+index 8793e8cc1a48..ae68925ff71a 100644
+--- a/mm/shmem.c
++++ b/mm/shmem.c
+@@ -110,7 +110,7 @@ struct shmem_falloc {
+ 
+ struct shmem_options {
+ 	unsigned long long blocks;
+-	unsigned long long inodes;
++	int inodes;
+ 	struct mempolicy *mpol;
+ 	kuid_t uid;
+ 	kgid_t gid;
+@@ -128,11 +128,14 @@ static unsigned long shmem_default_max_blocks(void)
+ 	return totalram_pages() / 2;
+ }
+ 
+-static unsigned long shmem_default_max_inodes(void)
++static int shmem_default_max_inodes(void)
+ {
+ 	unsigned long nr_pages = totalram_pages();
++	unsigned long ul;
+ 
+-	return min(nr_pages - totalhigh_pages(), nr_pages / 2);
++	ul = INT_MAX;
++	ul = min3(ul, nr_pages - totalhigh_pages(), nr_pages / 2);
++	return ul;
+ }
+ #endif
+ 
+@@ -1112,6 +1115,11 @@ static void shmem_evict_inode(struct inode *inode)
+ 
+ 	simple_xattrs_free(&info->xattrs);
+ 	WARN_ON(inode->i_blocks);
++	if (!sbinfo->idr_nouse && inode->i_ino) {
++		mutex_lock(&sbinfo->idr_lock);
++		idr_remove(&sbinfo->idr, inode->i_ino);
++		mutex_unlock(&sbinfo->idr_lock);
++	}
+ 	shmem_free_inode(inode->i_sb);
+ 	clear_inode(inode);
+ }
+@@ -2242,13 +2250,13 @@ static struct inode *shmem_get_inode(struct super_block *sb, const struct inode
+ 	struct inode *inode;
+ 	struct shmem_inode_info *info;
+ 	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
++	int ino;
+ 
+ 	if (shmem_reserve_inode(sb))
+ 		return NULL;
+ 
+ 	inode = new_inode(sb);
+ 	if (inode) {
+-		inode->i_ino = get_next_ino();
+ 		inode_init_owner(inode, dir, mode);
+ 		inode->i_blocks = 0;
+ 		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
+@@ -2292,6 +2300,25 @@ static struct inode *shmem_get_inode(struct super_block *sb, const struct inode
+ 			break;
+ 		}
+ 
++		if (!sbinfo->idr_nouse) {
++			/* inum 0 and 1 are unused */
++			mutex_lock(&sbinfo->idr_lock);
++			ino = idr_alloc(&sbinfo->idr, inode, 2, INT_MAX,
++					GFP_NOFS);
++			if (ino > 0) {
++				inode->i_ino = ino;
++				mutex_unlock(&sbinfo->idr_lock);
++				__insert_inode_hash(inode, inode->i_ino);
++			} else {
++				inode->i_ino = 0;
++				mutex_unlock(&sbinfo->idr_lock);
++				iput(inode);
++				/* shmem_free_inode() will be called */
++				inode = NULL;
++			}
++		} else
++			inode->i_ino = get_next_ino();
++
+ 		lockdep_annotate_inode_mutex_key(inode);
+ 	} else
+ 		shmem_free_inode(sb);
+@@ -3297,8 +3324,7 @@ static struct dentry *shmem_get_parent(struct dentry *child)
+ static int shmem_match(struct inode *ino, void *vfh)
+ {
+ 	__u32 *fh = vfh;
+-	__u64 inum = fh[2];
+-	inum = (inum << 32) | fh[1];
++	__u64 inum = fh[1];
+ 	return ino->i_ino == inum && fh[0] == ino->i_generation;
+ }
+ 
+@@ -3318,14 +3344,11 @@ static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
+ 	struct dentry *dentry = NULL;
+ 	u64 inum;
+ 
+-	if (fh_len < 3)
++	if (fh_len < 2)
+ 		return NULL;
+ 
+-	inum = fid->raw[2];
+-	inum = (inum << 32) | fid->raw[1];
+-
+-	inode = ilookup5(sb, (unsigned long)(inum + fid->raw[0]),
+-			shmem_match, fid->raw);
++	inum = fid->raw[1];
++	inode = ilookup5(sb, inum, shmem_match, fid->raw);
+ 	if (inode) {
+ 		dentry = shmem_find_alias(inode);
+ 		iput(inode);
+@@ -3337,30 +3360,15 @@ static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
+ static int shmem_encode_fh(struct inode *inode, __u32 *fh, int *len,
+ 				struct inode *parent)
+ {
+-	if (*len < 3) {
+-		*len = 3;
++	if (*len < 2) {
++		*len = 2;
+ 		return FILEID_INVALID;
+ 	}
+ 
+-	if (inode_unhashed(inode)) {
+-		/* Unfortunately insert_inode_hash is not idempotent,
+-		 * so as we hash inodes here rather than at creation
+-		 * time, we need a lock to ensure we only try
+-		 * to do it once
+-		 */
+-		static DEFINE_SPINLOCK(lock);
+-		spin_lock(&lock);
+-		if (inode_unhashed(inode))
+-			__insert_inode_hash(inode,
+-					    inode->i_ino + inode->i_generation);
+-		spin_unlock(&lock);
+-	}
+-
+ 	fh[0] = inode->i_generation;
+ 	fh[1] = inode->i_ino;
+-	fh[2] = ((__u64)inode->i_ino) >> 32;
+ 
+-	*len = 3;
++	*len = 2;
+ 	return 1;
+ }
+ 
+@@ -3441,7 +3449,7 @@ static int shmem_parse_one(struct fs_context *fc, struct fs_parameter *param)
+ 		break;
+ 	case Opt_nr_inodes:
+ 		ctx->inodes = memparse(param->string, &rest);
+-		if (*rest)
++		if (*rest || ctx->inodes < 2)
+ 			goto bad_value;
+ 		ctx->seen |= SHMEM_SEEN_INODES;
+ 		break;
+@@ -3539,7 +3547,7 @@ static int shmem_reconfigure(struct fs_context *fc)
+ {
+ 	struct shmem_options *ctx = fc->fs_private;
+ 	struct shmem_sb_info *sbinfo = SHMEM_SB(fc->root->d_sb);
+-	unsigned long inodes;
++	int inodes;
+ 	const char *err;
+ 
+ 	spin_lock(&sbinfo->stat_lock);
+@@ -3598,7 +3606,7 @@ static int shmem_show_options(struct seq_file *seq, struct dentry *root)
+ 		seq_printf(seq, ",size=%luk",
+ 			sbinfo->max_blocks << (PAGE_SHIFT - 10));
+ 	if (sbinfo->max_inodes != shmem_default_max_inodes())
+-		seq_printf(seq, ",nr_inodes=%lu", sbinfo->max_inodes);
++		seq_printf(seq, ",nr_inodes=%d", sbinfo->max_inodes);
+ 	if (sbinfo->mode != (0777 | S_ISVTX))
+ 		seq_printf(seq, ",mode=%03ho", sbinfo->mode);
+ 	if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID))
+@@ -3622,6 +3630,8 @@ static void shmem_put_super(struct super_block *sb)
+ {
+ 	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
+ 
++	if (!sbinfo->idr_nouse)
++		idr_destroy(&sbinfo->idr);
+ 	percpu_counter_destroy(&sbinfo->used_blocks);
+ 	mpol_put(sbinfo->mpol);
+ 	kfree(sbinfo);
+@@ -3662,6 +3672,8 @@ static int shmem_fill_super(struct super_block *sb, struct fs_context *fc)
+ #else
+ 	sb->s_flags |= SB_NOUSER;
+ #endif
++	mutex_init(&sbinfo->idr_lock);
++	idr_init(&sbinfo->idr);
+ 	sbinfo->max_blocks = ctx->blocks;
+ 	sbinfo->free_inodes = sbinfo->max_inodes = ctx->inodes;
+ 	sbinfo->uid = ctx->uid;
+@@ -3773,6 +3785,15 @@ static void shmem_destroy_inodecache(void)
+ 	kmem_cache_destroy(shmem_inode_cachep);
+ }
+ 
++static __init void shmem_no_idr(struct super_block *sb)
++{
++	struct shmem_sb_info *sbinfo;
++
++	sbinfo = SHMEM_SB(sb);
++	sbinfo->idr_nouse = true;
++	idr_destroy(&sbinfo->idr);
++}
++
+ static const struct address_space_operations shmem_aops = {
+ 	.writepage	= shmem_writepage,
+ 	.set_page_dirty	= __set_page_dirty_no_writeback,
+@@ -3913,6 +3934,7 @@ int __init shmem_init(void)
+ 		pr_err("Could not kern_mount tmpfs\n");
+ 		goto out1;
+ 	}
++	shmem_no_idr(shm_mnt->mnt_sb);
+ 
+ #ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE
+ 	if (has_transparent_hugepage() && shmem_huge > SHMEM_HUGE_DENY)

vfs-ino.patch

+SPDX-License-Identifier: GPL-2.0
+
+diff --git a/fs/inode.c b/fs/inode.c
+index 96d62d97694e..9f873b4380a4 100644
+--- a/fs/inode.c
++++ b/fs/inode.c
+@@ -892,6 +892,8 @@ unsigned int get_next_ino(void)
+ 	unsigned int *p = &get_cpu_var(last_ino);
+ 	unsigned int res = *p;
+ 
++start:
++
+ #ifdef CONFIG_SMP
+ 	if (unlikely((res & (LAST_INO_BATCH-1)) == 0)) {
+ 		static atomic_t shared_last_ino;
+@@ -904,7 +906,7 @@ unsigned int get_next_ino(void)
+ 	res++;
+ 	/* get_next_ino should not provide a 0 inode number */
+ 	if (unlikely(!res))
+-		res++;
++		goto start;
+ 	*p = res;
+ 	put_cpu_var(last_ino);
+ 	return res;