Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 1 | /* thread_info.h: low-level thread information |
| 2 | * |
| 3 | * Copyright (C) 2002 David Howells (dhowells@redhat.com) |
| 4 | * - Incorporating suggestions made by Linus Torvalds and Dave Miller |
| 5 | */ |
| 6 | |
H. Peter Anvin | 1965aae | 2008-10-22 22:26:29 -0700 | [diff] [blame] | 7 | #ifndef _ASM_X86_THREAD_INFO_H |
| 8 | #define _ASM_X86_THREAD_INFO_H |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 9 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 10 | #include <linux/compiler.h> |
| 11 | #include <asm/page.h> |
Steven Rostedt | 198d208 | 2014-02-06 09:41:31 -0500 | [diff] [blame] | 12 | #include <asm/percpu.h> |
Christoph Lameter | 12a638e | 2008-04-28 18:52:33 -0700 | [diff] [blame] | 13 | #include <asm/types.h> |
| 14 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 15 | /* |
Andy Lutomirski | 3ee4298 | 2015-03-10 11:05:58 -0700 | [diff] [blame] | 16 | * TOP_OF_KERNEL_STACK_PADDING is a number of unused bytes that we |
| 17 | * reserve at the top of the kernel stack. We do it because of a nasty |
| 18 | * 32-bit corner case. On x86_32, the hardware stack frame is |
| 19 | * variable-length. Except for vm86 mode, struct pt_regs assumes a |
| 20 | * maximum-length frame. If we enter from CPL 0, the top 8 bytes of |
| 21 | * pt_regs don't actually exist. Ordinarily this doesn't matter, but it |
| 22 | * does in at least one case: |
| 23 | * |
| 24 | * If we take an NMI early enough in SYSENTER, then we can end up with |
| 25 | * pt_regs that extends above sp0. On the way out, in the espfix code, |
| 26 | * we can read the saved SS value, but that value will be above sp0. |
| 27 | * Without this offset, that can result in a page fault. (We are |
| 28 | * careful that, in this case, the value we read doesn't matter.) |
| 29 | * |
| 30 | * In vm86 mode, the hardware frame is much longer still, but we neither |
| 31 | * access the extra members from NMI context, nor do we write such a |
| 32 | * frame at sp0 at all. |
| 33 | * |
| 34 | * x86_64 has a fixed-length stack frame. |
| 35 | */ |
| 36 | #ifdef CONFIG_X86_32 |
| 37 | # define TOP_OF_KERNEL_STACK_PADDING 8 |
| 38 | #else |
| 39 | # define TOP_OF_KERNEL_STACK_PADDING 0 |
| 40 | #endif |
| 41 | |
| 42 | /* |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 43 | * low level task data that entry.S needs immediate access to |
| 44 | * - this struct should fit entirely inside of one cache line |
| 45 | * - this struct shares the supervisor stack pages |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 46 | */ |
| 47 | #ifndef __ASSEMBLY__ |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 48 | struct task_struct; |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 49 | #include <asm/processor.h> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 50 | #include <linux/atomic.h> |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 51 | |
| 52 | struct thread_info { |
| 53 | struct task_struct *task; /* main task structure */ |
Joe Korty | affa219 | 2008-12-03 18:58:19 -0500 | [diff] [blame] | 54 | __u32 flags; /* low level flags */ |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 55 | __u32 status; /* thread synchronous flags */ |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 56 | __u32 cpu; /* current CPU */ |
Peter Zijlstra | c2daa3b | 2013-08-14 14:51:00 +0200 | [diff] [blame] | 57 | int saved_preempt_count; |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 58 | mm_segment_t addr_limit; |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 59 | void __user *sysenter_return; |
Steven Rostedt | 0788aa6 | 2014-02-06 09:41:30 -0500 | [diff] [blame] | 60 | unsigned int sig_on_uaccess_error:1; |
| 61 | unsigned int uaccess_err:1; /* uaccess failed */ |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 62 | }; |
Christoph Lameter | 3351cc0 | 2008-04-28 18:52:36 -0700 | [diff] [blame] | 63 | |
| 64 | #define INIT_THREAD_INFO(tsk) \ |
| 65 | { \ |
| 66 | .task = &tsk, \ |
Christoph Lameter | 3351cc0 | 2008-04-28 18:52:36 -0700 | [diff] [blame] | 67 | .flags = 0, \ |
| 68 | .cpu = 0, \ |
Peter Zijlstra | c2daa3b | 2013-08-14 14:51:00 +0200 | [diff] [blame] | 69 | .saved_preempt_count = INIT_PREEMPT_COUNT, \ |
Christoph Lameter | 3351cc0 | 2008-04-28 18:52:36 -0700 | [diff] [blame] | 70 | .addr_limit = KERNEL_DS, \ |
Christoph Lameter | 3351cc0 | 2008-04-28 18:52:36 -0700 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | #define init_thread_info (init_thread_union.thread_info) |
| 74 | #define init_stack (init_thread_union.stack) |
| 75 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 76 | #else /* !__ASSEMBLY__ */ |
| 77 | |
| 78 | #include <asm/asm-offsets.h> |
| 79 | |
| 80 | #endif |
| 81 | |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 82 | /* |
| 83 | * thread information flags |
| 84 | * - these are process state flags that various assembly files |
| 85 | * may need to access |
| 86 | * - pending work-to-be-done flags are in LSW |
| 87 | * - other flags in MSW |
| 88 | * Warning: layout of LSW is hardcoded in entry.S |
| 89 | */ |
| 90 | #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ |
Roland McGrath | 59e5213 | 2008-04-19 19:10:57 -0700 | [diff] [blame] | 91 | #define TIF_NOTIFY_RESUME 1 /* callback before returning to user */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 92 | #define TIF_SIGPENDING 2 /* signal pending */ |
| 93 | #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ |
| 94 | #define TIF_SINGLESTEP 4 /* reenable singlestep on user return*/ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 95 | #define TIF_SYSCALL_EMU 6 /* syscall emulation active */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 96 | #define TIF_SYSCALL_AUDIT 7 /* syscall auditing active */ |
| 97 | #define TIF_SECCOMP 8 /* secure computing */ |
Avi Kivity | 7c68af6 | 2009-09-19 09:40:22 +0300 | [diff] [blame] | 98 | #define TIF_USER_RETURN_NOTIFY 11 /* notify kernel of userspace return */ |
Srikar Dronamraju | 0326f5a | 2012-03-13 23:30:11 +0530 | [diff] [blame] | 99 | #define TIF_UPROBE 12 /* breakpointed or singlestepping */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 100 | #define TIF_NOTSC 16 /* TSC is not accessible in userland */ |
H. Peter Anvin | 6bd3300 | 2012-02-06 13:03:09 -0800 | [diff] [blame] | 101 | #define TIF_IA32 17 /* IA32 compatibility process */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 102 | #define TIF_FORK 18 /* ret_from_fork */ |
Frederic Weisbecker | bf5a3c1 | 2012-07-11 20:26:34 +0200 | [diff] [blame] | 103 | #define TIF_NOHZ 19 /* in adaptive nohz mode */ |
Andreas Dilger | 0ddc932 | 2010-05-14 11:13:27 +0200 | [diff] [blame] | 104 | #define TIF_MEMDIE 20 /* is terminating due to OOM killer */ |
Peter Zijlstra | f80c5b3 | 2014-04-11 09:59:05 +0200 | [diff] [blame] | 105 | #define TIF_POLLING_NRFLAG 21 /* idle is polling for TIF_NEED_RESCHED */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 106 | #define TIF_IO_BITMAP 22 /* uses I/O bitmap */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 107 | #define TIF_FORCED_TF 24 /* true if TF in eflags artificially */ |
Peter Zijlstra | ea8e61b | 2010-03-25 14:51:51 +0100 | [diff] [blame] | 108 | #define TIF_BLOCKSTEP 25 /* set when we want DEBUGCTLMSR_BTF */ |
Jeremy Fitzhardinge | b407fc5 | 2009-02-17 23:46:21 -0800 | [diff] [blame] | 109 | #define TIF_LAZY_MMU_UPDATES 27 /* task is updating the mmu lazily */ |
Josh Stone | 6670000 | 2009-08-24 14:43:11 -0700 | [diff] [blame] | 110 | #define TIF_SYSCALL_TRACEPOINT 28 /* syscall tracepoint instrumentation */ |
H. Peter Anvin | 6bd3300 | 2012-02-06 13:03:09 -0800 | [diff] [blame] | 111 | #define TIF_ADDR32 29 /* 32-bit address space on 64 bits */ |
H. Peter Anvin | bb21272 | 2012-02-14 13:56:49 -0800 | [diff] [blame] | 112 | #define TIF_X32 30 /* 32-bit native x86-64 binary */ |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 113 | |
| 114 | #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE) |
Roland McGrath | 59e5213 | 2008-04-19 19:10:57 -0700 | [diff] [blame] | 115 | #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 116 | #define _TIF_SIGPENDING (1 << TIF_SIGPENDING) |
| 117 | #define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP) |
| 118 | #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 119 | #define _TIF_SYSCALL_EMU (1 << TIF_SYSCALL_EMU) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 120 | #define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT) |
| 121 | #define _TIF_SECCOMP (1 << TIF_SECCOMP) |
Avi Kivity | 7c68af6 | 2009-09-19 09:40:22 +0300 | [diff] [blame] | 122 | #define _TIF_USER_RETURN_NOTIFY (1 << TIF_USER_RETURN_NOTIFY) |
Srikar Dronamraju | 0326f5a | 2012-03-13 23:30:11 +0530 | [diff] [blame] | 123 | #define _TIF_UPROBE (1 << TIF_UPROBE) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 124 | #define _TIF_NOTSC (1 << TIF_NOTSC) |
| 125 | #define _TIF_IA32 (1 << TIF_IA32) |
| 126 | #define _TIF_FORK (1 << TIF_FORK) |
Frederic Weisbecker | bf5a3c1 | 2012-07-11 20:26:34 +0200 | [diff] [blame] | 127 | #define _TIF_NOHZ (1 << TIF_NOHZ) |
Peter Zijlstra | f80c5b3 | 2014-04-11 09:59:05 +0200 | [diff] [blame] | 128 | #define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 129 | #define _TIF_IO_BITMAP (1 << TIF_IO_BITMAP) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 130 | #define _TIF_FORCED_TF (1 << TIF_FORCED_TF) |
Peter Zijlstra | ea8e61b | 2010-03-25 14:51:51 +0100 | [diff] [blame] | 131 | #define _TIF_BLOCKSTEP (1 << TIF_BLOCKSTEP) |
Jeremy Fitzhardinge | b407fc5 | 2009-02-17 23:46:21 -0800 | [diff] [blame] | 132 | #define _TIF_LAZY_MMU_UPDATES (1 << TIF_LAZY_MMU_UPDATES) |
Josh Stone | 6670000 | 2009-08-24 14:43:11 -0700 | [diff] [blame] | 133 | #define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT) |
H. Peter Anvin | 6bd3300 | 2012-02-06 13:03:09 -0800 | [diff] [blame] | 134 | #define _TIF_ADDR32 (1 << TIF_ADDR32) |
H. Peter Anvin | bb21272 | 2012-02-14 13:56:49 -0800 | [diff] [blame] | 135 | #define _TIF_X32 (1 << TIF_X32) |
Christoph Lameter | e57549b | 2008-04-28 18:52:38 -0700 | [diff] [blame] | 136 | |
Roland McGrath | d4d6715 | 2008-07-09 02:38:07 -0700 | [diff] [blame] | 137 | /* work to do in syscall_trace_enter() */ |
| 138 | #define _TIF_WORK_SYSCALL_ENTRY \ |
Josh Stone | 6670000 | 2009-08-24 14:43:11 -0700 | [diff] [blame] | 139 | (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_EMU | _TIF_SYSCALL_AUDIT | \ |
Frederic Weisbecker | bf5a3c1 | 2012-07-11 20:26:34 +0200 | [diff] [blame] | 140 | _TIF_SECCOMP | _TIF_SINGLESTEP | _TIF_SYSCALL_TRACEPOINT | \ |
| 141 | _TIF_NOHZ) |
Roland McGrath | d4d6715 | 2008-07-09 02:38:07 -0700 | [diff] [blame] | 142 | |
| 143 | /* work to do in syscall_trace_leave() */ |
| 144 | #define _TIF_WORK_SYSCALL_EXIT \ |
Frederic Weisbecker | 1b3fa2ce | 2009-03-07 05:53:00 +0100 | [diff] [blame] | 145 | (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SINGLESTEP | \ |
Frederic Weisbecker | bf5a3c1 | 2012-07-11 20:26:34 +0200 | [diff] [blame] | 146 | _TIF_SYSCALL_TRACEPOINT | _TIF_NOHZ) |
Roland McGrath | d4d6715 | 2008-07-09 02:38:07 -0700 | [diff] [blame] | 147 | |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 148 | /* work to do on interrupt/exception return */ |
| 149 | #define _TIF_WORK_MASK \ |
| 150 | (0x0000FFFF & \ |
Roland McGrath | 64f0973 | 2008-07-09 01:33:14 -0700 | [diff] [blame] | 151 | ~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT| \ |
Roland McGrath | d4d6715 | 2008-07-09 02:38:07 -0700 | [diff] [blame] | 152 | _TIF_SINGLESTEP|_TIF_SECCOMP|_TIF_SYSCALL_EMU)) |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 153 | |
| 154 | /* work to do on any return to user space */ |
Josh Stone | 6670000 | 2009-08-24 14:43:11 -0700 | [diff] [blame] | 155 | #define _TIF_ALLWORK_MASK \ |
Frederic Weisbecker | bf5a3c1 | 2012-07-11 20:26:34 +0200 | [diff] [blame] | 156 | ((0x0000FFFF & ~_TIF_SECCOMP) | _TIF_SYSCALL_TRACEPOINT | \ |
| 157 | _TIF_NOHZ) |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 158 | |
Christoph Lameter | b84200b | 2008-04-28 18:52:40 -0700 | [diff] [blame] | 159 | /* Only used for 64 bit */ |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 160 | #define _TIF_DO_NOTIFY_MASK \ |
Luck, Tony | d4812e1 | 2015-01-05 16:44:42 -0800 | [diff] [blame] | 161 | (_TIF_SIGPENDING | _TIF_NOTIFY_RESUME | \ |
Andy Lutomirski | 82975bc | 2014-11-21 13:26:07 -0800 | [diff] [blame] | 162 | _TIF_USER_RETURN_NOTIFY | _TIF_UPROBE) |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 163 | |
| 164 | /* flags to check in __switch_to() */ |
| 165 | #define _TIF_WORK_CTXSW \ |
Peter Zijlstra | ea8e61b | 2010-03-25 14:51:51 +0100 | [diff] [blame] | 166 | (_TIF_IO_BITMAP|_TIF_NOTSC|_TIF_BLOCKSTEP) |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 167 | |
Avi Kivity | 7c68af6 | 2009-09-19 09:40:22 +0300 | [diff] [blame] | 168 | #define _TIF_WORK_CTXSW_PREV (_TIF_WORK_CTXSW|_TIF_USER_RETURN_NOTIFY) |
Oleg Nesterov | 37f0765 | 2013-07-03 15:08:11 -0700 | [diff] [blame] | 169 | #define _TIF_WORK_CTXSW_NEXT (_TIF_WORK_CTXSW) |
Christoph Lameter | 00c1bb1 | 2008-04-28 18:52:39 -0700 | [diff] [blame] | 170 | |
Steven Rostedt | 198d208 | 2014-02-06 09:41:31 -0500 | [diff] [blame] | 171 | #define STACK_WARN (THREAD_SIZE/8) |
Christoph Lameter | 006c484 | 2008-04-28 18:52:35 -0700 | [diff] [blame] | 172 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 173 | /* |
| 174 | * macros/functions for gaining access to the thread information structure |
| 175 | * |
| 176 | * preempt_count needs to be 1 initially, until the scheduler is functional. |
| 177 | */ |
| 178 | #ifndef __ASSEMBLY__ |
| 179 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 180 | static inline struct thread_info *current_thread_info(void) |
| 181 | { |
Andy Lutomirski | a7fcf28 | 2015-03-06 17:50:19 -0800 | [diff] [blame] | 182 | return (struct thread_info *)(current_top_of_stack() - THREAD_SIZE); |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 183 | } |
| 184 | |
Andy Lutomirski | 83653c1 | 2014-11-13 15:57:07 -0800 | [diff] [blame] | 185 | static inline unsigned long current_stack_pointer(void) |
| 186 | { |
| 187 | unsigned long sp; |
| 188 | #ifdef CONFIG_X86_64 |
| 189 | asm("mov %%rsp,%0" : "=g" (sp)); |
| 190 | #else |
| 191 | asm("mov %%esp,%0" : "=g" (sp)); |
| 192 | #endif |
| 193 | return sp; |
| 194 | } |
| 195 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 196 | #else /* !__ASSEMBLY__ */ |
| 197 | |
Denys Vlasenko | 3a23208 | 2015-04-24 17:31:35 +0200 | [diff] [blame] | 198 | #ifdef CONFIG_X86_64 |
| 199 | # define cpu_current_top_of_stack (cpu_tss + TSS_sp0) |
| 200 | #endif |
| 201 | |
Denys Vlasenko | ef59326 | 2015-03-19 18:17:46 +0100 | [diff] [blame] | 202 | /* Load thread_info address into "reg" */ |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 203 | #define GET_THREAD_INFO(reg) \ |
Denys Vlasenko | 63332a8 | 2015-04-24 17:31:33 +0200 | [diff] [blame] | 204 | _ASM_MOV PER_CPU_VAR(cpu_current_top_of_stack),reg ; \ |
Denys Vlasenko | ef59326 | 2015-03-19 18:17:46 +0100 | [diff] [blame] | 205 | _ASM_SUB $(THREAD_SIZE),reg ; |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 206 | |
Jan Beulich | 46db09d | 2011-11-29 11:17:45 +0000 | [diff] [blame] | 207 | /* |
Ingo Molnar | 1ddc6f3 | 2015-03-24 19:43:11 +0100 | [diff] [blame] | 208 | * ASM operand which evaluates to a 'thread_info' address of |
| 209 | * the current task, if it is known that "reg" is exactly "off" |
| 210 | * bytes below the top of the stack currently. |
| 211 | * |
| 212 | * ( The kernel stack's size is known at build time, it is usually |
| 213 | * 2 or 4 pages, and the bottom of the kernel stack contains |
| 214 | * the thread_info structure. So to access the thread_info very |
| 215 | * quickly from assembly code we can calculate down from the |
| 216 | * top of the kernel stack to the bottom, using constant, |
| 217 | * build-time calculations only. ) |
| 218 | * |
| 219 | * For example, to fetch the current thread_info->flags value into %eax |
| 220 | * on x86-64 defconfig kernels, in syscall entry code where RSP is |
| 221 | * currently at exactly SIZEOF_PTREGS bytes away from the top of the |
| 222 | * stack: |
| 223 | * |
Ingo Molnar | dca5b52 | 2015-03-24 19:44:42 +0100 | [diff] [blame] | 224 | * mov ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS), %eax |
Ingo Molnar | 1ddc6f3 | 2015-03-24 19:43:11 +0100 | [diff] [blame] | 225 | * |
| 226 | * will translate to: |
| 227 | * |
| 228 | * 8b 84 24 b8 c0 ff ff mov -0x3f48(%rsp), %eax |
| 229 | * |
| 230 | * which is below the current RSP by almost 16K. |
Jan Beulich | 46db09d | 2011-11-29 11:17:45 +0000 | [diff] [blame] | 231 | */ |
Ingo Molnar | dca5b52 | 2015-03-24 19:44:42 +0100 | [diff] [blame] | 232 | #define ASM_THREAD_INFO(field, reg, off) ((field)+(off)-THREAD_SIZE)(reg) |
Jan Beulich | 46db09d | 2011-11-29 11:17:45 +0000 | [diff] [blame] | 233 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 234 | #endif |
| 235 | |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 236 | /* |
| 237 | * Thread-synchronous status. |
| 238 | * |
| 239 | * This is different from the flags in that nobody else |
| 240 | * ever touches our thread-synchronous status, so we don't |
| 241 | * have to worry about atomic accesses. |
| 242 | */ |
Christoph Lameter | f2ea3b1 | 2008-04-28 18:52:34 -0700 | [diff] [blame] | 243 | #define TS_COMPAT 0x0002 /* 32bit syscall active (64BIT)*/ |
Ingo Molnar | 8a6c160 | 2008-04-30 22:13:44 +0200 | [diff] [blame] | 244 | #define TS_RESTORE_SIGMASK 0x0008 /* restore signal mask in do_signal() */ |
Christoph Lameter | 2052e8d | 2008-05-12 15:43:41 +0200 | [diff] [blame] | 245 | |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 246 | #ifndef __ASSEMBLY__ |
Ingo Molnar | 8a6c160 | 2008-04-30 22:13:44 +0200 | [diff] [blame] | 247 | #define HAVE_SET_RESTORE_SIGMASK 1 |
| 248 | static inline void set_restore_sigmask(void) |
| 249 | { |
| 250 | struct thread_info *ti = current_thread_info(); |
| 251 | ti->status |= TS_RESTORE_SIGMASK; |
Al Viro | edd63a2 | 2012-04-27 13:42:45 -0400 | [diff] [blame] | 252 | WARN_ON(!test_bit(TIF_SIGPENDING, (unsigned long *)&ti->flags)); |
Ingo Molnar | 8a6c160 | 2008-04-30 22:13:44 +0200 | [diff] [blame] | 253 | } |
Al Viro | 4ebefe3 | 2012-04-26 22:29:20 -0400 | [diff] [blame] | 254 | static inline void clear_restore_sigmask(void) |
| 255 | { |
| 256 | current_thread_info()->status &= ~TS_RESTORE_SIGMASK; |
| 257 | } |
| 258 | static inline bool test_restore_sigmask(void) |
| 259 | { |
| 260 | return current_thread_info()->status & TS_RESTORE_SIGMASK; |
| 261 | } |
| 262 | static inline bool test_and_clear_restore_sigmask(void) |
| 263 | { |
| 264 | struct thread_info *ti = current_thread_info(); |
| 265 | if (!(ti->status & TS_RESTORE_SIGMASK)) |
| 266 | return false; |
| 267 | ti->status &= ~TS_RESTORE_SIGMASK; |
| 268 | return true; |
| 269 | } |
Srikar Dronamraju | ef334a2 | 2012-03-13 19:33:03 +0530 | [diff] [blame] | 270 | |
| 271 | static inline bool is_ia32_task(void) |
| 272 | { |
| 273 | #ifdef CONFIG_X86_32 |
| 274 | return true; |
| 275 | #endif |
| 276 | #ifdef CONFIG_IA32_EMULATION |
| 277 | if (current_thread_info()->status & TS_COMPAT) |
| 278 | return true; |
| 279 | #endif |
| 280 | return false; |
| 281 | } |
Brian Gerst | 1daeaa3 | 2015-03-21 18:54:21 -0400 | [diff] [blame] | 282 | |
| 283 | /* |
| 284 | * Force syscall return via IRET by making it look as if there was |
| 285 | * some work pending. IRET is our most capable (but slowest) syscall |
| 286 | * return path, which is able to restore modified SS, CS and certain |
| 287 | * EFLAGS values that other (fast) syscall return instructions |
| 288 | * are not able to restore properly. |
| 289 | */ |
| 290 | #define force_iret() set_thread_flag(TIF_NOTIFY_RESUME) |
| 291 | |
Ingo Molnar | 8a6c160 | 2008-04-30 22:13:44 +0200 | [diff] [blame] | 292 | #endif /* !__ASSEMBLY__ */ |
| 293 | |
| 294 | #ifndef __ASSEMBLY__ |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 295 | extern void arch_task_cache_init(void); |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 296 | extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src); |
Thomas Gleixner | 38e7c57 | 2012-05-05 15:05:42 +0000 | [diff] [blame] | 297 | extern void arch_release_task_struct(struct task_struct *tsk); |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 298 | #endif |
H. Peter Anvin | 1965aae | 2008-10-22 22:26:29 -0700 | [diff] [blame] | 299 | #endif /* _ASM_X86_THREAD_INFO_H */ |