Add support for shared PTEs across processes

Add a ram-based filesystem that contains page table sharing information and files that enables processes to share page tables. This patch adds the basic filesystem that can be mounted.

Signed-off-by Khalid Aziz <[email protected]>

---
 Documentation/filesystems/msharefs.rst |  19 +++++
 include/uapi/linux/magic.h             |   1 +
 mm/Makefile                            |   2 +-
 mm/mshare.c                            | 103 +++++++++++++++++++++++++
 4 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 Documentation/filesystems/msharefs.rst
 create mode 100644 mm/mshare.c

Documentation/filesystems/msharefs.rst new file +5 -0

new file mode 100644
index 000000000000..fd161f67045d
@@ -0,0 +1,19 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=====================================================
+msharefs - a filesystem to support shared page tables
+=====================================================

mm/mshare.c new file +103 -0

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Enable copperating processes to share page table between
+ * them to reduce the extra memory consumed by multiple copies
+ * of page tables.
+ *
+ * This code adds an in-memory filesystem - msharefs.
+ * msharefs is used to manage page table sharing
+ *
+ *
+ * Copyright (C) 2022 Oracle Corp. All rights reserved.
+ * Author:	Khalid Aziz <[email protected]>
+ *
+ */
+
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/syscalls.h>
+#include <linux/uaccess.h>
+#include <linux/pseudo_fs.h>
+#include <linux/fileattr.h>
+#include <uapi/linux/magic.h>
+#include <uapi/linux/limits.h>
+
+static struct super_block *msharefs_sb;
+
+static const struct file_operations msharefs_file_operations = {
+	.open	= simple_open,
+	.llseek	= no_llseek,
+};
+
+static int
+msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
+{
+	unsigned long hash = init_name_hash(dentry);
+	const unsigned char *s = qstr->name;
+	unsigned int len = qstr->len;
+
+	while (len--)
+		hash = partial_name_hash(*s++, hash);
+	qstr->hash = end_name_hash(hash);
+	return 0;
+}
+
+static const struct dentry_operations msharefs_d_ops = {
+	.d_hash = msharefs_d_hash,
+};
+
+static int
+msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
+{
+	static const struct tree_descr empty_descr = {""};
+	int err;
+
+	sb->s_d_op = &msharefs_d_ops;
+	err = simple_fill_super(sb, MSHARE_MAGIC, &empty_descr);
+	if (err)
+		return err;
+
+	msharefs_sb = sb;
+	return 0;
+}
+
+static int
+msharefs_get_tree(struct fs_context *fc)
+{
+	return get_tree_single(fc, msharefs_fill_super);
+}
+
+static const struct fs_context_operations msharefs_context_ops = {
+	.get_tree	= msharefs_get_tree,
+};
+
+static int
+mshare_init_fs_context(struct fs_context *fc)
+{
+	fc->ops = &msharefs_context_ops;
+	return 0;
+}
+
+static struct file_system_type mshare_fs = {
+	.name			= "msharefs",
+	.init_fs_context	= mshare_init_fs_context,
+	.kill_sb		= kill_litter_super,
+};
+
+static int
+mshare_init(void)
+{
+	int ret = 0;
+
+	ret = sysfs_create_mount_point(fs_kobj, "mshare");
+	if (ret)
+		return ret;
+
+	ret = register_filesystem(&mshare_fs);
+	if (ret)
+		sysfs_remove_mount_point(fs_kobj, "mshare");
+
+	return ret;
+}
+
+fs_initcall(mshare_init);

Signature · 1 line

2.32.0

Quoted 25 lines · Khalid Aziz

Add a ram-based filesystem that contains page table sharing information and files that enables processes to share page tables. This patch adds the basic filesystem that can be mounted.

Signed-off-by Khalid Aziz <[email protected]>

---
  Documentation/filesystems/msharefs.rst |  19 +++++
  include/uapi/linux/magic.h             |   1 +
  mm/Makefile                            |   2 +-
  mm/mshare.c                            | 103 +++++++++++++++++++++++++
  4 files changed, 124 insertions(+), 1 deletion(-)

create mode 100644 Documentation/filesystems/msharefs.rst create mode 100644 mm/mshare.c

Documentation/filesystems/msharefs.rst new file +5 -0

new file mode 100644
index 000000000000..fd161f67045d
@@ -0,0 +1,19 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=====================================================
+msharefs - a filesystem to support shared page tables
+=====================================================

Documentation/filesystems/msharefs.rst line 15

Quoted 10 lines

Documentation/filesystems/msharefs.rst new file +10 -0

+
+msharefs is a ram-based filesystem that allows multiple processes to
+share page table entries for shared pages.
+
+msharefs is typically mounted like this::
+
+	mount -t msharefs none /sys/fs/mshare
+
+When a process calls mshare syscall with a name for the shared address
+range,

You mean creat()?

Documentation/filesystems/msharefs.rst line 18

Quoted 4 lines

a file with the same name is created under msharefs with that

Documentation/filesystems/msharefs.rst new file +3 -0

+name. This file can be opened by another process, if permissions
+allow, to query the addresses shared under this range. These files are
+removed by mshare_unlink syscall and can not be deleted directly.

Oh?

mm/mshare.c

Quoted 30 lines

Documentation/filesystems/msharefs.rst new file +1 -0

+Hence these files are created as immutable files.

include/uapi/linux/magic.h +1 -0

index f724129c0425..2a57a6ec6f3e 100644
@@ -105,5 +105,6 @@
  #define Z3FOLD_MAGIC		0x33
  #define PPC_CMM_MAGIC		0xc7571590
  #define SECRETMEM_MAGIC		0x5345434d	/* "SECM" */
+#define MSHARE_MAGIC		0x4d534852	/* "MSHR" */
 
  #endif /* __LINUX_MAGIC_H__ */

mm/Makefile +1 -1

index 6f9ffa968a1a..51a2ab9080d9 100644
@@ -37,7 +37,7 @@ CFLAGS_init-mm.o += $(call cc-disable-warning, override-init)
  CFLAGS_init-mm.o += $(call cc-disable-warning, initializer-overrides)
 
  mmu-y			:= nommu.o
-mmu-$(CONFIG_MMU)	:= highmem.o memory.o mincore.o \
+mmu-$(CONFIG_MMU)	:= highmem.o memory.o mincore.o mshare.o \
  			   mlock.o mmap.o mmu_gather.o mprotect.o mremap.o \
  			   msync.o page_vma_mapped.o pagewalk.o \
  			   pgtable-generic.o rmap.o vmalloc.o

mm/mshare.c new file +0 -0

new file mode 100644
index 000000000000..c8fab3869bab

Filesystems are usually supposed to live under fs/; is there some reason to put it in mm/?

I guess shmfs is in mm so maybe this isn't much of an objection.

Also, should this fs be selectable via a Kconfig option?

mm/mshare.c line 43

Quoted 12 lines · Khalid Aziz

mm/mshare.c new file +12 -0

+static int
+msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
+{
+	unsigned long hash = init_name_hash(dentry);
+	const unsigned char *s = qstr->name;
+	unsigned int len = qstr->len;
+
+	while (len--)
+		hash = partial_name_hash(*s++, hash);
+	qstr->hash = end_name_hash(hash);
+	return 0;
+}

What do you need that for and how is it different from letting it use full_name_hash() (which is what it will do if you leave dentry_operations->d_hash equal to NULL)?

Users of mshare feature to share page tables need to know the size and alignment requirement for shared regions. Pre-populate msharefs with a file, mshare_info, that provides this information.

Signed-off-by Khalid Aziz <[email protected]>

---
 mm/mshare.c | 62 +++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 48 insertions(+), 14 deletions(-)

mm/mshare.c +0 -0

index c8fab3869bab..3e448e11c742 100644

mm/mshare.c +6 -0

 };
 
 static int

@@ -42,23 +42,52 @@ msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 	return 0;
 }
 
+static void
+mshare_evict_inode(struct inode *inode)
+{
+	clear_inode(inode);
+}
+
 static const struct dentry_operations msharefs_d_ops = {

mm/mshare.c +33 -12

+	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
+}
+
+static const struct file_operations mshare_info_ops = {
+	.read   = mshare_info_read,
+	.llseek	= noop_llseek,
+};
+
+static const struct super_operations mshare_s_ops = {
+	.statfs	     = simple_statfs,
+	.evict_inode = mshare_evict_inode,
+};
+
 static int
 msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
 {
-	static const struct tree_descr empty_descr = {""};
+	static const struct tree_descr mshare_files[] = {
+		[2] = { "mshare_info", &mshare_info_ops, 0444},
+		{""},
+	};
 	int err;
 
-	sb->s_d_op = &msharefs_d_ops;
-	err = simple_fill_super(sb, MSHARE_MAGIC, &empty_descr);
-	if (err)
-		return err;
-
-	msharefs_sb = sb;
-	return 0;
+	err = simple_fill_super(sb, MSHARE_MAGIC, mshare_files);
+	if (!err) {
+		msharefs_sb = sb;
+		sb->s_d_op = &msharefs_d_ops;
+		sb->s_op = &mshare_s_ops;
+	}
+	return err;
 }
 
 static int

@@ -84,20 +113,25 @@ static struct file_system_type mshare_fs = {
 	.kill_sb		= kill_litter_super,
 };
 
-static int
+static int __init
 mshare_init(void)
 {
 	int ret = 0;
 
 	ret = sysfs_create_mount_point(fs_kobj, "mshare");
 	if (ret)
-		return ret;
+		goto out;
 
 	ret = register_filesystem(&mshare_fs);
-	if (ret)
+	if (ret) {
 		sysfs_remove_mount_point(fs_kobj, "mshare");
+		goto out;
+	}
+
+	return 0;
 
+out:
 	return ret;
 }
 
-fs_initcall(mshare_init);
+core_initcall(mshare_init);

Signature · 1 line

2.32.0

Quoted 16 lines · Khalid Aziz

Users of mshare feature to share page tables need to know the size and alignment requirement for shared regions. Pre-populate msharefs with a file, mshare_info, that provides this information.

Signed-off-by Khalid Aziz <[email protected]>

---
  mm/mshare.c | 62 +++++++++++++++++++++++++++++++++++++++++------------
  1 file changed, 48 insertions(+), 14 deletions(-)

mm/mshare.c +0 -0

index c8fab3869bab..3e448e11c742 100644
@@ -25,8 +25,8 @@
  static struct super_block *msharefs_sb;
 

mm/mshare.c line 29

Quoted 5 lines

mm/mshare.c +2 -2

  static const struct file_operations msharefs_file_operations = {
-	.open	= simple_open,
-	.llseek	= no_llseek,
+	.open		= simple_open,
+	.llseek		= no_llseek,

I feel like there's a lot of churn between the previous patch and this one that could have been in the previous patch.

Quoted 18 lines

mm/mshare.c +6 -0

  };
 
  static int

@@ -42,23 +42,52 @@ msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
  	return 0;
  }
 
+static void
+mshare_evict_inode(struct inode *inode)
+{
+	clear_inode(inode);
+}
+
  static const struct dentry_operations msharefs_d_ops = {
  	.d_hash = msharefs_d_hash,
  };
 

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 61

Quoted 7 lines

mm/mshare.c +7 -0

+static ssize_t
+mshare_info_read(struct file *file, char __user *buf, size_t nbytes,
+		loff_t *ppos)
+{
+	char s[80];
+
+	sprintf(s, "%ld", PGDIR_SIZE);

SO what is this "mshare_info" file supposed to reveal? Hugepage size? I wonder why this isn't exported in struct mshare_info?

Quoted 74 lines

mm/mshare.c +33 -12

+	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
+}
+
+static const struct file_operations mshare_info_ops = {
+	.read   = mshare_info_read,
+	.llseek	= noop_llseek,
+};
+
+static const struct super_operations mshare_s_ops = {
+	.statfs	     = simple_statfs,
+	.evict_inode = mshare_evict_inode,
+};
+
  static int
  msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
  {
-	static const struct tree_descr empty_descr = {""};
+	static const struct tree_descr mshare_files[] = {
+		[2] = { "mshare_info", &mshare_info_ops, 0444},
+		{""},
+	};
  	int err;
 
-	sb->s_d_op = &msharefs_d_ops;
-	err = simple_fill_super(sb, MSHARE_MAGIC, &empty_descr);
-	if (err)
-		return err;
-
-	msharefs_sb = sb;
-	return 0;
+	err = simple_fill_super(sb, MSHARE_MAGIC, mshare_files);
+	if (!err) {
+		msharefs_sb = sb;
+		sb->s_d_op = &msharefs_d_ops;
+		sb->s_op = &mshare_s_ops;
+	}
+	return err;
  }
 
  static int

@@ -84,20 +113,25 @@ static struct file_system_type mshare_fs = {
  	.kill_sb		= kill_litter_super,
  };
 
-static int
+static int __init
  mshare_init(void)
  {
  	int ret = 0;
 
  	ret = sysfs_create_mount_point(fs_kobj, "mshare");
  	if (ret)
-		return ret;
+		goto out;
 
  	ret = register_filesystem(&mshare_fs);
-	if (ret)
+	if (ret) {
  		sysfs_remove_mount_point(fs_kobj, "mshare");
+		goto out;
+	}
+
+	return 0;
 
+out:
  	return ret;
  }
 
-fs_initcall(mshare_init);
+core_initcall(mshare_init);

Signature · 1 line

2.32.0

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 49

Quoted 5 lines · Khalid Aziz

mm/mshare.c +5 -0

+static void
+mshare_evict_inode(struct inode *inode)
+{
+	clear_inode(inode);
+}

Again, what for? And while we are at it, shouldn't you evict the pages when inode gets freed and ->i_data along with it? IOW, aren't you missing

                 truncate_inode_pages_final(&inode->i_data);

That, or just leave ->evict_inode NULL...

Make msharefs filesystem writable and allow creating directories to support better access control to mshare'd regions defined in msharefs.

Signed-off-by Khalid Aziz <[email protected]>

---
 mm/mshare.c | 195 +++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 186 insertions(+), 9 deletions(-)

mm/mshare.c +29 -1

index 3e448e11c742..2d5924d39221 100644
@@ -21,11 +21,21 @@
 #include <linux/fileattr.h>
 #include <uapi/linux/magic.h>
 #include <uapi/linux/limits.h>
+#include <uapi/linux/mman.h>
 
 static struct super_block *msharefs_sb;
 
+static const struct inode_operations msharefs_dir_inode_ops;
+static const struct inode_operations msharefs_file_inode_ops;
+
+static int
+msharefs_open(struct inode *inode, struct file *file)
+{
+	return simple_open(inode, file);
+}
+
 static const struct file_operations msharefs_file_operations = {
-	.open		= simple_open,
+	.open		= msharefs_open,
 	.llseek		= no_llseek,
 };
 

@@ -42,6 +52,113 @@ msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
 	return 0;
 }
 
+static struct dentry
+*msharefs_alloc_dentry(struct dentry *parent, const char *name)
+{
+	struct dentry *d;
+	struct qstr q;
+	int err;
+
+	q.name = name;
+	q.len = strlen(name);
+
+	err = msharefs_d_hash(parent, &q);
+	if (err)
+		return ERR_PTR(err);
+
+	d = d_alloc(parent, &q);
+	if (d)
+		return d;
+

mm/mshare.c +22 -0

+		case S_IFREG:
+			inode->i_op = &msharefs_file_inode_ops;
+			inode->i_fop = &msharefs_file_operations;
+			break;
+		case S_IFDIR:
+			inode->i_op = &msharefs_dir_inode_ops;
+			inode->i_fop = &simple_dir_operations;
+			inc_nlink(inode);
+			break;
+		case S_IFLNK:
+			inode->i_op = &page_symlink_inode_operations;
+			break;
+		default:
+			discard_new_inode(inode);
+			inode = NULL;
+			break;
+		}
+	}
+
+	return inode;
+}
+

mm/mshare.c +41 -0

+
+	d_instantiate(dentry, inode);
+	dget(dentry);
+	dir->i_mtime = dir->i_ctime = current_time(dir);
+
+	return err;
+}
+
+static int
+msharefs_create(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, bool excl)
+{
+	return msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFREG, 0);
+}
+
+static int
+msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode)
+{
+	int ret = msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFDIR, 0);
+
+	if (!ret)
+		inc_nlink(dir);
+	return ret;
+}
+
+static const struct inode_operations msharefs_file_inode_ops = {
+	.setattr	= simple_setattr,
+	.getattr	= simple_getattr,
+};
+static const struct inode_operations msharefs_dir_inode_ops = {
+	.create		= msharefs_create,
+	.lookup		= simple_lookup,
+	.link		= simple_link,
+	.unlink		= simple_unlink,
+	.mkdir		= msharefs_mkdir,
+	.rmdir		= simple_rmdir,
+	.mknod		= msharefs_mknod,
+	.rename		= simple_rename,
+};
+
 static void
 mshare_evict_inode(struct inode *inode)
 {

mm/mshare.c +1 -0

 	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
 }
 

@@ -72,6 +189,38 @@ static const struct super_operations mshare_s_ops = {
 	.evict_inode = mshare_evict_inode,
 };
 
+static int

mm/mshare.c +56 -7

+
+		dentry = msharefs_alloc_dentry(root, files->name);
+		if (!dentry)
+			return -ENOMEM;
+
+		inode = msharefs_get_inode(s, dir, S_IFREG | files->mode);
+		if (!inode) {
+			dput(dentry);
+			return -ENOMEM;
+		}
+		inode->i_mode = S_IFREG | files->mode;
+		inode->i_atime = inode->i_mtime = inode->i_ctime
+			= current_time(inode);
+		inode->i_fop = files->ops;
+		inode->i_ino = i;
+		d_add(dentry, inode);
+	}
+
+	return 0;
+}
+
 static int
 msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
 {

@@ -79,21 +228,49 @@ msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
 		[2] = { "mshare_info", &mshare_info_ops, 0444},
 		{""},
 	};
-	int err;
+	struct inode *inode;
+	struct dentry *root;
+	int err = 0;
 
-	err = simple_fill_super(sb, MSHARE_MAGIC, mshare_files);
-	if (!err) {
-		msharefs_sb = sb;
-		sb->s_d_op = &msharefs_d_ops;
-		sb->s_op = &mshare_s_ops;
+	sb->s_blocksize		= PAGE_SIZE;
+	sb->s_blocksize_bits	= PAGE_SHIFT;
+	sb->s_magic		= MSHARE_MAGIC;
+	sb->s_op		= &mshare_s_ops;
+	sb->s_d_op		= &msharefs_d_ops;
+	sb->s_time_gran		= 1;
+
+	inode = msharefs_get_inode(sb, NULL, S_IFDIR | 0777);
+	if (!inode) {
+		err = -ENOMEM;
+		goto out;
 	}
+	inode->i_ino = 1;
+	root = d_make_root(inode);
+	if (!root) {
+		err = -ENOMEM;
+		goto out;
+	}
+
+	err = prepopulate_files(sb, inode, root, mshare_files);
+	if (err < 0)
+		goto clean_root;
+
+	sb->s_root = root;
+	msharefs_sb = sb;
+	return err;
+
+clean_root:
+	d_genocide(root);
+	shrink_dcache_parent(root);
+	dput(root);
+out:
 	return err;
 }
 
 static int
 msharefs_get_tree(struct fs_context *fc)
 {
-	return get_tree_single(fc, msharefs_fill_super);
+	return get_tree_nodev(fc, msharefs_fill_super);
 }
 
 static const struct fs_context_operations msharefs_context_ops = {

Signature · 1 line

2.32.0

Quoted 58 lines · Khalid Aziz

Make msharefs filesystem writable and allow creating directories to support better access control to mshare'd regions defined in msharefs.

Signed-off-by Khalid Aziz <[email protected]>

---
  mm/mshare.c | 195 +++++++++++++++++++++++++++++++++++++++++++++++++---
  1 file changed, 186 insertions(+), 9 deletions(-)

mm/mshare.c +29 -1

index 3e448e11c742..2d5924d39221 100644
@@ -21,11 +21,21 @@
  #include <linux/fileattr.h>
  #include <uapi/linux/magic.h>
  #include <uapi/linux/limits.h>
+#include <uapi/linux/mman.h>
 
  static struct super_block *msharefs_sb;
 
+static const struct inode_operations msharefs_dir_inode_ops;
+static const struct inode_operations msharefs_file_inode_ops;
+
+static int
+msharefs_open(struct inode *inode, struct file *file)
+{
+	return simple_open(inode, file);
+}
+
  static const struct file_operations msharefs_file_operations = {
-	.open		= simple_open,
+	.open		= msharefs_open,
  	.llseek		= no_llseek,
  };
 

@@ -42,6 +52,113 @@ msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr)
  	return 0;
  }
 
+static struct dentry
+*msharefs_alloc_dentry(struct dentry *parent, const char *name)
+{
+	struct dentry *d;
+	struct qstr q;
+	int err;
+
+	q.name = name;
+	q.len = strlen(name);
+
+	err = msharefs_d_hash(parent, &q);
+	if (err)
+		return ERR_PTR(err);
+
+	d = d_alloc(parent, &q);
+	if (d)
+		return d;
+

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 82

Quoted 10 lines

mm/mshare.c +10 -0

+	return ERR_PTR(-ENOMEM);
+}
+
+static struct inode
+*msharefs_get_inode(struct super_block *sb, const struct inode *dir,
+			umode_t mode)
+{
+	struct inode *inode = new_inode(sb);
+
+	if (inode) {

Not sure why you wouldn't go with the less-indently version:

	if (!inode)
		return ERR_PTR(-ENOMEM);

	inode->i_ino = get_next_ino();
	<etc>

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 88

Quoted 6 lines

mm/mshare.c +6 -0

+		inode->i_ino = get_next_ino();
+		inode_init_owner(&init_user_ns, inode, dir, mode);
+
+		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
+
+		switch (mode & S_IFMT) {

Shouldn't we set the mode somewhere?

Quoted 27 lines

mm/mshare.c +26 -0

+		case S_IFREG:
+			inode->i_op = &msharefs_file_inode_ops;
+			inode->i_fop = &msharefs_file_operations;
+			break;
+		case S_IFDIR:
+			inode->i_op = &msharefs_dir_inode_ops;
+			inode->i_fop = &simple_dir_operations;
+			inc_nlink(inode);
+			break;
+		case S_IFLNK:
+			inode->i_op = &page_symlink_inode_operations;
+			break;
+		default:
+			discard_new_inode(inode);
+			inode = NULL;
+			break;
+		}
+	}
+
+	return inode;
+}
+
+static int
+msharefs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, dev_t dev)
+{

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 120

Quoted 6 lines

mm/mshare.c +6 -0

+	struct inode *inode;
+	int err = 0;
+
+	inode = msharefs_get_inode(dir->i_sb, dir, mode);
+	if (IS_ERR(inode))
+		return PTR_ERR(inode);

...and if @inode is NULL?

Quoted 49 lines

mm/mshare.c +41 -0

+
+	d_instantiate(dentry, inode);
+	dget(dentry);
+	dir->i_mtime = dir->i_ctime = current_time(dir);
+
+	return err;
+}
+
+static int
+msharefs_create(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, bool excl)
+{
+	return msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFREG, 0);
+}
+
+static int
+msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode)
+{
+	int ret = msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFDIR, 0);
+
+	if (!ret)
+		inc_nlink(dir);
+	return ret;
+}
+
+static const struct inode_operations msharefs_file_inode_ops = {
+	.setattr	= simple_setattr,
+	.getattr	= simple_getattr,
+};
+static const struct inode_operations msharefs_dir_inode_ops = {
+	.create		= msharefs_create,
+	.lookup		= simple_lookup,
+	.link		= simple_link,
+	.unlink		= simple_unlink,
+	.mkdir		= msharefs_mkdir,
+	.rmdir		= simple_rmdir,
+	.mknod		= msharefs_mknod,
+	.rename		= simple_rename,
+};
+
  static void
  mshare_evict_inode(struct inode *inode)
  {

@@ -58,7 +175,7 @@ mshare_info_read(struct file *file, char __user *buf, size_t nbytes,
  {
  	char s[80];
 

mm/mshare.c mshare_info_read(struct file *file, char __user *buf, size_t nbytes, · line 178

Quoted 2 lines

mm/mshare.c +1 -1

-	sprintf(s, "%ld", PGDIR_SIZE);
+	sprintf(s, "%ld\n", PGDIR_SIZE);

Changing this already?

Quoted 8 lines

mm/mshare.c +0 -0

  	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
  }
 

@@ -72,6 +189,38 @@ static const struct super_operations mshare_s_ops = {
  	.evict_inode = mshare_evict_inode,
  };
 

mm/mshare.c static const struct super_operations mshare_s_ops = { · line 202

Quoted 11 lines

mm/mshare.c +11 -0

+static int
+prepopulate_files(struct super_block *s, struct inode *dir,
+			struct dentry *root, const struct tree_descr *files)
+{
+	int i;
+	struct inode *inode;
+	struct dentry *dentry;
+
+	for (i = 0; !files->name || files->name[0]; i++, files++) {
+		if (!files->name)
+			continue;

What ends the array? NULL name or empty name?
Do we have to erase all of these when the fs gets unmounted?

mm/mshare.c +10 -0

+static struct dentry
+*msharefs_alloc_dentry(struct dentry *parent, const char *name)
+{
+	struct dentry *d;
+	struct qstr q;
+	int err;
+
+	q.name = name;
+	q.len = strlen(name);
+

mm/mshare.c +7 -0

+static int
+msharefs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, dev_t dev)
+{
+	struct inode *inode;
+	int err = 0;
+

mm/mshare.c +55 -1

+static int
+msharefs_create(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, bool excl)
+{
+	return msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFREG, 0);
+}
+
+static int
+msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode)
+{
+	int ret = msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFDIR, 0);
+
+	if (!ret)
+		inc_nlink(dir);
+	return ret;
+}
+
+static const struct inode_operations msharefs_file_inode_ops = {
+	.setattr	= simple_setattr,
+	.getattr	= simple_getattr,
+};
+static const struct inode_operations msharefs_dir_inode_ops = {
+	.create		= msharefs_create,
+	.lookup		= simple_lookup,
+	.link		= simple_link,
+	.unlink		= simple_unlink,
+	.mkdir		= msharefs_mkdir,
+	.rmdir		= simple_rmdir,
+	.mknod		= msharefs_mknod,
+	.rename		= simple_rename,
+};
+
 static void
 mshare_evict_inode(struct inode *inode)
 {

@@ -58,7 +175,7 @@ mshare_info_read(struct file *file, char __user *buf, size_t nbytes,
 {
 	char s[80];
 
-	sprintf(s, "%ld", PGDIR_SIZE);
+	sprintf(s, "%ld\n", PGDIR_SIZE);
 	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
 }
 

@@ -72,6 +189,38 @@ static const struct super_operations mshare_s_ops = {
 	.evict_inode = mshare_evict_inode,
 };
 
+static int
+prepopulate_files(struct super_block *s, struct inode *dir,
+			struct dentry *root, const struct tree_descr *files)
+{
+	int i;
+	struct inode *inode;
+	struct dentry *dentry;
+
+	for (i = 0; !files->name || files->name[0]; i++, files++) {
+		if (!files->name)
+			continue;
+
+		dentry = msharefs_alloc_dentry(root, files->name);
+		if (!dentry)
+			return -ENOMEM;
+
+		inode = msharefs_get_inode(s, dir, S_IFREG | files->mode);
+		if (!inode) {
+			dput(dentry);
+			return -ENOMEM;
+		}

mm/mshare.c line 35

Quoted 5 lines · Khalid Aziz

mm/mshare.c +5 -0

+static int
+msharefs_open(struct inode *inode, struct file *file)
+{
+	return simple_open(inode, file);
+}

Again, whatever for? >

Quoted 14 lines

mm/mshare.c +14 -0

+static struct dentry
+*msharefs_alloc_dentry(struct dentry *parent, const char *name)
+{
+	struct dentry *d;
+	struct qstr q;
+	int err;
+
+	q.name = name;
+	q.len = strlen(name);
+
+	err = msharefs_d_hash(parent, &q);
+	if (err)
+		return ERR_PTR(err);
+

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 74

Quoted 6 lines

mm/mshare.c +6 -0

+	d = d_alloc(parent, &q);
+	if (d)
+		return d;
+
+	return ERR_PTR(-ENOMEM);
+}

And it's different from d_alloc_name() how, exactly?

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 100

Quoted 4 lines

mm/mshare.c +3 -0

+		case S_IFLNK:
+			inode->i_op = &page_symlink_inode_operations;
+			break;

Really? You've got symlinks here?

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 103

Quoted 4 lines

mm/mshare.c +3 -0

+		default:
+			discard_new_inode(inode);
+			inode = NULL;

That's an odd way to spell BUG()...

Quoted 12 lines

mm/mshare.c +11 -0

+static int
+msharefs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, dev_t dev)
+{
+	struct inode *inode;
+	int err = 0;
+
+	inode = msharefs_get_inode(dir->i_sb, dir, mode);
+	if (IS_ERR(inode))
+		return PTR_ERR(inode);
+

mm/mshare.c msharefs_d_hash(const struct dentry *dentry, struct qstr *qstr) · line 127

Quoted 6 lines

mm/mshare.c +6 -0

+	d_instantiate(dentry, inode);
+	dget(dentry);
+	dir->i_mtime = dir->i_ctime = current_time(dir);
+
+	return err;
+}

BTW, what's the point of having device nodes on that thing?

Quoted 71 lines

mm/mshare.c +55 -1

+static int
+msharefs_create(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode, bool excl)
+{
+	return msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFREG, 0);
+}
+
+static int
+msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
+		struct dentry *dentry, umode_t mode)
+{
+	int ret = msharefs_mknod(&init_user_ns, dir, dentry, mode | S_IFDIR, 0);
+
+	if (!ret)
+		inc_nlink(dir);
+	return ret;
+}
+
+static const struct inode_operations msharefs_file_inode_ops = {
+	.setattr	= simple_setattr,
+	.getattr	= simple_getattr,
+};
+static const struct inode_operations msharefs_dir_inode_ops = {
+	.create		= msharefs_create,
+	.lookup		= simple_lookup,
+	.link		= simple_link,
+	.unlink		= simple_unlink,
+	.mkdir		= msharefs_mkdir,
+	.rmdir		= simple_rmdir,
+	.mknod		= msharefs_mknod,
+	.rename		= simple_rename,
+};
+
  static void
  mshare_evict_inode(struct inode *inode)
  {

@@ -58,7 +175,7 @@ mshare_info_read(struct file *file, char __user *buf, size_t nbytes,
  {
  	char s[80];
 
-	sprintf(s, "%ld", PGDIR_SIZE);
+	sprintf(s, "%ld\n", PGDIR_SIZE);
  	return simple_read_from_buffer(buf, nbytes, ppos, s, strlen(s));
  }
 

@@ -72,6 +189,38 @@ static const struct super_operations mshare_s_ops = {
  	.evict_inode = mshare_evict_inode,
  };
 
+static int
+prepopulate_files(struct super_block *s, struct inode *dir,
+			struct dentry *root, const struct tree_descr *files)
+{
+	int i;
+	struct inode *inode;
+	struct dentry *dentry;
+
+	for (i = 0; !files->name || files->name[0]; i++, files++) {
+		if (!files->name)
+			continue;
+
+		dentry = msharefs_alloc_dentry(root, files->name);
+		if (!dentry)
+			return -ENOMEM;
+
+		inode = msharefs_get_inode(s, dir, S_IFREG | files->mode);
+		if (!inode) {
+			dput(dentry);
+			return -ENOMEM;
+		}

mm/mshare.c static const struct super_operations mshare_s_ops = { · line 222

Quoted 10 lines

mm/mshare.c +10 -0

+		inode->i_mode = S_IFREG | files->mode;
+		inode->i_atime = inode->i_mtime = inode->i_ctime
+			= current_time(inode);
+		inode->i_fop = files->ops;
+		inode->i_ino = i;
+		d_add(dentry, inode);
+	}
+
+	return 0;
+}

Looks remarkably similar to something I've seen somewhere... fs/libfs.c, if I'm not mistaken...

Sarcasm aside, what's wrong with using simple_fill_super()?

When a new file is created under msharefs, allocate a new mm_struct that will hold the VMAs for mshare region. Also allocate structure to defines the mshare region and add a read operation to the file that returns this information about the mshare region. Currently this information is returned as a struct:

struct mshare_info {
	unsigned long start;
	unsigned long size;
};

This gives the start address for mshare region and its size.

Signed-off-by Khalid Aziz <[email protected]>

---
 include/uapi/linux/mman.h |  5 +++
 mm/mshare.c               | 64 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 68 insertions(+), 1 deletion(-)

include/uapi/linux/mman.h +0 -0

index f55bc680b5b0..56fe446e24b1 100644

include/uapi/linux/mman.h +2 -0

+};
+
 #endif /* _UAPI_LINUX_MMAN_H */

mm/mshare.c +9 -0

index 2d5924d39221..d238b68b0576 100644
@@ -22,8 +22,14 @@
 #include <uapi/linux/magic.h>
 #include <uapi/linux/limits.h>
 #include <uapi/linux/mman.h>
+#include <linux/sched/mm.h>
 
 static struct super_block *msharefs_sb;
+struct mshare_data {
+	struct mm_struct *mm;
+	refcount_t refcnt;
+	struct mshare_info *minfo;
+};
 
 static const struct inode_operations msharefs_dir_inode_ops;
 static const struct inode_operations msharefs_file_inode_ops;

@@ -34,8 +40,29 @@ msharefs_open(struct inode *inode, struct file *file)
 	return simple_open(inode, file);
 }
 
+static ssize_t
+msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
+{

mm/mshare.c +40 -1

+	}
+	ret = copy_to_iter(&m_info, sizeof(m_info), iov);
+	if (!ret)
+		return -EFAULT;
+	return ret;
+}
+
 static const struct file_operations msharefs_file_operations = {
 	.open		= msharefs_open,
+	.read_iter	= msharefs_read,
 	.llseek		= no_llseek,
 };
 

@@ -73,12 +100,43 @@ static struct dentry
 	return ERR_PTR(-ENOMEM);
 }
 
+static int
+msharefs_fill_mm(struct inode *inode)
+{
+	struct mm_struct *mm;
+	struct mshare_data *info = NULL;
+	int retval = 0;
+
+	mm = mm_alloc();
+	if (!mm) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+
+	info = kzalloc(sizeof(*info), GFP_KERNEL);
+	if (!info) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+	info->mm = mm;
+	info->minfo = NULL;
+	refcount_set(&info->refcnt, 1);
+	inode->i_private = info;
+
+	return 0;
+
+err_free:
+	if (mm)
+		mmput(mm);
+	kfree(info);
+	return retval;
+}
+
 static struct inode
 *msharefs_get_inode(struct super_block *sb, const struct inode *dir,
 			umode_t mode)
 {
 	struct inode *inode = new_inode(sb);
-
 	if (inode) {
 		inode->i_ino = get_next_ino();
 		inode_init_owner(&init_user_ns, inode, dir, mode);

mm/mshare.c +1 -0

+			}
 			break;
 		case S_IFDIR:
 			inode->i_op = &msharefs_dir_inode_ops;

Signature · 1 line

2.32.0

Quoted 24 lines · Khalid Aziz

When a new file is created under msharefs, allocate a new mm_struct that will hold the VMAs for mshare region. Also allocate structure to defines the mshare region and add a read operation to the file that returns this information about the mshare region. Currently this information is returned as a struct:

struct mshare_info {
	unsigned long start;
	unsigned long size;
};

This gives the start address for mshare region and its size.

Signed-off-by Khalid Aziz <[email protected]>

---
  include/uapi/linux/mman.h |  5 +++
  mm/mshare.c               | 64 ++++++++++++++++++++++++++++++++++++++-
  2 files changed, 68 insertions(+), 1 deletion(-)

include/uapi/linux/mman.h +0 -0

index f55bc680b5b0..56fe446e24b1 100644

include/uapi/linux/mman.h line 46

Quoted 6 lines

include/uapi/linux/mman.h +3 -0

@@ -41,4 +41,9 @@
  #define MAP_HUGE_2GB	HUGETLB_FLAG_ENCODE_2GB
  #define MAP_HUGE_16GB	HUGETLB_FLAG_ENCODE_16GB
 
+struct mshare_info {
+	unsigned long start;
+	unsigned long size;

You might want to make these explicitly u64, since this is userspace ABI and you never know when someone will want to do something crazy like run 32-bit programs with mshare files.

Also you might want to add some padding fields for flags, future expansion, etc.

Quoted 30 lines

include/uapi/linux/mman.h +2 -0

+};
+
  #endif /* _UAPI_LINUX_MMAN_H */

mm/mshare.c +9 -0

index 2d5924d39221..d238b68b0576 100644
@@ -22,8 +22,14 @@
  #include <uapi/linux/magic.h>
  #include <uapi/linux/limits.h>
  #include <uapi/linux/mman.h>
+#include <linux/sched/mm.h>
 
  static struct super_block *msharefs_sb;
+struct mshare_data {
+	struct mm_struct *mm;
+	refcount_t refcnt;
+	struct mshare_info *minfo;
+};
 
  static const struct inode_operations msharefs_dir_inode_ops;
  static const struct inode_operations msharefs_file_inode_ops;

@@ -34,8 +40,29 @@ msharefs_open(struct inode *inode, struct file *file)
  	return simple_open(inode, file);
  }
 
+static ssize_t
+msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
+{

mm/mshare.c msharefs_open(struct inode *inode, struct file *file) · line 55

Quoted 10 lines

mm/mshare.c +10 -0

+	struct mshare_data *info = iocb->ki_filp->private_data;
+	size_t ret;
+	struct mshare_info m_info;
+
+	if (info->minfo != NULL) {
+		m_info.start = info->minfo->start;
+		m_info.size = info->minfo->size;
+	} else {
+		m_info.start = 0;
+		m_info.size = 0;

Hmmm, read()ing out the shared mapping information. Heh.

When does this case happen? Is it before anybody mmaps this file into an address space?

Quoted 60 lines

mm/mshare.c +40 -1

+	}
+	ret = copy_to_iter(&m_info, sizeof(m_info), iov);
+	if (!ret)
+		return -EFAULT;
+	return ret;
+}
+
  static const struct file_operations msharefs_file_operations = {
  	.open		= msharefs_open,
+	.read_iter	= msharefs_read,
  	.llseek		= no_llseek,
  };
 

@@ -73,12 +100,43 @@ static struct dentry
  	return ERR_PTR(-ENOMEM);
  }
 
+static int
+msharefs_fill_mm(struct inode *inode)
+{
+	struct mm_struct *mm;
+	struct mshare_data *info = NULL;
+	int retval = 0;
+
+	mm = mm_alloc();
+	if (!mm) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+
+	info = kzalloc(sizeof(*info), GFP_KERNEL);
+	if (!info) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+	info->mm = mm;
+	info->minfo = NULL;
+	refcount_set(&info->refcnt, 1);
+	inode->i_private = info;
+
+	return 0;
+
+err_free:
+	if (mm)
+		mmput(mm);
+	kfree(info);
+	return retval;
+}
+
  static struct inode
  *msharefs_get_inode(struct super_block *sb, const struct inode *dir,
  			umode_t mode)
  {
  	struct inode *inode = new_inode(sb);
-
  	if (inode) {
  		inode->i_ino = get_next_ino();
  		inode_init_owner(&init_user_ns, inode, dir, mode);

@@ -89,6 +147,10 @@ static struct inode
  		case S_IFREG:

mm/mshare.c static struct inode · line 152

Quoted 5 lines

mm/mshare.c +3 -0

  			inode->i_op = &msharefs_file_inode_ops;
  			inode->i_fop = &msharefs_file_operations;
+			if (msharefs_fill_mm(inode) != 0) {
+				discard_new_inode(inode);
+				inode = ERR_PTR(-ENOMEM);

Is it intentional to clobber the msharefs_fill_mm return value and replace it with ENOMEM?

Add a bit to vm_flags to indicate a vma shares PTEs with others. Add a function to determine if a vma shares PTE by checking this flag. This is to be used to find the shared page table entries on page fault for vmas sharing PTE.

Signed-off-by Khalid Aziz <[email protected]>

Signed-off-by Matthew Wilcox (Oracle) <[email protected]>

---
 include/linux/mm.h             | 8 ++++++++
 include/trace/events/mmflags.h | 3 ++-
 mm/internal.h                  | 5 +++++
 3 files changed, 15 insertions(+), 1 deletion(-)

include/linux/mm.h +2 -0

index bc8f326be0ce..0ddc3057f73b 100644
@@ -310,11 +310,13 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_HIGH_ARCH_BIT_2     34      /* bit only usable on 64-bit architectures */
 #define VM_HIGH_ARCH_BIT_3     35      /* bit only usable on 64-bit architectures */
 #define VM_HIGH_ARCH_BIT_4     36      /* bit only usable on 64-bit architectures */
+#define VM_HIGH_ARCH_BIT_5     37      /* bit only usable on 64-bit architectures */
 #define VM_HIGH_ARCH_0 BIT(VM_HIGH_ARCH_BIT_0)
 #define VM_HIGH_ARCH_1 BIT(VM_HIGH_ARCH_BIT_1)
 #define VM_HIGH_ARCH_2 BIT(VM_HIGH_ARCH_BIT_2)
 #define VM_HIGH_ARCH_3 BIT(VM_HIGH_ARCH_BIT_3)
 #define VM_HIGH_ARCH_4 BIT(VM_HIGH_ARCH_BIT_4)
+#define VM_HIGH_ARCH_5 BIT(VM_HIGH_ARCH_BIT_5)
 #endif /* CONFIG_ARCH_USES_HIGH_VMA_FLAGS */
 
 #ifdef CONFIG_ARCH_HAS_PKEYS

include/linux/mm.h +0 -0

 #ifndef VM_GROWSUP
 # define VM_GROWSUP    VM_NONE
 #endif

include/trace/events/mmflags.h +2 -1

index e87cb2b80ed3..30e56cbac99b 100644
@@ -194,7 +194,8 @@ IF_HAVE_VM_SOFTDIRTY(VM_SOFTDIRTY,  "softdirty"     )               \
        {VM_MIXEDMAP,                   "mixedmap"      },              \
        {VM_HUGEPAGE,                   "hugepage"      },              \
        {VM_NOHUGEPAGE,                 "nohugepage"    },              \
-       {VM_MERGEABLE,                  "mergeable"     }               \
+       {VM_MERGEABLE,                  "mergeable"     },              \
+       {VM_SHARED_PT,                  "sharedpt"      }               \
 
 #define show_vma_flags(flags)                                          \
        (flags) ? __print_flags(flags, "|",                             \

mm/internal.h +5 -1

index c0f8fbe0445b..3f2790aea918 100644
@@ -861,4 +861,9 @@ struct folio *try_grab_folio(struct page *page, int refs, unsigned int flags);
 
 DECLARE_PER_CPU(struct per_cpu_nodestat, boot_nodestats);
 
+static inline bool vma_is_shared(const struct vm_area_struct *vma)
+{
+       return vma->vm_flags & VM_SHARED_PT;
+}
+
 #endif /* __MM_INTERNAL_H */
--

2.32.0

Quoted 36 lines · Khalid Aziz

Add a bit to vm_flags to indicate a vma shares PTEs with others. Add a function to determine if a vma shares PTE by checking this flag. This is to be used to find the shared page table entries on page fault for vmas sharing PTE.

Signed-off-by Khalid Aziz <[email protected]>

Signed-off-by Matthew Wilcox (Oracle) <[email protected]>

---
  include/linux/mm.h             | 8 ++++++++
  include/trace/events/mmflags.h | 3 ++-
  mm/internal.h                  | 5 +++++
  3 files changed, 15 insertions(+), 1 deletion(-)

include/linux/mm.h +2 -0

index bc8f326be0ce..0ddc3057f73b 100644
@@ -310,11 +310,13 @@ extern unsigned int kobjsize(const void *objp);
  #define VM_HIGH_ARCH_BIT_2     34      /* bit only usable on 64-bit architectures */
  #define VM_HIGH_ARCH_BIT_3     35      /* bit only usable on 64-bit architectures */
  #define VM_HIGH_ARCH_BIT_4     36      /* bit only usable on 64-bit architectures */
+#define VM_HIGH_ARCH_BIT_5     37      /* bit only usable on 64-bit architectures */
  #define VM_HIGH_ARCH_0 BIT(VM_HIGH_ARCH_BIT_0)
  #define VM_HIGH_ARCH_1 BIT(VM_HIGH_ARCH_BIT_1)
  #define VM_HIGH_ARCH_2 BIT(VM_HIGH_ARCH_BIT_2)
  #define VM_HIGH_ARCH_3 BIT(VM_HIGH_ARCH_BIT_3)
  #define VM_HIGH_ARCH_4 BIT(VM_HIGH_ARCH_BIT_4)
+#define VM_HIGH_ARCH_5 BIT(VM_HIGH_ARCH_BIT_5)
  #endif /* CONFIG_ARCH_USES_HIGH_VMA_FLAGS */
 
  #ifdef CONFIG_ARCH_HAS_PKEYS

@@ -356,6 +358,12 @@ extern unsigned int kobjsize(const void *objp);
  # define VM_MTE_ALLOWED        VM_NONE
  #endif
 

include/linux/mm.h extern unsigned int kobjsize(const void *objp); · line 366

Quoted 6 lines

include/linux/mm.h +6 -0

+#ifdef CONFIG_ARCH_USES_HIGH_VMA_FLAGS
+#define VM_SHARED_PT   VM_HIGH_ARCH_5
+#else
+#define VM_SHARED_PT   0
+#endif
+

I'm not clear why mshare is using high-vma flags for VM_SHARED_PT. CONFIG_ARCH_USES_HIGH_VMA_FLAGS might not be defined, making mshare unsupported (or, rather, broken).
Is this being done as there is a shortage of non-high flags? 0x00000800 is available, although it appears to be the last one (quick check).
(When using the last 'normal' flag bit, good idea to highlight this in the cover letter.)

Quoted 35 lines

include/linux/mm.h +0 -0

  #ifndef VM_GROWSUP
  # define VM_GROWSUP    VM_NONE
  #endif

include/trace/events/mmflags.h +2 -1

index e87cb2b80ed3..30e56cbac99b 100644
@@ -194,7 +194,8 @@ IF_HAVE_VM_SOFTDIRTY(VM_SOFTDIRTY,  "softdirty"     )               \
         {VM_MIXEDMAP,                   "mixedmap"      },              \
         {VM_HUGEPAGE,                   "hugepage"      },              \
         {VM_NOHUGEPAGE,                 "nohugepage"    },              \
-       {VM_MERGEABLE,                  "mergeable"     }               \
+       {VM_MERGEABLE,                  "mergeable"     },              \
+       {VM_SHARED_PT,                  "sharedpt"      }               \
 
  #define show_vma_flags(flags)                                          \
         (flags) ? __print_flags(flags, "|",                             \

mm/internal.h +5 -1

index c0f8fbe0445b..3f2790aea918 100644
@@ -861,4 +861,9 @@ struct folio *try_grab_folio(struct page *page, int refs, unsigned int flags);
 
  DECLARE_PER_CPU(struct per_cpu_nodestat, boot_nodestats);
 
+static inline bool vma_is_shared(const struct vm_area_struct *vma)
+{
+       return vma->vm_flags & VM_SHARED_PT;
+}
+
  #endif /* __MM_INTERNAL_H */
--

2.32.0

mmap is used to establish address range for mshare region and map the region into process's address space. Add basic mmap operation that supports setting address range. Also fix code to not allocate new mm_struct for files in msharefs that exist for information and not for defining a new mshare region.

Signed-off-by Khalid Aziz <[email protected]>

Signed-off-by Matthew Wilcox (Oracle) <[email protected]>

---
 mm/mshare.c | 48 +++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 7 deletions(-)

mm/mshare.c +13 -1

index d238b68b0576..088a6cab1e93 100644
@@ -9,7 +9,8 @@
  *
  *
  * Copyright (C) 2022 Oracle Corp. All rights reserved.
- * Author:	Khalid Aziz <[email protected]>
+ * Authors:	Khalid Aziz <[email protected]>
+ *		Matthew Wilcox <[email protected]>
  *
  */
 

@@ -60,9 +61,36 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
 	return ret;
 }
 
+static int
+msharefs_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	struct mshare_data *info = file->private_data;
+	struct mm_struct *mm = info->mm;
+
+	/*
+	 * If this mshare region has been set up once already, bail out
+	 */
+	if (mm->mmap_base != 0)
+		return -EINVAL;

mm/mshare.c +16 -4

+	vma->vm_flags |= VM_SHARED_PT;
+	vma->vm_private_data = info;
+	return 0;
+}
+
 static const struct file_operations msharefs_file_operations = {
 	.open		= msharefs_open,
 	.read_iter	= msharefs_read,
+	.mmap		= msharefs_mmap,
 	.llseek		= no_llseek,
 };
 

@@ -119,7 +147,12 @@ msharefs_fill_mm(struct inode *inode)
 		goto err_free;
 	}
 	info->mm = mm;
-	info->minfo = NULL;
+	info->minfo = kzalloc(sizeof(struct mshare_info), GFP_KERNEL);
+	if (info->minfo == NULL) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+
 	refcount_set(&info->refcnt, 1);
 	inode->i_private = info;
 

@@ -128,13 +161,14 @@ msharefs_fill_mm(struct inode *inode)
 err_free:
 	if (mm)
 		mmput(mm);
+	kfree(info->minfo);
 	kfree(info);
 	return retval;
 }
 
 static struct inode
 *msharefs_get_inode(struct super_block *sb, const struct inode *dir,
-			umode_t mode)
+			umode_t mode, bool newmm)
 {
 	struct inode *inode = new_inode(sb);
 	if (inode) {

@@ -147,7 +181,7 @@ static struct inode
 		case S_IFREG:
 			inode->i_op = &msharefs_file_inode_ops;
 			inode->i_fop = &msharefs_file_operations;
-			if (msharefs_fill_mm(inode) != 0) {
+			if (newmm && msharefs_fill_mm(inode) != 0) {
 				discard_new_inode(inode);
 				inode = ERR_PTR(-ENOMEM);
 			}

@@ -177,7 +211,7 @@ msharefs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
 	struct inode *inode;
 	int err = 0;
 
-	inode = msharefs_get_inode(dir->i_sb, dir, mode);
+	inode = msharefs_get_inode(dir->i_sb, dir, mode, true);
 	if (IS_ERR(inode))
 		return PTR_ERR(inode);
 

mm/mshare.c +0 -0

 	if (!inode) {
 		err = -ENOMEM;
 		goto out;

Signature · 1 line

2.32.0

Quoted 47 lines · Khalid Aziz

mmap is used to establish address range for mshare region and map the region into process's address space. Add basic mmap operation that supports setting address range. Also fix code to not allocate new mm_struct for files in msharefs that exist for information and not for defining a new mshare region.

Signed-off-by Khalid Aziz <[email protected]>

Signed-off-by Matthew Wilcox (Oracle) <[email protected]>

---
  mm/mshare.c | 48 +++++++++++++++++++++++++++++++++++++++++-------
  1 file changed, 41 insertions(+), 7 deletions(-)

mm/mshare.c +19 -1

index d238b68b0576..088a6cab1e93 100644
@@ -9,7 +9,8 @@
   *
   *
   * Copyright (C) 2022 Oracle Corp. All rights reserved.
- * Author:	Khalid Aziz <[email protected]>
+ * Authors:	Khalid Aziz <[email protected]>
+ *		Matthew Wilcox <[email protected]>
   *
   */
 

@@ -60,9 +61,36 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
  	return ret;
  }
 
+static int
+msharefs_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	struct mshare_data *info = file->private_data;
+	struct mm_struct *mm = info->mm;
+
+	/*
+	 * If this mshare region has been set up once already, bail out
+	 */
+	if (mm->mmap_base != 0)
+		return -EINVAL;
+
+	if ((vma->vm_start | vma->vm_end) & (PGDIR_SIZE - 1))
+		return -EINVAL;
+
+	mm->mmap_base = vma->vm_start;
+	mm->task_size = vma->vm_end - vma->vm_start;

mm/mshare.c msharefs_read(struct kiocb *iocb, struct iov_iter *iov) · line 84

Quoted 4 lines

mm/mshare.c +4 -0

+	if (!mm->task_size)
+		mm->task_size--;
+	info->minfo->start = mm->mmap_base;
+	info->minfo->size = mm->task_size;

So, uh, if the second mmap() caller decides to ignore the mshare_info, should they get an -EINVAL here since the memory mappings won't be at the same process virtual address?

Quoted 65 lines

mm/mshare.c +16 -4

+	vma->vm_flags |= VM_SHARED_PT;
+	vma->vm_private_data = info;
+	return 0;
+}
+
  static const struct file_operations msharefs_file_operations = {
  	.open		= msharefs_open,
  	.read_iter	= msharefs_read,
+	.mmap		= msharefs_mmap,
  	.llseek		= no_llseek,
  };
 

@@ -119,7 +147,12 @@ msharefs_fill_mm(struct inode *inode)
  		goto err_free;
  	}
  	info->mm = mm;
-	info->minfo = NULL;
+	info->minfo = kzalloc(sizeof(struct mshare_info), GFP_KERNEL);
+	if (info->minfo == NULL) {
+		retval = -ENOMEM;
+		goto err_free;
+	}
+
  	refcount_set(&info->refcnt, 1);
  	inode->i_private = info;
 

@@ -128,13 +161,14 @@ msharefs_fill_mm(struct inode *inode)
  err_free:
  	if (mm)
  		mmput(mm);
+	kfree(info->minfo);
  	kfree(info);
  	return retval;
  }
 
  static struct inode
  *msharefs_get_inode(struct super_block *sb, const struct inode *dir,
-			umode_t mode)
+			umode_t mode, bool newmm)
  {
  	struct inode *inode = new_inode(sb);
  	if (inode) {

@@ -147,7 +181,7 @@ static struct inode
  		case S_IFREG:
  			inode->i_op = &msharefs_file_inode_ops;
  			inode->i_fop = &msharefs_file_operations;
-			if (msharefs_fill_mm(inode) != 0) {
+			if (newmm && msharefs_fill_mm(inode) != 0) {
  				discard_new_inode(inode);
  				inode = ERR_PTR(-ENOMEM);
  			}

@@ -177,7 +211,7 @@ msharefs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
  	struct inode *inode;
  	int err = 0;
 
-	inode = msharefs_get_inode(dir->i_sb, dir, mode);
+	inode = msharefs_get_inode(dir->i_sb, dir, mode, true);
  	if (IS_ERR(inode))
  		return PTR_ERR(inode);
 

@@ -267,7 +301,7 @@ prepopulate_files(struct super_block *s, struct inode *dir,
  		if (!dentry)
  			return -ENOMEM;
 

mm/mshare.c prepopulate_files(struct super_block *s, struct inode *dir, · line 304

Quoted 2 lines

mm/mshare.c +1 -1

-		inode = msharefs_get_inode(s, dir, S_IFREG | files->mode);
+		inode = msharefs_get_inode(s, dir, S_IFREG | files->mode, false);

I was wondering why the information files were getting their own mshare_data.

TBH I'm not really sure what the difference is between mshare_data and mshare_info, since those names are not especially distinct.

Quoted 8 lines

mm/mshare.c +0 -0

  		if (!inode) {
  			dput(dentry);
  			return -ENOMEM;

@@ -301,7 +335,7 @@ msharefs_fill_super(struct super_block *sb, struct fs_context *fc)
  	sb->s_d_op		= &msharefs_d_ops;
  	sb->s_time_gran		= 1;
 

mm/mshare.c msharefs_fill_super(struct super_block *sb, struct fs_context *fc) · line 338

Quoted 2 lines

mm/mshare.c +1 -1

-	inode = msharefs_get_inode(sb, NULL, S_IFDIR | 0777);
+	inode = msharefs_get_inode(sb, NULL, S_IFDIR | 0777, false);

Is it wise to default to world-writable? Surely whatever userspace software wraps an msharefs can relax permissions as needed.

Number of mappings of an mshare region should be tracked so it can be removed when there are no more references to it and associated file has been deleted. This add code to support the unlink operation for associated file, remove the mshare region on file deletion if refcount goes to zero, add munmap operation to maintain refcount to mshare region and remove it on last munmap if file has been deleted.

Signed-off-by Khalid Aziz <[email protected]>

---
 mm/mshare.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 63 insertions(+), 1 deletion(-)

mm/mshare.c +5 -0

index 088a6cab1e93..90ce0564a138 100644
@@ -29,6 +29,7 @@ static struct super_block *msharefs_sb;
 struct mshare_data {
 	struct mm_struct *mm;
 	refcount_t refcnt;
+	int deleted;
 	struct mshare_info *minfo;
 };
 

@@ -48,6 +49,7 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
 	size_t ret;
 	struct mshare_info m_info;
 
+	mmap_read_lock(info->mm);
 	if (info->minfo != NULL) {
 		m_info.start = info->minfo->start;
 		m_info.size = info->minfo->size;

@@ -55,18 +57,42 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
 		m_info.start = 0;
 		m_info.size = 0;
 	}
+	mmap_read_unlock(info->mm);
 	ret = copy_to_iter(&m_info, sizeof(m_info), iov);
 	if (!ret)
 		return -EFAULT;
 	return ret;
 }
 
+static void
+msharefs_close(struct vm_area_struct *vma)

mm/mshare.c +24 -0

+		} else {
+			mmap_read_unlock(info->mm);
+		}
+	}
+}
+
+static const struct vm_operations_struct msharefs_vm_ops = {
+	.close	= msharefs_close,
+};
+
 static int
 msharefs_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct mshare_data *info = file->private_data;
 	struct mm_struct *mm = info->mm;
 
+	mmap_write_lock(mm);
 	/*
 	 * If this mshare region has been set up once already, bail out
 	 */

@@ -80,10 +106,14 @@ msharefs_mmap(struct file *file, struct vm_area_struct *vma)
 	mm->task_size = vma->vm_end - vma->vm_start;
 	if (!mm->task_size)
 		mm->task_size--;
+	mmap_write_unlock(mm);
 	info->minfo->start = mm->mmap_base;
 	info->minfo->size = mm->task_size;
+	info->deleted = 0;
+	refcount_inc(&info->refcnt);
 	vma->vm_flags |= VM_SHARED_PT;
 	vma->vm_private_data = info;
+	vma->vm_ops = &msharefs_vm_ops;
 	return 0;
 }
 

@@ -240,6 +270,38 @@ msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
 	return ret;
 }
 
+static int
+msharefs_unlink(struct inode *dir, struct dentry *dentry)
+{
+	struct inode *inode = d_inode(dentry);
+	struct mshare_data *info = inode->i_private;
+
+	/*
+	 * Unmap the mshare region if it is still mapped in
+	 */

mm/mshare.c +14 -1

+
+	/*
+	 * Is this the last reference? If so, delete mshare region and
+	 * remove the file
+	 */
+	if (!refcount_dec_and_test(&info->refcnt)) {
+		mmput(info->mm);
+		kfree(info->minfo);
+		kfree(info);
+	}
+	return 0;
+}
+
 static const struct inode_operations msharefs_file_inode_ops = {
 	.setattr	= simple_setattr,
 	.getattr	= simple_getattr,

@@ -248,7 +310,7 @@ static const struct inode_operations msharefs_dir_inode_ops = {
 	.create		= msharefs_create,
 	.lookup		= simple_lookup,
 	.link		= simple_link,
-	.unlink		= simple_unlink,
+	.unlink		= msharefs_unlink,
 	.mkdir		= msharefs_mkdir,
 	.rmdir		= simple_rmdir,
 	.mknod		= msharefs_mknod,

Signature · 1 line

2.32.0

Quoted 54 lines · Khalid Aziz

Number of mappings of an mshare region should be tracked so it can be removed when there are no more references to it and associated file has been deleted. This add code to support the unlink operation for associated file, remove the mshare region on file deletion if refcount goes to zero, add munmap operation to maintain refcount to mshare region and remove it on last munmap if file has been deleted.

Signed-off-by Khalid Aziz <[email protected]>

---
  mm/mshare.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
  1 file changed, 63 insertions(+), 1 deletion(-)

mm/mshare.c +13 -0

index 088a6cab1e93..90ce0564a138 100644
@@ -29,6 +29,7 @@ static struct super_block *msharefs_sb;
  struct mshare_data {
  	struct mm_struct *mm;
  	refcount_t refcnt;
+	int deleted;
  	struct mshare_info *minfo;
  };
 

@@ -48,6 +49,7 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
  	size_t ret;
  	struct mshare_info m_info;
 
+	mmap_read_lock(info->mm);
  	if (info->minfo != NULL) {
  		m_info.start = info->minfo->start;
  		m_info.size = info->minfo->size;

@@ -55,18 +57,42 @@ msharefs_read(struct kiocb *iocb, struct iov_iter *iov)
  		m_info.start = 0;
  		m_info.size = 0;
  	}
+	mmap_read_unlock(info->mm);
  	ret = copy_to_iter(&m_info, sizeof(m_info), iov);
  	if (!ret)
  		return -EFAULT;
  	return ret;
  }
 
+static void
+msharefs_close(struct vm_area_struct *vma)
+{
+	struct mshare_data *info = vma->vm_private_data;
+
+	if (refcount_dec_and_test(&info->refcnt)) {
+		mmap_read_lock(info->mm);
+		if (info->deleted) {
+			mmap_read_unlock(info->mm);
+			mmput(info->mm);

mm/mshare.c msharefs_read(struct kiocb *iocb, struct iov_iter *iov) · line 78

Quoted 2 lines

mm/mshare.c +2 -0

+			kfree(info->minfo);
+			kfree(info);

Aren't filesystems supposed to take care of disposing of the file data in destroy_inode? IIRC struct inode doesn't go away until all fds are closed, mappings are torn down, and there are no more references from dentries. I could be misremembering since it's been a few months since I went looking at the (VFS) inode lifecycle.

Quoted 53 lines

mm/mshare.c +28 -0

+		} else {
+			mmap_read_unlock(info->mm);
+		}
+	}
+}
+
+static const struct vm_operations_struct msharefs_vm_ops = {
+	.close	= msharefs_close,
+};
+
  static int
  msharefs_mmap(struct file *file, struct vm_area_struct *vma)
  {
  	struct mshare_data *info = file->private_data;
  	struct mm_struct *mm = info->mm;
 
+	mmap_write_lock(mm);
  	/*
  	 * If this mshare region has been set up once already, bail out
  	 */

@@ -80,10 +106,14 @@ msharefs_mmap(struct file *file, struct vm_area_struct *vma)
  	mm->task_size = vma->vm_end - vma->vm_start;
  	if (!mm->task_size)
  		mm->task_size--;
+	mmap_write_unlock(mm);
  	info->minfo->start = mm->mmap_base;
  	info->minfo->size = mm->task_size;
+	info->deleted = 0;
+	refcount_inc(&info->refcnt);
  	vma->vm_flags |= VM_SHARED_PT;
  	vma->vm_private_data = info;
+	vma->vm_ops = &msharefs_vm_ops;
  	return 0;
  }
 

@@ -240,6 +270,38 @@ msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
  	return ret;
  }
 
+static int
+msharefs_unlink(struct inode *dir, struct dentry *dentry)
+{
+	struct inode *inode = d_inode(dentry);
+	struct mshare_data *info = inode->i_private;
+
+	/*
+	 * Unmap the mshare region if it is still mapped in
+	 */
+	vm_munmap(info->minfo->start, info->minfo->size);
+
+	/*
+	 * Mark msharefs file for deletion so it can not be opened

mm/mshare.c msharefs_mkdir(struct user_namespace *mnt_userns, struct inode *dir, · line 291

Quoted 6 lines

mm/mshare.c +6 -0

+	 * and used for mshare mappings any more
+	 */
+	simple_unlink(dir, dentry);
+	mmap_write_lock(info->mm);
+	info->deleted = 1;
+	mmap_write_unlock(info->mm);

What if the file is hardlinked?

Add support for creating a new set of shared page tables in a new mm_struct upon mmap of an mshare region. Add page fault handling in this now mshare'd region. Modify exit_mmap path to make sure page tables in the mshare'd regions are kept intact when a process using mshare'd region exits. Clean up mshare mm_struct when the mshare region is deleted. This support is for the process creating mshare region only. Subsequent patches will add support for other processes to be able to map the mshare region.

Signed-off-by Khalid Aziz <[email protected]>

Signed-off-by Matthew Wilcox (Oracle) <[email protected]>

---
  include/linux/mm.h |   2 +
  mm/internal.h      |   2 +
  mm/memory.c        | 101 +++++++++++++++++++++++++++++-
  mm/mshare.c        | 149 ++++++++++++++++++++++++++++++++++++---------
  4 files changed, 222 insertions(+), 32 deletions(-)

include/linux/mm.h +2 -0

index 0ddc3057f73b..63887f06b37b 100644
@@ -1859,6 +1859,8 @@ void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
  		unsigned long end, unsigned long floor, unsigned long ceiling);
  int
  copy_page_range(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma);
+int
+mshare_copy_ptes(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma);
  int follow_pte(struct mm_struct *mm, unsigned long address,
  	       pte_t **ptepp, spinlock_t **ptlp);
  int follow_pfn(struct vm_area_struct *vma, unsigned long address,

mm/internal.h +2 -0

index 3f2790aea918..6ae7063ac10d 100644
@@ -861,6 +861,8 @@ struct folio *try_grab_folio(struct page *page, int refs, unsigned int flags);
 
  DECLARE_PER_CPU(struct per_cpu_nodestat, boot_nodestats);
 
+extern vm_fault_t find_shared_vma(struct vm_area_struct **vma,
+					unsigned long *addrp);
  static inline bool vma_is_shared(const struct vm_area_struct *vma)
  {
  	return vma->vm_flags & VM_SHARED_PT;

mm/memory.c +64 -2

index 7a089145cad4..2a8d5b8928f5 100644
@@ -416,15 +416,20 @@ void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *vma,
  		unlink_anon_vmas(vma);
  		unlink_file_vma(vma);
 
+		/*
+		 * There is no page table to be freed for vmas that
+		 * are mapped in mshare regions
+		 */
  		if (is_vm_hugetlb_page(vma)) {
  			hugetlb_free_pgd_range(tlb, addr, vma->vm_end,
  				floor, next ? next->vm_start : ceiling);
-		} else {
+		} else if (!vma_is_shared(vma)) {
  			/*
  			 * Optimization: gather nearby vmas into one call down
  			 */
  			while (next && next->vm_start <= vma->vm_end + PMD_SIZE
-			       && !is_vm_hugetlb_page(next)) {
+			       && !is_vm_hugetlb_page(next)
+			       && !vma_is_shared(next)) {
  				vma = next;
  				next = vma->vm_next;
  				unlink_anon_vmas(vma);

@@ -1260,6 +1265,54 @@ vma_needs_copy(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma)
  	return false;
  }
 
+/*
+ * Copy PTEs for mshare'd pages.
+ * This code is based upon copy_page_range()
+ */
+int
+mshare_copy_ptes(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma)
+{
+	pgd_t *src_pgd, *dst_pgd;
+	unsigned long next;
+	unsigned long addr = src_vma->vm_start;
+	unsigned long end = src_vma->vm_end;
+	struct mm_struct *dst_mm = dst_vma->vm_mm;
+	struct mm_struct *src_mm = src_vma->vm_mm;
+	struct mmu_notifier_range range;
+	int ret = 0;
+
+	mmu_notifier_range_init(&range, MMU_NOTIFY_PROTECTION_PAGE,
+				0, src_vma, src_mm, addr, end);
+	mmu_notifier_invalidate_range_start(&range);
+	/*
+	 * Disabling preemption is not needed for the write side, as
+	 * the read side doesn't spin, but goes to the mmap_lock.
+	 *
+	 * Use the raw variant of the seqcount_t write API to avoid
+	 * lockdep complaining about preemptibility.
+	 */
+	mmap_assert_write_locked(src_mm);
+	raw_write_seqcount_begin(&src_mm->write_protect_seq);
+
+	dst_pgd = pgd_offset(dst_mm, addr);
+	src_pgd = pgd_offset(src_mm, addr);
+	do {
+		next = pgd_addr_end(addr, end);
+		if (pgd_none_or_clear_bad(src_pgd))
+			continue;
+		if (unlikely(copy_p4d_range(dst_vma, src_vma, dst_pgd, src_pgd,
+					    addr, next))) {
+			ret = -ENOMEM;
+			break;
+		}
+	} while (dst_pgd++, src_pgd++, addr = next, addr != end);
+
+	raw_write_seqcount_end(&src_mm->write_protect_seq);
+	mmu_notifier_invalidate_range_end(&range);
+
+	return ret;
+}
+
  int
  copy_page_range(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma)
  {

@@ -1628,6 +1681,13 @@ void unmap_page_range(struct mmu_gather *tlb,
  	pgd_t *pgd;
  	unsigned long next;
 
+	/*
+	 * No need to unmap vmas that share page table through
+	 * mshare region
+	 */
+	if (vma_is_shared(vma))
+		return;
+
  	BUG_ON(addr >= end);
  	tlb_start_vma(tlb, vma);
  	pgd = pgd_offset(vma->vm_mm, addr);

@@ -5113,6 +5173,8 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
  			   unsigned int flags, struct pt_regs *regs)
  {
  	vm_fault_t ret;
+	bool shared = false;
+	struct mm_struct *orig_mm;
 
  	__set_current_state(TASK_RUNNING);
 

@@ -5122,6 +5184,16 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
  	/* do counter updates before entering really critical section. */