[PATCH 0/8] tools lib bpf: fixes and functional upgrade

The include of err.h is not explicitely needed in exported
functions and it was causing include conflict with some existing
code due to redefining some macros.

To fix this, let's have error handling functions provided by the
library. Furthermore this will allow user to have an homogeneous
API.

Signed-off-by: Eric Leblond <redacted>
---
  tools/lib/bpf/libbpf.c | 11 +++++++++++
  tools/lib/bpf/libbpf.h |  4 +++-
  2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index b699aea..90932f1 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c

@@ -31,6 +31,7 @@
  #include <linux/kernel.h>
  #include <linux/bpf.h>
  #include <linux/list.h>
+#include <linux/err.h>
  #include <libelf.h>
  #include <gelf.h>
  

@@ -1447,3 +1448,13 @@ bpf_object__find_map_by_name(struct bpf_object *obj, const char *name)
  	}
  	return NULL;
  }
+
+bool bpf__is_error(const void *ptr)

---
  tools/include/uapi/linux/bpf.h | 52 ++++++++++++++++++++++++++++++++++++++++++
  1 file changed, 52 insertions(+)

diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index 9e5fc16..570287f 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h

@@ -95,6 +95,8 @@ enum bpf_prog_type {
  	BPF_PROG_TYPE_SCHED_ACT,
  	BPF_PROG_TYPE_TRACEPOINT,
  	BPF_PROG_TYPE_XDP,
+	BPF_PROG_TYPE_PERF_EVENT,
+	__MAX_BPF_PROG_TYPE,
  };
  
  #define BPF_PSEUDO_MAP_FD	1

@@ -375,6 +377,56 @@ enum bpf_func_id {
  	 */
  	BPF_FUNC_probe_write_user,
  
+	/**
+	 * bpf_current_task_under_cgroup(map, index) - Check cgroup2 membership of current task
+	 * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
+	 * @index: index of the cgroup in the bpf_map
+	 * Return:
+	 *   == 0 current failed the cgroup2 descendant test
+	 *   == 1 current succeeded the cgroup2 descendant test
+	 *    < 0 error
+	 */
+	BPF_FUNC_current_task_under_cgroup,
+
+	/**
+	 * bpf_skb_change_tail(skb, len, flags)
+	 * The helper will resize the skb to the given new size,
+	 * to be used f.e. with control messages.
+	 * @skb: pointer to skb
+	 * @len: new skb length
+	 * @flags: reserved
+	 * Return: 0 on success or negative error
+	 */
+	BPF_FUNC_skb_change_tail,
+
+	/**
+	 * bpf_skb_pull_data(skb, len)
+	 * The helper will pull in non-linear data in case the
+	 * skb is non-linear and not all of len are part of the
+	 * linear section. Only needed for read/write with direct
+	 * packet access.
+	 * @skb: pointer to skb
+	 * @len: len to make read/writeable
+	 * Return: 0 on success or negative error
+	 */
+	BPF_FUNC_skb_pull_data,
+
+	/**
+	 * bpf_csum_update(skb, csum)
+	 * Adds csum into skb->csum in case of CHECKSUM_COMPLETE.
+	 * @skb: pointer to skb
+	 * @csum: csum to add
+	 * Return: csum on success or negative error
+	 */
+	BPF_FUNC_csum_update,
+
+	/**
+	 * bpf_set_hash_invalid(skb)
+	 * Invalidate current skb>hash.
+	 * @skb: pointer to skb
+	 */
+	BPF_FUNC_set_hash_invalid,
+
  	__BPF_FUNC_MAX_ID,
  };
  

Current API was not allowing the user to set a type like socket
filter. To avoid a setter function for each type, the patch simply
exports a set function that takes the type in parameter.

Signed-off-by: Eric Leblond <redacted>
---
  tools/lib/bpf/libbpf.c | 19 +++++++++----------
  tools/lib/bpf/libbpf.h |  3 +++
  2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 90932f1..7cd341e 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c

@@ -1336,26 +1336,25 @@ int bpf_program__nth_fd(struct bpf_program *prog, int n)
  	return fd;
  }
  
-static void bpf_program__set_type(struct bpf_program *prog,
-				  enum bpf_prog_type type)
+int bpf_program__set_type(struct bpf_program *prog, unsigned int type)
  {
+	if (!prog)
+		return -EINVAL;
+	if (type >= __MAX_BPF_PROG_TYPE)
+		return -EINVAL;
+
  	prog->type = type;
+	return 0;
  }
  
  int bpf_program__set_tracepoint(struct bpf_program *prog)
  {
-	if (!prog)
-		return -EINVAL;
-	bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
-	return 0;
+	return bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
  }
  
  int bpf_program__set_kprobe(struct bpf_program *prog)
  {
-	if (!prog)
-		return -EINVAL;
-	bpf_program__set_type(prog, BPF_PROG_TYPE_KPROBE);
-	return 0;
+	return bpf_program__set_type(prog, BPF_PROG_TYPE_KPROBE);
  }
  
  static bool bpf_program__is_type(struct bpf_program *prog,

diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index e40c8d3..a18783b 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h

@@ -173,6 +173,9 @@ int bpf_program__set_kprobe(struct bpf_program *prog);
  bool bpf_program__is_tracepoint(struct bpf_program *prog);
  bool bpf_program__is_kprobe(struct bpf_program *prog);
  
+int bpf_program__set_type(struct bpf_program *prog,
+				  unsigned int type);
+

Some functions were missing in the library to be able to use it
in the case where the userspace is handling the maps in kernel.

The patch also renames functions to have a homogeneous naming
convention.

Signed-off-by: Eric Leblond <redacted>
---
  tools/lib/bpf/bpf.c    | 35 ++++++++++++++++++++++++++++++++++-
  tools/lib/bpf/bpf.h    |  2 --
  tools/lib/bpf/libbpf.h |  5 +++++
  3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 4212ed6..c0e07bd 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c

@@ -25,6 +25,7 @@
  #include <asm/unistd.h>
  #include <linux/bpf.h>
  #include "bpf.h"
+#include "libbpf.h"
  
  /*
   * When building perf, unistd.h is overrided. __NR_bpf is

@@ -97,7 +98,7 @@ int bpf_load_program(enum bpf_prog_type type, struct bpf_insn *insns,
  	return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
  }
  
-int bpf_map_update_elem(int fd, void *key, void *value,
+int bpf_map__update_elem(int fd, void *key, void *value,
  			u64 flags)

  {
  	union bpf_attr attr;

@@ -110,3 +111,35 @@ int bpf_map_update_elem(int fd, void *key, void *value,
  
  	return sys_bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
  }
+
+int bpf_map__lookup_elem(int fd, void *key, void *value)
+{
+	union bpf_attr attr = {
+		.map_fd = fd,
+		.key = ptr_to_u64(key),
+		.value = ptr_to_u64(value),
+	};
+
+	return sys_bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
+}
+
+int bpf_map__delete_elem(int fd, void *key)
+{
+	union bpf_attr attr = {
+		.map_fd = fd,
+		.key = ptr_to_u64(key),
+	};
+
+	return sys_bpf(BPF_MAP_DELETE_ELEM, &attr, sizeof(attr));
+}
+
+int bpf_map__get_next_key(int fd, void *key, void *next_key)
+{
+	union bpf_attr attr = {
+		.map_fd = fd,
+		.key = ptr_to_u64(key),
+		.next_key = ptr_to_u64(next_key),
+	};
+
+	return sys_bpf(BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr));
+}

diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index e8ba540..5ca834a 100644
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h

@@ -33,6 +33,4 @@ int bpf_load_program(enum bpf_prog_type type, struct bpf_insn *insns,
  		     u32 kern_version, char *log_buf,
  		     size_t log_buf_sz);
  
-int bpf_map_update_elem(int fd, void *key, void *value,
-			u64 flags);
  #endif

diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index a18783b..dfb46d0 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h

@@ -207,6 +207,11 @@ bpf_map__next(struct bpf_map *map, struct bpf_object *obj);
  int bpf_map__fd(struct bpf_map *map);
  const struct bpf_map_def *bpf_map__def(struct bpf_map *map);
  const char *bpf_map__name(struct bpf_map *map);
+int bpf_map__update_elem(int fd, void *key, void *value,
+			uint64_t flags);
+int bpf_map__lookup_elem(int fd, void *key, void *value);
+int bpf_map__delete_elem(int fd, void *key);
+int bpf_map__get_next_key(int fd, void *key, void *next_key);

---
  tools/lib/bpf/libbpf.c | 3 ++-
  1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 7cd341e..1fe4532 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c

@@ -802,7 +802,8 @@ bpf_object__create_maps(struct bpf_object *obj)
  			size_t j;
  			int err = *pfd;
  
-			pr_warning("failed to create map: %s\n",
+			pr_warning("failed to create map (name: '%s'): %s\n",
+				   obj->maps[i].name,
  				   strerror(errno));
  			for (j = 0; j < i; j++)
  				zclose(obj->maps[j].fd);

It is not correct to assimilate the elf data of the maps section
to an array of map definition. In fact the sizes differ. The
offset provided in the symbol section has to be used instead.

This patch fixes a bug causing a elf with two maps not to load
correctly.

Signed-off-by: Eric Leblond <redacted>
---
  tools/lib/bpf/libbpf.c | 50 +++++++++++++++++++++++++++++++++++---------------
  1 file changed, 35 insertions(+), 15 deletions(-)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 1fe4532..f72628b 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c

@@ -186,6 +186,7 @@ struct bpf_program {
  struct bpf_map {
  	int fd;
  	char *name;
+	size_t offset;
  	struct bpf_map_def def;
  	void *priv;
  	bpf_map_clear_priv_t clear_priv;

@@ -529,13 +530,6 @@ bpf_object__init_maps(struct bpf_object *obj, void *data,
  
  	pr_debug("maps in %s: %zd bytes\n", obj->path, size);
  
-	obj->maps = calloc(nr_maps, sizeof(obj->maps[0]));
-	if (!obj->maps) {
-		pr_warning("alloc maps for object failed\n");
-		return -ENOMEM;
-	}
-	obj->nr_maps = nr_maps;
-
  	for (i = 0; i < nr_maps; i++) {
  		struct bpf_map_def *def = &obj->maps[i].def;
  

@@ -547,23 +541,42 @@ bpf_object__init_maps(struct bpf_object *obj, void *data,
  		obj->maps[i].fd = -1;
  
  		/* Save map definition into obj->maps */
-		*def = ((struct bpf_map_def *)data)[i];
+		*def = *(struct bpf_map_def *)(data + obj->maps[i].offset);
  	}
  	return 0;
  }
  
  static int
-bpf_object__init_maps_name(struct bpf_object *obj)
+bpf_object__init_maps_symbol(struct bpf_object *obj)
  {
  	int i;
+	int nr_maps = 0;
  	Elf_Data *symbols = obj->efile.symbols;
+	size_t map_idx = 0;
  
  	if (!symbols || obj->efile.maps_shndx < 0)
  		return -EINVAL;
  
+	/* get the number of maps */
+	for (i = 0; i < symbols->d_size / sizeof(GElf_Sym); i++) {
+		GElf_Sym sym;
+
+		if (!gelf_getsym(symbols, i, &sym))
+			continue;
+		if (sym.st_shndx != obj->efile.maps_shndx)
+			continue;
+		nr_maps++;
+	}
+
+	obj->maps = calloc(nr_maps, sizeof(obj->maps[0]));
+	if (!obj->maps) {
+		pr_warning("alloc maps for object failed\n");
+		return -ENOMEM;
+	}
+	obj->nr_maps = nr_maps;
+
  	for (i = 0; i < symbols->d_size / sizeof(GElf_Sym); i++) {
  		GElf_Sym sym;
-		size_t map_idx;
  		const char *map_name;
  
  		if (!gelf_getsym(symbols, i, &sym))

@@ -574,12 +587,12 @@ bpf_object__init_maps_name(struct bpf_object *obj)
  		map_name = elf_strptr(obj->efile.elf,
  				      obj->efile.strtabidx,
  				      sym.st_name);
-		map_idx = sym.st_value / sizeof(struct bpf_map_def);
  		if (map_idx >= obj->nr_maps) {
  			pr_warning("index of map \"%s\" is buggy: %zu > %zu\n",
  				   map_name, map_idx, obj->nr_maps);
  			continue;
  		}
+		obj->maps[map_idx].offset = sym.st_value;
  		obj->maps[map_idx].name = strdup(map_name);
  		if (!obj->maps[map_idx].name) {
  			pr_warning("failed to alloc map name\n");

@@ -587,6 +600,7 @@ bpf_object__init_maps_name(struct bpf_object *obj)
  		}
  		pr_debug("map %zu is \"%s\"\n", map_idx,
  			 obj->maps[map_idx].name);
+		map_idx++;
  	}
  	return 0;
  }

@@ -647,8 +661,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
  							data->d_buf,
  							data->d_size);
  		else if (strcmp(name, "maps") == 0) {
-			err = bpf_object__init_maps(obj, data->d_buf,
-						    data->d_size);
  			obj->efile.maps_shndx = idx;
  		} else if (sh.sh_type == SHT_SYMTAB) {
  			if (obj->efile.symbols) {

@@ -698,8 +710,16 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
  		pr_warning("Corrupted ELF file: index of strtab invalid\n");
  		return LIBBPF_ERRNO__FORMAT;
  	}
-	if (obj->efile.maps_shndx >= 0)
-		err = bpf_object__init_maps_name(obj);
+	if (obj->efile.maps_shndx >= 0) {
+		Elf_Data *data;
+		err = bpf_object__init_maps_symbol(obj);
+		if (err)
+			goto out;
+
+		scn = elf_getscn(elf, obj->efile.maps_shndx);
+		data = elf_getdata(scn, 0);
+		err = bpf_object__init_maps(obj, data->d_buf, data->d_size);
+	}
  out:
  	return err;
  }

It is not correct to assimilate the elf data of the maps section
to an array of map definition. In fact the sizes differ. The
offset provided in the symbol section has to be used instead.

This patch fixes a bug causing a elf with two maps not to load
correctly.

Signed-off-by: Eric Leblond <redacted>
---
  tools/lib/bpf/libbpf.c | 50 +++++++++++++++++++++++++++++++++++---------------
  1 file changed, 35 insertions(+), 15 deletions(-)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 1fe4532..f72628b 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c

@@ -186,6 +186,7 @@ struct bpf_program {
  struct bpf_map {
  	int fd;
  	char *name;
+	size_t offset;
  	struct bpf_map_def def;
  	void *priv;
  	bpf_map_clear_priv_t clear_priv;

@@ -529,13 +530,6 @@ bpf_object__init_maps(struct bpf_object *obj, void *data,
  
  	pr_debug("maps in %s: %zd bytes\n", obj->path, size);
  
-	obj->maps = calloc(nr_maps, sizeof(obj->maps[0]));
-	if (!obj->maps) {
-		pr_warning("alloc maps for object failed\n");
-		return -ENOMEM;
-	}
-	obj->nr_maps = nr_maps;
-
  	for (i = 0; i < nr_maps; i++) {
  		struct bpf_map_def *def = &obj->maps[i].def;
  

@@ -547,23 +541,42 @@ bpf_object__init_maps(struct bpf_object *obj, void *data,
  		obj->maps[i].fd = -1;
  
  		/* Save map definition into obj->maps */
-		*def = ((struct bpf_map_def *)data)[i];
+		*def = *(struct bpf_map_def *)(data + obj->maps[i].offset);
  	}

  	return 0;
  }
  
  static int
-bpf_object__init_maps_name(struct bpf_object *obj)
+bpf_object__init_maps_symbol(struct bpf_object *obj)
  {
  	int i;
+	int nr_maps = 0;
  	Elf_Data *symbols = obj->efile.symbols;
+	size_t map_idx = 0;
  
  	if (!symbols || obj->efile.maps_shndx < 0)
  		return -EINVAL;
  
+	/* get the number of maps */
+	for (i = 0; i < symbols->d_size / sizeof(GElf_Sym); i++) {
+		GElf_Sym sym;
+
+		if (!gelf_getsym(symbols, i, &sym))
+			continue;
+		if (sym.st_shndx != obj->efile.maps_shndx)
+			continue;
+		nr_maps++;
+	}
+
+	obj->maps = calloc(nr_maps, sizeof(obj->maps[0]));
+	if (!obj->maps) {
+		pr_warning("alloc maps for object failed\n");
+		return -ENOMEM;
+	}
+	obj->nr_maps = nr_maps;
+
  	for (i = 0; i < symbols->d_size / sizeof(GElf_Sym); i++) {
  		GElf_Sym sym;
-		size_t map_idx;
  		const char *map_name;
  
  		if (!gelf_getsym(symbols, i, &sym))

@@ -574,12 +587,12 @@ bpf_object__init_maps_name(struct bpf_object *obj)
  		map_name = elf_strptr(obj->efile.elf,
  				      obj->efile.strtabidx,
  				      sym.st_name);
-		map_idx = sym.st_value / sizeof(struct bpf_map_def);
  		if (map_idx >= obj->nr_maps) {
  			pr_warning("index of map \"%s\" is buggy: %zu > %zu\n",
  				   map_name, map_idx, obj->nr_maps);
  			continue;
  		}
+		obj->maps[map_idx].offset = sym.st_value;
  		obj->maps[map_idx].name = strdup(map_name);
  		if (!obj->maps[map_idx].name) {
  			pr_warning("failed to alloc map name\n");

@@ -587,6 +600,7 @@ bpf_object__init_maps_name(struct bpf_object *obj)
  		}
  		pr_debug("map %zu is \"%s\"\n", map_idx,
  			 obj->maps[map_idx].name);
+		map_idx++;
  	}
  	return 0;
  }

@@ -647,8 +661,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
  							data->d_buf,
  							data->d_size);
  		else if (strcmp(name, "maps") == 0) {
-			err = bpf_object__init_maps(obj, data->d_buf,
-						    data->d_size);
  			obj->efile.maps_shndx = idx;
  		} else if (sh.sh_type == SHT_SYMTAB) {
  			if (obj->efile.symbols) {

@@ -698,8 +710,16 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
  		pr_warning("Corrupted ELF file: index of strtab invalid\n");
  		return LIBBPF_ERRNO__FORMAT;
  	}
-	if (obj->efile.maps_shndx >= 0)
-		err = bpf_object__init_maps_name(obj);
+	if (obj->efile.maps_shndx >= 0) {
+		Elf_Data *data;
+		err = bpf_object__init_maps_symbol(obj);
+		if (err)
+			goto out;
+
+		scn = elf_getscn(elf, obj->efile.maps_shndx);
+		data = elf_getdata(scn, 0);
+		err = bpf_object__init_maps(obj, data->d_buf, data->d_size);
+	}
  out:
  	return err;
  }