Merge branch 'filter-next'

Alexei Starovoitov says:

====================
net: filter: split sk_filter into socket and bpf, cleanup names

The main goal of the series is to split 'struct sk_filter' into socket and
bpf parts and cleanup names in the following way:
- everything that deals with sockets keeps 'sk_*' prefix
- everything that is pure BPF is changed to 'bpf_*' prefix

split 'struct sk_filter' into
struct sk_filter {
	atomic_t        refcnt;
	struct rcu_head rcu;
	struct bpf_prog *prog;
};
and
struct bpf_prog {
        u32                     jited:1,
                                len:31;
        struct sock_fprog_kern  *orig_prog;
        unsigned int            (*bpf_func)(const struct sk_buff *skb,
                                            const struct bpf_insn *filter);
        union {
                struct sock_filter      insns[0];
                struct bpf_insn         insnsi[0];
                struct work_struct      work;
        };
};
so that 'struct bpf_prog' can be used independent of sockets and cleans up
'unattached' bpf use cases:
isdn, ppp, team, seccomp, ptp, xt_bpf, cls_bpf, test_bpf
which don't need refcnt/rcu fields.

It's a follow up to the rcu cleanup started by Pablo in
commit 34c5bd66e5 ("net: filter: don't release unattached filter through call_rcu()")

Patch 1 - cleans up socket memory charging and makes it possible for functions
  sk(bpf)_migrate_filter(), sk(bpf)_prepare_filter() to be socket independent
Patches 2-4 - trivial renames
Patch 5 - sk_filter split and renames of related sk_*() functions
====================

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

6 files changed, 112 insertions, 108 deletions

diff --git a/net/core/filter.c b/net/core/filter.c
index 42c1944b0c63..d814b8a89d0f 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -18,7 +18,7 @@
  * 2 of the License, or (at your option) any later version.
  *
  * Andi Kleen - Fix a few bad bugs and races.
- * Kris Katterjohn - Added many additional checks in sk_chk_filter()
+ * Kris Katterjohn - Added many additional checks in bpf_check_classic()
  */
 
 #include <linux/module.h>
@@ -312,7 +312,7 @@ static bool convert_bpf_extensions(struct sock_filter *fp,
 }
 
 /**
- *      sk_convert_filter - convert filter program
+ *      bpf_convert_filter - convert filter program
  *      @prog: the user passed filter program
  *      @len: the length of the user passed filter program
  *      @new_prog: buffer where converted program will be stored
@@ -322,12 +322,12 @@ static bool convert_bpf_extensions(struct sock_filter *fp,
  * Conversion workflow:
  *
  * 1) First pass for calculating the new program length:
- *   sk_convert_filter(old_prog, old_len, NULL, &new_len)
+ *   bpf_convert_filter(old_prog, old_len, NULL, &new_len)
  *
  * 2) 2nd pass to remap in two passes: 1st pass finds new
  *    jump offsets, 2nd pass remapping:
  *   new_prog = kmalloc(sizeof(struct bpf_insn) * new_len);
- *   sk_convert_filter(old_prog, old_len, new_prog, &new_len);
+ *   bpf_convert_filter(old_prog, old_len, new_prog, &new_len);
  *
  * User BPF's register A is mapped to our BPF register 6, user BPF
  * register X is mapped to BPF register 7; frame pointer is always
@@ -335,8 +335,8 @@ static bool convert_bpf_extensions(struct sock_filter *fp,
  * for socket filters: ctx == 'struct sk_buff *', for seccomp:
  * ctx == 'struct seccomp_data *'.
  */
-int sk_convert_filter(struct sock_filter *prog, int len,
-                      struct bpf_insn *new_prog, int *new_len)
+int bpf_convert_filter(struct sock_filter *prog, int len,
+                       struct bpf_insn *new_prog, int *new_len)
 {
         int new_flen = 0, pass = 0, target, i;
         struct bpf_insn *new_insn;
@@ -721,7 +721,7 @@ static bool chk_code_allowed(u16 code_to_probe)
 }
 
 /**
- *      sk_chk_filter - verify socket filter code
+ *      bpf_check_classic - verify socket filter code
  *      @filter: filter to verify
  *      @flen: length of filter
  *
@@ -734,7 +734,7 @@ static bool chk_code_allowed(u16 code_to_probe)
  *
  * Returns 0 if the rule set is legal or -EINVAL if not.
  */
-int sk_chk_filter(const struct sock_filter *filter, unsigned int flen)
+int bpf_check_classic(const struct sock_filter *filter, unsigned int flen)
 {
         bool anc_found;
         int pc;
@@ -808,12 +808,12 @@ int sk_chk_filter(const struct sock_filter *filter, unsigned int flen)
 
         return -EINVAL;
 }
-EXPORT_SYMBOL(sk_chk_filter);
+EXPORT_SYMBOL(bpf_check_classic);
 
-static int sk_store_orig_filter(struct sk_filter *fp,
-                                const struct sock_fprog *fprog)
+static int bpf_prog_store_orig_filter(struct bpf_prog *fp,
+                                      const struct sock_fprog *fprog)
 {
-        unsigned int fsize = sk_filter_proglen(fprog);
+        unsigned int fsize = bpf_classic_proglen(fprog);
         struct sock_fprog_kern *fkprog;
 
         fp->orig_prog = kmalloc(sizeof(*fkprog), GFP_KERNEL);
@@ -831,7 +831,7 @@ static int sk_store_orig_filter(struct sk_filter *fp,
         return 0;
 }
 
-static void sk_release_orig_filter(struct sk_filter *fp)
+static void bpf_release_orig_filter(struct bpf_prog *fp)
 {
         struct sock_fprog_kern *fprog = fp->orig_prog;
 
@@ -841,10 +841,16 @@ static void sk_release_orig_filter(struct sk_filter *fp)
         }
 }
 
+static void __bpf_prog_release(struct bpf_prog *prog)
+{
+        bpf_release_orig_filter(prog);
+        bpf_prog_free(prog);
+}
+
 static void __sk_filter_release(struct sk_filter *fp)
 {
-        sk_release_orig_filter(fp);
-        sk_filter_free(fp);
+        __bpf_prog_release(fp->prog);
+        kfree(fp);
 }
 
 /**
@@ -872,44 +878,33 @@ static void sk_filter_release(struct sk_filter *fp)
 
 void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
 {
-        atomic_sub(sk_filter_size(fp->len), &sk->sk_omem_alloc);
-        sk_filter_release(fp);
-}
+        u32 filter_size = bpf_prog_size(fp->prog->len);
 
-void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
-{
-        atomic_inc(&fp->refcnt);
-        atomic_add(sk_filter_size(fp->len), &sk->sk_omem_alloc);
+        atomic_sub(filter_size, &sk->sk_omem_alloc);
+        sk_filter_release(fp);
 }
 
-static struct sk_filter *__sk_migrate_realloc(struct sk_filter *fp,
-                                              struct sock *sk,
-                                              unsigned int len)
+/* try to charge the socket memory if there is space available
+ * return true on success
+ */
+bool sk_filter_charge(struct sock *sk, struct sk_filter *fp)
 {
-        struct sk_filter *fp_new;
-
-        if (sk == NULL)
-                return krealloc(fp, len, GFP_KERNEL);
-
-        fp_new = sock_kmalloc(sk, len, GFP_KERNEL);
-        if (fp_new) {
-                *fp_new = *fp;
-                /* As we're keeping orig_prog in fp_new along,
-                 * we need to make sure we're not evicting it
-                 * from the old fp.
-                 */
-                fp->orig_prog = NULL;
-                sk_filter_uncharge(sk, fp);
+        u32 filter_size = bpf_prog_size(fp->prog->len);
+
+        /* same check as in sock_kmalloc() */
+        if (filter_size <= sysctl_optmem_max &&
+            atomic_read(&sk->sk_omem_alloc) + filter_size < sysctl_optmem_max) {
+                atomic_inc(&fp->refcnt);
+                atomic_add(filter_size, &sk->sk_omem_alloc);
+                return true;
         }
-
-        return fp_new;
+        return false;
 }
 
-static struct sk_filter *__sk_migrate_filter(struct sk_filter *fp,
-                                             struct sock *sk)
+static struct bpf_prog *bpf_migrate_filter(struct bpf_prog *fp)
 {
         struct sock_filter *old_prog;
-        struct sk_filter *old_fp;
+        struct bpf_prog *old_fp;
         int err, new_len, old_len = fp->len;
 
         /* We are free to overwrite insns et al right here as it
@@ -932,13 +927,13 @@ static struct sk_filter *__sk_migrate_filter(struct sk_filter *fp,
         }
 
         /* 1st pass: calculate the new program length. */
-        err = sk_convert_filter(old_prog, old_len, NULL, &new_len);
+        err = bpf_convert_filter(old_prog, old_len, NULL, &new_len);
         if (err)
                 goto out_err_free;
 
         /* Expand fp for appending the new filter representation. */
         old_fp = fp;
-        fp = __sk_migrate_realloc(old_fp, sk, sk_filter_size(new_len));
+        fp = krealloc(old_fp, bpf_prog_size(new_len), GFP_KERNEL);
         if (!fp) {
                 /* The old_fp is still around in case we couldn't
                  * allocate new memory, so uncharge on that one.
@@ -951,16 +946,16 @@ static struct sk_filter *__sk_migrate_filter(struct sk_filter *fp,
         fp->len = new_len;
 
         /* 2nd pass: remap sock_filter insns into bpf_insn insns. */
-        err = sk_convert_filter(old_prog, old_len, fp->insnsi, &new_len);
+        err = bpf_convert_filter(old_prog, old_len, fp->insnsi, &new_len);
         if (err)
-                /* 2nd sk_convert_filter() can fail only if it fails
+                /* 2nd bpf_convert_filter() can fail only if it fails
                  * to allocate memory, remapping must succeed. Note,
                  * that at this time old_fp has already been released
-                 * by __sk_migrate_realloc().
+                 * by krealloc().
                  */
                 goto out_err_free;
 
-        sk_filter_select_runtime(fp);
+        bpf_prog_select_runtime(fp);
 
         kfree(old_prog);
         return fp;
@@ -968,28 +963,20 @@ static struct sk_filter *__sk_migrate_filter(struct sk_filter *fp,
 out_err_free:
         kfree(old_prog);
 out_err:
-        /* Rollback filter setup. */
-        if (sk != NULL)
-                sk_filter_uncharge(sk, fp);
-        else
-                kfree(fp);
+        __bpf_prog_release(fp);
         return ERR_PTR(err);
 }
 
-static struct sk_filter *__sk_prepare_filter(struct sk_filter *fp,
-                                             struct sock *sk)
+static struct bpf_prog *bpf_prepare_filter(struct bpf_prog *fp)
 {
         int err;
 
         fp->bpf_func = NULL;
         fp->jited = 0;
 
-        err = sk_chk_filter(fp->insns, fp->len);
+        err = bpf_check_classic(fp->insns, fp->len);
         if (err) {
-                if (sk != NULL)
-                        sk_filter_uncharge(sk, fp);
-                else
-                        kfree(fp);
+                __bpf_prog_release(fp);
                 return ERR_PTR(err);
         }
 
@@ -1002,13 +989,13 @@ static struct sk_filter *__sk_prepare_filter(struct sk_filter *fp,
          * internal BPF translation for the optimized interpreter.
          */
         if (!fp->jited)
-                fp = __sk_migrate_filter(fp, sk);
+                fp = bpf_migrate_filter(fp);
 
         return fp;
 }
 
 /**
- *      sk_unattached_filter_create - create an unattached filter
+ *      bpf_prog_create - create an unattached filter
  *      @pfp: the unattached filter that is created
  *      @fprog: the filter program
  *
@@ -1017,23 +1004,21 @@ static struct sk_filter *__sk_prepare_filter(struct sk_filter *fp,
  * If an error occurs or there is insufficient memory for the filter
  * a negative errno code is returned. On success the return is zero.
  */
-int sk_unattached_filter_create(struct sk_filter **pfp,
-                                struct sock_fprog_kern *fprog)
+int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog)
 {
-        unsigned int fsize = sk_filter_proglen(fprog);
-        struct sk_filter *fp;
+        unsigned int fsize = bpf_classic_proglen(fprog);
+        struct bpf_prog *fp;
 
         /* Make sure new filter is there and in the right amounts. */
         if (fprog->filter == NULL)
                 return -EINVAL;
 
-        fp = kmalloc(sk_filter_size(fprog->len), GFP_KERNEL);
+        fp = kmalloc(bpf_prog_size(fprog->len), GFP_KERNEL);
         if (!fp)
                 return -ENOMEM;
 
         memcpy(fp->insns, fprog->filter, fsize);
 
-        atomic_set(&fp->refcnt, 1);
         fp->len = fprog->len;
         /* Since unattached filters are not copied back to user
          * space through sk_get_filter(), we do not need to hold
@@ -1041,23 +1026,23 @@ int sk_unattached_filter_create(struct sk_filter **pfp,
          */
         fp->orig_prog = NULL;
 
-        /* __sk_prepare_filter() already takes care of uncharging
+        /* bpf_prepare_filter() already takes care of freeing
          * memory in case something goes wrong.
          */
-        fp = __sk_prepare_filter(fp, NULL);
+        fp = bpf_prepare_filter(fp);
         if (IS_ERR(fp))
                 return PTR_ERR(fp);
 
         *pfp = fp;
         return 0;
 }
-EXPORT_SYMBOL_GPL(sk_unattached_filter_create);
+EXPORT_SYMBOL_GPL(bpf_prog_create);
 
-void sk_unattached_filter_destroy(struct sk_filter *fp)
+void bpf_prog_destroy(struct bpf_prog *fp)
 {
-        __sk_filter_release(fp);
+        __bpf_prog_release(fp);
 }
-EXPORT_SYMBOL_GPL(sk_unattached_filter_destroy);
+EXPORT_SYMBOL_GPL(bpf_prog_destroy);
 
 /**
  *      sk_attach_filter - attach a socket filter
@@ -1072,8 +1057,9 @@ EXPORT_SYMBOL_GPL(sk_unattached_filter_destroy);
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
 {
         struct sk_filter *fp, *old_fp;
-        unsigned int fsize = sk_filter_proglen(fprog);
-        unsigned int sk_fsize = sk_filter_size(fprog->len);
+        unsigned int fsize = bpf_classic_proglen(fprog);
+        unsigned int bpf_fsize = bpf_prog_size(fprog->len);
+        struct bpf_prog *prog;
         int err;
 
         if (sock_flag(sk, SOCK_FILTER_LOCKED))
@@ -1083,30 +1069,43 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
         if (fprog->filter == NULL)
                 return -EINVAL;
 
-        fp = sock_kmalloc(sk, sk_fsize, GFP_KERNEL);
-        if (!fp)
+        prog = kmalloc(bpf_fsize, GFP_KERNEL);
+        if (!prog)
                 return -ENOMEM;
 
-        if (copy_from_user(fp->insns, fprog->filter, fsize)) {
-                sock_kfree_s(sk, fp, sk_fsize);
+        if (copy_from_user(prog->insns, fprog->filter, fsize)) {
+                kfree(prog);
                 return -EFAULT;
         }
 
-        atomic_set(&fp->refcnt, 1);
-        fp->len = fprog->len;
+        prog->len = fprog->len;
 
-        err = sk_store_orig_filter(fp, fprog);
+        err = bpf_prog_store_orig_filter(prog, fprog);
         if (err) {
-                sk_filter_uncharge(sk, fp);
+                kfree(prog);
                 return -ENOMEM;
         }
 
-        /* __sk_prepare_filter() already takes care of uncharging
+        /* bpf_prepare_filter() already takes care of freeing
          * memory in case something goes wrong.
          */
-        fp = __sk_prepare_filter(fp, sk);
-        if (IS_ERR(fp))
-                return PTR_ERR(fp);
+        prog = bpf_prepare_filter(prog);
+        if (IS_ERR(prog))
+                return PTR_ERR(prog);
+
+        fp = kmalloc(sizeof(*fp), GFP_KERNEL);
+        if (!fp) {
+                __bpf_prog_release(prog);
+                return -ENOMEM;
+        }
+        fp->prog = prog;
+
+        atomic_set(&fp->refcnt, 0);
+
+        if (!sk_filter_charge(sk, fp)) {
+                __sk_filter_release(fp);
+                return -ENOMEM;
+        }
 
         old_fp = rcu_dereference_protected(sk->sk_filter,
                                            sock_owned_by_user(sk));
@@ -1155,7 +1154,7 @@ int sk_get_filter(struct sock *sk, struct sock_filter __user *ubuf,
         /* We're copying the filter that has been originally attached,
          * so no conversion/decode needed anymore.
          */
-        fprog = filter->orig_prog;
+        fprog = filter->prog->orig_prog;
 
         ret = fprog->len;
         if (!len)
@@ -1167,7 +1166,7 @@ int sk_get_filter(struct sock *sk, struct sock_filter __user *ubuf,
                 goto out;
 
         ret = -EFAULT;
-        if (copy_to_user(ubuf, fprog->filter, sk_filter_proglen(fprog)))
+        if (copy_to_user(ubuf, fprog->filter, bpf_classic_proglen(fprog)))
                 goto out;
 
         /* Instead of bytes, the API requests to return the number
diff --git a/net/core/ptp_classifier.c b/net/core/ptp_classifier.c
index 12ab7b4be609..4eab4a94a59d 100644
--- a/net/core/ptp_classifier.c
+++ b/net/core/ptp_classifier.c
@@ -107,11 +107,11 @@
 #include <linux/filter.h>
 #include <linux/ptp_classify.h>
 
-static struct sk_filter *ptp_insns __read_mostly;
+static struct bpf_prog *ptp_insns __read_mostly;
 
 unsigned int ptp_classify_raw(const struct sk_buff *skb)
 {
-        return SK_RUN_FILTER(ptp_insns, skb);
+        return BPF_PROG_RUN(ptp_insns, skb);
 }
 EXPORT_SYMBOL_GPL(ptp_classify_raw);
 
@@ -189,5 +189,5 @@ void __init ptp_classifier_init(void)
                 .len = ARRAY_SIZE(ptp_filter), .filter = ptp_filter,
         };
 
-        BUG_ON(sk_unattached_filter_create(&ptp_insns, &ptp_prog));
+        BUG_ON(bpf_prog_create(&ptp_insns, &ptp_prog));
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index 134291d73fcd..a741163568fa 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1474,6 +1474,7 @@ static void sk_update_clone(const struct sock *sk, struct sock *newsk)
 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
 {
         struct sock *newsk;
+        bool is_charged = true;
 
         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
         if (newsk != NULL) {
@@ -1518,9 +1519,13 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
 
                 filter = rcu_dereference_protected(newsk->sk_filter, 1);
                 if (filter != NULL)
-                        sk_filter_charge(newsk, filter);
+                        /* though it's an empty new sock, the charging may fail
+                         * if sysctl_optmem_max was changed between creation of
+                         * original socket and cloning
+                         */
+                        is_charged = sk_filter_charge(newsk, filter);
 
-                if (unlikely(xfrm_sk_clone_policy(newsk))) {
+                if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk))) {
                         /* It is still raw copy of parent, so invalidate
                          * destructor and make plain sk_free() */
                         newsk->sk_destruct = NULL;
diff --git a/net/core/sock_diag.c b/net/core/sock_diag.c
index a4216a4c9572..ad704c757bb4 100644
--- a/net/core/sock_diag.c
+++ b/net/core/sock_diag.c
@@ -68,8 +68,8 @@ int sock_diag_put_filterinfo(bool may_report_filterinfo, struct sock *sk,
         if (!filter)
                 goto out;
 
-        fprog = filter->orig_prog;
-        flen = sk_filter_proglen(fprog);
+        fprog = filter->prog->orig_prog;
+        flen = bpf_classic_proglen(fprog);
 
         attr = nla_reserve(skb, attrtype, flen);
         if (attr == NULL) {
diff --git a/net/netfilter/xt_bpf.c b/net/netfilter/xt_bpf.c
index bbffdbdaf603..dffee9d47ec4 100644
--- a/net/netfilter/xt_bpf.c
+++ b/net/netfilter/xt_bpf.c
@@ -28,7 +28,7 @@ static int bpf_mt_check(const struct xt_mtchk_param *par)
         program.len = info->bpf_program_num_elem;
         program.filter = info->bpf_program;
 
-        if (sk_unattached_filter_create(&info->filter, &program)) {
+        if (bpf_prog_create(&info->filter, &program)) {
                 pr_info("bpf: check failed: parse error\n");
                 return -EINVAL;
         }
@@ -40,13 +40,13 @@ static bool bpf_mt(const struct sk_buff *skb, struct xt_action_param *par)
 {
         const struct xt_bpf_info *info = par->matchinfo;
 
-        return SK_RUN_FILTER(info->filter, skb);
+        return BPF_PROG_RUN(info->filter, skb);
 }
 
 static void bpf_mt_destroy(const struct xt_mtdtor_param *par)
 {
         const struct xt_bpf_info *info = par->matchinfo;
-        sk_unattached_filter_destroy(info->filter);
+        bpf_prog_destroy(info->filter);
 }
 
 static struct xt_match bpf_mt_reg __read_mostly = {
diff --git a/net/sched/cls_bpf.c b/net/sched/cls_bpf.c
index 13f64df2c710..0e30d58149da 100644
--- a/net/sched/cls_bpf.c
+++ b/net/sched/cls_bpf.c
@@ -30,7 +30,7 @@ struct cls_bpf_head {
 };
 
 struct cls_bpf_prog {
-        struct sk_filter *filter;
+        struct bpf_prog *filter;
         struct sock_filter *bpf_ops;
         struct tcf_exts exts;
         struct tcf_result res;
@@ -54,7 +54,7 @@ static int cls_bpf_classify(struct sk_buff *skb, const struct tcf_proto *tp,
         int ret;
 
         list_for_each_entry(prog, &head->plist, link) {
-                int filter_res = SK_RUN_FILTER(prog->filter, skb);
+                int filter_res = BPF_PROG_RUN(prog->filter, skb);
 
                 if (filter_res == 0)
                         continue;
@@ -92,7 +92,7 @@ static void cls_bpf_delete_prog(struct tcf_proto *tp, struct cls_bpf_prog *prog)
         tcf_unbind_filter(tp, &prog->res);
         tcf_exts_destroy(tp, &prog->exts);
 
-        sk_unattached_filter_destroy(prog->filter);
+        bpf_prog_destroy(prog->filter);
 
         kfree(prog->bpf_ops);
         kfree(prog);
@@ -161,7 +161,7 @@ static int cls_bpf_modify_existing(struct net *net, struct tcf_proto *tp,
         struct sock_filter *bpf_ops, *bpf_old;
         struct tcf_exts exts;
         struct sock_fprog_kern tmp;
-        struct sk_filter *fp, *fp_old;
+        struct bpf_prog *fp, *fp_old;
         u16 bpf_size, bpf_len;
         u32 classid;
         int ret;
@@ -193,7 +193,7 @@ static int cls_bpf_modify_existing(struct net *net, struct tcf_proto *tp,
         tmp.len = bpf_len;
         tmp.filter = bpf_ops;
 
-        ret = sk_unattached_filter_create(&fp, &tmp);
+        ret = bpf_prog_create(&fp, &tmp);
         if (ret)
                 goto errout_free;
 
@@ -211,7 +211,7 @@ static int cls_bpf_modify_existing(struct net *net, struct tcf_proto *tp,
         tcf_exts_change(tp, &prog->exts, &exts);
 
         if (fp_old)
-                sk_unattached_filter_destroy(fp_old);
+                bpf_prog_destroy(fp_old);
         if (bpf_old)
                 kfree(bpf_old);