x86, vdso: Move the vvar area before the vdso text (e6577a7c) · Commits · e / devices / android_kernel_teracube_mt6765

arch/x86/include/asm/vdso.h

+9 −9

Original line number	Original line	Diff line number	Diff line
	@@ -18,15 +18,15 @@ struct vdso_image {

	unsigned long alt, alt_len;		unsigned long alt, alt_len;

	unsigned long sym_end_mapping; /* Total size of the mapping */		long sym_vvar_start; /* Negative offset to the vvar area */

	unsigned long sym_vvar_page;		long sym_vvar_page;
	unsigned long sym_hpet_page;		long sym_hpet_page;
	unsigned long sym_VDSO32_NOTE_MASK;		long sym_VDSO32_NOTE_MASK;
	unsigned long sym___kernel_sigreturn;		long sym___kernel_sigreturn;
	unsigned long sym___kernel_rt_sigreturn;		long sym___kernel_rt_sigreturn;
	unsigned long sym___kernel_vsyscall;		long sym___kernel_vsyscall;
	unsigned long sym_VDSO32_SYSENTER_RETURN;		long sym_VDSO32_SYSENTER_RETURN;
	};		};

	#ifdef CONFIG_X86_64		#ifdef CONFIG_X86_64

arch/x86/vdso/vdso-layout.lds.S

+19 −25

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,25 @@

	SECTIONS		SECTIONS
	{		{
			/*
			* User/kernel shared data is before the vDSO. This may be a little
			* uglier than putting it after the vDSO, but it avoids issues with
			* non-allocatable things that dangle past the end of the PT_LOAD
			* segment.
			*/

			vvar_start = . - 2 * PAGE_SIZE;
			vvar_page = vvar_start;

			/* Place all vvars at the offsets in asm/vvar.h. */
			#define EMIT_VVAR(name, offset) vvar_ ## name = vvar_page + offset;
			#define __VVAR_KERNEL_LDS
			#include <asm/vvar.h>
			#undef __VVAR_KERNEL_LDS
			#undef EMIT_VVAR

			hpet_page = vvar_start + PAGE_SIZE;

	. = SIZEOF_HEADERS;		. = SIZEOF_HEADERS;

	.hash : { *(.hash) } :text		.hash : { *(.hash) } :text
	@@ -74,31 +93,6 @@ SECTIONS
	.altinstructions : { *(.altinstructions) } :text		.altinstructions : { *(.altinstructions) } :text
	.altinstr_replacement : { *(.altinstr_replacement) } :text		.altinstr_replacement : { *(.altinstr_replacement) } :text

	/*
	* The remainder of the vDSO consists of special pages that are
	* shared between the kernel and userspace. It needs to be at the
	* end so that it doesn't overlap the mapping of the actual
	* vDSO image.
	*/

	. = ALIGN(PAGE_SIZE);
	vvar_page = .;

	/* Place all vvars at the offsets in asm/vvar.h. */
	#define EMIT_VVAR(name, offset) vvar_ ## name = vvar_page + offset;
	#define __VVAR_KERNEL_LDS
	#include <asm/vvar.h>
	#undef __VVAR_KERNEL_LDS
	#undef EMIT_VVAR

	. = vvar_page + PAGE_SIZE;

	hpet_page = .;
	. = . + PAGE_SIZE;

	. = ALIGN(PAGE_SIZE);
	end_mapping = .;

	/DISCARD/ : {		/DISCARD/ : {
	*(.discard)		*(.discard)
	(.discard.)		(.discard.)

arch/x86/vdso/vdso2c.c

+7 −5

Original line number	Original line	Diff line number	Diff line
	@@ -20,9 +20,9 @@ const char *outfilename;

	/* Symbols that we need in vdso2c. */		/* Symbols that we need in vdso2c. */
	enum {		enum {
			sym_vvar_start,
	sym_vvar_page,		sym_vvar_page,
	sym_hpet_page,		sym_hpet_page,
	sym_end_mapping,
	sym_VDSO_FAKE_SECTION_TABLE_START,		sym_VDSO_FAKE_SECTION_TABLE_START,
	sym_VDSO_FAKE_SECTION_TABLE_END,		sym_VDSO_FAKE_SECTION_TABLE_END,
	};		};
	@@ -38,9 +38,9 @@ struct vdso_sym {
	};		};

	struct vdso_sym required_syms[] = {		struct vdso_sym required_syms[] = {
			[sym_vvar_start] = {"vvar_start", true},
	[sym_vvar_page] = {"vvar_page", true},		[sym_vvar_page] = {"vvar_page", true},
	[sym_hpet_page] = {"hpet_page", true},		[sym_hpet_page] = {"hpet_page", true},
	[sym_end_mapping] = {"end_mapping", true},
	[sym_VDSO_FAKE_SECTION_TABLE_START] = {		[sym_VDSO_FAKE_SECTION_TABLE_START] = {
	"VDSO_FAKE_SECTION_TABLE_START", false		"VDSO_FAKE_SECTION_TABLE_START", false
	},		},
	@@ -96,9 +96,11 @@ extern void bad_put_le(void);

	#define NSYMS (sizeof(required_syms) / sizeof(required_syms[0]))		#define NSYMS (sizeof(required_syms) / sizeof(required_syms[0]))

	#define BITSFUNC3(name, bits) name##bits		#define BITSFUNC3(name, bits, suffix) name##bits##suffix
	#define BITSFUNC2(name, bits) BITSFUNC3(name, bits)		#define BITSFUNC2(name, bits, suffix) BITSFUNC3(name, bits, suffix)
	#define BITSFUNC(name) BITSFUNC2(name, ELF_BITS)		#define BITSFUNC(name) BITSFUNC2(name, ELF_BITS, )

			#define INT_BITS BITSFUNC2(int, ELF_BITS, _t)

	#define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x		#define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x
	#define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x)		#define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x)

arch/x86/vdso/vdso2c.h

+16 −9

Original line number	Original line	Diff line number	Diff line
	@@ -132,7 +132,7 @@ static void BITSFUNC(go)(void *addr, size_t len,
	*alt_sec = NULL;		*alt_sec = NULL;
	ELF(Dyn) dyn = 0, dyn_end = 0;		ELF(Dyn) dyn = 0, dyn_end = 0;
	const char *secstrings;		const char *secstrings;
	uint64_t syms[NSYMS] = {};		INT_BITS syms[NSYMS] = {};

	struct BITSFUNC(fake_sections) fake_sections = {};		struct BITSFUNC(fake_sections) fake_sections = {};

	@@ -209,6 +209,13 @@ static void BITSFUNC(go)(void *addr, size_t len,
	fail("duplicate symbol %s\n",		fail("duplicate symbol %s\n",
	required_syms[k].name);		required_syms[k].name);
	}		}

			/*
			* Careful: we use negative addresses, but
			* st_value is unsigned, so we rely
			* on syms[k] being a signed type of the
			* correct width.
			*/
	syms[k] = GET_LE(&sym->st_value);		syms[k] = GET_LE(&sym->st_value);
	}		}
	}		}
	@@ -263,15 +270,15 @@ static void BITSFUNC(go)(void *addr, size_t len,
	if (syms[i] % 4096)		if (syms[i] % 4096)
	fail("%s must be a multiple of 4096\n",		fail("%s must be a multiple of 4096\n",
	required_syms[i].name);		required_syms[i].name);
	if (syms[i] < data_size)		if (syms[sym_vvar_start] > syms[i] + 4096)
	fail("%s must be after the text mapping\n",		fail("%s underruns begin_vvar\n",
	required_syms[i].name);		required_syms[i].name);
	if (syms[sym_end_mapping] < syms[i] + 4096)		if (syms[i] + 4096 > 0)
	fail("%s overruns end_mapping\n",		fail("%s is on the wrong side of the vdso text\n",
	required_syms[i].name);		required_syms[i].name);
	}		}
	if (syms[sym_end_mapping] % 4096)		if (syms[sym_vvar_start] % 4096)
	fail("end_mapping must be a multiple of 4096\n");		fail("vvar_begin must be a multiple of 4096\n");

	if (!name) {		if (!name) {
	fwrite(addr, load_size, 1, outfile);		fwrite(addr, load_size, 1, outfile);
	@@ -311,8 +318,8 @@ static void BITSFUNC(go)(void *addr, size_t len,
	}		}
	for (i = 0; i < NSYMS; i++) {		for (i = 0; i < NSYMS; i++) {
	if (required_syms[i].export && syms[i])		if (required_syms[i].export && syms[i])
	fprintf(outfile, "\t.sym_%s = 0x%" PRIx64 ",\n",		fprintf(outfile, "\t.sym_%s = %" PRIi64 ",\n",
	required_syms[i].name, syms[i]);		required_syms[i].name, (int64_t)syms[i]);
	}		}
	fprintf(outfile, "};\n");		fprintf(outfile, "};\n");
	}		}

arch/x86/vdso/vma.c

+11 −9

Original line number	Original line	Diff line number	Diff line
	@@ -93,7 +93,7 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)
	{		{
	struct mm_struct *mm = current->mm;		struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;		struct vm_area_struct *vma;
	unsigned long addr;		unsigned long addr, text_start;
	int ret = 0;		int ret = 0;
	static struct page *no_pages[] = {NULL};		static struct page *no_pages[] = {NULL};
	static struct vm_special_mapping vvar_mapping = {		static struct vm_special_mapping vvar_mapping = {
	@@ -103,26 +103,28 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)

	if (calculate_addr) {		if (calculate_addr) {
	addr = vdso_addr(current->mm->start_stack,		addr = vdso_addr(current->mm->start_stack,
	image->sym_end_mapping);		image->size - image->sym_vvar_start);
	} else {		} else {
	addr = 0;		addr = 0;
	}		}

	down_write(&mm->mmap_sem);		down_write(&mm->mmap_sem);

	addr = get_unmapped_area(NULL, addr, image->sym_end_mapping, 0, 0);		addr = get_unmapped_area(NULL, addr,
			image->size - image->sym_vvar_start, 0, 0);
	if (IS_ERR_VALUE(addr)) {		if (IS_ERR_VALUE(addr)) {
	ret = addr;		ret = addr;
	goto up_fail;		goto up_fail;
	}		}

	current->mm->context.vdso = (void __user *)addr;		text_start = addr - image->sym_vvar_start;
			current->mm->context.vdso = (void __user *)text_start;

	/*		/*
	* MAYWRITE to allow gdb to COW and set breakpoints		* MAYWRITE to allow gdb to COW and set breakpoints
	*/		*/
	vma = _install_special_mapping(mm,		vma = _install_special_mapping(mm,
	addr,		text_start,
	image->size,		image->size,
	VM_READ\|VM_EXEC\|		VM_READ\|VM_EXEC\|
	VM_MAYREAD\|VM_MAYWRITE\|VM_MAYEXEC,		VM_MAYREAD\|VM_MAYWRITE\|VM_MAYEXEC,
	@@ -134,8 +136,8 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)
	}		}

	vma = _install_special_mapping(mm,		vma = _install_special_mapping(mm,
	addr + image->size,		addr,
	image->sym_end_mapping - image->size,		-image->sym_vvar_start,
	VM_READ,		VM_READ,
	&vvar_mapping);		&vvar_mapping);

	@@ -146,7 +148,7 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)

	if (image->sym_vvar_page)		if (image->sym_vvar_page)
	ret = remap_pfn_range(vma,		ret = remap_pfn_range(vma,
	addr + image->sym_vvar_page,		text_start + image->sym_vvar_page,
	__pa_symbol(&__vvar_page) >> PAGE_SHIFT,		__pa_symbol(&__vvar_page) >> PAGE_SHIFT,
	PAGE_SIZE,		PAGE_SIZE,
	PAGE_READONLY);		PAGE_READONLY);
	@@ -157,7 +159,7 @@ static int map_vdso(const struct vdso_image *image, bool calculate_addr)
	#ifdef CONFIG_HPET_TIMER		#ifdef CONFIG_HPET_TIMER
	if (hpet_address && image->sym_hpet_page) {		if (hpet_address && image->sym_hpet_page) {
	ret = io_remap_pfn_range(vma,		ret = io_remap_pfn_range(vma,
	addr + image->sym_hpet_page,		text_start + image->sym_hpet_page,
	hpet_address >> PAGE_SHIFT,		hpet_address >> PAGE_SHIFT,
	PAGE_SIZE,		PAGE_SIZE,
	pgprot_noncached(PAGE_READONLY));		pgprot_noncached(PAGE_READONLY));