Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit edaad4aaa088d31a4a25ecc4a4df8b95579572b4

Authored by David S. Miller
Committed by Greg Kroah-Hartman
1 parent b22e085738

sparc64: Do not define thread fpregs save area as zero-length array. 

[ Upstream commit e2653143d7d79a49f1a961aeae1d82612838b12c ]

This breaks the stack end corruption detection facility.

What that facility does it write a magic value to "end_of_stack()"
and checking to see if it gets overwritten.

"end_of_stack()" is "task_thread_info(p) + 1", which for sparc64 is
the beginning of the FPU register save area.

So once the user uses the FPU, the magic value is overwritten and the
debug checks trigger.

Fix this by making the size explicit.

Due to the size we use for the fpsaved[], gsr[], and xfsr[] arrays we
are limited to 7 levels of FPU state saves.  So each FPU register set
is 256 bytes, allocate 256 * 7 for the fpregs area.

Reported-by: Meelis Roos <mroos@linux.ee>
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 2 additions and 1 deletions Inline Diff

arch/sparc/include/asm/thread_info_64.h
Diff comments   View file @ edaad4a
1 /* thread_info.h: sparc64 low-level thread information 1 /* thread_info.h: sparc64 low-level thread information
2 * 2 *
3 * Copyright (C) 2002 David S. Miller (davem@redhat.com) 3 * Copyright (C) 2002 David S. Miller (davem@redhat.com)
4 */ 4 */
5 5
6 #ifndef _ASM_THREAD_INFO_H 6 #ifndef _ASM_THREAD_INFO_H
7 #define _ASM_THREAD_INFO_H 7 #define _ASM_THREAD_INFO_H
8 8
9 #ifdef __KERNEL__ 9 #ifdef __KERNEL__
10 10
11 #define NSWINS 7 11 #define NSWINS 7
12 12
13 #define TI_FLAG_BYTE_FAULT_CODE 0 13 #define TI_FLAG_BYTE_FAULT_CODE 0
14 #define TI_FLAG_FAULT_CODE_SHIFT 56 14 #define TI_FLAG_FAULT_CODE_SHIFT 56
15 #define TI_FLAG_BYTE_WSTATE 1 15 #define TI_FLAG_BYTE_WSTATE 1
16 #define TI_FLAG_WSTATE_SHIFT 48 16 #define TI_FLAG_WSTATE_SHIFT 48
17 #define TI_FLAG_BYTE_NOERROR 2 17 #define TI_FLAG_BYTE_NOERROR 2
18 #define TI_FLAG_BYTE_NOERROR_SHIFT 40 18 #define TI_FLAG_BYTE_NOERROR_SHIFT 40
19 #define TI_FLAG_BYTE_FPDEPTH 3 19 #define TI_FLAG_BYTE_FPDEPTH 3
20 #define TI_FLAG_FPDEPTH_SHIFT 32 20 #define TI_FLAG_FPDEPTH_SHIFT 32
21 #define TI_FLAG_BYTE_CWP 4 21 #define TI_FLAG_BYTE_CWP 4
22 #define TI_FLAG_CWP_SHIFT 24 22 #define TI_FLAG_CWP_SHIFT 24
23 #define TI_FLAG_BYTE_WSAVED 5 23 #define TI_FLAG_BYTE_WSAVED 5
24 #define TI_FLAG_WSAVED_SHIFT 16 24 #define TI_FLAG_WSAVED_SHIFT 16
25 25
26 #include <asm/page.h> 26 #include <asm/page.h>
27 27
28 #ifndef __ASSEMBLY__ 28 #ifndef __ASSEMBLY__
29 29
30 #include <asm/ptrace.h> 30 #include <asm/ptrace.h>
31 #include <asm/types.h> 31 #include <asm/types.h>
32 32
33 struct task_struct; 33 struct task_struct;
34 struct exec_domain; 34 struct exec_domain;
35 35
36 struct thread_info { 36 struct thread_info {
37 /* D$ line 1 */ 37 /* D$ line 1 */
38 struct task_struct *task; 38 struct task_struct *task;
39 unsigned long flags; 39 unsigned long flags;
40 __u8 fpsaved[7]; 40 __u8 fpsaved[7];
41 __u8 status; 41 __u8 status;
42 unsigned long ksp; 42 unsigned long ksp;
43 43
44 /* D$ line 2 */ 44 /* D$ line 2 */
45 unsigned long fault_address; 45 unsigned long fault_address;
46 struct pt_regs *kregs; 46 struct pt_regs *kregs;
47 struct exec_domain *exec_domain; 47 struct exec_domain *exec_domain;
48 int preempt_count; /* 0 => preemptable, <0 => BUG */ 48 int preempt_count; /* 0 => preemptable, <0 => BUG */
49 __u8 new_child; 49 __u8 new_child;
50 __u8 current_ds; 50 __u8 current_ds;
51 __u16 cpu; 51 __u16 cpu;
52 52
53 unsigned long *utraps; 53 unsigned long *utraps;
54 54
55 struct reg_window reg_window[NSWINS]; 55 struct reg_window reg_window[NSWINS];
56 unsigned long rwbuf_stkptrs[NSWINS]; 56 unsigned long rwbuf_stkptrs[NSWINS];
57 57
58 unsigned long gsr[7]; 58 unsigned long gsr[7];
59 unsigned long xfsr[7]; 59 unsigned long xfsr[7];
60 60
61 struct restart_block restart_block; 61 struct restart_block restart_block;
62 62
63 struct pt_regs *kern_una_regs; 63 struct pt_regs *kern_una_regs;
64 unsigned int kern_una_insn; 64 unsigned int kern_una_insn;
65 65
66 unsigned long fpregs[0] __attribute__ ((aligned(64))); 66 unsigned long fpregs[(7 * 256) / sizeof(unsigned long)]
67 __attribute__ ((aligned(64)));
67 }; 68 };
68 69
69 #endif /* !(__ASSEMBLY__) */ 70 #endif /* !(__ASSEMBLY__) */
70 71
71 /* offsets into the thread_info struct for assembly code access */ 72 /* offsets into the thread_info struct for assembly code access */
72 #define TI_TASK 0x00000000 73 #define TI_TASK 0x00000000
73 #define TI_FLAGS 0x00000008 74 #define TI_FLAGS 0x00000008
74 #define TI_FAULT_CODE (TI_FLAGS + TI_FLAG_BYTE_FAULT_CODE) 75 #define TI_FAULT_CODE (TI_FLAGS + TI_FLAG_BYTE_FAULT_CODE)
75 #define TI_WSTATE (TI_FLAGS + TI_FLAG_BYTE_WSTATE) 76 #define TI_WSTATE (TI_FLAGS + TI_FLAG_BYTE_WSTATE)
76 #define TI_CWP (TI_FLAGS + TI_FLAG_BYTE_CWP) 77 #define TI_CWP (TI_FLAGS + TI_FLAG_BYTE_CWP)
77 #define TI_FPDEPTH (TI_FLAGS + TI_FLAG_BYTE_FPDEPTH) 78 #define TI_FPDEPTH (TI_FLAGS + TI_FLAG_BYTE_FPDEPTH)
78 #define TI_WSAVED (TI_FLAGS + TI_FLAG_BYTE_WSAVED) 79 #define TI_WSAVED (TI_FLAGS + TI_FLAG_BYTE_WSAVED)
79 #define TI_SYS_NOERROR (TI_FLAGS + TI_FLAG_BYTE_NOERROR) 80 #define TI_SYS_NOERROR (TI_FLAGS + TI_FLAG_BYTE_NOERROR)
80 #define TI_FPSAVED 0x00000010 81 #define TI_FPSAVED 0x00000010
81 #define TI_KSP 0x00000018 82 #define TI_KSP 0x00000018
82 #define TI_FAULT_ADDR 0x00000020 83 #define TI_FAULT_ADDR 0x00000020
83 #define TI_KREGS 0x00000028 84 #define TI_KREGS 0x00000028
84 #define TI_EXEC_DOMAIN 0x00000030 85 #define TI_EXEC_DOMAIN 0x00000030
85 #define TI_PRE_COUNT 0x00000038 86 #define TI_PRE_COUNT 0x00000038
86 #define TI_NEW_CHILD 0x0000003c 87 #define TI_NEW_CHILD 0x0000003c
87 #define TI_CURRENT_DS 0x0000003d 88 #define TI_CURRENT_DS 0x0000003d
88 #define TI_CPU 0x0000003e 89 #define TI_CPU 0x0000003e
89 #define TI_UTRAPS 0x00000040 90 #define TI_UTRAPS 0x00000040
90 #define TI_REG_WINDOW 0x00000048 91 #define TI_REG_WINDOW 0x00000048
91 #define TI_RWIN_SPTRS 0x000003c8 92 #define TI_RWIN_SPTRS 0x000003c8
92 #define TI_GSR 0x00000400 93 #define TI_GSR 0x00000400
93 #define TI_XFSR 0x00000438 94 #define TI_XFSR 0x00000438
94 #define TI_RESTART_BLOCK 0x00000470 95 #define TI_RESTART_BLOCK 0x00000470
95 #define TI_KUNA_REGS 0x000004a0 96 #define TI_KUNA_REGS 0x000004a0
96 #define TI_KUNA_INSN 0x000004a8 97 #define TI_KUNA_INSN 0x000004a8
97 #define TI_FPREGS 0x000004c0 98 #define TI_FPREGS 0x000004c0
98 99
99 /* We embed this in the uppermost byte of thread_info->flags */ 100 /* We embed this in the uppermost byte of thread_info->flags */
100 #define FAULT_CODE_WRITE 0x01 /* Write access, implies D-TLB */ 101 #define FAULT_CODE_WRITE 0x01 /* Write access, implies D-TLB */
101 #define FAULT_CODE_DTLB 0x02 /* Miss happened in D-TLB */ 102 #define FAULT_CODE_DTLB 0x02 /* Miss happened in D-TLB */
102 #define FAULT_CODE_ITLB 0x04 /* Miss happened in I-TLB */ 103 #define FAULT_CODE_ITLB 0x04 /* Miss happened in I-TLB */
103 #define FAULT_CODE_WINFIXUP 0x08 /* Miss happened during spill/fill */ 104 #define FAULT_CODE_WINFIXUP 0x08 /* Miss happened during spill/fill */
104 #define FAULT_CODE_BLKCOMMIT 0x10 /* Use blk-commit ASI in copy_page */ 105 #define FAULT_CODE_BLKCOMMIT 0x10 /* Use blk-commit ASI in copy_page */
105 #define FAULT_CODE_BAD_RA 0x20 /* Bad RA for sun4v */ 106 #define FAULT_CODE_BAD_RA 0x20 /* Bad RA for sun4v */
106 107
107 #if PAGE_SHIFT == 13 108 #if PAGE_SHIFT == 13
108 #define THREAD_SIZE (2*PAGE_SIZE) 109 #define THREAD_SIZE (2*PAGE_SIZE)
109 #define THREAD_SHIFT (PAGE_SHIFT + 1) 110 #define THREAD_SHIFT (PAGE_SHIFT + 1)
110 #else /* PAGE_SHIFT == 13 */ 111 #else /* PAGE_SHIFT == 13 */
111 #define THREAD_SIZE PAGE_SIZE 112 #define THREAD_SIZE PAGE_SIZE
112 #define THREAD_SHIFT PAGE_SHIFT 113 #define THREAD_SHIFT PAGE_SHIFT
113 #endif /* PAGE_SHIFT == 13 */ 114 #endif /* PAGE_SHIFT == 13 */
114 115
115 /* 116 /*
116 * macros/functions for gaining access to the thread information structure 117 * macros/functions for gaining access to the thread information structure
117 */ 118 */
118 #ifndef __ASSEMBLY__ 119 #ifndef __ASSEMBLY__
119 120
120 #define INIT_THREAD_INFO(tsk) \ 121 #define INIT_THREAD_INFO(tsk) \
121 { \ 122 { \
122 .task = &tsk, \ 123 .task = &tsk, \
123 .current_ds = ASI_P, \ 124 .current_ds = ASI_P, \
124 .exec_domain = &default_exec_domain, \ 125 .exec_domain = &default_exec_domain, \
125 .preempt_count = INIT_PREEMPT_COUNT, \ 126 .preempt_count = INIT_PREEMPT_COUNT, \
126 .restart_block = { \ 127 .restart_block = { \
127 .fn = do_no_restart_syscall, \ 128 .fn = do_no_restart_syscall, \
128 }, \ 129 }, \
129 } 130 }
130 131
131 #define init_thread_info (init_thread_union.thread_info) 132 #define init_thread_info (init_thread_union.thread_info)
132 #define init_stack (init_thread_union.stack) 133 #define init_stack (init_thread_union.stack)
133 134
134 /* how to get the thread information struct from C */ 135 /* how to get the thread information struct from C */
135 register struct thread_info *current_thread_info_reg asm("g6"); 136 register struct thread_info *current_thread_info_reg asm("g6");
136 #define current_thread_info() (current_thread_info_reg) 137 #define current_thread_info() (current_thread_info_reg)
137 138
138 /* thread information allocation */ 139 /* thread information allocation */
139 #if PAGE_SHIFT == 13 140 #if PAGE_SHIFT == 13
140 #define THREAD_SIZE_ORDER 1 141 #define THREAD_SIZE_ORDER 1
141 #else /* PAGE_SHIFT == 13 */ 142 #else /* PAGE_SHIFT == 13 */
142 #define THREAD_SIZE_ORDER 0 143 #define THREAD_SIZE_ORDER 0
143 #endif /* PAGE_SHIFT == 13 */ 144 #endif /* PAGE_SHIFT == 13 */
144 145
145 #define __thread_flag_byte_ptr(ti) \ 146 #define __thread_flag_byte_ptr(ti) \
146 ((unsigned char *)(&((ti)->flags))) 147 ((unsigned char *)(&((ti)->flags)))
147 #define __cur_thread_flag_byte_ptr __thread_flag_byte_ptr(current_thread_info()) 148 #define __cur_thread_flag_byte_ptr __thread_flag_byte_ptr(current_thread_info())
148 149
149 #define get_thread_fault_code() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FAULT_CODE]) 150 #define get_thread_fault_code() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FAULT_CODE])
150 #define set_thread_fault_code(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FAULT_CODE] = (val)) 151 #define set_thread_fault_code(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FAULT_CODE] = (val))
151 #define get_thread_wstate() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE]) 152 #define get_thread_wstate() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE])
152 #define set_thread_wstate(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE] = (val)) 153 #define set_thread_wstate(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE] = (val))
153 #define get_thread_cwp() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP]) 154 #define get_thread_cwp() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP])
154 #define set_thread_cwp(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP] = (val)) 155 #define set_thread_cwp(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP] = (val))
155 #define get_thread_noerror() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR]) 156 #define get_thread_noerror() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR])
156 #define set_thread_noerror(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR] = (val)) 157 #define set_thread_noerror(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR] = (val))
157 #define get_thread_fpdepth() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH]) 158 #define get_thread_fpdepth() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH])
158 #define set_thread_fpdepth(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH] = (val)) 159 #define set_thread_fpdepth(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FPDEPTH] = (val))
159 #define get_thread_wsaved() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED]) 160 #define get_thread_wsaved() (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED])
160 #define set_thread_wsaved(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED] = (val)) 161 #define set_thread_wsaved(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED] = (val))
161 #endif /* !(__ASSEMBLY__) */ 162 #endif /* !(__ASSEMBLY__) */
162 163
163 /* 164 /*
164 * Thread information flags, only 16 bits are available as we encode 165 * Thread information flags, only 16 bits are available as we encode
165 * other values into the upper 6 bytes. 166 * other values into the upper 6 bytes.
166 * 167 *
167 * On trap return we need to test several values: 168 * On trap return we need to test several values:
168 * 169 *
169 * user: need_resched, notify_resume, sigpending, wsaved 170 * user: need_resched, notify_resume, sigpending, wsaved
170 * kernel: fpdepth 171 * kernel: fpdepth
171 * 172 *
172 * So to check for work in the kernel case we simply load the fpdepth 173 * So to check for work in the kernel case we simply load the fpdepth
173 * byte out of the flags and test it. For the user case we encode the 174 * byte out of the flags and test it. For the user case we encode the
174 * lower 3 bytes of flags as follows: 175 * lower 3 bytes of flags as follows:
175 * ---------------------------------------- 176 * ----------------------------------------
176 * | wsaved | flags byte 1 | flags byte 2 | 177 * | wsaved | flags byte 1 | flags byte 2 |
177 * ---------------------------------------- 178 * ----------------------------------------
178 * This optimizes the user test into: 179 * This optimizes the user test into:
179 * ldx [%g6 + TI_FLAGS], REG1 180 * ldx [%g6 + TI_FLAGS], REG1
180 * sethi %hi(_TIF_USER_WORK_MASK), REG2 181 * sethi %hi(_TIF_USER_WORK_MASK), REG2
181 * or REG2, %lo(_TIF_USER_WORK_MASK), REG2 182 * or REG2, %lo(_TIF_USER_WORK_MASK), REG2
182 * andcc REG1, REG2, %g0 183 * andcc REG1, REG2, %g0
183 * be,pt no_work_to_do 184 * be,pt no_work_to_do
184 * nop 185 * nop
185 */ 186 */
186 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */ 187 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */
187 #define TIF_NOTIFY_RESUME 1 /* callback before returning to user */ 188 #define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
188 #define TIF_SIGPENDING 2 /* signal pending */ 189 #define TIF_SIGPENDING 2 /* signal pending */
189 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ 190 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */
190 /* flag bit 4 is available */ 191 /* flag bit 4 is available */
191 #define TIF_UNALIGNED 5 /* allowed to do unaligned accesses */ 192 #define TIF_UNALIGNED 5 /* allowed to do unaligned accesses */
192 /* flag bit 6 is available */ 193 /* flag bit 6 is available */
193 #define TIF_32BIT 7 /* 32-bit binary */ 194 #define TIF_32BIT 7 /* 32-bit binary */
194 #define TIF_NOHZ 8 /* in adaptive nohz mode */ 195 #define TIF_NOHZ 8 /* in adaptive nohz mode */
195 #define TIF_SECCOMP 9 /* secure computing */ 196 #define TIF_SECCOMP 9 /* secure computing */
196 #define TIF_SYSCALL_AUDIT 10 /* syscall auditing active */ 197 #define TIF_SYSCALL_AUDIT 10 /* syscall auditing active */
197 #define TIF_SYSCALL_TRACEPOINT 11 /* syscall tracepoint instrumentation */ 198 #define TIF_SYSCALL_TRACEPOINT 11 /* syscall tracepoint instrumentation */
198 /* NOTE: Thread flags >= 12 should be ones we have no interest 199 /* NOTE: Thread flags >= 12 should be ones we have no interest
199 * in using in assembly, else we can't use the mask as 200 * in using in assembly, else we can't use the mask as
200 * an immediate value in instructions such as andcc. 201 * an immediate value in instructions such as andcc.
201 */ 202 */
202 /* flag bit 12 is available */ 203 /* flag bit 12 is available */
203 #define TIF_MEMDIE 13 /* is terminating due to OOM killer */ 204 #define TIF_MEMDIE 13 /* is terminating due to OOM killer */
204 #define TIF_POLLING_NRFLAG 14 205 #define TIF_POLLING_NRFLAG 14
205 206
206 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) 207 #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)
207 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME) 208 #define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME)
208 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) 209 #define _TIF_SIGPENDING (1<<TIF_SIGPENDING)
209 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) 210 #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)
210 #define _TIF_UNALIGNED (1<<TIF_UNALIGNED) 211 #define _TIF_UNALIGNED (1<<TIF_UNALIGNED)
211 #define _TIF_32BIT (1<<TIF_32BIT) 212 #define _TIF_32BIT (1<<TIF_32BIT)
212 #define _TIF_NOHZ (1<<TIF_NOHZ) 213 #define _TIF_NOHZ (1<<TIF_NOHZ)
213 #define _TIF_SECCOMP (1<<TIF_SECCOMP) 214 #define _TIF_SECCOMP (1<<TIF_SECCOMP)
214 #define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) 215 #define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT)
215 #define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT) 216 #define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT)
216 #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) 217 #define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)
217 218
218 #define _TIF_USER_WORK_MASK ((0xff << TI_FLAG_WSAVED_SHIFT) | \ 219 #define _TIF_USER_WORK_MASK ((0xff << TI_FLAG_WSAVED_SHIFT) | \
219 _TIF_DO_NOTIFY_RESUME_MASK | \ 220 _TIF_DO_NOTIFY_RESUME_MASK | \
220 _TIF_NEED_RESCHED) 221 _TIF_NEED_RESCHED)
221 #define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING) 222 #define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING)
222 223
223 /* 224 /*
224 * Thread-synchronous status. 225 * Thread-synchronous status.
225 * 226 *
226 * This is different from the flags in that nobody else 227 * This is different from the flags in that nobody else
227 * ever touches our thread-synchronous status, so we don't 228 * ever touches our thread-synchronous status, so we don't
228 * have to worry about atomic accesses. 229 * have to worry about atomic accesses.
229 * 230 *
230 * Note that there are only 8 bits available. 231 * Note that there are only 8 bits available.
231 */ 232 */
232 #define TS_RESTORE_SIGMASK 0x0001 /* restore signal mask in do_signal() */ 233 #define TS_RESTORE_SIGMASK 0x0001 /* restore signal mask in do_signal() */
233 234
234 #ifndef __ASSEMBLY__ 235 #ifndef __ASSEMBLY__
235 #define HAVE_SET_RESTORE_SIGMASK 1 236 #define HAVE_SET_RESTORE_SIGMASK 1
236 static inline void set_restore_sigmask(void) 237 static inline void set_restore_sigmask(void)
237 { 238 {
238 struct thread_info *ti = current_thread_info(); 239 struct thread_info *ti = current_thread_info();
239 ti->status |= TS_RESTORE_SIGMASK; 240 ti->status |= TS_RESTORE_SIGMASK;
240 WARN_ON(!test_bit(TIF_SIGPENDING, &ti->flags)); 241 WARN_ON(!test_bit(TIF_SIGPENDING, &ti->flags));
241 } 242 }
242 static inline void clear_restore_sigmask(void) 243 static inline void clear_restore_sigmask(void)
243 { 244 {
244 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 245 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
245 } 246 }
246 static inline bool test_restore_sigmask(void) 247 static inline bool test_restore_sigmask(void)
247 { 248 {
248 return current_thread_info()->status & TS_RESTORE_SIGMASK; 249 return current_thread_info()->status & TS_RESTORE_SIGMASK;
249 } 250 }
250 static inline bool test_and_clear_restore_sigmask(void) 251 static inline bool test_and_clear_restore_sigmask(void)
251 { 252 {
252 struct thread_info *ti = current_thread_info(); 253 struct thread_info *ti = current_thread_info();
253 if (!(ti->status & TS_RESTORE_SIGMASK)) 254 if (!(ti->status & TS_RESTORE_SIGMASK))
254 return false; 255 return false;
255 ti->status &= ~TS_RESTORE_SIGMASK; 256 ti->status &= ~TS_RESTORE_SIGMASK;
256 return true; 257 return true;
257 } 258 }
258 259
259 #define thread32_stack_is_64bit(__SP) (((__SP) & 0x1) != 0) 260 #define thread32_stack_is_64bit(__SP) (((__SP) & 0x1) != 0)
260 #define test_thread_64bit_stack(__SP) \ 261 #define test_thread_64bit_stack(__SP) \
261 ((test_thread_flag(TIF_32BIT) && !thread32_stack_is_64bit(__SP)) ? \ 262 ((test_thread_flag(TIF_32BIT) && !thread32_stack_is_64bit(__SP)) ? \
262 false : true) 263 false : true)
263 264
264 #endif /* !__ASSEMBLY__ */ 265 #endif /* !__ASSEMBLY__ */
265 266
266 #endif /* __KERNEL__ */ 267 #endif /* __KERNEL__ */
267 268
268 #endif /* _ASM_THREAD_INFO_H */ 269 #endif /* _ASM_THREAD_INFO_H */
269 270