1 files changed, 14 insertions, 94 deletions

diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index ba03ec39efb3..d0d7d9462368 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -31,6 +31,7 @@
 #include <linux/rbtree_latch.h>
 #include <linux/kallsyms.h>
 #include <linux/rcupdate.h>
+#include <linux/perf_event.h>
 
 #include <asm/unaligned.h>
 
@@ -633,23 +634,6 @@ static int bpf_jit_blind_insn(const struct bpf_insn *from,
                 *to++ = BPF_JMP_REG(from->code, from->dst_reg, BPF_REG_AX, off);
                 break;
 
-        case BPF_LD | BPF_ABS | BPF_W:
-        case BPF_LD | BPF_ABS | BPF_H:
-        case BPF_LD | BPF_ABS | BPF_B:
-                *to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm);
-                *to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd);
-                *to++ = BPF_LD_IND(from->code, BPF_REG_AX, 0);
-                break;
-
-        case BPF_LD | BPF_IND | BPF_W:
-        case BPF_LD | BPF_IND | BPF_H:
-        case BPF_LD | BPF_IND | BPF_B:
-                *to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ from->imm);
-                *to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd);
-                *to++ = BPF_ALU32_REG(BPF_ADD, BPF_REG_AX, from->src_reg);
-                *to++ = BPF_LD_IND(from->code, BPF_REG_AX, 0);
-                break;
-
         case BPF_LD | BPF_IMM | BPF_DW:
                 *to++ = BPF_ALU64_IMM(BPF_MOV, BPF_REG_AX, imm_rnd ^ aux[1].imm);
                 *to++ = BPF_ALU64_IMM(BPF_XOR, BPF_REG_AX, imm_rnd);
@@ -890,14 +874,7 @@ EXPORT_SYMBOL_GPL(__bpf_call_base);
         INSN_3(LDX, MEM, W),                    \
         INSN_3(LDX, MEM, DW),                   \
         /*   Immediate based. */                \
-        INSN_3(LD, IMM, DW),                    \
-        /*   Misc (old cBPF carry-over). */     \
-        INSN_3(LD, ABS, B),                     \
-        INSN_3(LD, ABS, H),                     \
-        INSN_3(LD, ABS, W),                     \
-        INSN_3(LD, IND, B),                     \
-        INSN_3(LD, IND, H),                     \
-        INSN_3(LD, IND, W)
+        INSN_3(LD, IMM, DW)
 
 bool bpf_opcode_in_insntable(u8 code)
 {
@@ -907,6 +884,13 @@ bool bpf_opcode_in_insntable(u8 code)
                 [0 ... 255] = false,
                 /* Now overwrite non-defaults ... */
                 BPF_INSN_MAP(BPF_INSN_2_TBL, BPF_INSN_3_TBL),
+                /* UAPI exposed, but rewritten opcodes. cBPF carry-over. */
+                [BPF_LD | BPF_ABS | BPF_B] = true,
+                [BPF_LD | BPF_ABS | BPF_H] = true,
+                [BPF_LD | BPF_ABS | BPF_W] = true,
+                [BPF_LD | BPF_IND | BPF_B] = true,
+                [BPF_LD | BPF_IND | BPF_H] = true,
+                [BPF_LD | BPF_IND | BPF_W] = true,
         };
 #undef BPF_INSN_3_TBL
 #undef BPF_INSN_2_TBL
@@ -937,8 +921,6 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn, u64 *stack)
 #undef BPF_INSN_3_LBL
 #undef BPF_INSN_2_LBL
         u32 tail_call_cnt = 0;
-        void *ptr;
-        int off;
 
 #define CONT     ({ insn++; goto select_insn; })
 #define CONT_JMP ({ insn++; goto select_insn; })
@@ -1265,67 +1247,6 @@ out:
                 atomic64_add((u64) SRC, (atomic64_t *)(unsigned long)
                              (DST + insn->off));
                 CONT;
-        LD_ABS_W: /* BPF_R0 = ntohl(*(u32 *) (skb->data + imm32)) */
-                off = IMM;
-load_word:
-                /* BPF_LD + BPD_ABS and BPF_LD + BPF_IND insns are only
-                 * appearing in the programs where ctx == skb
-                 * (see may_access_skb() in the verifier). All programs
-                 * keep 'ctx' in regs[BPF_REG_CTX] == BPF_R6,
-                 * bpf_convert_filter() saves it in BPF_R6, internal BPF
-                 * verifier will check that BPF_R6 == ctx.
-                 *
-                 * BPF_ABS and BPF_IND are wrappers of function calls,
-                 * so they scratch BPF_R1-BPF_R5 registers, preserve
-                 * BPF_R6-BPF_R9, and store return value into BPF_R0.
-                 *
-                 * Implicit input:
-                 *   ctx == skb == BPF_R6 == CTX
-                 *
-                 * Explicit input:
-                 *   SRC == any register
-                 *   IMM == 32-bit immediate
-                 *
-                 * Output:
-                 *   BPF_R0 - 8/16/32-bit skb data converted to cpu endianness
-                 */
-
-                ptr = bpf_load_pointer((struct sk_buff *) (unsigned long) CTX, off, 4, &tmp);
-                if (likely(ptr != NULL)) {
-                        BPF_R0 = get_unaligned_be32(ptr);
-                        CONT;
-                }
-
-                return 0;
-        LD_ABS_H: /* BPF_R0 = ntohs(*(u16 *) (skb->data + imm32)) */
-                off = IMM;
-load_half:
-                ptr = bpf_load_pointer((struct sk_buff *) (unsigned long) CTX, off, 2, &tmp);
-                if (likely(ptr != NULL)) {
-                        BPF_R0 = get_unaligned_be16(ptr);
-                        CONT;
-                }
-
-                return 0;
-        LD_ABS_B: /* BPF_R0 = *(u8 *) (skb->data + imm32) */
-                off = IMM;
-load_byte:
-                ptr = bpf_load_pointer((struct sk_buff *) (unsigned long) CTX, off, 1, &tmp);
-                if (likely(ptr != NULL)) {
-                        BPF_R0 = *(u8 *)ptr;
-                        CONT;
-                }
-
-                return 0;
-        LD_IND_W: /* BPF_R0 = ntohl(*(u32 *) (skb->data + src_reg + imm32)) */
-                off = IMM + SRC;
-                goto load_word;
-        LD_IND_H: /* BPF_R0 = ntohs(*(u16 *) (skb->data + src_reg + imm32)) */
-                off = IMM + SRC;
-                goto load_half;
-        LD_IND_B: /* BPF_R0 = *(u8 *) (skb->data + src_reg + imm32) */
-                off = IMM + SRC;
-                goto load_byte;
 
         default_label:
                 /* If we ever reach this, we have a bug somewhere. Die hard here
@@ -1722,6 +1643,10 @@ static void bpf_prog_free_deferred(struct work_struct *work)
         aux = container_of(work, struct bpf_prog_aux, work);
         if (bpf_prog_is_dev_bound(aux))
                 bpf_prog_offload_destroy(aux->prog);
+#ifdef CONFIG_PERF_EVENTS
+        if (aux->prog->has_callchain_buf)
+                put_callchain_buffers();
+#endif
         for (i = 0; i < aux->func_cnt; i++)
                 bpf_jit_free(aux->func[i]);
         if (aux->func_cnt) {
@@ -1794,6 +1719,7 @@ bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size,
 {
         return -ENOTSUPP;
 }
+EXPORT_SYMBOL_GPL(bpf_event_output);
 
 /* Always built-in helper functions. */
 const struct bpf_func_proto bpf_tail_call_proto = {
@@ -1840,9 +1766,3 @@ int __weak skb_copy_bits(const struct sk_buff *skb, int offset, void *to,
 #include <linux/bpf_trace.h>
 
 EXPORT_TRACEPOINT_SYMBOL_GPL(xdp_exception);
-
-/* These are only used within the BPF_SYSCALL code */
-#ifdef CONFIG_BPF_SYSCALL
-EXPORT_TRACEPOINT_SYMBOL_GPL(bpf_prog_get_type);
-EXPORT_TRACEPOINT_SYMBOL_GPL(bpf_prog_put_rcu);
-#endif