2011-05-19 15:21:33 +07:00
|
|
|
/*
|
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
|
|
* for more details.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011 Wind River Systems,
|
|
|
|
* written by Ralf Baechle <ralf@linux-mips.org>
|
|
|
|
*/
|
2011-06-19 01:28:48 +07:00
|
|
|
#include <linux/compiler.h>
|
2011-05-19 15:21:33 +07:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/module.h>
|
2011-05-18 02:27:49 +07:00
|
|
|
#include <linux/personality.h>
|
2011-05-19 15:21:33 +07:00
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
|
|
|
unsigned long shm_align_mask = PAGE_SIZE - 1; /* Sane caches */
|
|
|
|
EXPORT_SYMBOL(shm_align_mask);
|
|
|
|
|
2011-05-18 02:27:49 +07:00
|
|
|
/* gap between mmap and stack */
|
|
|
|
#define MIN_GAP (128*1024*1024UL)
|
2011-06-19 01:28:48 +07:00
|
|
|
#define MAX_GAP ((TASK_SIZE)/6*5)
|
2011-05-18 02:27:49 +07:00
|
|
|
|
|
|
|
static int mmap_is_legacy(void)
|
|
|
|
{
|
|
|
|
if (current->personality & ADDR_COMPAT_LAYOUT)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (rlimit(RLIMIT_STACK) == RLIM_INFINITY)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return sysctl_legacy_va_layout;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long mmap_base(unsigned long rnd)
|
|
|
|
{
|
|
|
|
unsigned long gap = rlimit(RLIMIT_STACK);
|
|
|
|
|
|
|
|
if (gap < MIN_GAP)
|
|
|
|
gap = MIN_GAP;
|
|
|
|
else if (gap > MAX_GAP)
|
|
|
|
gap = MAX_GAP;
|
|
|
|
|
|
|
|
return PAGE_ALIGN(TASK_SIZE - gap - rnd);
|
|
|
|
}
|
|
|
|
|
2011-06-19 01:28:48 +07:00
|
|
|
#define COLOUR_ALIGN(addr, pgoff) \
|
2011-05-19 15:21:33 +07:00
|
|
|
((((addr) + shm_align_mask) & ~shm_align_mask) + \
|
|
|
|
(((pgoff) << PAGE_SHIFT) & shm_align_mask))
|
|
|
|
|
2011-05-18 02:27:49 +07:00
|
|
|
enum mmap_allocation_direction {UP, DOWN};
|
|
|
|
|
2011-06-19 01:28:48 +07:00
|
|
|
static unsigned long arch_get_unmapped_area_common(struct file *filp,
|
2011-05-18 02:27:49 +07:00
|
|
|
unsigned long addr0, unsigned long len, unsigned long pgoff,
|
|
|
|
unsigned long flags, enum mmap_allocation_direction dir)
|
2011-05-19 15:21:33 +07:00
|
|
|
{
|
2011-05-18 02:27:49 +07:00
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
unsigned long addr = addr0;
|
2011-05-19 15:21:33 +07:00
|
|
|
int do_color_align;
|
2012-12-12 07:02:06 +07:00
|
|
|
struct vm_unmapped_area_info info;
|
2011-05-19 15:21:33 +07:00
|
|
|
|
2011-05-18 02:27:49 +07:00
|
|
|
if (unlikely(len > TASK_SIZE))
|
2011-05-19 15:21:33 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (flags & MAP_FIXED) {
|
2011-05-18 02:27:49 +07:00
|
|
|
/* Even MAP_FIXED mappings must reside within TASK_SIZE */
|
2011-05-19 15:21:33 +07:00
|
|
|
if (TASK_SIZE - len < addr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We do not accept a shared mapping if it would violate
|
|
|
|
* cache aliasing constraints.
|
|
|
|
*/
|
|
|
|
if ((flags & MAP_SHARED) &&
|
|
|
|
((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
|
|
|
|
return -EINVAL;
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
do_color_align = 0;
|
|
|
|
if (filp || (flags & MAP_SHARED))
|
|
|
|
do_color_align = 1;
|
2011-05-18 02:27:49 +07:00
|
|
|
|
|
|
|
/* requesting a specific address */
|
2011-05-19 15:21:33 +07:00
|
|
|
if (addr) {
|
|
|
|
if (do_color_align)
|
|
|
|
addr = COLOUR_ALIGN(addr, pgoff);
|
|
|
|
else
|
|
|
|
addr = PAGE_ALIGN(addr);
|
2011-05-18 02:27:49 +07:00
|
|
|
|
|
|
|
vma = find_vma(mm, addr);
|
2011-05-19 15:21:33 +07:00
|
|
|
if (TASK_SIZE - len >= addr &&
|
2011-06-19 01:28:48 +07:00
|
|
|
(!vma || addr + len <= vma->vm_start))
|
2011-05-19 15:21:33 +07:00
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2012-12-12 07:02:06 +07:00
|
|
|
info.length = len;
|
|
|
|
info.align_mask = do_color_align ? (PAGE_MASK & shm_align_mask) : 0;
|
|
|
|
info.align_offset = pgoff << PAGE_SHIFT;
|
2011-05-18 02:27:49 +07:00
|
|
|
|
2012-12-12 07:02:06 +07:00
|
|
|
if (dir == DOWN) {
|
|
|
|
info.flags = VM_UNMAPPED_AREA_TOPDOWN;
|
|
|
|
info.low_limit = PAGE_SIZE;
|
|
|
|
info.high_limit = mm->mmap_base;
|
|
|
|
addr = vm_unmapped_area(&info);
|
|
|
|
|
|
|
|
if (!(addr & ~PAGE_MASK))
|
|
|
|
return addr;
|
2011-05-18 02:27:49 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A failed mmap() very likely causes application failure,
|
|
|
|
* so fall back to the bottom-up function here. This scenario
|
|
|
|
* can happen with large stack limits and large mmap()
|
|
|
|
* allocations.
|
|
|
|
*/
|
2011-05-19 15:21:33 +07:00
|
|
|
}
|
2012-12-12 07:02:06 +07:00
|
|
|
|
|
|
|
info.flags = 0;
|
|
|
|
info.low_limit = mm->mmap_base;
|
|
|
|
info.high_limit = TASK_SIZE;
|
|
|
|
return vm_unmapped_area(&info);
|
2011-05-19 15:21:33 +07:00
|
|
|
}
|
|
|
|
|
2011-05-18 02:27:49 +07:00
|
|
|
unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr0,
|
|
|
|
unsigned long len, unsigned long pgoff, unsigned long flags)
|
|
|
|
{
|
2011-06-19 01:28:48 +07:00
|
|
|
return arch_get_unmapped_area_common(filp,
|
2011-05-18 02:27:49 +07:00
|
|
|
addr0, len, pgoff, flags, UP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is no need to export this but sched.h declares the function as
|
|
|
|
* extern so making it static here results in an error.
|
|
|
|
*/
|
|
|
|
unsigned long arch_get_unmapped_area_topdown(struct file *filp,
|
|
|
|
unsigned long addr0, unsigned long len, unsigned long pgoff,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
2011-06-19 01:28:48 +07:00
|
|
|
return arch_get_unmapped_area_common(filp,
|
2011-05-18 02:27:49 +07:00
|
|
|
addr0, len, pgoff, flags, DOWN);
|
|
|
|
}
|
|
|
|
|
2015-04-15 05:48:00 +07:00
|
|
|
unsigned long arch_mmap_rnd(void)
|
2015-04-15 05:47:51 +07:00
|
|
|
{
|
|
|
|
unsigned long rnd;
|
|
|
|
|
2016-02-27 06:19:37 +07:00
|
|
|
rnd = get_random_long();
|
2015-04-15 05:47:51 +07:00
|
|
|
rnd <<= PAGE_SHIFT;
|
|
|
|
if (TASK_IS_32BIT_ADDR)
|
|
|
|
rnd &= 0xfffffful;
|
|
|
|
else
|
|
|
|
rnd &= 0xffffffful;
|
|
|
|
|
|
|
|
return rnd;
|
|
|
|
}
|
|
|
|
|
2011-05-19 15:21:33 +07:00
|
|
|
void arch_pick_mmap_layout(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
unsigned long random_factor = 0UL;
|
|
|
|
|
2015-04-15 05:47:51 +07:00
|
|
|
if (current->flags & PF_RANDOMIZE)
|
2015-04-15 05:48:00 +07:00
|
|
|
random_factor = arch_mmap_rnd();
|
2011-05-19 15:21:33 +07:00
|
|
|
|
2011-05-18 02:27:49 +07:00
|
|
|
if (mmap_is_legacy()) {
|
|
|
|
mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
|
|
|
|
mm->get_unmapped_area = arch_get_unmapped_area;
|
|
|
|
} else {
|
|
|
|
mm->mmap_base = mmap_base(random_factor);
|
|
|
|
mm->get_unmapped_area = arch_get_unmapped_area_topdown;
|
|
|
|
}
|
2011-05-19 15:21:33 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long brk_rnd(void)
|
|
|
|
{
|
2016-02-27 06:19:37 +07:00
|
|
|
unsigned long rnd = get_random_long();
|
2011-05-19 15:21:33 +07:00
|
|
|
|
|
|
|
rnd = rnd << PAGE_SHIFT;
|
|
|
|
/* 8MB for 32bit, 256MB for 64bit */
|
|
|
|
if (TASK_IS_32BIT_ADDR)
|
|
|
|
rnd = rnd & 0x7ffffful;
|
|
|
|
else
|
|
|
|
rnd = rnd & 0xffffffful;
|
|
|
|
|
|
|
|
return rnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long arch_randomize_brk(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
unsigned long base = mm->brk;
|
|
|
|
unsigned long ret;
|
|
|
|
|
|
|
|
ret = PAGE_ALIGN(base + brk_rnd());
|
|
|
|
|
|
|
|
if (ret < mm->brk)
|
|
|
|
return mm->brk;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-01-26 00:13:15 +07:00
|
|
|
|
|
|
|
int __virt_addr_valid(const volatile void *kaddr)
|
|
|
|
{
|
|
|
|
return pfn_valid(PFN_DOWN(virt_to_phys(kaddr)));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__virt_addr_valid);
|