nfsd: Revert "svcrpc: take advantage of tcp autotuning"

[safe/jmp/linux-2.6] / net / ipv6 / xfrm6_input.c

diff --git a/net/ipv6/xfrm6_input.c b/net/ipv6/xfrm6_input.c
index e2c3efd..9084582 100644 (file)
--- a/net/ipv6/xfrm6_input.c
+++ b/net/ipv6/xfrm6_input.c
@@ -23,6 +23,7 @@ int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb)
 
 int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
 {
+       XFRM_SPI_SKB_CB(skb)->family = AF_INET6;
        XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct ipv6hdr, daddr);
        return xfrm_input(skb, nexthdr, spi, 0);
 }
@@ -33,19 +34,17 @@ int xfrm6_transport_finish(struct sk_buff *skb, int async)
        skb_network_header(skb)[IP6CB(skb)->nhoff] =
                XFRM_MODE_SKB_CB(skb)->protocol;
 
-#ifdef CONFIG_NETFILTER
+#ifndef CONFIG_NETFILTER
+       if (!async)
+               return 1;
+#endif
+
        ipv6_hdr(skb)->payload_len = htons(skb->len);
        __skb_push(skb, skb->data - skb_network_header(skb));
 
        NF_HOOK(PF_INET6, NF_INET_PRE_ROUTING, skb, skb->dev, NULL,
                ip6_rcv_finish);
        return -1;
-#else
-       if (async)
-               return ip6_rcv_finish(skb);
-
-       return 1;
-#endif
 }
 
 int xfrm6_rcv(struct sk_buff *skb)
@@ -59,17 +58,32 @@ EXPORT_SYMBOL(xfrm6_rcv);
 int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
                     xfrm_address_t *saddr, u8 proto)
 {
+       struct net *net = dev_net(skb->dev);
        struct xfrm_state *x = NULL;
-       int wildcard = 0;
-       xfrm_address_t *xany;
-       struct xfrm_state *xfrm_vec_one = NULL;
-       int nh = 0;
        int i = 0;
 
-       xany = (xfrm_address_t *)&in6addr_any;
+       /* Allocate new secpath or COW existing one. */
+       if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) {
+               struct sec_path *sp;
+
+               sp = secpath_dup(skb->sp);
+               if (!sp) {
+                       XFRM_INC_STATS(net, LINUX_MIB_XFRMINERROR);
+                       goto drop;
+               }
+               if (skb->sp)
+                       secpath_put(skb->sp);
+               skb->sp = sp;
+       }
+
+       if (1 + skb->sp->len == XFRM_MAX_DEPTH) {
+               XFRM_INC_STATS(net, LINUX_MIB_XFRMINBUFFERERROR);
+               goto drop;
+       }
 
        for (i = 0; i < 3; i++) {
                xfrm_address_t *dst, *src;
+
                switch (i) {
                case 0:
                        dst = daddr;
@@ -77,88 +91,55 @@ int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
                        break;
                case 1:
                        /* lookup state with wild-card source address */
-                       wildcard = 1;
                        dst = daddr;
-                       src = xany;
+                       src = (xfrm_address_t *)&in6addr_any;
                        break;
-               case 2:
                default:
                        /* lookup state with wild-card addresses */
-                       wildcard = 1; /* XXX */
-                       dst = xany;
-                       src = xany;
+                       dst = (xfrm_address_t *)&in6addr_any;
+                       src = (xfrm_address_t *)&in6addr_any;
                        break;
                }
 
-               x = xfrm_state_lookup_byaddr(dst, src, proto, AF_INET6);
+               x = xfrm_state_lookup_byaddr(net, dst, src, proto, AF_INET6);
                if (!x)
                        continue;
 
                spin_lock(&x->lock);
 
-               if (wildcard) {
-                       if ((x->props.flags & XFRM_STATE_WILDRECV) == 0) {
-                               spin_unlock(&x->lock);
-                               xfrm_state_put(x);
-                               x = NULL;
-                               continue;
-                       }
-               }
-
-               if (unlikely(x->km.state != XFRM_STATE_VALID)) {
+               if ((!i || (x->props.flags & XFRM_STATE_WILDRECV)) &&
+                   likely(x->km.state == XFRM_STATE_VALID) &&
+                   !xfrm_state_check_expire(x)) {
                        spin_unlock(&x->lock);
-                       xfrm_state_put(x);
-                       x = NULL;
-                       continue;
-               }
-               if (xfrm_state_check_expire(x)) {
-                       spin_unlock(&x->lock);
-                       xfrm_state_put(x);
-                       x = NULL;
-                       continue;
-               }
-
-               nh = x->type->input(x, skb);
-               if (nh <= 0) {
+                       if (x->type->input(x, skb) > 0) {
+                               /* found a valid state */
+                               break;
+                       }
+               } else
                        spin_unlock(&x->lock);
-                       xfrm_state_put(x);
-                       x = NULL;
-                       continue;
-               }
-
-               x->curlft.bytes += skb->len;
-               x->curlft.packets++;
 
-               spin_unlock(&x->lock);
-
-               xfrm_vec_one = x;
-               break;
+               xfrm_state_put(x);
+               x = NULL;
        }
 
-       if (!xfrm_vec_one)
+       if (!x) {
+               XFRM_INC_STATS(net, LINUX_MIB_XFRMINNOSTATES);
+               xfrm_audit_state_notfound_simple(skb, AF_INET6);
                goto drop;
-
-       /* Allocate new secpath or COW existing one. */
-       if (!skb->sp || atomic_read(&skb->sp->refcnt) != 1) {
-               struct sec_path *sp;
-               sp = secpath_dup(skb->sp);
-               if (!sp)
-                       goto drop;
-               if (skb->sp)
-                       secpath_put(skb->sp);
-               skb->sp = sp;
        }
 
-       if (1 + skb->sp->len > XFRM_MAX_DEPTH)
-               goto drop;
+       skb->sp->xvec[skb->sp->len++] = x;
+
+       spin_lock(&x->lock);
 
-       skb->sp->xvec[skb->sp->len] = xfrm_vec_one;
-       skb->sp->len ++;
+       x->curlft.bytes += skb->len;
+       x->curlft.packets++;
+
+       spin_unlock(&x->lock);
 
        return 1;
+
 drop:
-       if (xfrm_vec_one)
-               xfrm_state_put(xfrm_vec_one);
        return -1;
 }