tools: bpftool: turn err() and info() macros into functions

Turn err() and info() macros into functions.

In order to avoid naming conflicts with variables in the code, rename
them as p_err() and p_info() respectively.

The behavior of these functions is similar to the one of the macros for
plain output. However, when JSON output is requested, these macros
return a JSON-formatted "error" object instead of printing a message to
stderr.

To handle error messages correctly with JSON, a modification was brought
to their behavior nonetheless: the functions now append a end-of-line
character at the end of the message. This way, we can remove end-of-line
characters at the end of the argument strings, and not have them in the
JSON output.

All error messages are formatted to hold in a single call to p_err(), in
order to produce a single JSON field.

Signed-off-by: Quentin Monnet <quentin.monnet@netronome.com>
Acked-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Acked-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 48 insertions, 39 deletions

diff --git a/tools/bpf/bpftool/map.c b/tools/bpf/bpftool/map.c
index 14d89bfabc66..86c128c433ba 100644
--- a/tools/bpf/bpftool/map.c
+++ b/tools/bpf/bpftool/map.c
@@ -81,19 +81,19 @@ static unsigned int get_possible_cpus(void)
 
         fd = open("/sys/devices/system/cpu/possible", O_RDONLY);
         if (fd < 0) {
-                err("can't open sysfs possible cpus\n");
+                p_err("can't open sysfs possible cpus");
                 exit(-1);
         }
 
         n = read(fd, buf, sizeof(buf));
         if (n < 2) {
-                err("can't read sysfs possible cpus\n");
+                p_err("can't read sysfs possible cpus");
                 exit(-1);
         }
         close(fd);
 
         if (n == sizeof(buf)) {
-                err("read sysfs possible cpus overflow\n");
+                p_err("read sysfs possible cpus overflow");
                 exit(-1);
         }
 
@@ -161,14 +161,14 @@ static int map_parse_fd(int *argc, char ***argv)
 
                 id = strtoul(**argv, &endptr, 0);
                 if (*endptr) {
-                        err("can't parse %s as ID\n", **argv);
+                        p_err("can't parse %s as ID", **argv);
                         return -1;
                 }
                 NEXT_ARGP();
 
                 fd = bpf_map_get_fd_by_id(id);
                 if (fd < 0)
-                        err("get map by id (%u): %s\n", id, strerror(errno));
+                        p_err("get map by id (%u): %s", id, strerror(errno));
                 return fd;
         } else if (is_prefix(**argv, "pinned")) {
                 char *path;
@@ -181,7 +181,7 @@ static int map_parse_fd(int *argc, char ***argv)
                 return open_obj_pinned_any(path, BPF_OBJ_MAP);
         }
 
-        err("expected 'id' or 'pinned', got: '%s'?\n", **argv);
+        p_err("expected 'id' or 'pinned', got: '%s'?", **argv);
         return -1;
 }
 
@@ -197,7 +197,7 @@ map_parse_fd_and_info(int *argc, char ***argv, void *info, __u32 *info_len)
 
         err = bpf_obj_get_info_by_fd(fd, info, info_len);
         if (err) {
-                err("can't get map info: %s\n", strerror(errno));
+                p_err("can't get map info: %s", strerror(errno));
                 close(fd);
                 return err;
         }
@@ -288,14 +288,14 @@ static char **parse_bytes(char **argv, const char *name, unsigned char *val,
         while (i < n && argv[i]) {
                 val[i] = strtoul(argv[i], &endptr, 0);
                 if (*endptr) {
-                        err("error parsing byte: %s\n", argv[i]);
+                        p_err("error parsing byte: %s", argv[i]);
                         return NULL;
                 }
                 i++;
         }
 
         if (i != n) {
-                err("%s expected %d bytes got %d\n", name, n, i);
+                p_err("%s expected %d bytes got %d", name, n, i);
                 return NULL;
         }
 
@@ -309,16 +309,16 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
         if (!*argv) {
                 if (!key && !value)
                         return 0;
-                err("did not find %s\n", key ? "key" : "value");
+                p_err("did not find %s", key ? "key" : "value");
                 return -1;
         }
 
         if (is_prefix(*argv, "key")) {
                 if (!key) {
                         if (key_size)
-                                err("duplicate key\n");
+                                p_err("duplicate key");
                         else
-                                err("unnecessary key\n");
+                                p_err("unnecessary key");
                         return -1;
                 }
 
@@ -333,9 +333,9 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
 
                 if (!value) {
                         if (value_size)
-                                err("duplicate value\n");
+                                p_err("duplicate value");
                         else
-                                err("unnecessary value\n");
+                                p_err("unnecessary value");
                         return -1;
                 }
 
@@ -345,11 +345,11 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
                         int argc = 2;
 
                         if (value_size != 4) {
-                                err("value smaller than 4B for map in map?\n");
+                                p_err("value smaller than 4B for map in map?");
                                 return -1;
                         }
                         if (!argv[0] || !argv[1]) {
-                                err("not enough value arguments for map in map\n");
+                                p_err("not enough value arguments for map in map");
                                 return -1;
                         }
 
@@ -363,11 +363,11 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
                         int argc = 2;
 
                         if (value_size != 4) {
-                                err("value smaller than 4B for map of progs?\n");
+                                p_err("value smaller than 4B for map of progs?");
                                 return -1;
                         }
                         if (!argv[0] || !argv[1]) {
-                                err("not enough value arguments for map of progs\n");
+                                p_err("not enough value arguments for map of progs");
                                 return -1;
                         }
 
@@ -388,7 +388,7 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
         } else if (is_prefix(*argv, "any") || is_prefix(*argv, "noexist") ||
                    is_prefix(*argv, "exist")) {
                 if (!flags) {
-                        err("flags specified multiple times: %s\n", *argv);
+                        p_err("flags specified multiple times: %s", *argv);
                         return -1;
                 }
 
@@ -403,7 +403,7 @@ static int parse_elem(char **argv, struct bpf_map_info *info,
                                   value_size, NULL, value_fd);
         }
 
-        err("expected key or value, got: %s\n", *argv);
+        p_err("expected key or value, got: %s", *argv);
         return -1;
 }
 
@@ -499,22 +499,21 @@ static int do_show(int argc, char **argv)
                 if (err) {
                         if (errno == ENOENT)
                                 break;
-                        err("can't get next map: %s\n", strerror(errno));
-                        if (errno == EINVAL)
-                                err("kernel too old?\n");
+                        p_err("can't get next map: %s%s", strerror(errno),
+                              errno == EINVAL ? " -- kernel too old?" : "");
                         return -1;
                 }
 
                 fd = bpf_map_get_fd_by_id(id);
                 if (fd < 0) {
-                        err("can't get map by id (%u): %s\n",
-                            id, strerror(errno));
+                        p_err("can't get map by id (%u): %s",
+                              id, strerror(errno));
                         return -1;
                 }
 
                 err = bpf_obj_get_info_by_fd(fd, &info, &len);
                 if (err) {
-                        err("can't get map info: %s\n", strerror(errno));
+                        p_err("can't get map info: %s", strerror(errno));
                         close(fd);
                         return -1;
                 }
@@ -547,7 +546,7 @@ static int do_dump(int argc, char **argv)
                 return -1;
 
         if (map_is_map_of_maps(info.type) || map_is_map_of_progs(info.type)) {
-                err("Dumping maps of maps and program maps not supported\n");
+                p_err("Dumping maps of maps and program maps not supported");
                 close(fd);
                 return -1;
         }
@@ -555,7 +554,7 @@ static int do_dump(int argc, char **argv)
         key = malloc(info.key_size);
         value = alloc_value(&info);
         if (!key || !value) {
-                err("mem alloc failed\n");
+                p_err("mem alloc failed");
                 err = -1;
                 goto exit_free;
         }
@@ -577,9 +576,19 @@ static int do_dump(int argc, char **argv)
                         else
                                 print_entry_plain(&info, key, value);
                 } else {
-                        info("can't lookup element with key: ");
-                        fprint_hex(stderr, key, info.key_size, " ");
-                        fprintf(stderr, "\n");
+                        if (json_output) {
+                                jsonw_name(json_wtr, "key");
+                                print_hex_data_json(key, info.key_size);
+                                jsonw_name(json_wtr, "value");
+                                jsonw_start_object(json_wtr);
+                                jsonw_string_field(json_wtr, "error",
+                                                   "can't lookup element");
+                                jsonw_end_object(json_wtr);
+                        } else {
+                                p_info("can't lookup element with key: ");
+                                fprint_hex(stderr, key, info.key_size, " ");
+                                fprintf(stderr, "\n");
+                        }
                 }
 
                 prev_key = key;
@@ -619,7 +628,7 @@ static int do_update(int argc, char **argv)
         key = malloc(info.key_size);
         value = alloc_value(&info);
         if (!key || !value) {
-                err("mem alloc failed");
+                p_err("mem alloc failed");
                 err = -1;
                 goto exit_free;
         }
@@ -631,7 +640,7 @@ static int do_update(int argc, char **argv)
 
         err = bpf_map_update_elem(fd, key, value, flags);
         if (err) {
-                err("update failed: %s\n", strerror(errno));
+                p_err("update failed: %s", strerror(errno));
                 goto exit_free;
         }
 
@@ -663,7 +672,7 @@ static int do_lookup(int argc, char **argv)
         key = malloc(info.key_size);
         value = alloc_value(&info);
         if (!key || !value) {
-                err("mem alloc failed");
+                p_err("mem alloc failed");
                 err = -1;
                 goto exit_free;
         }
@@ -687,7 +696,7 @@ static int do_lookup(int argc, char **argv)
                         printf("\n\nNot found\n");
                 }
         } else {
-                err("lookup failed: %s\n", strerror(errno));
+                p_err("lookup failed: %s", strerror(errno));
         }
 
 exit_free:
@@ -716,7 +725,7 @@ static int do_getnext(int argc, char **argv)
         key = malloc(info.key_size);
         nextkey = malloc(info.key_size);
         if (!key || !nextkey) {
-                err("mem alloc failed");
+                p_err("mem alloc failed");
                 err = -1;
                 goto exit_free;
         }
@@ -733,7 +742,7 @@ static int do_getnext(int argc, char **argv)
 
         err = bpf_map_get_next_key(fd, key, nextkey);
         if (err) {
-                err("can't get next key: %s\n", strerror(errno));
+                p_err("can't get next key: %s", strerror(errno));
                 goto exit_free;
         }
 
@@ -786,7 +795,7 @@ static int do_delete(int argc, char **argv)
 
         key = malloc(info.key_size);
         if (!key) {
-                err("mem alloc failed");
+                p_err("mem alloc failed");
                 err = -1;
                 goto exit_free;
         }
@@ -797,7 +806,7 @@ static int do_delete(int argc, char **argv)
 
         err = bpf_map_delete_elem(fd, key);
         if (err)
-                err("delete failed: %s\n", strerror(errno));
+                p_err("delete failed: %s", strerror(errno));
 
 exit_free:
         free(key);