[linux-2.6-block.git] / arch / mips / vdso / genvdso.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2015 Imagination Technologies
 * Author: Alex Smith <alex.smith@imgtec.com>
 */

/*
 * This tool is used to generate the real VDSO images from the raw image. It
 * first patches up the MIPS ABI flags and GNU attributes sections defined in
 * elf.S to have the correct name and type. It then generates a C source file
 * to be compiled into the kernel containing the VDSO image data and a
 * mips_vdso_image struct for it, including symbol offsets extracted from the
 * image.
 *
 * We need to be passed both a stripped and unstripped VDSO image. The stripped
 * image is compiled into the kernel, but we must also patch up the unstripped
 * image's ABI flags sections so that it can be installed and used for
 * debugging.
 */

#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <byteswap.h>
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/* Define these in case the system elf.h is not new enough to have them. */
#ifndef SHT_GNU_ATTRIBUTES
# define SHT_GNU_ATTRIBUTES	0x6ffffff5
#endif
#ifndef SHT_MIPS_ABIFLAGS
# define SHT_MIPS_ABIFLAGS	0x7000002a
#endif

enum {
	ABI_O32 = (1 << 0),
	ABI_N32 = (1 << 1),
	ABI_N64 = (1 << 2),

	ABI_ALL = ABI_O32 | ABI_N32 | ABI_N64,
};

/* Symbols the kernel requires offsets for. */
static struct {
	const char *name;
	const char *offset_name;
	unsigned int abis;
} vdso_symbols[] = {
	{ "__vdso_sigreturn", "off_sigreturn", ABI_O32 },
	{ "__vdso_rt_sigreturn", "off_rt_sigreturn", ABI_ALL },
	{}
};

static const char *program_name;
static const char *vdso_name;
static unsigned char elf_class;
static unsigned int elf_abi;
static bool need_swap;
static FILE *out_file;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
# define HOST_ORDER		ELFDATA2LSB
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
# define HOST_ORDER		ELFDATA2MSB
#endif

#define BUILD_SWAP(bits)						\
	static uint##bits##_t swap_uint##bits(uint##bits##_t val)	\
	{								\
		return need_swap ? bswap_##bits(val) : val;		\
	}

BUILD_SWAP(16)
BUILD_SWAP(32)
BUILD_SWAP(64)

#define __FUNC(name, bits) name##bits
#define _FUNC(name, bits) __FUNC(name, bits)
#define FUNC(name) _FUNC(name, ELF_BITS)

#define __ELF(x, bits) Elf##bits##_##x
#define _ELF(x, bits) __ELF(x, bits)
#define ELF(x) _ELF(x, ELF_BITS)

/*
 * Include genvdso.h twice with ELF_BITS defined differently to get functions
 * for both ELF32 and ELF64.
 */

#define ELF_BITS 64
#include "genvdso.h"
#undef ELF_BITS

#define ELF_BITS 32
#include "genvdso.h"
#undef ELF_BITS

static void *map_vdso(const char *path, size_t *_size)
{
	int fd;
	struct stat stat;
	void *addr;
	const Elf32_Ehdr *ehdr;

	fd = open(path, O_RDWR);
	if (fd < 0) {
		fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
			path, strerror(errno));
		return NULL;
	}

	if (fstat(fd, &stat) != 0) {
		fprintf(stderr, "%s: Failed to stat '%s': %s\n", program_name,
			path, strerror(errno));
		close(fd);
		return NULL;
	}

	addr = mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
		    0);
	if (addr == MAP_FAILED) {
		fprintf(stderr, "%s: Failed to map '%s': %s\n", program_name,
			path, strerror(errno));
		close(fd);
		return NULL;
	}

	/* ELF32/64 header formats are the same for the bits we're checking. */
	ehdr = addr;

	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0) {
		fprintf(stderr, "%s: '%s' is not an ELF file\n", program_name,
			path);
		close(fd);
		return NULL;
	}

	elf_class = ehdr->e_ident[EI_CLASS];
	switch (elf_class) {
	case ELFCLASS32:
	case ELFCLASS64:
		break;
	default:
		fprintf(stderr, "%s: '%s' has invalid ELF class\n",
			program_name, path);
		close(fd);
		return NULL;
	}

	switch (ehdr->e_ident[EI_DATA]) {
	case ELFDATA2LSB:
	case ELFDATA2MSB:
		need_swap = ehdr->e_ident[EI_DATA] != HOST_ORDER;
		break;
	default:
		fprintf(stderr, "%s: '%s' has invalid ELF data order\n",
			program_name, path);
		close(fd);
		return NULL;
	}

	if (swap_uint16(ehdr->e_machine) != EM_MIPS) {
		fprintf(stderr,
			"%s: '%s' has invalid ELF machine (expected EM_MIPS)\n",
			program_name, path);
		close(fd);
		return NULL;
	} else if (swap_uint16(ehdr->e_type) != ET_DYN) {
		fprintf(stderr,
			"%s: '%s' has invalid ELF type (expected ET_DYN)\n",
			program_name, path);
		close(fd);
		return NULL;
	}

	*_size = stat.st_size;
	close(fd);
	return addr;
}

static bool patch_vdso(const char *path, void *vdso)
{
	if (elf_class == ELFCLASS64)
		return patch_vdso64(path, vdso);
	else
		return patch_vdso32(path, vdso);
}

static bool get_symbols(const char *path, void *vdso)
{
	if (elf_class == ELFCLASS64)
		return get_symbols64(path, vdso);
	else
		return get_symbols32(path, vdso);
}

int main(int argc, char **argv)
{
	const char *dbg_vdso_path, *vdso_path, *out_path;
	void *dbg_vdso, *vdso;
	size_t dbg_vdso_size, vdso_size, i;

	program_name = argv[0];

	if (argc < 4 || argc > 5) {
		fprintf(stderr,
			"Usage: %s <debug VDSO> <stripped VDSO> <output file> [<name>]\n",
			program_name);
		return EXIT_FAILURE;
	}

	dbg_vdso_path = argv[1];
	vdso_path = argv[2];
	out_path = argv[3];
	vdso_name = (argc > 4) ? argv[4] : "";

	dbg_vdso = map_vdso(dbg_vdso_path, &dbg_vdso_size);
	if (!dbg_vdso)
		return EXIT_FAILURE;

	vdso = map_vdso(vdso_path, &vdso_size);
	if (!vdso)
		return EXIT_FAILURE;

	/* Patch both the VDSOs' ABI flags sections. */
	if (!patch_vdso(dbg_vdso_path, dbg_vdso))
		return EXIT_FAILURE;
	if (!patch_vdso(vdso_path, vdso))
		return EXIT_FAILURE;

	if (msync(dbg_vdso, dbg_vdso_size, MS_SYNC) != 0) {
		fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
			dbg_vdso_path, strerror(errno));
		return EXIT_FAILURE;
	} else if (msync(vdso, vdso_size, MS_SYNC) != 0) {
		fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
			vdso_path, strerror(errno));
		return EXIT_FAILURE;
	}

	out_file = fopen(out_path, "w");
	if (!out_file) {
		fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
			out_path, strerror(errno));
		return EXIT_FAILURE;
	}

	fprintf(out_file, "/* Automatically generated - do not edit */\n");
	fprintf(out_file, "#include <linux/linkage.h>\n");
	fprintf(out_file, "#include <linux/mm.h>\n");
	fprintf(out_file, "#include <asm/vdso.h>\n");
	fprintf(out_file, "static int vdso_mremap(\n");
	fprintf(out_file, "	const struct vm_special_mapping *sm,\n");
	fprintf(out_file, "	struct vm_area_struct *new_vma)\n");
	fprintf(out_file, "{\n");
	fprintf(out_file, "	current->mm->context.vdso =\n");
	fprintf(out_file, "	(void *)(new_vma->vm_start);\n");
	fprintf(out_file, "	return 0;\n");
	fprintf(out_file, "}\n");

	/* Write out the stripped VDSO data. */
	fprintf(out_file,
		"static unsigned char vdso_data[PAGE_ALIGN(%zu)] __page_aligned_data = {\n\t",
		vdso_size);
	for (i = 0; i < vdso_size; i++) {
		if (!(i % 10))
			fprintf(out_file, "\n\t");
		fprintf(out_file, "0x%02x, ", ((unsigned char *)vdso)[i]);
	}
	fprintf(out_file, "\n};\n");

	/* Preallocate a page array. */
	fprintf(out_file,
		"static struct page *vdso_pages[PAGE_ALIGN(%zu) / PAGE_SIZE];\n",
		vdso_size);

	fprintf(out_file, "struct mips_vdso_image vdso_image%s%s = {\n",
		(vdso_name[0]) ? "_" : "", vdso_name);
	fprintf(out_file, "\t.data = vdso_data,\n");
	fprintf(out_file, "\t.size = PAGE_ALIGN(%zu),\n", vdso_size);
	fprintf(out_file, "\t.mapping = {\n");
	fprintf(out_file, "\t\t.name = \"[vdso]\",\n");
	fprintf(out_file, "\t\t.pages = vdso_pages,\n");
	fprintf(out_file, "\t\t.mremap = vdso_mremap,\n");
	fprintf(out_file, "\t},\n");

	/* Calculate and write symbol offsets to <output file> */
	if (!get_symbols(dbg_vdso_path, dbg_vdso)) {
		unlink(out_path);
		fclose(out_file);
		return EXIT_FAILURE;
	}

	fprintf(out_file, "};\n");
	fclose(out_file);

	return EXIT_SUCCESS;
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
ebb5e78c AS	2	/*
	3	* Copyright (C) 2015 Imagination Technologies
	4	* Author: Alex Smith <alex.smith@imgtec.com>
ebb5e78c AS	5	*/
	6
	7	/*
	8	* This tool is used to generate the real VDSO images from the raw image. It
	9	* first patches up the MIPS ABI flags and GNU attributes sections defined in
	10	* elf.S to have the correct name and type. It then generates a C source file
	11	* to be compiled into the kernel containing the VDSO image data and a
	12	* mips_vdso_image struct for it, including symbol offsets extracted from the
	13	* image.
	14	*
	15	* We need to be passed both a stripped and unstripped VDSO image. The stripped
	16	* image is compiled into the kernel, but we must also patch up the unstripped
	17	* image's ABI flags sections so that it can be installed and used for
	18	* debugging.
	19	*/
	20
	21	#include <sys/mman.h>
	22	#include <sys/stat.h>
	23	#include <sys/types.h>
	24
	25	#include <byteswap.h>
	26	#include <elf.h>
	27	#include <errno.h>
	28	#include <fcntl.h>
	29	#include <inttypes.h>
	30	#include <stdarg.h>
	31	#include <stdbool.h>
	32	#include <stdio.h>
	33	#include <stdlib.h>
	34	#include <string.h>
	35	#include <unistd.h>
	36
	37	/* Define these in case the system elf.h is not new enough to have them. */
	38	#ifndef SHT_GNU_ATTRIBUTES
	39	# define SHT_GNU_ATTRIBUTES 0x6ffffff5
	40	#endif
	41	#ifndef SHT_MIPS_ABIFLAGS
	42	# define SHT_MIPS_ABIFLAGS 0x7000002a
	43	#endif
	44
	45	enum {
	46	ABI_O32 = (1 << 0),
	47	ABI_N32 = (1 << 1),
	48	ABI_N64 = (1 << 2),
	49
	50	ABI_ALL = ABI_O32 \| ABI_N32 \| ABI_N64,
	51	};
	52
	53	/* Symbols the kernel requires offsets for. */
	54	static struct {
	55	const char *name;
	56	const char *offset_name;
	57	unsigned int abis;
	58	} vdso_symbols[] = {
	59	{ "__vdso_sigreturn", "off_sigreturn", ABI_O32 },
	60	{ "__vdso_rt_sigreturn", "off_rt_sigreturn", ABI_ALL },
	61	{}
	62	};
	63
	64	static const char *program_name;
	65	static const char *vdso_name;
	66	static unsigned char elf_class;
	67	static unsigned int elf_abi;
	68	static bool need_swap;
69	static FILE *out_file;
70
71	#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
72	# define HOST_ORDER ELFDATA2LSB
73	#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
74	# define HOST_ORDER ELFDATA2MSB
75	#endif
76
77	#define BUILD_SWAP(bits) \
78	static uint##bits##_t swap_uint##bits(uint##bits##_t val) \
79	{ \
80	return need_swap ? bswap_##bits(val) : val; \
81	}
82
83	BUILD_SWAP(16)
84	BUILD_SWAP(32)
85	BUILD_SWAP(64)
86
87	#define __FUNC(name, bits) name##bits
88	#define _FUNC(name, bits) __FUNC(name, bits)
89	#define FUNC(name) _FUNC(name, ELF_BITS)
90
91	#define __ELF(x, bits) Elf##bits##_##x
92	#define _ELF(x, bits) __ELF(x, bits)
93	#define ELF(x) _ELF(x, ELF_BITS)
94
95	/*
96	* Include genvdso.h twice with ELF_BITS defined differently to get functions
97	* for both ELF32 and ELF64.
98	*/
99
100	#define ELF_BITS 64
101	#include "genvdso.h"
102	#undef ELF_BITS
103
104	#define ELF_BITS 32
105	#include "genvdso.h"
106	#undef ELF_BITS
107
108	static void map_vdso(const char path, size_t *_size)
109	{
110	int fd;
111	struct stat stat;
112	void *addr;
113	const Elf32_Ehdr *ehdr;
114
115	fd = open(path, O_RDWR);
116	if (fd < 0) {
117	fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
118	path, strerror(errno));
119	return NULL;
120	}
121
122	if (fstat(fd, &stat) != 0) {
123	fprintf(stderr, "%s: Failed to stat '%s': %s\n", program_name,
124	path, strerror(errno));
a859647b	125	close(fd);
ebb5e78c AS	126	return NULL;
	127	}
	128
	129	addr = mmap(NULL, stat.st_size, PROT_READ \| PROT_WRITE, MAP_SHARED, fd,
	130	0);
	131	if (addr == MAP_FAILED) {
	132	fprintf(stderr, "%s: Failed to map '%s': %s\n", program_name,
	133	path, strerror(errno));
a859647b	134	close(fd);
ebb5e78c AS	135	return NULL;
	136	}
	137
	138	/* ELF32/64 header formats are the same for the bits we're checking. */
	139	ehdr = addr;
	140
	141	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0) {
	142	fprintf(stderr, "%s: '%s' is not an ELF file\n", program_name,
	143	path);
a859647b	144	close(fd);
ebb5e78c AS	145	return NULL;
	146	}
	147
	148	elf_class = ehdr->e_ident[EI_CLASS];
	149	switch (elf_class) {
	150	case ELFCLASS32:
	151	case ELFCLASS64:
	152	break;
	153	default:
	154	fprintf(stderr, "%s: '%s' has invalid ELF class\n",
	155	program_name, path);
a859647b	156	close(fd);
ebb5e78c AS	157	return NULL;
	158	}
	159
	160	switch (ehdr->e_ident[EI_DATA]) {
	161	case ELFDATA2LSB:
	162	case ELFDATA2MSB:
	163	need_swap = ehdr->e_ident[EI_DATA] != HOST_ORDER;
	164	break;
	165	default:
	166	fprintf(stderr, "%s: '%s' has invalid ELF data order\n",
	167	program_name, path);
a859647b	168	close(fd);
ebb5e78c AS	169	return NULL;
	170	}
	171
	172	if (swap_uint16(ehdr->e_machine) != EM_MIPS) {
	173	fprintf(stderr,
	174	"%s: '%s' has invalid ELF machine (expected EM_MIPS)\n",
	175	program_name, path);
a859647b	176	close(fd);
ebb5e78c AS	177	return NULL;
	178	} else if (swap_uint16(ehdr->e_type) != ET_DYN) {
	179	fprintf(stderr,
	180	"%s: '%s' has invalid ELF type (expected ET_DYN)\n",
	181	program_name, path);
a859647b	182	close(fd);
ebb5e78c AS	183	return NULL;
	184	}
	185
	186	*_size = stat.st_size;
a859647b	187	close(fd);
ebb5e78c AS	188	return addr;
	189	}
	190
	191	static bool patch_vdso(const char path, void vdso)
	192	{
	193	if (elf_class == ELFCLASS64)
	194	return patch_vdso64(path, vdso);
	195	else
	196	return patch_vdso32(path, vdso);
	197	}
	198
	199	static bool get_symbols(const char path, void vdso)
	200	{
	201	if (elf_class == ELFCLASS64)
	202	return get_symbols64(path, vdso);
	203	else
	204	return get_symbols32(path, vdso);
	205	}
	206
	207	int main(int argc, char **argv)
	208	{
	209	const char dbg_vdso_path, vdso_path, *out_path;
	210	void dbg_vdso, vdso;
	211	size_t dbg_vdso_size, vdso_size, i;
	212
	213	program_name = argv[0];
	214
	215	if (argc < 4 \|\| argc > 5) {
	216	fprintf(stderr,
	217	"Usage: %s <debug VDSO> <stripped VDSO> <output file> [<name>]\n",
	218	program_name);
	219	return EXIT_FAILURE;
	220	}
	221
	222	dbg_vdso_path = argv[1];
	223	vdso_path = argv[2];
	224	out_path = argv[3];
	225	vdso_name = (argc > 4) ? argv[4] : "";
	226
	227	dbg_vdso = map_vdso(dbg_vdso_path, &dbg_vdso_size);
	228	if (!dbg_vdso)
	229	return EXIT_FAILURE;
	230
	231	vdso = map_vdso(vdso_path, &vdso_size);
	232	if (!vdso)
	233	return EXIT_FAILURE;
	234
	235	/* Patch both the VDSOs' ABI flags sections. */
	236	if (!patch_vdso(dbg_vdso_path, dbg_vdso))
	237	return EXIT_FAILURE;
	238	if (!patch_vdso(vdso_path, vdso))
	239	return EXIT_FAILURE;
	240
	241	if (msync(dbg_vdso, dbg_vdso_size, MS_SYNC) != 0) {
	242	fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
	243	dbg_vdso_path, strerror(errno));
	244	return EXIT_FAILURE;
	245	} else if (msync(vdso, vdso_size, MS_SYNC) != 0) {
	246	fprintf(stderr, "%s: Failed to sync '%s': %s\n", program_name,
	247	vdso_path, strerror(errno));
	248	return EXIT_FAILURE;
	249	}
	250
	251	out_file = fopen(out_path, "w");
252	if (!out_file) {
253	fprintf(stderr, "%s: Failed to open '%s': %s\n", program_name,
254	out_path, strerror(errno));
255	return EXIT_FAILURE;
256	}
257
258	fprintf(out_file, "/* Automatically generated - do not edit */\n");
259	fprintf(out_file, "#include <linux/linkage.h>\n");
260	fprintf(out_file, "#include <linux/mm.h>\n");
261	fprintf(out_file, "#include <asm/vdso.h>\n");
ad1df954 GS	262	fprintf(out_file, "static int vdso_mremap(\n");
	263	fprintf(out_file, " const struct vm_special_mapping *sm,\n");
	264	fprintf(out_file, " struct vm_area_struct *new_vma)\n");
	265	fprintf(out_file, "{\n");
ad1df954	266	fprintf(out_file, " current->mm->context.vdso =\n");
c7c101df	267	fprintf(out_file, " (void *)(new_vma->vm_start);\n");
ad1df954 GS	268	fprintf(out_file, " return 0;\n");
ad1df954 GS	269	fprintf(out_file, "}\n");
ebb5e78c AS	270
	271	/* Write out the stripped VDSO data. */
	272	fprintf(out_file,
	273	"static unsigned char vdso_data[PAGE_ALIGN(%zu)] __page_aligned_data = {\n\t",
	274	vdso_size);
	275	for (i = 0; i < vdso_size; i++) {
	276	if (!(i % 10))
	277	fprintf(out_file, "\n\t");
	278	fprintf(out_file, "0x%02x, ", ((unsigned char *)vdso)[i]);
	279	}
	280	fprintf(out_file, "\n};\n");
	281
	282	/* Preallocate a page array. */
	283	fprintf(out_file,
	284	"static struct page *vdso_pages[PAGE_ALIGN(%zu) / PAGE_SIZE];\n",
	285	vdso_size);
	286
	287	fprintf(out_file, "struct mips_vdso_image vdso_image%s%s = {\n",
	288	(vdso_name[0]) ? "_" : "", vdso_name);
	289	fprintf(out_file, "\t.data = vdso_data,\n");
	290	fprintf(out_file, "\t.size = PAGE_ALIGN(%zu),\n", vdso_size);
	291	fprintf(out_file, "\t.mapping = {\n");
	292	fprintf(out_file, "\t\t.name = \"[vdso]\",\n");
	293	fprintf(out_file, "\t\t.pages = vdso_pages,\n");
ad1df954	294	fprintf(out_file, "\t\t.mremap = vdso_mremap,\n");
ebb5e78c AS	295	fprintf(out_file, "\t},\n");
	296
	297	/* Calculate and write symbol offsets to <output file> */
	298	if (!get_symbols(dbg_vdso_path, dbg_vdso)) {
	299	unlink(out_path);
a859647b	300	fclose(out_file);
ebb5e78c AS	301	return EXIT_FAILURE;
	302	}
	303
	304	fprintf(out_file, "};\n");
a859647b	305	fclose(out_file);
ebb5e78c AS	306
	307	return EXIT_SUCCESS;
	308	}