ipsec: add support of limited SA dump

The goal of this patch is to allow userland to dump only a part of SA by
specifying a filter during the dump.
The kernel is in charge to filter SA, this avoids to generate useless netlink
traffic (it save also some cpu cycles). This is particularly useful when there
is a big number of SA set on the system.

Note that I removed the union in struct xfrm_state_walk to fix a problem on arm.
struct netlink_callback->args is defined as a array of 6 long and the first long
is used in xfrm code to flag the cb as initialized. Hence, we must have:
sizeof(struct xfrm_state_walk) <= sizeof(long) * 5.
With the union, it was false on arm (sizeof(struct xfrm_state_walk) was
sizeof(long) * 7), due to the padding.
In fact, whatever the arch is, this union seems useless, there will be always
padding after it. Removing it will not increase the size of this struct (and
reduce it on arm).

Signed-off-by: Nicolas Dichtel <nicolas.dichtel@6wind.com>
Signed-off-by: Steffen Klassert <steffen.klassert@secunet.com>

2 files changed, 51 insertions, 2 deletions

diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 0bf12f665b9b..a750901ac3db 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -1603,6 +1603,23 @@ unlock:
 }
 EXPORT_SYMBOL(xfrm_alloc_spi);
 
+static bool __xfrm_state_filter_match(struct xfrm_state *x,
+                                      struct xfrm_filter *filter)
+{
+        if (filter) {
+                if ((filter->family == AF_INET ||
+                     filter->family == AF_INET6) &&
+                    x->props.family != filter->family)
+                        return false;
+
+                return addr_match(&x->props.saddr, &filter->saddr,
+                                  filter->splen) &&
+                       addr_match(&x->id.daddr, &filter->daddr,
+                                  filter->dplen);
+        }
+        return true;
+}
+
 int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
                     int (*func)(struct xfrm_state *, int, void*),
                     void *data)
@@ -1625,6 +1642,8 @@ int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
                 state = container_of(x, struct xfrm_state, km);
                 if (!xfrm_id_proto_match(state->id.proto, walk->proto))
                         continue;
+                if (!__xfrm_state_filter_match(state, walk->filter))
+                        continue;
                 err = func(state, walk->seq, data);
                 if (err) {
                         list_move_tail(&walk->all, &x->all);
@@ -1643,17 +1662,21 @@ out:
 }
 EXPORT_SYMBOL(xfrm_state_walk);
 
-void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto)
+void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
+                          struct xfrm_filter *filter)
 {
         INIT_LIST_HEAD(&walk->all);
         walk->proto = proto;
         walk->state = XFRM_STATE_DEAD;
         walk->seq = 0;
+        walk->filter = filter;
 }
 EXPORT_SYMBOL(xfrm_state_walk_init);
 
 void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net)
 {
+        kfree(walk->filter);
+
         if (list_empty(&walk->all))
                 return;
 
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index d7694f258294..023e5e7ea4c6 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -887,6 +887,7 @@ static int xfrm_dump_sa_done(struct netlink_callback *cb)
         return 0;
 }
 
+static const struct nla_policy xfrma_policy[XFRMA_MAX+1];
 static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct net *net = sock_net(skb->sk);
@@ -902,8 +903,31 @@ static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
         info.nlmsg_flags = NLM_F_MULTI;
 
         if (!cb->args[0]) {
+                struct nlattr *attrs[XFRMA_MAX+1];
+                struct xfrm_filter *filter = NULL;
+                u8 proto = 0;
+                int err;
+
                 cb->args[0] = 1;
-                xfrm_state_walk_init(walk, 0);
+
+                err = nlmsg_parse(cb->nlh, 0, attrs, XFRMA_MAX,
+                                  xfrma_policy);
+                if (err < 0)
+                        return err;
+
+                if (attrs[XFRMA_FILTER]) {
+                        filter = kmalloc(sizeof(*filter), GFP_KERNEL);
+                        if (filter == NULL)
+                                return -ENOMEM;
+
+                        memcpy(filter, nla_data(attrs[XFRMA_FILTER]),
+                               sizeof(*filter));
+                }
+
+                if (attrs[XFRMA_PROTO])
+                        proto = nla_get_u8(attrs[XFRMA_PROTO]);
+
+                xfrm_state_walk_init(walk, proto, filter);
         }
 
         (void) xfrm_state_walk(net, walk, dump_one_state, &info);
@@ -2309,6 +2333,8 @@ static const struct nla_policy xfrma_policy[XFRMA_MAX+1] = {
         [XFRMA_TFCPAD]          = { .type = NLA_U32 },
         [XFRMA_REPLAY_ESN_VAL]  = { .len = sizeof(struct xfrm_replay_state_esn) },
         [XFRMA_SA_EXTRA_FLAGS]  = { .type = NLA_U32 },
+        [XFRMA_PROTO]           = { .type = NLA_U8 },
+        [XFRMA_FILTER]          = { .len = sizeof(struct xfrm_filter) },
 };
 
 static const struct xfrm_link {