Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security

Pull security subsystem updates from James Morris:
 "New notable features:
   - The seccomp work from Will Drewry
   - PR_{GET,SET}_NO_NEW_PRIVS from Andy Lutomirski
   - Longer security labels for Smack from Casey Schaufler
   - Additional ptrace restriction modes for Yama by Kees Cook"

Fix up trivial context conflicts in arch/x86/Kconfig and include/linux/filter.h

* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security: (65 commits)
  apparmor: fix long path failure due to disconnected path
  apparmor: fix profile lookup for unconfined
  ima: fix filename hint to reflect script interpreter name
  KEYS: Don't check for NULL key pointer in key_validate()
  Smack: allow for significantly longer Smack labels v4
  gfp flags for security_inode_alloc()?
  Smack: recursive tramsmute
  Yama: replace capable() with ns_capable()
  TOMOYO: Accept manager programs which do not start with / .
  KEYS: Add invalidation support
  KEYS: Do LRU discard in full keyrings
  KEYS: Permit in-place link replacement in keyring list
  KEYS: Perform RCU synchronisation on keys prior to key destruction
  KEYS: Announce key type (un)registration
  KEYS: Reorganise keys Makefile
  KEYS: Move the key config into security/keys/Kconfig
  KEYS: Use the compat keyctl() syscall wrapper on Sparc64 for Sparc32 compat
  Yama: remove an unused variable
  samples/seccomp: fix dependencies on arch macros
  Yama: add additional ptrace scopes
  ...

7 files changed, 720 insertions, 1 deletions

diff --git a/samples/Makefile b/samples/Makefile
index 2f75851ec629..5ef08bba96ce 100644
--- a/samples/Makefile
+++ b/samples/Makefile
@@ -1,4 +1,4 @@
 # Makefile for Linux samples code
 
 obj-$(CONFIG_SAMPLES)   += kobject/ kprobes/ tracepoints/ trace_events/ \
-                           hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/
+                           hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/ seccomp/
diff --git a/samples/seccomp/Makefile b/samples/seccomp/Makefile
new file mode 100644
index 000000000000..16aa2d424985
--- /dev/null
+++ b/samples/seccomp/Makefile
@@ -0,0 +1,32 @@
+# kbuild trick to avoid linker error. Can be omitted if a module is built.
+obj- := dummy.o
+
+hostprogs-$(CONFIG_SECCOMP_FILTER) := bpf-fancy dropper bpf-direct
+
+HOSTCFLAGS_bpf-fancy.o += -I$(objtree)/usr/include
+HOSTCFLAGS_bpf-fancy.o += -idirafter $(objtree)/include
+HOSTCFLAGS_bpf-helper.o += -I$(objtree)/usr/include
+HOSTCFLAGS_bpf-helper.o += -idirafter $(objtree)/include
+bpf-fancy-objs := bpf-fancy.o bpf-helper.o
+
+HOSTCFLAGS_dropper.o += -I$(objtree)/usr/include
+HOSTCFLAGS_dropper.o += -idirafter $(objtree)/include
+dropper-objs := dropper.o
+
+HOSTCFLAGS_bpf-direct.o += -I$(objtree)/usr/include
+HOSTCFLAGS_bpf-direct.o += -idirafter $(objtree)/include
+bpf-direct-objs := bpf-direct.o
+
+# Try to match the kernel target.
+ifeq ($(CONFIG_64BIT),)
+HOSTCFLAGS_bpf-direct.o += -m32
+HOSTCFLAGS_dropper.o += -m32
+HOSTCFLAGS_bpf-helper.o += -m32
+HOSTCFLAGS_bpf-fancy.o += -m32
+HOSTLOADLIBES_bpf-direct += -m32
+HOSTLOADLIBES_bpf-fancy += -m32
+HOSTLOADLIBES_dropper += -m32
+endif
+
+# Tell kbuild to always build the programs
+always := $(hostprogs-y)
diff --git a/samples/seccomp/bpf-direct.c b/samples/seccomp/bpf-direct.c
new file mode 100644
index 000000000000..151ec3f52189
--- /dev/null
+++ b/samples/seccomp/bpf-direct.c
@@ -0,0 +1,190 @@
+/*
+ * Seccomp filter example for x86 (32-bit and 64-bit) with 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, ...).
+ */
+#if defined(__i386__) || defined(__x86_64__)
+#define SUPPORTED_ARCH 1
+#endif
+
+#if defined(SUPPORTED_ARCH)
+#define __USE_GNU 1
+#define _GNU_SOURCE 1
+
+#include <linux/types.h>
+#include <linux/filter.h>
+#include <linux/seccomp.h>
+#include <linux/unistd.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+#define syscall_arg(_n) (offsetof(struct seccomp_data, args[_n]))
+#define syscall_nr (offsetof(struct seccomp_data, nr))
+
+#if defined(__i386__)
+#define REG_RESULT      REG_EAX
+#define REG_SYSCALL     REG_EAX
+#define REG_ARG0        REG_EBX
+#define REG_ARG1        REG_ECX
+#define REG_ARG2        REG_EDX
+#define REG_ARG3        REG_ESI
+#define REG_ARG4        REG_EDI
+#define REG_ARG5        REG_EBP
+#elif defined(__x86_64__)
+#define REG_RESULT      REG_RAX
+#define REG_SYSCALL     REG_RAX
+#define REG_ARG0        REG_RDI
+#define REG_ARG1        REG_RSI
+#define REG_ARG2        REG_RDX
+#define REG_ARG3        REG_R10
+#define REG_ARG4        REG_R8
+#define REG_ARG5        REG_R9
+#endif
+
+#ifndef PR_SET_NO_NEW_PRIVS
+#define PR_SET_NO_NEW_PRIVS 38
+#endif
+
+#ifndef SYS_SECCOMP
+#define SYS_SECCOMP 1
+#endif
+
+static void emulator(int nr, siginfo_t *info, void *void_context)
+{
+        ucontext_t *ctx = (ucontext_t *)(void_context);
+        int syscall;
+        char *buf;
+        ssize_t bytes;
+        size_t len;
+        if (info->si_code != SYS_SECCOMP)
+                return;
+        if (!ctx)
+                return;
+        syscall = ctx->uc_mcontext.gregs[REG_SYSCALL];
+        buf = (char *) ctx->uc_mcontext.gregs[REG_ARG1];
+        len = (size_t) ctx->uc_mcontext.gregs[REG_ARG2];
+
+        if (syscall != __NR_write)
+                return;
+        if (ctx->uc_mcontext.gregs[REG_ARG0] != STDERR_FILENO)
+                return;
+        /* Redirect stderr messages to stdout. Doesn't handle EINTR, etc */
+        ctx->uc_mcontext.gregs[REG_RESULT] = -1;
+        if (write(STDOUT_FILENO, "[ERR] ", 6) > 0) {
+                bytes = write(STDOUT_FILENO, buf, len);
+                ctx->uc_mcontext.gregs[REG_RESULT] = bytes;
+        }
+        return;
+}
+
+static int install_emulator(void)
+{
+        struct sigaction act;
+        sigset_t mask;
+        memset(&act, 0, sizeof(act));
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGSYS);
+
+        act.sa_sigaction = &emulator;
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGSYS, &act, NULL) < 0) {
+                perror("sigaction");
+                return -1;
+        }
+        if (sigprocmask(SIG_UNBLOCK, &mask, NULL)) {
+                perror("sigprocmask");
+                return -1;
+        }
+        return 0;
+}
+
+static int install_filter(void)
+{
+        struct sock_filter filter[] = {
+                /* Grab the system call number */
+                BPF_STMT(BPF_LD+BPF_W+BPF_ABS, syscall_nr),
+                /* Jump table for the allowed syscalls */
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_rt_sigreturn, 0, 1),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+#ifdef __NR_sigreturn
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_sigreturn, 0, 1),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+#endif
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_exit_group, 0, 1),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_exit, 0, 1),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_read, 1, 0),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_write, 3, 2),
+
+                /* Check that read is only using stdin. */
+                BPF_STMT(BPF_LD+BPF_W+BPF_ABS, syscall_arg(0)),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, STDIN_FILENO, 4, 0),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL),
+
+                /* Check that write is only using stdout */
+                BPF_STMT(BPF_LD+BPF_W+BPF_ABS, syscall_arg(0)),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, STDOUT_FILENO, 1, 0),
+                /* Trap attempts to write to stderr */
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, STDERR_FILENO, 1, 2),
+
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_TRAP),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
+                .filter = filter,
+        };
+
+        if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
+                perror("prctl(NO_NEW_PRIVS)");
+                return 1;
+        }
+
+
+        if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
+                perror("prctl");
+                return 1;
+        }
+        return 0;
+}
+
+#define payload(_c) (_c), sizeof((_c))
+int main(int argc, char **argv)
+{
+        char buf[4096];
+        ssize_t bytes = 0;
+        if (install_emulator())
+                return 1;
+        if (install_filter())
+                return 1;
+        syscall(__NR_write, STDOUT_FILENO,
+                payload("OHAI! WHAT IS YOUR NAME? "));
+        bytes = syscall(__NR_read, STDIN_FILENO, buf, sizeof(buf));
+        syscall(__NR_write, STDOUT_FILENO, payload("HELLO, "));
+        syscall(__NR_write, STDOUT_FILENO, buf, bytes);
+        syscall(__NR_write, STDERR_FILENO,
+                payload("Error message going to STDERR\n"));
+        return 0;
+}
+#else   /* SUPPORTED_ARCH */
+/*
+ * This sample is x86-only.  Since kernel samples are compiled with the
+ * host toolchain, a non-x86 host will result in using only the main()
+ * below.
+ */
+int main(void)
+{
+        return 1;
+}
+#endif  /* SUPPORTED_ARCH */
diff --git a/samples/seccomp/bpf-fancy.c b/samples/seccomp/bpf-fancy.c
new file mode 100644
index 000000000000..8eb483aaec46
--- /dev/null
+++ b/samples/seccomp/bpf-fancy.c
@@ -0,0 +1,102 @@
+/*
+ * Seccomp BPF example using a macro-based generator.
+ *
+ * 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_ATTACH_SECCOMP_FILTER).
+ */
+
+#include <linux/filter.h>
+#include <linux/seccomp.h>
+#include <linux/unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+#include "bpf-helper.h"
+
+#ifndef PR_SET_NO_NEW_PRIVS
+#define PR_SET_NO_NEW_PRIVS 38
+#endif
+
+int main(int argc, char **argv)
+{
+        struct bpf_labels l;
+        static const char msg1[] = "Please type something: ";
+        static const char msg2[] = "You typed: ";
+        char buf[256];
+        struct sock_filter filter[] = {
+                /* TODO: LOAD_SYSCALL_NR(arch) and enforce an arch */
+                LOAD_SYSCALL_NR,
+                SYSCALL(__NR_exit, ALLOW),
+                SYSCALL(__NR_exit_group, ALLOW),
+                SYSCALL(__NR_write, JUMP(&l, write_fd)),
+                SYSCALL(__NR_read, JUMP(&l, read)),
+                DENY,  /* Don't passthrough into a label */
+
+                LABEL(&l, read),
+                ARG(0),
+                JNE(STDIN_FILENO, DENY),
+                ARG(1),
+                JNE((unsigned long)buf, DENY),
+                ARG(2),
+                JGE(sizeof(buf), DENY),
+                ALLOW,
+
+                LABEL(&l, write_fd),
+                ARG(0),
+                JEQ(STDOUT_FILENO, JUMP(&l, write_buf)),
+                JEQ(STDERR_FILENO, JUMP(&l, write_buf)),
+                DENY,
+
+                LABEL(&l, write_buf),
+                ARG(1),
+                JEQ((unsigned long)msg1, JUMP(&l, msg1_len)),
+                JEQ((unsigned long)msg2, JUMP(&l, msg2_len)),
+                JEQ((unsigned long)buf, JUMP(&l, buf_len)),
+                DENY,
+
+                LABEL(&l, msg1_len),
+                ARG(2),
+                JLT(sizeof(msg1), ALLOW),
+                DENY,
+
+                LABEL(&l, msg2_len),
+                ARG(2),
+                JLT(sizeof(msg2), ALLOW),
+                DENY,
+
+                LABEL(&l, buf_len),
+                ARG(2),
+                JLT(sizeof(buf), ALLOW),
+                DENY,
+        };
+        struct sock_fprog prog = {
+                .filter = filter,
+                .len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
+        };
+        ssize_t bytes;
+        bpf_resolve_jumps(&l, filter, sizeof(filter)/sizeof(*filter));
+
+        if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
+                perror("prctl(NO_NEW_PRIVS)");
+                return 1;
+        }
+
+        if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {
+                perror("prctl(SECCOMP)");
+                return 1;
+        }
+        syscall(__NR_write, STDOUT_FILENO, msg1, strlen(msg1));
+        bytes = syscall(__NR_read, STDIN_FILENO, buf, sizeof(buf)-1);
+        bytes = (bytes > 0 ? bytes : 0);
+        syscall(__NR_write, STDERR_FILENO, msg2, strlen(msg2));
+        syscall(__NR_write, STDERR_FILENO, buf, bytes);
+        /* Now get killed */
+        syscall(__NR_write, STDERR_FILENO, msg2, strlen(msg2)+2);
+        return 0;
+}
diff --git a/samples/seccomp/bpf-helper.c b/samples/seccomp/bpf-helper.c
new file mode 100644
index 000000000000..579cfe331886
--- /dev/null
+++ b/samples/seccomp/bpf-helper.c
@@ -0,0 +1,89 @@
+/*
+ * Seccomp BPF helper functions
+ *
+ * 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_ATTACH_SECCOMP_FILTER).
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "bpf-helper.h"
+
+int bpf_resolve_jumps(struct bpf_labels *labels,
+                      struct sock_filter *filter, size_t count)
+{
+        struct sock_filter *begin = filter;
+        __u8 insn = count - 1;
+
+        if (count < 1)
+                return -1;
+        /*
+        * Walk it once, backwards, to build the label table and do fixups.
+        * Since backward jumps are disallowed by BPF, this is easy.
+        */
+        filter += insn;
+        for (; filter >= begin; --insn, --filter) {
+                if (filter->code != (BPF_JMP+BPF_JA))
+                        continue;
+                switch ((filter->jt<<8)|filter->jf) {
+                case (JUMP_JT<<8)|JUMP_JF:
+                        if (labels->labels[filter->k].location == 0xffffffff) {
+                                fprintf(stderr, "Unresolved label: '%s'\n",
+                                        labels->labels[filter->k].label);
+                                return 1;
+                        }
+                        filter->k = labels->labels[filter->k].location -
+                                    (insn + 1);
+                        filter->jt = 0;
+                        filter->jf = 0;
+                        continue;
+                case (LABEL_JT<<8)|LABEL_JF:
+                        if (labels->labels[filter->k].location != 0xffffffff) {
+                                fprintf(stderr, "Duplicate label use: '%s'\n",
+                                        labels->labels[filter->k].label);
+                                return 1;
+                        }
+                        labels->labels[filter->k].location = insn;
+                        filter->k = 0; /* fall through */
+                        filter->jt = 0;
+                        filter->jf = 0;
+                        continue;
+                }
+        }
+        return 0;
+}
+
+/* Simple lookup table for labels. */
+__u32 seccomp_bpf_label(struct bpf_labels *labels, const char *label)
+{
+        struct __bpf_label *begin = labels->labels, *end;
+        int id;
+        if (labels->count == 0) {
+                begin->label = label;
+                begin->location = 0xffffffff;
+                labels->count++;
+                return 0;
+        }
+        end = begin + labels->count;
+        for (id = 0; begin < end; ++begin, ++id) {
+                if (!strcmp(label, begin->label))
+                        return id;
+        }
+        begin->label = label;
+        begin->location = 0xffffffff;
+        labels->count++;
+        return id;
+}
+
+void seccomp_bpf_print(struct sock_filter *filter, size_t count)
+{
+        struct sock_filter *end = filter + count;
+        for ( ; filter < end; ++filter)
+                printf("{ code=%u,jt=%u,jf=%u,k=%u },\n",
+                        filter->code, filter->jt, filter->jf, filter->k);
+}
diff --git a/samples/seccomp/bpf-helper.h b/samples/seccomp/bpf-helper.h
new file mode 100644
index 000000000000..643279dd30fb
--- /dev/null
+++ b/samples/seccomp/bpf-helper.h
@@ -0,0 +1,238 @@
+/*
+ * 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__
+/* 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)
+#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
+
+#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 LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
+#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define ENDIAN(_lo, _hi) _hi, _lo
+#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
+#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
+#else
+#error "Unknown endianness"
+#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__ */
diff --git a/samples/seccomp/dropper.c b/samples/seccomp/dropper.c
new file mode 100644
index 000000000000..c69c347c7011
--- /dev/null
+++ b/samples/seccomp/dropper.c
@@ -0,0 +1,68 @@
+/*
+ * Naive system call dropper built on seccomp_filter.
+ *
+ * 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, ...).
+ *
+ * When run, returns the specified errno for the specified
+ * system call number against the given architecture.
+ *
+ * Run this one as root as PR_SET_NO_NEW_PRIVS is not called.
+ */
+
+#include <errno.h>
+#include <linux/audit.h>
+#include <linux/filter.h>
+#include <linux/seccomp.h>
+#include <linux/unistd.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+static int install_filter(int nr, int arch, int error)
+{
+        struct sock_filter filter[] = {
+                BPF_STMT(BPF_LD+BPF_W+BPF_ABS,
+                         (offsetof(struct seccomp_data, arch))),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, arch, 0, 3),
+                BPF_STMT(BPF_LD+BPF_W+BPF_ABS,
+                         (offsetof(struct seccomp_data, nr))),
+                BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, nr, 0, 1),
+                BPF_STMT(BPF_RET+BPF_K,
+                         SECCOMP_RET_ERRNO|(error & SECCOMP_RET_DATA)),
+                BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
+                .filter = filter,
+        };
+        if (prctl(PR_SET_SECCOMP, 2, &prog)) {
+                perror("prctl");
+                return 1;
+        }
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        if (argc < 5) {
+                fprintf(stderr, "Usage:\n"
+                        "dropper <syscall_nr> <arch> <errno> <prog> [<args>]\n"
+                        "Hint:  AUDIT_ARCH_I386: 0x%X\n"
+                        "       AUDIT_ARCH_X86_64: 0x%X\n"
+                        "\n", AUDIT_ARCH_I386, AUDIT_ARCH_X86_64);
+                return 1;
+        }
+        if (install_filter(strtol(argv[1], NULL, 0), strtol(argv[2], NULL, 0),
+                           strtol(argv[3], NULL, 0)))
+                return 1;
+        execv(argv[4], &argv[4]);
+        printf("Failed to execv\n");
+        return 255;
+}