[GitHub/mt8127/android_kernel_alcatel_ttab.git] / samples / seccomp / bpf-helper.h

/*
 * Example wrapper around BPF macros.
 *
 * Copyright (c) 2012 The Chromium OS Authors <chromium-os-dev@chromium.org>
 * Author: Will Drewry <wad@chromium.org>
 *
 * The code may be used by anyone for any purpose,
 * and can serve as a starting point for developing
 * applications using prctl(PR_SET_SECCOMP, 2, ...).
 *
 * No guarantees are provided with respect to the correctness
 * or functionality of this code.
 */
#ifndef __BPF_HELPER_H__
#define __BPF_HELPER_H__

#include <asm/bitsperlong.h>	/* for __BITS_PER_LONG */
#include <endian.h>
#include <linux/filter.h>
#include <linux/seccomp.h>	/* for seccomp_data */
#include <linux/types.h>
#include <linux/unistd.h>
#include <stddef.h>

#define BPF_LABELS_MAX 256
struct bpf_labels {
	int count;
	struct __bpf_label {
		const char *label;
		__u32 location;
	} labels[BPF_LABELS_MAX];
};

int bpf_resolve_jumps(struct bpf_labels *labels,
		      struct sock_filter *filter, size_t count);
__u32 seccomp_bpf_label(struct bpf_labels *labels, const char *label);
void seccomp_bpf_print(struct sock_filter *filter, size_t count);

#define JUMP_JT 0xff
#define JUMP_JF 0xff
#define LABEL_JT 0xfe
#define LABEL_JF 0xfe

#define ALLOW \
	BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
#define DENY \
	BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
#define JUMP(labels, label) \
	BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
		 JUMP_JT, JUMP_JF)
#define LABEL(labels, label) \
	BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
		 LABEL_JT, LABEL_JF)
#define SYSCALL(nr, jt) \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (nr), 0, 1), \
	jt

/* Lame, but just an example */
#define FIND_LABEL(labels, label) seccomp_bpf_label((labels), #label)

#define EXPAND(...) __VA_ARGS__

/* Ensure that we load the logically correct offset. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
#elif __BYTE_ORDER == __BIG_ENDIAN
#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
#else
#error "Unknown endianness"
#endif

/* Map all width-sensitive operations */
#if __BITS_PER_LONG == 32

#define JEQ(x, jt) JEQ32(x, EXPAND(jt))
#define JNE(x, jt) JNE32(x, EXPAND(jt))
#define JGT(x, jt) JGT32(x, EXPAND(jt))
#define JLT(x, jt) JLT32(x, EXPAND(jt))
#define JGE(x, jt) JGE32(x, EXPAND(jt))
#define JLE(x, jt) JLE32(x, EXPAND(jt))
#define JA(x, jt) JA32(x, EXPAND(jt))
#define ARG(i) ARG_32(i)

#elif __BITS_PER_LONG == 64

/* Ensure that we load the logically correct offset. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define ENDIAN(_lo, _hi) _lo, _hi
#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
#elif __BYTE_ORDER == __BIG_ENDIAN
#define ENDIAN(_lo, _hi) _hi, _lo
#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
#endif

union arg64 {
	struct {
		__u32 ENDIAN(lo32, hi32);
	};
	__u64 u64;
};

#define JEQ(x, jt) \
	JEQ64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))
#define JGT(x, jt) \
	JGT64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))
#define JGE(x, jt) \
	JGE64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))
#define JNE(x, jt) \
	JNE64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))
#define JLT(x, jt) \
	JLT64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))
#define JLE(x, jt) \
	JLE64(((union arg64){.u64 = (x)}).lo32, \
	      ((union arg64){.u64 = (x)}).hi32, \
	      EXPAND(jt))

#define JA(x, jt) \
	JA64(((union arg64){.u64 = (x)}).lo32, \
	       ((union arg64){.u64 = (x)}).hi32, \
	       EXPAND(jt))
#define ARG(i) ARG_64(i)

#else
#error __BITS_PER_LONG value unusable.
#endif

/* Loads the arg into A */
#define ARG_32(idx) \
	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx))

/* Loads lo into M[0] and hi into M[1] and A */
#define ARG_64(idx) \
	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)), \
	BPF_STMT(BPF_ST, 0), /* lo -> M[0] */ \
	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, HI_ARG(idx)), \
	BPF_STMT(BPF_ST, 1) /* hi -> M[1] */

#define JEQ32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 0, 1), \
	jt

#define JNE32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 1, 0), \
	jt

#define JA32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \
	jt

#define JGE32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \
	jt

#define JGT32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \
	jt

#define JLE32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \
	jt

#define JLT32(value, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \
	jt

/*
 * All the JXX64 checks assume lo is saved in M[0] and hi is saved in both
 * A and M[1]. This invariant is kept by restoring A if necessary.
 */
#define JEQ64(lo, hi, jt) \
	/* if (hi != arg.hi) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	/* if (lo != arg.lo) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JNE64(lo, hi, jt) \
	/* if (hi != arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo != arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JA64(lo, hi, jt) \
	/* if (hi & arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo & arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JGE64(lo, hi, jt) \
	/* if (hi > arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
	/* if (hi != arg.hi) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo >= arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JGT64(lo, hi, jt) \
	/* if (hi > arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
	/* if (hi != arg.hi) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo > arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JLE64(lo, hi, jt) \
	/* if (hi < arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
	/* if (hi != arg.hi) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo <= arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define JLT64(lo, hi, jt) \
	/* if (hi < arg.hi) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
	/* if (hi != arg.hi) goto NOMATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	/* if (lo < arg.lo) goto MATCH; */ \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1)

#define LOAD_SYSCALL_NR \
	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \
		 offsetof(struct seccomp_data, nr))

#endif  /* __BPF_HELPER_H__ */
Commit	Line	Data
8ac270d1 WD	1	/*
	2	* Example wrapper around BPF macros.
	3	*
	4	* Copyright (c) 2012 The Chromium OS Authors <chromium-os-dev@chromium.org>
	5	* Author: Will Drewry <wad@chromium.org>
	6	*
	7	* The code may be used by anyone for any purpose,
	8	* and can serve as a starting point for developing
	9	* applications using prctl(PR_SET_SECCOMP, 2, ...).
	10	*
	11	* No guarantees are provided with respect to the correctness
	12	* or functionality of this code.
	13	*/
	14	#ifndef __BPF_HELPER_H__
	15	#define __BPF_HELPER_H__
	16
	17	#include <asm/bitsperlong.h> /* for __BITS_PER_LONG */
	18	#include <endian.h>
	19	#include <linux/filter.h>
	20	#include <linux/seccomp.h> /* for seccomp_data */
	21	#include <linux/types.h>
	22	#include <linux/unistd.h>
	23	#include <stddef.h>
	24
	25	#define BPF_LABELS_MAX 256
	26	struct bpf_labels {
	27	int count;
	28	struct __bpf_label {
	29	const char *label;
	30	__u32 location;
	31	} labels[BPF_LABELS_MAX];
	32	};
	33
	34	int bpf_resolve_jumps(struct bpf_labels *labels,
	35	struct sock_filter *filter, size_t count);
	36	__u32 seccomp_bpf_label(struct bpf_labels labels, const char label);
	37	void seccomp_bpf_print(struct sock_filter *filter, size_t count);
	38
	39	#define JUMP_JT 0xff
	40	#define JUMP_JF 0xff
	41	#define LABEL_JT 0xfe
	42	#define LABEL_JF 0xfe
	43
	44	#define ALLOW \
	45	BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
	46	#define DENY \
	47	BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
	48	#define JUMP(labels, label) \
	49	BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
	50	JUMP_JT, JUMP_JF)
	51	#define LABEL(labels, label) \
	52	BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
	53	LABEL_JT, LABEL_JF)
	54	#define SYSCALL(nr, jt) \
	55	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (nr), 0, 1), \
	56	jt
	57
	58	/* Lame, but just an example */
	59	#define FIND_LABEL(labels, label) seccomp_bpf_label((labels), #label)
	60
	61	#define EXPAND(...) __VA_ARGS__
de4bb3b9 HC	62
	63	/* Ensure that we load the logically correct offset. */
	64	#if __BYTE_ORDER == __LITTLE_ENDIAN
	65	#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
	66	#elif __BYTE_ORDER == __BIG_ENDIAN
	67	#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
	68	#else
	69	#error "Unknown endianness"
	70	#endif
	71
8ac270d1 WD	72	/* Map all width-sensitive operations */
	73	#if __BITS_PER_LONG == 32
	74
	75	#define JEQ(x, jt) JEQ32(x, EXPAND(jt))
	76	#define JNE(x, jt) JNE32(x, EXPAND(jt))
	77	#define JGT(x, jt) JGT32(x, EXPAND(jt))
	78	#define JLT(x, jt) JLT32(x, EXPAND(jt))
	79	#define JGE(x, jt) JGE32(x, EXPAND(jt))
	80	#define JLE(x, jt) JLE32(x, EXPAND(jt))
	81	#define JA(x, jt) JA32(x, EXPAND(jt))
	82	#define ARG(i) ARG_32(i)
8ac270d1 WD	83
	84	#elif __BITS_PER_LONG == 64
	85
	86	/* Ensure that we load the logically correct offset. */
	87	#if __BYTE_ORDER == __LITTLE_ENDIAN
	88	#define ENDIAN(_lo, _hi) _lo, _hi
8ac270d1 WD	89	#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
	90	#elif __BYTE_ORDER == __BIG_ENDIAN
	91	#define ENDIAN(_lo, _hi) _hi, _lo
8ac270d1	92	#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
8ac270d1 WD	93	#endif
	94
	95	union arg64 {
	96	struct {
	97	__u32 ENDIAN(lo32, hi32);
	98	};
	99	__u64 u64;
	100	};
	101
	102	#define JEQ(x, jt) \
	103	JEQ64(((union arg64){.u64 = (x)}).lo32, \
	104	((union arg64){.u64 = (x)}).hi32, \
	105	EXPAND(jt))
	106	#define JGT(x, jt) \
	107	JGT64(((union arg64){.u64 = (x)}).lo32, \
	108	((union arg64){.u64 = (x)}).hi32, \
	109	EXPAND(jt))
	110	#define JGE(x, jt) \
	111	JGE64(((union arg64){.u64 = (x)}).lo32, \
	112	((union arg64){.u64 = (x)}).hi32, \
	113	EXPAND(jt))
	114	#define JNE(x, jt) \
	115	JNE64(((union arg64){.u64 = (x)}).lo32, \
	116	((union arg64){.u64 = (x)}).hi32, \
	117	EXPAND(jt))
	118	#define JLT(x, jt) \
	119	JLT64(((union arg64){.u64 = (x)}).lo32, \
	120	((union arg64){.u64 = (x)}).hi32, \
	121	EXPAND(jt))
	122	#define JLE(x, jt) \
	123	JLE64(((union arg64){.u64 = (x)}).lo32, \
	124	((union arg64){.u64 = (x)}).hi32, \
	125	EXPAND(jt))
	126
	127	#define JA(x, jt) \
	128	JA64(((union arg64){.u64 = (x)}).lo32, \
	129	((union arg64){.u64 = (x)}).hi32, \
	130	EXPAND(jt))
	131	#define ARG(i) ARG_64(i)
	132
	133	#else
	134	#error __BITS_PER_LONG value unusable.
	135	#endif
	136
	137	/* Loads the arg into A */
	138	#define ARG_32(idx) \
	139	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx))
	140
109b4210	141	/* Loads lo into M[0] and hi into M[1] and A */
8ac270d1 WD	142	#define ARG_64(idx) \
	143	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)), \
	144	BPF_STMT(BPF_ST, 0), /* lo -> M[0] */ \
	145	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, HI_ARG(idx)), \
	146	BPF_STMT(BPF_ST, 1) /* hi -> M[1] */
	147
	148	#define JEQ32(value, jt) \
	149	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 0, 1), \
	150	jt
	151
	152	#define JNE32(value, jt) \
	153	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 1, 0), \
	154	jt
	155
109b4210 MS	156	#define JA32(value, jt) \
	157	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \
	158	jt
	159
	160	#define JGE32(value, jt) \
	161	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \
	162	jt
	163
	164	#define JGT32(value, jt) \
	165	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \
	166	jt
	167
	168	#define JLE32(value, jt) \
	169	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \
	170	jt
	171
	172	#define JLT32(value, jt) \
	173	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \
	174	jt
	175
	176	/*
	177	* All the JXX64 checks assume lo is saved in M[0] and hi is saved in both
	178	* A and M[1]. This invariant is kept by restoring A if necessary.
	179	*/
8ac270d1	180	#define JEQ64(lo, hi, jt) \
109b4210	181	/* if (hi != arg.hi) goto NOMATCH; */ \
8ac270d1 WD	182	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
8ac270d1 WD	183	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
109b4210	184	/* if (lo != arg.lo) goto NOMATCH; */ \
8ac270d1	185	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
109b4210	186	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	187	jt, \
109b4210	188	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1 WD	189
8ac270d1 WD	190	#define JNE64(lo, hi, jt) \
109b4210 MS	191	/* if (hi != arg.hi) goto MATCH; */ \
	192	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
	193	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	194	/* if (lo != arg.lo) goto MATCH; */ \
8ac270d1	195	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
109b4210	196	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	197	jt, \
109b4210	198	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1 WD	199
8ac270d1 WD	200	#define JA64(lo, hi, jt) \
109b4210	201	/* if (hi & arg.hi) goto MATCH; */ \
8ac270d1	202	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
109b4210 MS	203	BPF_STMT(BPF_LD+BPF_MEM, 0), \
109b4210 MS	204	/* if (lo & arg.lo) goto MATCH; */ \
8ac270d1	205	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
109b4210	206	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	207	jt, \
109b4210	208	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1	209
8ac270d1	210	#define JGE64(lo, hi, jt) \
109b4210	211	/* if (hi > arg.hi) goto MATCH; */ \
8ac270d1	212	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
109b4210	213	/* if (hi != arg.hi) goto NOMATCH; */ \
8ac270d1	214	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
109b4210 MS	215	BPF_STMT(BPF_LD+BPF_MEM, 0), \
109b4210 MS	216	/* if (lo >= arg.lo) goto MATCH; */ \
8ac270d1	217	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
109b4210	218	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	219	jt, \
109b4210	220	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1	221
8ac270d1	222	#define JGT64(lo, hi, jt) \
109b4210	223	/* if (hi > arg.hi) goto MATCH; */ \
8ac270d1	224	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
109b4210	225	/* if (hi != arg.hi) goto NOMATCH; */ \
8ac270d1	226	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
109b4210 MS	227	BPF_STMT(BPF_LD+BPF_MEM, 0), \
109b4210 MS	228	/* if (lo > arg.lo) goto MATCH; */ \
8ac270d1	229	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
109b4210	230	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	231	jt, \
109b4210	232	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1 WD	233
8ac270d1 WD	234	#define JLE64(lo, hi, jt) \
109b4210 MS	235	/* if (hi < arg.hi) goto MATCH; */ \
	236	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
	237	/* if (hi != arg.hi) goto NOMATCH; */ \
	238	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	239	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	240	/* if (lo <= arg.lo) goto MATCH; */ \
8ac270d1	241	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
109b4210 MS	242	BPF_STMT(BPF_LD+BPF_MEM, 1), \
	243	jt, \
	244	BPF_STMT(BPF_LD+BPF_MEM, 1)
	245
	246	#define JLT64(lo, hi, jt) \
	247	/* if (hi < arg.hi) goto MATCH; */ \
	248	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
	249	/* if (hi != arg.hi) goto NOMATCH; */ \
	250	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	251	BPF_STMT(BPF_LD+BPF_MEM, 0), \
	252	/* if (lo < arg.lo) goto MATCH; */ \
	253	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 2, 0), \
	254	BPF_STMT(BPF_LD+BPF_MEM, 1), \
8ac270d1	255	jt, \
109b4210	256	BPF_STMT(BPF_LD+BPF_MEM, 1)
8ac270d1 WD	257
	258	#define LOAD_SYSCALL_NR \
	259	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \
	260	offsetof(struct seccomp_data, nr))
	261
	262	#endif /* __BPF_HELPER_H__ */