Commit 0aed726c authored by Tony Ambardar's avatar Tony Ambardar Committed by Alexei Starovoitov
Browse files

libbpf: Support linking bpf objects of either endianness 



Allow static linking object files of either endianness, checking that input
files have consistent byte-order, and setting output endianness from input.

Linking requires in-memory processing of programs, relocations, sections,
etc. in native endianness, and output conversion to target byte-order. This
is enabled by built-in ELF translation and recent BTF/BTF.ext endianness
functions. Further add local functions for swapping byte-order of sections
containing BPF insns.

Signed-off-by: default avatarTony Ambardar <tony.ambardar@gmail.com>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/b47ca686d02664843fc99b96262fe3259650bc43.1726475448.git.tony.ambardar@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent bcc60abd

tools/lib/bpf/linker.c

+62 −16
Original line number Diff line number Diff line
@@ -135,6 +135,7 @@ struct bpf_linker { 
	int fd;

	Elf *elf;

	Elf64_Ehdr *elf_hdr;

	bool swapped_endian;



	/* Output sections metadata */

	struct dst_sec *secs;
@@ -324,13 +325,8 @@ static int init_output_elf(struct bpf_linker *linker, const char *file) 


	linker->elf_hdr->e_machine = EM_BPF;

	linker->elf_hdr->e_type = ET_REL;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

	linker->elf_hdr->e_ident[EI_DATA] = ELFDATA2LSB;

#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

	linker->elf_hdr->e_ident[EI_DATA] = ELFDATA2MSB;

#else

#error "Unknown __BYTE_ORDER__"

#endif

	/* Set unknown ELF endianness, assign later from input files */

	linker->elf_hdr->e_ident[EI_DATA] = ELFDATANONE;



	/* STRTAB */

	/* initialize strset with an empty string to conform to ELF */
@@ -541,19 +537,21 @@ static int linker_load_obj_file(struct bpf_linker *linker, const char *filename, 
				const struct bpf_linker_file_opts *opts,

				struct src_obj *obj)

{

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

	const int host_endianness = ELFDATA2LSB;

#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

	const int host_endianness = ELFDATA2MSB;

#else

#error "Unknown __BYTE_ORDER__"

#endif

	int err = 0;

	Elf_Scn *scn;

	Elf_Data *data;

	Elf64_Ehdr *ehdr;

	Elf64_Shdr *shdr;

	struct src_sec *sec;

	unsigned char obj_byteorder;

	unsigned char link_byteorder = linker->elf_hdr->e_ident[EI_DATA];

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

	const unsigned char host_byteorder = ELFDATA2LSB;

#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

	const unsigned char host_byteorder = ELFDATA2MSB;

#else

#error "Unknown __BYTE_ORDER__"

#endif



	pr_debug("linker: adding object file '%s'...\n", filename);
@@ -579,11 +577,25 @@ static int linker_load_obj_file(struct bpf_linker *linker, const char *filename, 
		pr_warn_elf("failed to get ELF header for %s", filename);

		return err;

	}

	if (ehdr->e_ident[EI_DATA] != host_endianness) {



	/* Linker output endianness set by first input object */

	obj_byteorder = ehdr->e_ident[EI_DATA];

	if (obj_byteorder != ELFDATA2LSB && obj_byteorder != ELFDATA2MSB) {

		err = -EOPNOTSUPP;

		pr_warn("unknown byte order of ELF file %s\n", filename);

		return err;

	}

	if (link_byteorder == ELFDATANONE) {

		linker->elf_hdr->e_ident[EI_DATA] = obj_byteorder;

		linker->swapped_endian = obj_byteorder != host_byteorder;

		pr_debug("linker: set %s-endian output byte order\n",

			 obj_byteorder == ELFDATA2MSB ? "big" : "little");

	} else if (link_byteorder != obj_byteorder) {

		err = -EOPNOTSUPP;

		pr_warn_elf("unsupported byte order of ELF file %s", filename);

		pr_warn("byte order mismatch with ELF file %s\n", filename);

		return err;

	}



	if (ehdr->e_type != ET_REL

	    || ehdr->e_machine != EM_BPF

	    || ehdr->e_ident[EI_CLASS] != ELFCLASS64) {
@@ -1111,6 +1123,24 @@ static bool sec_content_is_same(struct dst_sec *dst_sec, struct src_sec *src_sec 
	return true;

}



static bool is_exec_sec(struct dst_sec *sec)

{

	if (!sec || sec->ephemeral)

		return false;

	return (sec->shdr->sh_type == SHT_PROGBITS) &&

	       (sec->shdr->sh_flags & SHF_EXECINSTR);

}



static void exec_sec_bswap(void *raw_data, int size)

{

	const int insn_cnt = size / sizeof(struct bpf_insn);

	struct bpf_insn *insn = raw_data;

	int i;



	for (i = 0; i < insn_cnt; i++, insn++)

		bpf_insn_bswap(insn);

}



static int extend_sec(struct bpf_linker *linker, struct dst_sec *dst, struct src_sec *src)

{

	void *tmp;
@@ -1170,6 +1200,10 @@ static int extend_sec(struct bpf_linker *linker, struct dst_sec *dst, struct src 
		memset(dst->raw_data + dst->sec_sz, 0, dst_align_sz - dst->sec_sz);

		/* now copy src data at a properly aligned offset */

		memcpy(dst->raw_data + dst_align_sz, src->data->d_buf, src->shdr->sh_size);



		/* convert added bpf insns to native byte-order */

		if (linker->swapped_endian && is_exec_sec(dst))

			exec_sec_bswap(dst->raw_data + dst_align_sz, src->shdr->sh_size);

	}



	dst->sec_sz = dst_final_sz;
@@ -2630,6 +2664,10 @@ int bpf_linker__finalize(struct bpf_linker *linker) 
		if (!sec->scn)

			continue;



		/* restore sections with bpf insns to target byte-order */

		if (linker->swapped_endian && is_exec_sec(sec))

			exec_sec_bswap(sec->raw_data, sec->sec_sz);



		sec->data->d_buf = sec->raw_data;

	}
@@ -2698,6 +2736,7 @@ static int emit_elf_data_sec(struct bpf_linker *linker, const char *sec_name, 


static int finalize_btf(struct bpf_linker *linker)

{

	enum btf_endianness link_endianness;

	LIBBPF_OPTS(btf_dedup_opts, opts);

	struct btf *btf = linker->btf;

	const void *raw_data;
@@ -2742,6 +2781,13 @@ static int finalize_btf(struct bpf_linker *linker) 
		return err;

	}



	/* Set .BTF and .BTF.ext output byte order */

	link_endianness = linker->elf_hdr->e_ident[EI_DATA] == ELFDATA2MSB ?

			  BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;

	btf__set_endianness(linker->btf, link_endianness);

	if (linker->btf_ext)

		btf_ext__set_endianness(linker->btf_ext, link_endianness);



	/* Emit .BTF section */

	raw_data = btf__raw_data(linker->btf, &raw_sz);

	if (!raw_data)