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(__vm_enough_memory
);
49 /* list of shareable VMAs */
50 struct rb_root nommu_vma_tree
= RB_ROOT
;
51 DECLARE_RWSEM(nommu_vma_sem
);
53 struct vm_operations_struct generic_file_vm_ops
= {
57 EXPORT_SYMBOL(vmalloc_to_page
);
58 EXPORT_SYMBOL(vmalloc_32
);
60 EXPORT_SYMBOL(vunmap
);
63 * Handle all mappings that got truncated by a "truncate()"
66 * NOTE! We have to be ready to update the memory sharing
67 * between the file and the memory map for a potential last
68 * incomplete page. Ugly, but necessary.
70 int vmtruncate(struct inode
*inode
, loff_t offset
)
72 struct address_space
*mapping
= inode
->i_mapping
;
75 if (inode
->i_size
< offset
)
77 i_size_write(inode
, offset
);
79 truncate_inode_pages(mapping
, offset
);
83 limit
= current
->signal
->rlim
[RLIMIT_FSIZE
].rlim_cur
;
84 if (limit
!= RLIM_INFINITY
&& offset
> limit
)
86 if (offset
> inode
->i_sb
->s_maxbytes
)
88 i_size_write(inode
, offset
);
91 if (inode
->i_op
&& inode
->i_op
->truncate
)
92 inode
->i_op
->truncate(inode
);
95 send_sig(SIGXFSZ
, current
, 0);
100 EXPORT_SYMBOL(vmtruncate
);
103 * Return the total memory allocated for this pointer, not
104 * just what the caller asked for.
106 * Doesn't have to be accurate, i.e. may have races.
108 unsigned int kobjsize(const void *objp
)
112 if (!objp
|| !((page
= virt_to_page(objp
))))
118 BUG_ON(page
->index
< 0);
119 BUG_ON(page
->index
>= MAX_ORDER
);
121 return (PAGE_SIZE
<< page
->index
);
125 * The nommu dodgy version :-)
127 int get_user_pages(struct task_struct
*tsk
, struct mm_struct
*mm
,
128 unsigned long start
, int len
, int write
, int force
,
129 struct page
**pages
, struct vm_area_struct
**vmas
)
132 struct vm_area_struct
*vma
;
134 for (i
= 0; i
< len
; i
++) {
135 vma
= find_vma(mm
, start
);
137 return i
? : -EFAULT
;
140 pages
[i
] = virt_to_page(start
);
142 page_cache_get(pages
[i
]);
151 EXPORT_SYMBOL(get_user_pages
);
153 DEFINE_RWLOCK(vmlist_lock
);
154 struct vm_struct
*vmlist
;
156 void vfree(void *addr
)
161 void *__vmalloc(unsigned long size
, gfp_t gfp_mask
, pgprot_t prot
)
164 * kmalloc doesn't like __GFP_HIGHMEM for some reason
166 return kmalloc(size
, (gfp_mask
| __GFP_COMP
) & ~__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
);
211 EXPORT_SYMBOL(vmalloc
);
213 void *vmalloc_node(unsigned long size
, int node
)
215 return vmalloc(size
);
217 EXPORT_SYMBOL(vmalloc_node
);
220 * vmalloc_32 - allocate virtually continguos memory (32bit addressable)
222 * @size: allocation size
224 * Allocate enough 32bit PA addressable pages to cover @size from the
225 * page level allocator and map them into continguos kernel virtual space.
227 void *vmalloc_32(unsigned long size
)
229 return __vmalloc(size
, GFP_KERNEL
, PAGE_KERNEL
);
232 void *vmap(struct page
**pages
, unsigned int count
, unsigned long flags
, pgprot_t prot
)
238 void vunmap(void *addr
)
244 * sys_brk() for the most part doesn't need the global kernel
245 * lock, except when an application is doing something nasty
246 * like trying to un-brk an area that has already been mapped
247 * to a regular file. in this case, the unmapping will need
248 * to invoke file system routines that need the global lock.
250 asmlinkage
unsigned long sys_brk(unsigned long brk
)
252 struct mm_struct
*mm
= current
->mm
;
254 if (brk
< mm
->start_brk
|| brk
> mm
->context
.end_brk
)
261 * Always allow shrinking brk
263 if (brk
<= mm
->brk
) {
269 * Ok, looks good - let it rip.
271 return mm
->brk
= brk
;
275 static void show_process_blocks(void)
277 struct vm_list_struct
*vml
;
279 printk("Process blocks %d:", current
->pid
);
281 for (vml
= ¤t
->mm
->context
.vmlist
; vml
; vml
= vml
->next
) {
282 printk(" %p: %p", vml
, vml
->vma
);
284 printk(" (%d @%lx #%d)",
285 kobjsize((void *) vml
->vma
->vm_start
),
287 atomic_read(&vml
->vma
->vm_usage
));
288 printk(vml
->next
? " ->" : ".\n");
293 static inline struct vm_area_struct
*find_nommu_vma(unsigned long start
)
295 struct vm_area_struct
*vma
;
296 struct rb_node
*n
= nommu_vma_tree
.rb_node
;
299 vma
= rb_entry(n
, struct vm_area_struct
, vm_rb
);
301 if (start
< vma
->vm_start
)
303 else if (start
> vma
->vm_start
)
312 static void add_nommu_vma(struct vm_area_struct
*vma
)
314 struct vm_area_struct
*pvma
;
315 struct address_space
*mapping
;
316 struct rb_node
**p
= &nommu_vma_tree
.rb_node
;
317 struct rb_node
*parent
= NULL
;
319 /* add the VMA to the mapping */
321 mapping
= vma
->vm_file
->f_mapping
;
323 flush_dcache_mmap_lock(mapping
);
324 vma_prio_tree_insert(vma
, &mapping
->i_mmap
);
325 flush_dcache_mmap_unlock(mapping
);
328 /* add the VMA to the master list */
331 pvma
= rb_entry(parent
, struct vm_area_struct
, vm_rb
);
333 if (vma
->vm_start
< pvma
->vm_start
) {
336 else if (vma
->vm_start
> pvma
->vm_start
) {
340 /* mappings are at the same address - this can only
341 * happen for shared-mem chardevs and shared file
342 * mappings backed by ramfs/tmpfs */
343 BUG_ON(!(pvma
->vm_flags
& VM_SHARED
));
354 rb_link_node(&vma
->vm_rb
, parent
, p
);
355 rb_insert_color(&vma
->vm_rb
, &nommu_vma_tree
);
358 static void delete_nommu_vma(struct vm_area_struct
*vma
)
360 struct address_space
*mapping
;
362 /* remove the VMA from the mapping */
364 mapping
= vma
->vm_file
->f_mapping
;
366 flush_dcache_mmap_lock(mapping
);
367 vma_prio_tree_remove(vma
, &mapping
->i_mmap
);
368 flush_dcache_mmap_unlock(mapping
);
371 /* remove from the master list */
372 rb_erase(&vma
->vm_rb
, &nommu_vma_tree
);
376 * determine whether a mapping should be permitted and, if so, what sort of
377 * mapping we're capable of supporting
379 static int validate_mmap_request(struct file
*file
,
385 unsigned long *_capabilities
)
387 unsigned long capabilities
;
388 unsigned long reqprot
= prot
;
391 /* do the simple checks first */
392 if (flags
& MAP_FIXED
|| addr
) {
394 "%d: Can't do fixed-address/overlay mmap of RAM\n",
399 if ((flags
& MAP_TYPE
) != MAP_PRIVATE
&&
400 (flags
& MAP_TYPE
) != MAP_SHARED
)
403 if (PAGE_ALIGN(len
) == 0)
409 /* offset overflow? */
410 if ((pgoff
+ (len
>> PAGE_SHIFT
)) < pgoff
)
414 /* validate file mapping requests */
415 struct address_space
*mapping
;
417 /* files must support mmap */
418 if (!file
->f_op
|| !file
->f_op
->mmap
)
421 /* work out if what we've got could possibly be shared
422 * - we support chardevs that provide their own "memory"
423 * - we support files/blockdevs that are memory backed
425 mapping
= file
->f_mapping
;
427 mapping
= file
->f_dentry
->d_inode
->i_mapping
;
430 if (mapping
&& mapping
->backing_dev_info
)
431 capabilities
= mapping
->backing_dev_info
->capabilities
;
434 /* no explicit capabilities set, so assume some
436 switch (file
->f_dentry
->d_inode
->i_mode
& S_IFMT
) {
439 capabilities
= BDI_CAP_MAP_COPY
;
454 /* eliminate any capabilities that we can't support on this
456 if (!file
->f_op
->get_unmapped_area
)
457 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
458 if (!file
->f_op
->read
)
459 capabilities
&= ~BDI_CAP_MAP_COPY
;
461 if (flags
& MAP_SHARED
) {
462 /* do checks for writing, appending and locking */
463 if ((prot
& PROT_WRITE
) &&
464 !(file
->f_mode
& FMODE_WRITE
))
467 if (IS_APPEND(file
->f_dentry
->d_inode
) &&
468 (file
->f_mode
& FMODE_WRITE
))
471 if (locks_verify_locked(file
->f_dentry
->d_inode
))
474 if (!(capabilities
& BDI_CAP_MAP_DIRECT
))
477 if (((prot
& PROT_READ
) && !(capabilities
& BDI_CAP_READ_MAP
)) ||
478 ((prot
& PROT_WRITE
) && !(capabilities
& BDI_CAP_WRITE_MAP
)) ||
479 ((prot
& PROT_EXEC
) && !(capabilities
& BDI_CAP_EXEC_MAP
))
481 printk("MAP_SHARED not completely supported on !MMU\n");
485 /* we mustn't privatise shared mappings */
486 capabilities
&= ~BDI_CAP_MAP_COPY
;
489 /* we're going to read the file into private memory we
491 if (!(capabilities
& BDI_CAP_MAP_COPY
))
494 /* we don't permit a private writable mapping to be
495 * shared with the backing device */
496 if (prot
& PROT_WRITE
)
497 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
500 /* handle executable mappings and implied executable
502 if (file
->f_vfsmnt
->mnt_flags
& MNT_NOEXEC
) {
503 if (prot
& PROT_EXEC
)
506 else if ((prot
& PROT_READ
) && !(prot
& PROT_EXEC
)) {
507 /* handle implication of PROT_EXEC by PROT_READ */
508 if (current
->personality
& READ_IMPLIES_EXEC
) {
509 if (capabilities
& BDI_CAP_EXEC_MAP
)
513 else if ((prot
& PROT_READ
) &&
514 (prot
& PROT_EXEC
) &&
515 !(capabilities
& BDI_CAP_EXEC_MAP
)
517 /* backing file is not executable, try to copy */
518 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
522 /* anonymous mappings are always memory backed and can be
525 capabilities
= BDI_CAP_MAP_COPY
;
527 /* handle PROT_EXEC implication by PROT_READ */
528 if ((prot
& PROT_READ
) &&
529 (current
->personality
& READ_IMPLIES_EXEC
))
533 /* allow the security API to have its say */
534 ret
= security_file_mmap(file
, reqprot
, prot
, flags
);
539 *_capabilities
= capabilities
;
544 * we've determined that we can make the mapping, now translate what we
545 * now know into VMA flags
547 static unsigned long determine_vm_flags(struct file
*file
,
550 unsigned long capabilities
)
552 unsigned long vm_flags
;
554 vm_flags
= calc_vm_prot_bits(prot
) | calc_vm_flag_bits(flags
);
555 vm_flags
|= VM_MAYREAD
| VM_MAYWRITE
| VM_MAYEXEC
;
556 /* vm_flags |= mm->def_flags; */
558 if (!(capabilities
& BDI_CAP_MAP_DIRECT
)) {
559 /* attempt to share read-only copies of mapped file chunks */
560 if (file
&& !(prot
& PROT_WRITE
))
561 vm_flags
|= VM_MAYSHARE
;
564 /* overlay a shareable mapping on the backing device or inode
565 * if possible - used for chardevs, ramfs/tmpfs/shmfs and
567 if (flags
& MAP_SHARED
)
568 vm_flags
|= VM_MAYSHARE
| VM_SHARED
;
569 else if ((((vm_flags
& capabilities
) ^ vm_flags
) & BDI_CAP_VMFLAGS
) == 0)
570 vm_flags
|= VM_MAYSHARE
;
573 /* refuse to let anyone share private mappings with this process if
574 * it's being traced - otherwise breakpoints set in it may interfere
575 * with another untraced process
577 if ((flags
& MAP_PRIVATE
) && (current
->ptrace
& PT_PTRACED
))
578 vm_flags
&= ~VM_MAYSHARE
;
584 * set up a shared mapping on a file
586 static int do_mmap_shared_file(struct vm_area_struct
*vma
, unsigned long len
)
590 ret
= vma
->vm_file
->f_op
->mmap(vma
->vm_file
, vma
);
594 /* getting an ENOSYS error indicates that direct mmap isn't
595 * possible (as opposed to tried but failed) so we'll fall
596 * through to making a private copy of the data and mapping
602 * set up a private mapping or an anonymous shared mapping
604 static int do_mmap_private(struct vm_area_struct
*vma
, unsigned long len
)
609 /* invoke the file's mapping function so that it can keep track of
610 * shared mappings on devices or memory
611 * - VM_MAYSHARE will be set if it may attempt to share
614 ret
= vma
->vm_file
->f_op
->mmap(vma
->vm_file
, vma
);
615 if (ret
!= -ENOSYS
) {
616 /* shouldn't return success if we're not sharing */
617 BUG_ON(ret
== 0 && !(vma
->vm_flags
& VM_MAYSHARE
));
618 return ret
; /* success or a real error */
621 /* getting an ENOSYS error indicates that direct mmap isn't
622 * possible (as opposed to tried but failed) so we'll try to
623 * make a private copy of the data and map that instead */
626 /* allocate some memory to hold the mapping
627 * - note that this may not return a page-aligned address if the object
628 * we're allocating is smaller than a page
630 base
= kmalloc(len
, GFP_KERNEL
|__GFP_COMP
);
634 vma
->vm_start
= (unsigned long) base
;
635 vma
->vm_end
= vma
->vm_start
+ len
;
636 vma
->vm_flags
|= VM_MAPPED_COPY
;
639 if (len
+ WARN_ON_SLACK
<= kobjsize(result
))
640 printk("Allocation of %lu bytes from process %d has %lu bytes of slack\n",
641 len
, current
->pid
, kobjsize(result
) - len
);
645 /* read the contents of a file into the copy */
649 fpos
= vma
->vm_pgoff
;
654 ret
= vma
->vm_file
->f_op
->read(vma
->vm_file
, base
, len
, &fpos
);
660 /* clear the last little bit */
662 memset(base
+ ret
, 0, len
- ret
);
665 /* if it's an anonymous mapping, then just clear it */
666 memset(base
, 0, len
);
677 printk("Allocation of length %lu from process %d failed\n",
684 * handle mapping creation for uClinux
686 unsigned long do_mmap_pgoff(struct file
*file
,
693 struct vm_list_struct
*vml
= NULL
;
694 struct vm_area_struct
*vma
= NULL
;
696 unsigned long capabilities
, vm_flags
;
700 /* decide whether we should attempt the mapping, and if so what sort of
702 ret
= validate_mmap_request(file
, addr
, len
, prot
, flags
, pgoff
,
707 /* we've determined that we can make the mapping, now translate what we
708 * now know into VMA flags */
709 vm_flags
= determine_vm_flags(file
, prot
, flags
, capabilities
);
711 /* we're going to need to record the mapping if it works */
712 vml
= kmalloc(sizeof(struct vm_list_struct
), GFP_KERNEL
);
714 goto error_getting_vml
;
715 memset(vml
, 0, sizeof(*vml
));
717 down_write(&nommu_vma_sem
);
719 /* if we want to share, we need to check for VMAs created by other
720 * mmap() calls that overlap with our proposed mapping
721 * - we can only share with an exact match on most regular files
722 * - shared mappings on character devices and memory backed files are
723 * permitted to overlap inexactly as far as we are concerned for in
724 * these cases, sharing is handled in the driver or filesystem rather
727 if (vm_flags
& VM_MAYSHARE
) {
728 unsigned long pglen
= (len
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
729 unsigned long vmpglen
;
731 for (rb
= rb_first(&nommu_vma_tree
); rb
; rb
= rb_next(rb
)) {
732 vma
= rb_entry(rb
, struct vm_area_struct
, vm_rb
);
734 if (!(vma
->vm_flags
& VM_MAYSHARE
))
737 /* search for overlapping mappings on the same file */
738 if (vma
->vm_file
->f_dentry
->d_inode
!= file
->f_dentry
->d_inode
)
741 if (vma
->vm_pgoff
>= pgoff
+ pglen
)
744 vmpglen
= vma
->vm_end
- vma
->vm_start
+ PAGE_SIZE
- 1;
745 vmpglen
>>= PAGE_SHIFT
;
746 if (pgoff
>= vma
->vm_pgoff
+ vmpglen
)
749 /* handle inexactly overlapping matches between mappings */
750 if (vma
->vm_pgoff
!= pgoff
|| vmpglen
!= pglen
) {
751 if (!(capabilities
& BDI_CAP_MAP_DIRECT
))
752 goto sharing_violation
;
756 /* we've found a VMA we can share */
757 atomic_inc(&vma
->vm_usage
);
760 result
= (void *) vma
->vm_start
;
766 /* obtain the address at which to make a shared mapping
767 * - this is the hook for quasi-memory character devices to
768 * tell us the location of a shared mapping
770 if (file
&& file
->f_op
->get_unmapped_area
) {
771 addr
= file
->f_op
->get_unmapped_area(file
, addr
, len
,
773 if (IS_ERR((void *) addr
)) {
775 if (ret
!= (unsigned long) -ENOSYS
)
778 /* the driver refused to tell us where to site
779 * the mapping so we'll have to attempt to copy
781 ret
= (unsigned long) -ENODEV
;
782 if (!(capabilities
& BDI_CAP_MAP_COPY
))
785 capabilities
&= ~BDI_CAP_MAP_DIRECT
;
790 /* we're going to need a VMA struct as well */
791 vma
= kmalloc(sizeof(struct vm_area_struct
), GFP_KERNEL
);
793 goto error_getting_vma
;
795 memset(vma
, 0, sizeof(*vma
));
796 INIT_LIST_HEAD(&vma
->anon_vma_node
);
797 atomic_set(&vma
->vm_usage
, 1);
801 vma
->vm_flags
= vm_flags
;
802 vma
->vm_start
= addr
;
803 vma
->vm_end
= addr
+ len
;
804 vma
->vm_pgoff
= pgoff
;
808 /* set up the mapping */
809 if (file
&& vma
->vm_flags
& VM_SHARED
)
810 ret
= do_mmap_shared_file(vma
, len
);
812 ret
= do_mmap_private(vma
, len
);
816 /* okay... we have a mapping; now we have to register it */
817 result
= (void *) vma
->vm_start
;
819 if (vma
->vm_flags
& VM_MAPPED_COPY
) {
820 realalloc
+= kobjsize(result
);
824 realalloc
+= kobjsize(vma
);
825 askedalloc
+= sizeof(*vma
);
827 current
->mm
->total_vm
+= len
>> PAGE_SHIFT
;
832 realalloc
+= kobjsize(vml
);
833 askedalloc
+= sizeof(*vml
);
835 vml
->next
= current
->mm
->context
.vmlist
;
836 current
->mm
->context
.vmlist
= vml
;
838 up_write(&nommu_vma_sem
);
840 if (prot
& PROT_EXEC
)
841 flush_icache_range((unsigned long) result
,
842 (unsigned long) result
+ len
);
845 printk("do_mmap:\n");
846 show_process_blocks();
849 return (unsigned long) result
;
852 up_write(&nommu_vma_sem
);
861 up_write(&nommu_vma_sem
);
862 printk("Attempt to share mismatched mappings\n");
867 up_write(&nommu_vma_sem
);
869 printk("Allocation of vma for %lu byte allocation from process %d failed\n",
875 printk("Allocation of vml for %lu byte allocation from process %d failed\n",
882 * handle mapping disposal for uClinux
884 static void put_vma(struct vm_area_struct
*vma
)
887 down_write(&nommu_vma_sem
);
889 if (atomic_dec_and_test(&vma
->vm_usage
)) {
890 delete_nommu_vma(vma
);
892 if (vma
->vm_ops
&& vma
->vm_ops
->close
)
893 vma
->vm_ops
->close(vma
);
895 /* IO memory and memory shared directly out of the pagecache from
896 * ramfs/tmpfs mustn't be released here */
897 if (vma
->vm_flags
& VM_MAPPED_COPY
) {
898 realalloc
-= kobjsize((void *) vma
->vm_start
);
899 askedalloc
-= vma
->vm_end
- vma
->vm_start
;
900 kfree((void *) vma
->vm_start
);
903 realalloc
-= kobjsize(vma
);
904 askedalloc
-= sizeof(*vma
);
911 up_write(&nommu_vma_sem
);
915 int do_munmap(struct mm_struct
*mm
, unsigned long addr
, size_t len
)
917 struct vm_list_struct
*vml
, **parent
;
918 unsigned long end
= addr
+ len
;
921 printk("do_munmap:\n");
924 for (parent
= &mm
->context
.vmlist
; *parent
; parent
= &(*parent
)->next
)
925 if ((*parent
)->vma
->vm_start
== addr
&&
926 ((len
== 0) || ((*parent
)->vma
->vm_end
== end
)))
929 printk("munmap of non-mmaped memory by process %d (%s): %p\n",
930 current
->pid
, current
->comm
, (void *) addr
);
939 realalloc
-= kobjsize(vml
);
940 askedalloc
-= sizeof(*vml
);
943 update_hiwater_vm(mm
);
944 mm
->total_vm
-= len
>> PAGE_SHIFT
;
947 show_process_blocks();
953 /* Release all mmaps. */
954 void exit_mmap(struct mm_struct
* mm
)
956 struct vm_list_struct
*tmp
;
960 printk("Exit_mmap:\n");
965 while ((tmp
= mm
->context
.vmlist
)) {
966 mm
->context
.vmlist
= tmp
->next
;
969 realalloc
-= kobjsize(tmp
);
970 askedalloc
-= sizeof(*tmp
);
975 show_process_blocks();
980 asmlinkage
long sys_munmap(unsigned long addr
, size_t len
)
983 struct mm_struct
*mm
= current
->mm
;
985 down_write(&mm
->mmap_sem
);
986 ret
= do_munmap(mm
, addr
, len
);
987 up_write(&mm
->mmap_sem
);
991 unsigned long do_brk(unsigned long addr
, unsigned long len
)
997 * Expand (or shrink) an existing mapping, potentially moving it at the
998 * same time (controlled by the MREMAP_MAYMOVE flag and available VM space)
1000 * MREMAP_FIXED option added 5-Dec-1999 by Benjamin LaHaise
1001 * This option implies MREMAP_MAYMOVE.
1003 * on uClinux, we only permit changing a mapping's size, and only as long as it stays within the
1004 * hole allocated by the kmalloc() call in do_mmap_pgoff() and the block is not shareable
1006 unsigned long do_mremap(unsigned long addr
,
1007 unsigned long old_len
, unsigned long new_len
,
1008 unsigned long flags
, unsigned long new_addr
)
1010 struct vm_list_struct
*vml
= NULL
;
1012 /* insanity checks first */
1014 return (unsigned long) -EINVAL
;
1016 if (flags
& MREMAP_FIXED
&& new_addr
!= addr
)
1017 return (unsigned long) -EINVAL
;
1019 for (vml
= current
->mm
->context
.vmlist
; vml
; vml
= vml
->next
)
1020 if (vml
->vma
->vm_start
== addr
)
1023 return (unsigned long) -EINVAL
;
1026 if (vml
->vma
->vm_end
!= vml
->vma
->vm_start
+ old_len
)
1027 return (unsigned long) -EFAULT
;
1029 if (vml
->vma
->vm_flags
& VM_MAYSHARE
)
1030 return (unsigned long) -EPERM
;
1032 if (new_len
> kobjsize((void *) addr
))
1033 return (unsigned long) -ENOMEM
;
1035 /* all checks complete - do it */
1036 vml
->vma
->vm_end
= vml
->vma
->vm_start
+ new_len
;
1038 askedalloc
-= old_len
;
1039 askedalloc
+= new_len
;
1041 return vml
->vma
->vm_start
;
1045 * Look up the first VMA which satisfies addr < vm_end, NULL if none
1046 * - should be called with mm->mmap_sem at least readlocked
1048 struct vm_area_struct
*find_vma(struct mm_struct
*mm
, unsigned long addr
)
1050 struct vm_list_struct
*vml
;
1052 for (vml
= mm
->context
.vmlist
; vml
; vml
= vml
->next
)
1053 if (addr
>= vml
->vma
->vm_start
&& addr
< vml
->vma
->vm_end
)
1059 EXPORT_SYMBOL(find_vma
);
1061 struct page
*follow_page(struct vm_area_struct
*vma
, unsigned long address
,
1062 unsigned int foll_flags
)
1067 struct vm_area_struct
*find_extend_vma(struct mm_struct
*mm
, unsigned long addr
)
1072 int remap_pfn_range(struct vm_area_struct
*vma
, unsigned long from
,
1073 unsigned long to
, unsigned long size
, pgprot_t prot
)
1075 vma
->vm_start
= vma
->vm_pgoff
<< PAGE_SHIFT
;
1078 EXPORT_SYMBOL(remap_pfn_range
);
1080 void swap_unplug_io_fn(struct backing_dev_info
*bdi
, struct page
*page
)
1084 unsigned long arch_get_unmapped_area(struct file
*file
, unsigned long addr
,
1085 unsigned long len
, unsigned long pgoff
, unsigned long flags
)
1090 void arch_unmap_area(struct mm_struct
*mm
, unsigned long addr
)
1094 void unmap_mapping_range(struct address_space
*mapping
,
1095 loff_t
const holebegin
, loff_t
const holelen
,
1099 EXPORT_SYMBOL(unmap_mapping_range
);
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
= global_page_state(NR_FILE_PAGES
);
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
+= global_page_state(NR_SLAB_RECLAIMABLE
);
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();
1159 * Leave reserved pages. The pages are not for anonymous pages.
1161 if (n
<= totalreserve_pages
)
1164 n
-= totalreserve_pages
;
1167 * Leave the last 3% for root
1179 allowed
= totalram_pages
* sysctl_overcommit_ratio
/ 100;
1181 * Leave the last 3% for root
1184 allowed
-= allowed
/ 32;
1185 allowed
+= total_swap_pages
;
1187 /* Don't let a single process grow too big:
1188 leave 3% of the size of this process for other processes */
1189 allowed
-= current
->mm
->total_vm
/ 32;
1192 * cast `allowed' as a signed long because vm_committed_space
1193 * sometimes has a negative value
1195 if (atomic_read(&vm_committed_space
) < (long)allowed
)
1198 vm_unacct_memory(pages
);
1203 int in_gate_area_no_task(unsigned long addr
)
1208 struct page
*filemap_nopage(struct vm_area_struct
*area
,
1209 unsigned long address
, int *type
)
1216 * Access another process' address space.
1217 * - source/target buffer must be kernel space
1219 int access_process_vm(struct task_struct
*tsk
, unsigned long addr
, void *buf
, int len
, int write
)
1221 struct vm_area_struct
*vma
;
1222 struct mm_struct
*mm
;
1224 if (addr
+ len
< addr
)
1227 mm
= get_task_mm(tsk
);
1231 down_read(&mm
->mmap_sem
);
1233 /* the access must start within one of the target process's mappings */
1234 vma
= find_vma(mm
, addr
);
1236 /* don't overrun this mapping */
1237 if (addr
+ len
>= vma
->vm_end
)
1238 len
= vma
->vm_end
- addr
;
1240 /* only read or write mappings where it is permitted */
1241 if (write
&& vma
->vm_flags
& VM_WRITE
)
1242 len
-= copy_to_user((void *) addr
, buf
, len
);
1243 else if (!write
&& vma
->vm_flags
& VM_READ
)
1244 len
-= copy_from_user(buf
, (void *) addr
, len
);
1251 up_read(&mm
->mmap_sem
);