1747 lines · 37.5 KB · C
RawDownload
/* * Common eBPF ELF object loading operations. * * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org> * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com> * Copyright (C) 2015 Huawei Inc. * Copyright (C) 2017 Nicira, Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License (not later!) * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this program; if not,  see <http://www.gnu.org/licenses> */ #include <stdlib.h>#include <stdio.h>#include <stdarg.h>#include <libgen.h>#include <inttypes.h>#include <string.h>#include <unistd.h>#include <fcntl.h>#include <errno.h>#include <asm/unistd.h>#include <linux/err.h>#include <linux/kernel.h>#include <linux/bpf.h>#include <linux/list.h>#include <linux/limits.h>#include <sys/stat.h>#include <sys/types.h>#include <sys/vfs.h>#include <libelf.h>#include <gelf.h> #include "libbpf.h"#include "bpf.h" #ifndef EM_BPF#define EM_BPF 247#endif #ifndef BPF_FS_MAGIC#define BPF_FS_MAGIC		0xcafe4a11#endif #define __printf(a, b)	__attribute__((format(printf, a, b))) __printf(1, 2)static int __base_pr(const char *format, ...){	va_list args;	int err; 	va_start(args, format);	err = vfprintf(stderr, format, args);	va_end(args);	return err;} static __printf(1, 2) libbpf_print_fn_t __pr_warning = __base_pr;static __printf(1, 2) libbpf_print_fn_t __pr_info = __base_pr;static __printf(1, 2) libbpf_print_fn_t __pr_debug; #define __pr(func, fmt, ...)	\do {				\	if ((func))		\		(func)("libbpf: " fmt, ##__VA_ARGS__); \} while (0) #define pr_warning(fmt, ...)	__pr(__pr_warning, fmt, ##__VA_ARGS__)#define pr_info(fmt, ...)	__pr(__pr_info, fmt, ##__VA_ARGS__)#define pr_debug(fmt, ...)	__pr(__pr_debug, fmt, ##__VA_ARGS__) void libbpf_set_print(libbpf_print_fn_t warn,		      libbpf_print_fn_t info,		      libbpf_print_fn_t debug){	__pr_warning = warn;	__pr_info = info;	__pr_debug = debug;} #define STRERR_BUFSIZE  128 #define ERRNO_OFFSET(e)		((e) - __LIBBPF_ERRNO__START)#define ERRCODE_OFFSET(c)	ERRNO_OFFSET(LIBBPF_ERRNO__##c)#define NR_ERRNO	(__LIBBPF_ERRNO__END - __LIBBPF_ERRNO__START) static const char *libbpf_strerror_table[NR_ERRNO] = {	[ERRCODE_OFFSET(LIBELF)]	= "Something wrong in libelf",	[ERRCODE_OFFSET(FORMAT)]	= "BPF object format invalid",	[ERRCODE_OFFSET(KVERSION)]	= "'version' section incorrect or lost",	[ERRCODE_OFFSET(ENDIAN)]	= "Endian mismatch",	[ERRCODE_OFFSET(INTERNAL)]	= "Internal error in libbpf",	[ERRCODE_OFFSET(RELOC)]		= "Relocation failed",	[ERRCODE_OFFSET(VERIFY)]	= "Kernel verifier blocks program loading",	[ERRCODE_OFFSET(PROG2BIG)]	= "Program too big",	[ERRCODE_OFFSET(KVER)]		= "Incorrect kernel version",	[ERRCODE_OFFSET(PROGTYPE)]	= "Kernel doesn't support this program type",}; int libbpf_strerror(int err, char *buf, size_t size){	if (!buf || !size)		return -1; 	err = err > 0 ? err : -err; 	if (err < __LIBBPF_ERRNO__START) {		int ret; 		ret = strerror_r(err, buf, size);		buf[size - 1] = '\0';		return ret;	} 	if (err < __LIBBPF_ERRNO__END) {		const char *msg; 		msg = libbpf_strerror_table[ERRNO_OFFSET(err)];		snprintf(buf, size, "%s", msg);		buf[size - 1] = '\0';		return 0;	} 	snprintf(buf, size, "Unknown libbpf error %d", err);	buf[size - 1] = '\0';	return -1;} #define CHECK_ERR(action, err, out) do {	\	err = action;			\	if (err)			\		goto out;		\} while(0)  /* Copied from tools/perf/util/util.h */#ifndef zfree# define zfree(ptr) ({ free(*ptr); *ptr = NULL; })#endif #ifndef zclose# define zclose(fd) ({			\	int ___err = 0;			\	if ((fd) >= 0)			\		___err = close((fd));	\	fd = -1;			\	___err; })#endif #ifdef HAVE_LIBELF_MMAP_SUPPORT# define LIBBPF_ELF_C_READ_MMAP ELF_C_READ_MMAP#else# define LIBBPF_ELF_C_READ_MMAP ELF_C_READ#endif /* * bpf_prog should be a better name but it has been used in * linux/filter.h. */struct bpf_program {	/* Index in elf obj file, for relocation use. */	int idx;	char *section_name;	struct bpf_insn *insns;	size_t insns_cnt;	enum bpf_prog_type type; 	struct {		int insn_idx;		int map_idx;	} *reloc_desc;	int nr_reloc; 	struct {		int nr;		int *fds;	} instances;	bpf_program_prep_t preprocessor; 	struct bpf_object *obj;	void *priv;	bpf_program_clear_priv_t clear_priv;}; struct bpf_map {	int fd;	char *name;	size_t offset;	struct bpf_map_def def;	void *priv;	bpf_map_clear_priv_t clear_priv;}; static LIST_HEAD(bpf_objects_list); struct bpf_object {	char license[64];	u32 kern_version; 	struct bpf_program *programs;	size_t nr_programs;	struct bpf_map *maps;	size_t nr_maps; 	bool loaded; 	/*	 * Information when doing elf related work. Only valid if fd	 * is valid.	 */	struct {		int fd;		void *obj_buf;		size_t obj_buf_sz;		Elf *elf;		GElf_Ehdr ehdr;		Elf_Data *symbols;		size_t strtabidx;		struct {			GElf_Shdr shdr;			Elf_Data *data;		} *reloc;		int nr_reloc;		int maps_shndx;	} efile;	/*	 * All loaded bpf_object is linked in a list, which is	 * hidden to caller. bpf_objects__<func> handlers deal with	 * all objects.	 */	struct list_head list; 	void *priv;	bpf_object_clear_priv_t clear_priv; 	char path[];};#define obj_elf_valid(o)	((o)->efile.elf) static void bpf_program__unload(struct bpf_program *prog){	int i; 	if (!prog)		return; 	/*	 * If the object is opened but the program was never loaded,	 * it is possible that prog->instances.nr == -1.	 */	if (prog->instances.nr > 0) {		for (i = 0; i < prog->instances.nr; i++)			zclose(prog->instances.fds[i]);	} else if (prog->instances.nr != -1) {		pr_warning("Internal error: instances.nr is %d\n",			   prog->instances.nr);	} 	prog->instances.nr = -1;	zfree(&prog->instances.fds);} static void bpf_program__exit(struct bpf_program *prog){	if (!prog)		return; 	if (prog->clear_priv)		prog->clear_priv(prog, prog->priv); 	prog->priv = NULL;	prog->clear_priv = NULL; 	bpf_program__unload(prog);	zfree(&prog->section_name);	zfree(&prog->insns);	zfree(&prog->reloc_desc); 	prog->nr_reloc = 0;	prog->insns_cnt = 0;	prog->idx = -1;} static intbpf_program__init(void *data, size_t size, char *name, int idx,		    struct bpf_program *prog){	if (size < sizeof(struct bpf_insn)) {		pr_warning("corrupted section '%s'\n", name);		return -EINVAL;	} 	bzero(prog, sizeof(*prog)); 	prog->section_name = strdup(name);	if (!prog->section_name) {		pr_warning("failed to alloc name for prog %s\n",			   name);		goto errout;	} 	prog->insns = malloc(size);	if (!prog->insns) {		pr_warning("failed to alloc insns for %s\n", name);		goto errout;	}	prog->insns_cnt = size / sizeof(struct bpf_insn);	memcpy(prog->insns, data,	       prog->insns_cnt * sizeof(struct bpf_insn));	prog->idx = idx;	prog->instances.fds = NULL;	prog->instances.nr = -1;	prog->type = BPF_PROG_TYPE_KPROBE; 	return 0;errout:	bpf_program__exit(prog);	return -ENOMEM;} static intbpf_object__add_program(struct bpf_object *obj, void *data, size_t size,			char *name, int idx){	struct bpf_program prog, *progs;	int nr_progs, err; 	err = bpf_program__init(data, size, name, idx, &prog);	if (err)		return err; 	progs = obj->programs;	nr_progs = obj->nr_programs; 	progs = realloc(progs, sizeof(progs[0]) * (nr_progs + 1));	if (!progs) {		/*		 * In this case the original obj->programs		 * is still valid, so don't need special treat for		 * bpf_close_object().		 */		pr_warning("failed to alloc a new program '%s'\n",			   name);		bpf_program__exit(&prog);		return -ENOMEM;	} 	pr_debug("found program %s\n", prog.section_name);	obj->programs = progs;	obj->nr_programs = nr_progs + 1;	prog.obj = obj;	progs[nr_progs] = prog;	return 0;} static struct bpf_object *bpf_object__new(const char *path,					  void *obj_buf,					  size_t obj_buf_sz){	struct bpf_object *obj; 	obj = calloc(1, sizeof(struct bpf_object) + strlen(path) + 1);	if (!obj) {		pr_warning("alloc memory failed for %s\n", path);		return ERR_PTR(-ENOMEM);	} 	strcpy(obj->path, path);	obj->efile.fd = -1; 	/*	 * Caller of this function should also calls	 * bpf_object__elf_finish() after data collection to return	 * obj_buf to user. If not, we should duplicate the buffer to	 * avoid user freeing them before elf finish.	 */	obj->efile.obj_buf = obj_buf;	obj->efile.obj_buf_sz = obj_buf_sz;	obj->efile.maps_shndx = -1; 	obj->loaded = false; 	INIT_LIST_HEAD(&obj->list);	list_add(&obj->list, &bpf_objects_list);	return obj;} static void bpf_object__elf_finish(struct bpf_object *obj){	if (!obj_elf_valid(obj))		return; 	if (obj->efile.elf) {		elf_end(obj->efile.elf);		obj->efile.elf = NULL;	}	obj->efile.symbols = NULL; 	zfree(&obj->efile.reloc);	obj->efile.nr_reloc = 0;	zclose(obj->efile.fd);	obj->efile.obj_buf = NULL;	obj->efile.obj_buf_sz = 0;} static int bpf_object__elf_init(struct bpf_object *obj){	int err = 0;	GElf_Ehdr *ep; 	if (obj_elf_valid(obj)) {		pr_warning("elf init: internal error\n");		return -LIBBPF_ERRNO__LIBELF;	} 	if (obj->efile.obj_buf_sz > 0) {		/*		 * obj_buf should have been validated by		 * bpf_object__open_buffer().		 */		obj->efile.elf = elf_memory(obj->efile.obj_buf,					    obj->efile.obj_buf_sz);	} else {		obj->efile.fd = open(obj->path, O_RDONLY);		if (obj->efile.fd < 0) {			pr_warning("failed to open %s: %s\n", obj->path,					strerror(errno));			return -errno;		} 		obj->efile.elf = elf_begin(obj->efile.fd,				LIBBPF_ELF_C_READ_MMAP,				NULL);	} 	if (!obj->efile.elf) {		pr_warning("failed to open %s as ELF file\n",				obj->path);		err = -LIBBPF_ERRNO__LIBELF;		goto errout;	} 	if (!gelf_getehdr(obj->efile.elf, &obj->efile.ehdr)) {		pr_warning("failed to get EHDR from %s\n",				obj->path);		err = -LIBBPF_ERRNO__FORMAT;		goto errout;	}	ep = &obj->efile.ehdr; 	/* Old LLVM set e_machine to EM_NONE */	if ((ep->e_type != ET_REL) || (ep->e_machine && (ep->e_machine != EM_BPF))) {		pr_warning("%s is not an eBPF object file\n",			obj->path);		err = -LIBBPF_ERRNO__FORMAT;		goto errout;	} 	return 0;errout:	bpf_object__elf_finish(obj);	return err;} static intbpf_object__check_endianness(struct bpf_object *obj){	static unsigned int const endian = 1; 	switch (obj->efile.ehdr.e_ident[EI_DATA]) {	case ELFDATA2LSB:		/* We are big endian, BPF obj is little endian. */		if (*(unsigned char const *)&endian != 1)			goto mismatch;		break; 	case ELFDATA2MSB:		/* We are little endian, BPF obj is big endian. */		if (*(unsigned char const *)&endian != 0)			goto mismatch;		break;	default:		return -LIBBPF_ERRNO__ENDIAN;	} 	return 0; mismatch:	pr_warning("Error: endianness mismatch.\n");

Lines 1–500 of 1747.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t