arch/arm/mm/mmap.c

   1 /*
   2  *  linux/arch/arm/mm/mmap.c
   3  */
   4 #include <linux/fs.h>
   5 #include <linux/mm.h>
   6 #include <linux/mman.h>
   7 #include <linux/shm.h>
   8 #include <linux/sched.h>
   9 #include <linux/io.h>
  10 #include <linux/personality.h>
  11 #include <linux/random.h>
  12 #include <asm/cachetype.h>
  13
  14 #define COLOUR_ALIGN(addr,pgoff)                \
  15         ((((addr)+SHMLBA-1)&~(SHMLBA-1)) +      \
  16          (((pgoff)<<PAGE_SHIFT) & (SHMLBA-1)))
  17
  18 /* gap between mmap and stack */
  19 #define MIN_GAP (128*1024*1024UL)
  20 #define MAX_GAP ((TASK_SIZE)/6*5)
  21
  22 static int mmap_is_legacy(void)
  23 {
  24         if (current->personality & ADDR_COMPAT_LAYOUT)
  25                 return 1;
  26
  27         if (rlimit(RLIMIT_STACK) == RLIM_INFINITY)
  28                 return 1;
  29
  30         return sysctl_legacy_va_layout;
  31 }
  32
  33 static unsigned long mmap_base(unsigned long rnd)
  34 {
  35         unsigned long gap = rlimit(RLIMIT_STACK);
  36
  37         if (gap < MIN_GAP)
  38                 gap = MIN_GAP;
  39         else if (gap > MAX_GAP)
  40                 gap = MAX_GAP;
  41
  42         return PAGE_ALIGN(TASK_SIZE - gap - rnd);
  43 }
  44
  45 /*
  46  * We need to ensure that shared mappings are correctly aligned to
  47  * avoid aliasing issues with VIPT caches.  We need to ensure that
  48  * a specific page of an object is always mapped at a multiple of
  49  * SHMLBA bytes.
  50  *
  51  * We unconditionally provide this function for all cases, however
  52  * in the VIVT case, we optimise out the alignment rules.
  53  */
  54 unsigned long
  55 arch_get_unmapped_area(struct file *filp, unsigned long addr,
  56                 unsigned long len, unsigned long pgoff, unsigned long flags)
  57 {
  58         struct mm_struct *mm = current->mm;
  59         struct vm_area_struct *vma;
  60         int do_align = 0;
  61         int aliasing = cache_is_vipt_aliasing();
  62         struct vm_unmapped_area_info info;
  63
  64         /*
  65          * We only need to do colour alignment if either the I or D
  66          * caches alias.
  67          */
  68         if (aliasing)
  69                 do_align = filp || (flags & MAP_SHARED);
  70
  71         /*
  72          * We enforce the MAP_FIXED case.
  73          */
  74         if (flags & MAP_FIXED) {
  75                 if (aliasing && flags & MAP_SHARED &&
  76                     (addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1))
  77                         return -EINVAL;
  78                 return addr;
  79         }
  80
  81         if (len > TASK_SIZE)
  82                 return -ENOMEM;
  83
  84         if (addr) {
  85                 if (do_align)
  86                         addr = COLOUR_ALIGN(addr, pgoff);
  87                 else
  88                         addr = PAGE_ALIGN(addr);
  89
  90                 vma = find_vma(mm, addr);
  91                 if (TASK_SIZE - len >= addr &&
  92                     (!vma || addr + len <= vma->vm_start))
  93                         return addr;
  94         }
  95
  96         info.flags = 0;
  97         info.length = len;
  98         info.low_limit = mm->mmap_base;
  99         info.high_limit = TASK_SIZE;
 100         info.align_mask = do_align ? (PAGE_MASK & (SHMLBA - 1)) : 0;
 101         info.align_offset = pgoff << PAGE_SHIFT;
 102         return vm_unmapped_area(&info);
 103 }
 104
 105 unsigned long
 106 arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
 107                         const unsigned long len, const unsigned long pgoff,
 108                         const unsigned long flags)
 109 {
 110         struct vm_area_struct *vma;
 111         struct mm_struct *mm = current->mm;
 112         unsigned long addr = addr0;
 113         int do_align = 0;
 114         int aliasing = cache_is_vipt_aliasing();
 115         struct vm_unmapped_area_info info;
 116
 117         /*
 118          * We only need to do colour alignment if either the I or D
 119          * caches alias.
 120          */
 121         if (aliasing)
 122                 do_align = filp || (flags & MAP_SHARED);
 123
 124         /* requested length too big for entire address space */
 125         if (len > TASK_SIZE)
 126                 return -ENOMEM;
 127
 128         if (flags & MAP_FIXED) {
 129                 if (aliasing && flags & MAP_SHARED &&
 130                     (addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1))
 131                         return -EINVAL;
 132                 return addr;
 133         }
 134
 135         /* requesting a specific address */
 136         if (addr) {
 137                 if (do_align)
 138                         addr = COLOUR_ALIGN(addr, pgoff);
 139                 else
 140                         addr = PAGE_ALIGN(addr);
 141                 vma = find_vma(mm, addr);
 142                 if (TASK_SIZE - len >= addr &&
 143                                 (!vma || addr + len <= vma->vm_start))
 144                         return addr;
 145         }
 146
 147         info.flags = VM_UNMAPPED_AREA_TOPDOWN;
 148         info.length = len;
 149         info.low_limit = PAGE_SIZE;
 150         info.high_limit = mm->mmap_base;
 151         info.align_mask = do_align ? (PAGE_MASK & (SHMLBA - 1)) : 0;
 152         info.align_offset = pgoff << PAGE_SHIFT;
 153         addr = vm_unmapped_area(&info);
 154
 155         /*
 156          * A failed mmap() very likely causes application failure,
 157          * so fall back to the bottom-up function here. This scenario
 158          * can happen with large stack limits and large mmap()
 159          * allocations.
 160          */
 161         if (addr & ~PAGE_MASK) {
 162                 VM_BUG_ON(addr != -ENOMEM);
 163                 info.flags = 0;
 164                 info.low_limit = mm->mmap_base;
 165                 info.high_limit = TASK_SIZE;
 166                 addr = vm_unmapped_area(&info);
 167         }
 168
 169         return addr;
 170 }
 171
 172 void arch_pick_mmap_layout(struct mm_struct *mm)
 173 {
 174         unsigned long random_factor = 0UL;
 175
 176         /* 8 bits of randomness in 20 address space bits */
 177         if ((current->flags & PF_RANDOMIZE) &&
 178             !(current->personality & ADDR_NO_RANDOMIZE))
 179                 random_factor = (get_random_int() % (1 << 8)) << PAGE_SHIFT;
 180
 181         if (mmap_is_legacy()) {
 182                 mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
 183                 mm->get_unmapped_area = arch_get_unmapped_area;
 184                 mm->unmap_area = arch_unmap_area;
 185         } else {
 186                 mm->mmap_base = mmap_base(random_factor);
 187                 mm->get_unmapped_area = arch_get_unmapped_area_topdown;
 188                 mm->unmap_area = arch_unmap_area_topdown;
 189         }
 190 }
 191
 192 /*
 193  * You really shouldn't be using read() or write() on /dev/mem.  This
 194  * might go away in the future.
 195  */
 196 int valid_phys_addr_range(phys_addr_t addr, size_t size)
 197 {
 198         if (addr < PHYS_OFFSET)
 199                 return 0;
 200         if (addr + size > __pa(high_memory - 1) + 1)
 201                 return 0;
 202
 203         return 1;
 204 }
 205
 206 /*
 207  * We don't use supersection mappings for mmap() on /dev/mem, which
 208  * means that we can't map the memory area above the 4G barrier into
 209  * userspace.
 210  */
 211 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
 212 {
 213         return !(pfn + (size >> PAGE_SHIFT) > 0x00100000);
 214 }
 215
 216 #ifdef CONFIG_STRICT_DEVMEM
 217
 218 #include <linux/ioport.h>
 219
 220 /*
 221  * devmem_is_allowed() checks to see if /dev/mem access to a certain
 222  * address is valid. The argument is a physical page number.
 223  * We mimic x86 here by disallowing access to system RAM as well as
 224  * device-exclusive MMIO regions. This effectively disable read()/write()
 225  * on /dev/mem.
 226  */
 227 int devmem_is_allowed(unsigned long pfn)
 228 {
 229         if (iomem_is_exclusive(pfn << PAGE_SHIFT))
 230                 return 0;
 231         if (!page_is_ram(pfn))
 232                 return 1;
 233         return 0;
 234 }
 235
 236 #endif