Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec-next

Steffen Klassert says:

====================
One patch to rename a newly introduced struct. The rest is
the rework of the IPsec virtual tunnel interface for ipv6 to
support inter address family tunneling and namespace crossing.

1) Rename the newly introduced struct xfrm_filter to avoid a
   conflict with iproute2. From Nicolas Dichtel.

2) Introduce xfrm_input_afinfo to access the address family
   dependent tunnel callback functions properly.

3) Add and use a IPsec protocol multiplexer for ipv6.

4) Remove dst_entry caching. vti can lookup multiple different
   dst entries, dependent of the configured xfrm states. Therefore
   it does not make to cache a dst_entry.

5) Remove caching of flow informations. vti6 does not use the the
   tunnel endpoint addresses to do route and xfrm lookups.

6) Update the vti6 to use its own receive hook.

7) Remove the now unused xfrm_tunnel_notifier. This was used from vti
   and is replaced by the IPsec protocol multiplexer hooks.

8) Support inter address family tunneling for vti6.

9) Check if the tunnel endpoints of the xfrm state and the vti interface
   are matching and return an error otherwise.

10) Enable namespace crossing for vti devices.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 81 insertions, 6 deletions

diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index 4218164f4f5e..85d1d4764612 100644
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -16,6 +16,81 @@
 
 static struct kmem_cache *secpath_cachep __read_mostly;
 
+static DEFINE_SPINLOCK(xfrm_input_afinfo_lock);
+static struct xfrm_input_afinfo __rcu *xfrm_input_afinfo[NPROTO];
+
+int xfrm_input_register_afinfo(struct xfrm_input_afinfo *afinfo)
+{
+        int err = 0;
+
+        if (unlikely(afinfo == NULL))
+                return -EINVAL;
+        if (unlikely(afinfo->family >= NPROTO))
+                return -EAFNOSUPPORT;
+        spin_lock_bh(&xfrm_input_afinfo_lock);
+        if (unlikely(xfrm_input_afinfo[afinfo->family] != NULL))
+                err = -ENOBUFS;
+        else
+                rcu_assign_pointer(xfrm_input_afinfo[afinfo->family], afinfo);
+        spin_unlock_bh(&xfrm_input_afinfo_lock);
+        return err;
+}
+EXPORT_SYMBOL(xfrm_input_register_afinfo);
+
+int xfrm_input_unregister_afinfo(struct xfrm_input_afinfo *afinfo)
+{
+        int err = 0;
+
+        if (unlikely(afinfo == NULL))
+                return -EINVAL;
+        if (unlikely(afinfo->family >= NPROTO))
+                return -EAFNOSUPPORT;
+        spin_lock_bh(&xfrm_input_afinfo_lock);
+        if (likely(xfrm_input_afinfo[afinfo->family] != NULL)) {
+                if (unlikely(xfrm_input_afinfo[afinfo->family] != afinfo))
+                        err = -EINVAL;
+                else
+                        RCU_INIT_POINTER(xfrm_input_afinfo[afinfo->family], NULL);
+        }
+        spin_unlock_bh(&xfrm_input_afinfo_lock);
+        synchronize_rcu();
+        return err;
+}
+EXPORT_SYMBOL(xfrm_input_unregister_afinfo);
+
+static struct xfrm_input_afinfo *xfrm_input_get_afinfo(unsigned int family)
+{
+        struct xfrm_input_afinfo *afinfo;
+
+        if (unlikely(family >= NPROTO))
+                return NULL;
+        rcu_read_lock();
+        afinfo = rcu_dereference(xfrm_input_afinfo[family]);
+        if (unlikely(!afinfo))
+                rcu_read_unlock();
+        return afinfo;
+}
+
+static void xfrm_input_put_afinfo(struct xfrm_input_afinfo *afinfo)
+{
+        rcu_read_unlock();
+}
+
+static int xfrm_rcv_cb(struct sk_buff *skb, unsigned int family, u8 protocol,
+                       int err)
+{
+        int ret;
+        struct xfrm_input_afinfo *afinfo = xfrm_input_get_afinfo(family);
+
+        if (!afinfo)
+                return -EAFNOSUPPORT;
+
+        ret = afinfo->callback(skb, protocol, err);
+        xfrm_input_put_afinfo(afinfo);
+
+        return ret;
+}
+
 void __secpath_destroy(struct sec_path *sp)
 {
         int i;
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 06970fee9155..8e9c781a6bba 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -1609,7 +1609,7 @@ unlock:
 EXPORT_SYMBOL(xfrm_alloc_spi);
 
 static bool __xfrm_state_filter_match(struct xfrm_state *x,
-                                      struct xfrm_filter *filter)
+                                      struct xfrm_address_filter *filter)
 {
         if (filter) {
                 if ((filter->family == AF_INET ||
@@ -1668,7 +1668,7 @@ out:
 EXPORT_SYMBOL(xfrm_state_walk);
 
 void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
-                          struct xfrm_filter *filter)
+                          struct xfrm_address_filter *filter)
 {
         INIT_LIST_HEAD(&walk->all);
         walk->proto = proto;
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index 195dbe230b98..cdd9e9c7ff0e 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -899,7 +899,7 @@ static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
 
         if (!cb->args[0]) {
                 struct nlattr *attrs[XFRMA_MAX+1];
-                struct xfrm_filter *filter = NULL;
+                struct xfrm_address_filter *filter = NULL;
                 u8 proto = 0;
                 int err;
 
@@ -910,12 +910,12 @@ static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
                 if (err < 0)
                         return err;
 
-                if (attrs[XFRMA_FILTER]) {
+                if (attrs[XFRMA_ADDRESS_FILTER]) {
                         filter = kmalloc(sizeof(*filter), GFP_KERNEL);
                         if (filter == NULL)
                                 return -ENOMEM;
 
-                        memcpy(filter, nla_data(attrs[XFRMA_FILTER]),
+                        memcpy(filter, nla_data(attrs[XFRMA_ADDRESS_FILTER]),
                                sizeof(*filter));
                 }
 
@@ -2329,7 +2329,7 @@ static const struct nla_policy xfrma_policy[XFRMA_MAX+1] = {
         [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) },
+        [XFRMA_ADDRESS_FILTER]  = { .len = sizeof(struct xfrm_address_filter) },
 };
 
 static const struct xfrm_link {