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