2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
|
|
|
* for more details.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1994 Waldorf GMBH
|
|
|
|
|
* Copyright (C) 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003 Ralf Baechle
|
|
|
|
|
* Copyright (C) 1996 Paul M. Antoine
|
|
|
|
|
* Copyright (C) 1999, 2000 Silicon Graphics, Inc.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _ASM_PROCESSOR_H
|
|
|
|
|
#define _ASM_PROCESSOR_H
|
|
|
|
|
|
MIPS: Use per-mm page to execute branch delay slot instructions
In some cases the kernel needs to execute an instruction from the delay
slot of an emulated branch instruction. These cases include:
- Emulated floating point branch instructions (bc1[ft]l?) for systems
which don't include an FPU, or upon which the kernel is run with the
"nofpu" parameter.
- MIPSr6 systems running binaries targeting older revisions of the
architecture, which may include branch instructions whose encodings
are no longer valid in MIPSr6.
Executing instructions from such delay slots is done by writing the
instruction to memory followed by a trap, as part of an "emuframe", and
executing it. This avoids the requirement of an emulator for the entire
MIPS instruction set. Prior to this patch such emuframes are written to
the user stack and executed from there.
This patch moves FP branch delay emuframes off of the user stack and
into a per-mm page. Allocating a page per-mm leaves userland with access
to only what it had access to previously, and compared to other
solutions is relatively simple.
When a thread requires a delay slot emulation, it is allocated a frame.
A thread may only have one frame allocated at any one time, since it may
only ever be executing one instruction at any one time. In order to
ensure that we can free up allocated frame later, its index is recorded
in struct thread_struct. In the typical case, after executing the delay
slot instruction we'll execute a break instruction with the BRK_MEMU
code. This traps back to the kernel & leads to a call to do_dsemulret
which frees the allocated frame & moves the user PC back to the
instruction that would have executed following the emulated branch.
In some cases the delay slot instruction may be invalid, such as a
branch, or may trigger an exception. In these cases the BRK_MEMU break
instruction will not be hit. In order to ensure that frames are freed
this patch introduces dsemul_thread_cleanup() and calls it to free any
allocated frame upon thread exit. If the instruction generated an
exception & leads to a signal being delivered to the thread, or indeed
if a signal simply happens to be delivered to the thread whilst it is
executing from the struct emuframe, then we need to take care to exit
the frame appropriately. This is done by either rolling back the user PC
to the branch or advancing it to the continuation PC prior to signal
delivery, using dsemul_thread_rollback(). If this were not done then a
sigreturn would return to the struct emuframe, and if that frame had
meanwhile been used in response to an emulated branch instruction within
the signal handler then we would execute the wrong user code.
Whilst a user could theoretically place something like a compact branch
to self in a delay slot and cause their thread to become stuck in an
infinite loop with the frame never being deallocated, this would:
- Only affect the users single process.
- Be architecturally invalid since there would be a branch in the
delay slot, which is forbidden.
- Be extremely unlikely to happen by mistake, and provide a program
with no more ability to harm the system than a simple infinite loop
would.
If a thread requires a delay slot emulation & no frame is available to
it (ie. the process has enough other threads that all frames are
currently in use) then the thread joins a waitqueue. It will sleep until
a frame is freed by another thread in the process.
Since we now know whether a thread has an allocated frame due to our
tracking of its index, the cookie field of struct emuframe is removed as
we can be more certain whether we have a valid frame. Since a thread may
only ever have a single frame at any given time, the epc field of struct
emuframe is also removed & the PC to continue from is instead stored in
struct thread_struct. Together these changes simplify & shrink struct
emuframe somewhat, allowing twice as many frames to fit into the page
allocated for them.
The primary benefit of this patch is that we are now free to mark the
user stack non-executable where that is possible.
Signed-off-by: Paul Burton <paul.burton@imgtec.com>
Cc: Leonid Yegoshin <leonid.yegoshin@imgtec.com>
Cc: Maciej Rozycki <maciej.rozycki@imgtec.com>
Cc: Faraz Shahbazker <faraz.shahbazker@imgtec.com>
Cc: Raghu Gandham <raghu.gandham@imgtec.com>
Cc: Matthew Fortune <matthew.fortune@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/13764/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2016-07-08 10:06:19 +00:00
|
|
|
#include <linux/atomic.h>
|
2006-04-05 08:45:45 +00:00
|
|
|
#include <linux/cpumask.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/threads.h>
|
|
|
|
|
|
|
|
|
|
#include <asm/cachectl.h>
|
|
|
|
|
#include <asm/cpu.h>
|
|
|
|
|
#include <asm/cpu-info.h>
|
MIPS: Use per-mm page to execute branch delay slot instructions
In some cases the kernel needs to execute an instruction from the delay
slot of an emulated branch instruction. These cases include:
- Emulated floating point branch instructions (bc1[ft]l?) for systems
which don't include an FPU, or upon which the kernel is run with the
"nofpu" parameter.
- MIPSr6 systems running binaries targeting older revisions of the
architecture, which may include branch instructions whose encodings
are no longer valid in MIPSr6.
Executing instructions from such delay slots is done by writing the
instruction to memory followed by a trap, as part of an "emuframe", and
executing it. This avoids the requirement of an emulator for the entire
MIPS instruction set. Prior to this patch such emuframes are written to
the user stack and executed from there.
This patch moves FP branch delay emuframes off of the user stack and
into a per-mm page. Allocating a page per-mm leaves userland with access
to only what it had access to previously, and compared to other
solutions is relatively simple.
When a thread requires a delay slot emulation, it is allocated a frame.
A thread may only have one frame allocated at any one time, since it may
only ever be executing one instruction at any one time. In order to
ensure that we can free up allocated frame later, its index is recorded
in struct thread_struct. In the typical case, after executing the delay
slot instruction we'll execute a break instruction with the BRK_MEMU
code. This traps back to the kernel & leads to a call to do_dsemulret
which frees the allocated frame & moves the user PC back to the
instruction that would have executed following the emulated branch.
In some cases the delay slot instruction may be invalid, such as a
branch, or may trigger an exception. In these cases the BRK_MEMU break
instruction will not be hit. In order to ensure that frames are freed
this patch introduces dsemul_thread_cleanup() and calls it to free any
allocated frame upon thread exit. If the instruction generated an
exception & leads to a signal being delivered to the thread, or indeed
if a signal simply happens to be delivered to the thread whilst it is
executing from the struct emuframe, then we need to take care to exit
the frame appropriately. This is done by either rolling back the user PC
to the branch or advancing it to the continuation PC prior to signal
delivery, using dsemul_thread_rollback(). If this were not done then a
sigreturn would return to the struct emuframe, and if that frame had
meanwhile been used in response to an emulated branch instruction within
the signal handler then we would execute the wrong user code.
Whilst a user could theoretically place something like a compact branch
to self in a delay slot and cause their thread to become stuck in an
infinite loop with the frame never being deallocated, this would:
- Only affect the users single process.
- Be architecturally invalid since there would be a branch in the
delay slot, which is forbidden.
- Be extremely unlikely to happen by mistake, and provide a program
with no more ability to harm the system than a simple infinite loop
would.
If a thread requires a delay slot emulation & no frame is available to
it (ie. the process has enough other threads that all frames are
currently in use) then the thread joins a waitqueue. It will sleep until
a frame is freed by another thread in the process.
Since we now know whether a thread has an allocated frame due to our
tracking of its index, the cookie field of struct emuframe is removed as
we can be more certain whether we have a valid frame. Since a thread may
only ever have a single frame at any given time, the epc field of struct
emuframe is also removed & the PC to continue from is instead stored in
struct thread_struct. Together these changes simplify & shrink struct
emuframe somewhat, allowing twice as many frames to fit into the page
allocated for them.
The primary benefit of this patch is that we are now free to mark the
user stack non-executable where that is possible.
Signed-off-by: Paul Burton <paul.burton@imgtec.com>
Cc: Leonid Yegoshin <leonid.yegoshin@imgtec.com>
Cc: Maciej Rozycki <maciej.rozycki@imgtec.com>
Cc: Faraz Shahbazker <faraz.shahbazker@imgtec.com>
Cc: Raghu Gandham <raghu.gandham@imgtec.com>
Cc: Matthew Fortune <matthew.fortune@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/13764/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2016-07-08 10:06:19 +00:00
|
|
|
#include <asm/dsemul.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/mipsregs.h>
|
|
|
|
|
#include <asm/prefetch.h>
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return current * instruction pointer ("program counter").
|
|
|
|
|
*/
|
|
|
|
|
#define current_text_addr() ({ __label__ _l; _l: &&_l;})
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* System setup and hardware flags..
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
extern unsigned int vced_count, vcei_count;
|
|
|
|
|
|
2010-07-19 20:14:56 +00:00
|
|
|
/*
|
|
|
|
|
* MIPS does have an arch_pick_mmap_layout()
|
|
|
|
|
*/
|
|
|
|
|
#define HAVE_ARCH_PICK_MMAP_LAYOUT 1
|
|
|
|
|
|
2005-09-03 22:56:16 +00:00
|
|
|
#ifdef CONFIG_32BIT
|
2012-11-22 02:34:03 +00:00
|
|
|
#ifdef CONFIG_KVM_GUEST
|
|
|
|
|
/* User space process size is limited to 1GB in KVM Guest Mode */
|
|
|
|
|
#define TASK_SIZE 0x3fff8000UL
|
|
|
|
|
#else
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* User space process size: 2GB. This is hardcoded into a few places,
|
|
|
|
|
* so don't change it unless you know what you are doing.
|
|
|
|
|
*/
|
2016-02-04 00:24:40 +00:00
|
|
|
#define TASK_SIZE 0x80000000UL
|
2012-11-22 02:34:03 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-10-14 18:32:33 +00:00
|
|
|
#define STACK_TOP_MAX TASK_SIZE
|
2010-07-19 20:14:56 +00:00
|
|
|
|
|
|
|
|
#define TASK_IS_32BIT_ADDR 1
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
2005-09-03 22:56:16 +00:00
|
|
|
#ifdef CONFIG_64BIT
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* User space process size: 1TB. This is hardcoded into a few places,
|
|
|
|
|
* so don't change it unless you know what you are doing. TASK_SIZE
|
|
|
|
|
* is limited to 1TB by the R4000 architecture; R10000 and better can
|
|
|
|
|
* support 16TB; the architectural reserve for future expansion is
|
|
|
|
|
* 8192EB ...
|
|
|
|
|
*/
|
|
|
|
|
#define TASK_SIZE32 0x7fff8000UL
|
2015-05-15 01:34:43 +00:00
|
|
|
#ifdef CONFIG_MIPS_VA_BITS_48
|
|
|
|
|
#define TASK_SIZE64 (0x1UL << ((cpu_data[0].vmbits>48)?48:cpu_data[0].vmbits))
|
|
|
|
|
#else
|
|
|
|
|
#define TASK_SIZE64 0x10000000000UL
|
|
|
|
|
#endif
|
2010-10-14 18:32:33 +00:00
|
|
|
#define TASK_SIZE (test_thread_flag(TIF_32BIT_ADDR) ? TASK_SIZE32 : TASK_SIZE64)
|
|
|
|
|
#define STACK_TOP_MAX TASK_SIZE64
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-05 06:28:59 +00:00
|
|
|
#define TASK_SIZE_OF(tsk) \
|
2010-10-14 18:32:33 +00:00
|
|
|
(test_tsk_thread_flag(tsk, TIF_32BIT_ADDR) ? TASK_SIZE32 : TASK_SIZE64)
|
2010-07-19 20:14:56 +00:00
|
|
|
|
|
|
|
|
#define TASK_IS_32BIT_ADDR test_thread_flag(TIF_32BIT_ADDR)
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
MIPS: Use per-mm page to execute branch delay slot instructions
In some cases the kernel needs to execute an instruction from the delay
slot of an emulated branch instruction. These cases include:
- Emulated floating point branch instructions (bc1[ft]l?) for systems
which don't include an FPU, or upon which the kernel is run with the
"nofpu" parameter.
- MIPSr6 systems running binaries targeting older revisions of the
architecture, which may include branch instructions whose encodings
are no longer valid in MIPSr6.
Executing instructions from such delay slots is done by writing the
instruction to memory followed by a trap, as part of an "emuframe", and
executing it. This avoids the requirement of an emulator for the entire
MIPS instruction set. Prior to this patch such emuframes are written to
the user stack and executed from there.
This patch moves FP branch delay emuframes off of the user stack and
into a per-mm page. Allocating a page per-mm leaves userland with access
to only what it had access to previously, and compared to other
solutions is relatively simple.
When a thread requires a delay slot emulation, it is allocated a frame.
A thread may only have one frame allocated at any one time, since it may
only ever be executing one instruction at any one time. In order to
ensure that we can free up allocated frame later, its index is recorded
in struct thread_struct. In the typical case, after executing the delay
slot instruction we'll execute a break instruction with the BRK_MEMU
code. This traps back to the kernel & leads to a call to do_dsemulret
which frees the allocated frame & moves the user PC back to the
instruction that would have executed following the emulated branch.
In some cases the delay slot instruction may be invalid, such as a
branch, or may trigger an exception. In these cases the BRK_MEMU break
instruction will not be hit. In order to ensure that frames are freed
this patch introduces dsemul_thread_cleanup() and calls it to free any
allocated frame upon thread exit. If the instruction generated an
exception & leads to a signal being delivered to the thread, or indeed
if a signal simply happens to be delivered to the thread whilst it is
executing from the struct emuframe, then we need to take care to exit
the frame appropriately. This is done by either rolling back the user PC
to the branch or advancing it to the continuation PC prior to signal
delivery, using dsemul_thread_rollback(). If this were not done then a
sigreturn would return to the struct emuframe, and if that frame had
meanwhile been used in response to an emulated branch instruction within
the signal handler then we would execute the wrong user code.
Whilst a user could theoretically place something like a compact branch
to self in a delay slot and cause their thread to become stuck in an
infinite loop with the frame never being deallocated, this would:
- Only affect the users single process.
- Be architecturally invalid since there would be a branch in the
delay slot, which is forbidden.
- Be extremely unlikely to happen by mistake, and provide a program
with no more ability to harm the system than a simple infinite loop
would.
If a thread requires a delay slot emulation & no frame is available to
it (ie. the process has enough other threads that all frames are
currently in use) then the thread joins a waitqueue. It will sleep until
a frame is freed by another thread in the process.
Since we now know whether a thread has an allocated frame due to our
tracking of its index, the cookie field of struct emuframe is removed as
we can be more certain whether we have a valid frame. Since a thread may
only ever have a single frame at any given time, the epc field of struct
emuframe is also removed & the PC to continue from is instead stored in
struct thread_struct. Together these changes simplify & shrink struct
emuframe somewhat, allowing twice as many frames to fit into the page
allocated for them.
The primary benefit of this patch is that we are now free to mark the
user stack non-executable where that is possible.
Signed-off-by: Paul Burton <paul.burton@imgtec.com>
Cc: Leonid Yegoshin <leonid.yegoshin@imgtec.com>
Cc: Maciej Rozycki <maciej.rozycki@imgtec.com>
Cc: Faraz Shahbazker <faraz.shahbazker@imgtec.com>
Cc: Raghu Gandham <raghu.gandham@imgtec.com>
Cc: Matthew Fortune <matthew.fortune@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/13764/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2016-07-08 10:06:19 +00:00
|
|
|
/*
|
|
|
|
|
* One page above the stack is used for branch delay slot "emulation".
|
|
|
|
|
* See dsemul.c for details.
|
|
|
|
|
*/
|
|
|
|
|
#define STACK_TOP ((TASK_SIZE & PAGE_MASK) - PAGE_SIZE)
|
2010-10-14 18:32:33 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This decides where the kernel will search for a free chunk of vm
|
|
|
|
|
* space during mmap's.
|
|
|
|
|
*/
|
|
|
|
|
#define TASK_UNMAPPED_BASE PAGE_ALIGN(TASK_SIZE / 3)
|
|
|
|
|
|
2008-02-08 12:19:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define NUM_FPU_REGS 32
|
2014-01-27 15:23:11 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_CPU_HAS_MSA
|
|
|
|
|
# define FPU_REG_WIDTH 128
|
|
|
|
|
#else
|
|
|
|
|
# define FPU_REG_WIDTH 64
|
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-02-13 11:26:41 +00:00
|
|
|
union fpureg {
|
|
|
|
|
__u32 val32[FPU_REG_WIDTH / 32];
|
|
|
|
|
__u64 val64[FPU_REG_WIDTH / 64];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CPU_LITTLE_ENDIAN
|
|
|
|
|
# define FPR_IDX(width, idx) (idx)
|
|
|
|
|
#else
|
2015-01-30 12:09:39 +00:00
|
|
|
# define FPR_IDX(width, idx) ((idx) ^ ((64 / (width)) - 1))
|
2014-02-13 11:26:41 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define BUILD_FPR_ACCESS(width) \
|
|
|
|
|
static inline u##width get_fpr##width(union fpureg *fpr, unsigned idx) \
|
|
|
|
|
{ \
|
|
|
|
|
return fpr->val##width[FPR_IDX(width, idx)]; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
static inline void set_fpr##width(union fpureg *fpr, unsigned idx, \
|
|
|
|
|
u##width val) \
|
|
|
|
|
{ \
|
|
|
|
|
fpr->val##width[FPR_IDX(width, idx)] = val; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BUILD_FPR_ACCESS(32)
|
|
|
|
|
BUILD_FPR_ACCESS(64)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
2014-01-27 15:23:01 +00:00
|
|
|
* It would be nice to add some more fields for emulator statistics,
|
|
|
|
|
* the additional information is private to the FPU emulator for now.
|
|
|
|
|
* See arch/mips/include/asm/fpu_emulator.h.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
2006-05-15 16:26:03 +00:00
|
|
|
struct mips_fpu_struct {
|
2014-02-13 11:26:41 +00:00
|
|
|
union fpureg fpr[NUM_FPU_REGS];
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int fcr31;
|
2014-01-27 15:23:11 +00:00
|
|
|
unsigned int msacsr;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2005-05-31 11:49:19 +00:00
|
|
|
#define NUM_DSP_REGS 6
|
|
|
|
|
|
|
|
|
|
typedef __u32 dspreg_t;
|
|
|
|
|
|
|
|
|
|
struct mips_dsp_state {
|
2013-01-22 11:59:30 +00:00
|
|
|
dspreg_t dspr[NUM_DSP_REGS];
|
|
|
|
|
unsigned int dspcontrol;
|
2005-05-31 11:49:19 +00:00
|
|
|
};
|
|
|
|
|
|
2006-04-05 08:45:45 +00:00
|
|
|
#define INIT_CPUMASK { \
|
|
|
|
|
{0,} \
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-23 07:05:54 +00:00
|
|
|
struct mips3264_watch_reg_state {
|
|
|
|
|
/* The width of watchlo is 32 in a 32 bit kernel and 64 in a
|
|
|
|
|
64 bit kernel. We use unsigned long as it has the same
|
|
|
|
|
property. */
|
|
|
|
|
unsigned long watchlo[NUM_WATCH_REGS];
|
|
|
|
|
/* Only the mask and IRW bits from watchhi. */
|
|
|
|
|
u16 watchhi[NUM_WATCH_REGS];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
union mips_watch_reg_state {
|
|
|
|
|
struct mips3264_watch_reg_state mips3264;
|
|
|
|
|
};
|
|
|
|
|
|
2013-06-10 06:30:00 +00:00
|
|
|
#if defined(CONFIG_CPU_CAVIUM_OCTEON)
|
2008-12-11 23:33:30 +00:00
|
|
|
|
|
|
|
|
struct octeon_cop2_state {
|
|
|
|
|
/* DMFC2 rt, 0x0201 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_crc_iv;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0202 (Set with DMTC2 rt, 0x1202) */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_crc_length;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0200 (set with DMTC2 rt, 0x4200) */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_crc_poly;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0402; DMFC2 rt, 0x040A */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_llm_dat[2];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0084 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_3des_iv;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0080; DMFC2 rt, 0x0081; DMFC2 rt, 0x0082 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_3des_key[3];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0088 (Set with DMTC2 rt, 0x0098) */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_3des_result;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0111 (FIXME: Read Pass1 Errata) */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_aes_inp0;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0102; DMFC2 rt, 0x0103 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_aes_iv[2];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0104; DMFC2 rt, 0x0105; DMFC2 rt, 0x0106; DMFC2
|
|
|
|
|
* rt, 0x0107 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_aes_key[4];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0110 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_aes_keylen;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0100; DMFC2 rt, 0x0101 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_aes_result[2];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0240; DMFC2 rt, 0x0241; DMFC2 rt, 0x0242; DMFC2
|
|
|
|
|
* rt, 0x0243; DMFC2 rt, 0x0244; DMFC2 rt, 0x0245; DMFC2 rt,
|
|
|
|
|
* 0x0246; DMFC2 rt, 0x0247; DMFC2 rt, 0x0248; DMFC2 rt,
|
|
|
|
|
* 0x0249; DMFC2 rt, 0x024A; DMFC2 rt, 0x024B; DMFC2 rt,
|
|
|
|
|
* 0x024C; DMFC2 rt, 0x024D; DMFC2 rt, 0x024E - Pass2 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_hsh_datw[15];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0250; DMFC2 rt, 0x0251; DMFC2 rt, 0x0252; DMFC2
|
|
|
|
|
* rt, 0x0253; DMFC2 rt, 0x0254; DMFC2 rt, 0x0255; DMFC2 rt,
|
|
|
|
|
* 0x0256; DMFC2 rt, 0x0257 - Pass2 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_hsh_ivw[8];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x0258; DMFC2 rt, 0x0259 - Pass2 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_gfm_mult[2];
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x025E - Pass2 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_gfm_poly;
|
2008-12-11 23:33:30 +00:00
|
|
|
/* DMFC2 rt, 0x025A; DMFC2 rt, 0x025B - Pass2 */
|
2013-01-22 11:59:30 +00:00
|
|
|
unsigned long cop2_gfm_result[2];
|
2015-01-15 13:11:07 +00:00
|
|
|
/* DMFC2 rt, 0x24F, DMFC2 rt, 0x50, OCTEON III */
|
|
|
|
|
unsigned long cop2_sha3[2];
|
2008-12-11 23:33:30 +00:00
|
|
|
};
|
2013-06-10 06:30:00 +00:00
|
|
|
#define COP2_INIT \
|
|
|
|
|
.cp2 = {0,},
|
2008-12-11 23:33:30 +00:00
|
|
|
|
|
|
|
|
struct octeon_cvmseg_state {
|
|
|
|
|
unsigned long cvmseg[CONFIG_CAVIUM_OCTEON_CVMSEG_SIZE]
|
|
|
|
|
[cpu_dcache_line_size() / sizeof(unsigned long)];
|
|
|
|
|
};
|
|
|
|
|
|
2013-06-10 06:30:04 +00:00
|
|
|
#elif defined(CONFIG_CPU_XLP)
|
|
|
|
|
struct nlm_cop2_state {
|
|
|
|
|
u64 rx[4];
|
|
|
|
|
u64 tx[4];
|
|
|
|
|
u32 tx_msg_status;
|
|
|
|
|
u32 rx_msg_status;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define COP2_INIT \
|
|
|
|
|
.cp2 = {{0}, {0}, 0, 0},
|
2013-06-10 06:30:00 +00:00
|
|
|
#else
|
|
|
|
|
#define COP2_INIT
|
2008-12-11 23:33:30 +00:00
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef struct {
|
|
|
|
|
unsigned long seg;
|
|
|
|
|
} mm_segment_t;
|
|
|
|
|
|
2014-07-11 15:46:54 +00:00
|
|
|
#ifdef CONFIG_CPU_HAS_MSA
|
|
|
|
|
# define ARCH_MIN_TASKALIGN 16
|
|
|
|
|
# define FPU_ALIGN __aligned(16)
|
|
|
|
|
#else
|
|
|
|
|
# define ARCH_MIN_TASKALIGN 8
|
|
|
|
|
# define FPU_ALIGN
|
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-05-31 11:49:19 +00:00
|
|
|
struct mips_abi;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* If you change thread_struct remember to change the #defines below too!
|
|
|
|
|
*/
|
|
|
|
|
struct thread_struct {
|
|
|
|
|
/* Saved main processor registers. */
|
|
|
|
|
unsigned long reg16;
|
|
|
|
|
unsigned long reg17, reg18, reg19, reg20, reg21, reg22, reg23;
|
|
|
|
|
unsigned long reg29, reg30, reg31;
|
|
|
|
|
|
|
|
|
|
/* Saved cp0 stuff. */
|
|
|
|
|
unsigned long cp0_status;
|
|
|
|
|
|
|
|
|
|
/* Saved fpu/fpu emulator stuff. */
|
2014-07-11 15:46:54 +00:00
|
|
|
struct mips_fpu_struct fpu FPU_ALIGN;
|
MIPS: Use per-mm page to execute branch delay slot instructions
In some cases the kernel needs to execute an instruction from the delay
slot of an emulated branch instruction. These cases include:
- Emulated floating point branch instructions (bc1[ft]l?) for systems
which don't include an FPU, or upon which the kernel is run with the
"nofpu" parameter.
- MIPSr6 systems running binaries targeting older revisions of the
architecture, which may include branch instructions whose encodings
are no longer valid in MIPSr6.
Executing instructions from such delay slots is done by writing the
instruction to memory followed by a trap, as part of an "emuframe", and
executing it. This avoids the requirement of an emulator for the entire
MIPS instruction set. Prior to this patch such emuframes are written to
the user stack and executed from there.
This patch moves FP branch delay emuframes off of the user stack and
into a per-mm page. Allocating a page per-mm leaves userland with access
to only what it had access to previously, and compared to other
solutions is relatively simple.
When a thread requires a delay slot emulation, it is allocated a frame.
A thread may only have one frame allocated at any one time, since it may
only ever be executing one instruction at any one time. In order to
ensure that we can free up allocated frame later, its index is recorded
in struct thread_struct. In the typical case, after executing the delay
slot instruction we'll execute a break instruction with the BRK_MEMU
code. This traps back to the kernel & leads to a call to do_dsemulret
which frees the allocated frame & moves the user PC back to the
instruction that would have executed following the emulated branch.
In some cases the delay slot instruction may be invalid, such as a
branch, or may trigger an exception. In these cases the BRK_MEMU break
instruction will not be hit. In order to ensure that frames are freed
this patch introduces dsemul_thread_cleanup() and calls it to free any
allocated frame upon thread exit. If the instruction generated an
exception & leads to a signal being delivered to the thread, or indeed
if a signal simply happens to be delivered to the thread whilst it is
executing from the struct emuframe, then we need to take care to exit
the frame appropriately. This is done by either rolling back the user PC
to the branch or advancing it to the continuation PC prior to signal
delivery, using dsemul_thread_rollback(). If this were not done then a
sigreturn would return to the struct emuframe, and if that frame had
meanwhile been used in response to an emulated branch instruction within
the signal handler then we would execute the wrong user code.
Whilst a user could theoretically place something like a compact branch
to self in a delay slot and cause their thread to become stuck in an
infinite loop with the frame never being deallocated, this would:
- Only affect the users single process.
- Be architecturally invalid since there would be a branch in the
delay slot, which is forbidden.
- Be extremely unlikely to happen by mistake, and provide a program
with no more ability to harm the system than a simple infinite loop
would.
If a thread requires a delay slot emulation & no frame is available to
it (ie. the process has enough other threads that all frames are
currently in use) then the thread joins a waitqueue. It will sleep until
a frame is freed by another thread in the process.
Since we now know whether a thread has an allocated frame due to our
tracking of its index, the cookie field of struct emuframe is removed as
we can be more certain whether we have a valid frame. Since a thread may
only ever have a single frame at any given time, the epc field of struct
emuframe is also removed & the PC to continue from is instead stored in
struct thread_struct. Together these changes simplify & shrink struct
emuframe somewhat, allowing twice as many frames to fit into the page
allocated for them.
The primary benefit of this patch is that we are now free to mark the
user stack non-executable where that is possible.
Signed-off-by: Paul Burton <paul.burton@imgtec.com>
Cc: Leonid Yegoshin <leonid.yegoshin@imgtec.com>
Cc: Maciej Rozycki <maciej.rozycki@imgtec.com>
Cc: Faraz Shahbazker <faraz.shahbazker@imgtec.com>
Cc: Raghu Gandham <raghu.gandham@imgtec.com>
Cc: Matthew Fortune <matthew.fortune@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/13764/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2016-07-08 10:06:19 +00:00
|
|
|
/* Assigned branch delay slot 'emulation' frame */
|
|
|
|
|
atomic_t bd_emu_frame;
|
|
|
|
|
/* PC of the branch from a branch delay slot 'emulation' */
|
|
|
|
|
unsigned long bd_emu_branch_pc;
|
|
|
|
|
/* PC to continue from following a branch delay slot 'emulation' */
|
|
|
|
|
unsigned long bd_emu_cont_pc;
|
2006-04-05 08:45:47 +00:00
|
|
|
#ifdef CONFIG_MIPS_MT_FPAFF
|
|
|
|
|
/* Emulated instruction count */
|
|
|
|
|
unsigned long emulated_fp;
|
|
|
|
|
/* Saved per-thread scheduler affinity mask */
|
|
|
|
|
cpumask_t user_cpus_allowed;
|
|
|
|
|
#endif /* CONFIG_MIPS_MT_FPAFF */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-05-31 11:49:19 +00:00
|
|
|
/* Saved state of the DSP ASE, if available. */
|
|
|
|
|
struct mips_dsp_state dsp;
|
|
|
|
|
|
2008-09-23 07:05:54 +00:00
|
|
|
/* Saved watch register state, if available. */
|
|
|
|
|
union mips_watch_reg_state watch;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Other stuff associated with the thread. */
|
|
|
|
|
unsigned long cp0_badvaddr; /* Last user fault */
|
|
|
|
|
unsigned long cp0_baduaddr; /* Last kernel fault accessing USEG */
|
|
|
|
|
unsigned long error_code;
|
2015-07-28 18:37:43 +00:00
|
|
|
unsigned long trap_nr;
|
2008-12-11 23:33:30 +00:00
|
|
|
#ifdef CONFIG_CPU_CAVIUM_OCTEON
|
2013-06-21 10:10:46 +00:00
|
|
|
struct octeon_cop2_state cp2 __attribute__ ((__aligned__(128)));
|
|
|
|
|
struct octeon_cvmseg_state cvmseg __attribute__ ((__aligned__(128)));
|
2013-06-10 06:30:04 +00:00
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_CPU_XLP
|
|
|
|
|
struct nlm_cop2_state cp2;
|
2008-12-11 23:33:30 +00:00
|
|
|
#endif
|
2005-05-31 11:49:19 +00:00
|
|
|
struct mips_abi *abi;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2006-04-05 08:45:47 +00:00
|
|
|
#ifdef CONFIG_MIPS_MT_FPAFF
|
2007-07-10 16:33:02 +00:00
|
|
|
#define FPAFF_INIT \
|
|
|
|
|
.emulated_fp = 0, \
|
|
|
|
|
.user_cpus_allowed = INIT_CPUMASK,
|
2006-04-05 08:45:47 +00:00
|
|
|
#else
|
|
|
|
|
#define FPAFF_INIT
|
|
|
|
|
#endif /* CONFIG_MIPS_MT_FPAFF */
|
|
|
|
|
|
2007-07-10 16:33:02 +00:00
|
|
|
#define INIT_THREAD { \
|
2013-01-22 11:59:30 +00:00
|
|
|
/* \
|
|
|
|
|
* Saved main processor registers \
|
|
|
|
|
*/ \
|
2007-07-10 16:33:02 +00:00
|
|
|
.reg16 = 0, \
|
|
|
|
|
.reg17 = 0, \
|
|
|
|
|
.reg18 = 0, \
|
|
|
|
|
.reg19 = 0, \
|
|
|
|
|
.reg20 = 0, \
|
|
|
|
|
.reg21 = 0, \
|
|
|
|
|
.reg22 = 0, \
|
|
|
|
|
.reg23 = 0, \
|
|
|
|
|
.reg29 = 0, \
|
|
|
|
|
.reg30 = 0, \
|
|
|
|
|
.reg31 = 0, \
|
|
|
|
|
/* \
|
|
|
|
|
* Saved cp0 stuff \
|
|
|
|
|
*/ \
|
|
|
|
|
.cp0_status = 0, \
|
|
|
|
|
/* \
|
|
|
|
|
* Saved FPU/FPU emulator stuff \
|
|
|
|
|
*/ \
|
|
|
|
|
.fpu = { \
|
2014-02-13 11:26:41 +00:00
|
|
|
.fpr = {{{0,},},}, \
|
2007-07-10 16:33:02 +00:00
|
|
|
.fcr31 = 0, \
|
2014-01-27 15:23:11 +00:00
|
|
|
.msacsr = 0, \
|
2007-07-10 16:33:02 +00:00
|
|
|
}, \
|
|
|
|
|
/* \
|
|
|
|
|
* FPU affinity state (null if not FPAFF) \
|
|
|
|
|
*/ \
|
|
|
|
|
FPAFF_INIT \
|
MIPS: Use per-mm page to execute branch delay slot instructions
In some cases the kernel needs to execute an instruction from the delay
slot of an emulated branch instruction. These cases include:
- Emulated floating point branch instructions (bc1[ft]l?) for systems
which don't include an FPU, or upon which the kernel is run with the
"nofpu" parameter.
- MIPSr6 systems running binaries targeting older revisions of the
architecture, which may include branch instructions whose encodings
are no longer valid in MIPSr6.
Executing instructions from such delay slots is done by writing the
instruction to memory followed by a trap, as part of an "emuframe", and
executing it. This avoids the requirement of an emulator for the entire
MIPS instruction set. Prior to this patch such emuframes are written to
the user stack and executed from there.
This patch moves FP branch delay emuframes off of the user stack and
into a per-mm page. Allocating a page per-mm leaves userland with access
to only what it had access to previously, and compared to other
solutions is relatively simple.
When a thread requires a delay slot emulation, it is allocated a frame.
A thread may only have one frame allocated at any one time, since it may
only ever be executing one instruction at any one time. In order to
ensure that we can free up allocated frame later, its index is recorded
in struct thread_struct. In the typical case, after executing the delay
slot instruction we'll execute a break instruction with the BRK_MEMU
code. This traps back to the kernel & leads to a call to do_dsemulret
which frees the allocated frame & moves the user PC back to the
instruction that would have executed following the emulated branch.
In some cases the delay slot instruction may be invalid, such as a
branch, or may trigger an exception. In these cases the BRK_MEMU break
instruction will not be hit. In order to ensure that frames are freed
this patch introduces dsemul_thread_cleanup() and calls it to free any
allocated frame upon thread exit. If the instruction generated an
exception & leads to a signal being delivered to the thread, or indeed
if a signal simply happens to be delivered to the thread whilst it is
executing from the struct emuframe, then we need to take care to exit
the frame appropriately. This is done by either rolling back the user PC
to the branch or advancing it to the continuation PC prior to signal
delivery, using dsemul_thread_rollback(). If this were not done then a
sigreturn would return to the struct emuframe, and if that frame had
meanwhile been used in response to an emulated branch instruction within
the signal handler then we would execute the wrong user code.
Whilst a user could theoretically place something like a compact branch
to self in a delay slot and cause their thread to become stuck in an
infinite loop with the frame never being deallocated, this would:
- Only affect the users single process.
- Be architecturally invalid since there would be a branch in the
delay slot, which is forbidden.
- Be extremely unlikely to happen by mistake, and provide a program
with no more ability to harm the system than a simple infinite loop
would.
If a thread requires a delay slot emulation & no frame is available to
it (ie. the process has enough other threads that all frames are
currently in use) then the thread joins a waitqueue. It will sleep until
a frame is freed by another thread in the process.
Since we now know whether a thread has an allocated frame due to our
tracking of its index, the cookie field of struct emuframe is removed as
we can be more certain whether we have a valid frame. Since a thread may
only ever have a single frame at any given time, the epc field of struct
emuframe is also removed & the PC to continue from is instead stored in
struct thread_struct. Together these changes simplify & shrink struct
emuframe somewhat, allowing twice as many frames to fit into the page
allocated for them.
The primary benefit of this patch is that we are now free to mark the
user stack non-executable where that is possible.
Signed-off-by: Paul Burton <paul.burton@imgtec.com>
Cc: Leonid Yegoshin <leonid.yegoshin@imgtec.com>
Cc: Maciej Rozycki <maciej.rozycki@imgtec.com>
Cc: Faraz Shahbazker <faraz.shahbazker@imgtec.com>
Cc: Raghu Gandham <raghu.gandham@imgtec.com>
Cc: Matthew Fortune <matthew.fortune@imgtec.com>
Cc: linux-mips@linux-mips.org
Patchwork: https://patchwork.linux-mips.org/patch/13764/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
2016-07-08 10:06:19 +00:00
|
|
|
/* Delay slot emulation */ \
|
|
|
|
|
.bd_emu_frame = ATOMIC_INIT(BD_EMUFRAME_NONE), \
|
|
|
|
|
.bd_emu_branch_pc = 0, \
|
|
|
|
|
.bd_emu_cont_pc = 0, \
|
2007-07-10 16:33:02 +00:00
|
|
|
/* \
|
|
|
|
|
* Saved DSP stuff \
|
|
|
|
|
*/ \
|
|
|
|
|
.dsp = { \
|
|
|
|
|
.dspr = {0, }, \
|
|
|
|
|
.dspcontrol = 0, \
|
|
|
|
|
}, \
|
2008-09-23 07:05:54 +00:00
|
|
|
/* \
|
|
|
|
|
* saved watch register stuff \
|
|
|
|
|
*/ \
|
|
|
|
|
.watch = {{{0,},},}, \
|
2007-07-10 16:33:02 +00:00
|
|
|
/* \
|
|
|
|
|
* Other stuff associated with the process \
|
|
|
|
|
*/ \
|
|
|
|
|
.cp0_badvaddr = 0, \
|
|
|
|
|
.cp0_baduaddr = 0, \
|
|
|
|
|
.error_code = 0, \
|
2015-07-28 18:37:43 +00:00
|
|
|
.trap_nr = 0, \
|
2008-12-11 23:33:30 +00:00
|
|
|
/* \
|
2013-06-10 06:30:00 +00:00
|
|
|
* Platform specific cop2 registers(null if no COP2) \
|
2008-12-11 23:33:30 +00:00
|
|
|
*/ \
|
2013-06-10 06:30:00 +00:00
|
|
|
COP2_INIT \
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct task_struct;
|
|
|
|
|
|
|
|
|
|
/* Free all resources held by a thread. */
|
|
|
|
|
#define release_thread(thread) do { } while(0)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Do necessary setup to start up a newly executed thread.
|
|
|
|
|
*/
|
|
|
|
|
extern void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp);
|
|
|
|
|
|
2016-03-26 23:07:14 +00:00
|
|
|
static inline void flush_thread(void)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long get_wchan(struct task_struct *p);
|
|
|
|
|
|
2009-07-08 17:07:50 +00:00
|
|
|
#define __KSTK_TOS(tsk) ((unsigned long)task_stack_page(tsk) + \
|
|
|
|
|
THREAD_SIZE - 32 - sizeof(struct pt_regs))
|
|
|
|
|
#define task_pt_regs(tsk) ((struct pt_regs *)__KSTK_TOS(tsk))
|
2006-01-12 09:06:07 +00:00
|
|
|
#define KSTK_EIP(tsk) (task_pt_regs(tsk)->cp0_epc)
|
|
|
|
|
#define KSTK_ESP(tsk) (task_pt_regs(tsk)->regs[29])
|
|
|
|
|
#define KSTK_STATUS(tsk) (task_pt_regs(tsk)->cp0_status)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#define cpu_relax() barrier()
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return_address is a replacement for __builtin_return_address(count)
|
|
|
|
|
* which on certain architectures cannot reasonably be implemented in GCC
|
2011-03-31 01:57:33 +00:00
|
|
|
* (MIPS, Alpha) or is unusable with -fomit-frame-pointer (i386).
|
2005-04-16 22:20:36 +00:00
|
|
|
* Note that __builtin_return_address(x>=1) is forbidden because GCC
|
|
|
|
|
* aborts compilation on some CPUs. It's simply not possible to unwind
|
|
|
|
|
* some CPU's stackframes.
|
|
|
|
|
*
|
2013-01-22 11:59:30 +00:00
|
|
|
* __builtin_return_address works only for non-leaf functions. We avoid the
|
2005-04-16 22:20:36 +00:00
|
|
|
* overhead of a function call by forcing the compiler to save the return
|
|
|
|
|
* address register on the stack.
|
|
|
|
|
*/
|
|
|
|
|
#define return_address() ({__asm__ __volatile__("":::"$31");__builtin_return_address(0);})
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CPU_HAS_PREFETCH
|
|
|
|
|
|
|
|
|
|
#define ARCH_HAS_PREFETCH
|
2010-05-14 19:44:18 +00:00
|
|
|
#define prefetch(x) __builtin_prefetch((x), 0, 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-05-14 19:44:18 +00:00
|
|
|
#define ARCH_HAS_PREFETCHW
|
|
|
|
|
#define prefetchw(x) __builtin_prefetch((x), 1, 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-01-08 12:17:37 +00:00
|
|
|
/*
|
|
|
|
|
* Functions & macros implementing the PR_GET_FP_MODE & PR_SET_FP_MODE options
|
|
|
|
|
* to the prctl syscall.
|
|
|
|
|
*/
|
|
|
|
|
extern int mips_get_process_fp_mode(struct task_struct *task);
|
|
|
|
|
extern int mips_set_process_fp_mode(struct task_struct *task,
|
|
|
|
|
unsigned int value);
|
|
|
|
|
|
|
|
|
|
#define GET_FP_MODE(task) mips_get_process_fp_mode(task)
|
|
|
|
|
#define SET_FP_MODE(task,value) mips_set_process_fp_mode(task, value)
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _ASM_PROCESSOR_H */
|
