libbpf: Consistent prefixes for interfaces in nlattr.h.

libbpf is used more and more outside kernel tree. That means the library
should follow good practices in library design and implementation to
play well with third party code that uses it.

One of such practices is to have a common prefix (or a few) for every
interface, function or data structure, library provides. I helps to
avoid name conflicts with other libraries and keeps API consistent.

Inconsistent names in libbpf already cause problems in real life. E.g.
an application can't use both libbpf and libnl due to conflicting
symbols.

Having common prefix will help to fix current and avoid future problems.

libbpf already uses the following prefixes for its interfaces:
* bpf_ for bpf system call wrappers, program/map/elf-object
  abstractions and a few other things;
* btf_ for BTF related API;
* libbpf_ for everything else.

The patch adds libbpf_ prefix to interfaces in nlattr.h that use none of
mentioned above prefixes and doesn't fit well into the first two
categories.

Since affected part of API is used in bpftool, the patch applies
corresponding change to bpftool as well. Having it in a separate patch
will cause a state of tree where bpftool is broken what may not be a
good idea.

Signed-off-by: Andrey Ignatov <rdna@fb.com>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/tools/bpf/bpftool/net.c b/tools/bpf/bpftool/net.c
index ef83e8a084908f643187739ce5c35058bd79c2ff..d441bb7035cae99ad73ab0bb28410c572f1a7559 100644 (file)
--- a/tools/bpf/bpftool/net.c
+++ b/tools/bpf/bpftool/net.c
@@ -69,7 +69,9 @@ static int dump_link_nlmsg(void *cookie, void *msg, struct nlattr **tb)
        snprintf(netinfo->devices[netinfo->used_len].devname,
                 sizeof(netinfo->devices[netinfo->used_len].devname),
                 "%s",
-                tb[IFLA_IFNAME] ? nla_getattr_str(tb[IFLA_IFNAME]) : "");
+                tb[IFLA_IFNAME]
+                        ? libbpf_nla_getattr_str(tb[IFLA_IFNAME])
+                        : "");
        netinfo->used_len++;
 
        return do_xdp_dump(ifinfo, tb);
@@ -83,7 +85,7 @@ static int dump_class_qdisc_nlmsg(void *cookie, void *msg, struct nlattr **tb)
        if (tcinfo->is_qdisc) {
                /* skip clsact qdisc */
                if (tb[TCA_KIND] &&
-                   strcmp(nla_data(tb[TCA_KIND]), "clsact") == 0)
+                   strcmp(libbpf_nla_data(tb[TCA_KIND]), "clsact") == 0)
                        return 0;
                if (info->tcm_handle == 0)
                        return 0;
@@ -101,7 +103,9 @@ static int dump_class_qdisc_nlmsg(void *cookie, void *msg, struct nlattr **tb)
        snprintf(tcinfo->handle_array[tcinfo->used_len].kind,
                 sizeof(tcinfo->handle_array[tcinfo->used_len].kind),
                 "%s",
-                tb[TCA_KIND] ? nla_getattr_str(tb[TCA_KIND]) : "unknown");
+                tb[TCA_KIND]
+                        ? libbpf_nla_getattr_str(tb[TCA_KIND])
+                        : "unknown");
        tcinfo->used_len++;
 
        return 0;

diff --git a/tools/bpf/bpftool/netlink_dumper.c b/tools/bpf/bpftool/netlink_dumper.c
index 6f5e9cc6836c385651daf02a112f18a578384f7a..4e9f4531269fabe66b5d0ef98c45eb2f52a6398b 100644 (file)
--- a/tools/bpf/bpftool/netlink_dumper.c
+++ b/tools/bpf/bpftool/netlink_dumper.c
@@ -21,7 +21,7 @@ static void xdp_dump_prog_id(struct nlattr **tb, int attr,
        if (new_json_object)
                NET_START_OBJECT
        NET_DUMP_STR("mode", " %s", mode);
-       NET_DUMP_UINT("id", " id %u", nla_getattr_u32(tb[attr]))
+       NET_DUMP_UINT("id", " id %u", libbpf_nla_getattr_u32(tb[attr]))
        if (new_json_object)
                NET_END_OBJECT
 }
@@ -32,13 +32,13 @@ static int do_xdp_dump_one(struct nlattr *attr, unsigned int ifindex,
        struct nlattr *tb[IFLA_XDP_MAX + 1];
        unsigned char mode;
 
-       if (nla_parse_nested(tb, IFLA_XDP_MAX, attr, NULL) < 0)
+       if (libbpf_nla_parse_nested(tb, IFLA_XDP_MAX, attr, NULL) < 0)
                return -1;
 
        if (!tb[IFLA_XDP_ATTACHED])
                return 0;
 
-       mode = nla_getattr_u8(tb[IFLA_XDP_ATTACHED]);
+       mode = libbpf_nla_getattr_u8(tb[IFLA_XDP_ATTACHED]);
        if (mode == XDP_ATTACHED_NONE)
                return 0;
 
@@ -75,14 +75,14 @@ int do_xdp_dump(struct ifinfomsg *ifinfo, struct nlattr **tb)
                return 0;
 
        return do_xdp_dump_one(tb[IFLA_XDP], ifinfo->ifi_index,
-                              nla_getattr_str(tb[IFLA_IFNAME]));
+                              libbpf_nla_getattr_str(tb[IFLA_IFNAME]));
 }
 
 static int do_bpf_dump_one_act(struct nlattr *attr)
 {
        struct nlattr *tb[TCA_ACT_BPF_MAX + 1];
 
-       if (nla_parse_nested(tb, TCA_ACT_BPF_MAX, attr, NULL) < 0)
+       if (libbpf_nla_parse_nested(tb, TCA_ACT_BPF_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        if (!tb[TCA_ACT_BPF_PARMS])
@@ -91,10 +91,10 @@ static int do_bpf_dump_one_act(struct nlattr *attr)
        NET_START_OBJECT_NESTED2;
        if (tb[TCA_ACT_BPF_NAME])
                NET_DUMP_STR("name", "%s",
-                            nla_getattr_str(tb[TCA_ACT_BPF_NAME]));
+                            libbpf_nla_getattr_str(tb[TCA_ACT_BPF_NAME]));
        if (tb[TCA_ACT_BPF_ID])
                NET_DUMP_UINT("id", " id %u",
-                             nla_getattr_u32(tb[TCA_ACT_BPF_ID]));
+                             libbpf_nla_getattr_u32(tb[TCA_ACT_BPF_ID]));
        NET_END_OBJECT_NESTED;
        return 0;
 }
@@ -106,10 +106,11 @@ static int do_dump_one_act(struct nlattr *attr)
        if (!attr)
                return 0;
 
-       if (nla_parse_nested(tb, TCA_ACT_MAX, attr, NULL) < 0)
+       if (libbpf_nla_parse_nested(tb, TCA_ACT_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
-       if (tb[TCA_ACT_KIND] && strcmp(nla_data(tb[TCA_ACT_KIND]), "bpf") == 0)
+       if (tb[TCA_ACT_KIND] &&
+           strcmp(libbpf_nla_data(tb[TCA_ACT_KIND]), "bpf") == 0)
                return do_bpf_dump_one_act(tb[TCA_ACT_OPTIONS]);
 
        return 0;
@@ -120,7 +121,7 @@ static int do_bpf_act_dump(struct nlattr *attr)
        struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
        int act, ret;
 
-       if (nla_parse_nested(tb, TCA_ACT_MAX_PRIO, attr, NULL) < 0)
+       if (libbpf_nla_parse_nested(tb, TCA_ACT_MAX_PRIO, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        NET_START_ARRAY("act", " %s [");
@@ -139,13 +140,15 @@ static int do_bpf_filter_dump(struct nlattr *attr)
        struct nlattr *tb[TCA_BPF_MAX + 1];
        int ret;
 
-       if (nla_parse_nested(tb, TCA_BPF_MAX, attr, NULL) < 0)
+       if (libbpf_nla_parse_nested(tb, TCA_BPF_MAX, attr, NULL) < 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        if (tb[TCA_BPF_NAME])
-               NET_DUMP_STR("name", " %s", nla_getattr_str(tb[TCA_BPF_NAME]));
+               NET_DUMP_STR("name", " %s",
+                            libbpf_nla_getattr_str(tb[TCA_BPF_NAME]));
        if (tb[TCA_BPF_ID])
-               NET_DUMP_UINT("id", " id %u", nla_getattr_u32(tb[TCA_BPF_ID]));
+               NET_DUMP_UINT("id", " id %u",
+                             libbpf_nla_getattr_u32(tb[TCA_BPF_ID]));
        if (tb[TCA_BPF_ACT]) {
                ret = do_bpf_act_dump(tb[TCA_BPF_ACT]);
                if (ret)
@@ -160,7 +163,8 @@ int do_filter_dump(struct tcmsg *info, struct nlattr **tb, const char *kind,
 {
        int ret = 0;
 
-       if (tb[TCA_OPTIONS] && strcmp(nla_data(tb[TCA_KIND]), "bpf") == 0) {
+       if (tb[TCA_OPTIONS] &&
+           strcmp(libbpf_nla_data(tb[TCA_KIND]), "bpf") == 0) {
                NET_START_OBJECT;
                if (devname[0] != '\0')
                        NET_DUMP_STR("devname", "%s", devname);

diff --git a/tools/lib/bpf/netlink.c b/tools/lib/bpf/netlink.c
index 506bdfdbcab0e54f89fafa765ff6f4dd515367d3..2d2edbbd8ae801983709ebc0f100084e9825f6c5 100644 (file)
--- a/tools/lib/bpf/netlink.c
+++ b/tools/lib/bpf/netlink.c
@@ -103,7 +103,7 @@ static int bpf_netlink_recv(int sock, __u32 nl_pid, int seq,
                                if (!err->error)
                                        continue;
                                ret = err->error;
-                               nla_dump_errormsg(nh);
+                               libbpf_nla_dump_errormsg(nh);
                                goto done;
                        case NLMSG_DONE:
                                return 0;
@@ -190,7 +190,7 @@ static int __dump_link_nlmsg(struct nlmsghdr *nlh,
 
        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi));
        attr = (struct nlattr *) ((void *) ifi + NLMSG_ALIGN(sizeof(*ifi)));
-       if (nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0)
+       if (libbpf_nla_parse(tb, IFLA_MAX, attr, len, NULL) != 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        return dump_link_nlmsg(cookie, ifi, tb);
@@ -228,7 +228,7 @@ static int __dump_class_nlmsg(struct nlmsghdr *nlh,
 
        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
-       if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+       if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        return dump_class_nlmsg(cookie, t, tb);
@@ -267,7 +267,7 @@ static int __dump_qdisc_nlmsg(struct nlmsghdr *nlh,
 
        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
-       if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+       if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        return dump_qdisc_nlmsg(cookie, t, tb);
@@ -306,7 +306,7 @@ static int __dump_filter_nlmsg(struct nlmsghdr *nlh,
 
        len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(*t));
        attr = (struct nlattr *) ((void *) t + NLMSG_ALIGN(sizeof(*t)));
-       if (nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
+       if (libbpf_nla_parse(tb, TCA_MAX, attr, len, NULL) != 0)
                return -LIBBPF_ERRNO__NLPARSE;
 
        return dump_filter_nlmsg(cookie, t, tb);

diff --git a/tools/lib/bpf/nlattr.c b/tools/lib/bpf/nlattr.c
index 49f514119bdb083e24b5720f9d077aaa63b053d9..e52257a7367a28ff9e0b92fddc86b001550f64a0 100644 (file)
--- a/tools/lib/bpf/nlattr.c
+++ b/tools/lib/bpf/nlattr.c
@@ -17,13 +17,13 @@
 #include <string.h>
 #include <stdio.h>
 
-static uint16_t nla_attr_minlen[NLA_TYPE_MAX+1] = {
-       [NLA_U8]        = sizeof(uint8_t),
-       [NLA_U16]       = sizeof(uint16_t),
-       [NLA_U32]       = sizeof(uint32_t),
-       [NLA_U64]       = sizeof(uint64_t),
-       [NLA_STRING]    = 1,
-       [NLA_FLAG]      = 0,
+static uint16_t nla_attr_minlen[LIBBPF_NLA_TYPE_MAX+1] = {
+       [LIBBPF_NLA_U8]         = sizeof(uint8_t),
+       [LIBBPF_NLA_U16]        = sizeof(uint16_t),
+       [LIBBPF_NLA_U32]        = sizeof(uint32_t),
+       [LIBBPF_NLA_U64]        = sizeof(uint64_t),
+       [LIBBPF_NLA_STRING]     = 1,
+       [LIBBPF_NLA_FLAG]       = 0,
 };
 
 static struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
@@ -47,9 +47,9 @@ static int nla_type(const struct nlattr *nla)
 }
 
 static int validate_nla(struct nlattr *nla, int maxtype,
-                       struct nla_policy *policy)
+                       struct libbpf_nla_policy *policy)
 {
-       struct nla_policy *pt;
+       struct libbpf_nla_policy *pt;
        unsigned int minlen = 0;
        int type = nla_type(nla);
 
@@ -58,23 +58,24 @@ static int validate_nla(struct nlattr *nla, int maxtype,
 
        pt = &policy[type];
 
-       if (pt->type > NLA_TYPE_MAX)
+       if (pt->type > LIBBPF_NLA_TYPE_MAX)
                return 0;
 
        if (pt->minlen)
                minlen = pt->minlen;
-       else if (pt->type != NLA_UNSPEC)
+       else if (pt->type != LIBBPF_NLA_UNSPEC)
                minlen = nla_attr_minlen[pt->type];
 
-       if (nla_len(nla) < minlen)
+       if (libbpf_nla_len(nla) < minlen)
                return -1;
 
-       if (pt->maxlen && nla_len(nla) > pt->maxlen)
+       if (pt->maxlen && libbpf_nla_len(nla) > pt->maxlen)
                return -1;
 
-       if (pt->type == NLA_STRING) {
-               char *data = nla_data(nla);
-               if (data[nla_len(nla) - 1] != '\0')
+       if (pt->type == LIBBPF_NLA_STRING) {
+               char *data = libbpf_nla_data(nla);
+
+               if (data[libbpf_nla_len(nla) - 1] != '\0')
                        return -1;
        }
 
@@ -104,15 +105,15 @@ static inline int nlmsg_len(const struct nlmsghdr *nlh)
  * @see nla_validate
  * @return 0 on success or a negative error code.
  */
-int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
-             struct nla_policy *policy)
+int libbpf_nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
+                    int len, struct libbpf_nla_policy *policy)
 {
        struct nlattr *nla;
        int rem, err;
 
        memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
 
-       nla_for_each_attr(nla, head, len, rem) {
+       libbpf_nla_for_each_attr(nla, head, len, rem) {
                int type = nla_type(nla);
 
                if (type > maxtype)
@@ -144,23 +145,25 @@ errout:
  * @arg policy          Attribute validation policy.
  *
  * Feeds the stream of attributes nested into the specified attribute
- * to nla_parse().
+ * to libbpf_nla_parse().
  *
- * @see nla_parse
+ * @see libbpf_nla_parse
  * @return 0 on success or a negative error code.
  */
-int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla,
-                    struct nla_policy *policy)
+int libbpf_nla_parse_nested(struct nlattr *tb[], int maxtype,
+                           struct nlattr *nla,
+                           struct libbpf_nla_policy *policy)
 {
-       return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+       return libbpf_nla_parse(tb, maxtype, libbpf_nla_data(nla),
+                               libbpf_nla_len(nla), policy);
 }
 
 /* dump netlink extended ack error message */
-int nla_dump_errormsg(struct nlmsghdr *nlh)
+int libbpf_nla_dump_errormsg(struct nlmsghdr *nlh)
 {
-       struct nla_policy extack_policy[NLMSGERR_ATTR_MAX + 1] = {
-               [NLMSGERR_ATTR_MSG]     = { .type = NLA_STRING },
-               [NLMSGERR_ATTR_OFFS]    = { .type = NLA_U32 },
+       struct libbpf_nla_policy extack_policy[NLMSGERR_ATTR_MAX + 1] = {
+               [NLMSGERR_ATTR_MSG]     = { .type = LIBBPF_NLA_STRING },
+               [NLMSGERR_ATTR_OFFS]    = { .type = LIBBPF_NLA_U32 },
        };
        struct nlattr *tb[NLMSGERR_ATTR_MAX + 1], *attr;
        struct nlmsgerr *err;
@@ -181,14 +184,15 @@ int nla_dump_errormsg(struct nlmsghdr *nlh)
        attr = (struct nlattr *) ((void *) err + hlen);
        alen = nlh->nlmsg_len - hlen;
 
-       if (nla_parse(tb, NLMSGERR_ATTR_MAX, attr, alen, extack_policy) != 0) {
+       if (libbpf_nla_parse(tb, NLMSGERR_ATTR_MAX, attr, alen,
+                            extack_policy) != 0) {
                fprintf(stderr,
                        "Failed to parse extended error attributes\n");
                return 0;
        }
 
        if (tb[NLMSGERR_ATTR_MSG])
-               errmsg = (char *) nla_data(tb[NLMSGERR_ATTR_MSG]);
+               errmsg = (char *) libbpf_nla_data(tb[NLMSGERR_ATTR_MSG]);
 
        fprintf(stderr, "Kernel error message: %s\n", errmsg);
 

diff --git a/tools/lib/bpf/nlattr.h b/tools/lib/bpf/nlattr.h
index a6e2396bce7ccba09f3d262741eaf7f8c81fc94c..755a3312c87f5193b73cac9ded2454f0c3cd53ad 100644 (file)
--- a/tools/lib/bpf/nlattr.h
+++ b/tools/lib/bpf/nlattr.h
@@ -23,19 +23,19 @@
  * Standard attribute types to specify validation policy
  */
 enum {
-       NLA_UNSPEC,     /**< Unspecified type, binary data chunk */
-       NLA_U8,         /**< 8 bit integer */
-       NLA_U16,        /**< 16 bit integer */
-       NLA_U32,        /**< 32 bit integer */
-       NLA_U64,        /**< 64 bit integer */
-       NLA_STRING,     /**< NUL terminated character string */
-       NLA_FLAG,       /**< Flag */
-       NLA_MSECS,      /**< Micro seconds (64bit) */
-       NLA_NESTED,     /**< Nested attributes */
-       __NLA_TYPE_MAX,
+       LIBBPF_NLA_UNSPEC,      /**< Unspecified type, binary data chunk */
+       LIBBPF_NLA_U8,          /**< 8 bit integer */
+       LIBBPF_NLA_U16,         /**< 16 bit integer */
+       LIBBPF_NLA_U32,         /**< 32 bit integer */
+       LIBBPF_NLA_U64,         /**< 64 bit integer */
+       LIBBPF_NLA_STRING,      /**< NUL terminated character string */
+       LIBBPF_NLA_FLAG,        /**< Flag */
+       LIBBPF_NLA_MSECS,       /**< Micro seconds (64bit) */
+       LIBBPF_NLA_NESTED,      /**< Nested attributes */
+       __LIBBPF_NLA_TYPE_MAX,
 };
 
-#define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
+#define LIBBPF_NLA_TYPE_MAX (__LIBBPF_NLA_TYPE_MAX - 1)
 
 /**
  * @ingroup attr
@@ -43,8 +43,8 @@ enum {
  *
  * See section @core_doc{core_attr_parse,Attribute Parsing} for more details.
  */
-struct nla_policy {
-       /** Type of attribute or NLA_UNSPEC */
+struct libbpf_nla_policy {
+       /** Type of attribute or LIBBPF_NLA_UNSPEC */
        uint16_t        type;
 
        /** Minimal length of payload required */
@@ -62,49 +62,50 @@ struct nla_policy {
  * @arg len    length of attribute stream
  * @arg rem    initialized to len, holds bytes currently remaining in stream
  */
-#define nla_for_each_attr(pos, head, len, rem) \
+#define libbpf_nla_for_each_attr(pos, head, len, rem) \
        for (pos = head, rem = len; \
             nla_ok(pos, rem); \
             pos = nla_next(pos, &(rem)))
 
 /**
- * nla_data - head of payload
+ * libbpf_nla_data - head of payload
  * @nla: netlink attribute
  */
-static inline void *nla_data(const struct nlattr *nla)
+static inline void *libbpf_nla_data(const struct nlattr *nla)
 {
        return (char *) nla + NLA_HDRLEN;
 }
 
-static inline uint8_t nla_getattr_u8(const struct nlattr *nla)
+static inline uint8_t libbpf_nla_getattr_u8(const struct nlattr *nla)
 {
-       return *(uint8_t *)nla_data(nla);
+       return *(uint8_t *)libbpf_nla_data(nla);
 }
 
-static inline uint32_t nla_getattr_u32(const struct nlattr *nla)
+static inline uint32_t libbpf_nla_getattr_u32(const struct nlattr *nla)
 {
-       return *(uint32_t *)nla_data(nla);
+       return *(uint32_t *)libbpf_nla_data(nla);
 }
 
-static inline const char *nla_getattr_str(const struct nlattr *nla)
+static inline const char *libbpf_nla_getattr_str(const struct nlattr *nla)
 {
-       return (const char *)nla_data(nla);
+       return (const char *)libbpf_nla_data(nla);
 }
 
 /**
- * nla_len - length of payload
+ * libbpf_nla_len - length of payload
  * @nla: netlink attribute
  */
-static inline int nla_len(const struct nlattr *nla)
+static inline int libbpf_nla_len(const struct nlattr *nla)
 {
        return nla->nla_len - NLA_HDRLEN;
 }
 
-int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
-             struct nla_policy *policy);
-int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla,
-                    struct nla_policy *policy);
+int libbpf_nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head,
+                    int len, struct libbpf_nla_policy *policy);
+int libbpf_nla_parse_nested(struct nlattr *tb[], int maxtype,
+                           struct nlattr *nla,
+                           struct libbpf_nla_policy *policy);
 
-int nla_dump_errormsg(struct nlmsghdr *nlh);
+int libbpf_nla_dump_errormsg(struct nlmsghdr *nlh);
 
 #endif /* __NLATTR_H */