cregit-Linux how code gets into the kernel

Release 4.16 samples/seccomp/bpf-helper.h

Directory: samples/seccomp
/* SPDX-License-Identifier: GPL-2.0 */
/*
 * 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__ */

Overall Contributors

PersonTokensPropCommitsCommitProp
Will Drewry55083.33%125.00%
Mathias Svensson7711.67%125.00%
Heiko Carstens324.85%125.00%
Greg Kroah-Hartman10.15%125.00%
Total660100.00%4100.00%
Directory: samples/seccomp
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.