tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal

Pull pile 2 of execve and kernel_thread unification work from Al Viro:
"Stuff in there: kernel_thread/kernel_execve/sys_execve conversions for
several more architectures plus assorted signal fixes and cleanups.

There'll be more (in particular, real fixes for the alpha
do_notify_resume() irq mess)..."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/signal: (43 commits)
alpha: don't open-code trace_report_syscall_{enter,exit}
Uninclude linux/freezer.h
m32r: trim masks
avr32: trim masks
tile: don't bother with SIGTRAP in setup_frame
microblaze: don't bother with SIGTRAP in setup_rt_frame()
mn10300: don't bother with SIGTRAP in setup_frame()
frv: no need to raise SIGTRAP in setup_frame()
x86: get rid of duplicate code in case of CONFIG_VM86
unicore32: remove pointless test
h8300: trim _TIF_WORK_MASK
parisc: decide whether to go to slow path (tracesys) based on thread flags
parisc: don't bother looping in do_signal()
parisc: fix double restarts
bury the rest of TIF_IRET
sanitize tsk_is_polling()
bury _TIF_RESTORE_SIGMASK
unicore32: unobfuscate _TIF_WORK_MASK
mips: NOTIFY_RESUME is not needed in TIF masks
mips: merge the identical "return from syscall" per-ABI code
...

Conflicts:
arch/arm/include/asm/thread_info.h

Linus Torvalds 8213a2f3 40924754

+350 -888
+2 -1
arch/alpha/include/asm/thread_info.h
··· 84 84 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 85 85 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 86 86 #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 87 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 88 87 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 89 88 90 89 /* Work to do on interrupt/exception return. */ ··· 115 116 >> (ALPHA_UAC_SHIFT - 1), \ 116 117 (int __user *)(value)); \ 117 118 }) 119 + 120 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 118 121 119 122 #endif /* __KERNEL__ */ 120 123 #endif /* _ALPHA_THREAD_INFO_H */
+6 -7
arch/alpha/kernel/entry.S
··· 418 418 strace: 419 419 /* set up signal stack, call syscall_trace */ 420 420 bsr $1, do_switch_stack 421 - jsr $26, syscall_trace 421 + jsr $26, syscall_trace_enter /* returns the syscall number */ 422 422 bsr $1, undo_switch_stack 423 423 424 - /* get the system call number and the arguments back.. */ 425 - ldq $0, 0($sp) 424 + /* get the arguments back.. */ 426 425 ldq $16, SP_OFF+24($sp) 427 426 ldq $17, SP_OFF+32($sp) 428 427 ldq $18, SP_OFF+40($sp) ··· 448 449 stq $0, 0($sp) /* save return value */ 449 450 450 451 bsr $1, do_switch_stack 451 - jsr $26, syscall_trace 452 + jsr $26, syscall_trace_leave 452 453 bsr $1, undo_switch_stack 453 454 br $31, ret_from_sys_call 454 455 ··· 466 467 bsr $1, do_switch_stack 467 468 mov $19, $9 /* save old syscall number */ 468 469 mov $20, $10 /* save old a3 */ 469 - jsr $26, syscall_trace 470 + jsr $26, syscall_trace_leave 470 471 mov $9, $19 471 472 mov $10, $20 472 473 bsr $1, undo_switch_stack ··· 697 698 lda $sp, -SWITCH_STACK_SIZE($sp) 698 699 jsr $26, do_sigreturn 699 700 bne $9, 1f 700 - jsr $26, syscall_trace 701 + jsr $26, syscall_trace_leave 701 702 1: br $1, undo_switch_stack 702 703 br ret_from_sys_call 703 704 .end sys_sigreturn ··· 714 715 lda $sp, -SWITCH_STACK_SIZE($sp) 715 716 jsr $26, do_rt_sigreturn 716 717 bne $9, 1f 717 - jsr $26, syscall_trace 718 + jsr $26, syscall_trace_leave 718 719 1: br $1, undo_switch_stack 719 720 br ret_from_sys_call 720 721 .end sys_rt_sigreturn
+13 -19
arch/alpha/kernel/ptrace.c
··· 13 13 #include <linux/user.h> 14 14 #include <linux/security.h> 15 15 #include <linux/signal.h> 16 + #include <linux/tracehook.h> 16 17 17 18 #include <asm/uaccess.h> 18 19 #include <asm/pgtable.h> ··· 313 312 return ret; 314 313 } 315 314 316 - asmlinkage void 317 - syscall_trace(void) 315 + asmlinkage unsigned long syscall_trace_enter(void) 318 316 { 319 - if (!test_thread_flag(TIF_SYSCALL_TRACE)) 320 - return; 321 - if (!(current->ptrace & PT_PTRACED)) 322 - return; 323 - /* The 0x80 provides a way for the tracing parent to distinguish 324 - between a syscall stop and SIGTRAP delivery */ 325 - ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) 326 - ? 0x80 : 0)); 317 + unsigned long ret = 0; 318 + if (test_thread_flag(TIF_SYSCALL_TRACE) && 319 + tracehook_report_syscall_entry(current_pt_regs())) 320 + ret = -1UL; 321 + return ret ?: current_pt_regs()->r0; 322 + } 327 323 328 - /* 329 - * This isn't the same as continuing with a signal, but it will do 330 - * for normal use. strace only continues with a signal if the 331 - * stopping signal is not SIGTRAP. -brl 332 - */ 333 - if (current->exit_code) { 334 - send_sig(current->exit_code, current, 1); 335 - current->exit_code = 0; 336 - } 324 + asmlinkage void 325 + syscall_trace_leave(void) 326 + { 327 + if (test_thread_flag(TIF_SYSCALL_TRACE)) 328 + tracehook_report_syscall_exit(current_pt_regs(), 0); 337 329 }
-2
arch/arm/include/asm/thread_info.h
··· 151 151 #define TIF_SYSCALL_TRACE 8 152 152 #define TIF_SYSCALL_AUDIT 9 153 153 #define TIF_SYSCALL_TRACEPOINT 10 154 - #define TIF_POLLING_NRFLAG 16 155 154 #define TIF_USING_IWMMXT 17 156 155 #define TIF_MEMDIE 18 /* is terminating due to OOM killer */ 157 156 #define TIF_RESTORE_SIGMASK 20 ··· 163 164 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) 164 165 #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) 165 166 #define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT) 166 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 167 167 #define _TIF_USING_IWMMXT (1 << TIF_USING_IWMMXT) 168 168 #define _TIF_SECCOMP (1 << TIF_SECCOMP) 169 169
-1
arch/arm/kernel/signal.c
··· 10 10 #include <linux/errno.h> 11 11 #include <linux/signal.h> 12 12 #include <linux/personality.h> 13 - #include <linux/freezer.h> 14 13 #include <linux/uaccess.h> 15 14 #include <linux/tracehook.h> 16 15
+6 -12
arch/avr32/include/asm/thread_info.h
··· 77 77 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 78 78 #define TIF_SIGPENDING 1 /* signal pending */ 79 79 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 80 - #define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling 81 - TIF_NEED_RESCHED */ 82 80 #define TIF_BREAKPOINT 4 /* enter monitor mode on return */ 83 81 #define TIF_SINGLE_STEP 5 /* single step in progress */ 84 82 #define TIF_MEMDIE 6 /* is terminating due to OOM killer */ ··· 89 91 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) 90 92 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 91 93 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 92 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 94 + #define _TIF_BREAKPOINT (1 << TIF_BREAKPOINT) 93 95 #define _TIF_SINGLE_STEP (1 << TIF_SINGLE_STEP) 94 96 #define _TIF_MEMDIE (1 << TIF_MEMDIE) 95 - #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) 96 97 #define _TIF_CPU_GOING_TO_SLEEP (1 << TIF_CPU_GOING_TO_SLEEP) 97 98 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) 98 99 ··· 99 102 100 103 /* work to do on interrupt/exception return */ 101 104 #define _TIF_WORK_MASK \ 102 - ((1 << TIF_SIGPENDING) \ 105 + (_TIF_SIGPENDING \ 103 106 | _TIF_NOTIFY_RESUME \ 104 - | (1 << TIF_NEED_RESCHED) \ 105 - | (1 << TIF_POLLING_NRFLAG) \ 106 - | (1 << TIF_BREAKPOINT) \ 107 - | (1 << TIF_RESTORE_SIGMASK)) 107 + | _TIF_NEED_RESCHED \ 108 + | _TIF_BREAKPOINT) 108 109 109 110 /* work to do on any return to userspace */ 110 - #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK | (1 << TIF_SYSCALL_TRACE) | \ 111 - _TIF_NOTIFY_RESUME) 111 + #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK | _TIF_SYSCALL_TRACE) 112 112 /* work to do on return from debug mode */ 113 - #define _TIF_DBGWORK_MASK (_TIF_WORK_MASK & ~(1 << TIF_BREAKPOINT)) 113 + #define _TIF_DBGWORK_MASK (_TIF_WORK_MASK & ~_TIF_BREAKPOINT) 114 114 115 115 #endif /* __ASM_AVR32_THREAD_INFO_H */
-1
arch/avr32/kernel/signal.c
··· 15 15 #include <linux/errno.h> 16 16 #include <linux/ptrace.h> 17 17 #include <linux/unistd.h> 18 - #include <linux/freezer.h> 19 18 #include <linux/tracehook.h> 20 19 21 20 #include <asm/uaccess.h>
-4
arch/blackfin/include/asm/thread_info.h
··· 96 96 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 97 97 #define TIF_SIGPENDING 1 /* signal pending */ 98 98 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 99 - #define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling 100 - TIF_NEED_RESCHED */ 101 99 #define TIF_MEMDIE 4 /* is terminating due to OOM killer */ 102 100 #define TIF_RESTORE_SIGMASK 5 /* restore signal mask in do_signal() */ 103 101 #define TIF_IRQ_SYNC 7 /* sync pipeline stage */ ··· 106 108 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 107 109 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 108 110 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 109 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 110 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 111 111 #define _TIF_IRQ_SYNC (1<<TIF_IRQ_SYNC) 112 112 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 113 113 #define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP)
-1
arch/blackfin/kernel/signal.c
··· 10 10 #include <linux/tty.h> 11 11 #include <linux/personality.h> 12 12 #include <linux/binfmts.h> 13 - #include <linux/freezer.h> 14 13 #include <linux/uaccess.h> 15 14 #include <linux/tracehook.h> 16 15
+1
arch/c6x/Kconfig
··· 17 17 select OF 18 18 select OF_EARLY_FLATTREE 19 19 select GENERIC_CLOCKEVENTS 20 + select GENERIC_KERNEL_THREAD 20 21 21 22 config MMU 22 23 def_bool n
-2
arch/c6x/include/asm/processor.h
··· 92 92 { 93 93 } 94 94 95 - extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); 96 - 97 95 #define copy_segments(tsk, mm) do { } while (0) 98 96 #define release_segments(mm) do { } while (0) 99 97
-5
arch/c6x/include/asm/syscalls.h
··· 44 44 struct pt_regs; 45 45 46 46 extern asmlinkage long sys_c6x_clone(struct pt_regs *regs); 47 - extern asmlinkage long sys_c6x_execve(const char __user *name, 48 - const char __user *const __user *argv, 49 - const char __user *const __user *envp, 50 - struct pt_regs *regs); 51 - 52 47 53 48 #include <asm-generic/syscalls.h> 54 49
-1
arch/c6x/include/asm/thread_info.h
··· 97 97 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 98 98 #define TIF_RESTORE_SIGMASK 4 /* restore signal mask in do_signal() */ 99 99 100 - #define TIF_POLLING_NRFLAG 16 /* true if polling TIF_NEED_RESCHED */ 101 100 #define TIF_MEMDIE 17 /* OOM killer killed process */ 102 101 103 102 #define TIF_WORK_MASK 0x00007FFE /* work on irq/exception return */
+3
arch/c6x/include/asm/unistd.h
··· 14 14 * more details. 15 15 */ 16 16 17 + #define __ARCH_WANT_KERNEL_EXECVE 18 + #define __ARCH_WANT_SYS_EXECVE 19 + 17 20 /* Use the standard ABI for syscalls. */ 18 21 #include <asm-generic/unistd.h> 19 22
-1
arch/c6x/kernel/asm-offsets.c
··· 116 116 DEFINE(_TIF_NOTIFY_RESUME, (1<<TIF_NOTIFY_RESUME)); 117 117 DEFINE(_TIF_SIGPENDING, (1<<TIF_SIGPENDING)); 118 118 DEFINE(_TIF_NEED_RESCHED, (1<<TIF_NEED_RESCHED)); 119 - DEFINE(_TIF_POLLING_NRFLAG, (1<<TIF_POLLING_NRFLAG)); 120 119 121 120 DEFINE(_TIF_ALLWORK_MASK, TIF_ALLWORK_MASK); 122 121 DEFINE(_TIF_WORK_MASK, TIF_WORK_MASK);
+26 -30
arch/c6x/kernel/entry.S
··· 400 400 STW .D2T2 B0,*+SP(REGS_A4+8) 401 401 ENDPROC(ret_from_fork) 402 402 403 + ENTRY(ret_from_kernel_thread) 404 + #ifdef CONFIG_C6X_BIG_KERNEL 405 + MVKL .S1 schedule_tail,A0 406 + MVKH .S1 schedule_tail,A0 407 + B .S2X A0 408 + #else 409 + B .S2 schedule_tail 410 + #endif 411 + LDW .D2T2 *+SP(REGS_A0+8),B10 /* get fn */ 412 + ADDKPC .S2 0f,B3,3 413 + 0: 414 + B .S2 B10 /* call fn */ 415 + LDW .D2T1 *+SP(REGS_A1+8),A4 /* get arg */ 416 + MVKL .S2 sys_exit,B11 417 + MVKH .S2 sys_exit,B11 418 + ADDKPC .S2 0f,B3,1 419 + 0: 420 + BNOP .S2 B11,5 /* jump to sys_exit */ 421 + ENDPROC(ret_from_kernel_thread) 422 + 423 + ENTRY(ret_from_kernel_execve) 424 + GET_THREAD_INFO A12 425 + BNOP .S2 syscall_exit,4 426 + ADD .D2X A4,-8,SP 427 + ENDPROC(ret_from_kernel_execve) 428 + 403 429 ;; 404 430 ;; These are the interrupt handlers, responsible for calling __do_IRQ() 405 431 ;; int6 is used for syscalls (see _system_call entry) ··· 619 593 NOP 4 620 594 ENDPROC(sys_sigaltstack) 621 595 622 - ;; kernel_execve 623 - ENTRY(kernel_execve) 624 - MVK .S2 __NR_execve,B0 625 - SWE 626 - BNOP .S2 B3,5 627 - ENDPROC(kernel_execve) 628 - 629 596 ;; 630 597 ;; Special system calls 631 598 ;; return address is in B3 ··· 646 627 NOP 5 647 628 #endif 648 629 ENDPROC(sys_rt_sigreturn) 649 - 650 - ENTRY(sys_execve) 651 - ADDAW .D2 SP,2,B6 ; put regs addr in 4th parameter 652 - ; & adjust regs stack addr 653 - LDW .D2T2 *+SP(REGS_B4+8),B4 654 - 655 - ;; c6x_execve(char *name, char **argv, 656 - ;; char **envp, struct pt_regs *regs) 657 - #ifdef CONFIG_C6X_BIG_KERNEL 658 - || MVKL .S1 sys_c6x_execve,A0 659 - MVKH .S1 sys_c6x_execve,A0 660 - B .S2X A0 661 - #else 662 - || B .S2 sys_c6x_execve 663 - #endif 664 - STW .D2T2 B3,*SP--[2] 665 - ADDKPC .S2 ret_from_c6x_execve,B3,3 666 - 667 - ret_from_c6x_execve: 668 - LDW .D2T2 *++SP[2],B3 669 - NOP 4 670 - BNOP .S2 B3,5 671 - ENDPROC(sys_execve) 672 630 673 631 ENTRY(sys_pread_c6x) 674 632 MV .D2X A8,B7
+11 -61
arch/c6x/kernel/process.c
··· 25 25 void (*c6x_halt)(void); 26 26 27 27 extern asmlinkage void ret_from_fork(void); 28 + extern asmlinkage void ret_from_kernel_thread(void); 28 29 29 30 /* 30 31 * power off function, if any ··· 104 103 halt_loop(); 105 104 } 106 105 107 - static void kernel_thread_helper(int dummy, void *arg, int (*fn)(void *)) 108 - { 109 - do_exit(fn(arg)); 110 - } 111 - 112 - /* 113 - * Create a kernel thread 114 - */ 115 - int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 116 - { 117 - struct pt_regs regs; 118 - 119 - /* 120 - * copy_thread sets a4 to zero (child return from fork) 121 - * so we can't just set things up to directly return to 122 - * fn. 123 - */ 124 - memset(&regs, 0, sizeof(regs)); 125 - regs.b4 = (unsigned long) arg; 126 - regs.a6 = (unsigned long) fn; 127 - regs.pc = (unsigned long) kernel_thread_helper; 128 - local_save_flags(regs.csr); 129 - regs.csr |= 1; 130 - regs.tsr = 5; /* Set GEE and GIE in TSR */ 131 - 132 - /* Ok, create the new process.. */ 133 - return do_fork(flags | CLONE_VM | CLONE_UNTRACED, -1, &regs, 134 - 0, NULL, NULL); 135 - } 136 - EXPORT_SYMBOL(kernel_thread); 137 - 138 106 void flush_thread(void) 139 107 { 140 108 } ··· 161 191 162 192 childregs = task_pt_regs(p); 163 193 164 - *childregs = *regs; 165 - childregs->a4 = 0; 166 - 167 - if (usp == -1) 194 + if (!regs) { 168 195 /* case of __kernel_thread: we return to supervisor space */ 196 + memset(childregs, 0, sizeof(struct pt_regs)); 169 197 childregs->sp = (unsigned long)(childregs + 1); 170 - else 198 + p->thread.pc = (unsigned long) ret_from_kernel_thread; 199 + childregs->a0 = usp; /* function */ 200 + childregs->a1 = ustk_size; /* argument */ 201 + } else { 171 202 /* Otherwise use the given stack */ 203 + *childregs = *regs; 172 204 childregs->sp = usp; 205 + p->thread.pc = (unsigned long) ret_from_fork; 206 + } 173 207 174 208 /* Set usp/ksp */ 175 209 p->thread.usp = childregs->sp; 176 - /* switch_to uses stack to save/restore 14 callee-saved regs */ 177 210 thread_saved_ksp(p) = (unsigned long)childregs - 8; 178 - p->thread.pc = (unsigned int) ret_from_fork; 179 - p->thread.wchan = (unsigned long) ret_from_fork; 211 + p->thread.wchan = p->thread.pc; 180 212 #ifdef __DSBT__ 181 213 { 182 214 unsigned long dp; ··· 191 219 } 192 220 #endif 193 221 return 0; 194 - } 195 - 196 - /* 197 - * c6x_execve() executes a new program. 198 - */ 199 - SYSCALL_DEFINE4(c6x_execve, const char __user *, name, 200 - const char __user *const __user *, argv, 201 - const char __user *const __user *, envp, 202 - struct pt_regs *, regs) 203 - { 204 - int error; 205 - char *filename; 206 - 207 - filename = getname(name); 208 - error = PTR_ERR(filename); 209 - if (IS_ERR(filename)) 210 - goto out; 211 - 212 - error = do_execve(filename, argv, envp, regs); 213 - putname(filename); 214 - out: 215 - return error; 216 222 } 217 223 218 224 unsigned long get_wchan(struct task_struct *p)
-3
arch/cris/include/asm/thread_info.h
··· 78 78 #define TIF_SIGPENDING 2 /* signal pending */ 79 79 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 80 80 #define TIF_RESTORE_SIGMASK 9 /* restore signal mask in do_signal() */ 81 - #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 82 81 #define TIF_MEMDIE 17 /* is terminating due to OOM killer */ 83 82 84 83 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 85 84 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 86 85 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 87 86 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 88 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 89 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 90 87 91 88 #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ 92 89 #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */
+1
arch/frv/Kconfig
··· 12 12 select ARCH_HAVE_NMI_SAFE_CMPXCHG 13 13 select GENERIC_CPU_DEVICES 14 14 select ARCH_WANT_IPC_PARSE_VERSION 15 + select GENERIC_KERNEL_THREAD 15 16 16 17 config ZONE_DMA 17 18 bool
+3 -6
arch/frv/include/asm/processor.h
··· 92 92 93 93 /* 94 94 * do necessary setup to start up a newly executed thread. 95 - * - need to discard the frame stacked by init() invoking the execve syscall 96 95 */ 97 96 #define start_thread(_regs, _pc, _usp) \ 98 97 do { \ 99 - __frame = __kernel_frame0_ptr; \ 100 - __frame->pc = (_pc); \ 101 - __frame->psr &= ~PSR_S; \ 102 - __frame->sp = (_usp); \ 98 + _regs->pc = (_pc); \ 99 + _regs->psr &= ~PSR_S; \ 100 + _regs->sp = (_usp); \ 103 101 } while(0) 104 102 105 103 /* Free all resources held by a thread. */ ··· 105 107 { 106 108 } 107 109 108 - extern asmlinkage int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); 109 110 extern asmlinkage void save_user_regs(struct user_context *target); 110 111 extern asmlinkage void *restore_user_regs(const struct user_context *target, ...); 111 112
+1
arch/frv/include/asm/ptrace.h
··· 76 76 #define user_mode(regs) (!((regs)->psr & PSR_S)) 77 77 #define instruction_pointer(regs) ((regs)->pc) 78 78 #define user_stack_pointer(regs) ((regs)->sp) 79 + #define current_pt_regs() (__frame) 79 80 80 81 extern unsigned long user_stack(const struct pt_regs *); 81 82 #define profile_pc(regs) ((regs)->pc)
-3
arch/frv/include/asm/thread_info.h
··· 94 94 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 95 95 #define TIF_SINGLESTEP 4 /* restore singlestep on return to user mode */ 96 96 #define TIF_RESTORE_SIGMASK 5 /* restore signal mask in do_signal() */ 97 - #define TIF_POLLING_NRFLAG 6 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 98 97 #define TIF_MEMDIE 7 /* is terminating due to OOM killer */ 99 98 100 99 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) ··· 101 102 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 102 103 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 103 104 #define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) 104 - #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) 105 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 106 105 107 106 /* work to do on interrupt/exception return */ 108 107 #define _TIF_WORK_MASK \
+2
arch/frv/include/asm/unistd.h
··· 372 372 #define __ARCH_WANT_SYS_SIGPROCMASK 373 373 #define __ARCH_WANT_SYS_RT_SIGACTION 374 374 #define __ARCH_WANT_SYS_RT_SIGSUSPEND 375 + #define __ARCH_WANT_SYS_EXECVE 376 + #define __ARCH_WANT_KERNEL_EXECVE 375 377 376 378 /* 377 379 * "Conditional" syscalls
+2 -2
arch/frv/kernel/Makefile
··· 7 7 8 8 extra-y:= head.o vmlinux.lds 9 9 10 - obj-y := $(heads-y) entry.o entry-table.o break.o switch_to.o kernel_thread.o \ 11 - kernel_execve.o process.o traps.o ptrace.o signal.o dma.o \ 10 + obj-y := $(heads-y) entry.o entry-table.o break.o switch_to.o \ 11 + process.o traps.o ptrace.o signal.o dma.o \ 12 12 sys_frv.o time.o setup.o frv_ksyms.o \ 13 13 debug-stub.o irq.o sleep.o uaccess.o 14 14
+13
arch/frv/kernel/entry.S
··· 863 863 setlos.p #0,gr8 864 864 bra __syscall_exit 865 865 866 + .globl ret_from_kernel_thread 867 + ret_from_kernel_thread: 868 + lddi.p @(gr28,#REG_GR(8)),gr20 869 + call schedule_tail 870 + or.p gr20,gr20,gr8 871 + calll @(gr21,gr0) 872 + bra sys_exit 873 + 874 + .globl ret_from_kernel_execve 875 + ret_from_kernel_execve: 876 + ori gr28,0,sp 877 + bra __syscall_exit 878 + 866 879 ################################################################################################### 867 880 # 868 881 # Return to user mode is not as complex as all this looks,
-1
arch/frv/kernel/frv_ksyms.c
··· 30 30 EXPORT_SYMBOL(local_irq_count); 31 31 EXPORT_SYMBOL(local_bh_count); 32 32 #endif 33 - EXPORT_SYMBOL(kernel_thread); 34 33 35 34 EXPORT_SYMBOL(__res_bus_clock_speed_HZ); 36 35 EXPORT_SYMBOL(__page_offset);
-33
arch/frv/kernel/kernel_execve.S
··· 1 - /* in-kernel program execution 2 - * 3 - * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved. 4 - * Written by David Howells (dhowells@redhat.com) 5 - * 6 - * This program is free software; you can redistribute it and/or 7 - * modify it under the terms of the GNU General Public License 8 - * as published by the Free Software Foundation; either version 9 - * 2 of the License, or (at your option) any later version. 10 - */ 11 - 12 - #include <linux/linkage.h> 13 - #include <asm/unistd.h> 14 - 15 - ############################################################################### 16 - # 17 - # Do a system call from kernel instead of calling sys_execve so we end up with 18 - # proper pt_regs. 19 - # 20 - # int kernel_execve(const char *filename, char *const argv[], char *const envp[]) 21 - # 22 - # On entry: GR8/GR9/GR10: arguments to function 23 - # On return: GR8: syscall return. 24 - # 25 - ############################################################################### 26 - .globl kernel_execve 27 - .type kernel_execve,@function 28 - kernel_execve: 29 - setlos __NR_execve,gr7 30 - tira gr0,#0 31 - bralr 32 - 33 - .size kernel_execve,.-kernel_execve
-77
arch/frv/kernel/kernel_thread.S
··· 1 - /* kernel_thread.S: kernel thread creation 2 - * 3 - * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved. 4 - * Written by David Howells (dhowells@redhat.com) 5 - * 6 - * This program is free software; you can redistribute it and/or 7 - * modify it under the terms of the GNU General Public License 8 - * as published by the Free Software Foundation; either version 9 - * 2 of the License, or (at your option) any later version. 10 - */ 11 - 12 - #include <linux/linkage.h> 13 - #include <linux/kern_levels.h> 14 - #include <asm/unistd.h> 15 - 16 - #define CLONE_VM 0x00000100 /* set if VM shared between processes */ 17 - 18 - .section .rodata 19 - kernel_thread_emsg: 20 - .asciz KERN_ERR "failed to create kernel thread: error=%d\n" 21 - 22 - .text 23 - .balign 4 24 - 25 - ############################################################################### 26 - # 27 - # Create a kernel thread 28 - # 29 - # int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 30 - # 31 - ############################################################################### 32 - .globl kernel_thread 33 - .type kernel_thread,@function 34 - kernel_thread: 35 - or.p gr8,gr0,gr4 36 - or gr9,gr0,gr5 37 - 38 - # start by forking the current process, but with shared VM 39 - setlos.p #__NR_clone,gr7 ; syscall number 40 - ori gr10,#CLONE_VM,gr8 ; first syscall arg [clone_flags] 41 - sethi.p #0xe4e4,gr9 ; second syscall arg [newsp] 42 - setlo #0xe4e4,gr9 43 - setlos.p #0,gr10 ; third syscall arg [parent_tidptr] 44 - setlos #0,gr11 ; fourth syscall arg [child_tidptr] 45 - tira gr0,#0 46 - setlos.p #4095,gr7 47 - andcc gr8,gr8,gr0,icc0 48 - addcc.p gr8,gr7,gr0,icc1 49 - bnelr icc0,#2 50 - bc icc1,#0,kernel_thread_error 51 - 52 - # now invoke the work function 53 - or gr5,gr0,gr8 54 - calll @(gr4,gr0) 55 - 56 - # and finally exit the thread 57 - setlos #__NR_exit,gr7 ; syscall number 58 - tira gr0,#0 59 - 60 - kernel_thread_error: 61 - subi sp,#8,sp 62 - movsg lr,gr4 63 - sti gr8,@(sp,#0) 64 - sti.p gr4,@(sp,#4) 65 - 66 - or gr8,gr0,gr9 67 - sethi.p %hi(kernel_thread_emsg),gr8 68 - setlo %lo(kernel_thread_emsg),gr8 69 - 70 - call printk 71 - 72 - ldi @(sp,#4),gr4 73 - ldi @(sp,#0),gr8 74 - subi sp,#8,sp 75 - jmpl @(gr4,gr0) 76 - 77 - .size kernel_thread,.-kernel_thread
+23 -43
arch/frv/kernel/process.c
··· 38 38 #include "local.h" 39 39 40 40 asmlinkage void ret_from_fork(void); 41 + asmlinkage void ret_from_kernel_thread(void); 41 42 42 43 #include <asm/pgalloc.h> 43 44 ··· 173 172 * set up the kernel stack and exception frames for a new process 174 173 */ 175 174 int copy_thread(unsigned long clone_flags, 176 - unsigned long usp, unsigned long topstk, 175 + unsigned long usp, unsigned long arg, 177 176 struct task_struct *p, struct pt_regs *regs) 178 177 { 179 - struct pt_regs *childregs0, *childregs, *regs0; 178 + struct pt_regs *childregs; 180 179 181 - regs0 = __kernel_frame0_ptr; 182 - childregs0 = (struct pt_regs *) 180 + childregs = (struct pt_regs *) 183 181 (task_stack_page(p) + THREAD_SIZE - FRV_FRAME0_SIZE); 184 - childregs = childregs0; 185 - 186 - /* set up the userspace frame (the only place that the USP is stored) */ 187 - *childregs0 = *regs0; 188 - 189 - childregs0->gr8 = 0; 190 - childregs0->sp = usp; 191 - childregs0->next_frame = NULL; 192 - 193 - /* set up the return kernel frame if called from kernel_thread() */ 194 - if (regs != regs0) { 195 - childregs--; 196 - *childregs = *regs; 197 - childregs->sp = (unsigned long) childregs0; 198 - childregs->next_frame = childregs0; 199 - childregs->gr15 = (unsigned long) task_thread_info(p); 200 - childregs->gr29 = (unsigned long) p; 201 - } 202 182 203 183 p->set_child_tid = p->clear_child_tid = NULL; 204 184 ··· 188 206 p->thread.sp = (unsigned long) childregs; 189 207 p->thread.fp = 0; 190 208 p->thread.lr = 0; 191 - p->thread.pc = (unsigned long) ret_from_fork; 192 - p->thread.frame0 = childregs0; 209 + p->thread.frame0 = childregs; 210 + 211 + if (unlikely(!regs)) { 212 + memset(childregs, 0, sizeof(struct pt_regs)); 213 + childregs->gr9 = usp; /* function */ 214 + childregs->gr8 = arg; 215 + chilregs->psr = PSR_S; 216 + p->thread.pc = (unsigned long) ret_from_kernel_thread; 217 + save_user_regs(p->thread.user); 218 + return 0; 219 + } 220 + 221 + /* set up the userspace frame (the only place that the USP is stored) */ 222 + *childregs = *regs; 223 + 224 + childregs->sp = usp; 225 + childregs->next_frame = NULL; 226 + 227 + p->thread.pc = (unsigned long) ret_from_fork; 193 228 194 229 /* the new TLS pointer is passed in as arg #5 to sys_clone() */ 195 230 if (clone_flags & CLONE_SETTLS) ··· 216 217 217 218 return 0; 218 219 } /* end copy_thread() */ 219 - 220 - /* 221 - * sys_execve() executes a new program. 222 - */ 223 - asmlinkage int sys_execve(const char __user *name, 224 - const char __user *const __user *argv, 225 - const char __user *const __user *envp) 226 - { 227 - int error; 228 - char * filename; 229 - 230 - filename = getname(name); 231 - error = PTR_ERR(filename); 232 - if (IS_ERR(filename)) 233 - return error; 234 - error = do_execve(filename, argv, envp, __frame); 235 - putname(filename); 236 - return error; 237 - } 238 220 239 221 unsigned long get_wchan(struct task_struct *p) 240 222 {
-9
arch/frv/kernel/signal.c
··· 20 20 #include <linux/ptrace.h> 21 21 #include <linux/unistd.h> 22 22 #include <linux/personality.h> 23 - #include <linux/freezer.h> 24 23 #include <linux/tracehook.h> 25 24 #include <asm/ucontext.h> 26 25 #include <asm/uaccess.h> ··· 297 298 __frame->lr = (unsigned long) &frame->retcode; 298 299 __frame->gr8 = sig; 299 300 300 - /* the tracer may want to single-step inside the handler */ 301 - if (test_thread_flag(TIF_SINGLESTEP)) 302 - ptrace_notify(SIGTRAP); 303 - 304 301 #if DEBUG_SIG 305 302 printk("SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n", 306 303 sig, current->comm, current->pid, frame, __frame->pc, ··· 394 399 __frame->lr = (unsigned long) &frame->retcode; 395 400 __frame->gr8 = sig; 396 401 __frame->gr9 = (unsigned long) &frame->info; 397 - 398 - /* the tracer may want to single-step inside the handler */ 399 - if (test_thread_flag(TIF_SINGLESTEP)) 400 - ptrace_notify(SIGTRAP); 401 402 402 403 #if DEBUG_SIG 403 404 printk("SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n",
+2 -5
arch/h8300/include/asm/thread_info.h
··· 85 85 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 86 86 #define TIF_SIGPENDING 1 /* signal pending */ 87 87 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 88 - #define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling 89 - TIF_NEED_RESCHED */ 90 88 #define TIF_MEMDIE 4 /* is terminating due to OOM killer */ 91 89 #define TIF_RESTORE_SIGMASK 5 /* restore signal mask in do_signal() */ 92 90 #define TIF_NOTIFY_RESUME 6 /* callback before returning to user */ ··· 93 95 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 94 96 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 95 97 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 96 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 97 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 98 98 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) 99 99 100 - #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ 100 + #define _TIF_WORK_MASK (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \ 101 + _TIF_NOTIFY_RESUME) 101 102 102 103 #endif /* __KERNEL__ */ 103 104
-1
arch/h8300/kernel/signal.c
··· 38 38 #include <linux/personality.h> 39 39 #include <linux/tty.h> 40 40 #include <linux/binfmts.h> 41 - #include <linux/freezer.h> 42 41 #include <linux/tracehook.h> 43 42 44 43 #include <asm/setup.h>
-5
arch/hexagon/include/asm/thread_info.h
··· 120 120 #define TIF_SIGPENDING 2 /* signal pending */ 121 121 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 122 122 #define TIF_SINGLESTEP 4 /* restore ss @ return to usr mode */ 123 - #define TIF_IRET 5 /* return with iret */ 124 123 #define TIF_RESTORE_SIGMASK 6 /* restore sig mask in do_signal() */ 125 124 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 126 - #define TIF_POLLING_NRFLAG 16 127 125 #define TIF_MEMDIE 17 /* OOM killer killed process */ 128 126 129 127 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) ··· 129 131 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 130 132 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 131 133 #define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) 132 - #define _TIF_IRET (1 << TIF_IRET) 133 - #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) 134 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 135 134 136 135 /* work to do on interrupt/exception return - All but TIF_SYSCALL_TRACE */ 137 136 #define _TIF_WORK_MASK (0x0000FFFF & ~_TIF_SYSCALL_TRACE)
-1
arch/hexagon/kernel/signal.c
··· 20 20 21 21 #include <linux/linkage.h> 22 22 #include <linux/syscalls.h> 23 - #include <linux/freezer.h> 24 23 #include <linux/tracehook.h> 25 24 #include <asm/registers.h> 26 25 #include <asm/thread_info.h>
-2
arch/ia64/include/asm/thread_info.h
··· 106 106 #define TIF_SYSCALL_AUDIT 3 /* syscall auditing active */ 107 107 #define TIF_SINGLESTEP 4 /* restore singlestep on return to user mode */ 108 108 #define TIF_NOTIFY_RESUME 6 /* resumption notification requested */ 109 - #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 110 109 #define TIF_MEMDIE 17 /* is terminating due to OOM killer */ 111 110 #define TIF_MCA_INIT 18 /* this task is processing MCA or INIT */ 112 111 #define TIF_DB_DISABLED 19 /* debug trap disabled for fsyscall */ ··· 118 119 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) 119 120 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 120 121 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 121 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 122 122 #define _TIF_MCA_INIT (1 << TIF_MCA_INIT) 123 123 #define _TIF_DB_DISABLED (1 << TIF_DB_DISABLED) 124 124 #define _TIF_RESTORE_RSE (1 << TIF_RESTORE_RSE)
-8
arch/ia64/kernel/signal.c
··· 438 438 long errno = scr->pt.r8; 439 439 440 440 /* 441 - * In the ia64_leave_kernel code path, we want the common case to go fast, which 442 - * is why we may in certain cases get here from kernel mode. Just return without 443 - * doing anything if so. 444 - */ 445 - if (!user_mode(&scr->pt)) 446 - return; 447 - 448 - /* 449 441 * This only loops in the rare cases of handle_signal() failing, in which case we 450 442 * need to push through a forced SIGSEGV. 451 443 */
+2 -7
arch/m32r/include/asm/thread_info.h
··· 119 119 #define TIF_SIGPENDING 1 /* signal pending */ 120 120 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 121 121 #define TIF_SINGLESTEP 3 /* restore singlestep on return to user mode */ 122 - #define TIF_IRET 4 /* return with iret */ 123 122 #define TIF_NOTIFY_RESUME 5 /* callback before returning to user */ 124 123 #define TIF_RESTORE_SIGMASK 8 /* restore signal mask in do_signal() */ 125 124 #define TIF_USEDFPU 16 /* FPU was used by this task this quantum (SMP) */ 126 - #define TIF_POLLING_NRFLAG 17 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 127 125 #define TIF_MEMDIE 18 /* is terminating due to OOM killer */ 128 126 129 127 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 130 128 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 131 129 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 132 130 #define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP) 133 - #define _TIF_IRET (1<<TIF_IRET) 134 131 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 135 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 136 132 #define _TIF_USEDFPU (1<<TIF_USEDFPU) 137 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 138 133 139 - #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ 140 - #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ 134 + #define _TIF_WORK_MASK (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_NOTIFY_RESUME) 135 + #define _TIF_ALLWORK_MASK (_TIF_WORK_MASK | _TIF_SYSCALL_TRACE) 141 136 142 137 /* 143 138 * Thread-synchronous status.
-3
arch/m32r/kernel/signal.c
··· 20 20 #include <linux/unistd.h> 21 21 #include <linux/stddef.h> 22 22 #include <linux/personality.h> 23 - #include <linux/freezer.h> 24 23 #include <linux/tracehook.h> 25 24 #include <asm/cacheflush.h> 26 25 #include <asm/ucontext.h> ··· 365 366 clear_thread_flag(TIF_NOTIFY_RESUME); 366 367 tracehook_notify_resume(regs); 367 368 } 368 - 369 - clear_thread_flag(TIF_IRET); 370 369 }
+1
arch/m68k/Kconfig
··· 15 15 select FPU if MMU 16 16 select ARCH_WANT_IPC_PARSE_VERSION 17 17 select ARCH_USES_GETTIMEOFFSET if MMU && !COLDFIRE 18 + select GENERIC_KERNEL_THREAD 18 19 19 20 config RWSEM_GENERIC_SPINLOCK 20 21 bool
+12 -13
arch/m68k/include/asm/processor.h
··· 100 100 .fs = __KERNEL_DS, \ 101 101 } 102 102 103 + /* 104 + * ColdFire stack format sbould be 0x4 for an aligned usp (will always be 105 + * true on thread creation). We need to set this explicitly. 106 + */ 107 + #ifdef CONFIG_COLDFIRE 108 + #define setframeformat(_regs) do { (_regs)->format = 0x4; } while(0) 109 + #else 110 + #define setframeformat(_regs) do { } while (0) 111 + #endif 112 + 103 113 #ifdef CONFIG_MMU 104 114 /* 105 115 * Do necessary setup to start up a newly executed thread. ··· 119 109 { 120 110 regs->pc = pc; 121 111 regs->sr &= ~0x2000; 112 + setframeformat(regs); 122 113 wrusp(usp); 123 114 } 124 115 ··· 127 116 128 117 #else 129 118 130 - /* 131 - * Coldfire stacks need to be re-aligned on trap exit, conventional 132 - * 68k can handle this case cleanly. 133 - */ 134 - #ifdef CONFIG_COLDFIRE 135 - #define reformat(_regs) do { (_regs)->format = 0x4; } while(0) 136 - #else 137 - #define reformat(_regs) do { } while (0) 138 - #endif 139 - 140 119 #define start_thread(_regs, _pc, _usp) \ 141 120 do { \ 142 121 (_regs)->pc = (_pc); \ 143 122 ((struct switch_stack *)(_regs))[-1].a6 = 0; \ 144 - reformat(_regs); \ 123 + setframeformat(_regs); \ 145 124 if (current->mm) \ 146 125 (_regs)->d5 = current->mm->start_data; \ 147 126 (_regs)->sr &= ~0x2000; \ ··· 153 152 static inline void release_thread(struct task_struct *dead_task) 154 153 { 155 154 } 156 - 157 - extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags); 158 155 159 156 /* 160 157 * Free current thread data structures etc..
+2
arch/m68k/include/asm/ptrace.h
··· 85 85 #define user_mode(regs) (!((regs)->sr & PS_S)) 86 86 #define instruction_pointer(regs) ((regs)->pc) 87 87 #define profile_pc(regs) instruction_pointer(regs) 88 + #define current_pt_regs() \ 89 + (struct pt_regs *)((char *)current_thread_info() + THREAD_SIZE) - 1 88 90 89 91 #define arch_has_single_step() (1) 90 92
+2
arch/m68k/include/asm/unistd.h
··· 382 382 #define __ARCH_WANT_SYS_SIGPROCMASK 383 383 #define __ARCH_WANT_SYS_RT_SIGACTION 384 384 #define __ARCH_WANT_SYS_RT_SIGSUSPEND 385 + #define __ARCH_WANT_SYS_EXECVE 386 + #define __ARCH_WANT_KERNEL_EXECVE 385 387 386 388 /* 387 389 * "Conditional" syscalls
+16
arch/m68k/kernel/entry.S
··· 111 111 addql #4,%sp 112 112 jra ret_from_exception 113 113 114 + ENTRY(ret_from_kernel_thread) 115 + | a3 contains the kernel thread payload, d7 - its argument 116 + movel %d1,%sp@- 117 + jsr schedule_tail 118 + GET_CURRENT(%d0) 119 + movel %d7,(%sp) 120 + jsr %a3@ 121 + addql #4,%sp 122 + movel %d0,(%sp) 123 + jra sys_exit 124 + 125 + ENTRY(ret_from_kernel_execve) 126 + movel 4(%sp), %sp 127 + GET_CURRENT(%d0) 128 + jra ret_from_exception 129 + 114 130 #if defined(CONFIG_COLDFIRE) || !defined(CONFIG_MMU) 115 131 116 132 #ifdef TRAP_DBG_INTERRUPT
+24 -80
arch/m68k/kernel/process.c
··· 35 35 36 36 37 37 asmlinkage void ret_from_fork(void); 38 + asmlinkage void ret_from_kernel_thread(void); 38 39 39 40 40 41 /* ··· 124 123 printk("USP: %08lx\n", rdusp()); 125 124 } 126 125 127 - /* 128 - * Create a kernel thread 129 - */ 130 - int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags) 131 - { 132 - int pid; 133 - mm_segment_t fs; 134 - 135 - fs = get_fs(); 136 - set_fs (KERNEL_DS); 137 - 138 - { 139 - register long retval __asm__ ("d0"); 140 - register long clone_arg __asm__ ("d1") = flags | CLONE_VM | CLONE_UNTRACED; 141 - 142 - retval = __NR_clone; 143 - __asm__ __volatile__ 144 - ("clrl %%d2\n\t" 145 - "trap #0\n\t" /* Linux/m68k system call */ 146 - "tstl %0\n\t" /* child or parent */ 147 - "jne 1f\n\t" /* parent - jump */ 148 - #ifdef CONFIG_MMU 149 - "lea %%sp@(%c7),%6\n\t" /* reload current */ 150 - "movel %6@,%6\n\t" 151 - #endif 152 - "movel %3,%%sp@-\n\t" /* push argument */ 153 - "jsr %4@\n\t" /* call fn */ 154 - "movel %0,%%d1\n\t" /* pass exit value */ 155 - "movel %2,%%d0\n\t" /* exit */ 156 - "trap #0\n" 157 - "1:" 158 - : "+d" (retval) 159 - : "i" (__NR_clone), "i" (__NR_exit), 160 - "r" (arg), "a" (fn), "d" (clone_arg), "r" (current), 161 - "i" (-THREAD_SIZE) 162 - : "d2"); 163 - 164 - pid = retval; 165 - } 166 - 167 - set_fs (fs); 168 - return pid; 169 - } 170 - EXPORT_SYMBOL(kernel_thread); 171 - 172 126 void flush_thread(void) 173 127 { 174 128 current->thread.fs = __USER_DS; ··· 175 219 } 176 220 177 221 int copy_thread(unsigned long clone_flags, unsigned long usp, 178 - unsigned long unused, 222 + unsigned long arg, 179 223 struct task_struct * p, struct pt_regs * regs) 180 224 { 181 225 struct pt_regs * childregs; 182 - struct switch_stack * childstack, *stack; 183 - unsigned long *retp; 226 + struct switch_stack *childstack; 184 227 185 228 childregs = (struct pt_regs *) (task_stack_page(p) + THREAD_SIZE) - 1; 186 - 187 - *childregs = *regs; 188 - childregs->d0 = 0; 189 - 190 - retp = ((unsigned long *) regs); 191 - stack = ((struct switch_stack *) retp) - 1; 192 - 193 229 childstack = ((struct switch_stack *) childregs) - 1; 194 - *childstack = *stack; 195 - childstack->retpc = (unsigned long)ret_from_fork; 196 230 197 231 p->thread.usp = usp; 198 232 p->thread.ksp = (unsigned long)childstack; 199 - 200 - if (clone_flags & CLONE_SETTLS) 201 - task_thread_info(p)->tp_value = regs->d5; 233 + p->thread.esp0 = (unsigned long)childregs; 202 234 203 235 /* 204 236 * Must save the current SFC/DFC value, NOT the value when 205 237 * the parent was last descheduled - RGH 10-08-96 206 238 */ 207 239 p->thread.fs = get_fs().seg; 240 + 241 + if (unlikely(!regs)) { 242 + /* kernel thread */ 243 + memset(childstack, 0, 244 + sizeof(struct switch_stack) + sizeof(struct pt_regs)); 245 + childregs->sr = PS_S; 246 + childstack->a3 = usp; /* function */ 247 + childstack->d7 = arg; 248 + childstack->retpc = (unsigned long)ret_from_kernel_thread; 249 + p->thread.usp = 0; 250 + return 0; 251 + } 252 + *childregs = *regs; 253 + childregs->d0 = 0; 254 + 255 + *childstack = ((struct switch_stack *) regs)[-1]; 256 + childstack->retpc = (unsigned long)ret_from_fork; 257 + 258 + if (clone_flags & CLONE_SETTLS) 259 + task_thread_info(p)->tp_value = regs->d5; 208 260 209 261 #ifdef CONFIG_FPU 210 262 if (!FPU_IS_EMU) { ··· 300 336 } 301 337 EXPORT_SYMBOL(dump_fpu); 302 338 #endif /* CONFIG_FPU */ 303 - 304 - /* 305 - * sys_execve() executes a new program. 306 - */ 307 - asmlinkage int sys_execve(const char __user *name, 308 - const char __user *const __user *argv, 309 - const char __user *const __user *envp) 310 - { 311 - int error; 312 - char * filename; 313 - struct pt_regs *regs = (struct pt_regs *) &name; 314 - 315 - filename = getname(name); 316 - error = PTR_ERR(filename); 317 - if (IS_ERR(filename)) 318 - return error; 319 - error = do_execve(filename, argv, envp, regs); 320 - putname(filename); 321 - return error; 322 - } 323 339 324 340 unsigned long get_wchan(struct task_struct *p) 325 341 {
-17
arch/m68k/kernel/sys_m68k.c
··· 549 549 return PAGE_SIZE; 550 550 } 551 551 552 - /* 553 - * Do a system call from kernel instead of calling sys_execve so we 554 - * end up with proper pt_regs. 555 - */ 556 - int kernel_execve(const char *filename, 557 - const char *const argv[], 558 - const char *const envp[]) 559 - { 560 - register long __res asm ("%d0") = __NR_execve; 561 - register long __a asm ("%d1") = (long)(filename); 562 - register long __b asm ("%d2") = (long)(argv); 563 - register long __c asm ("%d3") = (long)(envp); 564 - asm volatile ("trap #0" : "+d" (__res) 565 - : "d" (__a), "d" (__b), "d" (__c)); 566 - return __res; 567 - } 568 - 569 552 asmlinkage unsigned long sys_get_thread_area(void) 570 553 { 571 554 return current_thread_info()->tp_value;
+1 -2
arch/microblaze/include/asm/thread_info.h
··· 121 121 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 122 122 /* restore singlestep on return to user mode */ 123 123 #define TIF_SINGLESTEP 4 124 - #define TIF_IRET 5 /* return with iret */ 125 124 #define TIF_MEMDIE 6 /* is terminating due to OOM killer */ 126 125 #define TIF_SYSCALL_AUDIT 9 /* syscall auditing active */ 127 126 #define TIF_SECCOMP 10 /* secure computing */ ··· 133 134 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 134 135 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 135 136 #define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) 136 - #define _TIF_IRET (1 << TIF_IRET) 137 137 #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 138 138 #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) 139 139 #define _TIF_SECCOMP (1 << TIF_SECCOMP) ··· 182 184 ti->status &= ~TS_RESTORE_SIGMASK; 183 185 return true; 184 186 } 187 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 185 188 #endif 186 189 187 190 #endif /* __KERNEL__ */
+2 -5
arch/microblaze/kernel/signal.c
··· 254 254 255 255 set_fs(USER_DS); 256 256 257 - /* the tracer may want to single-step inside the handler */ 258 - if (test_thread_flag(TIF_SINGLESTEP)) 259 - ptrace_notify(SIGTRAP); 260 - 261 257 #ifdef DEBUG_SIG 262 258 printk(KERN_INFO "SIG deliver (%s:%d): sp=%p pc=%08lx\n", 263 259 current->comm, current->pid, frame, regs->pc); ··· 311 315 if (ret) 312 316 return; 313 317 314 - signal_delivered(sig, info, ka, regs, 0); 318 + signal_delivered(sig, info, ka, regs, 319 + test_thread_flag(TIF_SINGLESTEP)); 315 320 } 316 321 317 322 /*
-3
arch/mips/include/asm/thread_info.h
··· 103 103 #define TIF_NOTIFY_RESUME 5 /* callback before returning to user */ 104 104 #define TIF_RESTORE_SIGMASK 9 /* restore signal mask in do_signal() */ 105 105 #define TIF_USEDFPU 16 /* FPU was used by this task this quantum (SMP) */ 106 - #define TIF_POLLING_NRFLAG 17 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 107 106 #define TIF_MEMDIE 18 /* is terminating due to OOM killer */ 108 107 #define TIF_FIXADE 20 /* Fix address errors in software */ 109 108 #define TIF_LOGADE 21 /* Log address errors to syslog */ ··· 124 125 #define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) 125 126 #define _TIF_SECCOMP (1<<TIF_SECCOMP) 126 127 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 127 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 128 128 #define _TIF_USEDFPU (1<<TIF_USEDFPU) 129 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 130 129 #define _TIF_FIXADE (1<<TIF_FIXADE) 131 130 #define _TIF_LOGADE (1<<TIF_LOGADE) 132 131 #define _TIF_32BIT_REGS (1<<TIF_32BIT_REGS)
+1
arch/mn10300/Kconfig
··· 8 8 select HAVE_ARCH_KGDB 9 9 select HAVE_NMI_WATCHDOG if MN10300_WD_TIMER 10 10 select GENERIC_CLOCKEVENTS 11 + select GENERIC_KERNEL_THREAD 11 12 12 13 config AM33_2 13 14 def_bool n
+1 -1
arch/mn10300/include/asm/frame.inc
··· 61 61 ############################################################################### 62 62 .macro RESTORE_ALL 63 63 # peel back the stack to the calling frame 64 - # - this permits execve() to discard extra frames due to kernel syscalls 64 + # - we need that when returning from interrupts to kernel mode 65 65 GET_THREAD_INFO a0 66 66 mov (TI_frame,a0),fp 67 67 mov fp,sp
+3 -15
arch/mn10300/include/asm/processor.h
··· 119 119 120 120 /* 121 121 * do necessary setup to start up a newly executed thread 122 - * - need to discard the frame stacked by the kernel thread invoking the execve 123 - * syscall (see RESTORE_ALL macro) 124 122 */ 125 123 static inline void start_thread(struct pt_regs *regs, 126 124 unsigned long new_pc, unsigned long new_sp) 127 125 { 128 - struct thread_info *ti = current_thread_info(); 129 - struct pt_regs *frame0; 130 - 131 - frame0 = thread_info_to_uregs(ti); 132 - frame0->epsw = EPSW_nSL | EPSW_IE | EPSW_IM; 133 - frame0->pc = new_pc; 134 - frame0->sp = new_sp; 135 - ti->frame = frame0; 126 + regs->epsw = EPSW_nSL | EPSW_IE | EPSW_IM; 127 + regs->pc = new_pc; 128 + regs->sp = new_sp; 136 129 } 137 130 138 131 139 132 /* Free all resources held by a thread. */ 140 133 extern void release_thread(struct task_struct *); 141 - 142 - /* 143 - * create a kernel thread without removing it from tasklists 144 - */ 145 - extern int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags); 146 134 147 135 /* 148 136 * Return saved PC of a blocked thread.
+1
arch/mn10300/include/asm/ptrace.h
··· 86 86 #define user_mode(regs) (((regs)->epsw & EPSW_nSL) == EPSW_nSL) 87 87 #define instruction_pointer(regs) ((regs)->pc) 88 88 #define user_stack_pointer(regs) ((regs)->sp) 89 + #define current_pt_regs() current_frame() 89 90 90 91 #define arch_has_single_step() (1) 91 92
+2 -1
arch/mn10300/include/asm/thread_info.h
··· 160 160 #define _TIF_SIGPENDING +(1 << TIF_SIGPENDING) 161 161 #define _TIF_NEED_RESCHED +(1 << TIF_NEED_RESCHED) 162 162 #define _TIF_SINGLESTEP +(1 << TIF_SINGLESTEP) 163 - #define _TIF_RESTORE_SIGMASK +(1 << TIF_RESTORE_SIGMASK) 164 163 #define _TIF_POLLING_NRFLAG +(1 << TIF_POLLING_NRFLAG) 165 164 166 165 #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ 167 166 #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */ 167 + 168 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 168 169 169 170 #endif /* __KERNEL__ */ 170 171
+2
arch/mn10300/include/asm/unistd.h
··· 382 382 #define __ARCH_WANT_SYS_SIGPROCMASK 383 383 #define __ARCH_WANT_SYS_RT_SIGACTION 384 384 #define __ARCH_WANT_SYS_RT_SIGSUSPEND 385 + #define __ARCH_WANT_SYS_EXECVE 386 + #define __ARCH_WANT_KERNEL_EXECVE 385 387 386 388 /* 387 389 * "Conditional" syscalls
+2 -2
arch/mn10300/kernel/Makefile
··· 7 7 fpu-obj-$(CONFIG_FPU) := fpu.o fpu-low.o 8 8 9 9 obj-y := process.o signal.o entry.o traps.o irq.o \ 10 - ptrace.o setup.o time.o sys_mn10300.o io.o kthread.o \ 11 - switch_to.o mn10300_ksyms.o kernel_execve.o $(fpu-obj-y) \ 10 + ptrace.o setup.o time.o sys_mn10300.o io.o \ 11 + switch_to.o mn10300_ksyms.o $(fpu-obj-y) \ 12 12 csrc-mn10300.o cevt-mn10300.o 13 13 14 14 obj-$(CONFIG_SMP) += smp.o smp-low.o
+18
arch/mn10300/kernel/entry.S
··· 55 55 mov d0,(REG_D0,fp) 56 56 jmp syscall_exit 57 57 58 + ENTRY(ret_from_kernel_thread) 59 + call schedule_tail[],0 60 + mov (REG_D0,fp),d0 61 + mov (REG_A0,fp),a0 62 + calls (a0) 63 + jmp sys_exit 64 + 65 + ENTRY(ret_from_kernel_execve) 66 + add -12,d0 /* pt_regs -> frame */ 67 + mov d0,sp 68 + GET_THREAD_INFO a2 69 + clr d0 70 + jmp syscall_exit 71 + 58 72 ############################################################################### 59 73 # 60 74 # system call handler ··· 108 94 ############################################################################### 109 95 ALIGN 110 96 syscall_exit_work: 97 + mov (REG_EPSW,fp),d0 98 + and EPSW_nSL,d0 99 + beq resume_kernel # returning to supervisor mode 100 + 111 101 btst _TIF_SYSCALL_TRACE,d2 112 102 beq work_pending 113 103 LOCAL_IRQ_ENABLE # could let syscall_trace_exit() call
+1 -5
arch/mn10300/kernel/internal.h
··· 15 15 struct clock_event_device; 16 16 17 17 /* 18 - * kthread.S 19 - */ 20 - extern int kernel_thread_helper(int); 21 - 22 - /* 23 18 * entry.S 24 19 */ 25 20 extern void ret_from_fork(struct task_struct *) __attribute__((noreturn)); 21 + extern void ret_from_kernel_thread(struct task_struct *) __attribute__((noreturn)); 26 22 27 23 /* 28 24 * smp-low.S
-37
arch/mn10300/kernel/kernel_execve.S
··· 1 - /* MN10300 In-kernel program execution 2 - * 3 - * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 - * Written by David Howells (dhowells@redhat.com) 5 - * 6 - * This program is free software; you can redistribute it and/or 7 - * modify it under the terms of the GNU General Public Licence 8 - * as published by the Free Software Foundation; either version 9 - * 2 of the Licence, or (at your option) any later version. 10 - */ 11 - #include <linux/linkage.h> 12 - #include <asm/unistd.h> 13 - 14 - ############################################################################### 15 - # 16 - # Do a system call from kernel instead of calling sys_execve so we end up with 17 - # proper pt_regs. 18 - # 19 - # int kernel_execve(const char *filename, char *const argv[], 20 - # char *const envp[]) 21 - # 22 - # On entry: D0/D1/8(SP): arguments to function 23 - # On return: D0: syscall return. 24 - # 25 - ############################################################################### 26 - .globl kernel_execve 27 - .type kernel_execve,@function 28 - kernel_execve: 29 - mov a3,a1 30 - mov d0,a0 31 - mov (12,sp),a3 32 - mov +__NR_execve,d0 33 - syscall 0 34 - mov a1,a3 35 - rets 36 - 37 - .size kernel_execve,.-kernel_execve
-31
arch/mn10300/kernel/kthread.S
··· 1 - /* MN10300 Kernel thread trampoline function 2 - * 3 - * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 - * Written by Mark Salter (msalter@redhat.com) 5 - * 6 - * This program is free software; you can redistribute it and/or 7 - * modify it under the terms of the GNU General Public Licence 8 - * as published by the Free Software Foundation; either version 9 - * 2 of the Licence, or (at your option) any later version. 10 - */ 11 - .text 12 - 13 - ############################################################################### 14 - # 15 - # kernel_thread_helper - trampoline for kernel_thread() 16 - # 17 - # On entry: 18 - # A2 = address of function to call 19 - # D2 = function argument 20 - # 21 - ############################################################################### 22 - .globl kernel_thread_helper 23 - .type kernel_thread_helper,@function 24 - kernel_thread_helper: 25 - mov do_exit,d1 26 - mov d1,(sp) 27 - mov d1,mdr 28 - mov d2,d0 29 - jmp (a2) 30 - 31 - .size kernel_thread_helper,.-kernel_thread_helper
+24 -69
arch/mn10300/kernel/process.c
··· 165 165 } 166 166 167 167 /* 168 - * create a kernel thread 169 - */ 170 - int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags) 171 - { 172 - struct pt_regs regs; 173 - 174 - memset(&regs, 0, sizeof(regs)); 175 - 176 - regs.a2 = (unsigned long) fn; 177 - regs.d2 = (unsigned long) arg; 178 - regs.pc = (unsigned long) kernel_thread_helper; 179 - local_save_flags(regs.epsw); 180 - regs.epsw |= EPSW_IE | EPSW_IM_7; 181 - 182 - /* Ok, create the new process.. */ 183 - return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, 184 - NULL, NULL); 185 - } 186 - EXPORT_SYMBOL(kernel_thread); 187 - 188 - /* 189 168 * free current thread data structures etc.. 190 169 */ 191 170 void exit_thread(void) ··· 209 230 struct task_struct *p, struct pt_regs *kregs) 210 231 { 211 232 struct thread_info *ti = task_thread_info(p); 212 - struct pt_regs *c_uregs, *c_kregs, *uregs; 233 + struct pt_regs *c_regs; 213 234 unsigned long c_ksp; 214 - 215 - uregs = current->thread.uregs; 216 235 217 236 c_ksp = (unsigned long) task_stack_page(p) + THREAD_SIZE; 218 237 219 238 /* allocate the userspace exception frame and set it up */ 220 239 c_ksp -= sizeof(struct pt_regs); 221 - c_uregs = (struct pt_regs *) c_ksp; 222 - 223 - p->thread.uregs = c_uregs; 224 - *c_uregs = *uregs; 225 - c_uregs->sp = c_usp; 226 - c_uregs->epsw &= ~EPSW_FE; /* my FPU */ 227 - 240 + c_regs = (struct pt_regs *) c_ksp; 228 241 c_ksp -= 12; /* allocate function call ABI slack */ 242 + 243 + /* set up things up so the scheduler can start the new task */ 244 + p->thread.uregs = c_regs; 245 + ti->frame = c_regs; 246 + p->thread.a3 = (unsigned long) c_regs; 247 + p->thread.sp = c_ksp; 248 + p->thread.wchan = p->thread.pc; 249 + p->thread.usp = c_usp; 250 + 251 + if (unlikely(!kregs)) { 252 + memset(c_regs, 0, sizeof(struct pt_regs)); 253 + c_regs->a0 = c_usp; /* function */ 254 + c_regs->d0 = ustk_size; /* argument */ 255 + local_save_flags(c_regs->epsw); 256 + c_regs->epsw |= EPSW_IE | EPSW_IM_7; 257 + p->thread.pc = (unsigned long) ret_from_kernel_thread; 258 + return 0; 259 + } 260 + *c_regs = *kregs; 261 + c_regs->sp = c_usp; 262 + c_regs->epsw &= ~EPSW_FE; /* my FPU */ 229 263 230 264 /* the new TLS pointer is passed in as arg #5 to sys_clone() */ 231 265 if (clone_flags & CLONE_SETTLS) 232 - c_uregs->e2 = current_frame()->d3; 266 + c_regs->e2 = current_frame()->d3; 233 267 234 - /* set up the return kernel frame if called from kernel_thread() */ 235 - c_kregs = c_uregs; 236 - if (kregs != uregs) { 237 - c_ksp -= sizeof(struct pt_regs); 238 - c_kregs = (struct pt_regs *) c_ksp; 239 - *c_kregs = *kregs; 240 - c_kregs->sp = c_usp; 241 - c_kregs->next = c_uregs; 242 - #ifdef CONFIG_MN10300_CURRENT_IN_E2 243 - c_kregs->e2 = (unsigned long) p; /* current */ 244 - #endif 245 - 246 - c_ksp -= 12; /* allocate function call ABI slack */ 247 - } 248 - 249 - /* set up things up so the scheduler can start the new task */ 250 - ti->frame = c_kregs; 251 - p->thread.a3 = (unsigned long) c_kregs; 252 - p->thread.sp = c_ksp; 253 268 p->thread.pc = (unsigned long) ret_from_fork; 254 - p->thread.wchan = (unsigned long) ret_from_fork; 255 - p->thread.usp = c_usp; 256 269 257 270 return 0; 258 271 } ··· 271 300 { 272 301 return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, current_frame()->sp, 273 302 current_frame(), 0, NULL, NULL); 274 - } 275 - 276 - asmlinkage long sys_execve(const char __user *name, 277 - const char __user *const __user *argv, 278 - const char __user *const __user *envp) 279 - { 280 - char *filename; 281 - int error; 282 - 283 - filename = getname(name); 284 - error = PTR_ERR(filename); 285 - if (IS_ERR(filename)) 286 - return error; 287 - error = do_execve(filename, argv, envp, current_frame()); 288 - putname(filename); 289 - return error; 290 303 } 291 304 292 305 unsigned long get_wchan(struct task_struct *p)
-13
arch/mn10300/kernel/signal.c
··· 317 317 regs->d0 = sig; 318 318 regs->d1 = (unsigned long) &frame->sc; 319 319 320 - /* the tracer may want to single-step inside the handler */ 321 - if (test_thread_flag(TIF_SINGLESTEP)) 322 - ptrace_notify(SIGTRAP); 323 - 324 320 #if DEBUG_SIG 325 321 printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n", 326 322 sig, current->comm, current->pid, frame, regs->pc, ··· 394 398 regs->d0 = sig; 395 399 regs->d1 = (long) &frame->info; 396 400 397 - /* the tracer may want to single-step inside the handler */ 398 - if (test_thread_flag(TIF_SINGLESTEP)) 399 - ptrace_notify(SIGTRAP); 400 - 401 401 #if DEBUG_SIG 402 402 printk(KERN_DEBUG "SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p\n", 403 403 sig, current->comm, current->pid, frame, regs->pc, ··· 466 474 struct k_sigaction ka; 467 475 siginfo_t info; 468 476 int signr; 469 - 470 - /* we want the common case to go fast, which is why we may in certain 471 - * cases get here from kernel mode */ 472 - if (!user_mode(regs)) 473 - return; 474 477 475 478 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 476 479 if (signr > 0) {
+2 -1
arch/openrisc/include/asm/thread_info.h
··· 121 121 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 122 122 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 123 123 #define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP) 124 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 125 124 #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 126 125 127 126 128 127 /* Work to do when returning from interrupt/exception */ 129 128 /* For OpenRISC, this is anything in the LSW other than syscall trace */ 130 129 #define _TIF_WORK_MASK (0xff & ~(_TIF_SYSCALL_TRACE|_TIF_SINGLESTEP)) 130 + 131 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 131 132 132 133 #endif /* __KERNEL__ */ 133 134
+1 -1
arch/parisc/hpux/gate.S
··· 71 71 STREG %r26, TASK_PT_GR26(%r1) /* 1st argument */ 72 72 STREG %r27, TASK_PT_GR27(%r1) /* user dp */ 73 73 STREG %r28, TASK_PT_GR28(%r1) /* return value 0 */ 74 - STREG %r28, TASK_PT_ORIG_R28(%r1) /* return value 0 (saved for signals) */ 74 + STREG %r0, TASK_PT_ORIG_R28(%r1) /* don't prohibit restarts */ 75 75 STREG %r29, TASK_PT_GR29(%r1) /* 8th argument */ 76 76 STREG %r31, TASK_PT_GR31(%r1) /* preserve syscall return ptr */ 77 77
+4 -1
arch/parisc/include/asm/thread_info.h
··· 68 68 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 69 69 #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 70 70 #define _TIF_32BIT (1 << TIF_32BIT) 71 - #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) 72 71 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) 73 72 #define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) 74 73 #define _TIF_BLOCKSTEP (1 << TIF_BLOCKSTEP) 75 74 76 75 #define _TIF_USER_WORK_MASK (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | \ 77 76 _TIF_NEED_RESCHED) 77 + #define _TIF_SYSCALL_TRACE_MASK (_TIF_SYSCALL_TRACE | _TIF_SINGLESTEP | \ 78 + _TIF_BLOCKSTEP) 79 + 80 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 78 81 79 82 #endif /* __KERNEL__ */ 80 83
+15 -30
arch/parisc/kernel/signal.c
··· 113 113 (usp - sigframe_size); 114 114 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame); 115 115 116 + regs->orig_r28 = 1; /* no restarts for sigreturn */ 117 + 116 118 #ifdef CONFIG_64BIT 117 119 compat_frame = (struct compat_rt_sigframe __user *)frame; 118 120 ··· 439 437 * OK, we're invoking a handler. 440 438 */ 441 439 442 - static long 440 + static void 443 441 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 444 442 struct pt_regs *regs, int in_syscall) 445 443 { ··· 449 447 450 448 /* Set up the stack frame */ 451 449 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall)) 452 - return 0; 450 + return; 453 451 454 452 signal_delivered(sig, info, ka, regs, 455 453 test_thread_flag(TIF_SINGLESTEP) || ··· 457 455 458 456 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n", 459 457 regs->gr[28]); 460 - 461 - return 1; 462 458 } 463 459 464 460 static inline void 465 461 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka) 466 462 { 463 + if (regs->orig_r28) 464 + return; 465 + regs->orig_r28 = 1; /* no more restarts */ 467 466 /* Check the return code */ 468 467 switch (regs->gr[28]) { 469 468 case -ERESTART_RESTARTBLOCK: ··· 485 482 * we have to do is fiddle the return pointer. 486 483 */ 487 484 regs->gr[31] -= 8; /* delayed branching */ 488 - /* Preserve original r28. */ 489 - regs->gr[28] = regs->orig_r28; 490 485 break; 491 486 } 492 487 } ··· 492 491 static inline void 493 492 insert_restart_trampoline(struct pt_regs *regs) 494 493 { 494 + if (regs->orig_r28) 495 + return; 496 + regs->orig_r28 = 1; /* no more restarts */ 495 497 switch(regs->gr[28]) { 496 498 case -ERESTART_RESTARTBLOCK: { 497 499 /* Restart the system call - no handlers present */ ··· 529 525 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4); 530 526 531 527 regs->gr[31] = regs->gr[30] + 8; 532 - /* Preserve original r28. */ 533 - regs->gr[28] = regs->orig_r28; 534 - 535 528 return; 536 529 } 537 530 case -ERESTARTNOHAND: ··· 540 539 * slot of the branch external instruction. 541 540 */ 542 541 regs->gr[31] -= 8; 543 - /* Preserve original r28. */ 544 - regs->gr[28] = regs->orig_r28; 545 - 546 542 return; 547 543 } 548 544 default: ··· 568 570 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n", 569 571 regs, regs->sr[7], in_syscall); 570 572 571 - /* Everyone else checks to see if they are in kernel mode at 572 - this point and exits if that's the case. I'm not sure why 573 - we would be called in that case, but for some reason we 574 - are. */ 575 - 576 - /* May need to force signal if handle_signal failed to deliver */ 577 - while (1) { 578 - signr = get_signal_to_deliver(&info, &ka, regs, NULL); 579 - DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 573 + signr = get_signal_to_deliver(&info, &ka, regs, NULL); 574 + DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 580 575 581 - if (signr <= 0) 582 - break; 583 - 576 + if (signr > 0) { 584 577 /* Restart a system call if necessary. */ 585 578 if (in_syscall) 586 579 syscall_restart(regs, &ka); 587 580 588 - /* Whee! Actually deliver the signal. If the 589 - delivery failed, we need to continue to iterate in 590 - this loop so we can deliver the SIGSEGV... */ 591 - if (handle_signal(signr, &info, &ka, regs, in_syscall)) 592 - return; 581 + handle_signal(signr, &info, &ka, regs, in_syscall); 582 + return; 593 583 } 594 - /* end of while(1) looping forever if we can't force a signal */ 595 584 596 585 /* Did we come from a system call? */ 597 586 if (in_syscall)
+5 -4
arch/parisc/kernel/syscall.S
··· 156 156 STREG %r26, TASK_PT_GR26(%r1) /* 1st argument */ 157 157 STREG %r27, TASK_PT_GR27(%r1) /* user dp */ 158 158 STREG %r28, TASK_PT_GR28(%r1) /* return value 0 */ 159 - STREG %r28, TASK_PT_ORIG_R28(%r1) /* return value 0 (saved for signals) */ 159 + STREG %r0, TASK_PT_ORIG_R28(%r1) /* don't prohibit restarts */ 160 160 STREG %r29, TASK_PT_GR29(%r1) /* return value 1 */ 161 161 STREG %r31, TASK_PT_GR31(%r1) /* preserve syscall return ptr */ 162 162 ··· 180 180 181 181 /* Are we being ptraced? */ 182 182 mfctl %cr30, %r1 183 - LDREG TI_TASK(%r1),%r1 184 - ldw TASK_PTRACE(%r1), %r1 185 - bb,<,n %r1,31,.Ltracesys 183 + LDREG TI_FLAGS(%r1),%r1 184 + ldi _TIF_SYSCALL_TRACE_MASK, %r19 185 + and,COND(=) %r1, %r19, %r0 186 + b,n .Ltracesys 186 187 187 188 /* Note! We cannot use the syscall table that is mapped 188 189 nearby since the gateway page is mapped execute-only. */
+1
arch/powerpc/Kconfig
··· 141 141 select GENERIC_CLOCKEVENTS 142 142 select GENERIC_STRNCPY_FROM_USER 143 143 select GENERIC_STRNLEN_USER 144 + select GENERIC_KERNEL_THREAD 144 145 145 146 config EARLY_PRINTK 146 147 bool
-3
arch/powerpc/include/asm/processor.h
··· 74 74 void start_thread(struct pt_regs *regs, unsigned long fdptr, unsigned long sp); 75 75 void release_thread(struct task_struct *); 76 76 77 - /* Create a new kernel thread. */ 78 - extern long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags); 79 - 80 77 /* Lazy FPU handling on uni-processor */ 81 78 extern struct task_struct *last_task_used_math; 82 79 extern struct task_struct *last_task_used_altivec;
+2
arch/powerpc/include/asm/ptrace.h
··· 125 125 extern int ptrace_put_reg(struct task_struct *task, int regno, 126 126 unsigned long data); 127 127 128 + #define current_pt_regs() \ 129 + ((struct pt_regs *)((unsigned long)current_thread_info() + THREAD_SIZE) - 1) 128 130 /* 129 131 * We use the least-significant bit of the trap field to indicate 130 132 * whether we have saved the full set of registers, or only a
-3
arch/powerpc/include/asm/syscalls.h
··· 17 17 asmlinkage unsigned long sys_mmap2(unsigned long addr, size_t len, 18 18 unsigned long prot, unsigned long flags, 19 19 unsigned long fd, unsigned long pgoff); 20 - asmlinkage int sys_execve(unsigned long a0, unsigned long a1, 21 - unsigned long a2, unsigned long a3, unsigned long a4, 22 - unsigned long a5, struct pt_regs *regs); 23 20 asmlinkage int sys_clone(unsigned long clone_flags, unsigned long usp, 24 21 int __user *parent_tidp, void __user *child_threadptr, 25 22 int __user *child_tidp, int p6, struct pt_regs *regs);
+2
arch/powerpc/include/asm/thread_info.h
··· 182 182 #define is_32bit_task() (1) 183 183 #endif 184 184 185 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 186 + 185 187 #endif /* !__ASSEMBLY__ */ 186 188 187 189 #endif /* __KERNEL__ */
+2
arch/powerpc/include/asm/unistd.h
··· 421 421 #define __ARCH_WANT_SYS_NEWFSTATAT 422 422 #define __ARCH_WANT_COMPAT_SYS_SENDFILE 423 423 #endif 424 + #define __ARCH_WANT_SYS_EXECVE 425 + #define __ARCH_WANT_KERNEL_EXECVE 424 426 425 427 /* 426 428 * "Conditional" syscalls
+16
arch/powerpc/kernel/entry_32.S
··· 435 435 li r3,0 436 436 b ret_from_syscall 437 437 438 + .globl ret_from_kernel_thread 439 + ret_from_kernel_thread: 440 + REST_NVGPRS(r1) 441 + bl schedule_tail 442 + mtlr r14 443 + mr r3,r15 444 + PPC440EP_ERR42 445 + blrl 446 + li r3,0 447 + b do_exit # no return 448 + 449 + .globl __ret_from_kernel_execve 450 + __ret_from_kernel_execve: 451 + addi r1,r3,-STACK_FRAME_OVERHEAD 452 + b ret_from_syscall 453 + 438 454 /* Traced system call support */ 439 455 syscall_dotrace: 440 456 SAVE_NVGPRS(r1)
+16
arch/powerpc/kernel/entry_64.S
··· 370 370 li r3,0 371 371 b syscall_exit 372 372 373 + _GLOBAL(ret_from_kernel_thread) 374 + bl .schedule_tail 375 + REST_NVGPRS(r1) 376 + REST_GPR(2,r1) 377 + mtlr r14 378 + mr r3,r15 379 + blrl 380 + li r3,0 381 + b .do_exit # no return 382 + 383 + _GLOBAL(__ret_from_kernel_execve) 384 + addi r1,r3,-STACK_FRAME_OVERHEAD 385 + li r10,1 386 + std r10,SOFTE(r1) 387 + b syscall_exit 388 + 373 389 .section ".toc","aw" 374 390 DSCR_DEFAULT: 375 391 .tc dscr_default[TC],dscr_default
-7
arch/powerpc/kernel/misc.S
··· 54 54 .align 3 55 55 2: PPC_LONG 1b 56 56 57 - _GLOBAL(kernel_execve) 58 - li r0,__NR_execve 59 - sc 60 - bnslr 61 - neg r3,r3 62 - blr 63 - 64 57 _GLOBAL(setjmp) 65 58 mflr r0 66 59 PPC_STL r0,0(r3)
-33
arch/powerpc/kernel/misc_32.S
··· 663 663 sub r3,r3,r4 664 664 blr 665 665 666 - /* 667 - * Create a kernel thread 668 - * kernel_thread(fn, arg, flags) 669 - */ 670 - _GLOBAL(kernel_thread) 671 - stwu r1,-16(r1) 672 - stw r30,8(r1) 673 - stw r31,12(r1) 674 - mr r30,r3 /* function */ 675 - mr r31,r4 /* argument */ 676 - ori r3,r5,CLONE_VM /* flags */ 677 - oris r3,r3,CLONE_UNTRACED>>16 678 - li r4,0 /* new sp (unused) */ 679 - li r0,__NR_clone 680 - sc 681 - bns+ 1f /* did system call indicate error? */ 682 - neg r3,r3 /* if so, make return code negative */ 683 - 1: cmpwi 0,r3,0 /* parent or child? */ 684 - bne 2f /* return if parent */ 685 - li r0,0 /* make top-level stack frame */ 686 - stwu r0,-16(r1) 687 - mtlr r30 /* fn addr in lr */ 688 - mr r3,r31 /* load arg and call fn */ 689 - PPC440EP_ERR42 690 - blrl 691 - li r0,__NR_exit /* exit if function returns */ 692 - li r3,0 693 - sc 694 - 2: lwz r30,8(r1) 695 - lwz r31,12(r1) 696 - addi r1,r1,16 697 - blr 698 - 699 666 #ifdef CONFIG_SMP 700 667 _GLOBAL(start_secondary_resume) 701 668 /* Reset stack */
-34
arch/powerpc/kernel/misc_64.S
··· 407 407 408 408 409 409 /* 410 - * Create a kernel thread 411 - * kernel_thread(fn, arg, flags) 412 - */ 413 - _GLOBAL(kernel_thread) 414 - std r29,-24(r1) 415 - std r30,-16(r1) 416 - stdu r1,-STACK_FRAME_OVERHEAD(r1) 417 - mr r29,r3 418 - mr r30,r4 419 - ori r3,r5,CLONE_VM /* flags */ 420 - oris r3,r3,(CLONE_UNTRACED>>16) 421 - li r4,0 /* new sp (unused) */ 422 - li r0,__NR_clone 423 - sc 424 - bns+ 1f /* did system call indicate error? */ 425 - neg r3,r3 /* if so, make return code negative */ 426 - 1: cmpdi 0,r3,0 /* parent or child? */ 427 - bne 2f /* return if parent */ 428 - li r0,0 429 - stdu r0,-STACK_FRAME_OVERHEAD(r1) 430 - ld r2,8(r29) 431 - ld r29,0(r29) 432 - mtlr r29 /* fn addr in lr */ 433 - mr r3,r30 /* load arg and call fn */ 434 - blrl 435 - li r0,__NR_exit /* exit after child exits */ 436 - li r3,0 437 - sc 438 - 2: addi r1,r1,STACK_FRAME_OVERHEAD 439 - ld r29,-24(r1) 440 - ld r30,-16(r1) 441 - blr 442 - 443 - /* 444 410 * disable_kernel_fp() 445 411 * Disable the FPU. 446 412 */
-1
arch/powerpc/kernel/ppc_ksyms.c
··· 94 94 #endif /* CONFIG_PCI */ 95 95 96 96 EXPORT_SYMBOL(start_thread); 97 - EXPORT_SYMBOL(kernel_thread); 98 97 99 98 EXPORT_SYMBOL(giveup_fpu); 100 99 #ifdef CONFIG_ALTIVEC
+27 -32
arch/powerpc/kernel/process.c
··· 733 733 extern unsigned long dscr_default; /* defined in arch/powerpc/kernel/sysfs.c */ 734 734 735 735 int copy_thread(unsigned long clone_flags, unsigned long usp, 736 - unsigned long unused, struct task_struct *p, 736 + unsigned long arg, struct task_struct *p, 737 737 struct pt_regs *regs) 738 738 { 739 739 struct pt_regs *childregs, *kregs; 740 740 extern void ret_from_fork(void); 741 + extern void ret_from_kernel_thread(void); 742 + void (*f)(void); 741 743 unsigned long sp = (unsigned long)task_stack_page(p) + THREAD_SIZE; 742 744 743 - CHECK_FULL_REGS(regs); 744 745 /* Copy registers */ 745 746 sp -= sizeof(struct pt_regs); 746 747 childregs = (struct pt_regs *) sp; 747 - *childregs = *regs; 748 - if ((childregs->msr & MSR_PR) == 0) { 748 + if (!regs) { 749 749 /* for kernel thread, set `current' and stackptr in new task */ 750 + memset(childregs, 0, sizeof(struct pt_regs)); 750 751 childregs->gpr[1] = sp + sizeof(struct pt_regs); 751 - #ifdef CONFIG_PPC32 752 - childregs->gpr[2] = (unsigned long) p; 753 - #else 752 + #ifdef CONFIG_PPC64 753 + childregs->gpr[14] = *(unsigned long *)usp; 754 + childregs->gpr[2] = ((unsigned long *)usp)[1], 754 755 clear_tsk_thread_flag(p, TIF_32BIT); 756 + #else 757 + childregs->gpr[14] = usp; /* function */ 758 + childregs->gpr[2] = (unsigned long) p; 755 759 #endif 760 + childregs->gpr[15] = arg; 756 761 p->thread.regs = NULL; /* no user register state */ 762 + f = ret_from_kernel_thread; 757 763 } else { 764 + CHECK_FULL_REGS(regs); 765 + *childregs = *regs; 758 766 childregs->gpr[1] = usp; 759 767 p->thread.regs = childregs; 768 + childregs->gpr[3] = 0; /* Result from fork() */ 760 769 if (clone_flags & CLONE_SETTLS) { 761 770 #ifdef CONFIG_PPC64 762 771 if (!is_32bit_task()) ··· 774 765 #endif 775 766 childregs->gpr[2] = childregs->gpr[6]; 776 767 } 768 + 769 + f = ret_from_fork; 777 770 } 778 - childregs->gpr[3] = 0; /* Result from fork() */ 779 771 sp -= STACK_FRAME_OVERHEAD; 780 772 781 773 /* ··· 815 805 p->thread.dscr = current->thread.dscr; 816 806 } 817 807 #endif 818 - 819 808 /* 820 809 * The PPC64 ABI makes use of a TOC to contain function 821 810 * pointers. The function (ret_from_except) is actually a pointer 822 811 * to the TOC entry. The first entry is a pointer to the actual 823 812 * function. 824 - */ 813 + */ 825 814 #ifdef CONFIG_PPC64 826 - kregs->nip = *((unsigned long *)ret_from_fork); 815 + kregs->nip = *((unsigned long *)f); 827 816 #else 828 - kregs->nip = (unsigned long)ret_from_fork; 817 + kregs->nip = (unsigned long)f; 829 818 #endif 830 - 831 819 return 0; 832 820 } 833 821 ··· 1063 1055 regs, 0, NULL, NULL); 1064 1056 } 1065 1057 1066 - int sys_execve(unsigned long a0, unsigned long a1, unsigned long a2, 1067 - unsigned long a3, unsigned long a4, unsigned long a5, 1068 - struct pt_regs *regs) 1069 - { 1070 - int error; 1071 - char *filename; 1058 + void __ret_from_kernel_execve(struct pt_regs *normal) 1059 + __noreturn; 1072 1060 1073 - filename = getname((const char __user *) a0); 1074 - error = PTR_ERR(filename); 1075 - if (IS_ERR(filename)) 1076 - goto out; 1077 - flush_fp_to_thread(current); 1078 - flush_altivec_to_thread(current); 1079 - flush_spe_to_thread(current); 1080 - error = do_execve(filename, 1081 - (const char __user *const __user *) a1, 1082 - (const char __user *const __user *) a2, regs); 1083 - putname(filename); 1084 - out: 1085 - return error; 1061 + void ret_from_kernel_execve(struct pt_regs *normal) 1062 + { 1063 + set_thread_flag(TIF_RESTOREALL); 1064 + __ret_from_kernel_execve(normal); 1086 1065 } 1087 1066 1088 1067 static inline int valid_irq_stack(unsigned long sp, struct task_struct *p,
-1
arch/powerpc/kernel/signal_32.c
··· 35 35 #include <linux/stddef.h> 36 36 #include <linux/tty.h> 37 37 #include <linux/binfmts.h> 38 - #include <linux/freezer.h> 39 38 #endif 40 39 41 40 #include <asm/uaccess.h>
-22
arch/powerpc/kernel/sys_ppc32.c
··· 156 156 (off_t __user *)offset, count); 157 157 } 158 158 159 - long compat_sys_execve(unsigned long a0, unsigned long a1, unsigned long a2, 160 - unsigned long a3, unsigned long a4, unsigned long a5, 161 - struct pt_regs *regs) 162 - { 163 - int error; 164 - char * filename; 165 - 166 - filename = getname((char __user *) a0); 167 - error = PTR_ERR(filename); 168 - if (IS_ERR(filename)) 169 - goto out; 170 - flush_fp_to_thread(current); 171 - flush_altivec_to_thread(current); 172 - 173 - error = compat_do_execve(filename, compat_ptr(a1), compat_ptr(a2), regs); 174 - 175 - putname(filename); 176 - 177 - out: 178 - return error; 179 - } 180 - 181 159 /* Note: it is necessary to treat option as an unsigned int, 182 160 * with the corresponding cast to a signed int to insure that the 183 161 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
-4
arch/s390/include/asm/thread_info.h
··· 91 91 #define TIF_SYSCALL_AUDIT 9 /* syscall auditing active */ 92 92 #define TIF_SECCOMP 10 /* secure computing */ 93 93 #define TIF_SYSCALL_TRACEPOINT 11 /* syscall tracepoint instrumentation */ 94 - #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling 95 - TIF_NEED_RESCHED */ 96 94 #define TIF_31BIT 17 /* 32bit process */ 97 95 #define TIF_MEMDIE 18 /* is terminating due to OOM killer */ 98 96 #define TIF_RESTORE_SIGMASK 19 /* restore signal mask in do_signal() */ ··· 98 100 99 101 #define _TIF_SYSCALL (1<<TIF_SYSCALL) 100 102 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 101 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 102 103 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 103 104 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 104 105 #define _TIF_PER_TRAP (1<<TIF_PER_TRAP) ··· 106 109 #define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) 107 110 #define _TIF_SECCOMP (1<<TIF_SECCOMP) 108 111 #define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT) 109 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 110 112 #define _TIF_31BIT (1<<TIF_31BIT) 111 113 #define _TIF_SINGLE_STEP (1<<TIF_SINGLE_STEP) 112 114
-4
arch/score/include/asm/thread_info.h
··· 86 86 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 87 87 #define TIF_NOTIFY_RESUME 5 /* callback before returning to user */ 88 88 #define TIF_RESTORE_SIGMASK 9 /* restore signal mask in do_signal() */ 89 - #define TIF_POLLING_NRFLAG 17 /* true if poll_idle() is polling 90 - TIF_NEED_RESCHED */ 91 89 #define TIF_MEMDIE 18 /* is terminating due to OOM killer */ 92 90 93 91 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 94 92 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 95 93 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 96 94 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 97 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 98 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 99 95 100 96 #define _TIF_WORK_MASK (0x0000ffff) 101 97
+1
arch/score/kernel/signal.c
··· 174 174 /* It is more difficult to avoid calling this function than to 175 175 call it and ignore errors. */ 176 176 do_sigaltstack((stack_t __user *)&st, NULL, regs->regs[0]); 177 + regs->is_syscall = 0; 177 178 178 179 __asm__ __volatile__( 179 180 "mv\tr0, %0\n\t"
+3
arch/sh/include/asm/thread_info.h
··· 206 206 ti->status &= ~TS_RESTORE_SIGMASK; 207 207 return true; 208 208 } 209 + 210 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 211 + 209 212 #endif /* !__ASSEMBLY__ */ 210 213 211 214 #endif /* __KERNEL__ */
-1
arch/sh/kernel/signal_32.c
··· 22 22 #include <linux/elf.h> 23 23 #include <linux/personality.h> 24 24 #include <linux/binfmts.h> 25 - #include <linux/freezer.h> 26 25 #include <linux/io.h> 27 26 #include <linux/tracehook.h> 28 27 #include <asm/ucontext.h>
-1
arch/sh/kernel/signal_64.c
··· 18 18 #include <linux/errno.h> 19 19 #include <linux/wait.h> 20 20 #include <linux/personality.h> 21 - #include <linux/freezer.h> 22 21 #include <linux/ptrace.h> 23 22 #include <linux/unistd.h> 24 23 #include <linux/stddef.h>
+2 -1
arch/sparc/include/asm/thread_info_32.h
··· 126 126 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 127 127 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 128 128 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 129 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 130 129 #define _TIF_USEDFPU (1<<TIF_USEDFPU) 131 130 #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 132 131 133 132 #define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | \ 134 133 _TIF_SIGPENDING) 134 + 135 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 135 136 136 137 #endif /* __KERNEL__ */ 137 138
+3
arch/sparc/include/asm/thread_info_64.h
··· 256 256 ti->status &= ~TS_RESTORE_SIGMASK; 257 257 return true; 258 258 } 259 + 260 + #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 261 + 259 262 #endif /* !__ASSEMBLY__ */ 260 263 261 264 #endif /* __KERNEL__ */
-9
arch/tile/kernel/compat_signal.c
··· 354 354 regs->regs[1] = ptr_to_compat_reg(&frame->info); 355 355 regs->regs[2] = ptr_to_compat_reg(&frame->uc); 356 356 regs->flags |= PT_FLAGS_CALLER_SAVES; 357 - 358 - /* 359 - * Notify any tracer that was single-stepping it. 360 - * The tracer may want to single-step inside the 361 - * handler too. 362 - */ 363 - if (test_thread_flag(TIF_SINGLESTEP)) 364 - ptrace_notify(SIGTRAP); 365 - 366 357 return 0; 367 358 368 359 give_sigsegv:
+2 -10
arch/tile/kernel/signal.c
··· 219 219 regs->regs[1] = (unsigned long) &frame->info; 220 220 regs->regs[2] = (unsigned long) &frame->uc; 221 221 regs->flags |= PT_FLAGS_CALLER_SAVES; 222 - 223 - /* 224 - * Notify any tracer that was single-stepping it. 225 - * The tracer may want to single-step inside the 226 - * handler too. 227 - */ 228 - if (test_thread_flag(TIF_SINGLESTEP)) 229 - ptrace_notify(SIGTRAP); 230 - 231 222 return 0; 232 223 233 224 give_sigsegv: ··· 269 278 ret = setup_rt_frame(sig, ka, info, oldset, regs); 270 279 if (ret) 271 280 return; 272 - signal_delivered(sig, info, ka, regs, 0); 281 + signal_delivered(sig, info, ka, regs, 282 + test_thread_flag(TIF_SINGLESTEP)); 273 283 } 274 284 275 285 /*
-3
arch/um/include/asm/thread_info.h
··· 65 65 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 66 66 #define TIF_SIGPENDING 1 /* signal pending */ 67 67 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 68 - #define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling 69 - * TIF_NEED_RESCHED */ 70 68 #define TIF_RESTART_BLOCK 4 71 69 #define TIF_MEMDIE 5 /* is terminating due to OOM killer */ 72 70 #define TIF_SYSCALL_AUDIT 6 ··· 74 76 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) 75 77 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) 76 78 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 77 - #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) 78 79 #define _TIF_MEMDIE (1 << TIF_MEMDIE) 79 80 #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) 80 81
+2 -2
arch/unicore32/include/asm/thread_info.h
··· 141 141 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) 142 142 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) 143 143 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) 144 - #define _TIF_RESTORE_SIGMASK (1 << TIF_RESTORE_SIGMASK) 145 144 146 145 /* 147 146 * Change these and you break ASM code in entry-common.S 148 147 */ 149 - #define _TIF_WORK_MASK 0x000000ff 148 + #define _TIF_WORK_MASK \ 149 + (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_NOTIFY_RESUME) 150 150 151 151 #endif /* __KERNEL__ */ 152 152 #endif /* __UNICORE_THREAD_INFO_H__ */
-2
arch/unicore32/kernel/entry.S
··· 544 544 work_pending: 545 545 cand.a r1, #_TIF_NEED_RESCHED 546 546 bne work_resched 547 - cand.a r1, #_TIF_SIGPENDING|_TIF_NOTIFY_RESUME 548 - beq no_work_pending 549 547 mov r0, sp @ 'regs' 550 548 mov r2, why @ 'syscall' 551 549 cand.a r1, #_TIF_SIGPENDING @ delivering a signal?
-1
arch/unicore32/kernel/signal.c
··· 12 12 #include <linux/errno.h> 13 13 #include <linux/signal.h> 14 14 #include <linux/personality.h> 15 - #include <linux/freezer.h> 16 15 #include <linux/uaccess.h> 17 16 #include <linux/tracehook.h> 18 17 #include <linux/elf.h>
+11 -16
arch/x86/kernel/entry_32.S
··· 622 622 movl %esp, %eax 623 623 jne work_notifysig_v86 # returning to kernel-space or 624 624 # vm86-space 625 - TRACE_IRQS_ON 626 - ENABLE_INTERRUPTS(CLBR_NONE) 627 - movb PT_CS(%esp), %bl 628 - andb $SEGMENT_RPL_MASK, %bl 629 - cmpb $USER_RPL, %bl 630 - jb resume_kernel 631 - xorl %edx, %edx 632 - call do_notify_resume 633 - jmp resume_userspace 634 - 635 - ALIGN 636 - work_notifysig_v86: 637 - pushl_cfi %ecx # save ti_flags for do_notify_resume 638 - call save_v86_state # %eax contains pt_regs pointer 639 - popl_cfi %ecx 640 - movl %eax, %esp 625 + 1: 641 626 #else 642 627 movl %esp, %eax 643 628 #endif ··· 635 650 xorl %edx, %edx 636 651 call do_notify_resume 637 652 jmp resume_userspace 653 + 654 + #ifdef CONFIG_VM86 655 + ALIGN 656 + work_notifysig_v86: 657 + pushl_cfi %ecx # save ti_flags for do_notify_resume 658 + call save_v86_state # %eax contains pt_regs pointer 659 + popl_cfi %ecx 660 + movl %eax, %esp 661 + jmp 1b 662 + #endif 638 663 END(work_pending) 639 664 640 665 # perform syscall exit tracing
-5
arch/xtensa/include/asm/thread_info.h
··· 128 128 #define TIF_SIGPENDING 1 /* signal pending */ 129 129 #define TIF_NEED_RESCHED 2 /* rescheduling necessary */ 130 130 #define TIF_SINGLESTEP 3 /* restore singlestep on return to user mode */ 131 - #define TIF_IRET 4 /* return with iret */ 132 131 #define TIF_MEMDIE 5 /* is terminating due to OOM killer */ 133 132 #define TIF_RESTORE_SIGMASK 6 /* restore signal mask in do_signal() */ 134 133 #define TIF_NOTIFY_RESUME 7 /* callback before returning to user */ 135 - #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ 136 134 137 135 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 138 136 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 139 137 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 140 138 #define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP) 141 - #define _TIF_IRET (1<<TIF_IRET) 142 - #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 143 - #define _TIF_RESTORE_SIGMASK (1<<TIF_RESTORE_SIGMASK) 144 139 145 140 #define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */ 146 141 #define _TIF_ALLWORK_MASK 0x0000FFFF /* work to do on any return to u-space */
-4
arch/xtensa/kernel/signal.c
··· 19 19 #include <linux/errno.h> 20 20 #include <linux/ptrace.h> 21 21 #include <linux/personality.h> 22 - #include <linux/freezer.h> 23 22 #include <linux/tracehook.h> 24 23 25 24 #include <asm/ucontext.h> ··· 526 527 527 528 void do_notify_resume(struct pt_regs *regs) 528 529 { 529 - if (!user_mode(regs)) 530 - return; 531 - 532 530 if (test_thread_flag(TIF_SIGPENDING)) 533 531 do_signal(regs); 534 532
+1 -1
kernel/sched/core.c
··· 505 505 #ifdef CONFIG_SMP 506 506 507 507 #ifndef tsk_is_polling 508 - #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG) 508 + #define tsk_is_polling(t) 0 509 509 #endif 510 510 511 511 void resched_task(struct task_struct *p)