| Message ID | 20200727162935.31714-4-rppt@kernel.org (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | mm: introduce memfd_secret system call to create "secret" memory areas | expand |
Hi Mike, On Mon, Jul 27, 2020 at 07:29:31PM +0300, Mike Rapoport wrote: > For instance, the following example will create an uncached mapping (error > handling is omitted): > > fd = memfd_secret(SECRETMEM_UNCACHED); > ftruncate(fd, MAP_SIZE); > ptr = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); [...] > +static struct page *secretmem_alloc_page(gfp_t gfp) > +{ > + /* > + * FIXME: use a cache of large pages to reduce the direct map > + * fragmentation > + */ > + return alloc_page(gfp); > +} > + > +static vm_fault_t secretmem_fault(struct vm_fault *vmf) > +{ > + struct address_space *mapping = vmf->vma->vm_file->f_mapping; > + struct inode *inode = file_inode(vmf->vma->vm_file); > + pgoff_t offset = vmf->pgoff; > + unsigned long addr; > + struct page *page; > + int ret = 0; > + > + if (((loff_t)vmf->pgoff << PAGE_SHIFT) >= i_size_read(inode)) > + return vmf_error(-EINVAL); > + > + page = find_get_entry(mapping, offset); > + if (!page) { > + page = secretmem_alloc_page(vmf->gfp_mask); > + if (!page) > + return vmf_error(-ENOMEM); > + > + ret = add_to_page_cache(page, mapping, offset, vmf->gfp_mask); > + if (unlikely(ret)) > + goto err_put_page; > + > + ret = set_direct_map_invalid_noflush(page); > + if (ret) > + goto err_del_page_cache; > + > + addr = (unsigned long)page_address(page); > + flush_tlb_kernel_range(addr, addr + PAGE_SIZE); > + > + __SetPageUptodate(page); > + > + ret = VM_FAULT_LOCKED; > + } > + > + vmf->page = page; > + return ret; > + > +err_del_page_cache: > + delete_from_page_cache(page); > +err_put_page: > + put_page(page); > + return vmf_error(ret); > +} > + > +static const struct vm_operations_struct secretmem_vm_ops = { > + .fault = secretmem_fault, > +}; > + > +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) > +{ > + struct secretmem_ctx *ctx = file->private_data; > + unsigned long mode = ctx->mode; > + unsigned long len = vma->vm_end - vma->vm_start; > + > + if (!mode) > + return -EINVAL; > + > + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) > + return -EINVAL; > + > + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) > + return -EAGAIN; > + > + switch (mode) { > + case SECRETMEM_UNCACHED: > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > + fallthrough; > + case SECRETMEM_EXCLUSIVE: > + vma->vm_ops = &secretmem_vm_ops; > + break; > + default: > + return -EINVAL; > + } > + > + vma->vm_flags |= VM_LOCKED; > + > + return 0; > +} I think the uncached mapping is not the right thing for arm/arm64. First of all, pgprot_noncached() gives us Strongly Ordered (Device memory) semantics together with not allowing unaligned accesses. I suspect the semantics are different on x86. The second, more serious problem, is that I can't find any place where the caches are flushed for the page mapped on fault. When a page is allocated, assuming GFP_ZERO, only the caches are guaranteed to be zeroed. Exposing this subsequently to user space as uncached would allow the user to read stale data prior to zeroing. The arm64 set_direct_map_default_noflush() doesn't do any cache maintenance.
On Thu, Jul 30, 2020 at 05:22:10PM +0100, Catalin Marinas wrote: > Hi Mike, > > On Mon, Jul 27, 2020 at 07:29:31PM +0300, Mike Rapoport wrote: > > For instance, the following example will create an uncached mapping (error > > handling is omitted): > > > > fd = memfd_secret(SECRETMEM_UNCACHED); > > ftruncate(fd, MAP_SIZE); > > ptr = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); > [...] > > +static struct page *secretmem_alloc_page(gfp_t gfp) > > +{ > > + /* > > + * FIXME: use a cache of large pages to reduce the direct map > > + * fragmentation > > + */ > > + return alloc_page(gfp); > > +} > > + > > +static vm_fault_t secretmem_fault(struct vm_fault *vmf) > > +{ > > + struct address_space *mapping = vmf->vma->vm_file->f_mapping; > > + struct inode *inode = file_inode(vmf->vma->vm_file); > > + pgoff_t offset = vmf->pgoff; > > + unsigned long addr; > > + struct page *page; > > + int ret = 0; > > + > > + if (((loff_t)vmf->pgoff << PAGE_SHIFT) >= i_size_read(inode)) > > + return vmf_error(-EINVAL); > > + > > + page = find_get_entry(mapping, offset); > > + if (!page) { > > + page = secretmem_alloc_page(vmf->gfp_mask); > > + if (!page) > > + return vmf_error(-ENOMEM); > > + > > + ret = add_to_page_cache(page, mapping, offset, vmf->gfp_mask); > > + if (unlikely(ret)) > > + goto err_put_page; > > + > > + ret = set_direct_map_invalid_noflush(page); > > + if (ret) > > + goto err_del_page_cache; > > + > > + addr = (unsigned long)page_address(page); > > + flush_tlb_kernel_range(addr, addr + PAGE_SIZE); > > + > > + __SetPageUptodate(page); > > + > > + ret = VM_FAULT_LOCKED; > > + } > > + > > + vmf->page = page; > > + return ret; > > + > > +err_del_page_cache: > > + delete_from_page_cache(page); > > +err_put_page: > > + put_page(page); > > + return vmf_error(ret); > > +} > > + > > +static const struct vm_operations_struct secretmem_vm_ops = { > > + .fault = secretmem_fault, > > +}; > > + > > +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) > > +{ > > + struct secretmem_ctx *ctx = file->private_data; > > + unsigned long mode = ctx->mode; > > + unsigned long len = vma->vm_end - vma->vm_start; > > + > > + if (!mode) > > + return -EINVAL; > > + > > + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) > > + return -EINVAL; > > + > > + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) > > + return -EAGAIN; > > + > > + switch (mode) { > > + case SECRETMEM_UNCACHED: > > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > > + fallthrough; > > + case SECRETMEM_EXCLUSIVE: > > + vma->vm_ops = &secretmem_vm_ops; > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + vma->vm_flags |= VM_LOCKED; > > + > > + return 0; > > +} > > I think the uncached mapping is not the right thing for arm/arm64. First > of all, pgprot_noncached() gives us Strongly Ordered (Device memory) > semantics together with not allowing unaligned accesses. I suspect the > semantics are different on x86. Hmm, on x86 it's also Strongly Ordered, but I didn't find any alignment restrictions. Is there a mode for arm64 that can provide similar semantics? Would it make sence to use something like #define pgprot_uncached(prot) \ __pgprot_modify(prot, PTE_ATTRINDX_MASK, \ PTE_ATTRINDX(MT_NORMAL_NC) | PTE_PXN) or is it too weak? > The second, more serious problem, is that I can't find any place where > the caches are flushed for the page mapped on fault. When a page is > allocated, assuming GFP_ZERO, only the caches are guaranteed to be > zeroed. Exposing this subsequently to user space as uncached would allow > the user to read stale data prior to zeroing. The arm64 > set_direct_map_default_noflush() doesn't do any cache maintenance. Well, the idea of uncached mappings came from Elena [1] to prevent possibility of side channels that leak user space memory. So I think even without cache flushing after the allocation, user space is protected as all its memory accesses bypass cache so even after the page is freed there won't be stale data in the cache. I think that it makes sense to limit SECRETMEM_UNCACHED only for architectures that define an appropriate protection, e.g. pgprot_uncahced(). For x86 it can be aliased to pgprot_noncached() and other architecures can define their versions. [1] https://lore.kernel.org/lkml/2236FBA76BA1254E88B949DDB74E612BA4EEC0CE@IRSMSX102.ger.corp.intel.com/
On Thu, Jul 30, 2020 at 11:44:09PM +0300, Mike Rapoport wrote: > On Thu, Jul 30, 2020 at 05:22:10PM +0100, Catalin Marinas wrote: > > On Mon, Jul 27, 2020 at 07:29:31PM +0300, Mike Rapoport wrote: > > > For instance, the following example will create an uncached mapping (error > > > handling is omitted): > > > > > > fd = memfd_secret(SECRETMEM_UNCACHED); > > > ftruncate(fd, MAP_SIZE); > > > ptr = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); [...] > > > +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) > > > +{ > > > + struct secretmem_ctx *ctx = file->private_data; > > > + unsigned long mode = ctx->mode; > > > + unsigned long len = vma->vm_end - vma->vm_start; > > > + > > > + if (!mode) > > > + return -EINVAL; > > > + > > > + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) > > > + return -EINVAL; > > > + > > > + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) > > > + return -EAGAIN; > > > + > > > + switch (mode) { > > > + case SECRETMEM_UNCACHED: > > > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > > > + fallthrough; > > > + case SECRETMEM_EXCLUSIVE: > > > + vma->vm_ops = &secretmem_vm_ops; > > > + break; > > > + default: > > > + return -EINVAL; > > > + } > > > + > > > + vma->vm_flags |= VM_LOCKED; > > > + > > > + return 0; > > > +} > > > > I think the uncached mapping is not the right thing for arm/arm64. First > > of all, pgprot_noncached() gives us Strongly Ordered (Device memory) > > semantics together with not allowing unaligned accesses. I suspect the > > semantics are different on x86. > > Hmm, on x86 it's also Strongly Ordered, but I didn't find any alignment > restrictions. Is there a mode for arm64 that can provide similar > semantics? > > Would it make sence to use something like > > #define pgprot_uncached(prot) \ > __pgprot_modify(prot, PTE_ATTRINDX_MASK, \ > PTE_ATTRINDX(MT_NORMAL_NC) | PTE_PXN) > > or is it too weak? Reading Elena's email, that's about preventing speculative loads. While the arm64 Normal NC is non-cacheable (equivalent to write-combine), a CPU is allowed to speculatively read from it. A carefully crafted gadget could leave an imprint on a different part of the cache via speculative execution based on a value in the secret memory. So IIUC, we want memory that cannot be speculatively loaded from and that would be Device memory on arm64 (with the alignment restrictions). Now, I think we could relax this to Device_GRE. So maybe add a pgprot_nospec() and allow architectures to define whatever they find suitable. The exact semantics will be different between architectures. > > The second, more serious problem, is that I can't find any place where > > the caches are flushed for the page mapped on fault. When a page is > > allocated, assuming GFP_ZERO, only the caches are guaranteed to be > > zeroed. Exposing this subsequently to user space as uncached would allow > > the user to read stale data prior to zeroing. The arm64 > > set_direct_map_default_noflush() doesn't do any cache maintenance. > > Well, the idea of uncached mappings came from Elena [1] to prevent > possibility of side channels that leak user space memory. So I think > even without cache flushing after the allocation, user space is > protected as all its memory accesses bypass cache so even after the page > is freed there won't be stale data in the cache. > > I think that it makes sense to limit SECRETMEM_UNCACHED only for > architectures that define an appropriate protection, e.g. > pgprot_uncahced(). For x86 it can be aliased to pgprot_noncached() and > other architecures can define their versions. Indeed, though as I said above, maybe use a name that suggests no speculation since non-cacheable doesn't always guarantee that. Something like pgprot_nospec() and SECRETMEM_NOSPEC. However, your implementation still has the problem that such memory must have the caches flushed before being mapped in user-space, otherwise we leak other secrets via such pages to the caller. The only generic API we have in the kernel for such things is the DMA one. If hch doesn't mind, you could abuse it and call arch_dma_prep_coherent() prior to set_direct_map_invalid_noflush() (if the mapping is non-cacheable).
On Thu, Jul 30, 2020 at 05:22:10PM +0100, Catalin Marinas wrote: > On Mon, Jul 27, 2020 at 07:29:31PM +0300, Mike Rapoport wrote: > > +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) > > +{ > > + struct secretmem_ctx *ctx = file->private_data; > > + unsigned long mode = ctx->mode; > > + unsigned long len = vma->vm_end - vma->vm_start; > > + > > + if (!mode) > > + return -EINVAL; > > + > > + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) > > + return -EINVAL; > > + > > + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) > > + return -EAGAIN; > > + > > + switch (mode) { > > + case SECRETMEM_UNCACHED: > > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > > + fallthrough; > > + case SECRETMEM_EXCLUSIVE: > > + vma->vm_ops = &secretmem_vm_ops; > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + vma->vm_flags |= VM_LOCKED; > > + > > + return 0; > > +} > > I think the uncached mapping is not the right thing for arm/arm64. First > of all, pgprot_noncached() gives us Strongly Ordered (Device memory) > semantics together with not allowing unaligned accesses. I suspect the > semantics are different on x86. > The second, more serious problem, is that I can't find any place where > the caches are flushed for the page mapped on fault. When a page is > allocated, assuming GFP_ZERO, only the caches are guaranteed to be > zeroed. Exposing this subsequently to user space as uncached would allow > the user to read stale data prior to zeroing. The arm64 > set_direct_map_default_noflush() doesn't do any cache maintenance. It's also worth noting that in a virtual machine this is liable to be either broken (with a potential loss of coherency if the host has a cacheable alias as existing KVM hosts have), or pointless (if the host uses S2FWB to upgrade Stage-1 attribues to cacheable as existing KVM hosts also have). I think that trying to avoid the data caches creates many more problems than it solves, and I don't think there's a strong justification for trying to support that on arm64 to begin with, so I'd rather entirely opt-out on supporting SECRETMEM_UNCACHED. Thanks, Mark.
On Fri, Jul 31, 2020 at 03:29:05PM +0100, Mark Rutland wrote: > On Thu, Jul 30, 2020 at 05:22:10PM +0100, Catalin Marinas wrote: > > On Mon, Jul 27, 2020 at 07:29:31PM +0300, Mike Rapoport wrote: > > > +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) > > > +{ > > > + struct secretmem_ctx *ctx = file->private_data; > > > + unsigned long mode = ctx->mode; > > > + unsigned long len = vma->vm_end - vma->vm_start; > > > + > > > + if (!mode) > > > + return -EINVAL; > > > + > > > + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) > > > + return -EINVAL; > > > + > > > + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) > > > + return -EAGAIN; > > > + > > > + switch (mode) { > > > + case SECRETMEM_UNCACHED: > > > + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); > > > + fallthrough; > > > + case SECRETMEM_EXCLUSIVE: > > > + vma->vm_ops = &secretmem_vm_ops; > > > + break; > > > + default: > > > + return -EINVAL; > > > + } > > > + > > > + vma->vm_flags |= VM_LOCKED; > > > + > > > + return 0; > > > +} > > > > I think the uncached mapping is not the right thing for arm/arm64. First > > of all, pgprot_noncached() gives us Strongly Ordered (Device memory) > > semantics together with not allowing unaligned accesses. I suspect the > > semantics are different on x86. > > > The second, more serious problem, is that I can't find any place where > > the caches are flushed for the page mapped on fault. When a page is > > allocated, assuming GFP_ZERO, only the caches are guaranteed to be > > zeroed. Exposing this subsequently to user space as uncached would allow > > the user to read stale data prior to zeroing. The arm64 > > set_direct_map_default_noflush() doesn't do any cache maintenance. > > It's also worth noting that in a virtual machine this is liable to be > either broken (with a potential loss of coherency if the host has a > cacheable alias as existing KVM hosts have), or pointless (if the host > uses S2FWB to upgrade Stage-1 attribues to cacheable as existing KVM > hosts also have). > > I think that trying to avoid the data caches creates many more problems > than it solves, and I don't think there's a strong justification for > trying to support that on arm64 to begin with, so I'd rather entirely > opt-out on supporting SECRETMEM_UNCACHED. Good point, I forgot the virtualisation aspect. So unless there is a hypervisor API to unmap it from the host memory, the uncached option isn't of much use on arm64.
diff --git a/include/uapi/linux/magic.h b/include/uapi/linux/magic.h index f3956fc11de6..35687dcb1a42 100644 --- a/include/uapi/linux/magic.h +++ b/include/uapi/linux/magic.h @@ -97,5 +97,6 @@ #define DEVMEM_MAGIC 0x454d444d /* "DMEM" */ #define Z3FOLD_MAGIC 0x33 #define PPC_CMM_MAGIC 0xc7571590 +#define SECRETMEM_MAGIC 0x5345434d /* "SECM" */ #endif /* __LINUX_MAGIC_H__ */ diff --git a/include/uapi/linux/secretmem.h b/include/uapi/linux/secretmem.h new file mode 100644 index 000000000000..cef7a59f7492 --- /dev/null +++ b/include/uapi/linux/secretmem.h @@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef _UAPI_LINUX_SECRERTMEM_H +#define _UAPI_LINUX_SECRERTMEM_H + +/* secretmem operation modes */ +#define SECRETMEM_EXCLUSIVE 0x1 +#define SECRETMEM_UNCACHED 0x2 + +#endif /* _UAPI_LINUX_SECRERTMEM_H */ diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 3b69a560a7ac..fd40e1c083e5 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -349,6 +349,8 @@ COND_SYSCALL(pkey_mprotect); COND_SYSCALL(pkey_alloc); COND_SYSCALL(pkey_free); +/* memfd_secret */ +COND_SYSCALL(memfd_secret); /* * Architecture specific weak syscall entries. diff --git a/mm/Kconfig b/mm/Kconfig index f2104cc0d35c..8378175e72a4 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -872,4 +872,8 @@ config ARCH_HAS_HUGEPD config MAPPING_DIRTY_HELPERS bool +config SECRETMEM + def_bool ARCH_HAS_SET_DIRECT_MAP && !EMBEDDED + select GENERIC_ALLOCATOR + endmenu diff --git a/mm/Makefile b/mm/Makefile index 6e9d46b2efc9..c2aa7a393b73 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -121,3 +121,4 @@ obj-$(CONFIG_MEMFD_CREATE) += memfd.o obj-$(CONFIG_MAPPING_DIRTY_HELPERS) += mapping_dirty_helpers.o obj-$(CONFIG_PTDUMP_CORE) += ptdump.o obj-$(CONFIG_PAGE_REPORTING) += page_reporting.o +obj-$(CONFIG_SECRETMEM) += secretmem.o diff --git a/mm/secretmem.c b/mm/secretmem.c new file mode 100644 index 000000000000..9d29f3e1c49d --- /dev/null +++ b/mm/secretmem.c @@ -0,0 +1,266 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/mm.h> +#include <linux/fs.h> +#include <linux/mount.h> +#include <linux/memfd.h> +#include <linux/bitops.h> +#include <linux/printk.h> +#include <linux/pagemap.h> +#include <linux/syscalls.h> +#include <linux/pseudo_fs.h> +#include <linux/set_memory.h> +#include <linux/sched/signal.h> + +#include <uapi/linux/secretmem.h> +#include <uapi/linux/magic.h> + +#include <asm/tlbflush.h> + +#include "internal.h" + +#undef pr_fmt +#define pr_fmt(fmt) "secretmem: " fmt + +#define SECRETMEM_MODE_MASK (SECRETMEM_EXCLUSIVE | SECRETMEM_UNCACHED) +#define SECRETMEM_FLAGS_MASK SECRETMEM_MODE_MASK + +struct secretmem_ctx { + unsigned int mode; +}; + +static struct page *secretmem_alloc_page(gfp_t gfp) +{ + /* + * FIXME: use a cache of large pages to reduce the direct map + * fragmentation + */ + return alloc_page(gfp); +} + +static vm_fault_t secretmem_fault(struct vm_fault *vmf) +{ + struct address_space *mapping = vmf->vma->vm_file->f_mapping; + struct inode *inode = file_inode(vmf->vma->vm_file); + pgoff_t offset = vmf->pgoff; + unsigned long addr; + struct page *page; + int ret = 0; + + if (((loff_t)vmf->pgoff << PAGE_SHIFT) >= i_size_read(inode)) + return vmf_error(-EINVAL); + + page = find_get_entry(mapping, offset); + if (!page) { + page = secretmem_alloc_page(vmf->gfp_mask); + if (!page) + return vmf_error(-ENOMEM); + + ret = add_to_page_cache(page, mapping, offset, vmf->gfp_mask); + if (unlikely(ret)) + goto err_put_page; + + ret = set_direct_map_invalid_noflush(page); + if (ret) + goto err_del_page_cache; + + addr = (unsigned long)page_address(page); + flush_tlb_kernel_range(addr, addr + PAGE_SIZE); + + __SetPageUptodate(page); + + ret = VM_FAULT_LOCKED; + } + + vmf->page = page; + return ret; + +err_del_page_cache: + delete_from_page_cache(page); +err_put_page: + put_page(page); + return vmf_error(ret); +} + +static const struct vm_operations_struct secretmem_vm_ops = { + .fault = secretmem_fault, +}; + +static int secretmem_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct secretmem_ctx *ctx = file->private_data; + unsigned long mode = ctx->mode; + unsigned long len = vma->vm_end - vma->vm_start; + + if (!mode) + return -EINVAL; + + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) + return -EINVAL; + + if (mlock_future_check(vma->vm_mm, vma->vm_flags | VM_LOCKED, len)) + return -EAGAIN; + + switch (mode) { + case SECRETMEM_UNCACHED: + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); + fallthrough; + case SECRETMEM_EXCLUSIVE: + vma->vm_ops = &secretmem_vm_ops; + break; + default: + return -EINVAL; + } + + vma->vm_flags |= VM_LOCKED; + + return 0; +} + +const struct file_operations secretmem_fops = { + .mmap = secretmem_mmap, +}; + +static bool secretmem_isolate_page(struct page *page, isolate_mode_t mode) +{ + return false; +} + +static int secretmem_migratepage(struct address_space *mapping, + struct page *newpage, struct page *page, + enum migrate_mode mode) +{ + return -EBUSY; +} + +static void secretmem_freepage(struct page *page) +{ + set_direct_map_default_noflush(page); +} + +static const struct address_space_operations secretmem_aops = { + .freepage = secretmem_freepage, + .migratepage = secretmem_migratepage, + .isolate_page = secretmem_isolate_page, +}; + +static struct vfsmount *secretmem_mnt; + +static struct file *secretmem_file_create(unsigned long flags) +{ + struct file *file = ERR_PTR(-ENOMEM); + struct secretmem_ctx *ctx; + struct inode *inode; + + inode = alloc_anon_inode(secretmem_mnt->mnt_sb); + if (IS_ERR(inode)) + return ERR_CAST(inode); + + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + goto err_free_inode; + + file = alloc_file_pseudo(inode, secretmem_mnt, "secretmem", + O_RDWR, &secretmem_fops); + if (IS_ERR(file)) + goto err_free_ctx; + + mapping_set_unevictable(inode->i_mapping); + + inode->i_mapping->private_data = ctx; + inode->i_mapping->a_ops = &secretmem_aops; + + /* pretend we are a normal file with zero size */ + inode->i_mode |= S_IFREG; + inode->i_size = 0; + + file->private_data = ctx; + + ctx->mode = flags & SECRETMEM_MODE_MASK; + + return file; + +err_free_ctx: + kfree(ctx); +err_free_inode: + iput(inode); + return file; +} + +SYSCALL_DEFINE1(memfd_secret, unsigned long, flags) +{ + struct file *file; + unsigned int mode; + int fd, err; + + /* make sure local flags do not confict with global fcntl.h */ + BUILD_BUG_ON(SECRETMEM_FLAGS_MASK & O_CLOEXEC); + + if (flags & ~(SECRETMEM_FLAGS_MASK | O_CLOEXEC)) + return -EINVAL; + + /* modes are mutually exclusive, only one mode bit should be set */ + mode = flags & SECRETMEM_FLAGS_MASK; + if (ffs(mode) != fls(mode)) + return -EINVAL; + + fd = get_unused_fd_flags(flags & O_CLOEXEC); + if (fd < 0) + return fd; + + file = secretmem_file_create(flags); + if (IS_ERR(file)) { + err = PTR_ERR(file); + goto err_put_fd; + } + + file->f_flags |= O_LARGEFILE; + + fd_install(fd, file); + return fd; + +err_put_fd: + put_unused_fd(fd); + return err; +} + +static void secretmem_evict_inode(struct inode *inode) +{ + struct secretmem_ctx *ctx = inode->i_private; + + truncate_inode_pages_final(&inode->i_data); + clear_inode(inode); + kfree(ctx); +} + +static const struct super_operations secretmem_super_ops = { + .evict_inode = secretmem_evict_inode, +}; + +static int secretmem_init_fs_context(struct fs_context *fc) +{ + struct pseudo_fs_context *ctx = init_pseudo(fc, SECRETMEM_MAGIC); + + if (!ctx) + return -ENOMEM; + ctx->ops = &secretmem_super_ops; + + return 0; +} + +static struct file_system_type secretmem_fs = { + .name = "secretmem", + .init_fs_context = secretmem_init_fs_context, + .kill_sb = kill_anon_super, +}; + +static int secretmem_init(void) +{ + int ret = 0; + + secretmem_mnt = kern_mount(&secretmem_fs); + if (IS_ERR(secretmem_mnt)) + ret = PTR_ERR(secretmem_mnt); + + return ret; +} +fs_initcall(secretmem_init);