Chris Metcalf | 867e359 | 2010-05-28 23:09:12 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2002 David Howells (dhowells@redhat.com) |
| 3 | * Copyright 2010 Tilera Corporation. All Rights Reserved. |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or |
| 6 | * modify it under the terms of the GNU General Public License |
| 7 | * as published by the Free Software Foundation, version 2. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, but |
| 10 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or |
| 12 | * NON INFRINGEMENT. See the GNU General Public License for |
| 13 | * more details. |
| 14 | */ |
| 15 | |
| 16 | #ifndef _ASM_TILE_THREAD_INFO_H |
| 17 | #define _ASM_TILE_THREAD_INFO_H |
| 18 | |
| 19 | #include <asm/processor.h> |
| 20 | #include <asm/page.h> |
| 21 | #ifndef __ASSEMBLY__ |
| 22 | |
| 23 | /* |
| 24 | * Low level task data that assembly code needs immediate access to. |
| 25 | * The structure is placed at the bottom of the supervisor stack. |
| 26 | */ |
| 27 | struct thread_info { |
| 28 | struct task_struct *task; /* main task structure */ |
| 29 | struct exec_domain *exec_domain; /* execution domain */ |
| 30 | unsigned long flags; /* low level flags */ |
| 31 | unsigned long status; /* thread-synchronous flags */ |
| 32 | __u32 homecache_cpu; /* CPU we are homecached on */ |
| 33 | __u32 cpu; /* current CPU */ |
| 34 | int preempt_count; /* 0 => preemptable, |
| 35 | <0 => BUG */ |
| 36 | |
| 37 | mm_segment_t addr_limit; /* thread address space |
| 38 | (KERNEL_DS or USER_DS) */ |
| 39 | struct restart_block restart_block; |
| 40 | struct single_step_state *step_state; /* single step state |
| 41 | (if non-zero) */ |
| 42 | }; |
| 43 | |
| 44 | /* |
| 45 | * macros/functions for gaining access to the thread information structure. |
| 46 | */ |
| 47 | #define INIT_THREAD_INFO(tsk) \ |
| 48 | { \ |
| 49 | .task = &tsk, \ |
| 50 | .exec_domain = &default_exec_domain, \ |
| 51 | .flags = 0, \ |
| 52 | .cpu = 0, \ |
| 53 | .preempt_count = INIT_PREEMPT_COUNT, \ |
| 54 | .addr_limit = KERNEL_DS, \ |
| 55 | .restart_block = { \ |
| 56 | .fn = do_no_restart_syscall, \ |
| 57 | }, \ |
Chris Metcalf | 0707ad3 | 2010-06-25 17:04:17 -0400 | [diff] [blame^] | 58 | .step_state = NULL, \ |
Chris Metcalf | 867e359 | 2010-05-28 23:09:12 -0400 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | #define init_thread_info (init_thread_union.thread_info) |
| 62 | #define init_stack (init_thread_union.stack) |
| 63 | |
| 64 | #endif /* !__ASSEMBLY__ */ |
| 65 | |
| 66 | #if PAGE_SIZE < 8192 |
| 67 | #define THREAD_SIZE_ORDER (13 - PAGE_SHIFT) |
| 68 | #else |
| 69 | #define THREAD_SIZE_ORDER (0) |
| 70 | #endif |
| 71 | |
| 72 | #define THREAD_SIZE (PAGE_SIZE << THREAD_SIZE_ORDER) |
| 73 | #define LOG2_THREAD_SIZE (PAGE_SHIFT + THREAD_SIZE_ORDER) |
| 74 | |
| 75 | #define STACK_WARN (THREAD_SIZE/8) |
| 76 | |
| 77 | #ifndef __ASSEMBLY__ |
| 78 | |
| 79 | /* How to get the thread information struct from C. */ |
| 80 | register unsigned long stack_pointer __asm__("sp"); |
| 81 | |
| 82 | #define current_thread_info() \ |
| 83 | ((struct thread_info *)(stack_pointer & -THREAD_SIZE)) |
| 84 | |
| 85 | #define __HAVE_ARCH_THREAD_INFO_ALLOCATOR |
| 86 | extern struct thread_info *alloc_thread_info(struct task_struct *task); |
| 87 | extern void free_thread_info(struct thread_info *info); |
| 88 | |
Chris Metcalf | 0707ad3 | 2010-06-25 17:04:17 -0400 | [diff] [blame^] | 89 | /* Sit on a nap instruction until interrupted. */ |
| 90 | extern void smp_nap(void); |
| 91 | |
| 92 | /* Enable interrupts racelessly and nap forever: helper for cpu_idle(). */ |
| 93 | extern void _cpu_idle(void); |
| 94 | |
Chris Metcalf | 867e359 | 2010-05-28 23:09:12 -0400 | [diff] [blame] | 95 | /* Switch boot idle thread to a freshly-allocated stack and free old stack. */ |
| 96 | extern void cpu_idle_on_new_stack(struct thread_info *old_ti, |
| 97 | unsigned long new_sp, |
| 98 | unsigned long new_ss10); |
| 99 | |
| 100 | #else /* __ASSEMBLY__ */ |
| 101 | |
| 102 | /* how to get the thread information struct from ASM */ |
| 103 | #ifdef __tilegx__ |
| 104 | #define GET_THREAD_INFO(reg) move reg, sp; mm reg, zero, LOG2_THREAD_SIZE, 63 |
| 105 | #else |
| 106 | #define GET_THREAD_INFO(reg) mm reg, sp, zero, LOG2_THREAD_SIZE, 31 |
| 107 | #endif |
| 108 | |
| 109 | #endif /* !__ASSEMBLY__ */ |
| 110 | |
| 111 | #define PREEMPT_ACTIVE 0x10000000 |
| 112 | |
| 113 | /* |
| 114 | * Thread information flags that various assembly files may need to access. |
| 115 | * Keep flags accessed frequently in low bits, particular since it makes |
| 116 | * it easier to build constants in assembly. |
| 117 | */ |
| 118 | #define TIF_SIGPENDING 0 /* signal pending */ |
| 119 | #define TIF_NEED_RESCHED 1 /* rescheduling necessary */ |
| 120 | #define TIF_SINGLESTEP 2 /* restore singlestep on return to |
| 121 | user mode */ |
| 122 | #define TIF_ASYNC_TLB 3 /* got an async TLB fault in kernel */ |
| 123 | #define TIF_SYSCALL_TRACE 4 /* syscall trace active */ |
| 124 | #define TIF_SYSCALL_AUDIT 5 /* syscall auditing active */ |
| 125 | #define TIF_SECCOMP 6 /* secure computing */ |
| 126 | #define TIF_MEMDIE 7 /* OOM killer at work */ |
| 127 | |
| 128 | #define _TIF_SIGPENDING (1<<TIF_SIGPENDING) |
| 129 | #define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED) |
| 130 | #define _TIF_SINGLESTEP (1<<TIF_SINGLESTEP) |
| 131 | #define _TIF_ASYNC_TLB (1<<TIF_ASYNC_TLB) |
| 132 | #define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE) |
| 133 | #define _TIF_SYSCALL_AUDIT (1<<TIF_SYSCALL_AUDIT) |
| 134 | #define _TIF_SECCOMP (1<<TIF_SECCOMP) |
| 135 | #define _TIF_MEMDIE (1<<TIF_MEMDIE) |
| 136 | |
| 137 | /* Work to do on any return to user space. */ |
| 138 | #define _TIF_ALLWORK_MASK \ |
| 139 | (_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_SINGLESTEP|_TIF_ASYNC_TLB) |
| 140 | |
| 141 | /* |
| 142 | * Thread-synchronous status. |
| 143 | * |
| 144 | * This is different from the flags in that nobody else |
| 145 | * ever touches our thread-synchronous status, so we don't |
| 146 | * have to worry about atomic accesses. |
| 147 | */ |
| 148 | #ifdef __tilegx__ |
| 149 | #define TS_COMPAT 0x0001 /* 32-bit compatibility mode */ |
| 150 | #endif |
| 151 | #define TS_POLLING 0x0004 /* in idle loop but not sleeping */ |
| 152 | #define TS_RESTORE_SIGMASK 0x0008 /* restore signal mask in do_signal */ |
| 153 | #define TS_EXEC_HASH_SET 0x0010 /* apply TS_EXEC_HASH_xxx flags */ |
| 154 | #define TS_EXEC_HASH_RO 0x0020 /* during exec, hash r/o segments */ |
| 155 | #define TS_EXEC_HASH_RW 0x0040 /* during exec, hash r/w segments */ |
| 156 | #define TS_EXEC_HASH_STACK 0x0080 /* during exec, hash the stack */ |
| 157 | #define TS_EXEC_HASH_FLAGS 0x00f0 /* mask for TS_EXEC_HASH_xxx flags */ |
| 158 | |
| 159 | #define tsk_is_polling(t) (task_thread_info(t)->status & TS_POLLING) |
| 160 | |
| 161 | #ifndef __ASSEMBLY__ |
| 162 | #define HAVE_SET_RESTORE_SIGMASK 1 |
| 163 | static inline void set_restore_sigmask(void) |
| 164 | { |
| 165 | struct thread_info *ti = current_thread_info(); |
| 166 | ti->status |= TS_RESTORE_SIGMASK; |
| 167 | set_bit(TIF_SIGPENDING, &ti->flags); |
| 168 | } |
| 169 | #endif /* !__ASSEMBLY__ */ |
| 170 | |
| 171 | #endif /* _ASM_TILE_THREAD_INFO_H */ |