Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752771AbbHaUf4 (ORCPT ); Mon, 31 Aug 2015 16:35:56 -0400 Received: from mx1.redhat.com ([209.132.183.28]:47878 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752023AbbHaUfy (ORCPT ); Mon, 31 Aug 2015 16:35:54 -0400 Date: Mon, 31 Aug 2015 17:35:50 -0300 From: Arnaldo Carvalho de Melo To: Wang Nan Cc: mingo@kernel.org, ast@plumgrid.com, linux-kernel@vger.kernel.org, lizefan@huawei.com, pi3orama@163.com, He Kuang , Brendan Gregg , Daniel Borkmann , David Ahern , Jiri Olsa , Kaixu Xia , Masami Hiramatsu , Namhyung Kim , Paul Mackerras , Peter Zijlstra Subject: Re: [PATCH 21/31] perf tools: Move linux/filter.h to tools/include Message-ID: <20150831203550.GC2443@redhat.com> References: <1440822125-52691-1-git-send-email-wangnan0@huawei.com> <1440822125-52691-22-git-send-email-wangnan0@huawei.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1440822125-52691-22-git-send-email-wangnan0@huawei.com> X-Url: http://acmel.wordpress.com User-Agent: Mutt/1.5.20 (2009-12-10) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 9393 Lines: 310 Em Sat, Aug 29, 2015 at 04:21:55AM +0000, Wang Nan escreveu: > From: He Kuang > > This patch moves filter.h from include/linux/kernel.h to Does this really _move_ a file from include/linux/kernel.h to some other place? Isn't there any other users for such file in the kernel sources? :-) Looking at the patch I see that it doesn't move anything, it _copies_ the file, right? - Arnaldo > tools/include/linux/filter.h to enable other libraries use macros in > it, like libbpf which will be introduced by further patches. Currenty, > the moved filter.h only contains the useful macros needed by libbpf > for not introducing too much dependence. > > MANIFEST is also updated for 'make perf-*-src-pkg'. > > One change: > imm field of BPF_EMIT_CALL becomes ((FUNC) - BPF_FUNC_unspec) to > suit user space code generator. > > Signed-off-by: He Kuang > Signed-off-by: Wang Nan > Cc: Alexei Starovoitov > Cc: Brendan Gregg > Cc: Daniel Borkmann > Cc: David Ahern > Cc: He Kuang > Cc: Jiri Olsa > Cc: Kaixu Xia > Cc: Masami Hiramatsu > Cc: Namhyung Kim > Cc: Paul Mackerras > Cc: Peter Zijlstra > Cc: Zefan Li > Cc: pi3orama@163.com > Cc: Arnaldo Carvalho de Melo > Link: http://lkml.kernel.org/n/1436445342-1402-32-git-send-email-wangnan0@huawei.com > --- > tools/include/linux/filter.h | 237 +++++++++++++++++++++++++++++++++++++++++++ > tools/perf/MANIFEST | 1 + > 2 files changed, 238 insertions(+) > create mode 100644 tools/include/linux/filter.h > > diff --git a/tools/include/linux/filter.h b/tools/include/linux/filter.h > new file mode 100644 > index 0000000..11d2b1c > --- /dev/null > +++ b/tools/include/linux/filter.h > @@ -0,0 +1,237 @@ > +/* > + * Linux Socket Filter Data Structures > + */ > +#ifndef __TOOLS_LINUX_FILTER_H > +#define __TOOLS_LINUX_FILTER_H > + > +#include > + > +/* ArgX, context and stack frame pointer register positions. Note, > + * Arg1, Arg2, Arg3, etc are used as argument mappings of function > + * calls in BPF_CALL instruction. > + */ > +#define BPF_REG_ARG1 BPF_REG_1 > +#define BPF_REG_ARG2 BPF_REG_2 > +#define BPF_REG_ARG3 BPF_REG_3 > +#define BPF_REG_ARG4 BPF_REG_4 > +#define BPF_REG_ARG5 BPF_REG_5 > +#define BPF_REG_CTX BPF_REG_6 > +#define BPF_REG_FP BPF_REG_10 > + > +/* Additional register mappings for converted user programs. */ > +#define BPF_REG_A BPF_REG_0 > +#define BPF_REG_X BPF_REG_7 > +#define BPF_REG_TMP BPF_REG_8 > + > +/* BPF program can access up to 512 bytes of stack space. */ > +#define MAX_BPF_STACK 512 > + > +/* Helper macros for filter block array initializers. */ > + > +/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */ > + > +#define BPF_ALU64_REG(OP, DST, SRC) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU64 | BPF_OP(OP) | BPF_X, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = 0 }) > + > +#define BPF_ALU32_REG(OP, DST, SRC) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_OP(OP) | BPF_X, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = 0 }) > + > +/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */ > + > +#define BPF_ALU64_IMM(OP, DST, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = IMM }) > + > +#define BPF_ALU32_IMM(OP, DST, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_OP(OP) | BPF_K, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = IMM }) > + > +/* Endianness conversion, cpu_to_{l,b}e(), {l,b}e_to_cpu() */ > + > +#define BPF_ENDIAN(TYPE, DST, LEN) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_END | BPF_SRC(TYPE), \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = LEN }) > + > +/* Short form of mov, dst_reg = src_reg */ > + > +#define BPF_MOV64_REG(DST, SRC) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU64 | BPF_MOV | BPF_X, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = 0 }) > + > +#define BPF_MOV32_REG(DST, SRC) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_MOV | BPF_X, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = 0 }) > + > +/* Short form of mov, dst_reg = imm32 */ > + > +#define BPF_MOV64_IMM(DST, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU64 | BPF_MOV | BPF_K, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = IMM }) > + > +#define BPF_MOV32_IMM(DST, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_MOV | BPF_K, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = IMM }) > + > +/* Short form of mov based on type, > + * BPF_X: dst_reg = src_reg, BPF_K: dst_reg = imm32 > + */ > + > +#define BPF_MOV64_RAW(TYPE, DST, SRC, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU64 | BPF_MOV | BPF_SRC(TYPE), \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = IMM }) > + > +#define BPF_MOV32_RAW(TYPE, DST, SRC, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ALU | BPF_MOV | BPF_SRC(TYPE), \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = IMM }) > + > +/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */ > + > +#define BPF_LD_ABS(SIZE, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS, \ > + .dst_reg = 0, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = IMM }) > + > +/* Indirect packet access, R0 = *(uint *) (skb->data + src_reg + imm32) */ > + > +#define BPF_LD_IND(SIZE, SRC, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_LD | BPF_SIZE(SIZE) | BPF_IND, \ > + .dst_reg = 0, \ > + .src_reg = SRC, \ > + .off = 0, \ > + .imm = IMM }) > + > +/* Memory load, dst_reg = *(uint *) (src_reg + off16) */ > + > +#define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \ > + ((struct bpf_insn) { \ > + .code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = OFF, \ > + .imm = 0 }) > + > +/* Memory store, *(uint *) (dst_reg + off16) = src_reg */ > + > +#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \ > + ((struct bpf_insn) { \ > + .code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = OFF, \ > + .imm = 0 }) > + > +/* Memory store, *(uint *) (dst_reg + off16) = imm32 */ > + > +#define BPF_ST_MEM(SIZE, DST, OFF, IMM) \ > + ((struct bpf_insn) { \ > + .code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = OFF, \ > + .imm = IMM }) > + > +/* Conditional jumps against registers, > + * if (dst_reg 'op' src_reg) goto pc + off16 > + */ > + > +#define BPF_JMP_REG(OP, DST, SRC, OFF) \ > + ((struct bpf_insn) { \ > + .code = BPF_JMP | BPF_OP(OP) | BPF_X, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = OFF, \ > + .imm = 0 }) > + > +/* Conditional jumps against immediates, > + * if (dst_reg 'op' imm32) goto pc + off16 > + */ > + > +#define BPF_JMP_IMM(OP, DST, IMM, OFF) \ > + ((struct bpf_insn) { \ > + .code = BPF_JMP | BPF_OP(OP) | BPF_K, \ > + .dst_reg = DST, \ > + .src_reg = 0, \ > + .off = OFF, \ > + .imm = IMM }) > + > +/* Function call */ > + > +#define BPF_EMIT_CALL(FUNC) \ > + ((struct bpf_insn) { \ > + .code = BPF_JMP | BPF_CALL, \ > + .dst_reg = 0, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = ((FUNC) - BPF_FUNC_unspec) }) > + > +/* Raw code statement block */ > + > +#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \ > + ((struct bpf_insn) { \ > + .code = CODE, \ > + .dst_reg = DST, \ > + .src_reg = SRC, \ > + .off = OFF, \ > + .imm = IMM }) > + > +/* Program exit */ > + > +#define BPF_EXIT_INSN() \ > + ((struct bpf_insn) { \ > + .code = BPF_JMP | BPF_EXIT, \ > + .dst_reg = 0, \ > + .src_reg = 0, \ > + .off = 0, \ > + .imm = 0 }) > + > +#endif /* __TOOLS_LINUX_FILTER_H */ > diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST > index 56fe0c9..14e8b98 100644 > --- a/tools/perf/MANIFEST > +++ b/tools/perf/MANIFEST > @@ -42,6 +42,7 @@ tools/include/asm-generic/bitops.h > tools/include/linux/atomic.h > tools/include/linux/bitops.h > tools/include/linux/compiler.h > +tools/include/linux/filter.h > tools/include/linux/hash.h > tools/include/linux/kernel.h > tools/include/linux/list.h > -- > 2.1.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/