[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 hi into A and lo in X */
#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

/* Checks the lo, then swaps to check the hi. A=lo,X=hi */
#define JEQ64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

#define JNE64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 5, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

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

#define JA64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

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

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

/* Shortcut checking if hi > arg.hi. */
#define JGE64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

#define JLT64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

#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

/* Check hi > args.hi first, then do the GE checking */
#define JGT64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

#define JLE64(lo, hi, jt) \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 6, 0), \
	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
	jt, \
	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */

#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
	141	/* Loads hi into A and lo in X */
	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
	156	/* Checks the lo, then swaps to check the hi. A=lo,X=hi */
157	#define JEQ64(lo, hi, jt) \
158	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
159	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
160	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
161	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
162	jt, \
163	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
164
165	#define JNE64(lo, hi, jt) \
166	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 5, 0), \
167	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
168	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
169	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
170	jt, \
171	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
172
173	#define JA32(value, jt) \
174	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \
175	jt
176
177	#define JA64(lo, hi, jt) \
178	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
179	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
180	BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
181	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
182	jt, \
183	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
184
185	#define JGE32(value, jt) \
186	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \
187	jt
188
189	#define JLT32(value, jt) \
190	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \
191	jt
192
193	/* Shortcut checking if hi > arg.hi. */
194	#define JGE64(lo, hi, jt) \
195	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
196	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
197	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
198	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
199	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
200	jt, \
201	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
202
203	#define JLT64(lo, hi, jt) \
204	BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
205	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
206	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
207	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
208	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
209	jt, \
210	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
211
212	#define JGT32(value, jt) \
213	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \
214	jt
215
216	#define JLE32(value, jt) \
217	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \
218	jt
219
220	/* Check hi > args.hi first, then do the GE checking */
221	#define JGT64(lo, hi, jt) \
222	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
223	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
224	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
225	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
226	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
227	jt, \
228	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
229
230	#define JLE64(lo, hi, jt) \
231	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 6, 0), \
232	BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
233	BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
234	BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
235	BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
236	jt, \
237	BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
238
239	#define LOAD_SYSCALL_NR \
240	BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \
241	offsetof(struct seccomp_data, nr))
242
243	#endif /* __BPF_HELPER_H__ */