io_uring: Adjust mapping wrt architecture aliasing requirements

Some architectures have memory cache aliasing requirements (e.g. parisc)
if memory is shared between userspace and kernel. This patch fixes the
kernel to return an aliased address when asked by userspace via mmap().

Signed-off-by: Helge Deller <deller@gmx.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c
index 1ed96caa586a81dc47cc79d52615b2986a4038d6..b49b7ee12d60063648fb482547ea6c072e78cc05 100644 (file)
--- a/io_uring/io_uring.c
+++ b/io_uring/io_uring.c
@@ -72,6 +72,7 @@
 #include <linux/io_uring.h>
 #include <linux/audit.h>
 #include <linux/security.h>
+#include <asm/shmparam.h>
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/io_uring.h>
@@ -3323,6 +3324,54 @@ static __cold int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
        return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);
 }
 
+static unsigned long io_uring_mmu_get_unmapped_area(struct file *filp,
+                       unsigned long addr, unsigned long len,
+                       unsigned long pgoff, unsigned long flags)
+{
+       const unsigned long mmap_end = arch_get_mmap_end(addr, len, flags);
+       struct vm_unmapped_area_info info;
+       void *ptr;
+
+       /*
+        * Do not allow to map to user-provided address to avoid breaking the
+        * aliasing rules. Userspace is not able to guess the offset address of
+        * kernel kmalloc()ed memory area.
+        */
+       if (addr)
+               return -EINVAL;
+
+       ptr = io_uring_validate_mmap_request(filp, pgoff, len);
+       if (IS_ERR(ptr))
+               return -ENOMEM;
+
+       info.flags = VM_UNMAPPED_AREA_TOPDOWN;
+       info.length = len;
+       info.low_limit = max(PAGE_SIZE, mmap_min_addr);
+       info.high_limit = arch_get_mmap_base(addr, current->mm->mmap_base);
+#ifdef SHM_COLOUR
+       info.align_mask = PAGE_MASK & (SHM_COLOUR - 1UL);
+#else
+       info.align_mask = PAGE_MASK & (SHMLBA - 1UL);
+#endif
+       info.align_offset = (unsigned long) ptr;
+
+       /*
+        * A failed mmap() very likely causes application failure,
+        * so fall back to the bottom-up function here. This scenario
+        * can happen with large stack limits and large mmap()
+        * allocations.
+        */
+       addr = vm_unmapped_area(&info);
+       if (offset_in_page(addr)) {
+               info.flags = 0;
+               info.low_limit = TASK_UNMAPPED_BASE;
+               info.high_limit = mmap_end;
+               addr = vm_unmapped_area(&info);
+       }
+
+       return addr;
+}
+
 #else /* !CONFIG_MMU */
 
 static int io_uring_mmap(struct file *file, struct vm_area_struct *vma)
@@ -3535,6 +3584,8 @@ static const struct file_operations io_uring_fops = {
 #ifndef CONFIG_MMU
        .get_unmapped_area = io_uring_nommu_get_unmapped_area,
        .mmap_capabilities = io_uring_nommu_mmap_capabilities,
+#else
+       .get_unmapped_area = io_uring_mmu_get_unmapped_area,
 #endif
        .poll           = io_uring_poll,
 #ifdef CONFIG_PROC_FS