~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/mm/nommu.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/mm/nommu.c
  3  *
  4  *  Replacement code for mm functions to support CPU's that don't
  5  *  have any form of memory management unit (thus no virtual memory).
  6  *
  7  *  See Documentation/nommu-mmap.txt
  8  *
  9  *  Copyright (c) 2004-2008 David Howells <dhowells@redhat.com>
 10  *  Copyright (c) 2000-2003 David McCullough <davidm@snapgear.com>
 11  *  Copyright (c) 2000-2001 D Jeff Dionne <jeff@uClinux.org>
 12  *  Copyright (c) 2002      Greg Ungerer <gerg@snapgear.com>
 13  *  Copyright (c) 2007-2010 Paul Mundt <lethal@linux-sh.org>
 14  */
 15 
 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 17 
 18 #include <linux/export.h>
 19 #include <linux/mm.h>
 20 #include <linux/vmacache.h>
 21 #include <linux/mman.h>
 22 #include <linux/swap.h>
 23 #include <linux/file.h>
 24 #include <linux/highmem.h>
 25 #include <linux/pagemap.h>
 26 #include <linux/slab.h>
 27 #include <linux/vmalloc.h>
 28 #include <linux/blkdev.h>
 29 #include <linux/backing-dev.h>
 30 #include <linux/compiler.h>
 31 #include <linux/mount.h>
 32 #include <linux/personality.h>
 33 #include <linux/security.h>
 34 #include <linux/syscalls.h>
 35 #include <linux/audit.h>
 36 #include <linux/sched/sysctl.h>
 37 #include <linux/printk.h>
 38 
 39 #include <asm/uaccess.h>
 40 #include <asm/tlb.h>
 41 #include <asm/tlbflush.h>
 42 #include <asm/mmu_context.h>
 43 #include "internal.h"
 44 
 45 #if 0
 46 #define kenter(FMT, ...) \
 47         printk(KERN_DEBUG "==> %s("FMT")\n", __func__, ##__VA_ARGS__)
 48 #define kleave(FMT, ...) \
 49         printk(KERN_DEBUG "<== %s()"FMT"\n", __func__, ##__VA_ARGS__)
 50 #define kdebug(FMT, ...) \
 51         printk(KERN_DEBUG "xxx" FMT"yyy\n", ##__VA_ARGS__)
 52 #else
 53 #define kenter(FMT, ...) \
 54         no_printk(KERN_DEBUG "==> %s("FMT")\n", __func__, ##__VA_ARGS__)
 55 #define kleave(FMT, ...) \
 56         no_printk(KERN_DEBUG "<== %s()"FMT"\n", __func__, ##__VA_ARGS__)
 57 #define kdebug(FMT, ...) \
 58         no_printk(KERN_DEBUG FMT"\n", ##__VA_ARGS__)
 59 #endif
 60 
 61 void *high_memory;
 62 struct page *mem_map;
 63 unsigned long max_mapnr;
 64 unsigned long highest_memmap_pfn;
 65 struct percpu_counter vm_committed_as;
 66 int sysctl_overcommit_memory = OVERCOMMIT_GUESS; /* heuristic overcommit */
 67 int sysctl_overcommit_ratio = 50; /* default is 50% */
 68 unsigned long sysctl_overcommit_kbytes __read_mostly;
 69 int sysctl_max_map_count = DEFAULT_MAX_MAP_COUNT;
 70 int sysctl_nr_trim_pages = CONFIG_NOMMU_INITIAL_TRIM_EXCESS;
 71 unsigned long sysctl_user_reserve_kbytes __read_mostly = 1UL << 17; /* 128MB */
 72 unsigned long sysctl_admin_reserve_kbytes __read_mostly = 1UL << 13; /* 8MB */
 73 int heap_stack_gap = 0;
 74 
 75 atomic_long_t mmap_pages_allocated;
 76 
 77 /*
 78  * The global memory commitment made in the system can be a metric
 79  * that can be used to drive ballooning decisions when Linux is hosted
 80  * as a guest. On Hyper-V, the host implements a policy engine for dynamically
 81  * balancing memory across competing virtual machines that are hosted.
 82  * Several metrics drive this policy engine including the guest reported
 83  * memory commitment.
 84  */
 85 unsigned long vm_memory_committed(void)
 86 {
 87         return percpu_counter_read_positive(&vm_committed_as);
 88 }
 89 
 90 EXPORT_SYMBOL_GPL(vm_memory_committed);
 91 
 92 EXPORT_SYMBOL(mem_map);
 93 
 94 /* list of mapped, potentially shareable regions */
 95 static struct kmem_cache *vm_region_jar;
 96 struct rb_root nommu_region_tree = RB_ROOT;
 97 DECLARE_RWSEM(nommu_region_sem);
 98 
 99 const struct vm_operations_struct generic_file_vm_ops = {
100 };
101 
102 /*
103  * Return the total memory allocated for this pointer, not
104  * just what the caller asked for.
105  *
106  * Doesn't have to be accurate, i.e. may have races.
107  */
108 unsigned int kobjsize(const void *objp)
109 {
110         struct page *page;
111 
112         /*
113          * If the object we have should not have ksize performed on it,
114          * return size of 0
115          */
116         if (!objp || !virt_addr_valid(objp))
117                 return 0;
118 
119         page = virt_to_head_page(objp);
120 
121         /*
122          * If the allocator sets PageSlab, we know the pointer came from
123          * kmalloc().
124          */
125         if (PageSlab(page))
126                 return ksize(objp);
127 
128         /*
129          * If it's not a compound page, see if we have a matching VMA
130          * region. This test is intentionally done in reverse order,
131          * so if there's no VMA, we still fall through and hand back
132          * PAGE_SIZE for 0-order pages.
133          */
134         if (!PageCompound(page)) {
135                 struct vm_area_struct *vma;
136 
137                 vma = find_vma(current->mm, (unsigned long)objp);
138                 if (vma)
139                         return vma->vm_end - vma->vm_start;
140         }
141 
142         /*
143          * The ksize() function is only guaranteed to work for pointers
144          * returned by kmalloc(). So handle arbitrary pointers here.
145          */
146         return PAGE_SIZE << compound_order(page);
147 }
148 
149 long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
150                       unsigned long start, unsigned long nr_pages,
151                       unsigned int foll_flags, struct page **pages,
152                       struct vm_area_struct **vmas, int *nonblocking)
153 {
154         struct vm_area_struct *vma;
155         unsigned long vm_flags;
156         int i;
157 
158         /* calculate required read or write permissions.
159          * If FOLL_FORCE is set, we only require the "MAY" flags.
160          */
161         vm_flags  = (foll_flags & FOLL_WRITE) ?
162                         (VM_WRITE | VM_MAYWRITE) : (VM_READ | VM_MAYREAD);
163         vm_flags &= (foll_flags & FOLL_FORCE) ?
164                         (VM_MAYREAD | VM_MAYWRITE) : (VM_READ | VM_WRITE);
165 
166         for (i = 0; i < nr_pages; i++) {
167                 vma = find_vma(mm, start);
168                 if (!vma)
169                         goto finish_or_fault;
170 
171                 /* protect what we can, including chardevs */
172                 if ((vma->vm_flags & (VM_IO | VM_PFNMAP)) ||
173                     !(vm_flags & vma->vm_flags))
174                         goto finish_or_fault;
175 
176                 if (pages) {
177                         pages[i] = virt_to_page(start);
178                         if (pages[i])
179                                 page_cache_get(pages[i]);
180                 }
181                 if (vmas)
182                         vmas[i] = vma;
183                 start = (start + PAGE_SIZE) & PAGE_MASK;
184         }
185 
186         return i;
187 
188 finish_or_fault:
189         return i ? : -EFAULT;
190 }
191 
192 /*
193  * get a list of pages in an address range belonging to the specified process
194  * and indicate the VMA that covers each page
195  * - this is potentially dodgy as we may end incrementing the page count of a
196  *   slab page or a secondary page from a compound page
197  * - don't permit access to VMAs that don't support it, such as I/O mappings
198  */
199 long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
200                     unsigned long start, unsigned long nr_pages,
201                     int write, int force, struct page **pages,
202                     struct vm_area_struct **vmas)
203 {
204         int flags = 0;
205 
206         if (write)
207                 flags |= FOLL_WRITE;
208         if (force)
209                 flags |= FOLL_FORCE;
210 
211         return __get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas,
212                                 NULL);
213 }
214 EXPORT_SYMBOL(get_user_pages);
215 
216 /**
217  * follow_pfn - look up PFN at a user virtual address
218  * @vma: memory mapping
219  * @address: user virtual address
220  * @pfn: location to store found PFN
221  *
222  * Only IO mappings and raw PFN mappings are allowed.
223  *
224  * Returns zero and the pfn at @pfn on success, -ve otherwise.
225  */
226 int follow_pfn(struct vm_area_struct *vma, unsigned long address,
227         unsigned long *pfn)
228 {
229         if (!(vma->vm_flags & (VM_IO | VM_PFNMAP)))
230                 return -EINVAL;
231 
232         *pfn = address >> PAGE_SHIFT;
233         return 0;
234 }
235 EXPORT_SYMBOL(follow_pfn);
236 
237 LIST_HEAD(vmap_area_list);
238 
239 void vfree(const void *addr)
240 {
241         kfree(addr);
242 }
243 EXPORT_SYMBOL(vfree);
244 
245 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
246 {
247         /*
248          *  You can't specify __GFP_HIGHMEM with kmalloc() since kmalloc()
249          * returns only a logical address.
250          */
251         return kmalloc(size, (gfp_mask | __GFP_COMP) & ~__GFP_HIGHMEM);
252 }
253 EXPORT_SYMBOL(__vmalloc);
254 
255 void *vmalloc_user(unsigned long size)
256 {
257         void *ret;
258 
259         ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
260                         PAGE_KERNEL);
261         if (ret) {
262                 struct vm_area_struct *vma;
263 
264                 down_write(&current->mm->mmap_sem);
265                 vma = find_vma(current->mm, (unsigned long)ret);
266                 if (vma)
267                         vma->vm_flags |= VM_USERMAP;
268                 up_write(&current->mm->mmap_sem);
269         }
270 
271         return ret;
272 }
273 EXPORT_SYMBOL(vmalloc_user);
274 
275 struct page *vmalloc_to_page(const void *addr)
276 {
277         return virt_to_page(addr);
278 }
279 EXPORT_SYMBOL(vmalloc_to_page);
280 
281 unsigned long vmalloc_to_pfn(const void *addr)
282 {
283         return page_to_pfn(virt_to_page(addr));
284 }
285 EXPORT_SYMBOL(vmalloc_to_pfn);
286 
287 long vread(char *buf, char *addr, unsigned long count)
288 {
289         /* Don't allow overflow */
290         if ((unsigned long) buf + count < count)
291                 count = -(unsigned long) buf;
292 
293         memcpy(buf, addr, count);
294         return count;
295 }
296 
297 long vwrite(char *buf, char *addr, unsigned long count)
298 {
299         /* Don't allow overflow */
300         if ((unsigned long) addr + count < count)
301                 count = -(unsigned long) addr;
302 
303         memcpy(addr, buf, count);
304         return count;
305 }
306 
307 /*
308  *      vmalloc  -  allocate virtually continguos memory
309  *
310  *      @size:          allocation size
311  *
312  *      Allocate enough pages to cover @size from the page level
313  *      allocator and map them into continguos kernel virtual space.
314  *
315  *      For tight control over page level allocator and protection flags
316  *      use __vmalloc() instead.
317  */
318 void *vmalloc(unsigned long size)
319 {
320        return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
321 }
322 EXPORT_SYMBOL(vmalloc);
323 
324 /*
325  *      vzalloc - allocate virtually continguos memory with zero fill
326  *
327  *      @size:          allocation size
328  *
329  *      Allocate enough pages to cover @size from the page level
330  *      allocator and map them into continguos kernel virtual space.
331  *      The memory allocated is set to zero.
332  *
333  *      For tight control over page level allocator and protection flags
334  *      use __vmalloc() instead.
335  */
336 void *vzalloc(unsigned long size)
337 {
338         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,
339                         PAGE_KERNEL);
340 }
341 EXPORT_SYMBOL(vzalloc);
342 
343 /**
344  * vmalloc_node - allocate memory on a specific node
345  * @size:       allocation size
346  * @node:       numa node
347  *
348  * Allocate enough pages to cover @size from the page level
349  * allocator and map them into contiguous kernel virtual space.
350  *
351  * For tight control over page level allocator and protection flags
352  * use __vmalloc() instead.
353  */
354 void *vmalloc_node(unsigned long size, int node)
355 {
356         return vmalloc(size);
357 }
358 EXPORT_SYMBOL(vmalloc_node);
359 
360 /**
361  * vzalloc_node - allocate memory on a specific node with zero fill
362  * @size:       allocation size
363  * @node:       numa node
364  *
365  * Allocate enough pages to cover @size from the page level
366  * allocator and map them into contiguous kernel virtual space.
367  * The memory allocated is set to zero.
368  *
369  * For tight control over page level allocator and protection flags
370  * use __vmalloc() instead.
371  */
372 void *vzalloc_node(unsigned long size, int node)
373 {
374         return vzalloc(size);
375 }
376 EXPORT_SYMBOL(vzalloc_node);
377 
378 #ifndef PAGE_KERNEL_EXEC
379 # define PAGE_KERNEL_EXEC PAGE_KERNEL
380 #endif
381 
382 /**
383  *      vmalloc_exec  -  allocate virtually contiguous, executable memory
384  *      @size:          allocation size
385  *
386  *      Kernel-internal function to allocate enough pages to cover @size
387  *      the page level allocator and map them into contiguous and
388  *      executable kernel virtual space.
389  *
390  *      For tight control over page level allocator and protection flags
391  *      use __vmalloc() instead.
392  */
393 
394 void *vmalloc_exec(unsigned long size)
395 {
396         return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL_EXEC);
397 }
398 
399 /**
400  * vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
401  *      @size:          allocation size
402  *
403  *      Allocate enough 32bit PA addressable pages to cover @size from the
404  *      page level allocator and map them into continguos kernel virtual space.
405  */
406 void *vmalloc_32(unsigned long size)
407 {
408         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
409 }
410 EXPORT_SYMBOL(vmalloc_32);
411 
412 /**
413  * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
414  *      @size:          allocation size
415  *
416  * The resulting memory area is 32bit addressable and zeroed so it can be
417  * mapped to userspace without leaking data.
418  *
419  * VM_USERMAP is set on the corresponding VMA so that subsequent calls to
420  * remap_vmalloc_range() are permissible.
421  */
422 void *vmalloc_32_user(unsigned long size)
423 {
424         /*
425          * We'll have to sort out the ZONE_DMA bits for 64-bit,
426          * but for now this can simply use vmalloc_user() directly.
427          */
428         return vmalloc_user(size);
429 }
430 EXPORT_SYMBOL(vmalloc_32_user);
431 
432 void *vmap(struct page **pages, unsigned int count, unsigned long flags, pgprot_t prot)
433 {
434         BUG();
435         return NULL;
436 }
437 EXPORT_SYMBOL(vmap);
438 
439 void vunmap(const void *addr)
440 {
441         BUG();
442 }
443 EXPORT_SYMBOL(vunmap);
444 
445 void *vm_map_ram(struct page **pages, unsigned int count, int node, pgprot_t prot)
446 {
447         BUG();
448         return NULL;
449 }
450 EXPORT_SYMBOL(vm_map_ram);
451 
452 void vm_unmap_ram(const void *mem, unsigned int count)
453 {
454         BUG();
455 }
456 EXPORT_SYMBOL(vm_unmap_ram);
457 
458 void vm_unmap_aliases(void)
459 {
460 }
461 EXPORT_SYMBOL_GPL(vm_unmap_aliases);
462 
463 /*
464  * Implement a stub for vmalloc_sync_all() if the architecture chose not to
465  * have one.
466  */
467 void __weak vmalloc_sync_all(void)
468 {
469 }
470 
471 /**
472  *      alloc_vm_area - allocate a range of kernel address space
473  *      @size:          size of the area
474  *
475  *      Returns:        NULL on failure, vm_struct on success
476  *
477  *      This function reserves a range of kernel address space, and
478  *      allocates pagetables to map that range.  No actual mappings
479  *      are created.  If the kernel address space is not shared
480  *      between processes, it syncs the pagetable across all
481  *      processes.
482  */
483 struct vm_struct *alloc_vm_area(size_t size, pte_t **ptes)
484 {
485         BUG();
486         return NULL;
487 }
488 EXPORT_SYMBOL_GPL(alloc_vm_area);
489 
490 void free_vm_area(struct vm_struct *area)
491 {
492         BUG();
493 }
494 EXPORT_SYMBOL_GPL(free_vm_area);
495 
496 int vm_insert_page(struct vm_area_struct *vma, unsigned long addr,
497                    struct page *page)
498 {
499         return -EINVAL;
500 }
501 EXPORT_SYMBOL(vm_insert_page);
502 
503 /*
504  *  sys_brk() for the most part doesn't need the global kernel
505  *  lock, except when an application is doing something nasty
506  *  like trying to un-brk an area that has already been mapped
507  *  to a regular file.  in this case, the unmapping will need
508  *  to invoke file system routines that need the global lock.
509  */
510 SYSCALL_DEFINE1(brk, unsigned long, brk)
511 {
512         struct mm_struct *mm = current->mm;
513 
514         if (brk < mm->start_brk || brk > mm->context.end_brk)
515                 return mm->brk;
516 
517         if (mm->brk == brk)
518                 return mm->brk;
519 
520         /*
521          * Always allow shrinking brk
522          */
523         if (brk <= mm->brk) {
524                 mm->brk = brk;
525                 return brk;
526         }
527 
528         /*
529          * Ok, looks good - let it rip.
530          */
531         flush_icache_range(mm->brk, brk);
532         return mm->brk = brk;
533 }
534 
535 /*
536  * initialise the VMA and region record slabs
537  */
538 void __init mmap_init(void)
539 {
540         int ret;
541 
542         ret = percpu_counter_init(&vm_committed_as, 0);
543         VM_BUG_ON(ret);
544         vm_region_jar = KMEM_CACHE(vm_region, SLAB_PANIC);
545 }
546 
547 /*
548  * validate the region tree
549  * - the caller must hold the region lock
550  */
551 #ifdef CONFIG_DEBUG_NOMMU_REGIONS
552 static noinline void validate_nommu_regions(void)
553 {
554         struct vm_region *region, *last;
555         struct rb_node *p, *lastp;
556 
557         lastp = rb_first(&nommu_region_tree);
558         if (!lastp)
559                 return;
560 
561         last = rb_entry(lastp, struct vm_region, vm_rb);
562         BUG_ON(unlikely(last->vm_end <= last->vm_start));
563         BUG_ON(unlikely(last->vm_top < last->vm_end));
564 
565         while ((p = rb_next(lastp))) {
566                 region = rb_entry(p, struct vm_region, vm_rb);
567                 last = rb_entry(lastp, struct vm_region, vm_rb);
568 
569                 BUG_ON(unlikely(region->vm_end <= region->vm_start));
570                 BUG_ON(unlikely(region->vm_top < region->vm_end));
571                 BUG_ON(unlikely(region->vm_start < last->vm_top));
572 
573                 lastp = p;
574         }
575 }
576 #else
577 static void validate_nommu_regions(void)
578 {
579 }
580 #endif
581 
582 /*
583  * add a region into the global tree
584  */
585 static void add_nommu_region(struct vm_region *region)
586 {
587         struct vm_region *pregion;
588         struct rb_node **p, *parent;
589 
590         validate_nommu_regions();
591 
592         parent = NULL;
593         p = &nommu_region_tree.rb_node;
594         while (*p) {
595                 parent = *p;
596                 pregion = rb_entry(parent, struct vm_region, vm_rb);
597                 if (region->vm_start < pregion->vm_start)
598                         p = &(*p)->rb_left;
599                 else if (region->vm_start > pregion->vm_start)
600                         p = &(*p)->rb_right;
601                 else if (pregion == region)
602                         return;
603                 else
604                         BUG();
605         }
606 
607         rb_link_node(&region->vm_rb, parent, p);
608         rb_insert_color(&region->vm_rb, &nommu_region_tree);
609 
610         validate_nommu_regions();
611 }
612 
613 /*
614  * delete a region from the global tree
615  */
616 static void delete_nommu_region(struct vm_region *region)
617 {
618         BUG_ON(!nommu_region_tree.rb_node);
619 
620         validate_nommu_regions();
621         rb_erase(&region->vm_rb, &nommu_region_tree);
622         validate_nommu_regions();
623 }
624 
625 /*
626  * free a contiguous series of pages
627  */
628 static void free_page_series(unsigned long from, unsigned long to)
629 {
630         for (; from < to; from += PAGE_SIZE) {
631                 struct page *page = virt_to_page(from);
632 
633                 kdebug("- free %lx", from);
634                 atomic_long_dec(&mmap_pages_allocated);
635                 if (page_count(page) != 1)
636                         kdebug("free page %p: refcount not one: %d",
637                                page, page_count(page));
638                 put_page(page);
639         }
640 }
641 
642 /*
643  * release a reference to a region
644  * - the caller must hold the region semaphore for writing, which this releases
645  * - the region may not have been added to the tree yet, in which case vm_top
646  *   will equal vm_start
647  */
648 static void __put_nommu_region(struct vm_region *region)
649         __releases(nommu_region_sem)
650 {
651         kenter("%p{%d}", region, region->vm_usage);
652 
653         BUG_ON(!nommu_region_tree.rb_node);
654 
655         if (--region->vm_usage == 0) {
656                 if (region->vm_top > region->vm_start)
657                         delete_nommu_region(region);
658                 up_write(&nommu_region_sem);
659 
660                 if (region->vm_file)
661                         fput(region->vm_file);
662 
663                 /* IO memory and memory shared directly out of the pagecache
664                  * from ramfs/tmpfs mustn't be released here */
665                 if (region->vm_flags & VM_MAPPED_COPY) {
666                         kdebug("free series");
667                         free_page_series(region->vm_start, region->vm_top);
668                 }
669                 kmem_cache_free(vm_region_jar, region);
670         } else {
671                 up_write(&nommu_region_sem);
672         }
673 }
674 
675 /*
676  * release a reference to a region
677  */
678 static void put_nommu_region(struct vm_region *region)
679 {
680         down_write(&nommu_region_sem);
681         __put_nommu_region(region);
682 }
683 
684 /*
685  * update protection on a vma
686  */
687 static void protect_vma(struct vm_area_struct *vma, unsigned long flags)
688 {
689 #ifdef CONFIG_MPU
690         struct mm_struct *mm = vma->vm_mm;
691         long start = vma->vm_start & PAGE_MASK;
692         while (start < vma->vm_end) {
693                 protect_page(mm, start, flags);
694                 start += PAGE_SIZE;
695         }
696         update_protections(mm);
697 #endif
698 }
699 
700 /*
701  * add a VMA into a process's mm_struct in the appropriate place in the list
702  * and tree and add to the address space's page tree also if not an anonymous
703  * page
704  * - should be called with mm->mmap_sem held writelocked
705  */
706 static void add_vma_to_mm(struct mm_struct *mm, struct vm_area_struct *vma)
707 {
708         struct vm_area_struct *pvma, *prev;
709         struct address_space *mapping;
710         struct rb_node **p, *parent, *rb_prev;
711 
712         kenter(",%p", vma);
713 
714         BUG_ON(!vma->vm_region);
715 
716         mm->map_count++;
717         vma->vm_mm = mm;
718 
719         protect_vma(vma, vma->vm_flags);
720 
721         /* add the VMA to the mapping */
722         if (vma->vm_file) {
723                 mapping = vma->vm_file->f_mapping;
724 
725                 mutex_lock(&mapping->i_mmap_mutex);
726                 flush_dcache_mmap_lock(mapping);
727                 vma_interval_tree_insert(vma, &mapping->i_mmap);
728                 flush_dcache_mmap_unlock(mapping);
729                 mutex_unlock(&mapping->i_mmap_mutex);
730         }
731 
732         /* add the VMA to the tree */
733         parent = rb_prev = NULL;
734         p = &mm->mm_rb.rb_node;
735         while (*p) {
736                 parent = *p;
737                 pvma = rb_entry(parent, struct vm_area_struct, vm_rb);
738 
739                 /* sort by: start addr, end addr, VMA struct addr in that order
740                  * (the latter is necessary as we may get identical VMAs) */
741                 if (vma->vm_start < pvma->vm_start)
742                         p = &(*p)->rb_left;
743                 else if (vma->vm_start > pvma->vm_start) {
744                         rb_prev = parent;
745                         p = &(*p)->rb_right;
746                 } else if (vma->vm_end < pvma->vm_end)
747                         p = &(*p)->rb_left;
748                 else if (vma->vm_end > pvma->vm_end) {
749                         rb_prev = parent;
750                         p = &(*p)->rb_right;
751                 } else if (vma < pvma)
752                         p = &(*p)->rb_left;
753                 else if (vma > pvma) {
754                         rb_prev = parent;
755                         p = &(*p)->rb_right;
756                 } else
757                         BUG();
758         }
759 
760         rb_link_node(&vma->vm_rb, parent, p);
761         rb_insert_color(&vma->vm_rb, &mm->mm_rb);
762 
763         /* add VMA to the VMA list also */
764         prev = NULL;
765         if (rb_prev)
766                 prev = rb_entry(rb_prev, struct vm_area_struct, vm_rb);
767 
768         __vma_link_list(mm, vma, prev, parent);
769 }
770 
771 /*
772  * delete a VMA from its owning mm_struct and address space
773  */
774 static void delete_vma_from_mm(struct vm_area_struct *vma)
775 {
776         int i;
777         struct address_space *mapping;
778         struct mm_struct *mm = vma->vm_mm;
779         struct task_struct *curr = current;
780 
781         kenter("%p", vma);
782 
783         protect_vma(vma, 0);
784 
785         mm->map_count--;
786         for (i = 0; i < VMACACHE_SIZE; i++) {
787                 /* if the vma is cached, invalidate the entire cache */
788                 if (curr->vmacache[i] == vma) {
789                         vmacache_invalidate(mm);
790                         break;
791                 }
792         }
793 
794         /* remove the VMA from the mapping */
795         if (vma->vm_file) {
796                 mapping = vma->vm_file->f_mapping;
797 
798                 mutex_lock(&mapping->i_mmap_mutex);
799                 flush_dcache_mmap_lock(mapping);
800                 vma_interval_tree_remove(vma, &mapping->i_mmap);
801                 flush_dcache_mmap_unlock(mapping);
802                 mutex_unlock(&mapping->i_mmap_mutex);
803         }
804 
805         /* remove from the MM's tree and list */
806         rb_erase(&vma->vm_rb, &mm->mm_rb);
807 
808         if (vma->vm_prev)
809                 vma->vm_prev->vm_next = vma->vm_next;
810         else
811                 mm->mmap = vma->vm_next;
812 
813         if (vma->vm_next)
814                 vma->vm_next->vm_prev = vma->vm_prev;
815 }
816 
817 /*
818  * destroy a VMA record
819  */
820 static void delete_vma(struct mm_struct *mm, struct vm_area_struct *vma)
821 {
822         kenter("%p", vma);
823         if (vma->vm_ops && vma->vm_ops->close)
824                 vma->vm_ops->close(vma);
825         if (vma->vm_file)
826                 fput(vma->vm_file);
827         put_nommu_region(vma->vm_region);
828         kmem_cache_free(vm_area_cachep, vma);
829 }
830 
831 /*
832  * look up the first VMA in which addr resides, NULL if none
833  * - should be called with mm->mmap_sem at least held readlocked
834  */
835 struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
836 {
837         struct vm_area_struct *vma;
838 
839         /* check the cache first */
840         vma = vmacache_find(mm, addr);
841         if (likely(vma))
842                 return vma;
843 
844         /* trawl the list (there may be multiple mappings in which addr
845          * resides) */
846         for (vma = mm->mmap; vma; vma = vma->vm_next) {
847                 if (vma->vm_start > addr)
848                         return NULL;
849                 if (vma->vm_end > addr) {
850                         vmacache_update(addr, vma);
851                         return vma;
852                 }
853         }
854 
855         return NULL;
856 }
857 EXPORT_SYMBOL(find_vma);
858 
859 /*
860  * find a VMA
861  * - we don't extend stack VMAs under NOMMU conditions
862  */
863 struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr)
864 {
865         return find_vma(mm, addr);
866 }
867 
868 /*
869  * expand a stack to a given address
870  * - not supported under NOMMU conditions
871  */
872 int expand_stack(struct vm_area_struct *vma, unsigned long address)
873 {
874         return -ENOMEM;
875 }
876 
877 /*
878  * look up the first VMA exactly that exactly matches addr
879  * - should be called with mm->mmap_sem at least held readlocked
880  */
881 static struct vm_area_struct *find_vma_exact(struct mm_struct *mm,
882                                              unsigned long addr,
883                                              unsigned long len)
884 {
885         struct vm_area_struct *vma;
886         unsigned long end = addr + len;
887 
888         /* check the cache first */
889         vma = vmacache_find_exact(mm, addr, end);
890         if (vma)
891                 return vma;
892 
893         /* trawl the list (there may be multiple mappings in which addr
894          * resides) */
895         for (vma = mm->mmap; vma; vma = vma->vm_next) {
896                 if (vma->vm_start < addr)
897                         continue;
898                 if (vma->vm_start > addr)
899                         return NULL;
900                 if (vma->vm_end == end) {
901                         vmacache_update(addr, vma);
902                         return vma;
903                 }
904         }
905 
906         return NULL;
907 }
908 
909 /*
910  * determine whether a mapping should be permitted and, if so, what sort of
911  * mapping we're capable of supporting
912  */
913 static int validate_mmap_request(struct file *file,
914                                  unsigned long addr,
915                                  unsigned long len,
916                                  unsigned long prot,
917                                  unsigned long flags,
918                                  unsigned long pgoff,
919                                  unsigned long *_capabilities)
920 {
921         unsigned long capabilities, rlen;
922         int ret;
923 
924         /* do the simple checks first */
925         if (flags & MAP_FIXED) {
926                 printk(KERN_DEBUG
927                        "%d: Can't do fixed-address/overlay mmap of RAM\n",
928                        current->pid);
929                 return -EINVAL;
930         }
931 
932         if ((flags & MAP_TYPE) != MAP_PRIVATE &&
933             (flags & MAP_TYPE) != MAP_SHARED)
934                 return -EINVAL;
935 
936         if (!len)
937                 return -EINVAL;
938 
939         /* Careful about overflows.. */
940         rlen = PAGE_ALIGN(len);
941         if (!rlen || rlen > TASK_SIZE)
942                 return -ENOMEM;
943 
944         /* offset overflow? */
945         if ((pgoff + (rlen >> PAGE_SHIFT)) < pgoff)
946                 return -EOVERFLOW;
947 
948         if (file) {
949                 /* validate file mapping requests */
950                 struct address_space *mapping;
951 
952                 /* files must support mmap */
953                 if (!file->f_op->mmap)
954                         return -ENODEV;
955 
956                 /* work out if what we've got could possibly be shared
957                  * - we support chardevs that provide their own "memory"
958                  * - we support files/blockdevs that are memory backed
959                  */
960                 mapping = file->f_mapping;
961                 if (!mapping)
962                         mapping = file_inode(file)->i_mapping;
963 
964                 capabilities = 0;
965                 if (mapping && mapping->backing_dev_info)
966                         capabilities = mapping->backing_dev_info->capabilities;
967 
968                 if (!capabilities) {
969                         /* no explicit capabilities set, so assume some
970                          * defaults */
971                         switch (file_inode(file)->i_mode & S_IFMT) {
972                         case S_IFREG:
973                         case S_IFBLK:
974                                 capabilities = BDI_CAP_MAP_COPY;
975                                 break;
976 
977                         case S_IFCHR:
978                                 capabilities =
979                                         BDI_CAP_MAP_DIRECT |
980                                         BDI_CAP_READ_MAP |
981                                         BDI_CAP_WRITE_MAP;
982                                 break;
983 
984                         default:
985                                 return -EINVAL;
986                         }
987                 }
988 
989                 /* eliminate any capabilities that we can't support on this
990                  * device */
991                 if (!file->f_op->get_unmapped_area)
992                         capabilities &= ~BDI_CAP_MAP_DIRECT;
993                 if (!file->f_op->read)
994                         capabilities &= ~BDI_CAP_MAP_COPY;
995 
996                 /* The file shall have been opened with read permission. */
997                 if (!(file->f_mode & FMODE_READ))
998                         return -EACCES;
999 
1000                 if (flags & MAP_SHARED) {
1001                         /* do checks for writing, appending and locking */
1002                         if ((prot & PROT_WRITE) &&
1003                             !(file->f_mode & FMODE_WRITE))
1004                                 return -EACCES;
1005 
1006                         if (IS_APPEND(file_inode(file)) &&
1007                             (file->f_mode & FMODE_WRITE))
1008                                 return -EACCES;
1009 
1010                         if (locks_verify_locked(file))
1011                                 return -EAGAIN;
1012 
1013                         if (!(capabilities & BDI_CAP_MAP_DIRECT))
1014                                 return -ENODEV;
1015 
1016                         /* we mustn't privatise shared mappings */
1017                         capabilities &= ~BDI_CAP_MAP_COPY;
1018                 } else {
1019                         /* we're going to read the file into private memory we
1020                          * allocate */
1021                         if (!(capabilities & BDI_CAP_MAP_COPY))
1022                                 return -ENODEV;
1023 
1024                         /* we don't permit a private writable mapping to be
1025                          * shared with the backing device */
1026                         if (prot & PROT_WRITE)
1027                                 capabilities &= ~BDI_CAP_MAP_DIRECT;
1028                 }
1029 
1030                 if (capabilities & BDI_CAP_MAP_DIRECT) {
1031                         if (((prot & PROT_READ)  && !(capabilities & BDI_CAP_READ_MAP))  ||
1032                             ((prot & PROT_WRITE) && !(capabilities & BDI_CAP_WRITE_MAP)) ||
1033                             ((prot & PROT_EXEC)  && !(capabilities & BDI_CAP_EXEC_MAP))
1034                             ) {
1035                                 capabilities &= ~BDI_CAP_MAP_DIRECT;
1036                                 if (flags & MAP_SHARED) {
1037                                         printk(KERN_WARNING
1038                                                "MAP_SHARED not completely supported on !MMU\n");
1039                                         return -EINVAL;
1040                                 }
1041                         }
1042                 }
1043 
1044                 /* handle executable mappings and implied executable
1045                  * mappings */
1046                 if (path_noexec(&file->f_path)) {
1047                         if (prot & PROT_EXEC)
1048                                 return -EPERM;
1049                 } else if ((prot & PROT_READ) && !(prot & PROT_EXEC)) {
1050                         /* handle implication of PROT_EXEC by PROT_READ */
1051                         if (current->personality & READ_IMPLIES_EXEC) {
1052                                 if (capabilities & BDI_CAP_EXEC_MAP)
1053                                         prot |= PROT_EXEC;
1054                         }
1055                 } else if ((prot & PROT_READ) &&
1056                          (prot & PROT_EXEC) &&
1057                          !(capabilities & BDI_CAP_EXEC_MAP)
1058                          ) {
1059                         /* backing file is not executable, try to copy */
1060                         capabilities &= ~BDI_CAP_MAP_DIRECT;
1061                 }
1062         } else {
1063                 /* anonymous mappings are always memory backed and can be
1064                  * privately mapped
1065                  */
1066                 capabilities = BDI_CAP_MAP_COPY;
1067 
1068                 /* handle PROT_EXEC implication by PROT_READ */
1069                 if ((prot & PROT_READ) &&
1070                     (current->personality & READ_IMPLIES_EXEC))
1071                         prot |= PROT_EXEC;
1072         }
1073 
1074         /* allow the security API to have its say */
1075         ret = security_mmap_addr(addr);
1076         if (ret < 0)
1077                 return ret;
1078 
1079         /* looks okay */
1080         *_capabilities = capabilities;
1081         return 0;
1082 }
1083 
1084 /*
1085  * we've determined that we can make the mapping, now translate what we
1086  * now know into VMA flags
1087  */
1088 static unsigned long determine_vm_flags(struct file *file,
1089                                         unsigned long prot,
1090                                         unsigned long flags,
1091                                         unsigned long capabilities)
1092 {
1093         unsigned long vm_flags;
1094 
1095         vm_flags = calc_vm_prot_bits(prot) | calc_vm_flag_bits(flags);
1096         /* vm_flags |= mm->def_flags; */
1097 
1098         if (!(capabilities & BDI_CAP_MAP_DIRECT)) {
1099                 /* attempt to share read-only copies of mapped file chunks */
1100                 vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
1101                 if (file && !(prot & PROT_WRITE))
1102                         vm_flags |= VM_MAYSHARE;
1103         } else {
1104                 /* overlay a shareable mapping on the backing device or inode
1105                  * if possible - used for chardevs, ramfs/tmpfs/shmfs and
1106                  * romfs/cramfs */
1107                 vm_flags |= VM_MAYSHARE | (capabilities & BDI_CAP_VMFLAGS);
1108                 if (flags & MAP_SHARED)
1109                         vm_flags |= VM_SHARED;
1110         }
1111 
1112         /* refuse to let anyone share private mappings with this process if
1113          * it's being traced - otherwise breakpoints set in it may interfere
1114          * with another untraced process
1115          */
1116         if ((flags & MAP_PRIVATE) && current->ptrace)
1117                 vm_flags &= ~VM_MAYSHARE;
1118 
1119         return vm_flags;
1120 }
1121 
1122 /*
1123  * set up a shared mapping on a file (the driver or filesystem provides and
1124  * pins the storage)
1125  */
1126 static int do_mmap_shared_file(struct vm_area_struct *vma)
1127 {
1128         int ret;
1129 
1130         ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
1131         if (ret == 0) {
1132                 vma->vm_region->vm_top = vma->vm_region->vm_end;
1133                 return 0;
1134         }
1135         if (ret != -ENOSYS)
1136                 return ret;
1137 
1138         /* getting -ENOSYS indicates that direct mmap isn't possible (as
1139          * opposed to tried but failed) so we can only give a suitable error as
1140          * it's not possible to make a private copy if MAP_SHARED was given */
1141         return -ENODEV;
1142 }
1143 
1144 /*
1145  * set up a private mapping or an anonymous shared mapping
1146  */
1147 static int do_mmap_private(struct vm_area_struct *vma,
1148                            struct vm_region *region,
1149                            unsigned long len,
1150                            unsigned long capabilities)
1151 {
1152         struct page *pages;
1153         unsigned long total, point, n;
1154         void *base;
1155         int ret, order;
1156 
1157         /* invoke the file's mapping function so that it can keep track of
1158          * shared mappings on devices or memory
1159          * - VM_MAYSHARE will be set if it may attempt to share
1160          */
1161         if (capabilities & BDI_CAP_MAP_DIRECT) {
1162                 ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
1163                 if (ret == 0) {
1164                         /* shouldn't return success if we're not sharing */
1165                         BUG_ON(!(vma->vm_flags & VM_MAYSHARE));
1166                         vma->vm_region->vm_top = vma->vm_region->vm_end;
1167                         return 0;
1168                 }
1169                 if (ret != -ENOSYS)
1170                         return ret;
1171 
1172                 /* getting an ENOSYS error indicates that direct mmap isn't
1173                  * possible (as opposed to tried but failed) so we'll try to
1174                  * make a private copy of the data and map that instead */
1175         }
1176 
1177 
1178         /* allocate some memory to hold the mapping
1179          * - note that this may not return a page-aligned address if the object
1180          *   we're allocating is smaller than a page
1181          */
1182         order = get_order(len);
1183         kdebug("alloc order %d for %lx", order, len);
1184 
1185         pages = alloc_pages(GFP_KERNEL, order);
1186         if (!pages)
1187                 goto enomem;
1188 
1189         total = 1 << order;
1190         atomic_long_add(total, &mmap_pages_allocated);
1191 
1192         point = len >> PAGE_SHIFT;
1193 
1194         /* we allocated a power-of-2 sized page set, so we may want to trim off
1195          * the excess */
1196         if (sysctl_nr_trim_pages && total - point >= sysctl_nr_trim_pages) {
1197                 while (total > point) {
1198                         order = ilog2(total - point);
1199                         n = 1 << order;
1200                         kdebug("shave %lu/%lu @%lu", n, total - point, total);
1201                         atomic_long_sub(n, &mmap_pages_allocated);
1202                         total -= n;
1203                         set_page_refcounted(pages + total);
1204                         __free_pages(pages + total, order);
1205                 }
1206         }
1207 
1208         for (point = 1; point < total; point++)
1209                 set_page_refcounted(&pages[point]);
1210 
1211         base = page_address(pages);
1212         region->vm_flags = vma->vm_flags |= VM_MAPPED_COPY;
1213         region->vm_start = (unsigned long) base;
1214         region->vm_end   = region->vm_start + len;
1215         region->vm_top   = region->vm_start + (total << PAGE_SHIFT);
1216 
1217         vma->vm_start = region->vm_start;
1218         vma->vm_end   = region->vm_start + len;
1219 
1220         if (vma->vm_file) {
1221                 /* read the contents of a file into the copy */
1222                 mm_segment_t old_fs;
1223                 loff_t fpos;
1224 
1225                 fpos = vma->vm_pgoff;
1226                 fpos <<= PAGE_SHIFT;
1227 
1228                 old_fs = get_fs();
1229                 set_fs(KERNEL_DS);
1230                 ret = vma->vm_file->f_op->read(vma->vm_file, base, len, &fpos);
1231                 set_fs(old_fs);
1232 
1233                 if (ret < 0)
1234                         goto error_free;
1235 
1236                 /* clear the last little bit */
1237                 if (ret < len)
1238                         memset(base + ret, 0, len - ret);
1239 
1240         }
1241 
1242         return 0;
1243 
1244 error_free:
1245         free_page_series(region->vm_start, region->vm_top);
1246         region->vm_start = vma->vm_start = 0;
1247         region->vm_end   = vma->vm_end = 0;
1248         region->vm_top   = 0;
1249         return ret;
1250 
1251 enomem:
1252         pr_err("Allocation of length %lu from process %d (%s) failed\n",
1253                len, current->pid, current->comm);
1254         show_free_areas(0);
1255         return -ENOMEM;
1256 }
1257 
1258 /*
1259  * handle mapping creation for uClinux
1260  */
1261 unsigned long do_mmap_pgoff(struct file *file,
1262                             unsigned long addr,
1263                             unsigned long len,
1264                             unsigned long prot,
1265                             unsigned long flags,
1266                             unsigned long pgoff,
1267                             unsigned long *populate)
1268 {
1269         struct vm_area_struct *vma;
1270         struct vm_region *region;
1271         struct rb_node *rb;
1272         unsigned long capabilities, vm_flags, result;
1273         int ret;
1274 
1275         kenter(",%lx,%lx,%lx,%lx,%lx", addr, len, prot, flags, pgoff);
1276 
1277         *populate = 0;
1278 
1279         /* decide whether we should attempt the mapping, and if so what sort of
1280          * mapping */
1281         ret = validate_mmap_request(file, addr, len, prot, flags, pgoff,
1282                                     &capabilities);
1283         if (ret < 0) {
1284                 kleave(" = %d [val]", ret);
1285                 return ret;
1286         }
1287 
1288         /* we ignore the address hint */
1289         addr = 0;
1290         len = PAGE_ALIGN(len);
1291 
1292         /* we've determined that we can make the mapping, now translate what we
1293          * now know into VMA flags */
1294         vm_flags = determine_vm_flags(file, prot, flags, capabilities);
1295 
1296         /* we're going to need to record the mapping */
1297         region = kmem_cache_zalloc(vm_region_jar, GFP_KERNEL);
1298         if (!region)
1299                 goto error_getting_region;
1300 
1301         vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
1302         if (!vma)
1303                 goto error_getting_vma;
1304 
1305         region->vm_usage = 1;
1306         region->vm_flags = vm_flags;
1307         region->vm_pgoff = pgoff;
1308 
1309         INIT_LIST_HEAD(&vma->anon_vma_chain);
1310         vma->vm_flags = vm_flags;
1311         vma->vm_pgoff = pgoff;
1312 
1313         if (file) {
1314                 region->vm_file = get_file(file);
1315                 vma->vm_file = get_file(file);
1316         }
1317 
1318         down_write(&nommu_region_sem);
1319 
1320         /* if we want to share, we need to check for regions created by other
1321          * mmap() calls that overlap with our proposed mapping
1322          * - we can only share with a superset match on most regular files
1323          * - shared mappings on character devices and memory backed files are
1324          *   permitted to overlap inexactly as far as we are concerned for in
1325          *   these cases, sharing is handled in the driver or filesystem rather
1326          *   than here
1327          */
1328         if (vm_flags & VM_MAYSHARE) {
1329                 struct vm_region *pregion;
1330                 unsigned long pglen, rpglen, pgend, rpgend, start;
1331 
1332                 pglen = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
1333                 pgend = pgoff + pglen;
1334 
1335                 for (rb = rb_first(&nommu_region_tree); rb; rb = rb_next(rb)) {
1336                         pregion = rb_entry(rb, struct vm_region, vm_rb);
1337 
1338                         if (!(pregion->vm_flags & VM_MAYSHARE))
1339                                 continue;
1340 
1341                         /* search for overlapping mappings on the same file */
1342                         if (file_inode(pregion->vm_file) !=
1343                             file_inode(file))
1344                                 continue;
1345 
1346                         if (pregion->vm_pgoff >= pgend)
1347                                 continue;
1348 
1349                         rpglen = pregion->vm_end - pregion->vm_start;
1350                         rpglen = (rpglen + PAGE_SIZE - 1) >> PAGE_SHIFT;
1351                         rpgend = pregion->vm_pgoff + rpglen;
1352                         if (pgoff >= rpgend)
1353                                 continue;
1354 
1355                         /* handle inexactly overlapping matches between
1356                          * mappings */
1357                         if ((pregion->vm_pgoff != pgoff || rpglen != pglen) &&
1358                             !(pgoff >= pregion->vm_pgoff && pgend <= rpgend)) {
1359                                 /* new mapping is not a subset of the region */
1360                                 if (!(capabilities & BDI_CAP_MAP_DIRECT))
1361                                         goto sharing_violation;
1362                                 continue;
1363                         }
1364 
1365                         /* we've found a region we can share */
1366                         pregion->vm_usage++;
1367                         vma->vm_region = pregion;
1368                         start = pregion->vm_start;
1369                         start += (pgoff - pregion->vm_pgoff) << PAGE_SHIFT;
1370                         vma->vm_start = start;
1371                         vma->vm_end = start + len;
1372 
1373                         if (pregion->vm_flags & VM_MAPPED_COPY) {
1374                                 kdebug("share copy");
1375                                 vma->vm_flags |= VM_MAPPED_COPY;
1376                         } else {
1377                                 kdebug("share mmap");
1378                                 ret = do_mmap_shared_file(vma);
1379                                 if (ret < 0) {
1380                                         vma->vm_region = NULL;
1381                                         vma->vm_start = 0;
1382                                         vma->vm_end = 0;
1383                                         pregion->vm_usage--;
1384                                         pregion = NULL;
1385                                         goto error_just_free;
1386                                 }
1387                         }
1388                         fput(region->vm_file);
1389                         kmem_cache_free(vm_region_jar, region);
1390                         region = pregion;
1391                         result = start;
1392                         goto share;
1393                 }
1394 
1395                 /* obtain the address at which to make a shared mapping
1396                  * - this is the hook for quasi-memory character devices to
1397                  *   tell us the location of a shared mapping
1398                  */
1399                 if (capabilities & BDI_CAP_MAP_DIRECT) {
1400                         addr = file->f_op->get_unmapped_area(file, addr, len,
1401                                                              pgoff, flags);
1402                         if (IS_ERR_VALUE(addr)) {
1403                                 ret = addr;
1404                                 if (ret != -ENOSYS)
1405                                         goto error_just_free;
1406 
1407                                 /* the driver refused to tell us where to site
1408                                  * the mapping so we'll have to attempt to copy
1409                                  * it */
1410                                 ret = -ENODEV;
1411                                 if (!(capabilities & BDI_CAP_MAP_COPY))
1412                                         goto error_just_free;
1413 
1414                                 capabilities &= ~BDI_CAP_MAP_DIRECT;
1415                         } else {
1416                                 vma->vm_start = region->vm_start = addr;
1417                                 vma->vm_end = region->vm_end = addr + len;
1418                         }
1419                 }
1420         }
1421 
1422         vma->vm_region = region;
1423 
1424         /* set up the mapping
1425          * - the region is filled in if BDI_CAP_MAP_DIRECT is still set
1426          */
1427         if (file && vma->vm_flags & VM_SHARED)
1428                 ret = do_mmap_shared_file(vma);
1429         else
1430                 ret = do_mmap_private(vma, region, len, capabilities);
1431         if (ret < 0)
1432                 goto error_just_free;
1433         add_nommu_region(region);
1434 
1435         /* clear anonymous mappings that don't ask for uninitialized data */
1436         if (!vma->vm_file && !(flags & MAP_UNINITIALIZED))
1437                 memset((void *)region->vm_start, 0,
1438                        region->vm_end - region->vm_start);
1439 
1440         /* okay... we have a mapping; now we have to register it */
1441         result = vma->vm_start;
1442 
1443         current->mm->total_vm += len >> PAGE_SHIFT;
1444 
1445 share:
1446         add_vma_to_mm(current->mm, vma);
1447 
1448         /* we flush the region from the icache only when the first executable
1449          * mapping of it is made  */
1450         if (vma->vm_flags & VM_EXEC && !region->vm_icache_flushed) {
1451                 flush_icache_range(region->vm_start, region->vm_end);
1452                 region->vm_icache_flushed = true;
1453         }
1454 
1455         up_write(&nommu_region_sem);
1456 
1457         kleave(" = %lx", result);
1458         return result;
1459 
1460 error_just_free:
1461         up_write(&nommu_region_sem);
1462 error:
1463         if (region->vm_file)
1464                 fput(region->vm_file);
1465         kmem_cache_free(vm_region_jar, region);
1466         if (vma->vm_file)
1467                 fput(vma->vm_file);
1468         kmem_cache_free(vm_area_cachep, vma);
1469         kleave(" = %d", ret);
1470         return ret;
1471 
1472 sharing_violation:
1473         up_write(&nommu_region_sem);
1474         printk(KERN_WARNING "Attempt to share mismatched mappings\n");
1475         ret = -EINVAL;
1476         goto error;
1477 
1478 error_getting_vma:
1479         kmem_cache_free(vm_region_jar, region);
1480         printk(KERN_WARNING "Allocation of vma for %lu byte allocation"
1481                " from process %d failed\n",
1482                len, current->pid);
1483         show_free_areas(0);
1484         return -ENOMEM;
1485 
1486 error_getting_region:
1487         printk(KERN_WARNING "Allocation of vm region for %lu byte allocation"
1488                " from process %d failed\n",
1489                len, current->pid);
1490         show_free_areas(0);
1491         return -ENOMEM;
1492 }
1493 
1494 SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
1495                 unsigned long, prot, unsigned long, flags,
1496                 unsigned long, fd, unsigned long, pgoff)
1497 {
1498         struct file *file = NULL;
1499         unsigned long retval = -EBADF;
1500 
1501         audit_mmap_fd(fd, flags);
1502         if (!(flags & MAP_ANONYMOUS)) {
1503                 file = fget(fd);
1504                 if (!file)
1505                         goto out;
1506         }
1507 
1508         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
1509 
1510         retval = vm_mmap_pgoff(file, addr, len, prot, flags, pgoff);
1511 
1512         if (file)
1513                 fput(file);
1514 out:
1515         return retval;
1516 }
1517 
1518 #ifdef __ARCH_WANT_SYS_OLD_MMAP
1519 struct mmap_arg_struct {
1520         unsigned long addr;
1521         unsigned long len;
1522         unsigned long prot;
1523         unsigned long flags;
1524         unsigned long fd;
1525         unsigned long offset;
1526 };
1527 
1528 SYSCALL_DEFINE1(old_mmap, struct mmap_arg_struct __user *, arg)
1529 {
1530         struct mmap_arg_struct a;
1531 
1532         if (copy_from_user(&a, arg, sizeof(a)))
1533                 return -EFAULT;
1534         if (a.offset & ~PAGE_MASK)
1535                 return -EINVAL;
1536 
1537         return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd,
1538                               a.offset >> PAGE_SHIFT);
1539 }
1540 #endif /* __ARCH_WANT_SYS_OLD_MMAP */
1541 
1542 /*
1543  * split a vma into two pieces at address 'addr', a new vma is allocated either
1544  * for the first part or the tail.
1545  */
1546 int split_vma(struct mm_struct *mm, struct vm_area_struct *vma,
1547               unsigned long addr, int new_below)
1548 {
1549         struct vm_area_struct *new;
1550         struct vm_region *region;
1551         unsigned long npages;
1552 
1553         kenter("");
1554 
1555         /* we're only permitted to split anonymous regions (these should have
1556          * only a single usage on the region) */
1557         if (vma->vm_file)
1558                 return -ENOMEM;
1559 
1560         if (mm->map_count >= sysctl_max_map_count)
1561                 return -ENOMEM;
1562 
1563         region = kmem_cache_alloc(vm_region_jar, GFP_KERNEL);
1564         if (!region)
1565                 return -ENOMEM;
1566 
1567         new = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
1568         if (!new) {
1569                 kmem_cache_free(vm_region_jar, region);
1570                 return -ENOMEM;
1571         }
1572 
1573         /* most fields are the same, copy all, and then fixup */
1574         *new = *vma;
1575         *region = *vma->vm_region;
1576         new->vm_region = region;
1577 
1578         npages = (addr - vma->vm_start) >> PAGE_SHIFT;
1579 
1580         if (new_below) {
1581                 region->vm_top = region->vm_end = new->vm_end = addr;
1582         } else {
1583                 region->vm_start = new->vm_start = addr;
1584                 region->vm_pgoff = new->vm_pgoff += npages;
1585         }
1586 
1587         if (new->vm_ops && new->vm_ops->open)
1588                 new->vm_ops->open(new);
1589 
1590         delete_vma_from_mm(vma);
1591         down_write(&nommu_region_sem);
1592         delete_nommu_region(vma->vm_region);
1593         if (new_below) {
1594                 vma->vm_region->vm_start = vma->vm_start = addr;
1595                 vma->vm_region->vm_pgoff = vma->vm_pgoff += npages;
1596         } else {
1597                 vma->vm_region->vm_end = vma->vm_end = addr;
1598                 vma->vm_region->vm_top = addr;
1599         }
1600         add_nommu_region(vma->vm_region);
1601         add_nommu_region(new->vm_region);
1602         up_write(&nommu_region_sem);
1603         add_vma_to_mm(mm, vma);
1604         add_vma_to_mm(mm, new);
1605         return 0;
1606 }
1607 
1608 /*
1609  * shrink a VMA by removing the specified chunk from either the beginning or
1610  * the end
1611  */
1612 static int shrink_vma(struct mm_struct *mm,
1613                       struct vm_area_struct *vma,
1614                       unsigned long from, unsigned long to)
1615 {
1616         struct vm_region *region;
1617 
1618         kenter("");
1619 
1620         /* adjust the VMA's pointers, which may reposition it in the MM's tree
1621          * and list */
1622         delete_vma_from_mm(vma);
1623         if (from > vma->vm_start)
1624                 vma->vm_end = from;
1625         else
1626                 vma->vm_start = to;
1627         add_vma_to_mm(mm, vma);
1628 
1629         /* cut the backing region down to size */
1630         region = vma->vm_region;
1631         BUG_ON(region->vm_usage != 1);
1632 
1633         down_write(&nommu_region_sem);
1634         delete_nommu_region(region);
1635         if (from > region->vm_start) {
1636                 to = region->vm_top;
1637                 region->vm_top = region->vm_end = from;
1638         } else {
1639                 region->vm_start = to;
1640         }
1641         add_nommu_region(region);
1642         up_write(&nommu_region_sem);
1643 
1644         free_page_series(from, to);
1645         return 0;
1646 }
1647 
1648 /*
1649  * release a mapping
1650  * - under NOMMU conditions the chunk to be unmapped must be backed by a single
1651  *   VMA, though it need not cover the whole VMA
1652  */
1653 int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
1654 {
1655         struct vm_area_struct *vma;
1656         unsigned long end;
1657         int ret;
1658 
1659         kenter(",%lx,%zx", start, len);
1660 
1661         len = PAGE_ALIGN(len);
1662         if (len == 0)
1663                 return -EINVAL;
1664 
1665         end = start + len;
1666 
1667         /* find the first potentially overlapping VMA */
1668         vma = find_vma(mm, start);
1669         if (!vma) {
1670                 static int limit;
1671                 if (limit < 5) {
1672                         printk(KERN_WARNING
1673                                "munmap of memory not mmapped by process %d"
1674                                " (%s): 0x%lx-0x%lx\n",
1675                                current->pid, current->comm,
1676                                start, start + len - 1);
1677                         limit++;
1678                 }
1679                 return -EINVAL;
1680         }
1681 
1682         /* we're allowed to split an anonymous VMA but not a file-backed one */
1683         if (vma->vm_file) {
1684                 do {
1685                         if (start > vma->vm_start) {
1686                                 kleave(" = -EINVAL [miss]");
1687                                 return -EINVAL;
1688                         }
1689                         if (end == vma->vm_end)
1690                                 goto erase_whole_vma;
1691                         vma = vma->vm_next;
1692                 } while (vma);
1693                 kleave(" = -EINVAL [split file]");
1694                 return -EINVAL;
1695         } else {
1696                 /* the chunk must be a subset of the VMA found */
1697                 if (start == vma->vm_start && end == vma->vm_end)
1698                         goto erase_whole_vma;
1699                 if (start < vma->vm_start || end > vma->vm_end) {
1700                         kleave(" = -EINVAL [superset]");
1701                         return -EINVAL;
1702                 }
1703                 if (start & ~PAGE_MASK) {
1704                         kleave(" = -EINVAL [unaligned start]");
1705                         return -EINVAL;
1706                 }
1707                 if (end != vma->vm_end && end & ~PAGE_MASK) {
1708                         kleave(" = -EINVAL [unaligned split]");
1709                         return -EINVAL;
1710                 }
1711                 if (start != vma->vm_start && end != vma->vm_end) {
1712                         ret = split_vma(mm, vma, start, 1);
1713                         if (ret < 0) {
1714                                 kleave(" = %d [split]", ret);
1715                                 return ret;
1716                         }
1717                 }
1718                 return shrink_vma(mm, vma, start, end);
1719         }
1720 
1721 erase_whole_vma:
1722         delete_vma_from_mm(vma);
1723         delete_vma(mm, vma);
1724         kleave(" = 0");
1725         return 0;
1726 }
1727 EXPORT_SYMBOL(do_munmap);
1728 
1729 int vm_munmap(unsigned long addr, size_t len)
1730 {
1731         struct mm_struct *mm = current->mm;
1732         int ret;
1733 
1734         down_write(&mm->mmap_sem);
1735         ret = do_munmap(mm, addr, len);
1736         up_write(&mm->mmap_sem);
1737         return ret;
1738 }
1739 EXPORT_SYMBOL(vm_munmap);
1740 
1741 SYSCALL_DEFINE2(munmap, unsigned long, addr, size_t, len)
1742 {
1743         return vm_munmap(addr, len);
1744 }
1745 
1746 /*
1747  * release all the mappings made in a process's VM space
1748  */
1749 void exit_mmap(struct mm_struct *mm)
1750 {
1751         struct vm_area_struct *vma;
1752 
1753         if (!mm)
1754                 return;
1755 
1756         kenter("");
1757 
1758         mm->total_vm = 0;
1759 
1760         while ((vma = mm->mmap)) {
1761                 mm->mmap = vma->vm_next;
1762                 delete_vma_from_mm(vma);
1763                 delete_vma(mm, vma);
1764                 cond_resched();
1765         }
1766 
1767         kleave("");
1768 }
1769 
1770 unsigned long vm_brk(unsigned long addr, unsigned long len)
1771 {
1772         return -ENOMEM;
1773 }
1774 
1775 /*
1776  * expand (or shrink) an existing mapping, potentially moving it at the same
1777  * time (controlled by the MREMAP_MAYMOVE flag and available VM space)
1778  *
1779  * under NOMMU conditions, we only permit changing a mapping's size, and only
1780  * as long as it stays within the region allocated by do_mmap_private() and the
1781  * block is not shareable
1782  *
1783  * MREMAP_FIXED is not supported under NOMMU conditions
1784  */
1785 static unsigned long do_mremap(unsigned long addr,
1786                         unsigned long old_len, unsigned long new_len,
1787                         unsigned long flags, unsigned long new_addr)
1788 {
1789         struct vm_area_struct *vma;
1790 
1791         /* insanity checks first */
1792         old_len = PAGE_ALIGN(old_len);
1793         new_len = PAGE_ALIGN(new_len);
1794         if (old_len == 0 || new_len == 0)
1795                 return (unsigned long) -EINVAL;
1796 
1797         if (addr & ~PAGE_MASK)
1798                 return -EINVAL;
1799 
1800         if (flags & MREMAP_FIXED && new_addr != addr)
1801                 return (unsigned long) -EINVAL;
1802 
1803         vma = find_vma_exact(current->mm, addr, old_len);
1804         if (!vma)
1805                 return (unsigned long) -EINVAL;
1806 
1807         if (vma->vm_end != vma->vm_start + old_len)
1808                 return (unsigned long) -EFAULT;
1809 
1810         if (vma->vm_flags & VM_MAYSHARE)
1811                 return (unsigned long) -EPERM;
1812 
1813         if (new_len > vma->vm_region->vm_end - vma->vm_region->vm_start)
1814                 return (unsigned long) -ENOMEM;
1815 
1816         /* all checks complete - do it */
1817         vma->vm_end = vma->vm_start + new_len;
1818         return vma->vm_start;
1819 }
1820 
1821 SYSCALL_DEFINE5(mremap, unsigned long, addr, unsigned long, old_len,
1822                 unsigned long, new_len, unsigned long, flags,
1823                 unsigned long, new_addr)
1824 {
1825         unsigned long ret;
1826 
1827         down_write(&current->mm->mmap_sem);
1828         ret = do_mremap(addr, old_len, new_len, flags, new_addr);
1829         up_write(&current->mm->mmap_sem);
1830         return ret;
1831 }
1832 
1833 struct page *follow_page_mask(struct vm_area_struct *vma,
1834                               unsigned long address, unsigned int flags,
1835                               unsigned int *page_mask)
1836 {
1837         *page_mask = 0;
1838         return NULL;
1839 }
1840 
1841 int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
1842                 unsigned long pfn, unsigned long size, pgprot_t prot)
1843 {
1844         if (addr != (pfn << PAGE_SHIFT))
1845                 return -EINVAL;
1846 
1847         vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;
1848         return 0;
1849 }
1850 EXPORT_SYMBOL(remap_pfn_range);
1851 
1852 int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len)
1853 {
1854         unsigned long pfn = start >> PAGE_SHIFT;
1855         unsigned long vm_len = vma->vm_end - vma->vm_start;
1856 
1857         pfn += vma->vm_pgoff;
1858         return io_remap_pfn_range(vma, vma->vm_start, pfn, vm_len, vma->vm_page_prot);
1859 }
1860 EXPORT_SYMBOL(vm_iomap_memory);
1861 
1862 int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
1863                         unsigned long pgoff)
1864 {
1865         unsigned int size = vma->vm_end - vma->vm_start;
1866 
1867         if (!(vma->vm_flags & VM_USERMAP))
1868                 return -EINVAL;
1869 
1870         vma->vm_start = (unsigned long)(addr + (pgoff << PAGE_SHIFT));
1871         vma->vm_end = vma->vm_start + size;
1872 
1873         return 0;
1874 }
1875 EXPORT_SYMBOL(remap_vmalloc_range);
1876 
1877 unsigned long arch_get_unmapped_area(struct file *file, unsigned long addr,
1878         unsigned long len, unsigned long pgoff, unsigned long flags)
1879 {
1880         return -ENOMEM;
1881 }
1882 
1883 void unmap_mapping_range(struct address_space *mapping,
1884                          loff_t const holebegin, loff_t const holelen,
1885                          int even_cows)
1886 {
1887 }
1888 EXPORT_SYMBOL(unmap_mapping_range);
1889 
1890 /*
1891  * Check that a process has enough memory to allocate a new virtual
1892  * mapping. 0 means there is enough memory for the allocation to
1893  * succeed and -ENOMEM implies there is not.
1894  *
1895  * We currently support three overcommit policies, which are set via the
1896  * vm.overcommit_memory sysctl.  See Documentation/vm/overcommit-accounting
1897  *
1898  * Strict overcommit modes added 2002 Feb 26 by Alan Cox.
1899  * Additional code 2002 Jul 20 by Robert Love.
1900  *
1901  * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise.
1902  *
1903  * Note this is a helper function intended to be used by LSMs which
1904  * wish to use this logic.
1905  */
1906 int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin)
1907 {
1908         long free, allowed, reserve;
1909 
1910         vm_acct_memory(pages);
1911 
1912         /*
1913          * Sometimes we want to use more memory than we have
1914          */
1915         if (sysctl_overcommit_memory == OVERCOMMIT_ALWAYS)
1916                 return 0;
1917 
1918         if (sysctl_overcommit_memory == OVERCOMMIT_GUESS) {
1919                 free = global_page_state(NR_FREE_PAGES);
1920                 free += global_page_state(NR_FILE_PAGES);
1921 
1922                 /*
1923                  * shmem pages shouldn't be counted as free in this
1924                  * case, they can't be purged, only swapped out, and
1925                  * that won't affect the overall amount of available
1926                  * memory in the system.
1927                  */
1928                 free -= global_page_state(NR_SHMEM);
1929 
1930                 free += get_nr_swap_pages();
1931 
1932                 /*
1933                  * Any slabs which are created with the
1934                  * SLAB_RECLAIM_ACCOUNT flag claim to have contents
1935                  * which are reclaimable, under pressure.  The dentry
1936                  * cache and most inode caches should fall into this
1937                  */
1938                 free += global_page_state(NR_SLAB_RECLAIMABLE);
1939 
1940                 /*
1941                  * Leave reserved pages. The pages are not for anonymous pages.
1942                  */
1943                 if (free <= totalreserve_pages)
1944                         goto error;
1945                 else
1946                         free -= totalreserve_pages;
1947 
1948                 /*
1949                  * Reserve some for root
1950                  */
1951                 if (!cap_sys_admin)
1952                         free -= sysctl_admin_reserve_kbytes >> (PAGE_SHIFT - 10);
1953 
1954                 if (free > pages)
1955                         return 0;
1956 
1957                 goto error;
1958         }
1959 
1960         allowed = vm_commit_limit();
1961         /*
1962          * Reserve some 3% for root
1963          */
1964         if (!cap_sys_admin)
1965                 allowed -= sysctl_admin_reserve_kbytes >> (PAGE_SHIFT - 10);
1966 
1967         /*
1968          * Don't let a single process grow so big a user can't recover
1969          */
1970         if (mm) {
1971                 reserve = sysctl_user_reserve_kbytes >> (PAGE_SHIFT - 10);
1972                 allowed -= min_t(long, mm->total_vm / 32, reserve);
1973         }
1974 
1975         if (percpu_counter_read_positive(&vm_committed_as) < allowed)
1976                 return 0;
1977 
1978 error:
1979         vm_unacct_memory(pages);
1980 
1981         return -ENOMEM;
1982 }
1983 
1984 int in_gate_area_no_mm(unsigned long addr)
1985 {
1986         return 0;
1987 }
1988 
1989 int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1990 {
1991         BUG();
1992         return 0;
1993 }
1994 EXPORT_SYMBOL(filemap_fault);
1995 
1996 void filemap_map_pages(struct vm_area_struct *vma, struct vm_fault *vmf)
1997 {
1998         BUG();
1999 }
2000 EXPORT_SYMBOL(filemap_map_pages);
2001 
2002 int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,
2003                 unsigned long addr, void *buf, int len, int write)
2004 {
2005         struct vm_area_struct *vma;
2006 
2007         down_read(&mm->mmap_sem);
2008 
2009         /* the access must start within one of the target process's mappings */
2010         vma = find_vma(mm, addr);
2011         if (vma) {
2012                 /* don't overrun this mapping */
2013                 if (addr + len >= vma->vm_end)
2014                         len = vma->vm_end - addr;
2015 
2016                 /* only read or write mappings where it is permitted */
2017                 if (write && vma->vm_flags & VM_MAYWRITE)
2018                         copy_to_user_page(vma, NULL, addr,
2019                                          (void *) addr, buf, len);
2020                 else if (!write && vma->vm_flags & VM_MAYREAD)
2021                         copy_from_user_page(vma, NULL, addr,
2022                                             buf, (void *) addr, len);
2023                 else
2024                         len = 0;
2025         } else {
2026                 len = 0;
2027         }
2028 
2029         up_read(&mm->mmap_sem);
2030 
2031         return len;
2032 }
2033 
2034 /**
2035  * @access_remote_vm - access another process' address space
2036  * @mm:         the mm_struct of the target address space
2037  * @addr:       start address to access
2038  * @buf:        source or destination buffer
2039  * @len:        number of bytes to transfer
2040  * @write:      whether the access is a write
2041  *
2042  * The caller must hold a reference on @mm.
2043  */
2044 int access_remote_vm(struct mm_struct *mm, unsigned long addr,
2045                 void *buf, int len, int write)
2046 {
2047         return __access_remote_vm(NULL, mm, addr, buf, len, write);
2048 }
2049 
2050 /*
2051  * Access another process' address space.
2052  * - source/target buffer must be kernel space
2053  */
2054 int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
2055 {
2056         struct mm_struct *mm;
2057 
2058         if (addr + len < addr)
2059                 return 0;
2060 
2061         mm = get_task_mm(tsk);
2062         if (!mm)
2063                 return 0;
2064 
2065         len = __access_remote_vm(tsk, mm, addr, buf, len, write);
2066 
2067         mmput(mm);
2068         return len;
2069 }
2070 
2071 /**
2072  * nommu_shrink_inode_mappings - Shrink the shared mappings on an inode
2073  * @inode: The inode to check
2074  * @size: The current filesize of the inode
2075  * @newsize: The proposed filesize of the inode
2076  *
2077  * Check the shared mappings on an inode on behalf of a shrinking truncate to
2078  * make sure that that any outstanding VMAs aren't broken and then shrink the
2079  * vm_regions that extend that beyond so that do_mmap_pgoff() doesn't
2080  * automatically grant mappings that are too large.
2081  */
2082 int nommu_shrink_inode_mappings(struct inode *inode, size_t size,
2083                                 size_t newsize)
2084 {
2085         struct vm_area_struct *vma;
2086         struct vm_region *region;
2087         pgoff_t low, high;
2088         size_t r_size, r_top;
2089 
2090         low = newsize >> PAGE_SHIFT;
2091         high = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
2092 
2093         down_write(&nommu_region_sem);
2094         mutex_lock(&inode->i_mapping->i_mmap_mutex);
2095 
2096         /* search for VMAs that fall within the dead zone */
2097         vma_interval_tree_foreach(vma, &inode->i_mapping->i_mmap, low, high) {
2098                 /* found one - only interested if it's shared out of the page
2099                  * cache */
2100                 if (vma->vm_flags & VM_SHARED) {
2101                         mutex_unlock(&inode->i_mapping->i_mmap_mutex);
2102                         up_write(&nommu_region_sem);
2103                         return -ETXTBSY; /* not quite true, but near enough */
2104                 }
2105         }
2106 
2107         /* reduce any regions that overlap the dead zone - if in existence,
2108          * these will be pointed to by VMAs that don't overlap the dead zone
2109          *
2110          * we don't check for any regions that start beyond the EOF as there
2111          * shouldn't be any
2112          */
2113         vma_interval_tree_foreach(vma, &inode->i_mapping->i_mmap,
2114                                   0, ULONG_MAX) {
2115                 if (!(vma->vm_flags & VM_SHARED))
2116                         continue;
2117 
2118                 region = vma->vm_region;
2119                 r_size = region->vm_top - region->vm_start;
2120                 r_top = (region->vm_pgoff << PAGE_SHIFT) + r_size;
2121 
2122                 if (r_top > newsize) {
2123                         region->vm_top -= r_top - newsize;
2124                         if (region->vm_end > region->vm_top)
2125                                 region->vm_end = region->vm_top;
2126                 }
2127         }
2128 
2129         mutex_unlock(&inode->i_mapping->i_mmap_mutex);
2130         up_write(&nommu_region_sem);
2131         return 0;
2132 }
2133 
2134 /*
2135  * Initialise sysctl_user_reserve_kbytes.
2136  *
2137  * This is intended to prevent a user from starting a single memory hogging
2138  * process, such that they cannot recover (kill the hog) in OVERCOMMIT_NEVER
2139  * mode.
2140  *
2141  * The default value is min(3% of free memory, 128MB)
2142  * 128MB is enough to recover with sshd/login, bash, and top/kill.
2143  */
2144 static int __meminit init_user_reserve(void)
2145 {
2146         unsigned long free_kbytes;
2147 
2148         free_kbytes = global_page_state(NR_FREE_PAGES) << (PAGE_SHIFT - 10);
2149 
2150         sysctl_user_reserve_kbytes = min(free_kbytes / 32, 1UL << 17);
2151         return 0;
2152 }
2153 module_init(init_user_reserve)
2154 
2155 /*
2156  * Initialise sysctl_admin_reserve_kbytes.
2157  *
2158  * The purpose of sysctl_admin_reserve_kbytes is to allow the sys admin
2159  * to log in and kill a memory hogging process.
2160  *
2161  * Systems with more than 256MB will reserve 8MB, enough to recover
2162  * with sshd, bash, and top in OVERCOMMIT_GUESS. Smaller systems will
2163  * only reserve 3% of free pages by default.
2164  */
2165 static int __meminit init_admin_reserve(void)
2166 {
2167         unsigned long free_kbytes;
2168 
2169         free_kbytes = global_page_state(NR_FREE_PAGES) << (PAGE_SHIFT - 10);
2170 
2171         sysctl_admin_reserve_kbytes = min(free_kbytes / 32, 1UL << 13);
2172         return 0;
2173 }
2174 module_init(init_admin_reserve)
2175 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp