[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / x86 / kernel / sys_x86_64.c

#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/syscalls.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/smp.h>
#include <linux/sem.h>
#include <linux/msg.h>
#include <linux/shm.h>
#include <linux/stat.h>
#include <linux/mman.h>
#include <linux/file.h>
#include <linux/utsname.h>
#include <linux/personality.h>
#include <linux/random.h>
#include <linux/uaccess.h>
#include <linux/elf.h>

#include <asm/ia32.h>
#include <asm/syscalls.h>

/*
 * Align a virtual address to avoid aliasing in the I$ on AMD F15h.
 */
static unsigned long get_align_mask(void)
{
	/* handle 32- and 64-bit case with a single conditional */
	if (va_align.flags < 0 || !(va_align.flags & (2 - mmap_is_ia32())))
		return 0;

	if (!(current->flags & PF_RANDOMIZE))
		return 0;

	return va_align.mask;
}

unsigned long align_vdso_addr(unsigned long addr)
{
	unsigned long align_mask = get_align_mask();
	return (addr + align_mask) & ~align_mask;
}

static int __init control_va_addr_alignment(char *str)
{
	/* guard against enabling this on other CPU families */
	if (va_align.flags < 0)
		return 1;

	if (*str == 0)
		return 1;

	if (*str == '=')
		str++;

	if (!strcmp(str, "32"))
		va_align.flags = ALIGN_VA_32;
	else if (!strcmp(str, "64"))
		va_align.flags = ALIGN_VA_64;
	else if (!strcmp(str, "off"))
		va_align.flags = 0;
	else if (!strcmp(str, "on"))
		va_align.flags = ALIGN_VA_32 | ALIGN_VA_64;
	else
		return 0;

	return 1;
}
__setup("align_va_addr", control_va_addr_alignment);

SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
		unsigned long, prot, unsigned long, flags,
		unsigned long, fd, unsigned long, off)
{
	long error;
	error = -EINVAL;
	if (off & ~PAGE_MASK)
		goto out;

	error = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
out:
	return error;
}

static void find_start_end(unsigned long flags, unsigned long *begin,
			   unsigned long *end)
{
	if (!test_thread_flag(TIF_ADDR32) && (flags & MAP_32BIT)) {
		unsigned long new_begin;
		/* This is usually used needed to map code in small
		   model, so it needs to be in the first 31bit. Limit
		   it to that.  This means we need to move the
		   unmapped base down for this case. This can give
		   conflicts with the heap, but we assume that glibc
		   malloc knows how to fall back to mmap. Give it 1GB
		   of playground for now. -AK */
		*begin = 0x40000000;
		*end = 0x80000000;
		if (current->flags & PF_RANDOMIZE) {
			new_begin = randomize_range(*begin, *begin + 0x02000000, 0);
			if (new_begin)
				*begin = new_begin;
		}
	} else {
		*begin = current->mm->mmap_legacy_base;
		*end = TASK_SIZE;
	}
}

unsigned long
arch_get_unmapped_area(struct file *filp, unsigned long addr,
		unsigned long len, unsigned long pgoff, unsigned long flags)
{
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	struct vm_unmapped_area_info info;
	unsigned long begin, end;

	if (flags & MAP_FIXED)
		return addr;

	find_start_end(flags, &begin, &end);

	if (len > end)
		return -ENOMEM;

	if (addr) {
		addr = PAGE_ALIGN(addr);
		vma = find_vma(mm, addr);
		if (end - len >= addr &&
		    (!vma || addr + len <= vm_start_gap(vma)))
			return addr;
	}

	info.flags = 0;
	info.length = len;
	info.low_limit = begin;
	info.high_limit = end;
	info.align_mask = filp ? get_align_mask() : 0;
	info.align_offset = pgoff << PAGE_SHIFT;
	return vm_unmapped_area(&info);
}

unsigned long
arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
			  const unsigned long len, const unsigned long pgoff,
			  const unsigned long flags)
{
	struct vm_area_struct *vma;
	struct mm_struct *mm = current->mm;
	unsigned long addr = addr0;
	struct vm_unmapped_area_info info;

	/* requested length too big for entire address space */
	if (len > TASK_SIZE)
		return -ENOMEM;

	if (flags & MAP_FIXED)
		return addr;

	/* for MAP_32BIT mappings we force the legacy mmap base */
	if (!test_thread_flag(TIF_ADDR32) && (flags & MAP_32BIT))
		goto bottomup;

	/* requesting a specific address */
	if (addr) {
		addr = PAGE_ALIGN(addr);
		vma = find_vma(mm, addr);
		if (TASK_SIZE - len >= addr &&
				(!vma || addr + len <= vm_start_gap(vma)))
			return addr;
	}

	info.flags = VM_UNMAPPED_AREA_TOPDOWN;
	info.length = len;
	info.low_limit = PAGE_SIZE;
	info.high_limit = mm->mmap_base;
	info.align_mask = filp ? get_align_mask() : 0;
	info.align_offset = pgoff << PAGE_SHIFT;
	addr = vm_unmapped_area(&info);
	if (!(addr & ~PAGE_MASK))
		return addr;
	VM_BUG_ON(addr != -ENOMEM);

bottomup:
	/*
	 * 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.
	 */
	return arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
}
Commit	Line	Data
	1	#include <linux/errno.h>
	2	#include <linux/sched.h>
	3	#include <linux/syscalls.h>
	4	#include <linux/mm.h>
	5	#include <linux/fs.h>
	6	#include <linux/smp.h>
	7	#include <linux/sem.h>
	8	#include <linux/msg.h>
	9	#include <linux/shm.h>
	10	#include <linux/stat.h>
	11	#include <linux/mman.h>
	12	#include <linux/file.h>
	13	#include <linux/utsname.h>
	14	#include <linux/personality.h>
	15	#include <linux/random.h>
	16	#include <linux/uaccess.h>
	17	#include <linux/elf.h>
	18
	19	#include <asm/ia32.h>
	20	#include <asm/syscalls.h>
	21
	22	/*
	23	* Align a virtual address to avoid aliasing in the I$ on AMD F15h.
	24	*/
	25	static unsigned long get_align_mask(void)
	26	{
	27	/* handle 32- and 64-bit case with a single conditional */
	28	if (va_align.flags < 0 \|\| !(va_align.flags & (2 - mmap_is_ia32())))
	29	return 0;
	30
	31	if (!(current->flags & PF_RANDOMIZE))
	32	return 0;
	33
	34	return va_align.mask;
	35	}
	36
	37	unsigned long align_vdso_addr(unsigned long addr)
	38	{
	39	unsigned long align_mask = get_align_mask();
	40	return (addr + align_mask) & ~align_mask;
	41	}
	42
	43	static int __init control_va_addr_alignment(char *str)
	44	{
	45	/* guard against enabling this on other CPU families */
	46	if (va_align.flags < 0)
	47	return 1;
	48
	49	if (*str == 0)
	50	return 1;
	51
	52	if (*str == '=')
	53	str++;
	54
	55	if (!strcmp(str, "32"))
	56	va_align.flags = ALIGN_VA_32;
	57	else if (!strcmp(str, "64"))
	58	va_align.flags = ALIGN_VA_64;
	59	else if (!strcmp(str, "off"))
	60	va_align.flags = 0;
	61	else if (!strcmp(str, "on"))
	62	va_align.flags = ALIGN_VA_32 \| ALIGN_VA_64;
	63	else
	64	return 0;
	65
	66	return 1;
	67	}
	68	__setup("align_va_addr", control_va_addr_alignment);
	69
	70	SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
	71	unsigned long, prot, unsigned long, flags,
	72	unsigned long, fd, unsigned long, off)
	73	{
	74	long error;
	75	error = -EINVAL;
	76	if (off & ~PAGE_MASK)
	77	goto out;
	78
	79	error = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
	80	out:
	81	return error;
	82	}
	83
	84	static void find_start_end(unsigned long flags, unsigned long *begin,
	85	unsigned long *end)
	86	{
	87	if (!test_thread_flag(TIF_ADDR32) && (flags & MAP_32BIT)) {
	88	unsigned long new_begin;
	89	/* This is usually used needed to map code in small
	90	model, so it needs to be in the first 31bit. Limit
	91	it to that. This means we need to move the
	92	unmapped base down for this case. This can give
	93	conflicts with the heap, but we assume that glibc
	94	malloc knows how to fall back to mmap. Give it 1GB
	95	of playground for now. -AK */
	96	*begin = 0x40000000;
	97	*end = 0x80000000;
	98	if (current->flags & PF_RANDOMIZE) {
	99	new_begin = randomize_range(begin, begin + 0x02000000, 0);
	100	if (new_begin)
	101	*begin = new_begin;
	102	}
	103	} else {
	104	*begin = current->mm->mmap_legacy_base;
	105	*end = TASK_SIZE;
	106	}
	107	}
	108
	109	unsigned long
	110	arch_get_unmapped_area(struct file *filp, unsigned long addr,
	111	unsigned long len, unsigned long pgoff, unsigned long flags)
	112	{
	113	struct mm_struct *mm = current->mm;
	114	struct vm_area_struct *vma;
	115	struct vm_unmapped_area_info info;
	116	unsigned long begin, end;
	117
	118	if (flags & MAP_FIXED)
	119	return addr;
	120
	121	find_start_end(flags, &begin, &end);
	122
	123	if (len > end)
	124	return -ENOMEM;
	125
	126	if (addr) {
	127	addr = PAGE_ALIGN(addr);
	128	vma = find_vma(mm, addr);
	129	if (end - len >= addr &&
	130	(!vma \|\| addr + len <= vm_start_gap(vma)))
	131	return addr;
	132	}
	133
	134	info.flags = 0;
	135	info.length = len;
	136	info.low_limit = begin;
	137	info.high_limit = end;
	138	info.align_mask = filp ? get_align_mask() : 0;
	139	info.align_offset = pgoff << PAGE_SHIFT;
	140	return vm_unmapped_area(&info);
	141	}
	142
	143	unsigned long
	144	arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
	145	const unsigned long len, const unsigned long pgoff,
	146	const unsigned long flags)
	147	{
	148	struct vm_area_struct *vma;
	149	struct mm_struct *mm = current->mm;
	150	unsigned long addr = addr0;
	151	struct vm_unmapped_area_info info;
	152
	153	/* requested length too big for entire address space */
	154	if (len > TASK_SIZE)
	155	return -ENOMEM;
	156
	157	if (flags & MAP_FIXED)
	158	return addr;
	159
	160	/* for MAP_32BIT mappings we force the legacy mmap base */
	161	if (!test_thread_flag(TIF_ADDR32) && (flags & MAP_32BIT))
	162	goto bottomup;
	163
	164	/* requesting a specific address */
	165	if (addr) {
	166	addr = PAGE_ALIGN(addr);
	167	vma = find_vma(mm, addr);
	168	if (TASK_SIZE - len >= addr &&
	169	(!vma \|\| addr + len <= vm_start_gap(vma)))
	170	return addr;
	171	}
	172
	173	info.flags = VM_UNMAPPED_AREA_TOPDOWN;
	174	info.length = len;
	175	info.low_limit = PAGE_SIZE;
	176	info.high_limit = mm->mmap_base;
	177	info.align_mask = filp ? get_align_mask() : 0;
	178	info.align_offset = pgoff << PAGE_SHIFT;
	179	addr = vm_unmapped_area(&info);
	180	if (!(addr & ~PAGE_MASK))
	181	return addr;
	182	VM_BUG_ON(addr != -ENOMEM);
	183
	184	bottomup:
	185	/*
	186	* A failed mmap() very likely causes application failure,
	187	* so fall back to the bottom-up function here. This scenario
	188	* can happen with large stack limits and large mmap()
	189	* allocations.
	190	*/
	191	return arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
	192	}