7 files changed, 44 insertions, 34 deletions

diff --git a/tools/bpf/bpftool/Makefile b/tools/bpf/bpftool/Makefile
index 492f0f24e2d3..4ad1f0894d53 100644
--- a/tools/bpf/bpftool/Makefile
+++ b/tools/bpf/bpftool/Makefile
@@ -93,9 +93,16 @@ BFD_SRCS = jit_disasm.c
 SRCS = $(filter-out $(BFD_SRCS),$(wildcard *.c))
 
 ifeq ($(feature-libbfd),1)
+  LIBS += -lbfd -ldl -lopcodes
+else ifeq ($(feature-libbfd-liberty),1)
+  LIBS += -lbfd -ldl -lopcodes -liberty
+else ifeq ($(feature-libbfd-liberty-z),1)
+  LIBS += -lbfd -ldl -lopcodes -liberty -lz
+endif
+
+ifneq ($(filter -lbfd,$(LIBS)),)
 CFLAGS += -DHAVE_LIBBFD_SUPPORT
 SRCS += $(BFD_SRCS)
-LIBS += -lbfd -lopcodes
 endif
 
 OBJS = $(patsubst %.c,$(OUTPUT)%.o,$(SRCS)) $(OUTPUT)disasm.o
diff --git a/tools/bpf/bpftool/btf_dumper.c b/tools/bpf/bpftool/btf_dumper.c
index 3f0629edbca5..6ba5f567a9d8 100644
--- a/tools/bpf/bpftool/btf_dumper.c
+++ b/tools/bpf/bpftool/btf_dumper.c
@@ -82,8 +82,6 @@ static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
         int bits_to_copy;
         __u64 print_num;
 
-        data += BITS_ROUNDDOWN_BYTES(bit_offset);
-        bit_offset = BITS_PER_BYTE_MASKED(bit_offset);
         bits_to_copy = bit_offset + nr_bits;
         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
 
@@ -118,7 +116,9 @@ static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
          * BTF_INT_OFFSET() cannot exceed 64 bits.
          */
         total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
-        btf_dumper_bitfield(nr_bits, total_bits_offset, data, jw,
+        data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
+        bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
+        btf_dumper_bitfield(nr_bits, bit_offset, data, jw,
                             is_plain_text);
 }
 
@@ -216,11 +216,12 @@ static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
                 }
 
                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
+                data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
                 if (bitfield_size) {
-                        btf_dumper_bitfield(bitfield_size, bit_offset,
-                                            data, d->jw, d->is_plain_text);
+                        btf_dumper_bitfield(bitfield_size,
+                                            BITS_PER_BYTE_MASKED(bit_offset),
+                                            data_off, d->jw, d->is_plain_text);
                 } else {
-                        data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
                         ret = btf_dumper_do_type(d, m[i].type,
                                                  BITS_PER_BYTE_MASKED(bit_offset),
                                                  data_off);
diff --git a/tools/bpf/bpftool/common.c b/tools/bpf/bpftool/common.c
index 897483457bf0..f7261fad45c1 100644
--- a/tools/bpf/bpftool/common.c
+++ b/tools/bpf/bpftool/common.c
@@ -297,10 +297,8 @@ char *get_fdinfo(int fd, const char *key)
         snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd);
 
         fdi = fopen(path, "r");
-        if (!fdi) {
-                p_err("can't open fdinfo: %s", strerror(errno));
+        if (!fdi)
                 return NULL;
-        }
 
         while ((n = getline(&line, &line_n, fdi)) > 0) {
                 char *value;
@@ -313,7 +311,6 @@ char *get_fdinfo(int fd, const char *key)
 
                 value = strchr(line, '\t');
                 if (!value || !value[1]) {
-                        p_err("malformed fdinfo!?");
                         free(line);
                         return NULL;
                 }
@@ -326,7 +323,6 @@ char *get_fdinfo(int fd, const char *key)
                 return line;
         }
 
-        p_err("key '%s' not found in fdinfo", key);
         free(line);
         fclose(fdi);
         return NULL;
diff --git a/tools/bpf/bpftool/json_writer.c b/tools/bpf/bpftool/json_writer.c
index bff7ee026680..6046dcab51cc 100644
--- a/tools/bpf/bpftool/json_writer.c
+++ b/tools/bpf/bpftool/json_writer.c
@@ -1,15 +1,10 @@
-// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+// SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)
 /*
  * Simple streaming JSON writer
  *
  * This takes care of the annoying bits of JSON syntax like the commas
  * after elements
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
  * Authors:     Stephen Hemminger <stephen@networkplumber.org>
  */
 
diff --git a/tools/bpf/bpftool/json_writer.h b/tools/bpf/bpftool/json_writer.h
index c1ab51aed99c..cb9a1993681c 100644
--- a/tools/bpf/bpftool/json_writer.h
+++ b/tools/bpf/bpftool/json_writer.h
@@ -5,11 +5,6 @@
  * This takes care of the annoying bits of JSON syntax like the commas
  * after elements
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
  * Authors:     Stephen Hemminger <stephen@networkplumber.org>
  */
 
diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c
index 2037e3dc864b..1ef1ee2280a2 100644
--- a/tools/bpf/bpftool/map.c
+++ b/tools/bpf/bpftool/map.c
@@ -347,6 +347,20 @@ static char **parse_bytes(char **argv, const char *name, unsigned char *val,
         return argv + i;
 }
 
+/* on per cpu maps we must copy the provided value on all value instances */
+static void fill_per_cpu_value(struct bpf_map_info *info, void *value)
+{
+        unsigned int i, n, step;
+
+        if (!map_is_per_cpu(info->type))
+                return;
+
+        n = get_possible_cpus();
+        step = round_up(info->value_size, 8);
+        for (i = 1; i < n; i++)
+                memcpy(value + i * step, value, info->value_size);
+}
+
 static int parse_elem(char **argv, struct bpf_map_info *info,
                       void *key, void *value, __u32 key_size, __u32 value_size,
                       __u32 *flags, __u32 **value_fd)
@@ -426,6 +440,8 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
                         argv = parse_bytes(argv, "value", value, value_size);
                         if (!argv)
                                 return -1;
+
+                        fill_per_cpu_value(info, value);
                 }
 
                 return parse_elem(argv, info, key, NULL, key_size, value_size,
@@ -497,10 +513,9 @@ static int show_map_close_json(int fd, struct bpf_map_info *info)
                                 jsonw_uint_field(json_wtr, "owner_prog_type",
                                                  prog_type);
                 }
-                if (atoi(owner_jited))
-                        jsonw_bool_field(json_wtr, "owner_jited", true);
-                else
-                        jsonw_bool_field(json_wtr, "owner_jited", false);
+                if (owner_jited)
+                        jsonw_bool_field(json_wtr, "owner_jited",
+                                         !!atoi(owner_jited));
 
                 free(owner_prog_type);
                 free(owner_jited);
@@ -553,7 +568,8 @@ static int show_map_close_plain(int fd, struct bpf_map_info *info)
                 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type");
                 char *owner_jited = get_fdinfo(fd, "owner_jited");
 
-                printf("\n\t");
+                if (owner_prog_type || owner_jited)
+                        printf("\n\t");
                 if (owner_prog_type) {
                         unsigned int prog_type = atoi(owner_prog_type);
 
@@ -563,10 +579,9 @@ static int show_map_close_plain(int fd, struct bpf_map_info *info)
                         else
                                 printf("owner_prog_type %d  ", prog_type);
                 }
-                if (atoi(owner_jited))
-                        printf("owner jited");
-                else
-                        printf("owner not jited");
+                if (owner_jited)
+                        printf("owner%s jited",
+                               atoi(owner_jited) ? "" : " not");
 
                 free(owner_prog_type);
                 free(owner_jited);
diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index 2d1bb7d6ff51..b54ed82b9589 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -78,13 +78,14 @@ static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
 
 static int prog_fd_by_tag(unsigned char *tag)
 {
-        struct bpf_prog_info info = {};
-        __u32 len = sizeof(info);
         unsigned int id = 0;
         int err;
         int fd;
 
         while (true) {
+                struct bpf_prog_info info = {};
+                __u32 len = sizeof(info);
+
                 err = bpf_prog_get_next_id(id, &id);
                 if (err) {
                         p_err("%s", strerror(errno));