revert android-tegra-2.6.36-honeycomb-mr1-9001adc to v2.6.36

[firefly-linux-kernel-4.4.55.git] / net / core / filter.c

diff --git a/net/core/filter.c b/net/core/filter.c
index 71a433cdf7d39817ce15da50af746336a352e2a0..52b051f82a016e37c792efc8bc30dca3d71fd537 100644 (file)
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -112,41 +112,39 @@ EXPORT_SYMBOL(sk_filter);
  */
 unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int flen)
 {
+       struct sock_filter *fentry;     /* We walk down these */
        void *ptr;
        u32 A = 0;                      /* Accumulator */
        u32 X = 0;                      /* Index Register */
        u32 mem[BPF_MEMWORDS];          /* Scratch Memory Store */
-       unsigned long memvalid = 0;
        u32 tmp;
        int k;
        int pc;
 
-       BUILD_BUG_ON(BPF_MEMWORDS > BITS_PER_LONG);
        /*
         * Process array of filter instructions.
         */
        for (pc = 0; pc < flen; pc++) {
-               const struct sock_filter *fentry = &filter[pc];
-               u32 f_k = fentry->k;
+               fentry = &filter[pc];
 
                switch (fentry->code) {
                case BPF_S_ALU_ADD_X:
                        A += X;
                        continue;
                case BPF_S_ALU_ADD_K:
-                       A += f_k;
+                       A += fentry->k;
                        continue;
                case BPF_S_ALU_SUB_X:
                        A -= X;
                        continue;
                case BPF_S_ALU_SUB_K:
-                       A -= f_k;
+                       A -= fentry->k;
                        continue;
                case BPF_S_ALU_MUL_X:
                        A *= X;
                        continue;
                case BPF_S_ALU_MUL_K:
-                       A *= f_k;
+                       A *= fentry->k;
                        continue;
                case BPF_S_ALU_DIV_X:
                        if (X == 0)
@@ -154,49 +152,49 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
                        A /= X;
                        continue;
                case BPF_S_ALU_DIV_K:
-                       A /= f_k;
+                       A /= fentry->k;
                        continue;
                case BPF_S_ALU_AND_X:
                        A &= X;
                        continue;
                case BPF_S_ALU_AND_K:
-                       A &= f_k;
+                       A &= fentry->k;
                        continue;
                case BPF_S_ALU_OR_X:
                        A |= X;
                        continue;
                case BPF_S_ALU_OR_K:
-                       A |= f_k;
+                       A |= fentry->k;
                        continue;
                case BPF_S_ALU_LSH_X:
                        A <<= X;
                        continue;
                case BPF_S_ALU_LSH_K:
-                       A <<= f_k;
+                       A <<= fentry->k;
                        continue;
                case BPF_S_ALU_RSH_X:
                        A >>= X;
                        continue;
                case BPF_S_ALU_RSH_K:
-                       A >>= f_k;
+                       A >>= fentry->k;
                        continue;
                case BPF_S_ALU_NEG:
                        A = -A;
                        continue;
                case BPF_S_JMP_JA:
-                       pc += f_k;
+                       pc += fentry->k;
                        continue;
                case BPF_S_JMP_JGT_K:
-                       pc += (A > f_k) ? fentry->jt : fentry->jf;
+                       pc += (A > fentry->k) ? fentry->jt : fentry->jf;
                        continue;
                case BPF_S_JMP_JGE_K:
-                       pc += (A >= f_k) ? fentry->jt : fentry->jf;
+                       pc += (A >= fentry->k) ? fentry->jt : fentry->jf;
                        continue;
                case BPF_S_JMP_JEQ_K:
-                       pc += (A == f_k) ? fentry->jt : fentry->jf;
+                       pc += (A == fentry->k) ? fentry->jt : fentry->jf;
                        continue;
                case BPF_S_JMP_JSET_K:
-                       pc += (A & f_k) ? fentry->jt : fentry->jf;
+                       pc += (A & fentry->k) ? fentry->jt : fentry->jf;
                        continue;
                case BPF_S_JMP_JGT_X:
                        pc += (A > X) ? fentry->jt : fentry->jf;
@@ -211,7 +209,7 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
                        pc += (A & X) ? fentry->jt : fentry->jf;
                        continue;
                case BPF_S_LD_W_ABS:
-                       k = f_k;
+                       k = fentry->k;
 load_w:
                        ptr = load_pointer(skb, k, 4, &tmp);
                        if (ptr != NULL) {
@@ -220,7 +218,7 @@ load_w:
                        }
                        break;
                case BPF_S_LD_H_ABS:
-                       k = f_k;
+                       k = fentry->k;
 load_h:
                        ptr = load_pointer(skb, k, 2, &tmp);
                        if (ptr != NULL) {
@@ -229,7 +227,7 @@ load_h:
                        }
                        break;
                case BPF_S_LD_B_ABS:
-                       k = f_k;
+                       k = fentry->k;
 load_b:
                        ptr = load_pointer(skb, k, 1, &tmp);
                        if (ptr != NULL) {
@@ -244,34 +242,32 @@ load_b:
                        X = skb->len;
                        continue;
                case BPF_S_LD_W_IND:
-                       k = X + f_k;
+                       k = X + fentry->k;
                        goto load_w;
                case BPF_S_LD_H_IND:
-                       k = X + f_k;
+                       k = X + fentry->k;
                        goto load_h;
                case BPF_S_LD_B_IND:
-                       k = X + f_k;
+                       k = X + fentry->k;
                        goto load_b;
                case BPF_S_LDX_B_MSH:
-                       ptr = load_pointer(skb, f_k, 1, &tmp);
+                       ptr = load_pointer(skb, fentry->k, 1, &tmp);
                        if (ptr != NULL) {
                                X = (*(u8 *)ptr & 0xf) << 2;
                                continue;
                        }
                        return 0;
                case BPF_S_LD_IMM:
-                       A = f_k;
+                       A = fentry->k;
                        continue;
                case BPF_S_LDX_IMM:
-                       X = f_k;
+                       X = fentry->k;
                        continue;
                case BPF_S_LD_MEM:
-                       A = (memvalid & (1UL << f_k)) ?
-                               mem[f_k] : 0;
+                       A = mem[fentry->k];
                        continue;
                case BPF_S_LDX_MEM:
-                       X = (memvalid & (1UL << f_k)) ?
-                               mem[f_k] : 0;
+                       X = mem[fentry->k];
                        continue;
                case BPF_S_MISC_TAX:
                        X = A;
@@ -280,16 +276,14 @@ load_b:
                        A = X;
                        continue;
                case BPF_S_RET_K:
-                       return f_k;
+                       return fentry->k;
                case BPF_S_RET_A:
                        return A;
                case BPF_S_ST:
-                       memvalid |= 1UL << f_k;
-                       mem[f_k] = A;
+                       mem[fentry->k] = A;
                        continue;
                case BPF_S_STX:
-                       memvalid |= 1UL << f_k;
-                       mem[f_k] = X;
+                       mem[fentry->k] = X;
                        continue;
                default:
                        WARN_ON(1);
@@ -589,16 +583,23 @@ int sk_chk_filter(struct sock_filter *filter, int flen)
 EXPORT_SYMBOL(sk_chk_filter);
 
 /**
- *     sk_filter_release_rcu - Release a socket filter by rcu_head
+ *     sk_filter_rcu_release: Release a socket filter by rcu_head
  *     @rcu: rcu_head that contains the sk_filter to free
  */
-void sk_filter_release_rcu(struct rcu_head *rcu)
+static void sk_filter_rcu_release(struct rcu_head *rcu)
 {
        struct sk_filter *fp = container_of(rcu, struct sk_filter, rcu);
 
-       kfree(fp);
+       sk_filter_release(fp);
+}
+
+static void sk_filter_delayed_uncharge(struct sock *sk, struct sk_filter *fp)
+{
+       unsigned int size = sk_filter_len(fp);
+
+       atomic_sub(size, &sk->sk_omem_alloc);
+       call_rcu_bh(&fp->rcu, sk_filter_rcu_release);
 }
-EXPORT_SYMBOL(sk_filter_release_rcu);
 
 /**
  *     sk_attach_filter - attach a socket filter
@@ -643,7 +644,7 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
        rcu_read_unlock_bh();
 
        if (old_fp)
-               sk_filter_uncharge(sk, old_fp);
+               sk_filter_delayed_uncharge(sk, old_fp);
        return 0;
 }
 EXPORT_SYMBOL_GPL(sk_attach_filter);
@@ -657,7 +658,7 @@ int sk_detach_filter(struct sock *sk)
        filter = rcu_dereference_bh(sk->sk_filter);
        if (filter) {
                rcu_assign_pointer(sk->sk_filter, NULL);
-               sk_filter_uncharge(sk, filter);
+               sk_filter_delayed_uncharge(sk, filter);
                ret = 0;
        }
        rcu_read_unlock_bh();