include/asm-x86/thread_info.h

   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
   7 #ifndef _ASM_X86_THREAD_INFO_H
   8 #define _ASM_X86_THREAD_INFO_H
   9
  10 #include <linux/compiler.h>
  11 #include <asm/page.h>
  12 #include <asm/types.h>
  13
  14 #ifdef CONFIG_X86_32
  15
  16 #ifndef __ASSEMBLY__
  17 #include <asm/processor.h>
  18 #endif
  19
  20 /*
  21  * low level task data that entry.S needs immediate access to
  22  * - this struct should fit entirely inside of one cache line
  23  * - this struct shares the supervisor stack pages
  24  * - if the contents of this structure are changed,
  25  *   the assembly constants must also be changed
  26  */
  27 #ifndef __ASSEMBLY__
  28
  29 struct thread_info {
  30         struct task_struct      *task;          /* main task structure */
  31         struct exec_domain      *exec_domain;   /* execution domain */
  32         unsigned long           flags;          /* low level flags */
  33         unsigned long           status;         /* thread-synchronous flags */
  34         __u32                   cpu;            /* current CPU */
  35         int                     preempt_count;  /* 0 => preemptable,
  36                                                    <0 => BUG */
  37         mm_segment_t            addr_limit;     /* thread address space:
  38                                                    0-0xBFFFFFFF user-thread
  39                                                    0-0xFFFFFFFF kernel-thread
  40                                                 */
  41         void                    *sysenter_return;
  42         struct restart_block    restart_block;
  43         unsigned long           previous_esp;   /* ESP of the previous stack in
  44                                                    case of nested (IRQ) stacks
  45                                                 */
  46         __u8                    supervisor_stack[0];
  47 };
  48
  49 #else /* !__ASSEMBLY__ */
  50
  51 #include <asm/asm-offsets.h>
  52
  53 #endif
  54
  55 #define PREEMPT_ACTIVE          0x10000000
  56 #ifdef CONFIG_4KSTACKS
  57 #define THREAD_SIZE            (4096)
  58 #else
  59 #define THREAD_SIZE             (8192)
  60 #endif
  61
  62 #define STACK_WARN             (THREAD_SIZE/8)
  63 /*
  64  * macros/functions for gaining access to the thread information structure
  65  *
  66  * preempt_count needs to be 1 initially, until the scheduler is functional.
  67  */
  68 #ifndef __ASSEMBLY__
  69
  70 #define INIT_THREAD_INFO(tsk)                   \
  71 {                                               \
  72         .task           = &tsk,                 \
  73         .exec_domain    = &default_exec_domain, \
  74         .flags          = 0,                    \
  75         .cpu            = 0,                    \
  76         .preempt_count  = 1,                    \
  77         .addr_limit     = KERNEL_DS,            \
  78         .restart_block = {                      \
  79                 .fn = do_no_restart_syscall,    \
  80         },                                      \
  81 }
  82
  83 #define init_thread_info        (init_thread_union.thread_info)
  84 #define init_stack              (init_thread_union.stack)
  85
  86
  87 /* how to get the current stack pointer from C */
  88 register unsigned long current_stack_pointer asm("esp") __used;
  89
  90 /* how to get the thread information struct from C */
  91 static inline struct thread_info *current_thread_info(void)
  92 {
  93         return (struct thread_info *)
  94                 (current_stack_pointer & ~(THREAD_SIZE - 1));
  95 }
  96
  97 /* thread information allocation */
  98 #ifdef CONFIG_DEBUG_STACK_USAGE
  99 #define alloc_thread_info(tsk) ((struct thread_info *)                  \
 100         __get_free_pages(GFP_KERNEL | __GFP_ZERO, get_order(THREAD_SIZE)))
 101 #else
 102 #define alloc_thread_info(tsk) ((struct thread_info *)                  \
 103         __get_free_pages(GFP_KERNEL, get_order(THREAD_SIZE)))
 104 #endif
 105
 106 #else /* !__ASSEMBLY__ */
 107
 108 /* how to get the thread information struct from ASM */
 109 #define GET_THREAD_INFO(reg)     \
 110         movl $-THREAD_SIZE, reg; \
 111         andl %esp, reg
 112
 113 /* use this one if reg already contains %esp */
 114 #define GET_THREAD_INFO_WITH_ESP(reg) \
 115         andl $-THREAD_SIZE, reg
 116
 117 #endif
 118
 119 /*
 120  * thread information flags
 121  * - these are process state flags that various
 122  *   assembly files may need to access
 123  * - pending work-to-be-done flags are in LSW
 124  * - other flags in MSW
 125  */
 126 #define TIF_SYSCALL_TRACE       0       /* syscall trace active */
 127 #define TIF_SIGPENDING          1       /* signal pending */
 128 #define TIF_NEED_RESCHED        2       /* rescheduling necessary */
 129 #define TIF_SINGLESTEP          3       /* restore singlestep on return to
 130                                            user mode */
 131 #define TIF_IRET                4       /* return with iret */
 132 #define TIF_SYSCALL_EMU         5       /* syscall emulation active */
 133 #define TIF_SYSCALL_AUDIT       6       /* syscall auditing active */
 134 #define TIF_SECCOMP             7       /* secure computing */
 135 #define TIF_RESTORE_SIGMASK     8       /* restore signal mask in do_signal() */
 136 #define TIF_HRTICK_RESCHED      9       /* reprogram hrtick timer */
 137 #define TIF_MEMDIE              16
 138 #define TIF_DEBUG               17      /* uses debug registers */
 139 #define TIF_IO_BITMAP           18      /* uses I/O bitmap */
 140 #define TIF_FREEZE              19      /* is freezing for suspend */
 141 #define TIF_NOTSC               20      /* TSC is not accessible in userland */
 142 #define TIF_FORCED_TF           21      /* true if TF in eflags artificially */
 143 #define TIF_DEBUGCTLMSR         22      /* uses thread_struct.debugctlmsr */
 144 #define TIF_DS_AREA_MSR         23      /* uses thread_struct.ds_area_msr */
 145 #define TIF_BTS_TRACE_TS        24      /* record scheduling event timestamps */
 146
 147 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
 148 #define _TIF_SIGPENDING         (1 << TIF_SIGPENDING)
 149 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
 150 #define _TIF_SINGLESTEP         (1 << TIF_SINGLESTEP)
 151 #define _TIF_IRET               (1 << TIF_IRET)
 152 #define _TIF_SYSCALL_EMU        (1 << TIF_SYSCALL_EMU)
 153 #define _TIF_SYSCALL_AUDIT      (1 << TIF_SYSCALL_AUDIT)
 154 #define _TIF_SECCOMP            (1 << TIF_SECCOMP)
 155 #define _TIF_RESTORE_SIGMASK    (1 << TIF_RESTORE_SIGMASK)
 156 #define _TIF_HRTICK_RESCHED     (1 << TIF_HRTICK_RESCHED)
 157 #define _TIF_DEBUG              (1 << TIF_DEBUG)
 158 #define _TIF_IO_BITMAP          (1 << TIF_IO_BITMAP)
 159 #define _TIF_FREEZE             (1 << TIF_FREEZE)
 160 #define _TIF_NOTSC              (1 << TIF_NOTSC)
 161 #define _TIF_FORCED_TF          (1 << TIF_FORCED_TF)
 162 #define _TIF_DEBUGCTLMSR        (1 << TIF_DEBUGCTLMSR)
 163 #define _TIF_DS_AREA_MSR        (1 << TIF_DS_AREA_MSR)
 164 #define _TIF_BTS_TRACE_TS       (1 << TIF_BTS_TRACE_TS)
 165
 166 /* work to do on interrupt/exception return */
 167 #define _TIF_WORK_MASK                                                  \
 168         (0x0000FFFF & ~(_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT |       \
 169                         _TIF_SECCOMP | _TIF_SYSCALL_EMU))
 170 /* work to do on any return to u-space */
 171 #define _TIF_ALLWORK_MASK       (0x0000FFFF & ~_TIF_SECCOMP)
 172
 173 /* flags to check in __switch_to() */
 174 #define _TIF_WORK_CTXSW                                         \
 175         (_TIF_IO_BITMAP | _TIF_NOTSC | _TIF_DEBUGCTLMSR |       \
 176          _TIF_DS_AREA_MSR | _TIF_BTS_TRACE_TS)
 177 #define _TIF_WORK_CTXSW_PREV _TIF_WORK_CTXSW
 178 #define _TIF_WORK_CTXSW_NEXT (_TIF_WORK_CTXSW | _TIF_DEBUG)
 179
 180
 181 /*
 182  * Thread-synchronous status.
 183  *
 184  * This is different from the flags in that nobody else
 185  * ever touches our thread-synchronous status, so we don't
 186  * have to worry about atomic accesses.
 187  */
 188 #define TS_USEDFPU              0x0001  /* FPU was used by this task
 189                                            this quantum (SMP) */
 190 #define TS_POLLING              0x0002  /* True if in idle loop
 191                                            and not sleeping */
 192
 193 #define tsk_is_polling(t) (task_thread_info(t)->status & TS_POLLING)
 194
 195 #else /* X86_32 */
 196
 197 #include <asm/pda.h>
 198
 199 /*
 200  * low level task data that entry.S needs immediate access to
 201  * - this struct should fit entirely inside of one cache line
 202  * - this struct shares the supervisor stack pages
 203  */
 204 #ifndef __ASSEMBLY__
 205 struct task_struct;
 206 struct exec_domain;
 207 #include <asm/processor.h>
 208
 209 struct thread_info {
 210         struct task_struct      *task;          /* main task structure */
 211         struct exec_domain      *exec_domain;   /* execution domain */
 212         __u32                   flags;          /* low level flags */
 213         __u32                   status;         /* thread synchronous flags */
 214         __u32                   cpu;            /* current CPU */
 215         int                     preempt_count;  /* 0 => preemptable,
 216                                                    <0 => BUG */
 217         mm_segment_t            addr_limit;
 218         struct restart_block    restart_block;
 219 #ifdef CONFIG_IA32_EMULATION
 220         void __user             *sysenter_return;
 221 #endif
 222 };
 223 #endif
 224
 225 /*
 226  * macros/functions for gaining access to the thread information structure
 227  * preempt_count needs to be 1 initially, until the scheduler is functional.
 228  */
 229 #ifndef __ASSEMBLY__
 230 #define INIT_THREAD_INFO(tsk)                   \
 231 {                                               \
 232         .task          = &tsk,                  \
 233         .exec_domain   = &default_exec_domain,  \
 234         .flags         = 0,                     \
 235         .cpu           = 0,                     \
 236         .preempt_count = 1,                     \
 237         .addr_limit     = KERNEL_DS,            \
 238         .restart_block = {                      \
 239                 .fn = do_no_restart_syscall,    \
 240         },                                      \
 241 }
 242
 243 #define init_thread_info        (init_thread_union.thread_info)
 244 #define init_stack              (init_thread_union.stack)
 245
 246 static inline struct thread_info *current_thread_info(void)
 247 {
 248         struct thread_info *ti;
 249         ti = (void *)(read_pda(kernelstack) + PDA_STACKOFFSET - THREAD_SIZE);
 250         return ti;
 251 }
 252
 253 /* do not use in interrupt context */
 254 static inline struct thread_info *stack_thread_info(void)
 255 {
 256         struct thread_info *ti;
 257         asm("andq %%rsp,%0; " : "=r" (ti) : "0" (~(THREAD_SIZE - 1)));
 258         return ti;
 259 }
 260
 261 /* thread information allocation */
 262 #ifdef CONFIG_DEBUG_STACK_USAGE
 263 #define THREAD_FLAGS (GFP_KERNEL | __GFP_ZERO)
 264 #else
 265 #define THREAD_FLAGS GFP_KERNEL
 266 #endif
 267
 268 #define alloc_thread_info(tsk)                                          \
 269         ((struct thread_info *)__get_free_pages(THREAD_FLAGS, THREAD_ORDER))
 270
 271 #else /* !__ASSEMBLY__ */
 272
 273 /* how to get the thread information struct from ASM */
 274 #define GET_THREAD_INFO(reg) \
 275         movq %gs:pda_kernelstack,reg ; \
 276         subq $(THREAD_SIZE-PDA_STACKOFFSET),reg
 277
 278 #endif
 279
 280 /*
 281  * thread information flags
 282  * - these are process state flags that various assembly files
 283  *   may need to access
 284  * - pending work-to-be-done flags are in LSW
 285  * - other flags in MSW
 286  * Warning: layout of LSW is hardcoded in entry.S
 287  */
 288 #define TIF_SYSCALL_TRACE       0       /* syscall trace active */
 289 #define TIF_SIGPENDING          2       /* signal pending */
 290 #define TIF_NEED_RESCHED        3       /* rescheduling necessary */
 291 #define TIF_SINGLESTEP          4       /* reenable singlestep on user return*/
 292 #define TIF_IRET                5       /* force IRET */
 293 #define TIF_SYSCALL_AUDIT       7       /* syscall auditing active */
 294 #define TIF_SECCOMP             8       /* secure computing */
 295 #define TIF_RESTORE_SIGMASK     9       /* restore signal mask in do_signal */
 296 #define TIF_MCE_NOTIFY          10      /* notify userspace of an MCE */
 297 #define TIF_HRTICK_RESCHED      11      /* reprogram hrtick timer */
 298 /* 16 free */
 299 #define TIF_IA32                17      /* 32bit process */
 300 #define TIF_FORK                18      /* ret_from_fork */
 301 #define TIF_ABI_PENDING         19
 302 #define TIF_MEMDIE              20
 303 #define TIF_DEBUG               21      /* uses debug registers */
 304 #define TIF_IO_BITMAP           22      /* uses I/O bitmap */
 305 #define TIF_FREEZE              23      /* is freezing for suspend */
 306 #define TIF_FORCED_TF           24      /* true if TF in eflags artificially */
 307 #define TIF_DEBUGCTLMSR         25      /* uses thread_struct.debugctlmsr */
 308 #define TIF_DS_AREA_MSR         26      /* uses thread_struct.ds_area_msr */
 309 #define TIF_BTS_TRACE_TS        27      /* record scheduling event timestamps */
 310 #define TIF_NOTSC               28      /* TSC is not accessible in userland */
 311
 312 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
 313 #define _TIF_SIGPENDING         (1 << TIF_SIGPENDING)
 314 #define _TIF_SINGLESTEP         (1 << TIF_SINGLESTEP)
 315 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
 316 #define _TIF_IRET               (1 << TIF_IRET)
 317 #define _TIF_SYSCALL_AUDIT      (1 << TIF_SYSCALL_AUDIT)
 318 #define _TIF_SECCOMP            (1 << TIF_SECCOMP)
 319 #define _TIF_RESTORE_SIGMASK    (1 << TIF_RESTORE_SIGMASK)
 320 #define _TIF_MCE_NOTIFY         (1 << TIF_MCE_NOTIFY)
 321 #define _TIF_HRTICK_RESCHED     (1 << TIF_HRTICK_RESCHED)
 322 #define _TIF_IA32               (1 << TIF_IA32)
 323 #define _TIF_FORK               (1 << TIF_FORK)
 324 #define _TIF_ABI_PENDING        (1 << TIF_ABI_PENDING)
 325 #define _TIF_DEBUG              (1 << TIF_DEBUG)
 326 #define _TIF_IO_BITMAP          (1 << TIF_IO_BITMAP)
 327 #define _TIF_FREEZE             (1 << TIF_FREEZE)
 328 #define _TIF_FORCED_TF          (1 << TIF_FORCED_TF)
 329 #define _TIF_DEBUGCTLMSR        (1 << TIF_DEBUGCTLMSR)
 330 #define _TIF_DS_AREA_MSR        (1 << TIF_DS_AREA_MSR)
 331 #define _TIF_BTS_TRACE_TS       (1 << TIF_BTS_TRACE_TS)
 332 #define _TIF_NOTSC              (1 << TIF_NOTSC)
 333
 334 /* work to do on interrupt/exception return */
 335 #define _TIF_WORK_MASK                                                  \
 336         (0x0000FFFF &                                                   \
 337          ~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP|_TIF_SECCOMP))
 338 /* work to do on any return to user space */
 339 #define _TIF_ALLWORK_MASK (0x0000FFFF & ~_TIF_SECCOMP)
 340
 341 #define _TIF_DO_NOTIFY_MASK                                             \
 342         (_TIF_SIGPENDING|_TIF_SINGLESTEP|_TIF_MCE_NOTIFY|_TIF_HRTICK_RESCHED)
 343
 344 /* flags to check in __switch_to() */
 345 #define _TIF_WORK_CTXSW                                                 \
 346         (_TIF_IO_BITMAP|_TIF_DEBUGCTLMSR|_TIF_DS_AREA_MSR|_TIF_BTS_TRACE_TS|_TIF_NOTSC)
 347 #define _TIF_WORK_CTXSW_PREV _TIF_WORK_CTXSW
 348 #define _TIF_WORK_CTXSW_NEXT (_TIF_WORK_CTXSW|_TIF_DEBUG)
 349
 350 #define PREEMPT_ACTIVE     0x10000000
 351
 352 /*
 353  * Thread-synchronous status.
 354  *
 355  * This is different from the flags in that nobody else
 356  * ever touches our thread-synchronous status, so we don't
 357  * have to worry about atomic accesses.
 358  */
 359 #define TS_USEDFPU              0x0001  /* FPU was used by this task
 360                                            this quantum (SMP) */
 361 #define TS_COMPAT               0x0002  /* 32bit syscall active */
 362 #define TS_POLLING              0x0004  /* true if in idle loop
 363                                            and not sleeping */
 364
 365 #define tsk_is_polling(t) (task_thread_info(t)->status & TS_POLLING)
 366
 367 #endif /* !X86_32 */
 368
 369
 370 #ifndef __ASSEMBLY__
 371 extern void arch_task_cache_init(void);
 372 extern void free_thread_info(struct thread_info *ti);
 373 extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);
 374 #define arch_task_cache_init arch_task_cache_init
 375 #endif
 376 #endif /* _ASM_X86_THREAD_INFO_H */