Commit b055f4c4 authored by Steven Rostedt's avatar Steven Rostedt Committed by Steven Rostedt (Google)
Browse files

sorttable: Move ELF parsing into scripts/elf-parse.[ch] 

In order to share the elf parsing that is in sorttable.c so that other
programs could use the same code, move it into elf-parse.c and
elf-parse.h.

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Masahiro Yamada <masahiroy@kernel.org>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nicolas Schier <nicolas.schier@linux.dev>
Cc: Nick Desaulniers <nick.desaulniers+lkml@gmail.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Link: https://lore.kernel.org/20251022004452.752298788@kernel.org


Signed-off-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
parent 211ddde0

scripts/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -12,6 +12,8 @@ hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert 
hostprogs-always-$(CONFIG_RUST_KERNEL_DOCTESTS)		+= rustdoc_test_builder

hostprogs-always-$(CONFIG_RUST_KERNEL_DOCTESTS)		+= rustdoc_test_gen



sorttable-objs := sorttable.o elf-parse.o



ifneq ($(or $(CONFIG_X86_64),$(CONFIG_X86_32)),)

always-$(CONFIG_RUST)					+= target.json

filechk_rust_target = $< < include/config/auto.conf
@@ -25,6 +27,7 @@ generate_rust_target-rust := y 
rustdoc_test_builder-rust := y

rustdoc_test_gen-rust := y



HOSTCFLAGS_elf-parse.o = -I$(srctree)/tools/include

HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include

HOSTLDLIBS_sorttable = -lpthread

HOSTCFLAGS_asn1_compiler.o = -I$(srctree)/include

scripts/elf-parse.c

0 → 100644
+198 −0
Original line number Diff line number Diff line 
#include <sys/types.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>



#include "elf-parse.h"



struct elf_funcs elf_parser;



/*

 * Get the whole file as a programming convenience in order to avoid

 * malloc+lseek+read+free of many pieces.  If successful, then mmap

 * avoids copying unused pieces; else just read the whole file.

 * Open for both read and write.

 */

static void *map_file(char const *fname, size_t *size)

{

	int fd;

	struct stat sb;

	void *addr = NULL;



	fd = open(fname, O_RDWR);

	if (fd < 0) {

		perror(fname);

		return NULL;

	}

	if (fstat(fd, &sb) < 0) {

		perror(fname);

		goto out;

	}

	if (!S_ISREG(sb.st_mode)) {

		fprintf(stderr, "not a regular file: %s\n", fname);

		goto out;

	}



	addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

	if (addr == MAP_FAILED) {

		fprintf(stderr, "Could not mmap file: %s\n", fname);

		goto out;

	}



	*size = sb.st_size;



out:

	close(fd);

	return addr;

}



static int elf_parse(const char *fname, void *addr, uint32_t types)

{

	Elf_Ehdr *ehdr = addr;

	uint16_t type;



	switch (ehdr->e32.e_ident[EI_DATA]) {

	case ELFDATA2LSB:

		elf_parser.r	= rle;

		elf_parser.r2	= r2le;

		elf_parser.r8	= r8le;

		elf_parser.w	= wle;

		elf_parser.w8	= w8le;

		break;

	case ELFDATA2MSB:

		elf_parser.r	= rbe;

		elf_parser.r2	= r2be;

		elf_parser.r8	= r8be;

		elf_parser.w	= wbe;

		elf_parser.w8	= w8be;

		break;

	default:

		fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",

			ehdr->e32.e_ident[EI_DATA], fname);

		return -1;

	}



	if (memcmp(ELFMAG, ehdr->e32.e_ident, SELFMAG) != 0 ||

	    ehdr->e32.e_ident[EI_VERSION] != EV_CURRENT) {

		fprintf(stderr, "unrecognized ELF file %s\n", fname);

		return -1;

	}



	type = elf_parser.r2(&ehdr->e32.e_type);

	if (!((1 << type) & types)) {

		fprintf(stderr, "Invalid ELF type file %s\n", fname);

		return -1;

	}



	switch (ehdr->e32.e_ident[EI_CLASS]) {

	case ELFCLASS32: {

		elf_parser.ehdr_shoff		= ehdr32_shoff;

		elf_parser.ehdr_shentsize	= ehdr32_shentsize;

		elf_parser.ehdr_shstrndx	= ehdr32_shstrndx;

		elf_parser.ehdr_shnum		= ehdr32_shnum;

		elf_parser.shdr_addr		= shdr32_addr;

		elf_parser.shdr_offset		= shdr32_offset;

		elf_parser.shdr_link		= shdr32_link;

		elf_parser.shdr_size		= shdr32_size;

		elf_parser.shdr_name		= shdr32_name;

		elf_parser.shdr_type		= shdr32_type;

		elf_parser.shdr_entsize		= shdr32_entsize;

		elf_parser.sym_type		= sym32_type;

		elf_parser.sym_name		= sym32_name;

		elf_parser.sym_value		= sym32_value;

		elf_parser.sym_shndx		= sym32_shndx;

		elf_parser.rela_offset		= rela32_offset;

		elf_parser.rela_info		= rela32_info;

		elf_parser.rela_addend		= rela32_addend;

		elf_parser.rela_write_addend	= rela32_write_addend;



		if (elf_parser.r2(&ehdr->e32.e_ehsize) != sizeof(Elf32_Ehdr) ||

		    elf_parser.r2(&ehdr->e32.e_shentsize) != sizeof(Elf32_Shdr)) {

			fprintf(stderr,

				"unrecognized ET_EXEC/ET_DYN file: %s\n", fname);

			return -1;

		}



		}

		break;

	case ELFCLASS64: {

		elf_parser.ehdr_shoff		= ehdr64_shoff;

		elf_parser.ehdr_shentsize		= ehdr64_shentsize;

		elf_parser.ehdr_shstrndx		= ehdr64_shstrndx;

		elf_parser.ehdr_shnum		= ehdr64_shnum;

		elf_parser.shdr_addr		= shdr64_addr;

		elf_parser.shdr_offset		= shdr64_offset;

		elf_parser.shdr_link		= shdr64_link;

		elf_parser.shdr_size		= shdr64_size;

		elf_parser.shdr_name		= shdr64_name;

		elf_parser.shdr_type		= shdr64_type;

		elf_parser.shdr_entsize		= shdr64_entsize;

		elf_parser.sym_type		= sym64_type;

		elf_parser.sym_name		= sym64_name;

		elf_parser.sym_value		= sym64_value;

		elf_parser.sym_shndx		= sym64_shndx;

		elf_parser.rela_offset		= rela64_offset;

		elf_parser.rela_info		= rela64_info;

		elf_parser.rela_addend		= rela64_addend;

		elf_parser.rela_write_addend	= rela64_write_addend;



		if (elf_parser.r2(&ehdr->e64.e_ehsize) != sizeof(Elf64_Ehdr) ||

		    elf_parser.r2(&ehdr->e64.e_shentsize) != sizeof(Elf64_Shdr)) {

			fprintf(stderr,

				"unrecognized ET_EXEC/ET_DYN file: %s\n",

				fname);

			return -1;

		}



		}

		break;

	default:

		fprintf(stderr, "unrecognized ELF class %d %s\n",

			ehdr->e32.e_ident[EI_CLASS], fname);

		return -1;

	}

	return 0;

}



int elf_map_machine(void *addr)

{

	Elf_Ehdr *ehdr = addr;



	return elf_parser.r2(&ehdr->e32.e_machine);

}



int elf_map_long_size(void *addr)

{

	Elf_Ehdr *ehdr = addr;



	return ehdr->e32.e_ident[EI_CLASS] == ELFCLASS32 ? 4 : 8;

}



void *elf_map(char const *fname, size_t *size, uint32_t types)

{

	void *addr;

	int ret;



	addr = map_file(fname, size);

	if (!addr)

		return NULL;



	ret = elf_parse(fname, addr, types);

	if (ret < 0) {

		elf_unmap(addr, *size);

		return NULL;

	}



	return addr;

}



void elf_unmap(void *addr, size_t size)

{

	munmap(addr, size);

}

scripts/elf-parse.h

0 → 100644
+305 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

#ifndef _SCRIPTS_ELF_PARSE_H

#define _SCRIPTS_ELF_PARSE_H



#include <elf.h>



#include <tools/be_byteshift.h>

#include <tools/le_byteshift.h>



typedef union {

	Elf32_Ehdr	e32;

	Elf64_Ehdr	e64;

} Elf_Ehdr;



typedef union {

	Elf32_Shdr	e32;

	Elf64_Shdr	e64;

} Elf_Shdr;



typedef union {

	Elf32_Sym	e32;

	Elf64_Sym	e64;

} Elf_Sym;



typedef union {

	Elf32_Rela	e32;

	Elf64_Rela	e64;

} Elf_Rela;



struct elf_funcs {

	int (*compare_extable)(const void *a, const void *b);

	uint64_t (*ehdr_shoff)(Elf_Ehdr *ehdr);

	uint16_t (*ehdr_shstrndx)(Elf_Ehdr *ehdr);

	uint16_t (*ehdr_shentsize)(Elf_Ehdr *ehdr);

	uint16_t (*ehdr_shnum)(Elf_Ehdr *ehdr);

	uint64_t (*shdr_addr)(Elf_Shdr *shdr);

	uint64_t (*shdr_offset)(Elf_Shdr *shdr);

	uint64_t (*shdr_size)(Elf_Shdr *shdr);

	uint64_t (*shdr_entsize)(Elf_Shdr *shdr);

	uint32_t (*shdr_link)(Elf_Shdr *shdr);

	uint32_t (*shdr_name)(Elf_Shdr *shdr);

	uint32_t (*shdr_type)(Elf_Shdr *shdr);

	uint8_t (*sym_type)(Elf_Sym *sym);

	uint32_t (*sym_name)(Elf_Sym *sym);

	uint64_t (*sym_value)(Elf_Sym *sym);

	uint16_t (*sym_shndx)(Elf_Sym *sym);

	uint64_t (*rela_offset)(Elf_Rela *rela);

	uint64_t (*rela_info)(Elf_Rela *rela);

	uint64_t (*rela_addend)(Elf_Rela *rela);

	void (*rela_write_addend)(Elf_Rela *rela, uint64_t val);

	uint32_t (*r)(const uint32_t *);

	uint16_t (*r2)(const uint16_t *);

	uint64_t (*r8)(const uint64_t *);

	void (*w)(uint32_t, uint32_t *);

	void (*w8)(uint64_t, uint64_t *);

};



extern struct elf_funcs elf_parser;



static inline uint64_t ehdr64_shoff(Elf_Ehdr *ehdr)

{

	return elf_parser.r8(&ehdr->e64.e_shoff);

}



static inline uint64_t ehdr32_shoff(Elf_Ehdr *ehdr)

{

	return elf_parser.r(&ehdr->e32.e_shoff);

}



static inline uint64_t ehdr_shoff(Elf_Ehdr *ehdr)

{

	return elf_parser.ehdr_shoff(ehdr);

}



#define EHDR_HALF(fn_name)				\

static inline uint16_t ehdr64_##fn_name(Elf_Ehdr *ehdr)	\

{							\

	return elf_parser.r2(&ehdr->e64.e_##fn_name);	\

}							\

							\

static inline uint16_t ehdr32_##fn_name(Elf_Ehdr *ehdr)	\

{							\

	return elf_parser.r2(&ehdr->e32.e_##fn_name);	\

}							\

							\

static inline uint16_t ehdr_##fn_name(Elf_Ehdr *ehdr)	\

{							\

	return elf_parser.ehdr_##fn_name(ehdr);		\

}



EHDR_HALF(shentsize)

EHDR_HALF(shstrndx)

EHDR_HALF(shnum)



#define SHDR_WORD(fn_name)				\

static inline uint32_t shdr64_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r(&shdr->e64.sh_##fn_name);	\

}							\

							\

static inline uint32_t shdr32_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r(&shdr->e32.sh_##fn_name);	\

}							\

							\

static inline uint32_t shdr_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.shdr_##fn_name(shdr);	\

}



#define SHDR_ADDR(fn_name)				\

static inline uint64_t shdr64_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r8(&shdr->e64.sh_##fn_name);	\

}							\

							\

static inline uint64_t shdr32_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r(&shdr->e32.sh_##fn_name);	\

}							\

							\

static inline uint64_t shdr_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.shdr_##fn_name(shdr);		\

}



#define SHDR_WORD(fn_name)				\

static inline uint32_t shdr64_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r(&shdr->e64.sh_##fn_name);	\

}							\

							\

static inline uint32_t shdr32_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.r(&shdr->e32.sh_##fn_name);	\

}							\

static inline uint32_t shdr_##fn_name(Elf_Shdr *shdr)	\

{							\

	return elf_parser.shdr_##fn_name(shdr);		\

}



SHDR_ADDR(addr)

SHDR_ADDR(offset)

SHDR_ADDR(size)

SHDR_ADDR(entsize)



SHDR_WORD(link)

SHDR_WORD(name)

SHDR_WORD(type)



#define SYM_ADDR(fn_name)				\

static inline uint64_t sym64_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r8(&sym->e64.st_##fn_name);	\

}							\

							\

static inline uint64_t sym32_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r(&sym->e32.st_##fn_name);	\

}							\

							\

static inline uint64_t sym_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.sym_##fn_name(sym);		\

}



#define SYM_WORD(fn_name)				\

static inline uint32_t sym64_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r(&sym->e64.st_##fn_name);	\

}							\

							\

static inline uint32_t sym32_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r(&sym->e32.st_##fn_name);	\

}							\

							\

static inline uint32_t sym_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.sym_##fn_name(sym);		\

}



#define SYM_HALF(fn_name)				\

static inline uint16_t sym64_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r2(&sym->e64.st_##fn_name);	\

}							\

							\

static inline uint16_t sym32_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.r2(&sym->e32.st_##fn_name);	\

}							\

							\

static inline uint16_t sym_##fn_name(Elf_Sym *sym)	\

{							\

	return elf_parser.sym_##fn_name(sym);		\

}



static inline uint8_t sym64_type(Elf_Sym *sym)

{

	return ELF64_ST_TYPE(sym->e64.st_info);

}



static inline uint8_t sym32_type(Elf_Sym *sym)

{

	return ELF32_ST_TYPE(sym->e32.st_info);

}



static inline uint8_t sym_type(Elf_Sym *sym)

{

	return elf_parser.sym_type(sym);

}



SYM_ADDR(value)

SYM_WORD(name)

SYM_HALF(shndx)



#define __maybe_unused			__attribute__((__unused__))



#define RELA_ADDR(fn_name)						\

static inline uint64_t rela64_##fn_name(Elf_Rela *rela)			\

{									\

	return elf_parser.r8((uint64_t *)&rela->e64.r_##fn_name);	\

}									\

									\

static inline uint64_t rela32_##fn_name(Elf_Rela *rela)			\

{									\

	return elf_parser.r((uint32_t *)&rela->e32.r_##fn_name);	\

}									\

									\

static inline uint64_t __maybe_unused rela_##fn_name(Elf_Rela *rela)	\

{									\

	return elf_parser.rela_##fn_name(rela);				\

}



RELA_ADDR(offset)

RELA_ADDR(info)

RELA_ADDR(addend)



static inline void rela64_write_addend(Elf_Rela *rela, uint64_t val)

{

	elf_parser.w8(val, (uint64_t *)&rela->e64.r_addend);

}



static inline void rela32_write_addend(Elf_Rela *rela, uint64_t val)

{

	elf_parser.w(val, (uint32_t *)&rela->e32.r_addend);

}



static inline uint32_t rbe(const uint32_t *x)

{

	return get_unaligned_be32(x);

}



static inline uint16_t r2be(const uint16_t *x)

{

	return get_unaligned_be16(x);

}



static inline uint64_t r8be(const uint64_t *x)

{

	return get_unaligned_be64(x);

}



static inline uint32_t rle(const uint32_t *x)

{

	return get_unaligned_le32(x);

}



static inline uint16_t r2le(const uint16_t *x)

{

	return get_unaligned_le16(x);

}



static inline uint64_t r8le(const uint64_t *x)

{

	return get_unaligned_le64(x);

}



static inline void wbe(uint32_t val, uint32_t *x)

{

	put_unaligned_be32(val, x);

}



static inline void wle(uint32_t val, uint32_t *x)

{

	put_unaligned_le32(val, x);

}



static inline void w8be(uint64_t val, uint64_t *x)

{

	put_unaligned_be64(val, x);

}



static inline void w8le(uint64_t val, uint64_t *x)

{

	put_unaligned_le64(val, x);

}



void *elf_map(char const *fname, size_t *size, uint32_t types);

void elf_unmap(void *addr, size_t size);

int elf_map_machine(void *addr);

int elf_map_long_size(void *addr);



#endif /* _SCRIPTS_ELF_PARSE_H */

scripts/sorttable.c

+34 −443

File changed.

Preview size limit exceeded, changes collapsed.