rtnetlink: add new RTM_GETSTATS message to dump link stats

This patch adds a new RTM_GETSTATS message to query link stats via netlink
from the kernel. RTM_NEWLINK also dumps stats today, but RTM_NEWLINK
returns a lot more than just stats and is expensive in some cases when
frequent polling for stats from userspace is a common operation.

RTM_GETSTATS is an attempt to provide a light weight netlink message
to explicity query only link stats from the kernel on an interface.
The idea is to also keep it extensible so that new kinds of stats can be
added to it in the future.

This patch adds the following attribute for NETDEV stats:
struct nla_policy ifla_stats_policy[IFLA_STATS_MAX + 1] = {
        [IFLA_STATS_LINK_64]  = { .len = sizeof(struct rtnl_link_stats64) },
};

Like any other rtnetlink message, RTM_GETSTATS can be used to get stats of
a single interface or all interfaces with NLM_F_DUMP.

Future possible new types of stat attributes:
link af stats:
    - IFLA_STATS_LINK_IPV6  (nested. for ipv6 stats)
    - IFLA_STATS_LINK_MPLS  (nested. for mpls/mdev stats)
extended stats:
    - IFLA_STATS_LINK_EXTENDED (nested. extended software netdev stats like bridge,
      vlan, vxlan etc)
    - IFLA_STATS_LINK_HW_EXTENDED (nested. extended hardware stats which are
      available via ethtool today)

This patch also declares a filter mask for all stat attributes.
User has to provide a mask of stats attributes to query. filter mask
can be specified in the new hdr 'struct if_stats_msg' for stats messages.
Other important field in the header is the ifindex.

This api can also include attributes for global stats (eg tcp) in the future.
When global stats are included in a stats msg, the ifindex in the header
must be zero. A single stats message cannot contain both global and
netdev specific stats. To easily distinguish them, netdev specific stat
attributes name are prefixed with IFLA_STATS_LINK_

Without any attributes in the filter_mask, no stats will be returned.

This patch has been tested with mofified iproute2 ifstat.

Suggested-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Roopa Prabhu <roopa@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index af8fd58b40063434f758cbd4dd2554e81ea28805..ba69d44472497206e911a47666dfa1a9806f75cd 100644 (file)
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -782,4 +782,27 @@ enum {
 
 #define IFLA_HSR_MAX (__IFLA_HSR_MAX - 1)
 
+/* STATS section */
+
+struct if_stats_msg {
+       __u8  family;
+       __u8  pad1;
+       __u16 pad2;
+       __u32 ifindex;
+       __u32 filter_mask;
+};
+
+/* A stats attribute can be netdev specific or a global stat.
+ * For netdev stats, lets use the prefix IFLA_STATS_LINK_*
+ */
+enum {
+       IFLA_STATS_UNSPEC, /* also used as 64bit pad attribute */
+       IFLA_STATS_LINK_64,
+       __IFLA_STATS_MAX,
+};
+
+#define IFLA_STATS_MAX (__IFLA_STATS_MAX - 1)
+
+#define IFLA_STATS_FILTER_BIT(ATTR)    (1 << (ATTR - 1))
+
 #endif /* _UAPI_LINUX_IF_LINK_H */

diff --git a/include/uapi/linux/rtnetlink.h b/include/uapi/linux/rtnetlink.h
index ca764b5da86da440c9769693bdb0bdfce1daa623..cc885c4e9065a932a561cfff20beb48fb7944a1d 100644 (file)
--- a/include/uapi/linux/rtnetlink.h
+++ b/include/uapi/linux/rtnetlink.h
@@ -139,6 +139,11 @@ enum {
        RTM_GETNSID = 90,
 #define RTM_GETNSID RTM_GETNSID
 
+       RTM_NEWSTATS = 92,
+#define RTM_NEWSTATS RTM_NEWSTATS
+       RTM_GETSTATS = 94,
+#define RTM_GETSTATS RTM_GETSTATS
+
        __RTM_MAX,
 #define RTM_MAX                (((__RTM_MAX + 3) & ~3) - 1)
 };

diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index d3694a13c85aafde74bd2c0616e6668fe3dc7c41..4a47a9aceb1d63fe0500a5d27b987e65d120f7fd 100644 (file)
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -3449,6 +3449,161 @@ out:
        return err;
 }
 
+static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
+                              int type, u32 pid, u32 seq, u32 change,
+                              unsigned int flags, unsigned int filter_mask)
+{
+       struct if_stats_msg *ifsm;
+       struct nlmsghdr *nlh;
+       struct nlattr *attr;
+
+       ASSERT_RTNL();
+
+       nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
+       if (!nlh)
+               return -EMSGSIZE;
+
+       ifsm = nlmsg_data(nlh);
+       ifsm->ifindex = dev->ifindex;
+       ifsm->filter_mask = filter_mask;
+
+       if (filter_mask & IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_64)) {
+               struct rtnl_link_stats64 *sp;
+               int err;
+
+               /* if necessary, add a zero length NOP attribute so that
+                * IFLA_STATS_LINK_64 will be 64-bit aligned
+                */
+               err = nla_align_64bit(skb, IFLA_STATS_UNSPEC);
+               if (err)
+                       goto nla_put_failure;
+
+               attr = nla_reserve(skb, IFLA_STATS_LINK_64,
+                                  sizeof(struct rtnl_link_stats64));
+               if (!attr)
+                       goto nla_put_failure;
+
+               sp = nla_data(attr);
+               dev_get_stats(dev, sp);
+       }
+
+       nlmsg_end(skb, nlh);
+
+       return 0;
+
+nla_put_failure:
+       nlmsg_cancel(skb, nlh);
+
+       return -EMSGSIZE;
+}
+
+static const struct nla_policy ifla_stats_policy[IFLA_STATS_MAX + 1] = {
+       [IFLA_STATS_LINK_64]    = { .len = sizeof(struct rtnl_link_stats64) },
+};
+
+static size_t if_nlmsg_stats_size(const struct net_device *dev,
+                                 u32 filter_mask)
+{
+       size_t size = 0;
+
+       if (filter_mask & IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_64))
+               size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
+
+       return size;
+}
+
+static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh)
+{
+       struct net *net = sock_net(skb->sk);
+       struct if_stats_msg *ifsm;
+       struct net_device *dev = NULL;
+       struct sk_buff *nskb;
+       u32 filter_mask;
+       int err;
+
+       ifsm = nlmsg_data(nlh);
+       if (ifsm->ifindex > 0)
+               dev = __dev_get_by_index(net, ifsm->ifindex);
+       else
+               return -EINVAL;
+
+       if (!dev)
+               return -ENODEV;
+
+       filter_mask = ifsm->filter_mask;
+       if (!filter_mask)
+               return -EINVAL;
+
+       nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL);
+       if (!nskb)
+               return -ENOBUFS;
+
+       err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
+                                 NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
+                                 0, filter_mask);
+       if (err < 0) {
+               /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
+               WARN_ON(err == -EMSGSIZE);
+               kfree_skb(nskb);
+       } else {
+               err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
+       }
+
+       return err;
+}
+
+static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
+{
+       struct net *net = sock_net(skb->sk);
+       struct if_stats_msg *ifsm;
+       int h, s_h;
+       int idx = 0, s_idx;
+       struct net_device *dev;
+       struct hlist_head *head;
+       unsigned int flags = NLM_F_MULTI;
+       u32 filter_mask = 0;
+       int err;
+
+       s_h = cb->args[0];
+       s_idx = cb->args[1];
+
+       cb->seq = net->dev_base_seq;
+
+       ifsm = nlmsg_data(cb->nlh);
+       filter_mask = ifsm->filter_mask;
+       if (!filter_mask)
+               return -EINVAL;
+
+       for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
+               idx = 0;
+               head = &net->dev_index_head[h];
+               hlist_for_each_entry(dev, head, index_hlist) {
+                       if (idx < s_idx)
+                               goto cont;
+                       err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
+                                                 NETLINK_CB(cb->skb).portid,
+                                                 cb->nlh->nlmsg_seq, 0,
+                                                 flags, filter_mask);
+                       /* If we ran out of room on the first message,
+                        * we're in trouble
+                        */
+                       WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
+
+                       if (err < 0)
+                               goto out;
+
+                       nl_dump_check_consistent(cb, nlmsg_hdr(skb));
+cont:
+                       idx++;
+               }
+       }
+out:
+       cb->args[1] = idx;
+       cb->args[0] = h;
+
+       return skb->len;
+}
+
 /* Process one rtnetlink message. */
 
 static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
@@ -3598,4 +3753,7 @@ void __init rtnetlink_init(void)
        rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, NULL);
        rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, NULL);
        rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, NULL);
+
+       rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
+                     NULL);
 }

diff --git a/security/selinux/nlmsgtab.c b/security/selinux/nlmsgtab.c
index 8495b93681906bd39f4065723461cddac2e7d347..2ca9cde939d44976365aa67fe72f51be9b92897d 100644 (file)
--- a/security/selinux/nlmsgtab.c
+++ b/security/selinux/nlmsgtab.c
@@ -76,6 +76,8 @@ static struct nlmsg_perm nlmsg_route_perms[] =
        { RTM_NEWNSID,          NETLINK_ROUTE_SOCKET__NLMSG_WRITE },
        { RTM_DELNSID,          NETLINK_ROUTE_SOCKET__NLMSG_READ  },
        { RTM_GETNSID,          NETLINK_ROUTE_SOCKET__NLMSG_READ  },
+       { RTM_NEWSTATS,         NETLINK_ROUTE_SOCKET__NLMSG_READ },
+       { RTM_GETSTATS,         NETLINK_ROUTE_SOCKET__NLMSG_READ  },
 };
 
 static struct nlmsg_perm nlmsg_tcpdiag_perms[] =
@@ -155,7 +157,7 @@ int selinux_nlmsg_lookup(u16 sclass, u16 nlmsg_type, u32 *perm)
        switch (sclass) {
        case SECCLASS_NETLINK_ROUTE_SOCKET:
                /* RTM_MAX always point to RTM_SETxxxx, ie RTM_NEWxxx + 3 */
-               BUILD_BUG_ON(RTM_MAX != (RTM_NEWNSID + 3));
+               BUILD_BUG_ON(RTM_MAX != (RTM_NEWSTATS + 3));
                err = nlmsg_perm(nlmsg_type, perm, nlmsg_route_perms,
                                 sizeof(nlmsg_route_perms));
                break;