]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - arch/sh/mm/mmap.c
80bf494ddbcb4c86c1852d82fadfb973de89b435
[~shefty/rdma-dev.git] / arch / sh / mm / mmap.c
1 /*
2  * arch/sh/mm/mmap.c
3  *
4  * Copyright (C) 2008 - 2009  Paul Mundt
5  *
6  * This file is subject to the terms and conditions of the GNU General Public
7  * License.  See the file "COPYING" in the main directory of this archive
8  * for more details.
9  */
10 #include <linux/io.h>
11 #include <linux/mm.h>
12 #include <linux/mman.h>
13 #include <linux/module.h>
14 #include <asm/page.h>
15 #include <asm/processor.h>
16
17 unsigned long shm_align_mask = PAGE_SIZE - 1;   /* Sane caches */
18 EXPORT_SYMBOL(shm_align_mask);
19
20 #ifdef CONFIG_MMU
21 /*
22  * To avoid cache aliases, we map the shared page with same color.
23  */
24 static inline unsigned long COLOUR_ALIGN(unsigned long addr,
25                                          unsigned long pgoff)
26 {
27         unsigned long base = (addr + shm_align_mask) & ~shm_align_mask;
28         unsigned long off = (pgoff << PAGE_SHIFT) & shm_align_mask;
29
30         return base + off;
31 }
32
33 static inline unsigned long COLOUR_ALIGN_DOWN(unsigned long addr,
34                                               unsigned long pgoff)
35 {
36         unsigned long base = addr & ~shm_align_mask;
37         unsigned long off = (pgoff << PAGE_SHIFT) & shm_align_mask;
38
39         if (base + off <= addr)
40                 return base + off;
41
42         return base - off;
43 }
44
45 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
46         unsigned long len, unsigned long pgoff, unsigned long flags)
47 {
48         struct mm_struct *mm = current->mm;
49         struct vm_area_struct *vma;
50         unsigned long start_addr;
51         int do_colour_align;
52
53         if (flags & MAP_FIXED) {
54                 /* We do not accept a shared mapping if it would violate
55                  * cache aliasing constraints.
56                  */
57                 if ((flags & MAP_SHARED) &&
58                     ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
59                         return -EINVAL;
60                 return addr;
61         }
62
63         if (unlikely(len > TASK_SIZE))
64                 return -ENOMEM;
65
66         do_colour_align = 0;
67         if (filp || (flags & MAP_SHARED))
68                 do_colour_align = 1;
69
70         if (addr) {
71                 if (do_colour_align)
72                         addr = COLOUR_ALIGN(addr, pgoff);
73                 else
74                         addr = PAGE_ALIGN(addr);
75
76                 vma = find_vma(mm, addr);
77                 if (TASK_SIZE - len >= addr &&
78                     (!vma || addr + len <= vma->vm_start))
79                         return addr;
80         }
81
82         if (len > mm->cached_hole_size) {
83                 start_addr = addr = mm->free_area_cache;
84         } else {
85                 mm->cached_hole_size = 0;
86                 start_addr = addr = TASK_UNMAPPED_BASE;
87         }
88
89 full_search:
90         if (do_colour_align)
91                 addr = COLOUR_ALIGN(addr, pgoff);
92         else
93                 addr = PAGE_ALIGN(mm->free_area_cache);
94
95         for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
96                 /* At this point:  (!vma || addr < vma->vm_end). */
97                 if (unlikely(TASK_SIZE - len < addr)) {
98                         /*
99                          * Start a new search - just in case we missed
100                          * some holes.
101                          */
102                         if (start_addr != TASK_UNMAPPED_BASE) {
103                                 start_addr = addr = TASK_UNMAPPED_BASE;
104                                 mm->cached_hole_size = 0;
105                                 goto full_search;
106                         }
107                         return -ENOMEM;
108                 }
109                 if (likely(!vma || addr + len <= vma->vm_start)) {
110                         /*
111                          * Remember the place where we stopped the search:
112                          */
113                         mm->free_area_cache = addr + len;
114                         return addr;
115                 }
116                 if (addr + mm->cached_hole_size < vma->vm_start)
117                         mm->cached_hole_size = vma->vm_start - addr;
118
119                 addr = vma->vm_end;
120                 if (do_colour_align)
121                         addr = COLOUR_ALIGN(addr, pgoff);
122         }
123 }
124
125 unsigned long
126 arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
127                           const unsigned long len, const unsigned long pgoff,
128                           const unsigned long flags)
129 {
130         struct vm_area_struct *vma;
131         struct mm_struct *mm = current->mm;
132         unsigned long addr = addr0;
133         int do_colour_align;
134
135         if (flags & MAP_FIXED) {
136                 /* We do not accept a shared mapping if it would violate
137                  * cache aliasing constraints.
138                  */
139                 if ((flags & MAP_SHARED) &&
140                     ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
141                         return -EINVAL;
142                 return addr;
143         }
144
145         if (unlikely(len > TASK_SIZE))
146                 return -ENOMEM;
147
148         do_colour_align = 0;
149         if (filp || (flags & MAP_SHARED))
150                 do_colour_align = 1;
151
152         /* requesting a specific address */
153         if (addr) {
154                 if (do_colour_align)
155                         addr = COLOUR_ALIGN(addr, pgoff);
156                 else
157                         addr = PAGE_ALIGN(addr);
158
159                 vma = find_vma(mm, addr);
160                 if (TASK_SIZE - len >= addr &&
161                     (!vma || addr + len <= vma->vm_start))
162                         return addr;
163         }
164
165         /* check if free_area_cache is useful for us */
166         if (len <= mm->cached_hole_size) {
167                 mm->cached_hole_size = 0;
168                 mm->free_area_cache = mm->mmap_base;
169         }
170
171         /* either no address requested or can't fit in requested address hole */
172         addr = mm->free_area_cache;
173         if (do_colour_align) {
174                 unsigned long base = COLOUR_ALIGN_DOWN(addr-len, pgoff);
175
176                 addr = base + len;
177         }
178
179         /* make sure it can fit in the remaining address space */
180         if (likely(addr > len)) {
181                 vma = find_vma(mm, addr-len);
182                 if (!vma || addr <= vma->vm_start) {
183                         /* remember the address as a hint for next time */
184                         return (mm->free_area_cache = addr-len);
185                 }
186         }
187
188         if (unlikely(mm->mmap_base < len))
189                 goto bottomup;
190
191         addr = mm->mmap_base-len;
192         if (do_colour_align)
193                 addr = COLOUR_ALIGN_DOWN(addr, pgoff);
194
195         do {
196                 /*
197                  * Lookup failure means no vma is above this address,
198                  * else if new region fits below vma->vm_start,
199                  * return with success:
200                  */
201                 vma = find_vma(mm, addr);
202                 if (likely(!vma || addr+len <= vma->vm_start)) {
203                         /* remember the address as a hint for next time */
204                         return (mm->free_area_cache = addr);
205                 }
206
207                 /* remember the largest hole we saw so far */
208                 if (addr + mm->cached_hole_size < vma->vm_start)
209                         mm->cached_hole_size = vma->vm_start - addr;
210
211                 /* try just below the current vma->vm_start */
212                 addr = vma->vm_start-len;
213                 if (do_colour_align)
214                         addr = COLOUR_ALIGN_DOWN(addr, pgoff);
215         } while (likely(len < vma->vm_start));
216
217 bottomup:
218         /*
219          * A failed mmap() very likely causes application failure,
220          * so fall back to the bottom-up function here. This scenario
221          * can happen with large stack limits and large mmap()
222          * allocations.
223          */
224         mm->cached_hole_size = ~0UL;
225         mm->free_area_cache = TASK_UNMAPPED_BASE;
226         addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
227         /*
228          * Restore the topdown base:
229          */
230         mm->free_area_cache = mm->mmap_base;
231         mm->cached_hole_size = ~0UL;
232
233         return addr;
234 }
235 #endif /* CONFIG_MMU */
236
237 /*
238  * You really shouldn't be using read() or write() on /dev/mem.  This
239  * might go away in the future.
240  */
241 int valid_phys_addr_range(phys_addr_t addr, size_t count)
242 {
243         if (addr < __MEMORY_START)
244                 return 0;
245         if (addr + count > __pa(high_memory))
246                 return 0;
247
248         return 1;
249 }
250
251 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
252 {
253         return 1;
254 }