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).
7 * See Documentation/nommu-mmap.txt
9 * Copyright (c) 2004-2005 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>
16 #include <linux/mman.h>
17 #include <linux/swap.h>
18 #include <linux/file.h>
19 #include <linux/highmem.h>
20 #include <linux/pagemap.h>
21 #include <linux/slab.h>
22 #include <linux/vmalloc.h>
23 #include <linux/ptrace.h>
24 #include <linux/blkdev.h>
25 #include <linux/backing-dev.h>
26 #include <linux/mount.h>
27 #include <linux/personality.h>
28 #include <linux/security.h>
29 #include <linux/syscalls.h>
31 #include <asm/uaccess.h>
33 #include <asm/tlbflush.h>
37 unsigned long max_mapnr
;
38 unsigned long num_physpages
;
39 unsigned long askedalloc
, realalloc
;
40 atomic_t vm_committed_space
= ATOMIC_INIT(0);
41 int sysctl_overcommit_memory
= OVERCOMMIT_GUESS
; /* heuristic overcommit */
42 int sysctl_overcommit_ratio
= 50; /* default is 50% */
43 int sysctl_max_map_count
= DEFAULT_MAX_MAP_COUNT
;
44 int heap_stack_gap
= 0;
46 EXPORT_SYMBOL(mem_map
);
47 EXPORT_SYMBOL(sysctl_max_map_count
);
48 EXPORT_SYMBOL(sysctl_overcommit_memory
);
49 EXPORT_SYMBOL(sysctl_overcommit_ratio
);
50 EXPORT_SYMBOL(vm_committed_space
);
51 EXPORT_SYMBOL(__vm_enough_memory
);
53 /* list of shareable VMAs */
54 struct rb_root nommu_vma_tree
= RB_ROOT
;
55 DECLARE_RWSEM(nommu_vma_sem
);
57 struct vm_operations_struct generic_file_vm_ops
= {
60 EXPORT_SYMBOL(vmalloc
);
62 EXPORT_SYMBOL(vmalloc_to_page
);
63 EXPORT_SYMBOL(vmalloc_32
);
66 * Handle all mappings that got truncated by a "truncate()"
69 * NOTE! We have to be ready to update the memory sharing
70 * between the file and the memory map for a potential last
71 * incomplete page. Ugly, but necessary.
73 int vmtruncate(struct inode
*inode
, loff_t offset
)
75 struct address_space
*mapping
= inode
->i_mapping
;
78 if (inode
->i_size
< offset
)
80 i_size_write(inode
, offset
);
82 truncate_inode_pages(mapping
, offset
);
86 limit
= current
->signal
->rlim
[RLIMIT_FSIZE
].rlim_cur
;
87 if (limit
!= RLIM_INFINITY
&& offset
> limit
)
89 if (offset
> inode
->i_sb
->s_maxbytes
)
91 i_size_write(inode
, offset
);
94 if (inode
->i_op
&& inode
->i_op
->truncate
)
95 inode
->i_op
->truncate(inode
);
98 send_sig(SIGXFSZ
, current
, 0);
103 EXPORT_SYMBOL(vmtruncate
);
106 * Return the total memory allocated for this pointer, not
107 * just what the caller asked for.
109 * Doesn't have to be accurate, i.e. may have races.
111 unsigned int kobjsize(const void *objp
)
115 if (!objp
|| !((page
= virt_to_page(objp
))))
121 BUG_ON(page
->index
< 0);
122 BUG_ON(page
->index
>= MAX_ORDER
);
124 return (PAGE_SIZE
<< page
->index
);
128 * The nommu dodgy version :-)
130 int get_user_pages(struct task_struct
*tsk
, struct mm_struct
*mm
,
131 unsigned long start
, int len
, int write
, int force
,
132 struct page
**pages
, struct vm_area_struct
**vmas
)
135 static struct vm_area_struct dummy_vma
;
137 for (i
= 0; i
< len
; i
++) {
139 pages
[i
] = virt_to_page(start
);
141 page_cache_get(pages
[i
]);
144 vmas
[i
] = &dummy_vma
;
150 EXPORT_SYMBOL(get_user_pages
);
152 DEFINE_RWLOCK(vmlist_lock
);
153 struct vm_struct
*vmlist
;
155 void vfree(void *addr
)
160 void *__vmalloc(unsigned long size
, unsigned int __nocast gfp_mask
,
164 * kmalloc doesn't like __GFP_HIGHMEM for some reason
166 return kmalloc(size
, gfp_mask
& ~__GFP_HIGHMEM
);
169 struct page
* vmalloc_to_page(void *addr
)
171 return virt_to_page(addr
);
174 unsigned long vmalloc_to_pfn(void *addr
)
176 return page_to_pfn(virt_to_page(addr
));
180 long vread(char *buf
, char *addr
, unsigned long count
)
182 memcpy(buf
, addr
, count
);
186 long vwrite(char *buf
, char *addr
, unsigned long count
)
188 /* Don't allow overflow */
189 if ((unsigned long) addr
+ count
< count
)
190 count
= -(unsigned long) addr
;
192 memcpy(addr
, buf
, count
);
197 * vmalloc - allocate virtually continguos memory
199 * @size: allocation size
201 * Allocate enough pages to cover @size from the page level
202 * allocator and map them into continguos kernel virtual space.
204 * For tight cotrol over page level allocator and protection flags
205 * use __vmalloc() instead.
207 void *vmalloc(unsigned long size
)
209 return __vmalloc(size
, GFP_KERNEL
| __GFP_HIGHMEM
, PAGE_KERNEL
);
213 * vmalloc_32 - allocate virtually continguos memory (32bit addressable)
215 * @size: allocation size
217 * Allocate enough 32bit PA addressable pages to cover @size from the
218 * page level allocator and map them into continguos kernel virtual space.
220 void *vmalloc_32(unsigned long size
)
222 return __vmalloc(size
, GFP_KERNEL
, PAGE_KERNEL
);
225 void *vmap(struct page
**pages
, unsigned int count
, unsigned long flags
, pgprot_t prot
)
231 void vunmap(void *addr
)
237 * sys_brk() for the most part doesn't need the global kernel
238 * lock, except when an application is doing something nasty
239 * like trying to un-brk an area that has already been mapped
240 * to a regular file. in this case, the unmapping will need
241 * to invoke file system routines that need the global lock.
243 asmlinkage
unsigned long sys_brk(unsigned long brk
)
245 struct mm_struct
*mm
= current
->mm
;
247 if (brk
< mm
->start_brk
|| brk
> mm
->context
.end_brk
)
254 * Always allow shrinking brk
256 if (brk
<= mm
->brk
) {
262 * Ok, looks good - let it rip.
264 return mm
->brk
= brk
;
268 static void show_process_blocks(void)
270 struct vm_list_struct
*vml
;
272 printk("Process blocks %d:", current
->pid
);
274 for (vml
= ¤t
->mm
->context
.vmlist
; vml
; vml
= vml
->next
) {
275 printk(" %p: %p", vml
, vml
->vma
);
277 printk(" (%d @%lx #%d)",
278 kobjsize((void *) vml
->vma
->vm_start
),
280 atomic_read(&vml
->vma
->vm_usage
));
281 printk(vml
->next
? " ->" : ".\n");
286 static inline struct vm_area_struct
*find_nommu_vma(unsigned long start
)
288 struct vm_area_struct
*vma
;
289 struct rb_node
*n
= nommu_vma_tree
.rb_node
;
292 vma
= rb_entry(n
, struct vm_area_struct
, vm_rb
);
294 if (start
< vma
->vm_start
)
296 else if (start
> vma
->vm_start
)
305 static void add_nommu_vma(struct vm_area_struct
*vma
)
307 struct vm_area_struct
*pvma
;
308 struct address_space
*mapping
;
309 struct rb_node
**p
= &nommu_vma_tree
.rb_node
;
310 struct rb_node
*parent
= NULL
;
312 /* add the VMA to the mapping */
314 mapping
= vma
->vm_file
->f_mapping
;
316 flush_dcache_mmap_lock(mapping
);
317 vma_prio_tree_insert(vma
, &mapping
->i_mmap
);
318 flush_dcache_mmap_unlock(mapping
);
321 /* add the VMA to the master list */
324 pvma
= rb_entry(parent
, struct vm_area_struct
, vm_rb
);
326 if (vma
->vm_start
< pvma
->vm_start
) {
329 else if (vma
->vm_start
> pvma
->vm_start
) {
333 /* mappings are at the same address - this can only
334 * happen for shared-mem chardevs and shared file
335 * mappings backed by ramfs/tmpfs */
336 BUG_ON(!(pvma
->vm_flags
& VM_SHARED
));
347 rb_link_node(&vma
->vm_rb
, parent
, p
);
348 rb_insert_color(&vma
->vm_rb
, &nommu_vma_tree
);
351 static void delete_nommu_vma(struct vm_area_struct
*vma
)
353 struct address_space
*mapping
;
355 /* remove the VMA from the mapping */
357 mapping
= vma
->vm_file
->f_mapping
;
359 flush_dcache_mmap_lock(mapping
);
360 vma_prio_tree_remove(vma
, &mapping
->i_mmap
);
361 flush_dcache_mmap_unlock(mapping
);
364 /* remove from the master list */
365 rb_erase(&vma
->vm_rb
, &nommu_vma_tree
);
369 * determine whether a mapping should be permitted and, if so, what sort of
370 * mapping we're capable of supporting
372 static int validate_mmap_request(struct file
*file
,
378 unsigned long *_capabilities
)
380 unsigned long capabilities
;
381 unsigned long reqprot
= prot
;
384 /* do the simple checks first */
385 if (flags
& MAP_FIXED
|| addr
) {
387 "%d: Can't do fixed-address/overlay mmap of RAM\n",
392 if ((flags
& MAP_TYPE
) != MAP_PRIVATE
&&
393 (flags
& MAP_TYPE
) != MAP_SHARED
)
396 if (PAGE_ALIGN(len
) == 0)
402 /* offset overflow? */
403 if ((pgoff
+ (len
>> PAGE_SHIFT
)) < pgoff
)
407 /* validate file mapping requests */
408 struct address_space
*mapping
;
410 /* files must support mmap */
411 if (!file
->f_op
|| !file
->f_op
->mmap
)
414 /* work out if what we've got could possibly be shared
415 * - we support chardevs that provide their own "memory"
416 * - we support files/blockdevs that are memory backed
418 mapping
= file
->f_mapping
;
420 mapping
= file
->f_dentry
->d_inode
->i_mapping
;
423 if (mapping
&& mapping
->backing_dev_info
)
424 capabilities
= mapping
->backing_dev_info
->capabilities
;
427 /* no explicit capabilities set, so assume some
429 switch (file
->f_dentry
->d_inode
->i_mode
& S_IFMT
) {
432 capabilities
= BDI_CAP_MAP_COPY
;
447 /* eliminate any capabilities that we can't support on this
449 if (!file
->f_op
->get_unmapped_area
)
450 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
451 if (!file
->f_op
->read
)
452 capabilities
&= ~BDI_CAP_MAP_COPY
;
454 if (flags
& MAP_SHARED
) {
455 /* do checks for writing, appending and locking */
456 if ((prot
& PROT_WRITE
) &&
457 !(file
->f_mode
& FMODE_WRITE
))
460 if (IS_APPEND(file
->f_dentry
->d_inode
) &&
461 (file
->f_mode
& FMODE_WRITE
))
464 if (locks_verify_locked(file
->f_dentry
->d_inode
))
467 if (!(capabilities
& BDI_CAP_MAP_DIRECT
))
470 if (((prot
& PROT_READ
) && !(capabilities
& BDI_CAP_READ_MAP
)) ||
471 ((prot
& PROT_WRITE
) && !(capabilities
& BDI_CAP_WRITE_MAP
)) ||
472 ((prot
& PROT_EXEC
) && !(capabilities
& BDI_CAP_EXEC_MAP
))
474 printk("MAP_SHARED not completely supported on !MMU\n");
478 /* we mustn't privatise shared mappings */
479 capabilities
&= ~BDI_CAP_MAP_COPY
;
482 /* we're going to read the file into private memory we
484 if (!(capabilities
& BDI_CAP_MAP_COPY
))
487 /* we don't permit a private writable mapping to be
488 * shared with the backing device */
489 if (prot
& PROT_WRITE
)
490 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
493 /* handle executable mappings and implied executable
495 if (file
->f_vfsmnt
->mnt_flags
& MNT_NOEXEC
) {
496 if (prot
& PROT_EXEC
)
499 else if ((prot
& PROT_READ
) && !(prot
& PROT_EXEC
)) {
500 /* handle implication of PROT_EXEC by PROT_READ */
501 if (current
->personality
& READ_IMPLIES_EXEC
) {
502 if (capabilities
& BDI_CAP_EXEC_MAP
)
506 else if ((prot
& PROT_READ
) &&
507 (prot
& PROT_EXEC
) &&
508 !(capabilities
& BDI_CAP_EXEC_MAP
)
510 /* backing file is not executable, try to copy */
511 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
515 /* anonymous mappings are always memory backed and can be
518 capabilities
= BDI_CAP_MAP_COPY
;
520 /* handle PROT_EXEC implication by PROT_READ */
521 if ((prot
& PROT_READ
) &&
522 (current
->personality
& READ_IMPLIES_EXEC
))
526 /* allow the security API to have its say */
527 ret
= security_file_mmap(file
, reqprot
, prot
, flags
);
532 *_capabilities
= capabilities
;
537 * we've determined that we can make the mapping, now translate what we
538 * now know into VMA flags
540 static unsigned long determine_vm_flags(struct file
*file
,
543 unsigned long capabilities
)
545 unsigned long vm_flags
;
547 vm_flags
= calc_vm_prot_bits(prot
) | calc_vm_flag_bits(flags
);
548 vm_flags
|= VM_MAYREAD
| VM_MAYWRITE
| VM_MAYEXEC
;
549 /* vm_flags |= mm->def_flags; */
551 if (!(capabilities
& BDI_CAP_MAP_DIRECT
)) {
552 /* attempt to share read-only copies of mapped file chunks */
553 if (file
&& !(prot
& PROT_WRITE
))
554 vm_flags
|= VM_MAYSHARE
;
557 /* overlay a shareable mapping on the backing device or inode
558 * if possible - used for chardevs, ramfs/tmpfs/shmfs and
560 if (flags
& MAP_SHARED
)
561 vm_flags
|= VM_MAYSHARE
| VM_SHARED
;
562 else if ((((vm_flags
& capabilities
) ^ vm_flags
) & BDI_CAP_VMFLAGS
) == 0)
563 vm_flags
|= VM_MAYSHARE
;
566 /* refuse to let anyone share private mappings with this process if
567 * it's being traced - otherwise breakpoints set in it may interfere
568 * with another untraced process
570 if ((flags
& MAP_PRIVATE
) && (current
->ptrace
& PT_PTRACED
))
571 vm_flags
&= ~VM_MAYSHARE
;
577 * set up a shared mapping on a file
579 static int do_mmap_shared_file(struct vm_area_struct
*vma
, unsigned long len
)
583 ret
= vma
->vm_file
->f_op
->mmap(vma
->vm_file
, vma
);
587 /* getting an ENOSYS error indicates that direct mmap isn't
588 * possible (as opposed to tried but failed) so we'll fall
589 * through to making a private copy of the data and mapping
595 * set up a private mapping or an anonymous shared mapping
597 static int do_mmap_private(struct vm_area_struct
*vma
, unsigned long len
)
602 /* invoke the file's mapping function so that it can keep track of
603 * shared mappings on devices or memory
604 * - VM_MAYSHARE will be set if it may attempt to share
607 ret
= vma
->vm_file
->f_op
->mmap(vma
->vm_file
, vma
);
608 if (ret
!= -ENOSYS
) {
609 /* shouldn't return success if we're not sharing */
610 BUG_ON(ret
== 0 && !(vma
->vm_flags
& VM_MAYSHARE
));
611 return ret
; /* success or a real error */
614 /* getting an ENOSYS error indicates that direct mmap isn't
615 * possible (as opposed to tried but failed) so we'll try to
616 * make a private copy of the data and map that instead */
619 /* allocate some memory to hold the mapping
620 * - note that this may not return a page-aligned address if the object
621 * we're allocating is smaller than a page
623 base
= kmalloc(len
, GFP_KERNEL
);
627 vma
->vm_start
= (unsigned long) base
;
628 vma
->vm_end
= vma
->vm_start
+ len
;
629 vma
->vm_flags
|= VM_MAPPED_COPY
;
632 if (len
+ WARN_ON_SLACK
<= kobjsize(result
))
633 printk("Allocation of %lu bytes from process %d has %lu bytes of slack\n",
634 len
, current
->pid
, kobjsize(result
) - len
);
638 /* read the contents of a file into the copy */
642 fpos
= vma
->vm_pgoff
;
647 ret
= vma
->vm_file
->f_op
->read(vma
->vm_file
, base
, len
, &fpos
);
653 /* clear the last little bit */
655 memset(base
+ ret
, 0, len
- ret
);
658 /* if it's an anonymous mapping, then just clear it */
659 memset(base
, 0, len
);
670 printk("Allocation of length %lu from process %d failed\n",
677 * handle mapping creation for uClinux
679 unsigned long do_mmap_pgoff(struct file
*file
,
686 struct vm_list_struct
*vml
= NULL
;
687 struct vm_area_struct
*vma
= NULL
;
689 unsigned long capabilities
, vm_flags
;
693 /* decide whether we should attempt the mapping, and if so what sort of
695 ret
= validate_mmap_request(file
, addr
, len
, prot
, flags
, pgoff
,
700 /* we've determined that we can make the mapping, now translate what we
701 * now know into VMA flags */
702 vm_flags
= determine_vm_flags(file
, prot
, flags
, capabilities
);
704 /* we're going to need to record the mapping if it works */
705 vml
= kmalloc(sizeof(struct vm_list_struct
), GFP_KERNEL
);
707 goto error_getting_vml
;
708 memset(vml
, 0, sizeof(*vml
));
710 down_write(&nommu_vma_sem
);
712 /* if we want to share, we need to check for VMAs created by other
713 * mmap() calls that overlap with our proposed mapping
714 * - we can only share with an exact match on most regular files
715 * - shared mappings on character devices and memory backed files are
716 * permitted to overlap inexactly as far as we are concerned for in
717 * these cases, sharing is handled in the driver or filesystem rather
720 if (vm_flags
& VM_MAYSHARE
) {
721 unsigned long pglen
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
722 unsigned long vmpglen
;
724 for (rb
= rb_first(&nommu_vma_tree
); rb
; rb
= rb_next(rb
)) {
725 vma
= rb_entry(rb
, struct vm_area_struct
, vm_rb
);
727 if (!(vma
->vm_flags
& VM_MAYSHARE
))
730 /* search for overlapping mappings on the same file */
731 if (vma
->vm_file
->f_dentry
->d_inode
!= file
->f_dentry
->d_inode
)
734 if (vma
->vm_pgoff
>= pgoff
+ pglen
)
737 vmpglen
= vma
->vm_end
- vma
->vm_start
+ PAGE_SIZE
- 1;
738 vmpglen
>>= PAGE_SHIFT
;
739 if (pgoff
>= vma
->vm_pgoff
+ vmpglen
)
742 /* handle inexactly overlapping matches between mappings */
743 if (vma
->vm_pgoff
!= pgoff
|| vmpglen
!= pglen
) {
744 if (!(capabilities
& BDI_CAP_MAP_DIRECT
))
745 goto sharing_violation
;
749 /* we've found a VMA we can share */
750 atomic_inc(&vma
->vm_usage
);
753 result
= (void *) vma
->vm_start
;
759 /* obtain the address at which to make a shared mapping
760 * - this is the hook for quasi-memory character devices to
761 * tell us the location of a shared mapping
763 if (file
&& file
->f_op
->get_unmapped_area
) {
764 addr
= file
->f_op
->get_unmapped_area(file
, addr
, len
,
766 if (IS_ERR((void *) addr
)) {
768 if (ret
!= (unsigned long) -ENOSYS
)
771 /* the driver refused to tell us where to site
772 * the mapping so we'll have to attempt to copy
774 ret
= (unsigned long) -ENODEV
;
775 if (!(capabilities
& BDI_CAP_MAP_COPY
))
778 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
783 /* we're going to need a VMA struct as well */
784 vma
= kmalloc(sizeof(struct vm_area_struct
), GFP_KERNEL
);
786 goto error_getting_vma
;
788 memset(vma
, 0, sizeof(*vma
));
789 INIT_LIST_HEAD(&vma
->anon_vma_node
);
790 atomic_set(&vma
->vm_usage
, 1);
794 vma
->vm_flags
= vm_flags
;
795 vma
->vm_start
= addr
;
796 vma
->vm_end
= addr
+ len
;
797 vma
->vm_pgoff
= pgoff
;
801 /* set up the mapping */
802 if (file
&& vma
->vm_flags
& VM_SHARED
)
803 ret
= do_mmap_shared_file(vma
, len
);
805 ret
= do_mmap_private(vma
, len
);
809 /* okay... we have a mapping; now we have to register it */
810 result
= (void *) vma
->vm_start
;
812 if (vma
->vm_flags
& VM_MAPPED_COPY
) {
813 realalloc
+= kobjsize(result
);
817 realalloc
+= kobjsize(vma
);
818 askedalloc
+= sizeof(*vma
);
820 current
->mm
->total_vm
+= len
>> PAGE_SHIFT
;
825 realalloc
+= kobjsize(vml
);
826 askedalloc
+= sizeof(*vml
);
828 vml
->next
= current
->mm
->context
.vmlist
;
829 current
->mm
->context
.vmlist
= vml
;
831 up_write(&nommu_vma_sem
);
833 if (prot
& PROT_EXEC
)
834 flush_icache_range((unsigned long) result
,
835 (unsigned long) result
+ len
);
838 printk("do_mmap:\n");
839 show_process_blocks();
842 return (unsigned long) result
;
845 up_write(&nommu_vma_sem
);
854 up_write(&nommu_vma_sem
);
855 printk("Attempt to share mismatched mappings\n");
860 up_write(&nommu_vma_sem
);
862 printk("Allocation of vma for %lu byte allocation from process %d failed\n",
868 printk("Allocation of vml for %lu byte allocation from process %d failed\n",
875 * handle mapping disposal for uClinux
877 static void put_vma(struct vm_area_struct
*vma
)
880 down_write(&nommu_vma_sem
);
882 if (atomic_dec_and_test(&vma
->vm_usage
)) {
883 delete_nommu_vma(vma
);
885 if (vma
->vm_ops
&& vma
->vm_ops
->close
)
886 vma
->vm_ops
->close(vma
);
888 /* IO memory and memory shared directly out of the pagecache from
889 * ramfs/tmpfs mustn't be released here */
890 if (vma
->vm_flags
& VM_MAPPED_COPY
) {
891 realalloc
-= kobjsize((void *) vma
->vm_start
);
892 askedalloc
-= vma
->vm_end
- vma
->vm_start
;
893 kfree((void *) vma
->vm_start
);
896 realalloc
-= kobjsize(vma
);
897 askedalloc
-= sizeof(*vma
);
904 up_write(&nommu_vma_sem
);
908 int do_munmap(struct mm_struct
*mm
, unsigned long addr
, size_t len
)
910 struct vm_list_struct
*vml
, **parent
;
911 unsigned long end
= addr
+ len
;
914 printk("do_munmap:\n");
917 for (parent
= &mm
->context
.vmlist
; *parent
; parent
= &(*parent
)->next
)
918 if ((*parent
)->vma
->vm_start
== addr
&&
919 ((len
== 0) || ((*parent
)->vma
->vm_end
== end
)))
922 printk("munmap of non-mmaped memory by process %d (%s): %p\n",
923 current
->pid
, current
->comm
, (void *) addr
);
932 realalloc
-= kobjsize(vml
);
933 askedalloc
-= sizeof(*vml
);
935 mm
->total_vm
-= len
>> PAGE_SHIFT
;
938 show_process_blocks();
944 /* Release all mmaps. */
945 void exit_mmap(struct mm_struct
* mm
)
947 struct vm_list_struct
*tmp
;
951 printk("Exit_mmap:\n");
956 while ((tmp
= mm
->context
.vmlist
)) {
957 mm
->context
.vmlist
= tmp
->next
;
960 realalloc
-= kobjsize(tmp
);
961 askedalloc
-= sizeof(*tmp
);
966 show_process_blocks();
971 asmlinkage
long sys_munmap(unsigned long addr
, size_t len
)
974 struct mm_struct
*mm
= current
->mm
;
976 down_write(&mm
->mmap_sem
);
977 ret
= do_munmap(mm
, addr
, len
);
978 up_write(&mm
->mmap_sem
);
982 unsigned long do_brk(unsigned long addr
, unsigned long len
)
988 * Expand (or shrink) an existing mapping, potentially moving it at the
989 * same time (controlled by the MREMAP_MAYMOVE flag and available VM space)
991 * MREMAP_FIXED option added 5-Dec-1999 by Benjamin LaHaise
992 * This option implies MREMAP_MAYMOVE.
994 * on uClinux, we only permit changing a mapping's size, and only as long as it stays within the
995 * hole allocated by the kmalloc() call in do_mmap_pgoff() and the block is not shareable
997 unsigned long do_mremap(unsigned long addr
,
998 unsigned long old_len
, unsigned long new_len
,
999 unsigned long flags
, unsigned long new_addr
)
1001 struct vm_list_struct
*vml
= NULL
;
1003 /* insanity checks first */
1005 return (unsigned long) -EINVAL
;
1007 if (flags
& MREMAP_FIXED
&& new_addr
!= addr
)
1008 return (unsigned long) -EINVAL
;
1010 for (vml
= current
->mm
->context
.vmlist
; vml
; vml
= vml
->next
)
1011 if (vml
->vma
->vm_start
== addr
)
1014 return (unsigned long) -EINVAL
;
1017 if (vml
->vma
->vm_end
!= vml
->vma
->vm_start
+ old_len
)
1018 return (unsigned long) -EFAULT
;
1020 if (vml
->vma
->vm_flags
& VM_MAYSHARE
)
1021 return (unsigned long) -EPERM
;
1023 if (new_len
> kobjsize((void *) addr
))
1024 return (unsigned long) -ENOMEM
;
1026 /* all checks complete - do it */
1027 vml
->vma
->vm_end
= vml
->vma
->vm_start
+ new_len
;
1029 askedalloc
-= old_len
;
1030 askedalloc
+= new_len
;
1032 return vml
->vma
->vm_start
;
1036 * Look up the first VMA which satisfies addr < vm_end, NULL if none
1038 struct vm_area_struct
*find_vma(struct mm_struct
*mm
, unsigned long addr
)
1040 struct vm_list_struct
*vml
;
1042 for (vml
= mm
->context
.vmlist
; vml
; vml
= vml
->next
)
1043 if (addr
>= vml
->vma
->vm_start
&& addr
< vml
->vma
->vm_end
)
1049 EXPORT_SYMBOL(find_vma
);
1051 struct page
* follow_page(struct mm_struct
*mm
, unsigned long addr
, int write
)
1056 struct vm_area_struct
*find_extend_vma(struct mm_struct
*mm
, unsigned long addr
)
1061 int remap_pfn_range(struct vm_area_struct
*vma
, unsigned long from
,
1062 unsigned long to
, unsigned long size
, pgprot_t prot
)
1064 vma
->vm_start
= vma
->vm_pgoff
<< PAGE_SHIFT
;
1068 void swap_unplug_io_fn(struct backing_dev_info
*bdi
, struct page
*page
)
1072 unsigned long arch_get_unmapped_area(struct file
*file
, unsigned long addr
,
1073 unsigned long len
, unsigned long pgoff
, unsigned long flags
)
1078 void arch_unmap_area(struct mm_struct
*mm
, unsigned long addr
)
1082 void update_mem_hiwater(struct task_struct
*tsk
)
1086 if (likely(tsk
->mm
)) {
1087 rss
= get_mm_counter(tsk
->mm
, rss
);
1088 if (tsk
->mm
->hiwater_rss
< rss
)
1089 tsk
->mm
->hiwater_rss
= rss
;
1090 if (tsk
->mm
->hiwater_vm
< tsk
->mm
->total_vm
)
1091 tsk
->mm
->hiwater_vm
= tsk
->mm
->total_vm
;
1095 void unmap_mapping_range(struct address_space
*mapping
,
1096 loff_t
const holebegin
, loff_t
const holelen
,
1102 * Check that a process has enough memory to allocate a new virtual
1103 * mapping. 0 means there is enough memory for the allocation to
1104 * succeed and -ENOMEM implies there is not.
1106 * We currently support three overcommit policies, which are set via the
1107 * vm.overcommit_memory sysctl. See Documentation/vm/overcommit-accounting
1109 * Strict overcommit modes added 2002 Feb 26 by Alan Cox.
1110 * Additional code 2002 Jul 20 by Robert Love.
1112 * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise.
1114 * Note this is a helper function intended to be used by LSMs which
1115 * wish to use this logic.
1117 int __vm_enough_memory(long pages
, int cap_sys_admin
)
1119 unsigned long free
, allowed
;
1121 vm_acct_memory(pages
);
1124 * Sometimes we want to use more memory than we have
1126 if (sysctl_overcommit_memory
== OVERCOMMIT_ALWAYS
)
1129 if (sysctl_overcommit_memory
== OVERCOMMIT_GUESS
) {
1132 free
= get_page_cache_size();
1133 free
+= nr_swap_pages
;
1136 * Any slabs which are created with the
1137 * SLAB_RECLAIM_ACCOUNT flag claim to have contents
1138 * which are reclaimable, under pressure. The dentry
1139 * cache and most inode caches should fall into this
1141 free
+= atomic_read(&slab_reclaim_pages
);
1144 * Leave the last 3% for root
1153 * nr_free_pages() is very expensive on large systems,
1154 * only call if we're about to fail.
1156 n
= nr_free_pages();
1163 vm_unacct_memory(pages
);
1167 allowed
= totalram_pages
* sysctl_overcommit_ratio
/ 100;
1169 * Leave the last 3% for root
1172 allowed
-= allowed
/ 32;
1173 allowed
+= total_swap_pages
;
1175 /* Don't let a single process grow too big:
1176 leave 3% of the size of this process for other processes */
1177 allowed
-= current
->mm
->total_vm
/ 32;
1180 * cast `allowed' as a signed long because vm_committed_space
1181 * sometimes has a negative value
1183 if (atomic_read(&vm_committed_space
) < (long)allowed
)
1186 vm_unacct_memory(pages
);
1191 int in_gate_area_no_task(unsigned long addr
)