xnu-2050.24.15.tar.gz

[apple/xnu.git] / osfmk / mach / i386 / thread_status.h

diff --git a/osfmk/mach/i386/thread_status.h b/osfmk/mach/i386/thread_status.h
index 5b109ae16a17e34f525c8a57117b2746bec46e19..715422ac8f6cee59274e205168d00d947c500c84 100644 (file)
--- a/osfmk/mach/i386/thread_status.h
+++ b/osfmk/mach/i386/thread_status.h
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -61,38 +67,59 @@
 #ifndef        _MACH_I386_THREAD_STATUS_H_
 #define _MACH_I386_THREAD_STATUS_H_
 
 #ifndef        _MACH_I386_THREAD_STATUS_H_
 #define _MACH_I386_THREAD_STATUS_H_
 

+#include <mach/i386/_structs.h>
+#include <mach/message.h>

 #include <mach/i386/fp_reg.h>
 #include <mach/i386/thread_state.h>
 #include <mach/i386/fp_reg.h>
 #include <mach/i386/thread_state.h>

-#include <architecture/i386/frame.h>   /* FIXME */
-#include <architecture/i386/fpu.h>     /* FIXME */
+#include <i386/eflags.h>
+

 /*
 /*

- *     i386_thread_state       this is the structure that is exported
- *                             to user threads for use in status/mutate
- *                             calls.  This structure should never
- *                             change.
- *
- *     i386_float_state        exported to use threads for access to 
- *                             floating point registers. Try not to 
- *                             change this one, either.
+ * the i386_xxxx form is kept for legacy purposes since these types
+ * are externally known... eventually they should be deprecated.
+ * our internal implementation has moved to the following naming convention

  *
  *

- *     i386_isa_port_map_state exported to user threads to allow
- *                             selective in/out operations
- *
- *     i386_v86_assist_state 
- *
- *     thread_syscall_state 
+ *   x86_xxxx32 names are used to deal with 32 bit states
+ *   x86_xxxx64 names are used to deal with 64 bit states
+ *   x86_xxxx   names are used to deal with either 32 or 64 bit states
+ *     via a self-describing mechanism
+ */
+
+/*
+ * these are the legacy names which should be deprecated in the future
+ * they are externally known which is the only reason we don't just get
+ * rid of them
+ */
+#define i386_THREAD_STATE              1
+#define i386_FLOAT_STATE               2
+#define i386_EXCEPTION_STATE           3
+
+/*
+ * THREAD_STATE_FLAVOR_LIST 0
+ *     these are the supported flavors

  */
  */

+#define x86_THREAD_STATE32             1
+#define x86_FLOAT_STATE32              2
+#define x86_EXCEPTION_STATE32          3
+#define x86_THREAD_STATE64             4
+#define x86_FLOAT_STATE64              5
+#define x86_EXCEPTION_STATE64          6
+#define x86_THREAD_STATE               7
+#define x86_FLOAT_STATE                        8
+#define x86_EXCEPTION_STATE            9
+#define x86_DEBUG_STATE32              10
+#define x86_DEBUG_STATE64              11
+#define x86_DEBUG_STATE                        12
+#define THREAD_STATE_NONE              13
+/* 15 and 16 are used for the internal x86_SAVED_STATE flavours */
+#define x86_AVX_STATE32                        16
+#define x86_AVX_STATE64                        17

 
 

-/*     THREAD_STATE_FLAVOR_LIST 0 */
-#define i386_NEW_THREAD_STATE  1       /* used to be i386_THREAD_STATE */
-#define i386_FLOAT_STATE       2
-#define i386_ISA_PORT_MAP_STATE        3
-#define i386_V86_ASSIST_STATE  4
-#define i386_REGS_SEGS_STATE   5
-#define THREAD_SYSCALL_STATE   6
-#define THREAD_STATE_NONE      7
-#define i386_SAVED_STATE       8

 
 

+/*
+ * Largest state on this machine:
+ * (be sure mach/machine/thread_state.h matches!)
+ */
+#define THREAD_MACHINE_STATE_MAX       THREAD_STATE_MAX

 
 /*
  * VALID_THREAD_STATE_FLAVOR is a platform specific macro that when passed
 
 /*
  * VALID_THREAD_STATE_FLAVOR is a platform specific macro that when passed


@@ -100,293 +127,418 @@
  * platform. The macro must be manually updated to include all of the valid
  * exception flavors as defined above.
  */
  * platform. The macro must be manually updated to include all of the valid
  * exception flavors as defined above.
  */

-#define VALID_THREAD_STATE_FLAVOR(x)            \
-        ((x == i386_NEW_THREAD_STATE)        || \
-        (x == i386_FLOAT_STATE)             || \
-        (x == i386_ISA_PORT_MAP_STATE)      || \
-        (x == i386_V86_ASSIST_STATE)        || \
-        (x == i386_REGS_SEGS_STATE)         || \
-        (x == THREAD_SYSCALL_STATE)         || \
-        (x == THREAD_STATE_NONE)            || \
-        (x == i386_SAVED_STATE))
-
-/*
- * This structure is used for both
- * i386_THREAD_STATE and i386_REGS_SEGS_STATE.
- */
-struct i386_new_thread_state {
-       unsigned int    gs;
-       unsigned int    fs;
-       unsigned int    es;
-       unsigned int    ds;
-       unsigned int    edi;
-       unsigned int    esi;
-       unsigned int    ebp;
-       unsigned int    esp;
-       unsigned int    ebx;
-       unsigned int    edx;
-       unsigned int    ecx;
-       unsigned int    eax;
-       unsigned int    eip;
-       unsigned int    cs;
-       unsigned int    efl;
-       unsigned int    uesp;
-       unsigned int    ss;
+#define VALID_THREAD_STATE_FLAVOR(x)       \
+        ((x == x86_THREAD_STATE32)     || \
+         (x == x86_FLOAT_STATE32)      || \
+         (x == x86_EXCEPTION_STATE32)  || \
+         (x == x86_DEBUG_STATE32)      || \
+         (x == x86_THREAD_STATE64)     || \
+         (x == x86_FLOAT_STATE64)      || \
+         (x == x86_EXCEPTION_STATE64)  || \
+         (x == x86_DEBUG_STATE64)      || \
+         (x == x86_THREAD_STATE)       || \
+         (x == x86_FLOAT_STATE)        || \
+         (x == x86_EXCEPTION_STATE)    || \
+         (x == x86_DEBUG_STATE)        || \
+         (x == x86_AVX_STATE32)        || \
+         (x == x86_AVX_STATE64)        || \
+         (x == THREAD_STATE_NONE))
+
+struct x86_state_hdr {
+       int     flavor;
+       int     count;

 };
 };

-#define i386_NEW_THREAD_STATE_COUNT    \
-               (sizeof (struct i386_new_thread_state)/sizeof(unsigned int))
+typedef struct x86_state_hdr x86_state_hdr_t;

 
 /*
 
 /*

- * Subset of saved state stored by processor on kernel-to-kernel
- * trap.  (Used by ddb to examine state guaranteed to be present
- * on all traps into debugger.)
+ * Default segment register values.

  */
  */

-struct i386_saved_state_from_kernel {
-       unsigned int    gs;
-       unsigned int    fs;
-       unsigned int    es;
-       unsigned int    ds;
-       unsigned int    edi;
-       unsigned int    esi;
-       unsigned int    ebp;
-       unsigned int    esp;            /* kernel esp stored by pusha -
-                                          we save cr2 here later */
-       unsigned int    ebx;
-       unsigned int    edx;
-       unsigned int    ecx;
-       unsigned int    eax;
-       unsigned int    trapno;
-       unsigned int    err;
-       unsigned int    eip;
-       unsigned int    cs;
-       unsigned int    efl;
-};
+    
+#define USER_CODE_SELECTOR     0x0017
+#define USER_DATA_SELECTOR     0x001f
+#define KERN_CODE_SELECTOR     0x0008
+#define KERN_DATA_SELECTOR     0x0010

 
 /*
 
 /*

- * The format in which thread state is saved by Mach on this machine.  This
- * state flavor is most efficient for exception RPC's to kernel-loaded
- * servers, because copying can be avoided:
+ * to be deprecated in the future

  */
  */

-struct i386_saved_state {
-       unsigned int    gs;
-       unsigned int    fs;
-       unsigned int    es;
-       unsigned int    ds;
-       unsigned int    edi;
-       unsigned int    esi;
-       unsigned int    ebp;
-       unsigned int    esp;            /* kernel esp stored by pusha -
-                                          we save cr2 here later */
-       unsigned int    ebx;
-       unsigned int    edx;
-       unsigned int    ecx;
-       unsigned int    eax;
-       unsigned int    trapno;
-       unsigned int    err;
-       unsigned int    eip;
-       unsigned int    cs;
-       unsigned int    efl;
-       unsigned int    uesp;
-       unsigned int    ss;
-       struct v86_segs {
-           unsigned int v86_es;        /* virtual 8086 segment registers */
-           unsigned int v86_ds;
-           unsigned int v86_fs;
-           unsigned int v86_gs;
-       } v86_segs;
-#define i386_SAVED_ARGV_COUNT  7
-       unsigned int    argv_status;    /* Boolean flag indicating whether or
-                                        * not Mach copied in the args */
-       unsigned int    argv[i386_SAVED_ARGV_COUNT];
-                                       /* The return address, and the first several
-                                        * function call args from the stack, for
-                                        * efficient syscall exceptions */
-};
-#define i386_SAVED_STATE_COUNT (sizeof (struct i386_saved_state)/sizeof(unsigned int))
-#define i386_REGS_SEGS_STATE_COUNT     i386_SAVED_STATE_COUNT
+typedef _STRUCT_X86_THREAD_STATE32 i386_thread_state_t;
+#define i386_THREAD_STATE_COUNT        ((mach_msg_type_number_t) \
+    ( sizeof (i386_thread_state_t) / sizeof (int) ))
+
+typedef _STRUCT_X86_THREAD_STATE32 x86_thread_state32_t;
+#define x86_THREAD_STATE32_COUNT       ((mach_msg_type_number_t) \
+    ( sizeof (x86_thread_state32_t) / sizeof (int) ))

 
 /*
 
 /*

- * Machine-independent way for servers and Mach's exception mechanism to
- * choose the most efficient state flavor for exception RPC's:
+ * to be deprecated in the future

  */
  */

-#define MACHINE_THREAD_STATE           i386_SAVED_STATE
-#define MACHINE_THREAD_STATE_COUNT     144
+typedef _STRUCT_X86_FLOAT_STATE32 i386_float_state_t;
+#define i386_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \
+               (sizeof(i386_float_state_t)/sizeof(unsigned int)))
+
+typedef _STRUCT_X86_FLOAT_STATE32 x86_float_state32_t;
+#define x86_FLOAT_STATE32_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_float_state32_t)/sizeof(unsigned int)))
+
+typedef _STRUCT_X86_AVX_STATE32 x86_avx_state32_t;
+#define x86_AVX_STATE32_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_avx_state32_t)/sizeof(unsigned int)))

 
 /*
 
 /*

- * Largest state on this machine:
- * (be sure mach/machine/thread_state.h matches!)
+ * to be deprecated in the future

  */
  */

-#define THREAD_MACHINE_STATE_MAX       THREAD_STATE_MAX
+typedef _STRUCT_X86_EXCEPTION_STATE32 i386_exception_state_t;
+#define i386_EXCEPTION_STATE_COUNT     ((mach_msg_type_number_t) \
+    ( sizeof (i386_exception_state_t) / sizeof (int) ))

 
 

-/* 
- * Floating point state.
- *
- * fpkind tells in what way floating point operations are supported.  
- * See the values for fp_kind in <mach/i386/fp_reg.h>.
- * 
- * If the kind is FP_NO, then calls to set the state will fail, and 
- * thread_getstatus will return garbage for the rest of the state.
- * If "initialized" is false, then the rest of the state is garbage.  
- * Clients can set "initialized" to false to force the coprocessor to 
- * be reset.
- * "exc_status" is non-zero if the thread has noticed (but not 
- * proceeded from) a coprocessor exception.  It contains the status 
- * word with the exception bits set.  The status word in "fp_status" 
- * will have the exception bits turned off.  If an exception bit in 
- * "fp_status" is turned on, then "exc_status" should be zero.  This 
- * happens when the coprocessor exception is noticed after the system 
- * has context switched to some other thread.
- * 
- * If kind is FP_387, then "state" is a i387_state.  Other kinds might
- * also use i387_state, but somebody will have to verify it (XXX).
- * Note that the registers are ordered from top-of-stack down, not
- * according to physical register number.
- */
+typedef _STRUCT_X86_EXCEPTION_STATE32 x86_exception_state32_t;
+#define x86_EXCEPTION_STATE32_COUNT    ((mach_msg_type_number_t) \
+    ( sizeof (x86_exception_state32_t) / sizeof (int) ))

 
 

-#define FP_STATE_BYTES 512
+#define I386_EXCEPTION_STATE_COUNT i386_EXCEPTION_STATE_COUNT

 
 

-struct i386_float_state {
-       int             fpkind;                 /* FP_NO..FP_387 (readonly) */
-       int             initialized;
-       unsigned char   hw_state[FP_STATE_BYTES]; /* actual "hardware" state */
-       int             exc_status;             /* exception status (readonly) */
-};
-#define i386_FLOAT_STATE_COUNT \
-               (sizeof(struct i386_float_state)/sizeof(unsigned int))
+typedef _STRUCT_X86_DEBUG_STATE32 x86_debug_state32_t;
+#define x86_DEBUG_STATE32_COUNT       ((mach_msg_type_number_t) \
+       ( sizeof (x86_debug_state32_t) / sizeof (int) ))

 
 

+#define X86_DEBUG_STATE32_COUNT x86_DEBUG_STATE32_COUNT

 
 

-#define FP_old_STATE_BYTES \
-       (sizeof (struct i386_fp_save) + sizeof (struct i386_fp_regs))
+typedef _STRUCT_X86_THREAD_STATE64 x86_thread_state64_t;
+#define x86_THREAD_STATE64_COUNT       ((mach_msg_type_number_t) \
+    ( sizeof (x86_thread_state64_t) / sizeof (int) ))

 
 

-struct i386_old_float_state {
-       int             fpkind;                 /* FP_NO..FP_387 (readonly) */
-       int             initialized;
-       unsigned char   hw_state[FP_old_STATE_BYTES]; /* actual "hardware" state */
-       int             exc_status;             /* exception status (readonly) */
-};
-#define i386_old_FLOAT_STATE_COUNT \
-               (sizeof(struct i386_old_float_state)/sizeof(unsigned int))
+typedef _STRUCT_X86_FLOAT_STATE64 x86_float_state64_t;
+#define x86_FLOAT_STATE64_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_float_state64_t)/sizeof(unsigned int)))

 
 

+typedef _STRUCT_X86_AVX_STATE64 x86_avx_state64_t;
+#define x86_AVX_STATE64_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_avx_state64_t)/sizeof(unsigned int)))

 
 

-#define PORT_MAP_BITS 0x400
-struct i386_isa_port_map_state {
-       unsigned char   pm[PORT_MAP_BITS>>3];
-};
+typedef _STRUCT_X86_EXCEPTION_STATE64 x86_exception_state64_t;
+#define x86_EXCEPTION_STATE64_COUNT    ((mach_msg_type_number_t) \
+    ( sizeof (x86_exception_state64_t) / sizeof (int) ))
+
+#define X86_EXCEPTION_STATE64_COUNT x86_EXCEPTION_STATE64_COUNT

 
 

-#define i386_ISA_PORT_MAP_STATE_COUNT \
-               (sizeof(struct i386_isa_port_map_state)/sizeof(unsigned int))
+typedef _STRUCT_X86_DEBUG_STATE64 x86_debug_state64_t;
+#define x86_DEBUG_STATE64_COUNT        ((mach_msg_type_number_t) \
+    ( sizeof (x86_debug_state64_t) / sizeof (int) ))
+
+#define X86_DEBUG_STATE64_COUNT x86_DEBUG_STATE64_COUNT

 
 /*
 
 /*

- * V8086 assist supplies a pointer to an interrupt
- * descriptor table in task space.
+ * Combined thread, float and exception states

  */
  */

-struct i386_v86_assist_state {
-       unsigned int    int_table;      /* interrupt table address */
-       int             int_count;      /* interrupt table size */
+struct x86_thread_state {
+       x86_state_hdr_t                 tsh;
+       union {
+           x86_thread_state32_t        ts32;
+           x86_thread_state64_t        ts64;
+       } uts;

 };
 
 };
 

-struct v86_interrupt_table {
-       unsigned int    count;  /* count of pending interrupts */
-       unsigned short  mask;   /* ignore this interrupt if true */
-       unsigned short  vec;    /* vector to take */
+struct x86_float_state {
+       x86_state_hdr_t                 fsh;
+       union {
+               x86_float_state32_t     fs32;
+               x86_float_state64_t     fs64;
+       } ufs;

 };
 
 };
 

-#define        i386_V86_ASSIST_STATE_COUNT \
-           (sizeof(struct i386_v86_assist_state)/sizeof(unsigned int))
+struct x86_exception_state {
+       x86_state_hdr_t                 esh;
+       union {
+               x86_exception_state32_t es32;
+               x86_exception_state64_t es64;
+       } ues;
+};

 
 

-struct thread_syscall_state {
-       unsigned eax;
-       unsigned edx;
-       unsigned efl;
-       unsigned eip;
-       unsigned esp;
+struct x86_debug_state {
+       x86_state_hdr_t                 dsh;
+       union {
+               x86_debug_state32_t     ds32;
+               x86_debug_state64_t     ds64;
+       } uds;

 };
 
 };
 

-#define i386_THREAD_SYSCALL_STATE_COUNT \
-               (sizeof(struct thread_syscall_state) / sizeof(unsigned int))
+typedef struct x86_thread_state x86_thread_state_t;
+#define x86_THREAD_STATE_COUNT ((mach_msg_type_number_t) \
+               ( sizeof (x86_thread_state_t) / sizeof (int) ))
+
+typedef struct x86_float_state x86_float_state_t;
+#define x86_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_float_state_t)/sizeof(unsigned int)))
+
+typedef struct x86_exception_state x86_exception_state_t;
+#define x86_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_exception_state_t)/sizeof(unsigned int)))
+
+typedef struct x86_debug_state x86_debug_state_t;
+#define x86_DEBUG_STATE_COUNT ((mach_msg_type_number_t) \
+               (sizeof(x86_debug_state_t)/sizeof(unsigned int)))
+
+/*
+ * Machine-independent way for servers and Mach's exception mechanism to
+ * choose the most efficient state flavor for exception RPC's:
+ */
+#define MACHINE_THREAD_STATE           x86_THREAD_STATE
+#define MACHINE_THREAD_STATE_COUNT     x86_THREAD_STATE_COUNT

 
 /*
 
 /*

- * Main thread state consists of
- * general registers, segment registers,
- * eip and eflags.
+ * when reloading the segment registers on
+ * a return out of the kernel, we may take
+ * a GeneralProtection or SegmentNotPresent
+ * fault if one or more of the segment
+ * registers in the saved state was improperly
+ * specified via an x86_THREAD_STATE32 call
+ * the frame we push on top of the existing
+ * save area looks like this... we need to
+ * carry this as part of the save area
+ * in case we get hit so that we have a big
+ * enough stack

  */
  */

+struct x86_seg_load_fault32 {
+       uint16_t        trapno;
+       uint16_t        cpu;
+       uint32_t        err;
+       uint32_t        eip;
+       uint32_t        cs;
+       uint32_t        efl;
+};

 
 

-#define i386_THREAD_STATE      -1
+#ifdef XNU_KERNEL_PRIVATE

 
 

-typedef struct {
-    unsigned int       eax;
-    unsigned int       ebx;
-    unsigned int       ecx;
-    unsigned int       edx;
-    unsigned int       edi;
-    unsigned int       esi;
-    unsigned int       ebp;
-    unsigned int       esp;
-    unsigned int       ss;
-    unsigned int       eflags;
-    unsigned int       eip;
-    unsigned int       cs;
-    unsigned int       ds;
-    unsigned int       es;
-    unsigned int       fs;
-    unsigned int       gs;
-} i386_thread_state_t;
-
-#define i386_THREAD_STATE_COUNT                \
-    ( sizeof (i386_thread_state_t) / sizeof (int) )
+#define x86_SAVED_STATE32              THREAD_STATE_NONE + 1
+#define x86_SAVED_STATE64              THREAD_STATE_NONE + 2

 
 /*
 
 /*

- * Default segment register values.
+ * Subset of saved state stored by processor on kernel-to-kernel
+ * trap.  (Used by ddb to examine state guaranteed to be present
+ * on all traps into debugger.)

  */
  */

-    
-#define USER_CODE_SELECTOR     0x0017
-#define USER_DATA_SELECTOR     0x001f
-#define KERN_CODE_SELECTOR     0x0008
-#define KERN_DATA_SELECTOR     0x0010
+struct x86_saved_state32_from_kernel {
+       uint32_t        gs;
+       uint32_t        fs;
+       uint32_t        es;
+       uint32_t        ds;
+       uint32_t        edi;
+       uint32_t        esi;
+       uint32_t        ebp;
+       uint32_t        cr2;    /* kernel esp stored by pusha - we save cr2 here later */
+       uint32_t        ebx;
+       uint32_t        edx;
+       uint32_t        ecx;
+       uint32_t        eax;
+       uint16_t        trapno;
+       uint16_t        cpu;
+       uint32_t        err;
+       uint32_t        eip;
+       uint32_t        cs;
+       uint32_t        efl;
+};

 
 /*
 
 /*

- * Thread floating point state
- * includes FPU environment as
- * well as the register stack.
+ * The format in which thread state is saved by Mach on this machine.  This
+ * state flavor is most efficient for exception RPC's to kernel-loaded
+ * servers, because copying can be avoided:

  */
  */

- 
-#define i386_THREAD_FPSTATE    -2
+struct x86_saved_state32 {
+       uint32_t        gs;
+       uint32_t        fs;
+       uint32_t        es;
+       uint32_t        ds;
+       uint32_t        edi;
+       uint32_t        esi;
+       uint32_t        ebp;
+       uint32_t        cr2;    /* kernel esp stored by pusha - we save cr2 here later */
+       uint32_t        ebx;
+       uint32_t        edx;
+       uint32_t        ecx;
+       uint32_t        eax;
+       uint16_t        trapno;
+       uint16_t        cpu;
+       uint32_t        err;
+       uint32_t        eip;
+       uint32_t        cs;
+       uint32_t        efl;
+       uint32_t        uesp;
+       uint32_t        ss;
+};
+typedef struct x86_saved_state32 x86_saved_state32_t;

 
 

-typedef struct {
-    fp_env_t           environ;
-    fp_stack_t         stack;
-} i386_thread_fpstate_t;
+#define x86_SAVED_STATE32_COUNT        ((mach_msg_type_number_t) \
+       (sizeof (x86_saved_state32_t)/sizeof(unsigned int)))

 
 

-#define i386_THREAD_FPSTATE_COUNT      \
-    ( sizeof (i386_thread_fpstate_t) / sizeof (int) )
+#pragma pack(4)
+struct x86_saved_state32_tagged {
+       uint32_t                        tag;
+       struct x86_saved_state32        state;
+};
+typedef struct x86_saved_state32_tagged x86_saved_state32_tagged_t;
+/* Note: sizeof(x86_saved_state32_tagged_t) is a multiple of 16 bytes */
+
+struct x86_sframe32 {
+       /*
+        * in case we throw a fault reloading
+        * segment registers on a return out of
+        * the kernel... the 'slf' state is only kept
+        * long enough to rejigger (i.e. restore
+        * the save area to its original state)
+        * the save area and throw the appropriate
+        * kernel trap pointing to the 'ssf' state
+        */
+        struct x86_seg_load_fault32    slf;
+        struct x86_saved_state32_tagged ssf;
+};
+typedef struct x86_sframe32 x86_sframe32_t;

 
 /*
 
 /*

- * Extra state that may be
- * useful to exception handlers.
+ * This is the state pushed onto the 64-bit interrupt stack
+ * on any exception/trap/interrupt.

  */
  */

+struct x86_64_intr_stack_frame {
+       uint16_t        trapno;
+       uint16_t        cpu;
+       uint32_t        _pad;
+       uint64_t        trapfn;
+       uint64_t        err;
+       uint64_t        rip;
+       uint64_t        cs;
+       uint64_t        rflags;
+       uint64_t        rsp;
+       uint64_t        ss;
+};
+typedef struct x86_64_intr_stack_frame x86_64_intr_stack_frame_t;
+/* Note: sizeof(x86_64_intr_stack_frame_t) must be a multiple of 16 bytes */

 
 

-#define i386_THREAD_EXCEPTSTATE        -3
+/*
+ * This defines the state saved before entry into compatibility mode.
+ * The machine state is pushed automatically and the compat state is
+ * synthethized in the exception handling code.
+ */
+struct x86_saved_state_compat32 {
+       struct x86_saved_state32_tagged iss32;
+       struct x86_64_intr_stack_frame  isf64;
+};
+typedef struct x86_saved_state_compat32 x86_saved_state_compat32_t;

 
 

-typedef struct {
-    unsigned int       trapno;
-    err_code_t         err;
-} i386_thread_exceptstate_t;
+struct x86_sframe_compat32 {
+       uint32_t                        pad_for_16byte_alignment[2];
+       uint64_t                        _register_save_slot;
+        struct x86_64_intr_stack_frame  slf;
+        struct x86_saved_state_compat32 ssf;
+};
+typedef struct x86_sframe_compat32 x86_sframe_compat32_t;
+/* Note: sizeof(x86_sframe_compat32_t) must be a multiple of 16 bytes */

 
 

-#define i386_THREAD_EXCEPTSTATE_COUNT  \
-    ( sizeof (i386_thread_exceptstate_t) / sizeof (int) )
+/*
+ * thread state format for task running in 64bit long mode
+ * in long mode, the same hardware frame is always pushed regardless
+ * of whether there was a change in privlege level... therefore, there
+ * is no need for an x86_saved_state64_from_kernel variant
+ */
+struct x86_saved_state64 {
+        /*
+        * saved state organized to reflect the
+        * system call ABI register convention
+        * so that we can just pass a pointer
+        * to the saved state when calling through
+        * to the actual system call functions
+        * the ABI limits us to 6 args passed in 
+        * registers... I've add v_arg6 - v_arg8
+        * to accomodate our most 'greedy' system
+        * calls (both BSD and MACH)... the individual
+        * system call handlers will fill these in
+        * via copyin if needed...
+        */
+        uint64_t       rdi;            /* arg0 for system call */
+       uint64_t        rsi;
+       uint64_t        rdx;
+        uint64_t       r10;
+        uint64_t       r8;
+        uint64_t       r9;             /* arg5 for system call */
+        uint64_t       v_arg6;
+        uint64_t       v_arg7;
+        uint64_t       v_arg8;
+
+        uint64_t       cr2;
+        uint64_t       r15;
+        uint64_t       r14;
+        uint64_t       r13;
+        uint64_t       r12;
+        uint64_t       r11;
+       uint64_t        rbp;
+       uint64_t        rbx;
+       uint64_t        rcx;
+       uint64_t        rax;
+
+       uint32_t        gs;
+       uint32_t        fs;
+
+       uint32_t        _pad_for_tagged_alignment[3];
+
+       struct  x86_64_intr_stack_frame isf;
+};
+typedef struct x86_saved_state64 x86_saved_state64_t;
+#define x86_SAVED_STATE64_COUNT        ((mach_msg_type_number_t) \
+       (sizeof (struct x86_saved_state64)/sizeof(unsigned int)))
+
+struct x86_saved_state64_tagged {
+       uint32_t                tag;
+       x86_saved_state64_t     state;
+};
+typedef struct x86_saved_state64_tagged x86_saved_state64_tagged_t;
+
+struct x86_sframe64 {
+       uint64_t                        _register_save_slot[2];
+       struct x86_64_intr_stack_frame  slf;
+       x86_saved_state64_tagged_t      ssf;
+};
+typedef struct x86_sframe64 x86_sframe64_t;
+/* Note: sizeof(x86_sframe64_t) is a multiple of 16 bytes */
+
+extern uint32_t get_eflags_exportmask(void);

 
 /*
 
 /*

- * Per-thread variable used
- * to store 'self' id for cthreads.
+ * Unified, tagged saved state:

  */
  */

- 
-#define i386_THREAD_CTHREADSTATE       -4
- 

 typedef struct {
 typedef struct {

-    unsigned int       self;
-} i386_thread_cthreadstate_t;
-
-#define i386_THREAD_CTHREADSTATE_COUNT \
-    ( sizeof (i386_thread_cthreadstate_t) / sizeof (int) )
+       uint32_t                        flavor;
+       union {
+               x86_saved_state32_t     ss_32;
+               x86_saved_state64_t     ss_64;
+       } uss;
+} x86_saved_state_t;
+#define        ss_32   uss.ss_32
+#define        ss_64   uss.ss_64
+#pragma pack()
+
+static inline boolean_t
+is_saved_state64(x86_saved_state_t *iss)
+{
+       return (iss->flavor == x86_SAVED_STATE64);
+}
+
+static inline boolean_t
+is_saved_state32(x86_saved_state_t *iss)
+{
+       return (iss->flavor == x86_SAVED_STATE32);
+}
+
+static inline x86_saved_state32_t *
+saved_state32(x86_saved_state_t *iss)
+{
+       return &iss->ss_32; 
+}
+
+static inline x86_saved_state64_t *
+saved_state64(x86_saved_state_t *iss)
+{
+       return &iss->ss_64; 
+}
+
+#endif /* XNU_KERNEL_PRIVATE */

 
 #endif /* _MACH_I386_THREAD_STATUS_H_ */
 
 #endif /* _MACH_I386_THREAD_STATUS_H_ */