TIF_NOTSC and SECCOMP prctl
Subsystems (2)
In-Reply-To: <[email protected]>
Quoted 3 lines · On Fri, 14 Jul 2006 08:09:32 +0200, [email protected] wrote:
The below patch seems to work, I ported all my client code on top of prctl already. (it's a bit more painful to autodetect a kernel with
CONFIG_SECCOMPturned off but I already adapted to it)
AFAIC the /proc method of controlling seccomp is so ugly it should just go, but what about backwards compatibility?
I have a couple of questions:
+void disable_TSC(void)
+{
+ if (!test_and_set_thread_flag(TIF_NOTSC))
+ /*
+ * Must flip the CPU state synchronously with + * TIF_NOTSC in the current running context. + */
+ hard_disable_TSC();
+}
This gets called from sys_prctl(). Do you need to worry about preemption between the test_and_set and TSC disable?
include/asm-i386/processor.h Fri Jul 14 07:47:57 2006 +0200 renamed from include/asm-i386/processor.h Thu Jul 13 03:03:35 2006 +0700 +4 -0
@@ -256,6 +256,10 @@ static inline void clear_in_cr4 (unsigne cr4 &= ~mask; write_cr4(cr4); } + +extern void hard_disable_TSC(void); +extern void disable_TSC(void); +extern void hard_enable_TSC(void);
Maybe these should be inline? They're really small and that way you don't need #ifdef around the code for them.
Quoted 3 lines
Reviews are welcome (then I will move into x86-64, all other archs supporting seccomp should require no changes despite the API change). Thanks.
For x86_64 you need this:
ftp://ftp.firstfloor.org/pub/ak/x86_64/quilt-current/patches/tif-flags-for-debug-regs-and-io-bitmap-in-ctxsw
But I don't think Andi plans on pushing it for 2.6.18.
Signature · 1 line
Chuck
Quoted 2 lines · Chuck Ebbert
AFAIC the /proc method of controlling seccomp is so ugly it should just go, but what about backwards compatibility?
Given that so far CPUShare seems the only user there should be no problem, I already uploaded a new CPUShare package that handles both the old and new interfaces transparently, no matter what kernel runs under it.
Quoted 13 lines
I have a couple of questions:
(quoted diff) +9
-0+void disable_TSC(void) +{ + if (!test_and_set_thread_flag(TIF_NOTSC)) + /* + * Must flip the CPU state synchronously with + * TIF_NOTSC in the current running context. + */ + hard_disable_TSC(); +}
Quoted 2 lines
This gets called from
sys_prctl(). Do you need to worry about preemption between thetest_and_setand TSC disable?
I tend to completely forget about preempt.
Quoted 2 lines
Maybe these should be inline? They're really small and that way you don't need #ifdef around the code for them.
I wanted to reduce the bytecode overhead to the minimum when seccomp is set to y, for that I tried to avoided inlines.
Quoted 5 lines
For
x86_64you need this:ftp://ftp.firstfloor.org/pub/ak/x86_64/quilt-current/patches/tif-flags-for-debug-regs-and-io-bitmap-in-ctxsw
But I don't think Andi plans on pushing it for 2.6.18.
Thanks for the pointer.
For now the patch I posted already works on x86-64 and on all other archs (x86_64 misses the notsc feature for now, but that's not a problem, the patch is self contained and we can take care of the notsc for x86-64 later on).
This is the incremental patch to address the preempt=y kernel builds.
arch/i386/kernel/process.c +2 -0
@@ -542,12 +542,14 @@ void hard_disable_TSC(void) }void disable_TSC (void ) { +preempt_disable ();if (!test_and_set_thread_flag (TIF_NOTSC ))/* * Must flip the CPU state synchronously with * TIF_NOTSC in the current running context. */ hard_disable_TSC (); +preempt_enable (); }void hard_enable_TSC (void ) {
Here a repost of the last seccomp patch against current mainline including the preempt fix. This changes the seccomp API from /proc/<pid>/seccomp to a prctl (this will produce a smaller kernel) and it adds a TIF_NOTSC that seccomp sets. Only the current task can call disable_TSC (obviously because it hasn't a task_t param). This includes Chuck's patch to give zero runtime cost to the notsc feature.
After applying this patch, seccomp will keep working fine on all other archs that currently support it too.
arch/i386/kernel/process.c +67 -59
@@ -535,8 +535,31 @@ int dump_task_regs(struct task_struct *treturn 1 ; } -static noinline void __switch_to_xtra(struct task_struct *next_p, -struct tss_struct *tss) +#ifdef CONFIG_SECCOMP +void hard_disable_TSC (void ) +{ +write_cr4 (read_cr4 () |X86_CR4_TSD ); +} +void disable_TSC (void ) +{ +preempt_disable (); +if (!test_and_set_thread_flag (TIF_NOTSC )) +/* +* Must flip the CPU state synchronously with +* TIF_NOTSC in the current running context. +*/ +hard_disable_TSC (); +preempt_enable (); +} +void hard_enable_TSC (void ) +{ +write_cr4 (read_cr4 () & ~X86_CR4_TSD ); +} +#endif /* CONFIG_SECCOMP */ + +static noinline void +__switch_to_xtra (struct task_struct *prev_p,struct task_struct *next_p, +struct tss_struct *tss) {struct thread_struct *next;
@@ -552,60 +575,47 @@ static noinline void __switch_to_xtra(stset_debugreg (next->debugreg[7 ],7 ); } -if (!test_tsk_thread_flag (next_p,TIF_IO_BITMAP )) { +#ifdef CONFIG_SECCOMP +if (test_tsk_thread_flag (prev_p,TIF_NOTSC ) ^ +test_tsk_thread_flag (next_p,TIF_NOTSC )) { +/* prev and next are different */ +if (test_tsk_thread_flag (next_p,TIF_NOTSC )) +hard_disable_TSC (); +else +hard_enable_TSC (); + } +#endif + +if (test_tsk_thread_flag (prev_p,TIF_IO_BITMAP ) || +test_tsk_thread_flag (next_p,TIF_IO_BITMAP )) { +if (!test_tsk_thread_flag (next_p,TIF_IO_BITMAP )) { +/* +* Disable the bitmap via an invalid offset. We still cache +* the previous bitmap owner and the IO bitmap contents: +*/ + tss->io_bitmap_base =INVALID_IO_BITMAP_OFFSET ; +return ; + } + +if (likely (next == tss->io_bitmap_owner)) { +/* +* Previous owner of the bitmap (hence the bitmap content) +* matches the next task, we dont have to do anything but +* to set a valid offset in the TSS: +*/ + tss->io_bitmap_base =IO_BITMAP_OFFSET ; +return ; + }/* -* Disable the bitmap via an invalid offset. We still cache -* the previous bitmap owner and the IO bitmap contents: +* Lazy TSS's I/O bitmap copy. We set an invalid offset here +* and we let the task to get a GPF in case an I/O instruction +* is performed. The handler of the GPF will verify that the +* faulting task has a valid I/O bitmap and, it true, does the +* real copy and restart the instruction. This will save us +* redundant copies when the currently switched task does not +* perform any I/O during its timeslice. */ - tss->io_bitmap_base =INVALID_IO_BITMAP_OFFSET ; -return ; - } - -if (likely (next == tss->io_bitmap_owner)) { -/* -* Previous owner of the bitmap (hence the bitmap content) -* matches the next task, we dont have to do anything but -* to set a valid offset in the TSS: -*/ - tss->io_bitmap_base =IO_BITMAP_OFFSET ; -return ; - } -/* -* Lazy TSS's I/O bitmap copy. We set an invalid offset here -* and we let the task to get a GPF in case an I/O instruction -* is performed. The handler of the GPF will verify that the -* faulting task has a valid I/O bitmap and, it true, does the -* real copy and restart the instruction. This will save us -* redundant copies when the currently switched task does not -* perform any I/O during its timeslice. -*/ - tss->io_bitmap_base =INVALID_IO_BITMAP_OFFSET_LAZY ; -} - -/* -* This function selects if the context switch from prev to next -* has to tweak the TSC disable bit in the cr4. -*/ -static inline void disable_tsc (struct task_struct *prev_p, -struct task_struct *next_p) -{ -struct thread_info *prev, *next; - -/* -* gcc should eliminate the ->thread_info dereference if -* has_secure_computing returns 0 at compile time (SECCOMP=n). -*/ - prev =task_thread_info (prev_p); - next =task_thread_info (next_p); - -if (has_secure_computing (prev) ||has_secure_computing (next)) { -/* slow path here */ -if (has_secure_computing (prev) && - !has_secure_computing (next)) { -write_cr4 (read_cr4 () & ~X86_CR4_TSD ); - }else if (!has_secure_computing (prev) && -has_secure_computing (next)) -write_cr4 (read_cr4 () |X86_CR4_TSD ); + tss->io_bitmap_base =INVALID_IO_BITMAP_OFFSET_LAZY ; } }
@@ -690,11 +700,9 @@ struct task_struct fastcall * __switch_t/* * Now maybe handle debug registers and/or IO bitmaps */ -if (unlikely ((task_thread_info (next_p)->flags & _TIF_WORK_CTXSW)) - ||test_tsk_thread_flag (prev_p,TIF_IO_BITMAP )) -__switch_to_xtra (next_p, tss); - -disable_tsc (prev_p, next_p); +if (unlikely (task_thread_info (prev_p)->flags & _TIF_WORK_CTXSW_PREV || +task_thread_info (next_p)->flags & _TIF_WORK_CTXSW_NEXT)) +__switch_to_xtra (prev_p, next_p, tss);return prev_p; }
fs/proc/base.c +0 -91
133 lines not on this page · raw message
include/asm-i386/processor.h +4 -0
@@ -256,6 +256,10 @@ static inline void clear_in_cr4 (unsigne cr4 &= ~mask;write_cr4 (cr4); } + +extern void hard_disable_TSC (void ); +extern void disable_TSC (void ); +extern void hard_enable_TSC (void );/* * NSC/Cyrix CPU configuration register indexes
include/asm-i386/thread_info.h +4 -1
@@ -142,6 +142,7 @@ static inline struct thread_info *curren#define TIF_MEMDIE 16#define TIF_DEBUG 17/* uses debug registers */ #define TIF_IO_BITMAP 18/* uses I/O bitmap */ +#define TIF_NOTSC 19/* TSC is not accessible in userland */ #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)
@@ -155,6 +156,7 @@ static inline struct thread_info *curren#define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK)#define _TIF_DEBUG (1<<TIF_DEBUG)#define _TIF_IO_BITMAP (1<<TIF_IO_BITMAP) +#define _TIF_NOTSC (1<<TIF_NOTSC)/* work to do on interrupt/exception return */ #define _TIF_WORK_MASK \
@@ -164,7 +166,8 @@ static inline struct thread_info *curren#define _TIF_ALLWORK_MASK (0x0000FFFF & ~_TIF_SECCOMP)/* flags to check in __switch_to() */ -#define _TIF_WORK_CTXSW (_TIF_DEBUG|_TIF_IO_BITMAP) +#define _TIF_WORK_CTXSW_NEXT (_TIF_IO_BITMAP | _TIF_NOTSC | _TIF_DEBUG) +#define _TIF_WORK_CTXSW_PREV (_TIF_IO_BITMAP | _TIF_NOTSC)/* * Thread-synchronous status.
include/linux/prctl.h +4 -0
@@ -59,4 +59,8 @@# define PR_ENDIAN_LITTLE 1/* True little endian mode */ # define PR_ENDIAN_PPC_LITTLE 2/* "PowerPC" pseudo little endian */ +/* Get/set process seccomp mode */ +#define PR_GET_SECCOMP 21 +#define PR_SET_SECCOMP 22 +#endif /* _LINUX_PRCTL_H */
include/linux/seccomp.h +10 -9
@@ -3,8 +3,6 @@#ifdef CONFIG_SECCOMP - -#define NR_SECCOMP_MODES 1#include <linux/thread_info.h> #include <asm/seccomp.h>
@@ -18,20 +16,23 @@ static inline void secure_computing(int __secure_computing(this_syscall); } -static inline int has_secure_computing (struct thread_info *ti) -{ -return unlikely (test_ti_thread_flag (ti,TIF_SECCOMP )); -} +extern long prctl_get_seccomp (void ); +extern long prctl_set_seccomp (unsigned long );#else /* CONFIG_SECCOMP */ typedef struct { }seccomp_t ;#define secure_computing (x) do { } while (0) -/* static inline to preserve typechecking */ -static inline int has_secure_computing (struct thread_info *ti) + +static inline long prctl_get_seccomp (void ) { -return 0 ; +return -EINVAL ; +} + +static inline long prctl_set_seccomp (unsigned long arg2) +{ +return -EINVAL ; }#endif /* CONFIG_SECCOMP */
kernel/seccomp.c +30 -1
@@ -1,7 +1,7 @@/* * linux/kernel/seccomp.c * -* Copyright 2004-2005 Andrea Arcangeli <[email protected]> +* Copyright 2004-2006 Andrea Arcangeli <[email protected]> * * This defines a simple but solid secure-computing mode. */
@@ -10,6 +10,7 @@#include <linux/sched.h> /* #define SECCOMP_DEBUG 1 */ +#define NR_SECCOMP_MODES 1/* * Secure computing mode 1 allows only read/write/exit/sigreturn.
@@ -54,3 +55,31 @@ void __secure_computing(int this_syscall#endif do_exit (SIGKILL ); } + +long prctl_get_seccomp (void ) +{ +return current->seccomp.mode; +} + +long prctl_set_seccomp (unsigned long seccomp_mode) +{ +long ret; + +/* can set it only once to be even more secure */ + ret = -EPERM ; +if (unlikely (current->seccomp.mode)) + goto out; + + ret = -EINVAL ; +if (seccomp_mode && seccomp_mode <=NR_SECCOMP_MODES ) { + current->seccomp.mode = seccomp_mode; +set_thread_flag (TIF_SECCOMP ); +#ifdef TIF_NOTSC +disable_TSC (); +#endif + ret =0 ; + } + + out: +return ret; +}
kernel/sys.c +8 -0
@@ -28,6 +28,7 @@#include <linux/tty.h> #include <linux/signal.h> #include <linux/cn_proc.h> +#include <linux/seccomp.h> #include <linux/compat.h> #include <linux/syscalls.h>
@@ -2056,6 +2057,13 @@ asmlinkage long sys_prctl(int option, un error =SET_ENDIAN (current, arg2);break ; +case PR_GET_SECCOMP : + error =prctl_get_seccomp (); +break ; +case PR_SET_SECCOMP : + error =prctl_set_seccomp (arg2); +break ; +default : error = -EINVAL ;break ;
Quoted 6 lines · * [email protected] <[email protected]> wrote:
Here a repost of the last seccomp patch against current mainline including the preempt fix. This changes the seccomp API from /proc/<pid>/seccomp to a prctl (this will produce a smaller kernel) and it adds a
TIF_NOTSCthat seccomp sets. Only the current task can calldisable_TSC(obviously because it hasn't atask_tparam). This includes Chuck's patch to give zero runtime cost to the notsc feature.
please send a patch-queue that is properly split-up: the bugfix, the API change and the TIF_NOTSC improvement.
Ingo
Quoted 10 lines · Ingo Molnar
Quoted 6 lines · * [email protected] <[email protected]> wrote:
Here a repost of the last seccomp patch against current mainline including the preempt fix. This changes the seccomp API from /proc/<pid>/seccomp to a prctl (this will produce a smaller kernel) and it adds a
TIF_NOTSCthat seccomp sets. Only the current task can calldisable_TSC(obviously because it hasn't atask_tparam). This includes Chuck's patch to give zero runtime cost to the notsc feature.
Quoted 2 lines
please send a patch-queue that is properly split-up: the bugfix, the API change and the
TIF_NOTSCimprovement.
Which bugfix do you mean? If you mean the preempt fix for the NOTSC improvement it makes no sense to split it up from the NOTSC part. There are no other bugfixes (the reduction of the notsc window isn't strictly a bugfix, since the feature already helped).
I can split the API change from the NOTSC feature, I'll wait some more days in the hope this one goes in. If it doesn't go in I'll follow your suggestion and I'll try again later with the split up in the hope to increase my chances.
Quoted 1 line
From my point of view it's not urgent to merge it, it's just the
anti-seccomp advocates that should want this patch being merged urgently.