3 files changed, 114 insertions, 0 deletions

diff --git a/net/core/filter.c b/net/core/filter.c
index 949adc3d9abb..2014d76e0d2a 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -5695,6 +5695,46 @@ BPF_CALL_1(bpf_skb_ecn_set_ce, struct sk_buff *, skb)
         return INET_ECN_set_ce(skb);
 }
 
+bool bpf_xdp_sock_is_valid_access(int off, int size, enum bpf_access_type type,
+                                  struct bpf_insn_access_aux *info)
+{
+        if (off < 0 || off >= offsetofend(struct bpf_xdp_sock, queue_id))
+                return false;
+
+        if (off % size != 0)
+                return false;
+
+        switch (off) {
+        default:
+                return size == sizeof(__u32);
+        }
+}
+
+u32 bpf_xdp_sock_convert_ctx_access(enum bpf_access_type type,
+                                    const struct bpf_insn *si,
+                                    struct bpf_insn *insn_buf,
+                                    struct bpf_prog *prog, u32 *target_size)
+{
+        struct bpf_insn *insn = insn_buf;
+
+#define BPF_XDP_SOCK_GET(FIELD)                                         \
+        do {                                                            \
+                BUILD_BUG_ON(FIELD_SIZEOF(struct xdp_sock, FIELD) >     \
+                             FIELD_SIZEOF(struct bpf_xdp_sock, FIELD)); \
+                *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct xdp_sock, FIELD),\
+                                      si->dst_reg, si->src_reg,         \
+                                      offsetof(struct xdp_sock, FIELD)); \
+        } while (0)
+
+        switch (si->off) {
+        case offsetof(struct bpf_xdp_sock, queue_id):
+                BPF_XDP_SOCK_GET(queue_id);
+                break;
+        }
+
+        return insn - insn_buf;
+}
+
 static const struct bpf_func_proto bpf_skb_ecn_set_ce_proto = {
         .func           = bpf_skb_ecn_set_ce,
         .gpl_only       = false,
@@ -5897,6 +5937,10 @@ sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
         case BPF_FUNC_skc_lookup_tcp:
                 return &bpf_sock_addr_skc_lookup_tcp_proto;
 #endif /* CONFIG_INET */
+        case BPF_FUNC_sk_storage_get:
+                return &bpf_sk_storage_get_proto;
+        case BPF_FUNC_sk_storage_delete:
+                return &bpf_sk_storage_delete_proto;
         default:
                 return bpf_base_func_proto(func_id);
         }
@@ -5934,6 +5978,10 @@ cg_skb_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
                 return &bpf_sk_storage_get_proto;
         case BPF_FUNC_sk_storage_delete:
                 return &bpf_sk_storage_delete_proto;
+#ifdef CONFIG_SOCK_CGROUP_DATA
+        case BPF_FUNC_skb_cgroup_id:
+                return &bpf_skb_cgroup_id_proto;
+#endif
 #ifdef CONFIG_INET
         case BPF_FUNC_tcp_sock:
                 return &bpf_tcp_sock_proto;
@@ -6114,6 +6162,14 @@ sock_ops_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
                 return &bpf_get_local_storage_proto;
         case BPF_FUNC_perf_event_output:
                 return &bpf_sockopt_event_output_proto;
+        case BPF_FUNC_sk_storage_get:
+                return &bpf_sk_storage_get_proto;
+        case BPF_FUNC_sk_storage_delete:
+                return &bpf_sk_storage_delete_proto;
+#ifdef CONFIG_INET
+        case BPF_FUNC_tcp_sock:
+                return &bpf_tcp_sock_proto;
+#endif /* CONFIG_INET */
         default:
                 return bpf_base_func_proto(func_id);
         }
@@ -6801,6 +6857,13 @@ static bool sock_addr_is_valid_access(int off, int size,
                 if (size != size_default)
                         return false;
                 break;
+        case offsetof(struct bpf_sock_addr, sk):
+                if (type != BPF_READ)
+                        return false;
+                if (size != sizeof(__u64))
+                        return false;
+                info->reg_type = PTR_TO_SOCKET;
+                break;
         default:
                 if (type == BPF_READ) {
                         if (size != size_default)
@@ -6844,6 +6907,11 @@ static bool sock_ops_is_valid_access(int off, int size,
                         if (size != sizeof(__u64))
                                 return false;
                         break;
+                case offsetof(struct bpf_sock_ops, sk):
+                        if (size != sizeof(__u64))
+                                return false;
+                        info->reg_type = PTR_TO_SOCKET_OR_NULL;
+                        break;
                 default:
                         if (size != size_default)
                                 return false;
@@ -7751,6 +7819,11 @@ static u32 sock_addr_convert_ctx_access(enum bpf_access_type type,
                         struct bpf_sock_addr_kern, struct in6_addr, t_ctx,
                         s6_addr32[0], BPF_SIZE(si->code), off, tmp_reg);
                 break;
+        case offsetof(struct bpf_sock_addr, sk):
+                *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct bpf_sock_addr_kern, sk),
+                                      si->dst_reg, si->src_reg,
+                                      offsetof(struct bpf_sock_addr_kern, sk));
+                break;
         }
 
         return insn - insn_buf;
@@ -8010,6 +8083,19 @@ static u32 sock_ops_convert_ctx_access(enum bpf_access_type type,
                 SOCK_OPS_GET_OR_SET_FIELD(sk_txhash, sk_txhash,
                                           struct sock, type);
                 break;
+        case offsetof(struct bpf_sock_ops, sk):
+                *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
+                                                struct bpf_sock_ops_kern,
+                                                is_fullsock),
+                                      si->dst_reg, si->src_reg,
+                                      offsetof(struct bpf_sock_ops_kern,
+                                               is_fullsock));
+                *insn++ = BPF_JMP_IMM(BPF_JEQ, si->dst_reg, 0, 1);
+                *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(
+                                                struct bpf_sock_ops_kern, sk),
+                                      si->dst_reg, si->src_reg,
+                                      offsetof(struct bpf_sock_ops_kern, sk));
+                break;
         }
         return insn - insn_buf;
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index af09a23e4822..ef471f643c95 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1039,6 +1039,10 @@ set_rcvbuf:
                 }
                 break;
 
+        case SO_DETACH_REUSEPORT_BPF:
+                ret = reuseport_detach_prog(sk);
+                break;
+
         case SO_DETACH_FILTER:
                 ret = sk_detach_filter(sk);
                 break;
diff --git a/net/core/sock_reuseport.c b/net/core/sock_reuseport.c
index dc4aefdf2a08..9408f9264d05 100644
--- a/net/core/sock_reuseport.c
+++ b/net/core/sock_reuseport.c
@@ -332,3 +332,27 @@ int reuseport_attach_prog(struct sock *sk, struct bpf_prog *prog)
         return 0;
 }
 EXPORT_SYMBOL(reuseport_attach_prog);
+
+int reuseport_detach_prog(struct sock *sk)
+{
+        struct sock_reuseport *reuse;
+        struct bpf_prog *old_prog;
+
+        if (!rcu_access_pointer(sk->sk_reuseport_cb))
+                return sk->sk_reuseport ? -ENOENT : -EINVAL;
+
+        old_prog = NULL;
+        spin_lock_bh(&reuseport_lock);
+        reuse = rcu_dereference_protected(sk->sk_reuseport_cb,
+                                          lockdep_is_held(&reuseport_lock));
+        rcu_swap_protected(reuse->prog, old_prog,
+                           lockdep_is_held(&reuseport_lock));
+        spin_unlock_bh(&reuseport_lock);
+
+        if (!old_prog)
+                return -ENOENT;
+
+        sk_reuseport_prog_free(old_prog);
+        return 0;
+}
+EXPORT_SYMBOL(reuseport_detach_prog);