Two-phase seccomp and x86 tracing changes
Subsystems (7)
Andy Lutomirski
reviewerv2 cover Two-phase seccomp and x86 tracing changes
This is both a cleanup and a speedup. It reduces overhead due to installing a trivial seccomp filter by 87%. The speedup comes from avoiding the full syscall tracing mechanism for filters that don't return SECCOMP_RET_TRACE.
This series works by splitting the seccomp hooks into two phases. The first phase evaluates the filter; it can skip syscalls, allow them, kill the calling task, or pass a u32 to the second phase. The second phase requires a full tracing context, and it sends ptrace events if necessary.
Once this is done, I implemented a similar split for the x86 syscall entry work. The C callback is invoked in two phases: the first has only a partial frame, and it can request phase 2 processing with a full frame.
Finally, I switch the 64-bit system_call code to use the new split entry work. This is a net deletion of assembly code: it replaces all of the audit entry muck.
In the process, I fixed some bugs.
If this is acceptable, someone can do the same tweak for the ia32entry and entry_32 code.
This passes all seccomp tests that I know of. Now that it's properly rebased, even the previously expected failures are gone.
Kees, if you like this version, can you create a branch with patches 1-3? I think that the rest should go into tip/x86 once everyone's happy with it.
Changes from v1:
- Rebased on top of Kees' shiny new seccomp tree (no effect on the x86 part).
- Improved patch 6 vs patch 7 split (thanks Alexei!)
- Fixed bogus -ENOSYS in patch 5 (thanks Kees!)
- Improved changelog message in patch 6.
Changes from RFC version:
- The first three patches are more or less the same
- The rest is more or less a rewrite
Andy Lutomirski (7):
seccomp,x86,arm,mips,s390: Remove nr parameter from secure_computing
seccomp: Refactor the filter callback and the API
seccomp: Allow arch code to provide seccomp_data x86,x32,audit: Fix x32's AUDIT_ARCH wrt audit
x86: Split syscall_trace_enter into two phases x86_64,entry: Treat regs->ax the same in fastpath and slowpath
syscalls
x86_64,entry: Use split-phase syscall_trace_enter for 64-bit syscalls
arch/arm/kernel/ptrace.c | 7 +- arch/mips/kernel/ptrace.c | 2 +- arch/s390/kernel/ptrace.c | 2 +- arch/x86/include/asm/calling.h | 6 +- arch/x86/include/asm/ptrace.h | 5 + arch/x86/kernel/entry_64.S | 51 ++++----- arch/x86/kernel/ptrace.c | 146 +++++++++++++++++++----- arch/x86/kernel/vsyscall_64.c | 2 +- include/linux/seccomp.h | 25 ++-- kernel/seccomp.c | 252 ++++++++++++++++++++++++++++------------- 10 files changed, 344 insertions(+), 154 deletions(-)
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 1/7 seccomp,x86,arm,mips,s390: Remove nr parameter from secure_computing
The secure_computing function took a syscall number parameter, but it only paid any attention to that parameter if seccomp mode 1 was enabled. Rather than coming up with a kludge to get the parameter to work in mode 2, just remove the parameter.
To avoid churn in arches that don't have seccomp filters (and may not even support syscall_get_nr right now), this leaves the parameter in secure_computing_strict, which is now a real function.
For ARM, this is a bit ugly due to the fact that ARM conditionally supports seccomp filters. Fixing that would probably only be a couple of lines of code, but it should be coordinated with the audit maintainers.
This will be a slight slowdown on some arches. The right fix is to pass in all of seccomp_data instead of trying to make just the syscall nr part be fast.
This is a prerequisite for making two-phase seccomp work cleanly.
--- arch/arm/kernel/ptrace.c | 7 ++++- arch/mips/kernel/ptrace.c | 2 +- arch/s390/kernel/ptrace.c | 2 +- arch/x86/kernel/ptrace.c | 2 +- arch/x86/kernel/vsyscall_64.c | 2 +- include/linux/seccomp.h | 21 +++++++------- kernel/seccomp.c | 64 ++++++++++++++++++++++++++++++------------- 7 files changed, 66 insertions(+), 34 deletions(-)
arch/arm/kernel/ptrace.c +6 -1
@@ -933,8 +933,13 @@ asmlinkage int syscall_trace_enter(struct pt_regs *regs, int scno)current_thread_info ()->syscall = scno;/* Do the secure computing check first; failures should be fast. */ -if (secure_computing (scno) ==-1 ) +#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER +if (secure_computing () ==-1 )return -1 ; +#else +/* XXX: remove this once OABI gets fixed */ +secure_computing_strict (scno); +#endif if (test_thread_flag (TIF_SYSCALL_TRACE ))tracehook_report_syscall (regs,PTRACE_SYSCALL_ENTER );
arch/mips/kernel/ptrace.c +1 -1
@@ -639,7 +639,7 @@ asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall)long ret =0 ;user_exit (); -if (secure_computing (syscall) ==-1 ) +if (secure_computing () ==-1 )return -1 ; if (test_thread_flag(TIF_SYSCALL_TRACE) &&
arch/s390/kernel/ptrace.c +1 -1
@@ -795,7 +795,7 @@ asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)long ret =0 ;/* Do the secure computing check first. */ -if (secure_computing (regs->gprs[2 ])) { +if (secure_computing ()) {/* seccomp failures shouldn't expose any additional code. */ ret =-1 ; goto out;
arch/x86/kernel/ptrace.c +1 -1
@@ -1471,7 +1471,7 @@ long syscall_trace_enter(struct pt_regs *regs) regs->flags |=X86_EFLAGS_TF ;/* do the secure computing check first */ -if (secure_computing (regs->orig_ax)) { +if (secure_computing ()) {/* seccomp failures shouldn't expose any additional code. */ ret =-1L ; goto out;
arch/x86/kernel/vsyscall_64.c +1 -1
@@ -216,7 +216,7 @@ bool emulate_vsyscall(struct pt_regs *regs, unsigned long address)*/ regs->orig_ax = syscall_nr; regs->ax = -ENOSYS ; - tmp =secure_computing (syscall_nr); + tmp =secure_computing ();if ((!tmp && regs->orig_ax != syscall_nr) || regs->ip != address) {warn_bad_vsyscall (KERN_DEBUG , regs,"seccomp tried to change syscall nr or ip" );
include/linux/seccomp.h +11 -10
@@ -27,19 +27,17 @@ struct seccomp {struct seccomp_filter *filter; }; -extern int __secure_computing (int ); -static inline int secure_computing (int this_syscall) +#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER +extern int __secure_computing (void ); +static inline int secure_computing (void ) {if (unlikely (test_thread_flag (TIF_SECCOMP ))) -return __secure_computing (this_syscall); +return __secure_computing ();return 0 ; } - -/* A wrapper for architectures supporting only SECCOMP_MODE_STRICT. */ -static inline void secure_computing_strict (int this_syscall) -{ -BUG_ON (secure_computing (this_syscall) !=0 ); -} +#else +extern void secure_computing_strict (int this_syscall); +#endif extern long prctl_get_seccomp (void );extern long prctl_set_seccomp (unsigned long ,char __user *);
@@ -56,8 +54,11 @@ static inline int seccomp_mode(struct seccomp *s)struct seccomp { };struct seccomp_filter { }; -static inline int secure_computing (int this_syscall) {return 0 ; } +#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER +static inline int secure_computing (void ) {return 0 ; } +#else static inline void secure_computing_strict (int this_syscall) {return ; } +#endif static inline long prctl_get_seccomp (void ) {
kernel/seccomp.c +45 -19
102 lines not on this page · raw message
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 2/7 seccomp: Refactor the filter callback and the API
In reply to Andy LutomirskiThe reason I did this is to add a seccomp API that will be usable for an x86 fast path. The x86 entry code needs to use a rather expensive slow path for a syscall that might be visible to things like ptrace. By splitting seccomp into two phases, we can check whether we need the slow path and then use the fast path in if the filter allows the syscall or just returns some errno.
As a side effect, I think the new code is much easier to understand than the old code.
This has one user-visible effect: the audit record written for SECCOMP_RET_TRACE is now a simple indication that SECCOMP_RET_TRACE happened. It used to depend in a complicated way on what the tracer did. I couldn't make much sense of it.
--- include/linux/seccomp.h | 6 ++ kernel/seccomp.c | 190 +++++++++++++++++++++++++++++++----------------- 2 files changed, 130 insertions(+), 66 deletions(-)
include/linux/seccomp.h +6 -0
@@ -35,6 +35,12 @@ static inline int secure_computing(void)return __secure_computing (); return 0; } + +#define SECCOMP_PHASE1_OK 0 +#define SECCOMP_PHASE1_SKIP 1 + +extern u32 seccomp_phase1 (void ); +int seccomp_phase2 (u32 phase1_result);#else extern void secure_computing_strict (int this_syscall);#endif
kernel/seccomp.c +124 -66
215 lines not on this page · raw message
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 3/7 seccomp: Allow arch code to provide seccomp_data
In reply to Andy Lutomirskipopulate_seccomp_data is expensive: it works by inspecting task_pt_regs and various other bits to piece together all the information, and it's does so in multiple partially redundant steps.
Arch-specific code in the syscall entry path can do much better.
Admittedly this adds a bit of additional room for error, but the speedup should be worth it.
--- include/linux/seccomp.h | 2 +- kernel/seccomp.c | 32 +++++++++++++++++++------------- 2 files changed, 20 insertions(+), 14 deletions(-)
include/linux/seccomp.h +1 -1
@@ -39,7 +39,7 @@ static inline int secure_computing(void)#define SECCOMP_PHASE1_OK 0#define SECCOMP_PHASE1_SKIP 1 -extern u32 seccomp_phase1 (void ); +extern u32 seccomp_phase1 (struct seccomp_data *sd);int seccomp_phase2 (u32 phase1_result);#else extern void secure_computing_strict (int this_syscall);
kernel/seccomp.c +19 -13
@@ -173,10 +173,10 @@ static int seccomp_check_filter(struct sock_filter *filter, unsigned int flen)* * Returns valid seccomp BPF response codes. */ -static u32 seccomp_run_filters (void ) +static u32 seccomp_run_filters (struct seccomp_data *sd) {struct seccomp_filter *f =ACCESS_ONCE (current->seccomp.filter); -struct seccomp_data sd; +struct seccomp_data sd_local;u32 ret =SECCOMP_RET_ALLOW ;/* Ensure unexpected behavior doesn't result in failing open. */
@@ -186,14 +186,17 @@ static u32 seccomp_run_filters(void)/* Make sure cross-thread synced filter points somewhere sane. */ smp_read_barrier_depends (); -populate_seccomp_data (&sd); +if (!sd) { +populate_seccomp_data (&sd_local); + sd = &sd_local; + }/* * All filters in the list are evaluated and the lowest BPF return * value always takes priority (ignoring the DATA). */ for (; f; f = f->prev) { -u32 cur_ret =SK_RUN_FILTER (f->prog, (void *)&sd); +u32 cur_ret =SK_RUN_FILTER (f->prog, (void *)sd);if ((cur_ret &SECCOMP_RET_ACTION ) < (ret &SECCOMP_RET_ACTION )) ret = cur_ret;
@@ -599,7 +602,7 @@ void secure_computing_strict(int this_syscall)#else int __secure_computing (void ) { -u32 phase1_result =seccomp_phase1 (); +u32 phase1_result =seccomp_phase1 (NULL );if (likely (phase1_result ==SECCOMP_PHASE1_OK ))return 0 ;
@@ -610,7 +613,7 @@ int __secure_computing(void) }#ifdef CONFIG_SECCOMP_FILTER -static u32 __seccomp_phase1_filter (int this_syscall,struct pt_regs *regs) +static u32 __seccomp_phase1_filter (int this_syscall,struct seccomp_data *sd) {u32 filter_ret, action;int data;
@@ -621,20 +624,20 @@ static u32 __seccomp_phase1_filter(int this_syscall, struct pt_regs *regs)*/ rmb (); - filter_ret =seccomp_run_filters (); + filter_ret =seccomp_run_filters (sd); data = filter_ret &SECCOMP_RET_DATA ; action = filter_ret &SECCOMP_RET_ACTION ;switch (action) {case SECCOMP_RET_ERRNO :/* Set the low-order 16-bits as a errno. */ -syscall_set_return_value (current, regs, +syscall_set_return_value (current,task_pt_regs (current), -data,0 ); goto skip;case SECCOMP_RET_TRAP :/* Show the handler the original registers. */ -syscall_rollback (current, regs); +syscall_rollback (current,task_pt_regs (current));/* Let the filter pass back 16 bits of data. */ seccomp_send_sigsys (this_syscall, data); goto skip;
@@ -661,11 +664,14 @@ skip:/** * seccomp_phase1() - run fast path seccomp checks on the current syscall +* @arg sd: The seccomp_data or NULL * * This only reads pt_regs via the syscall_xyz helpers. The only change * it will make to pt_regs is via syscall_set_return_value, and it will * only do that if it returns SECCOMP_PHASE1_SKIP. * +* If sd is provided, it will not read pt_regs at all. +* * It may also call do_exit or force a signal; these actions must be * safe. *
@@ -679,11 +685,11 @@ skip:* If it returns anything else, then the return value should be passed * to seccomp_phase2 from a context in which ptrace hooks are safe. */ -u32 seccomp_phase1 (void ) +u32 seccomp_phase1 (struct seccomp_data *sd) {int mode = current->seccomp.mode; -struct pt_regs *regs =task_pt_regs (current); -int this_syscall =syscall_get_nr (current, regs); +int this_syscall = sd ? sd->nr : +syscall_get_nr (current,task_pt_regs (current));switch (mode) {case SECCOMP_MODE_STRICT :
@@ -691,7 +697,7 @@ u32 seccomp_phase1(void)return SECCOMP_PHASE1_OK ;#ifdef CONFIG_SECCOMP_FILTER case SECCOMP_MODE_FILTER : -return __seccomp_phase1_filter (this_syscall, regs); +return __seccomp_phase1_filter (this_syscall, sd);#endif default :BUG ();
Signature · 1 line
1.9.3
Re: [PATCH v2 3/7] seccomp: Allow arch code to provide seccomp_data
Quoted 8 lines · Andy Lutomirski
populate_seccomp_datais expensive: it works by inspectingtask_pt_regsand various other bits to piece together all the information, and it's does so in multiple partially redundant steps.Arch-specific code in the syscall entry path can do much better.
Admittedly this adds a bit of additional room for error, but the speedup should be worth it.
I still think we should gain either a note in the HAVE_ARCH_SECCOMP_FILTER help text in arch/Kconfig, or possibly a new section in Documentation/prctl/seccomp.txt (or similar) on how do implement filter support for an architecture, that mentions the arch-supplied seccomp_data and how two-phase can be done.
-Kees
Signature · 2 lines
Kees Cook Chrome OS Security
Andy Lutomirski
reviewerRe: [PATCH v2 3/7] seccomp: Allow arch code to provide seccomp_data
Quoted 7 lines · Kees Cook
Quoted 6 lines · Andy Lutomirski
populate_seccomp_datais expensive: it works by inspectingtask_pt_regsand various other bits to piece together all the information, and it's does so in multiple partially redundant steps.Arch-specific code in the syscall entry path can do much better.
Quoted 8 lines
Quoted 2 lines
Admittedly this adds a bit of additional room for error, but the speedup should be worth it.
I still think we should gain either a note in the
HAVE_ARCH_SECCOMP_FILTERhelp text inarch/Kconfig, or possibly a new section inDocumentation/prctl/seccomp.txt(or similar) on how do implement filter support for an architecture, that mentions the arch-suppliedseccomp_dataand how two-phase can be done.
I would have sworn I did that. I distinctly remember typing that text. I must have failed to commit it.
I'll send a followup patch.
--Andy
Quoted 6 lines
-Kees
--
Kees Cook
Chrome OS Security
Signature · 2 lines
Andy Lutomirski AMA Capital Management, LLC
Andy Lutomirski
reviewerPATCH v2 4/7 x86,x32,audit: Fix x32's AUDIT_ARCH wrt audit
In reply to Andy Lutomirskiis_compat_task() is the wrong check for audit arch; the check should be is_ia32_task(): x32 syscalls should be AUDIT_ARCH_X86_64, not AUDIT_ARCH_I386.
CONFIG_AUDITSYSCALL is currently incompatible with x32, so this has no visible effect.
--- arch/x86/kernel/ptrace.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/x86/kernel/ptrace.c +1 -10
@@ -1441,15 +1441,6 @@ void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,force_sig_info (SIGTRAP , &info, tsk); } - -#ifdef CONFIG_X86_32 -# define IS_IA32 1 -#elif definedCONFIG_IA32_EMULATION -# define IS_IA32 is_compat_task() -#else -# define IS_IA32 0 -#endif -/* * We must return the syscall number to actually look up in the table. * This can be -1L to skip running any syscall at all.
@@ -1487,7 +1478,7 @@ long syscall_trace_enter(struct pt_regs *regs)if (unlikely (test_thread_flag (TIF_SYSCALL_TRACEPOINT )))trace_sys_enter (regs, regs->orig_ax); -if (IS_IA32 ) +if (is_ia32_task ()) audit_syscall_entry(AUDIT_ARCH_I386, regs->orig_ax, regs->bx, regs->cx,
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 5/7 x86: Split syscall_trace_enter into two phases
In reply to Andy LutomirskiThis splits syscall_trace_enter into syscall_trace_enter_phase1 and syscall_trace_enter_phase2. Only phase 2 has full pt_regs, and only phase 2 is permitted to modify any of pt_regs except for orig_ax.
The intent is that phase 1 can be called from the syscall fast path.
--- arch/x86/include/asm/ptrace.h | 5 ++ arch/x86/kernel/ptrace.c | 139 ++++++++++++++++++++++++++++++++++++------ 2 files changed, 125 insertions(+), 19 deletions(-)
arch/x86/include/asm/ptrace.h +5 -0
@@ -75,6 +75,11 @@ convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs);extern void send_sigtrap (struct task_struct *tsk,struct pt_regs *regs,int error_code,int si_code); + +extern unsigned long syscall_trace_enter_phase1 (struct pt_regs *,u32 arch); +extern long syscall_trace_enter_phase2 (struct pt_regs *,u32 arch, +unsigned long phase1_result); +extern long syscall_trace_enter (struct pt_regs *);extern void syscall_trace_leave (struct pt_regs *);
arch/x86/kernel/ptrace.c +120 -19
173 lines not on this page · raw message
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 6/7 x86_64,entry: Treat regs->ax the same in fastpath and slowpath syscalls
In reply to Andy LutomirskiFor slowpath syscalls, we initialize regs->ax to -ENOSYS and stick the syscall number into regs->orig_ax prior to any possible tracing and syscall execution. This is user-visible ABI used by ptrace syscall emulation and seccomp.
For fastpath syscalls, there's no good reason not to do the same thing. It's even slightly simpler than what we're currently doing. It probably has no measureable performance impact. It should have no user-visible effect.
The purpose of this patch is to prepare for two-phase syscall tracing, in which the first phase might modify the saved RAX without leaving the fast path. This change is just subtle enough that I'm keeping it separate.
--- arch/x86/include/asm/calling.h | 6 +++++- arch/x86/kernel/entry_64.S | 13 ++++--------- 2 files changed, 9 insertions(+), 10 deletions(-)
arch/x86/include/asm/calling.h +5 -1
@@ -85,7 +85,7 @@ For 32-bit we have the following conventions - kernel is built with#define ARGOFFSET R11#define SWFRAME ORIG_RAX - .macro SAVE_ARGS addskip=0, save_rcx=1, save_r891011=1 + .macro SAVE_ARGS addskip=0, save_rcx=1, save_r891011=1, rax_enosys=0 subq $9*8+\addskip, %rsp CFI_ADJUST_CFA_OFFSET 9*8+\addskip movq_cfi rdi, 8*8
@@ -96,7 +96,11 @@ For 32-bit we have the following conventions - kernel is built with movq_cfi rcx, 5*8 .endif + .if \rax_enosys + movq $-ENOSYS, 4*8(%rsp) + .else movq_cfi rax, 4*8 + .endif .if \save_r891011 movq_cfi r8, 3*8
arch/x86/kernel/entry_64.S +4 -9
@@ -405,8 +405,8 @@ GLOBAL(system_call_after_swapgs) * and short: */ ENABLE_INTERRUPTS(CLBR_NONE) - SAVE_ARGS 8,0 - movq %rax,ORIG_RAX-ARGOFFSET(%rsp) + SAVE_ARGS 8, 0, rax_enosys=1 + movq_cfi rax,(ORIG_RAX-ARGOFFSET) movq %rcx,RIP-ARGOFFSET(%rsp) CFI_REL_OFFSET rip,RIP-ARGOFFSET testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
@@ -418,7 +418,7 @@ system_call_fastpath: andl $__SYSCALL_MASK,%eax cmpl $__NR_syscall_max,%eax #endif - ja badsys + ja ret_from_sys_call /* and return regs->ax */ movq %r10,%rcx call *sys_call_table(,%rax,8) # XXX: rip relative movq %rax,RAX-ARGOFFSET(%rsp)
@@ -477,10 +477,6 @@ sysret_signal: FIXUP_TOP_OF_STACK %r11, -ARGOFFSET jmp int_check_syscall_exit_work -badsys: - movq $-ENOSYS,RAX-ARGOFFSET(%rsp) - jmp ret_from_sys_call - #ifdef CONFIG_AUDITSYSCALL /* * Fast path for syscall audit without full syscall trace.
@@ -520,7 +516,6 @@ tracesys: jz auditsys #endif SAVE_REST - movq $-ENOSYS,RAX(%rsp) /* ptrace can change this for a bad syscall */ FIXUP_TOP_OF_STACK %rdi movq %rsp,%rdi call syscall_trace_enter
@@ -537,7 +532,7 @@ tracesys: andl $__SYSCALL_MASK,%eax cmpl $__NR_syscall_max,%eax #endif - ja int_ret_from_sys_call /* RAX(%rsp) set to -ENOSYS above */ + ja int_ret_from_sys_call /* RAX(%rsp) is already set */ movq %r10,%rcx /* fixup for C */ call *sys_call_table(,%rax,8) movq %rax,RAX-ARGOFFSET(%rsp)
Signature · 1 line
1.9.3
Andy Lutomirski
reviewerPATCH v2 7/7 x86_64,entry: Use split-phase syscall_trace_enter for 64-bit syscalls
In reply to Andy LutomirskiOn KVM on my box, this reduces the overhead from an always-accept seccomp filter from ~130ns to ~17ns. Most of that comes from avoiding IRET on every syscall when seccomp is enabled.
In extremely approximate hacked-up benchmarking, just bypassing IRET saves about 80ns, so there's another 43ns of savings here from simplifying the seccomp path.
The diffstat is also rather nice :)
--- arch/x86/kernel/entry_64.S | 38 +++++++++++++++----------------------- 1 file changed, 15 insertions(+), 23 deletions(-)
arch/x86/kernel/entry_64.S +15 -23
@@ -479,22 +479,6 @@ sysret_signal: #ifdef CONFIG_AUDITSYSCALL /* - * Fast path for syscall audit without full syscall trace. - * We just call __audit_syscall_entry() directly, and then - * jump back to the normal fast path. - */ -auditsys: - movq %r10,%r9 /* 6th arg: 4th syscall arg */ - movq %rdx,%r8 /* 5th arg: 3rd syscall arg */ - movq %rsi,%rcx /* 4th arg: 2nd syscall arg */ - movq %rdi,%rdx /* 3rd arg: 1st syscall arg */ - movq %rax,%rsi /* 2nd arg: syscall number */ - movl $AUDIT_ARCH_X86_64,%edi /* 1st arg: audit arch */ - call __audit_syscall_entry - LOAD_ARGS 0 /* reload call-clobbered registers */ - jmp system_call_fastpath - - /* * Return fast path for syscall audit. Call __audit_syscall_exit() * directly and then jump back to the fast path with TIF_SYSCALL_AUDIT * masked off.
@@ -511,17 +495,25 @@ sysret_audit: /* Do syscall tracing */ tracesys: -#ifdef CONFIG_AUDITSYSCALL - testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET) - jz auditsys -#endif + leaq -REST_SKIP(%rsp), %rdi + movq $AUDIT_ARCH_X86_64, %rsi + call syscall_trace_enter_phase1 + test %rax, %rax + jnz tracesys_phase2 /* if needed, run the slow path */ + LOAD_ARGS 0 /* else restore clobbered regs */ + jmp system_call_fastpath /* and return to the fast path */ + +tracesys_phase2: SAVE_REST FIXUP_TOP_OF_STACK %rdi - movq %rsp,%rdi - call syscall_trace_enter + movq %rsp, %rdi + movq $AUDIT_ARCH_X86_64, %rsi + movq %rax,%rdx + call syscall_trace_enter_phase2 + /* * Reload arg registers from stack in case ptrace changed them. - * We don't reload %rax because syscall_trace_enter() returned + * We don't reload %rax because syscall_trace_entry_phase2() returned * the value it wants us to use in the table lookup. */ LOAD_ARGS ARGOFFSET, 1
Signature · 1 line
1.9.3
Andy Lutomirski
reviewer[PATCH v2 8/7] seccomp: Document two-phase seccomp and arch-provided seccomp_data
In reply to Andy LutomirskiThe description of how arches should implement seccomp filters was still strictly correct, but it failed to describe the newly available optimizations.
---
I lost this somehow. Here it as an an extra patch. If I end up sending a v3, I'll fold it in.
arch/Kconfig | 11 +++++++++++ 1 file changed, 11 insertions(+)
arch/Kconfig +11 -0
@@ -323,6 +323,17 @@ config HAVE_ARCH_SECCOMP_FILTER results in the system call being skipped immediately. - seccomp syscall wired up + For best performance, an arch should use seccomp_phase1 and + seccomp_phase2 directly. It should call seccomp_phase1 for all + syscalls if TIF_SECCOMP is set, but seccomp_phase1 does not + need to be called from a ptrace-safe context. It must then + call seccomp_phase2 if seccomp_phase1 returns anything other + than SECCOMP_PHASE1_OK or SECCOMP_PHASE1_SKIP. + + As an additional optimization, an arch may provide seccomp_data + directly to seccomp_phase1; this avoids multiple calls + to the syscall_xyz helpers for every syscall. + config SECCOMP_FILTER def_bool y depends on HAVE_ARCH_SECCOMP_FILTER && SECCOMP && NET
Signature · 1 line
1.9.3