On Thu, Aug 22, 2024 at 2:25 AM Tony Ambardar <[email protected]> wrote:
>
> From: Tony Ambardar <[email protected]>
>
> 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: Tony Ambardar <[email protected]>
> ---
> tools/lib/bpf/linker.c | 106 ++++++++++++++++++++++++++++++++++-------
> 1 file changed, 90 insertions(+), 16 deletions(-)
>
Mostly just stylistic and code organization nits, the change overall looks good.
> diff --git a/tools/lib/bpf/linker.c b/tools/lib/bpf/linker.c
> index 7489306cd6f7..9bf218db443e 100644
> --- a/tools/lib/bpf/linker.c
> +++ b/tools/lib/bpf/linker.c
> @@ -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];
nit: not a fan of pointer into e_ident, just read local value of byte
order, and then assign it directly below (it's only in one of the
branches, no duplication, really)
> +#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_elf("unsupported byte order of ELF file %s",
> filename);
> + pr_warn("linker: unknown byte order of ELF file %s\n",
> filename);
> return err;
> }
> + if (*link_byteorder == ELFDATANONE) {
> + *link_byteorder = obj_byteorder;
see above, I'd prefer:
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("linker: 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,27 @@ 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 int 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;
> +
> + if (size % sizeof(struct bpf_insn))
> + return -EINVAL;
> + for (i = 0; i < insn_cnt; i++, insn++)
> + bpf_insn_bswap(insn);
> + return 0;
> +}
> +
> static int extend_sec(struct bpf_linker *linker, struct dst_sec *dst, struct
> src_sec *src)
> {
> void *tmp;
> @@ -1170,6 +1203,16 @@ 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)) {
> + err = exec_sec_bswap(dst->raw_data + dst_align_sz,
> + src->shdr->sh_size);
nit: I think exec_sec_bswap() shouldn't ever fail, so given we have
is_exec_sec() now, let's do the size alignment check early on (and
regardless of swapped_endian), and then just proceed with byte swap
that can't fail
> + if (err) {
> + pr_warn("%s: error changing insns
> endianness\n", __func__);
> + return err;
> + }
> + }
> }
>
> dst->sec_sz = dst_final_sz;
> @@ -2630,6 +2673,14 @@ 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)) {
> + err = exec_sec_bswap(sec->raw_data, sec->sec_sz);
and here we'll know that size is validly aligned anyways, so no checks required
> + if (err) {
> + pr_warn("error finalizing insns
> endianness\n");
> + return libbpf_err(err);
> + }
> + }
> sec->data->d_buf = sec->raw_data;
> }
>
> @@ -2696,6 +2747,13 @@ static int emit_elf_data_sec(struct bpf_linker
> *linker, const char *sec_name,
> return 0;
> }
>
> +static enum btf_endianness
> +linker_btf_endianness(const struct bpf_linker *linker)
> +{
> + unsigned char byteorder = linker->elf_hdr->e_ident[EI_DATA];
empty line between variable declaration and the rest of the code
> + return byteorder == ELFDATA2MSB ? BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN;
> +}
> +
but actually, this whole helper function seems unnecessary, just do
everything inside finalize_btf, it's a pretty trivial piece of logic
> static int finalize_btf(struct bpf_linker *linker)
> {
> LIBBPF_OPTS(btf_dedup_opts, opts);
> @@ -2742,6 +2800,22 @@ static int finalize_btf(struct bpf_linker *linker)
> return err;
> }
>
> + /* Set .BTF and .BTF.ext output byte order */
> + err = btf__set_endianness(linker->btf,
> + linker_btf_endianness(linker));
> + if (err) {
> + pr_warn("failed to set .BTF output endianness: %d\n", err);
nit: you used "linker: " prefix for messages like this, stay consistent?
> + return err;
> + }
> + if (linker->btf_ext) {
> + err = btf_ext__set_endianness(linker->btf_ext,
> + linker_btf_endianness(linker));
> + if (err) {
> + pr_warn("failed to set .BTF.ext output endianness:
> %d\n", err);
> + return err;
> + }
> + }
> +
> /* Emit .BTF section */
> raw_data = btf__raw_data(linker->btf, &raw_sz);
> if (!raw_data)
> --
> 2.34.1
>
