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-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> 13 * Copyright (c) 2007 Paul Mundt <lethal@linux-sh.org> 14 */ 15 16 #include <linux/module.h> 17 #include <linux/mm.h> 18 #include <linux/mman.h> 19 #include <linux/swap.h> 20 #include <linux/file.h> 21 #include <linux/highmem.h> 22 #include <linux/pagemap.h> 23 #include <linux/slab.h> 24 #include <linux/vmalloc.h> 25 #include <linux/ptrace.h> 26 #include <linux/blkdev.h> 27 #include <linux/backing-dev.h> 28 #include <linux/mount.h> 29 #include <linux/personality.h> 30 #include <linux/security.h> 31 #include <linux/syscalls.h> 32 33 #include <asm/uaccess.h> 34 #include <asm/tlb.h> 35 #include <asm/tlbflush.h> 36 37 void *high_memory; 38 struct page *mem_map; 39 unsigned long max_mapnr; 40 unsigned long num_physpages; 41 unsigned long askedalloc, realalloc; 42 atomic_long_t vm_committed_space = ATOMIC_LONG_INIT(0); 43 int sysctl_overcommit_memory = OVERCOMMIT_GUESS; /* heuristic overcommit */ 44 int sysctl_overcommit_ratio = 50; /* default is 50% */ 45 int sysctl_max_map_count = DEFAULT_MAX_MAP_COUNT; 46 int heap_stack_gap = 0; 47 48 EXPORT_SYMBOL(mem_map); 49 EXPORT_SYMBOL(num_physpages); 50 51 /* list of shareable VMAs */ 52 struct rb_root nommu_vma_tree = RB_ROOT; 53 DECLARE_RWSEM(nommu_vma_sem); 54 55 struct vm_operations_struct generic_file_vm_ops = { 56 }; 57 58 /* 59 * Handle all mappings that got truncated by a "truncate()" 60 * system call. 61 * 62 * NOTE! We have to be ready to update the memory sharing 63 * between the file and the memory map for a potential last 64 * incomplete page. Ugly, but necessary. 65 */ 66 int vmtruncate(struct inode *inode, loff_t offset) 67 { 68 struct address_space *mapping = inode->i_mapping; 69 unsigned long limit; 70 71 if (inode->i_size < offset) 72 goto do_expand; 73 i_size_write(inode, offset); 74 75 truncate_inode_pages(mapping, offset); 76 goto out_truncate; 77 78 do_expand: 79 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur; 80 if (limit != RLIM_INFINITY && offset > limit) 81 goto out_sig; 82 if (offset > inode->i_sb->s_maxbytes) 83 goto out; 84 i_size_write(inode, offset); 85 86 out_truncate: 87 if (inode->i_op && inode->i_op->truncate) 88 inode->i_op->truncate(inode); 89 return 0; 90 out_sig: 91 send_sig(SIGXFSZ, current, 0); 92 out: 93 return -EFBIG; 94 } 95 96 EXPORT_SYMBOL(vmtruncate); 97 98 /* 99 * Return the total memory allocated for this pointer, not 100 * just what the caller asked for. 101 * 102 * Doesn't have to be accurate, i.e. may have races. 103 */ 104 unsigned int kobjsize(const void *objp) 105 { 106 struct page *page; 107 int order = 0; 108 109 /* 110 * If the object we have should not have ksize performed on it, 111 * return size of 0 112 */ 113 if (!objp) 114 return 0; 115 116 if ((unsigned long)objp >= memory_end) 117 return 0; 118 119 page = virt_to_head_page(objp); 120 if (!page) 121 return 0; 122 123 /* 124 * If the allocator sets PageSlab, we know the pointer came from 125 * kmalloc(). 126 */ 127 if (PageSlab(page)) 128 return ksize(objp); 129 130 /* 131 * The ksize() function is only guaranteed to work for pointers 132 * returned by kmalloc(). So handle arbitrary pointers, that we expect 133 * always to be compound pages, here. 134 */ 135 if (PageCompound(page)) 136 order = compound_order(page); 137 138 /* 139 * Finally, handle arbitrary pointers that don't set PageSlab. 140 * Default to 0-order in the case when we're unable to ksize() 141 * the object. 142 */ 143 return PAGE_SIZE << order; 144 } 145 146 /* 147 * get a list of pages in an address range belonging to the specified process 148 * and indicate the VMA that covers each page 149 * - this is potentially dodgy as we may end incrementing the page count of a 150 * slab page or a secondary page from a compound page 151 * - don't permit access to VMAs that don't support it, such as I/O mappings 152 */ 153 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, 154 unsigned long start, int len, int write, int force, 155 struct page **pages, struct vm_area_struct **vmas) 156 { 157 struct vm_area_struct *vma; 158 unsigned long vm_flags; 159 int i; 160 161 /* calculate required read or write permissions. 162 * - if 'force' is set, we only require the "MAY" flags. 163 */ 164 vm_flags = write ? (VM_WRITE | VM_MAYWRITE) : (VM_READ | VM_MAYREAD); 165 vm_flags &= force ? (VM_MAYREAD | VM_MAYWRITE) : (VM_READ | VM_WRITE); 166 167 for (i = 0; i < len; i++) { 168 vma = find_vma(mm, start); 169 if (!vma) 170 goto finish_or_fault; 171 172 /* protect what we can, including chardevs */ 173 if (vma->vm_flags & (VM_IO | VM_PFNMAP) || 174 !(vm_flags & vma->vm_flags)) 175 goto finish_or_fault; 176 177 if (pages) { 178 pages[i] = virt_to_page(start); 179 if (pages[i]) 180 page_cache_get(pages[i]); 181 } 182 if (vmas) 183 vmas[i] = vma; 184 start += PAGE_SIZE; 185 } 186 187 return i; 188 189 finish_or_fault: 190 return i ? : -EFAULT; 191 } 192 EXPORT_SYMBOL(get_user_pages); 193 194 DEFINE_RWLOCK(vmlist_lock); 195 struct vm_struct *vmlist; 196 197 void vfree(const void *addr) 198 { 199 kfree(addr); 200 } 201 EXPORT_SYMBOL(vfree); 202 203 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot) 204 { 205 /* 206 * You can't specify __GFP_HIGHMEM with kmalloc() since kmalloc() 207 * returns only a logical address. 208 */ 209 return kmalloc(size, (gfp_mask | __GFP_COMP) & ~__GFP_HIGHMEM); 210 } 211 EXPORT_SYMBOL(__vmalloc); 212 213 void *vmalloc_user(unsigned long size) 214 { 215 void *ret; 216 217 ret = __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, 218 PAGE_KERNEL); 219 if (ret) { 220 struct vm_area_struct *vma; 221 222 down_write(¤t->mm->mmap_sem); 223 vma = find_vma(current->mm, (unsigned long)ret); 224 if (vma) 225 vma->vm_flags |= VM_USERMAP; 226 up_write(¤t->mm->mmap_sem); 227 } 228 229 return ret; 230 } 231 EXPORT_SYMBOL(vmalloc_user); 232 233 struct page *vmalloc_to_page(const void *addr) 234 { 235 return virt_to_page(addr); 236 } 237 EXPORT_SYMBOL(vmalloc_to_page); 238 239 unsigned long vmalloc_to_pfn(const void *addr) 240 { 241 return page_to_pfn(virt_to_page(addr)); 242 } 243 EXPORT_SYMBOL(vmalloc_to_pfn); 244 245 long vread(char *buf, char *addr, unsigned long count) 246 { 247 memcpy(buf, addr, count); 248 return count; 249 } 250 251 long vwrite(char *buf, char *addr, unsigned long count) 252 { 253 /* Don't allow overflow */ 254 if ((unsigned long) addr + count < count) 255 count = -(unsigned long) addr; 256 257 memcpy(addr, buf, count); 258 return(count); 259 } 260 261 /* 262 * vmalloc - allocate virtually continguos memory 263 * 264 * @size: allocation size 265 * 266 * Allocate enough pages to cover @size from the page level 267 * allocator and map them into continguos kernel virtual space. 268 * 269 * For tight control over page level allocator and protection flags 270 * use __vmalloc() instead. 271 */ 272 void *vmalloc(unsigned long size) 273 { 274 return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL); 275 } 276 EXPORT_SYMBOL(vmalloc); 277 278 void *vmalloc_node(unsigned long size, int node) 279 { 280 return vmalloc(size); 281 } 282 EXPORT_SYMBOL(vmalloc_node); 283 284 /** 285 * vmalloc_32 - allocate virtually contiguous memory (32bit addressable) 286 * @size: allocation size 287 * 288 * Allocate enough 32bit PA addressable pages to cover @size from the 289 * page level allocator and map them into continguos kernel virtual space. 290 */ 291 void *vmalloc_32(unsigned long size) 292 { 293 return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL); 294 } 295 EXPORT_SYMBOL(vmalloc_32); 296 297 /** 298 * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory 299 * @size: allocation size 300 * 301 * The resulting memory area is 32bit addressable and zeroed so it can be 302 * mapped to userspace without leaking data. 303 * 304 * VM_USERMAP is set on the corresponding VMA so that subsequent calls to 305 * remap_vmalloc_range() are permissible. 306 */ 307 void *vmalloc_32_user(unsigned long size) 308 { 309 /* 310 * We'll have to sort out the ZONE_DMA bits for 64-bit, 311 * but for now this can simply use vmalloc_user() directly. 312 */ 313 return vmalloc_user(size); 314 } 315 EXPORT_SYMBOL(vmalloc_32_user); 316 317 void *vmap(struct page **pages, unsigned int count, unsigned long flags, pgprot_t prot) 318 { 319 BUG(); 320 return NULL; 321 } 322 EXPORT_SYMBOL(vmap); 323 324 void vunmap(const void *addr) 325 { 326 BUG(); 327 } 328 EXPORT_SYMBOL(vunmap); 329 330 /* 331 * Implement a stub for vmalloc_sync_all() if the architecture chose not to 332 * have one. 333 */ 334 void __attribute__((weak)) vmalloc_sync_all(void) 335 { 336 } 337 338 int vm_insert_page(struct vm_area_struct *vma, unsigned long addr, 339 struct page *page) 340 { 341 return -EINVAL; 342 } 343 EXPORT_SYMBOL(vm_insert_page); 344 345 /* 346 * sys_brk() for the most part doesn't need the global kernel 347 * lock, except when an application is doing something nasty 348 * like trying to un-brk an area that has already been mapped 349 * to a regular file. in this case, the unmapping will need 350 * to invoke file system routines that need the global lock. 351 */ 352 asmlinkage unsigned long sys_brk(unsigned long brk) 353 { 354 struct mm_struct *mm = current->mm; 355 356 if (brk < mm->start_brk || brk > mm->context.end_brk) 357 return mm->brk; 358 359 if (mm->brk == brk) 360 return mm->brk; 361 362 /* 363 * Always allow shrinking brk 364 */ 365 if (brk <= mm->brk) { 366 mm->brk = brk; 367 return brk; 368 } 369 370 /* 371 * Ok, looks good - let it rip. 372 */ 373 return mm->brk = brk; 374 } 375 376 #ifdef DEBUG 377 static void show_process_blocks(void) 378 { 379 struct vm_list_struct *vml; 380 381 printk("Process blocks %d:", current->pid); 382 383 for (vml = ¤t->mm->context.vmlist; vml; vml = vml->next) { 384 printk(" %p: %p", vml, vml->vma); 385 if (vml->vma) 386 printk(" (%d @%lx #%d)", 387 kobjsize((void *) vml->vma->vm_start), 388 vml->vma->vm_start, 389 atomic_read(&vml->vma->vm_usage)); 390 printk(vml->next ? " ->" : ".\n"); 391 } 392 } 393 #endif /* DEBUG */ 394 395 /* 396 * add a VMA into a process's mm_struct in the appropriate place in the list 397 * - should be called with mm->mmap_sem held writelocked 398 */ 399 static void add_vma_to_mm(struct mm_struct *mm, struct vm_list_struct *vml) 400 { 401 struct vm_list_struct **ppv; 402 403 for (ppv = ¤t->mm->context.vmlist; *ppv; ppv = &(*ppv)->next) 404 if ((*ppv)->vma->vm_start > vml->vma->vm_start) 405 break; 406 407 vml->next = *ppv; 408 *ppv = vml; 409 } 410 411 /* 412 * look up the first VMA in which addr resides, NULL if none 413 * - should be called with mm->mmap_sem at least held readlocked 414 */ 415 struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr) 416 { 417 struct vm_list_struct *loop, *vml; 418 419 /* search the vm_start ordered list */ 420 vml = NULL; 421 for (loop = mm->context.vmlist; loop; loop = loop->next) { 422 if (loop->vma->vm_start > addr) 423 break; 424 vml = loop; 425 } 426 427 if (vml && vml->vma->vm_end > addr) 428 return vml->vma; 429 430 return NULL; 431 } 432 EXPORT_SYMBOL(find_vma); 433 434 /* 435 * find a VMA 436 * - we don't extend stack VMAs under NOMMU conditions 437 */ 438 struct vm_area_struct *find_extend_vma(struct mm_struct *mm, unsigned long addr) 439 { 440 return find_vma(mm, addr); 441 } 442 443 int expand_stack(struct vm_area_struct *vma, unsigned long address) 444 { 445 return -ENOMEM; 446 } 447 448 /* 449 * look up the first VMA exactly that exactly matches addr 450 * - should be called with mm->mmap_sem at least held readlocked 451 */ 452 static inline struct vm_area_struct *find_vma_exact(struct mm_struct *mm, 453 unsigned long addr) 454 { 455 struct vm_list_struct *vml; 456 457 /* search the vm_start ordered list */ 458 for (vml = mm->context.vmlist; vml; vml = vml->next) { 459 if (vml->vma->vm_start == addr) 460 return vml->vma; 461 if (vml->vma->vm_start > addr) 462 break; 463 } 464 465 return NULL; 466 } 467 468 /* 469 * find a VMA in the global tree 470 */ 471 static inline struct vm_area_struct *find_nommu_vma(unsigned long start) 472 { 473 struct vm_area_struct *vma; 474 struct rb_node *n = nommu_vma_tree.rb_node; 475 476 while (n) { 477 vma = rb_entry(n, struct vm_area_struct, vm_rb); 478 479 if (start < vma->vm_start) 480 n = n->rb_left; 481 else if (start > vma->vm_start) 482 n = n->rb_right; 483 else 484 return vma; 485 } 486 487 return NULL; 488 } 489 490 /* 491 * add a VMA in the global tree 492 */ 493 static void add_nommu_vma(struct vm_area_struct *vma) 494 { 495 struct vm_area_struct *pvma; 496 struct address_space *mapping; 497 struct rb_node **p = &nommu_vma_tree.rb_node; 498 struct rb_node *parent = NULL; 499 500 /* add the VMA to the mapping */ 501 if (vma->vm_file) { 502 mapping = vma->vm_file->f_mapping; 503 504 flush_dcache_mmap_lock(mapping); 505 vma_prio_tree_insert(vma, &mapping->i_mmap); 506 flush_dcache_mmap_unlock(mapping); 507 } 508 509 /* add the VMA to the master list */ 510 while (*p) { 511 parent = *p; 512 pvma = rb_entry(parent, struct vm_area_struct, vm_rb); 513 514 if (vma->vm_start < pvma->vm_start) { 515 p = &(*p)->rb_left; 516 } 517 else if (vma->vm_start > pvma->vm_start) { 518 p = &(*p)->rb_right; 519 } 520 else { 521 /* mappings are at the same address - this can only 522 * happen for shared-mem chardevs and shared file 523 * mappings backed by ramfs/tmpfs */ 524 BUG_ON(!(pvma->vm_flags & VM_SHARED)); 525 526 if (vma < pvma) 527 p = &(*p)->rb_left; 528 else if (vma > pvma) 529 p = &(*p)->rb_right; 530 else 531 BUG(); 532 } 533 } 534 535 rb_link_node(&vma->vm_rb, parent, p); 536 rb_insert_color(&vma->vm_rb, &nommu_vma_tree); 537 } 538 539 /* 540 * delete a VMA from the global list 541 */ 542 static void delete_nommu_vma(struct vm_area_struct *vma) 543 { 544 struct address_space *mapping; 545 546 /* remove the VMA from the mapping */ 547 if (vma->vm_file) { 548 mapping = vma->vm_file->f_mapping; 549 550 flush_dcache_mmap_lock(mapping); 551 vma_prio_tree_remove(vma, &mapping->i_mmap); 552 flush_dcache_mmap_unlock(mapping); 553 } 554 555 /* remove from the master list */ 556 rb_erase(&vma->vm_rb, &nommu_vma_tree); 557 } 558 559 /* 560 * determine whether a mapping should be permitted and, if so, what sort of 561 * mapping we're capable of supporting 562 */ 563 static int validate_mmap_request(struct file *file, 564 unsigned long addr, 565 unsigned long len, 566 unsigned long prot, 567 unsigned long flags, 568 unsigned long pgoff, 569 unsigned long *_capabilities) 570 { 571 unsigned long capabilities; 572 unsigned long reqprot = prot; 573 int ret; 574 575 /* do the simple checks first */ 576 if (flags & MAP_FIXED || addr) { 577 printk(KERN_DEBUG 578 "%d: Can't do fixed-address/overlay mmap of RAM\n", 579 current->pid); 580 return -EINVAL; 581 } 582 583 if ((flags & MAP_TYPE) != MAP_PRIVATE && 584 (flags & MAP_TYPE) != MAP_SHARED) 585 return -EINVAL; 586 587 if (!len) 588 return -EINVAL; 589 590 /* Careful about overflows.. */ 591 len = PAGE_ALIGN(len); 592 if (!len || len > TASK_SIZE) 593 return -ENOMEM; 594 595 /* offset overflow? */ 596 if ((pgoff + (len >> PAGE_SHIFT)) < pgoff) 597 return -EOVERFLOW; 598 599 if (file) { 600 /* validate file mapping requests */ 601 struct address_space *mapping; 602 603 /* files must support mmap */ 604 if (!file->f_op || !file->f_op->mmap) 605 return -ENODEV; 606 607 /* work out if what we've got could possibly be shared 608 * - we support chardevs that provide their own "memory" 609 * - we support files/blockdevs that are memory backed 610 */ 611 mapping = file->f_mapping; 612 if (!mapping) 613 mapping = file->f_path.dentry->d_inode->i_mapping; 614 615 capabilities = 0; 616 if (mapping && mapping->backing_dev_info) 617 capabilities = mapping->backing_dev_info->capabilities; 618 619 if (!capabilities) { 620 /* no explicit capabilities set, so assume some 621 * defaults */ 622 switch (file->f_path.dentry->d_inode->i_mode & S_IFMT) { 623 case S_IFREG: 624 case S_IFBLK: 625 capabilities = BDI_CAP_MAP_COPY; 626 break; 627 628 case S_IFCHR: 629 capabilities = 630 BDI_CAP_MAP_DIRECT | 631 BDI_CAP_READ_MAP | 632 BDI_CAP_WRITE_MAP; 633 break; 634 635 default: 636 return -EINVAL; 637 } 638 } 639 640 /* eliminate any capabilities that we can't support on this 641 * device */ 642 if (!file->f_op->get_unmapped_area) 643 capabilities &= ~BDI_CAP_MAP_DIRECT; 644 if (!file->f_op->read) 645 capabilities &= ~BDI_CAP_MAP_COPY; 646 647 if (flags & MAP_SHARED) { 648 /* do checks for writing, appending and locking */ 649 if ((prot & PROT_WRITE) && 650 !(file->f_mode & FMODE_WRITE)) 651 return -EACCES; 652 653 if (IS_APPEND(file->f_path.dentry->d_inode) && 654 (file->f_mode & FMODE_WRITE)) 655 return -EACCES; 656 657 if (locks_verify_locked(file->f_path.dentry->d_inode)) 658 return -EAGAIN; 659 660 if (!(capabilities & BDI_CAP_MAP_DIRECT)) 661 return -ENODEV; 662 663 if (((prot & PROT_READ) && !(capabilities & BDI_CAP_READ_MAP)) || 664 ((prot & PROT_WRITE) && !(capabilities & BDI_CAP_WRITE_MAP)) || 665 ((prot & PROT_EXEC) && !(capabilities & BDI_CAP_EXEC_MAP)) 666 ) { 667 printk("MAP_SHARED not completely supported on !MMU\n"); 668 return -EINVAL; 669 } 670 671 /* we mustn't privatise shared mappings */ 672 capabilities &= ~BDI_CAP_MAP_COPY; 673 } 674 else { 675 /* we're going to read the file into private memory we 676 * allocate */ 677 if (!(capabilities & BDI_CAP_MAP_COPY)) 678 return -ENODEV; 679 680 /* we don't permit a private writable mapping to be 681 * shared with the backing device */ 682 if (prot & PROT_WRITE) 683 capabilities &= ~BDI_CAP_MAP_DIRECT; 684 } 685 686 /* handle executable mappings and implied executable 687 * mappings */ 688 if (file->f_path.mnt->mnt_flags & MNT_NOEXEC) { 689 if (prot & PROT_EXEC) 690 return -EPERM; 691 } 692 else if ((prot & PROT_READ) && !(prot & PROT_EXEC)) { 693 /* handle implication of PROT_EXEC by PROT_READ */ 694 if (current->personality & READ_IMPLIES_EXEC) { 695 if (capabilities & BDI_CAP_EXEC_MAP) 696 prot |= PROT_EXEC; 697 } 698 } 699 else if ((prot & PROT_READ) && 700 (prot & PROT_EXEC) && 701 !(capabilities & BDI_CAP_EXEC_MAP) 702 ) { 703 /* backing file is not executable, try to copy */ 704 capabilities &= ~BDI_CAP_MAP_DIRECT; 705 } 706 } 707 else { 708 /* anonymous mappings are always memory backed and can be 709 * privately mapped 710 */ 711 capabilities = BDI_CAP_MAP_COPY; 712 713 /* handle PROT_EXEC implication by PROT_READ */ 714 if ((prot & PROT_READ) && 715 (current->personality & READ_IMPLIES_EXEC)) 716 prot |= PROT_EXEC; 717 } 718 719 /* allow the security API to have its say */ 720 ret = security_file_mmap(file, reqprot, prot, flags, addr, 0); 721 if (ret < 0) 722 return ret; 723 724 /* looks okay */ 725 *_capabilities = capabilities; 726 return 0; 727 } 728 729 /* 730 * we've determined that we can make the mapping, now translate what we 731 * now know into VMA flags 732 */ 733 static unsigned long determine_vm_flags(struct file *file, 734 unsigned long prot, 735 unsigned long flags, 736 unsigned long capabilities) 737 { 738 unsigned long vm_flags; 739 740 vm_flags = calc_vm_prot_bits(prot) | calc_vm_flag_bits(flags); 741 vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC; 742 /* vm_flags |= mm->def_flags; */ 743 744 if (!(capabilities & BDI_CAP_MAP_DIRECT)) { 745 /* attempt to share read-only copies of mapped file chunks */ 746 if (file && !(prot & PROT_WRITE)) 747 vm_flags |= VM_MAYSHARE; 748 } 749 else { 750 /* overlay a shareable mapping on the backing device or inode 751 * if possible - used for chardevs, ramfs/tmpfs/shmfs and 752 * romfs/cramfs */ 753 if (flags & MAP_SHARED) 754 vm_flags |= VM_MAYSHARE | VM_SHARED; 755 else if ((((vm_flags & capabilities) ^ vm_flags) & BDI_CAP_VMFLAGS) == 0) 756 vm_flags |= VM_MAYSHARE; 757 } 758 759 /* refuse to let anyone share private mappings with this process if 760 * it's being traced - otherwise breakpoints set in it may interfere 761 * with another untraced process 762 */ 763 if ((flags & MAP_PRIVATE) && (current->ptrace & PT_PTRACED)) 764 vm_flags &= ~VM_MAYSHARE; 765 766 return vm_flags; 767 } 768 769 /* 770 * set up a shared mapping on a file 771 */ 772 static int do_mmap_shared_file(struct vm_area_struct *vma, unsigned long len) 773 { 774 int ret; 775 776 ret = vma->vm_file->f_op->mmap(vma->vm_file, vma); 777 if (ret != -ENOSYS) 778 return ret; 779 780 /* getting an ENOSYS error indicates that direct mmap isn't 781 * possible (as opposed to tried but failed) so we'll fall 782 * through to making a private copy of the data and mapping 783 * that if we can */ 784 return -ENODEV; 785 } 786 787 /* 788 * set up a private mapping or an anonymous shared mapping 789 */ 790 static int do_mmap_private(struct vm_area_struct *vma, unsigned long len) 791 { 792 void *base; 793 int ret; 794 795 /* invoke the file's mapping function so that it can keep track of 796 * shared mappings on devices or memory 797 * - VM_MAYSHARE will be set if it may attempt to share 798 */ 799 if (vma->vm_file) { 800 ret = vma->vm_file->f_op->mmap(vma->vm_file, vma); 801 if (ret != -ENOSYS) { 802 /* shouldn't return success if we're not sharing */ 803 BUG_ON(ret == 0 && !(vma->vm_flags & VM_MAYSHARE)); 804 return ret; /* success or a real error */ 805 } 806 807 /* getting an ENOSYS error indicates that direct mmap isn't 808 * possible (as opposed to tried but failed) so we'll try to 809 * make a private copy of the data and map that instead */ 810 } 811 812 /* allocate some memory to hold the mapping 813 * - note that this may not return a page-aligned address if the object 814 * we're allocating is smaller than a page 815 */ 816 base = kmalloc(len, GFP_KERNEL|__GFP_COMP); 817 if (!base) 818 goto enomem; 819 820 vma->vm_start = (unsigned long) base; 821 vma->vm_end = vma->vm_start + len; 822 vma->vm_flags |= VM_MAPPED_COPY; 823 824 #ifdef WARN_ON_SLACK 825 if (len + WARN_ON_SLACK <= kobjsize(result)) 826 printk("Allocation of %lu bytes from process %d has %lu bytes of slack\n", 827 len, current->pid, kobjsize(result) - len); 828 #endif 829 830 if (vma->vm_file) { 831 /* read the contents of a file into the copy */ 832 mm_segment_t old_fs; 833 loff_t fpos; 834 835 fpos = vma->vm_pgoff; 836 fpos <<= PAGE_SHIFT; 837 838 old_fs = get_fs(); 839 set_fs(KERNEL_DS); 840 ret = vma->vm_file->f_op->read(vma->vm_file, base, len, &fpos); 841 set_fs(old_fs); 842 843 if (ret < 0) 844 goto error_free; 845 846 /* clear the last little bit */ 847 if (ret < len) 848 memset(base + ret, 0, len - ret); 849 850 } else { 851 /* if it's an anonymous mapping, then just clear it */ 852 memset(base, 0, len); 853 } 854 855 return 0; 856 857 error_free: 858 kfree(base); 859 vma->vm_start = 0; 860 return ret; 861 862 enomem: 863 printk("Allocation of length %lu from process %d failed\n", 864 len, current->pid); 865 show_free_areas(); 866 return -ENOMEM; 867 } 868 869 /* 870 * handle mapping creation for uClinux 871 */ 872 unsigned long do_mmap_pgoff(struct file *file, 873 unsigned long addr, 874 unsigned long len, 875 unsigned long prot, 876 unsigned long flags, 877 unsigned long pgoff) 878 { 879 struct vm_list_struct *vml = NULL; 880 struct vm_area_struct *vma = NULL; 881 struct rb_node *rb; 882 unsigned long capabilities, vm_flags; 883 void *result; 884 int ret; 885 886 if (!(flags & MAP_FIXED)) 887 addr = round_hint_to_min(addr); 888 889 /* decide whether we should attempt the mapping, and if so what sort of 890 * mapping */ 891 ret = validate_mmap_request(file, addr, len, prot, flags, pgoff, 892 &capabilities); 893 if (ret < 0) 894 return ret; 895 896 /* we've determined that we can make the mapping, now translate what we 897 * now know into VMA flags */ 898 vm_flags = determine_vm_flags(file, prot, flags, capabilities); 899 900 /* we're going to need to record the mapping if it works */ 901 vml = kzalloc(sizeof(struct vm_list_struct), GFP_KERNEL); 902 if (!vml) 903 goto error_getting_vml; 904 905 down_write(&nommu_vma_sem); 906 907 /* if we want to share, we need to check for VMAs created by other 908 * mmap() calls that overlap with our proposed mapping 909 * - we can only share with an exact match on most regular files 910 * - shared mappings on character devices and memory backed files are 911 * permitted to overlap inexactly as far as we are concerned for in 912 * these cases, sharing is handled in the driver or filesystem rather 913 * than here 914 */ 915 if (vm_flags & VM_MAYSHARE) { 916 unsigned long pglen = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; 917 unsigned long vmpglen; 918 919 /* suppress VMA sharing for shared regions */ 920 if (vm_flags & VM_SHARED && 921 capabilities & BDI_CAP_MAP_DIRECT) 922 goto dont_share_VMAs; 923 924 for (rb = rb_first(&nommu_vma_tree); rb; rb = rb_next(rb)) { 925 vma = rb_entry(rb, struct vm_area_struct, vm_rb); 926 927 if (!(vma->vm_flags & VM_MAYSHARE)) 928 continue; 929 930 /* search for overlapping mappings on the same file */ 931 if (vma->vm_file->f_path.dentry->d_inode != file->f_path.dentry->d_inode) 932 continue; 933 934 if (vma->vm_pgoff >= pgoff + pglen) 935 continue; 936 937 vmpglen = vma->vm_end - vma->vm_start + PAGE_SIZE - 1; 938 vmpglen >>= PAGE_SHIFT; 939 if (pgoff >= vma->vm_pgoff + vmpglen) 940 continue; 941 942 /* handle inexactly overlapping matches between mappings */ 943 if (vma->vm_pgoff != pgoff || vmpglen != pglen) { 944 if (!(capabilities & BDI_CAP_MAP_DIRECT)) 945 goto sharing_violation; 946 continue; 947 } 948 949 /* we've found a VMA we can share */ 950 atomic_inc(&vma->vm_usage); 951 952 vml->vma = vma; 953 result = (void *) vma->vm_start; 954 goto shared; 955 } 956 957 dont_share_VMAs: 958 vma = NULL; 959 960 /* obtain the address at which to make a shared mapping 961 * - this is the hook for quasi-memory character devices to 962 * tell us the location of a shared mapping 963 */ 964 if (file && file->f_op->get_unmapped_area) { 965 addr = file->f_op->get_unmapped_area(file, addr, len, 966 pgoff, flags); 967 if (IS_ERR((void *) addr)) { 968 ret = addr; 969 if (ret != (unsigned long) -ENOSYS) 970 goto error; 971 972 /* the driver refused to tell us where to site 973 * the mapping so we'll have to attempt to copy 974 * it */ 975 ret = (unsigned long) -ENODEV; 976 if (!(capabilities & BDI_CAP_MAP_COPY)) 977 goto error; 978 979 capabilities &= ~BDI_CAP_MAP_DIRECT; 980 } 981 } 982 } 983 984 /* we're going to need a VMA struct as well */ 985 vma = kzalloc(sizeof(struct vm_area_struct), GFP_KERNEL); 986 if (!vma) 987 goto error_getting_vma; 988 989 INIT_LIST_HEAD(&vma->anon_vma_node); 990 atomic_set(&vma->vm_usage, 1); 991 if (file) { 992 get_file(file); 993 if (vm_flags & VM_EXECUTABLE) { 994 added_exe_file_vma(current->mm); 995 vma->vm_mm = current->mm; 996 } 997 } 998 vma->vm_file = file; 999 vma->vm_flags = vm_flags; 1000 vma->vm_start = addr; 1001 vma->vm_end = addr + len; 1002 vma->vm_pgoff = pgoff; 1003 1004 vml->vma = vma; 1005 1006 /* set up the mapping */ 1007 if (file && vma->vm_flags & VM_SHARED) 1008 ret = do_mmap_shared_file(vma, len); 1009 else 1010 ret = do_mmap_private(vma, len); 1011 if (ret < 0) 1012 goto error; 1013 1014 /* okay... we have a mapping; now we have to register it */ 1015 result = (void *) vma->vm_start; 1016 1017 if (vma->vm_flags & VM_MAPPED_COPY) { 1018 realalloc += kobjsize(result); 1019 askedalloc += len; 1020 } 1021 1022 realalloc += kobjsize(vma); 1023 askedalloc += sizeof(*vma); 1024 1025 current->mm->total_vm += len >> PAGE_SHIFT; 1026 1027 add_nommu_vma(vma); 1028 1029 shared: 1030 realalloc += kobjsize(vml); 1031 askedalloc += sizeof(*vml); 1032 1033 add_vma_to_mm(current->mm, vml); 1034 1035 up_write(&nommu_vma_sem); 1036 1037 if (prot & PROT_EXEC) 1038 flush_icache_range((unsigned long) result, 1039 (unsigned long) result + len); 1040 1041 #ifdef DEBUG 1042 printk("do_mmap:\n"); 1043 show_process_blocks(); 1044 #endif 1045 1046 return (unsigned long) result; 1047 1048 error: 1049 up_write(&nommu_vma_sem); 1050 kfree(vml); 1051 if (vma) { 1052 if (vma->vm_file) { 1053 fput(vma->vm_file); 1054 if (vma->vm_flags & VM_EXECUTABLE) 1055 removed_exe_file_vma(vma->vm_mm); 1056 } 1057 kfree(vma); 1058 } 1059 return ret; 1060 1061 sharing_violation: 1062 up_write(&nommu_vma_sem); 1063 printk("Attempt to share mismatched mappings\n"); 1064 kfree(vml); 1065 return -EINVAL; 1066 1067 error_getting_vma: 1068 up_write(&nommu_vma_sem); 1069 kfree(vml); 1070 printk("Allocation of vma for %lu byte allocation from process %d failed\n", 1071 len, current->pid); 1072 show_free_areas(); 1073 return -ENOMEM; 1074 1075 error_getting_vml: 1076 printk("Allocation of vml for %lu byte allocation from process %d failed\n", 1077 len, current->pid); 1078 show_free_areas(); 1079 return -ENOMEM; 1080 } 1081 EXPORT_SYMBOL(do_mmap_pgoff); 1082 1083 /* 1084 * handle mapping disposal for uClinux 1085 */ 1086 static void put_vma(struct mm_struct *mm, struct vm_area_struct *vma) 1087 { 1088 if (vma) { 1089 down_write(&nommu_vma_sem); 1090 1091 if (atomic_dec_and_test(&vma->vm_usage)) { 1092 delete_nommu_vma(vma); 1093 1094 if (vma->vm_ops && vma->vm_ops->close) 1095 vma->vm_ops->close(vma); 1096 1097 /* IO memory and memory shared directly out of the pagecache from 1098 * ramfs/tmpfs mustn't be released here */ 1099 if (vma->vm_flags & VM_MAPPED_COPY) { 1100 realalloc -= kobjsize((void *) vma->vm_start); 1101 askedalloc -= vma->vm_end - vma->vm_start; 1102 kfree((void *) vma->vm_start); 1103 } 1104 1105 realalloc -= kobjsize(vma); 1106 askedalloc -= sizeof(*vma); 1107 1108 if (vma->vm_file) { 1109 fput(vma->vm_file); 1110 if (vma->vm_flags & VM_EXECUTABLE) 1111 removed_exe_file_vma(mm); 1112 } 1113 kfree(vma); 1114 } 1115 1116 up_write(&nommu_vma_sem); 1117 } 1118 } 1119 1120 /* 1121 * release a mapping 1122 * - under NOMMU conditions the parameters must match exactly to the mapping to 1123 * be removed 1124 */ 1125 int do_munmap(struct mm_struct *mm, unsigned long addr, size_t len) 1126 { 1127 struct vm_list_struct *vml, **parent; 1128 unsigned long end = addr + len; 1129 1130 #ifdef DEBUG 1131 printk("do_munmap:\n"); 1132 #endif 1133 1134 for (parent = &mm->context.vmlist; *parent; parent = &(*parent)->next) { 1135 if ((*parent)->vma->vm_start > addr) 1136 break; 1137 if ((*parent)->vma->vm_start == addr && 1138 ((len == 0) || ((*parent)->vma->vm_end == end))) 1139 goto found; 1140 } 1141 1142 printk("munmap of non-mmaped memory by process %d (%s): %p\n", 1143 current->pid, current->comm, (void *) addr); 1144 return -EINVAL; 1145 1146 found: 1147 vml = *parent; 1148 1149 put_vma(mm, vml->vma); 1150 1151 *parent = vml->next; 1152 realalloc -= kobjsize(vml); 1153 askedalloc -= sizeof(*vml); 1154 kfree(vml); 1155 1156 update_hiwater_vm(mm); 1157 mm->total_vm -= len >> PAGE_SHIFT; 1158 1159 #ifdef DEBUG 1160 show_process_blocks(); 1161 #endif 1162 1163 return 0; 1164 } 1165 EXPORT_SYMBOL(do_munmap); 1166 1167 asmlinkage long sys_munmap(unsigned long addr, size_t len) 1168 { 1169 int ret; 1170 struct mm_struct *mm = current->mm; 1171 1172 down_write(&mm->mmap_sem); 1173 ret = do_munmap(mm, addr, len); 1174 up_write(&mm->mmap_sem); 1175 return ret; 1176 } 1177 1178 /* 1179 * Release all mappings 1180 */ 1181 void exit_mmap(struct mm_struct * mm) 1182 { 1183 struct vm_list_struct *tmp; 1184 1185 if (mm) { 1186 #ifdef DEBUG 1187 printk("Exit_mmap:\n"); 1188 #endif 1189 1190 mm->total_vm = 0; 1191 1192 while ((tmp = mm->context.vmlist)) { 1193 mm->context.vmlist = tmp->next; 1194 put_vma(mm, tmp->vma); 1195 1196 realalloc -= kobjsize(tmp); 1197 askedalloc -= sizeof(*tmp); 1198 kfree(tmp); 1199 } 1200 1201 #ifdef DEBUG 1202 show_process_blocks(); 1203 #endif 1204 } 1205 } 1206 1207 unsigned long do_brk(unsigned long addr, unsigned long len) 1208 { 1209 return -ENOMEM; 1210 } 1211 1212 /* 1213 * expand (or shrink) an existing mapping, potentially moving it at the same 1214 * time (controlled by the MREMAP_MAYMOVE flag and available VM space) 1215 * 1216 * under NOMMU conditions, we only permit changing a mapping's size, and only 1217 * as long as it stays within the hole allocated by the kmalloc() call in 1218 * do_mmap_pgoff() and the block is not shareable 1219 * 1220 * MREMAP_FIXED is not supported under NOMMU conditions 1221 */ 1222 unsigned long do_mremap(unsigned long addr, 1223 unsigned long old_len, unsigned long new_len, 1224 unsigned long flags, unsigned long new_addr) 1225 { 1226 struct vm_area_struct *vma; 1227 1228 /* insanity checks first */ 1229 if (new_len == 0) 1230 return (unsigned long) -EINVAL; 1231 1232 if (flags & MREMAP_FIXED && new_addr != addr) 1233 return (unsigned long) -EINVAL; 1234 1235 vma = find_vma_exact(current->mm, addr); 1236 if (!vma) 1237 return (unsigned long) -EINVAL; 1238 1239 if (vma->vm_end != vma->vm_start + old_len) 1240 return (unsigned long) -EFAULT; 1241 1242 if (vma->vm_flags & VM_MAYSHARE) 1243 return (unsigned long) -EPERM; 1244 1245 if (new_len > kobjsize((void *) addr)) 1246 return (unsigned long) -ENOMEM; 1247 1248 /* all checks complete - do it */ 1249 vma->vm_end = vma->vm_start + new_len; 1250 1251 askedalloc -= old_len; 1252 askedalloc += new_len; 1253 1254 return vma->vm_start; 1255 } 1256 EXPORT_SYMBOL(do_mremap); 1257 1258 asmlinkage unsigned long sys_mremap(unsigned long addr, 1259 unsigned long old_len, unsigned long new_len, 1260 unsigned long flags, unsigned long new_addr) 1261 { 1262 unsigned long ret; 1263 1264 down_write(¤t->mm->mmap_sem); 1265 ret = do_mremap(addr, old_len, new_len, flags, new_addr); 1266 up_write(¤t->mm->mmap_sem); 1267 return ret; 1268 } 1269 1270 struct page *follow_page(struct vm_area_struct *vma, unsigned long address, 1271 unsigned int foll_flags) 1272 { 1273 return NULL; 1274 } 1275 1276 int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, 1277 unsigned long to, unsigned long size, pgprot_t prot) 1278 { 1279 vma->vm_start = vma->vm_pgoff << PAGE_SHIFT; 1280 return 0; 1281 } 1282 EXPORT_SYMBOL(remap_pfn_range); 1283 1284 int remap_vmalloc_range(struct vm_area_struct *vma, void *addr, 1285 unsigned long pgoff) 1286 { 1287 unsigned int size = vma->vm_end - vma->vm_start; 1288 1289 if (!(vma->vm_flags & VM_USERMAP)) 1290 return -EINVAL; 1291 1292 vma->vm_start = (unsigned long)(addr + (pgoff << PAGE_SHIFT)); 1293 vma->vm_end = vma->vm_start + size; 1294 1295 return 0; 1296 } 1297 EXPORT_SYMBOL(remap_vmalloc_range); 1298 1299 void swap_unplug_io_fn(struct backing_dev_info *bdi, struct page *page) 1300 { 1301 } 1302 1303 unsigned long arch_get_unmapped_area(struct file *file, unsigned long addr, 1304 unsigned long len, unsigned long pgoff, unsigned long flags) 1305 { 1306 return -ENOMEM; 1307 } 1308 1309 void arch_unmap_area(struct mm_struct *mm, unsigned long addr) 1310 { 1311 } 1312 1313 void unmap_mapping_range(struct address_space *mapping, 1314 loff_t const holebegin, loff_t const holelen, 1315 int even_cows) 1316 { 1317 } 1318 EXPORT_SYMBOL(unmap_mapping_range); 1319 1320 /* 1321 * ask for an unmapped area at which to create a mapping on a file 1322 */ 1323 unsigned long get_unmapped_area(struct file *file, unsigned long addr, 1324 unsigned long len, unsigned long pgoff, 1325 unsigned long flags) 1326 { 1327 unsigned long (*get_area)(struct file *, unsigned long, unsigned long, 1328 unsigned long, unsigned long); 1329 1330 get_area = current->mm->get_unmapped_area; 1331 if (file && file->f_op && file->f_op->get_unmapped_area) 1332 get_area = file->f_op->get_unmapped_area; 1333 1334 if (!get_area) 1335 return -ENOSYS; 1336 1337 return get_area(file, addr, len, pgoff, flags); 1338 } 1339 EXPORT_SYMBOL(get_unmapped_area); 1340 1341 /* 1342 * Check that a process has enough memory to allocate a new virtual 1343 * mapping. 0 means there is enough memory for the allocation to 1344 * succeed and -ENOMEM implies there is not. 1345 * 1346 * We currently support three overcommit policies, which are set via the 1347 * vm.overcommit_memory sysctl. See Documentation/vm/overcommit-accounting 1348 * 1349 * Strict overcommit modes added 2002 Feb 26 by Alan Cox. 1350 * Additional code 2002 Jul 20 by Robert Love. 1351 * 1352 * cap_sys_admin is 1 if the process has admin privileges, 0 otherwise. 1353 * 1354 * Note this is a helper function intended to be used by LSMs which 1355 * wish to use this logic. 1356 */ 1357 int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin) 1358 { 1359 unsigned long free, allowed; 1360 1361 vm_acct_memory(pages); 1362 1363 /* 1364 * Sometimes we want to use more memory than we have 1365 */ 1366 if (sysctl_overcommit_memory == OVERCOMMIT_ALWAYS) 1367 return 0; 1368 1369 if (sysctl_overcommit_memory == OVERCOMMIT_GUESS) { 1370 unsigned long n; 1371 1372 free = global_page_state(NR_FILE_PAGES); 1373 free += nr_swap_pages; 1374 1375 /* 1376 * Any slabs which are created with the 1377 * SLAB_RECLAIM_ACCOUNT flag claim to have contents 1378 * which are reclaimable, under pressure. The dentry 1379 * cache and most inode caches should fall into this 1380 */ 1381 free += global_page_state(NR_SLAB_RECLAIMABLE); 1382 1383 /* 1384 * Leave the last 3% for root 1385 */ 1386 if (!cap_sys_admin) 1387 free -= free / 32; 1388 1389 if (free > pages) 1390 return 0; 1391 1392 /* 1393 * nr_free_pages() is very expensive on large systems, 1394 * only call if we're about to fail. 1395 */ 1396 n = nr_free_pages(); 1397 1398 /* 1399 * Leave reserved pages. The pages are not for anonymous pages. 1400 */ 1401 if (n <= totalreserve_pages) 1402 goto error; 1403 else 1404 n -= totalreserve_pages; 1405 1406 /* 1407 * Leave the last 3% for root 1408 */ 1409 if (!cap_sys_admin) 1410 n -= n / 32; 1411 free += n; 1412 1413 if (free > pages) 1414 return 0; 1415 1416 goto error; 1417 } 1418 1419 allowed = totalram_pages * sysctl_overcommit_ratio / 100; 1420 /* 1421 * Leave the last 3% for root 1422 */ 1423 if (!cap_sys_admin) 1424 allowed -= allowed / 32; 1425 allowed += total_swap_pages; 1426 1427 /* Don't let a single process grow too big: 1428 leave 3% of the size of this process for other processes */ 1429 allowed -= current->mm->total_vm / 32; 1430 1431 /* 1432 * cast `allowed' as a signed long because vm_committed_space 1433 * sometimes has a negative value 1434 */ 1435 if (atomic_long_read(&vm_committed_space) < (long)allowed) 1436 return 0; 1437 error: 1438 vm_unacct_memory(pages); 1439 1440 return -ENOMEM; 1441 } 1442 1443 int in_gate_area_no_task(unsigned long addr) 1444 { 1445 return 0; 1446 } 1447 1448 int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 1449 { 1450 BUG(); 1451 return 0; 1452 } 1453 EXPORT_SYMBOL(filemap_fault); 1454 1455 /* 1456 * Access another process' address space. 1457 * - source/target buffer must be kernel space 1458 */ 1459 int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write) 1460 { 1461 struct vm_area_struct *vma; 1462 struct mm_struct *mm; 1463 1464 if (addr + len < addr) 1465 return 0; 1466 1467 mm = get_task_mm(tsk); 1468 if (!mm) 1469 return 0; 1470 1471 down_read(&mm->mmap_sem); 1472 1473 /* the access must start within one of the target process's mappings */ 1474 vma = find_vma(mm, addr); 1475 if (vma) { 1476 /* don't overrun this mapping */ 1477 if (addr + len >= vma->vm_end) 1478 len = vma->vm_end - addr; 1479 1480 /* only read or write mappings where it is permitted */ 1481 if (write && vma->vm_flags & VM_MAYWRITE) 1482 len -= copy_to_user((void *) addr, buf, len); 1483 else if (!write && vma->vm_flags & VM_MAYREAD) 1484 len -= copy_from_user(buf, (void *) addr, len); 1485 else 1486 len = 0; 1487 } else { 1488 len = 0; 1489 } 1490 1491 up_read(&mm->mmap_sem); 1492 mmput(mm); 1493 return len; 1494 } 1495