arch/arm64/mm/mmap.c

   1 /*
   2  * Based on arch/arm/mm/mmap.c
   3  *
   4  * Copyright (C) 2012 ARM Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/elf.h>
  20 #include <linux/fs.h>
  21 #include <linux/memblock.h>
  22 #include <linux/mm.h>
  23 #include <linux/mman.h>
  24 #include <linux/export.h>
  25 #include <linux/shm.h>
  26 #include <linux/sched/signal.h>
  27 #include <linux/sched/mm.h>
  28 #include <linux/io.h>
  29 #include <linux/personality.h>
  30 #include <linux/random.h>
  31
  32 #include <asm/cputype.h>
  33
  34 /*
  35  * Leave enough space between the mmap area and the stack to honour ulimit in
  36  * the face of randomisation.
  37  */
  38 #define MIN_GAP (SZ_128M)
  39 #define MAX_GAP (STACK_TOP/6*5)
  40
  41 static int mmap_is_legacy(struct rlimit *rlim_stack)
  42 {
  43         if (current->personality & ADDR_COMPAT_LAYOUT)
  44                 return 1;
  45
  46         if (rlim_stack->rlim_cur == RLIM_INFINITY)
  47                 return 1;
  48
  49         return sysctl_legacy_va_layout;
  50 }
  51
  52 unsigned long arch_mmap_rnd(void)
  53 {
  54         unsigned long rnd;
  55
  56 #ifdef CONFIG_COMPAT
  57         if (test_thread_flag(TIF_32BIT))
  58                 rnd = get_random_long() & ((1UL << mmap_rnd_compat_bits) - 1);
  59         else
  60 #endif
  61                 rnd = get_random_long() & ((1UL << mmap_rnd_bits) - 1);
  62         return rnd << PAGE_SHIFT;
  63 }
  64
  65 static unsigned long mmap_base(unsigned long rnd, struct rlimit *rlim_stack)
  66 {
  67         unsigned long gap = rlim_stack->rlim_cur;
  68         unsigned long pad = stack_guard_gap;
  69
  70         /* Account for stack randomization if necessary */
  71         if (current->flags & PF_RANDOMIZE)
  72                 pad += (STACK_RND_MASK << PAGE_SHIFT);
  73
  74         /* Values close to RLIM_INFINITY can overflow. */
  75         if (gap + pad > gap)
  76                 gap += pad;
  77
  78         if (gap < MIN_GAP)
  79                 gap = MIN_GAP;
  80         else if (gap > MAX_GAP)
  81                 gap = MAX_GAP;
  82
  83         return PAGE_ALIGN(STACK_TOP - gap - rnd);
  84 }
  85
  86 /*
  87  * This function, called very early during the creation of a new process VM
  88  * image, sets up which VM layout function to use:
  89  */
  90 void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)
  91 {
  92         unsigned long random_factor = 0UL;
  93
  94         if (current->flags & PF_RANDOMIZE)
  95                 random_factor = arch_mmap_rnd();
  96
  97         /*
  98          * Fall back to the standard layout if the personality bit is set, or
  99          * if the expected stack growth is unlimited:
 100          */
 101         if (mmap_is_legacy(rlim_stack)) {
 102                 mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
 103                 mm->get_unmapped_area = arch_get_unmapped_area;
 104         } else {
 105                 mm->mmap_base = mmap_base(random_factor, rlim_stack);
 106                 mm->get_unmapped_area = arch_get_unmapped_area_topdown;
 107         }
 108 }
 109
 110 /*
 111  * You really shouldn't be using read() or write() on /dev/mem.  This might go
 112  * away in the future.
 113  */
 114 int valid_phys_addr_range(phys_addr_t addr, size_t size)
 115 {
 116         /*
 117          * Check whether addr is covered by a memory region without the
 118          * MEMBLOCK_NOMAP attribute, and whether that region covers the
 119          * entire range. In theory, this could lead to false negatives
 120          * if the range is covered by distinct but adjacent memory regions
 121          * that only differ in other attributes. However, few of such
 122          * attributes have been defined, and it is debatable whether it
 123          * follows that /dev/mem read() calls should be able traverse
 124          * such boundaries.
 125          */
 126         return memblock_is_region_memory(addr, size) &&
 127                memblock_is_map_memory(addr);
 128 }
 129
 130 /*
 131  * Do not allow /dev/mem mappings beyond the supported physical range.
 132  */
 133 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
 134 {
 135         return !(((pfn << PAGE_SHIFT) + size) & ~PHYS_MASK);
 136 }
 137
 138 #ifdef CONFIG_STRICT_DEVMEM
 139
 140 #include <linux/ioport.h>
 141
 142 /*
 143  * devmem_is_allowed() checks to see if /dev/mem access to a certain address
 144  * is valid. The argument is a physical page number.  We mimic x86 here by
 145  * disallowing access to system RAM as well as device-exclusive MMIO regions.
 146  * This effectively disable read()/write() on /dev/mem.
 147  */
 148 int devmem_is_allowed(unsigned long pfn)
 149 {
 150         if (iomem_is_exclusive(pfn << PAGE_SHIFT))
 151                 return 0;
 152         if (!page_is_ram(pfn))
 153                 return 1;
 154         return 0;
 155 }
 156
 157 #endif