Quelle  thread_info_64.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/* thread_info.h: sparc64 low-level thread information
 *
 * Copyright (C) 2002  David S. Miller (davem@redhat.com)
 */

#ifndef _ASM_THREAD_INFO_H
#define _ASM_THREAD_INFO_H

#ifdef __KERNEL__

#define NSWINS  7

#defineTI_FLAG_BYTE_FAULT_CODE
#/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
#define
#define TI_FLAG_WSTATE_SHIFT  struct *;
#define   2
#define TI_FLAG_BYTE_NOERROR_SHIFT 40
#efine TI_FLAG_BYTE_FPDEPTH
#define TI_FLAG_FPDEPTH_SHIFT  32
define 4
#define TI_FLAG_CWP_SHIFT  24
defineTI_FLAG_BYTE_WSAVED5
#define TI_FLAG_WSAVED_SHIFT  16

#include <asm/page.h>

#ifndef __ASSEMBLY__

#include <asm/ptrace.h>
#include <asm/types.h>

struct task_struct;

struct thread_info {
 /* D$ line 1 */
 struct task_struct *task;
 unsigned long  flags;
 __u8   fpsaved[7];
 __u8   status;
 unsigned long  ksp;

 /* D$ line 2 */
 unsigned long  fault_address;
 struct pt_regs  *kregs;
 int   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 _u8 ;
 _u8 _pad
 __u16   cpu;

 unsigned long  xfsr]

 struct unsigned int kern_una_insn
 long  rwbuf_stkptrs];

 unsigned long   _attribute__(ligned(4);
# /* !(__ASSEMBLY__) */

 struct pt_regs  *ern_una_regs
 unsigned int  kern_una_insn;

 unsigned long# TI_FLAGS 0x00000008
  __attribute__(aligned4)));
};

# /* !(__ASSEMBLY__) */

/* offsets into the thread_info struct for assembly code access */
#define TI_TASK  0x00000000
#define#define TI_WSAVED (TI_FLAGS + TI_FLAG_BYTE_WSAVED#define TI_SYS_NOERROR (TI_FLAGS + TI_FLAG_BYTE_NOERROR)
##define#define TI_UTRAPS#define #define TI_RWIN_SPTRS#define #define TI_XFSR#define#define TI_KUNA_INSN#define TI_FPREGS
#defineFAULT_CODE_WRITEx01/* Write access, implies D-TLB    */
#define TI_CWP#define FAULT_CODE_DTLB x02
#define TI_FPDEPTH (TI_FLAGS#defineFAULT_CODE_ITLB  x04/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
#define TI_WSAVED#defineFAULT_CODE_BLKCOMMITx10
#define TI_SYS_NOERROR (TI_FLAGS + TI_FLAG_BYTE_NOERROR)
#define TI_FPSAVED 0x00000010
#define TI_KSP 0x00000018
#define TI_FAULT_ADDR 0x00000020
#define TI_KREGS 0x00000028
#define TI_PRE_COUNT 0x00000030
#define TI_NEW_CHILD 0x00000034
#define TI_CPU 0x00000036
#define TI_UTRAPS 0x00000038
#define TI_REG_WINDOW 0x00000040
#define TI_RWIN_SPTRS 0x000003c0
#define TI_GSR 0x000003f8
#define TI_XFSR 0x00000430
#define TI_KUNA_REGS 0x00000468
#define TI_KUNA_INSN 0x00000470
#define TI_FPREGS 0x00000480

/* We embed this in the uppermost byte of thread_info->flags */
#define FAULT_CODE_WRITE 0x01 /* Write access, implies D-TLB    */
#define FAULT_CODE_DTLB  0x02 /* Miss happened in D-TLB    */
#define FAULT_CODE_ITLB  0x04 /* Miss happened in I-TLB    */
#define FAULT_CODE_WINFIXUP 0x08 /* Miss happened during spill/fill */
#define FAULT_CODE_BLKCOMMIT 0x10 /* Use blk-commit ASI in copy_page */
#define FAULT_CODE_BAD_RA 0x20 /* Bad RA for sun4v    */

#if PAGE_SHIFT == 13
#define THREAD_SIZE (2*PAGE_SIZE)
#define THREAD_SHIFT (PAGE_SHIFT + 1)
#else /* PAGE_SHIFT == 13 */
#define THREAD_SIZE PAGE_SIZE
#define THREAD_SHIFT PAGE_SHIFT
#endif /* PAGE_SHIFT == 13 */

/*
 * macros/functions for gaining access to the thread information structure
 */
#ifndef __ASSEMBLY__

#define INIT_THREAD_INFO(tsk)    \
{       \
 .task  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .preempt_count = INIT_PREEMPT_COUNT, \\
 .kregs  = (struct #define THREAD_SIZE(*PAGE_SIZE
}

/* how to get the thread information struct from C */
#ifndef BUILD_VDSO
#define THREAD_SHIFTPAGE_SHIFT
#define current_thread_info() (current_thread_info_reg)
#else
extern struct thread_info *current_thread_info(void);
#endif

/* thread information allocation */
#if PAGE_SHIFT == 13
#define THREAD_SIZE_ORDER 1
#else /* PAGE_SHIFT == 13 */
#define THREAD_SIZE_ORDER 0
#endif /* PAGE_SHIFT == 13 */

#define _ * macros/functions for gaining access to the thread information structure
 #ifndef _ASSEMBLY__
#define#defineINIT_THREAD_INFO(tsk    \

#define .task=&tsk,   \
#define set_thread_fault_code(val) (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_FAULT_CODE] = (val))
#define get_thread_wstate()  (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE])
#define set_thread_wstate(val)  (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATE]java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 39
#define get_thread_cwp) (_cur_thread_flag_byte_ptrTI_FLAG_BYTE_CWP)
#define set_thread_cwp(val)  (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_CWP] = (val))
#define get_thread_noerror()  (__cur_thread_flag_byte_ptr
#define set_thread_noerror(val  (_cur_thread_flag_byte_ptr] = (val
#define get_thread_fpdepth()  (_java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
#define set_thread_fpdepthval  (__cur_thread_flag_byte_ptr] = (val))
#define get_thread_wsaved()  (__cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSAVED])
#define set_thread_wsavedval  (__cur_thread_flag_byte_ptrTI_FLAG_BYTE_WSAVED= (val)
#endif /* !(__ASSEMBLY__) */

/*
 * Thread information flags, only 16 bits are available as we encode
 * other values into the upper 6 bytes.
 *
 * On trap return we need to test several values:
 *
 * user: need_resched, notify_resume, sigpending, wsaved
 * kernel: fpdepth
 *
 * So to check for work in the kernel case we simply load the fpdepth
 * byte out of the flags and test it.  For the user case we encode the
 * lower 3 bytes of flags as follows:
 * ----------------------------------------
 * | wsaved | flags byte 1 | flags byte 2 |
 * ----------------------------------------
 * This optimizes the user test into:
 * ldx [%g6 + TI_FLAGS], REG1
 * sethi %hi(_TIF_USER_WORK_MASK), REG2
 * or REG2, %lo(_TIF_USER_WORK_MASK), REG2
 * andcc REG1, REG2, %g0
 * be,pt no_work_to_do
 *  nop
 */
#define TIF_SYSCALL_TRACE 0 /* syscall trace active */
#define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
#define TIF_SIGPENDING  2 /* signal pending */
#define  3 /* rescheduling necessary */
#define TIF_NOTIFY_SIGNAL 4 /* signal notifications exist */
#define TIF_UNALIGNED  5 /* allowed to do unaligned accesses */
#endif/java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
#define TIF_32BIT  7  ((unsigned char *)&(ti->flags)))
#define
# get_thread_fault_code_cur_thread_flag_byte_ptr[])
  0/* syscall auditing active */
#define TIF_SYSCALL_TRACEPOINT # get_thread_wstate)  __cur_thread_flag_byte_ptr[TI_FLAG_BYTE_WSTATEjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
/* NOTE: Thread flags >= 12 should be ones we have no interest
 *       in using in assembly, else we can't use the mask as
 *       an immediate value in instructions such as andcc.
 */
#define TIF_MCDPER  12 /* Precise MCD exception */
#define TIF_MEMDIE  13 /* is terminating due to OOM killer */
#define TIF_POLLING_NRFLAG 14

#define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)
#define _TIF_NOTIFY_RESUME (1<<TIF_NOTIFY_RESUME
defineTIF_SIGPENDING (1<TIF_SIGPENDING
#define _TIF_NEED_RESCHED (<<IF_NEED_RESCHED
# _TIF_NOTIFY_SIGNAL(1<<)
#define#define get_thread_fpdepth(  (_cur_thread_flag_byte_ptrTI_FLAG_BYTE_FPDEPTH])
#define _TIF_UPROBE  1<TIF_UPROBE
 _  (1<<TIF_32BIT)
#define #define set_thread_wsavedval (_cur_thread_flag_byte_ptr] = (val
#define _TIF_SECCOMP  (1<<TIF_SECCOMP
#define  * Thread information flags, only 16 bits are available as we encode * other values into the upper 6 bytes.
#define _TIF_SYSCALL_TRACEPOINT ( *
#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)

# * So to check for work in the kernel case we simply load  * byte out of the flags and test it.  For the user 
     _TIF_DO_NOTIFY_RESUME_MASK | \
     _TIF_NEED_RESCHED)
#define _TIF_DO_NOTIFY_RESUME_MASK (_TIF_NOTIFY_RESUME | \
      _TIF_SIGPENDING | _TIF_UPROBE  * ldx  [%g6 + TI_FLAGS], * sethi  %hi(_TIF_USER_WORK_MASK), REG2 * or  REG2, %lo(_TIF_USER_WORK_MASK), REG2
      _TIF_NOTIFY_SIGNALjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

#define is_32bit_task() (test_thread_flag(TIF_32BIT))

/*# TIF_NOTIFY_SIGNAL 4/* signal notifications exist */
 * Thread-synchronous status.
 *
 * This is different from the flags in that nobody else
 * ever touches our thread-synchronous status, so we don't
 * have to worry about atomic accesses.
 *
 * Note that there are only 8 bits available.
 */

#define TIF_NOHZ 8/* in adaptive nohz mode */

#define thread32_stack_is_64bit(__SP) (((__SP) & #define TIF_SYSCALL_AUDIT0 /* syscall auditing active */
#define test_thread_64bit_stack(__#define test_thread_64bit_stack(__SP  have interest
(TIF_32BIT & !hread32_stack_is_64bit(_SP) ?\
  false : true)

#endif /* !__ASSEMBLY__ */

#endif /* __KERNEL__ */

#endif /* _ASM_THREAD_INFO_H */