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/cputype.h>
  13 #include <asm/system.h>
  14
  15 #define COLOUR_ALIGN(addr,pgoff)                \
  16         ((((addr)+SHMLBA-1)&~(SHMLBA-1)) +      \
  17          (((pgoff)<<PAGE_SHIFT) & (SHMLBA-1)))
  18
  19 /*
  20  * We need to ensure that shared mappings are correctly aligned to
  21  * avoid aliasing issues with VIPT caches.  We need to ensure that
  22  * a specific page of an object is always mapped at a multiple of
  23  * SHMLBA bytes.
  24  *
  25  * We unconditionally provide this function for all cases, however
  26  * in the VIVT case, we optimise out the alignment rules.
  27  */
  28 unsigned long
  29 arch_get_unmapped_area(struct file *filp, unsigned long addr,
  30                 unsigned long len, unsigned long pgoff, unsigned long flags)
  31 {
  32         struct mm_struct *mm = current->mm;
  33         struct vm_area_struct *vma;
  34         unsigned long start_addr;
  35 #if defined(CONFIG_CPU_V6) || defined(CONFIG_CPU_V6K)
  36         unsigned int cache_type;
  37         int do_align = 0, aliasing = 0;
  38
  39         /*
  40          * We only need to do colour alignment if either the I or D
  41          * caches alias.  This is indicated by bits 9 and 21 of the
  42          * cache type register.
  43          */
  44         cache_type = read_cpuid_cachetype();
  45         if (cache_type != read_cpuid_id()) {
  46                 aliasing = (cache_type | cache_type >> 12) & (1 << 11);
  47                 if (aliasing)
  48                         do_align = filp || flags & MAP_SHARED;
  49         }
  50 #else
  51 #define do_align 0
  52 #define aliasing 0
  53 #endif
  54
  55         /*
  56          * We enforce the MAP_FIXED case.
  57          */
  58         if (flags & MAP_FIXED) {
  59                 if (aliasing && flags & MAP_SHARED &&
  60                     (addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1))
  61                         return -EINVAL;
  62                 return addr;
  63         }
  64
  65         if (len > TASK_SIZE)
  66                 return -ENOMEM;
  67
  68         if (addr) {
  69                 if (do_align)
  70                         addr = COLOUR_ALIGN(addr, pgoff);
  71                 else
  72                         addr = PAGE_ALIGN(addr);
  73
  74                 vma = find_vma(mm, addr);
  75                 if (TASK_SIZE - len >= addr &&
  76                     (!vma || addr + len <= vma->vm_start))
  77                         return addr;
  78         }
  79         if (len > mm->cached_hole_size) {
  80                 start_addr = addr = mm->free_area_cache;
  81         } else {
  82                 start_addr = addr = TASK_UNMAPPED_BASE;
  83                 mm->cached_hole_size = 0;
  84         }
  85         /* 8 bits of randomness in 20 address space bits */
  86         if ((current->flags & PF_RANDOMIZE) &&
  87             !(current->personality & ADDR_NO_RANDOMIZE))
  88                 addr += (get_random_int() % (1 << 8)) << PAGE_SHIFT;
  89
  90 full_search:
  91         if (do_align)
  92                 addr = COLOUR_ALIGN(addr, pgoff);
  93         else
  94                 addr = PAGE_ALIGN(addr);
  95
  96         for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
  97                 /* At this point:  (!vma || addr < vma->vm_end). */
  98                 if (TASK_SIZE - len < addr) {
  99                         /*
 100                          * Start a new search - just in case we missed
 101                          * some holes.
 102                          */
 103                         if (start_addr != TASK_UNMAPPED_BASE) {
 104                                 start_addr = addr = TASK_UNMAPPED_BASE;
 105                                 mm->cached_hole_size = 0;
 106                                 goto full_search;
 107                         }
 108                         return -ENOMEM;
 109                 }
 110                 if (!vma || addr + len <= vma->vm_start) {
 111                         /*
 112                          * Remember the place where we stopped the search:
 113                          */
 114                         mm->free_area_cache = addr + len;
 115                         return addr;
 116                 }
 117                 if (addr + mm->cached_hole_size < vma->vm_start)
 118                         mm->cached_hole_size = vma->vm_start - addr;
 119                 addr = vma->vm_end;
 120                 if (do_align)
 121                         addr = COLOUR_ALIGN(addr, pgoff);
 122         }
 123 }
 124
 125
 126 /*
 127  * You really shouldn't be using read() or write() on /dev/mem.  This
 128  * might go away in the future.
 129  */
 130 int valid_phys_addr_range(unsigned long addr, size_t size)
 131 {
 132         if (addr < PHYS_OFFSET)
 133                 return 0;
 134         if (addr + size > __pa(high_memory - 1) + 1)
 135                 return 0;
 136
 137         return 1;
 138 }
 139
 140 /*
 141  * We don't use supersection mappings for mmap() on /dev/mem, which
 142  * means that we can't map the memory area above the 4G barrier into
 143  * userspace.
 144  */
 145 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
 146 {
 147         return !(pfn + (size >> PAGE_SHIFT) > 0x00100000);
 148 }
 149
 150 #ifdef CONFIG_STRICT_DEVMEM
 151
 152 #include <linux/ioport.h>
 153
 154 /*
 155  * devmem_is_allowed() checks to see if /dev/mem access to a certain
 156  * address is valid. The argument is a physical page number.
 157  * We mimic x86 here by disallowing access to system RAM as well as
 158  * device-exclusive MMIO regions. This effectively disable read()/write()
 159  * on /dev/mem.
 160  */
 161 int devmem_is_allowed(unsigned long pfn)
 162 {
 163         if (iomem_is_exclusive(pfn << PAGE_SHIFT))
 164                 return 0;
 165         if (!page_is_ram(pfn))
 166                 return 1;
 167         return 0;
 168 }
 169
 170 #endif