Linux Audio

Check our new training course

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