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_NOERROR		2
18 #define TI_FLAG_BYTE_NOERROR_SHIFT	40
19 #define TI_FLAG_BYTE_FPDEPTH		3
20 #define TI_FLAG_FPDEPTH_SHIFT		32
21 #define TI_FLAG_BYTE_CWP		4
22 #define TI_FLAG_CWP_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 
33 struct task_struct;
34 struct exec_domain;
35 
36 struct 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			current_ds;
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_FPDEPTH	(TI_FLAGS + TI_FLAG_BYTE_FPDEPTH)
78 #define TI_WSAVED	(TI_FLAGS + TI_FLAG_BYTE_WSAVED)
79 #define TI_SYS_NOERROR	(TI_FLAGS + TI_FLAG_BYTE_NOERROR)
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_CURRENT_DS	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 	.current_ds	=	ASI_P,			\
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 */
136 register 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_noerror()		(__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR])
157 #define set_thread_noerror(val)		(__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_NOERROR] = (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 #endif /* !(__ASSEMBLY__) */
163 
164 /*
165  * Thread information flags, only 16 bits are available as we encode
166  * other values into the upper 6 bytes.
167  *
168  * On trap return we need to test several values:
169  *
170  * user:	need_resched, notify_resume, sigpending, wsaved
171  * kernel:	fpdepth
172  *
173  * So to check for work in the kernel case we simply load the fpdepth
174  * byte out of the flags and test it.  For the user case we encode the
175  * lower 3 bytes of flags as follows:
176  *	----------------------------------------
177  *	| wsaved | flags byte 1 | flags byte 2 |
178  *	----------------------------------------
179  * This optimizes the user test into:
180  *	ldx		[%g6 + TI_FLAGS], REG1
181  *	sethi		%hi(_TIF_USER_WORK_MASK), REG2
182  *	or		REG2, %lo(_TIF_USER_WORK_MASK), REG2
183  *	andcc		REG1, REG2, %g0
184  *	be,pt		no_work_to_do
185  *	 nop
186  */
187 #define TIF_SYSCALL_TRACE	0	/* syscall trace active */
188 #define TIF_NOTIFY_RESUME	1	/* callback before returning to user */
189 #define TIF_SIGPENDING		2	/* signal pending */
190 #define TIF_NEED_RESCHED	3	/* rescheduling necessary */
191 /* flag bit 4 is available */
192 #define TIF_UNALIGNED		5	/* allowed to do unaligned accesses */
193 /* flag bit 6 is available */
194 #define TIF_32BIT		7	/* 32-bit binary */
195 /* flag bit 8 is available */
196 #define TIF_SECCOMP		9	/* secure computing */
197 #define TIF_SYSCALL_AUDIT	10	/* syscall auditing active */
198 #define TIF_SYSCALL_TRACEPOINT	11	/* syscall tracepoint instrumentation */
199 /* NOTE: Thread flags >= 12 should be ones we have no interest
200  *       in using in assembly, else we can't use the mask as
201  *       an immediate value in instructions such as andcc.
202  */
203 /* flag bit 12 is available */
204 #define TIF_MEMDIE		13	/* is terminating due to OOM killer */
205 #define TIF_POLLING_NRFLAG	14
206 
207 #define _TIF_SYSCALL_TRACE	(1<<TIF_SYSCALL_TRACE)
208 #define _TIF_NOTIFY_RESUME	(1<<TIF_NOTIFY_RESUME)
209 #define _TIF_SIGPENDING		(1<<TIF_SIGPENDING)
210 #define _TIF_NEED_RESCHED	(1<<TIF_NEED_RESCHED)
211 #define _TIF_UNALIGNED		(1<<TIF_UNALIGNED)
212 #define _TIF_32BIT		(1<<TIF_32BIT)
213 #define _TIF_SECCOMP		(1<<TIF_SECCOMP)
214 #define _TIF_SYSCALL_AUDIT	(1<<TIF_SYSCALL_AUDIT)
215 #define _TIF_SYSCALL_TRACEPOINT	(1<<TIF_SYSCALL_TRACEPOINT)
216 #define _TIF_POLLING_NRFLAG	(1<<TIF_POLLING_NRFLAG)
217 
218 #define _TIF_USER_WORK_MASK	((0xff << TI_FLAG_WSAVED_SHIFT) | \
219 				 _TIF_DO_NOTIFY_RESUME_MASK | \
220 				 _TIF_NEED_RESCHED)
221 #define _TIF_DO_NOTIFY_RESUME_MASK	(_TIF_NOTIFY_RESUME | _TIF_SIGPENDING)
222 
223 /*
224  * Thread-synchronous status.
225  *
226  * This is different from the flags in that nobody else
227  * ever touches our thread-synchronous status, so we don't
228  * have to worry about atomic accesses.
229  *
230  * Note that there are only 8 bits available.
231  */
232 #define TS_RESTORE_SIGMASK	0x0001	/* restore signal mask in do_signal() */
233 
234 #ifndef __ASSEMBLY__
235 #define HAVE_SET_RESTORE_SIGMASK	1
236 static inline void set_restore_sigmask(void)
237 {
238 	struct thread_info *ti = current_thread_info();
239 	ti->status |= TS_RESTORE_SIGMASK;
240 	WARN_ON(!test_bit(TIF_SIGPENDING, &ti->flags));
241 }
242 static inline void clear_restore_sigmask(void)
243 {
244 	current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
245 }
246 static inline bool test_restore_sigmask(void)
247 {
248 	return current_thread_info()->status & TS_RESTORE_SIGMASK;
249 }
250 static inline bool test_and_clear_restore_sigmask(void)
251 {
252 	struct thread_info *ti = current_thread_info();
253 	if (!(ti->status & TS_RESTORE_SIGMASK))
254 		return false;
255 	ti->status &= ~TS_RESTORE_SIGMASK;
256 	return true;
257 }
258 
259 #define thread32_stack_is_64bit(__SP) (((__SP) & 0x1) != 0)
260 #define test_thread_64bit_stack(__SP) \
261 	((test_thread_flag(TIF_32BIT) && !thread32_stack_is_64bit(__SP)) ? \
262 	 false : true)
263 
264 #endif	/* !__ASSEMBLY__ */
265 
266 #endif /* __KERNEL__ */
267 
268 #endif /* _ASM_THREAD_INFO_H */
269