arch/um/include/sysdep-i386/ptrace.h

   1 /*
   2  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #ifndef __SYSDEP_I386_PTRACE_H
   7 #define __SYSDEP_I386_PTRACE_H
   8
   9 #include "uml-config.h"
  10
  11 #ifdef UML_CONFIG_MODE_TT
  12 #include "ptrace-tt.h"
  13 #endif
  14
  15 #ifdef UML_CONFIG_MODE_SKAS
  16 #include "ptrace-skas.h"
  17 #endif
  18
  19 #include "choose-mode.h"
  20
  21 union uml_pt_regs {
  22 #ifdef UML_CONFIG_MODE_TT
  23         struct tt_regs {
  24                 long syscall;
  25                 void *sc;
  26         } tt;
  27 #endif
  28 #ifdef UML_CONFIG_MODE_SKAS
  29         struct skas_regs {
  30                 unsigned long regs[HOST_FRAME_SIZE];
  31                 unsigned long fp[HOST_FP_SIZE];
  32                 unsigned long xfp[HOST_XFP_SIZE];
  33                 unsigned long fault_addr;
  34                 unsigned long fault_type;
  35                 unsigned long trap_type;
  36                 long syscall;
  37                 int is_user;
  38         } skas;
  39 #endif
  40 };
  41
  42 #define EMPTY_UML_PT_REGS { }
  43
  44 extern int mode_tt;
  45
  46 #define UPT_SC(r) ((r)->tt.sc)
  47 #define UPT_IP(r) \
  48         CHOOSE_MODE(SC_IP(UPT_SC(r)), REGS_IP((r)->skas.regs))
  49 #define UPT_SP(r) \
  50         CHOOSE_MODE(SC_SP(UPT_SC(r)), REGS_SP((r)->skas.regs))
  51 #define UPT_EFLAGS(r) \
  52         CHOOSE_MODE(SC_EFLAGS(UPT_SC(r)), REGS_EFLAGS((r)->skas.regs))
  53 #define UPT_EAX(r) \
  54         CHOOSE_MODE(SC_EAX(UPT_SC(r)), REGS_EAX((r)->skas.regs))
  55 #define UPT_EBX(r) \
  56         CHOOSE_MODE(SC_EBX(UPT_SC(r)), REGS_EBX((r)->skas.regs))
  57 #define UPT_ECX(r) \
  58         CHOOSE_MODE(SC_ECX(UPT_SC(r)), REGS_ECX((r)->skas.regs))
  59 #define UPT_EDX(r) \
  60         CHOOSE_MODE(SC_EDX(UPT_SC(r)), REGS_EDX((r)->skas.regs))
  61 #define UPT_ESI(r) \
  62         CHOOSE_MODE(SC_ESI(UPT_SC(r)), REGS_ESI((r)->skas.regs))
  63 #define UPT_EDI(r) \
  64         CHOOSE_MODE(SC_EDI(UPT_SC(r)), REGS_EDI((r)->skas.regs))
  65 #define UPT_EBP(r) \
  66         CHOOSE_MODE(SC_EBP(UPT_SC(r)), REGS_EBP((r)->skas.regs))
  67 #define UPT_ORIG_EAX(r) \
  68         CHOOSE_MODE((r)->tt.syscall, (r)->skas.syscall)
  69 #define UPT_CS(r) \
  70         CHOOSE_MODE(SC_CS(UPT_SC(r)), REGS_CS((r)->skas.regs))
  71 #define UPT_SS(r) \
  72         CHOOSE_MODE(SC_SS(UPT_SC(r)), REGS_SS((r)->skas.regs))
  73 #define UPT_DS(r) \
  74         CHOOSE_MODE(SC_DS(UPT_SC(r)), REGS_DS((r)->skas.regs))
  75 #define UPT_ES(r) \
  76         CHOOSE_MODE(SC_ES(UPT_SC(r)), REGS_ES((r)->skas.regs))
  77 #define UPT_FS(r) \
  78         CHOOSE_MODE(SC_FS(UPT_SC(r)), REGS_FS((r)->skas.regs))
  79 #define UPT_GS(r) \
  80         CHOOSE_MODE(SC_GS(UPT_SC(r)), REGS_GS((r)->skas.regs))
  81
  82 #define UPT_SYSCALL_ARG1(r) UPT_EBX(r)
  83 #define UPT_SYSCALL_ARG2(r) UPT_ECX(r)
  84 #define UPT_SYSCALL_ARG3(r) UPT_EDX(r)
  85 #define UPT_SYSCALL_ARG4(r) UPT_ESI(r)
  86 #define UPT_SYSCALL_ARG5(r) UPT_EDI(r)
  87 #define UPT_SYSCALL_ARG6(r) UPT_EBP(r)
  88
  89 extern int user_context(unsigned long sp);
  90
  91 #define UPT_IS_USER(r) \
  92         CHOOSE_MODE(user_context(UPT_SP(r)), (r)->skas.is_user)
  93
  94 struct syscall_args {
  95         unsigned long args[6];
  96 };
  97
  98 #define SYSCALL_ARGS(r) ((struct syscall_args) \
  99                         { .args = { UPT_SYSCALL_ARG1(r), \
 100                                     UPT_SYSCALL_ARG2(r), \
 101                                     UPT_SYSCALL_ARG3(r), \
 102                                     UPT_SYSCALL_ARG4(r), \
 103                                     UPT_SYSCALL_ARG5(r), \
 104                                     UPT_SYSCALL_ARG6(r) } } )
 105
 106 #define UPT_REG(regs, reg) \
 107         ({      unsigned long val; \
 108                 switch(reg){ \
 109                 case EIP: val = UPT_IP(regs); break; \
 110                 case UESP: val = UPT_SP(regs); break; \
 111                 case EAX: val = UPT_EAX(regs); break; \
 112                 case EBX: val = UPT_EBX(regs); break; \
 113                 case ECX: val = UPT_ECX(regs); break; \
 114                 case EDX: val = UPT_EDX(regs); break; \
 115                 case ESI: val = UPT_ESI(regs); break; \
 116                 case EDI: val = UPT_EDI(regs); break; \
 117                 case EBP: val = UPT_EBP(regs); break; \
 118                 case ORIG_EAX: val = UPT_ORIG_EAX(regs); break; \
 119                 case CS: val = UPT_CS(regs); break; \
 120                 case SS: val = UPT_SS(regs); break; \
 121                 case DS: val = UPT_DS(regs); break; \
 122                 case ES: val = UPT_ES(regs); break; \
 123                 case FS: val = UPT_FS(regs); break; \
 124                 case GS: val = UPT_GS(regs); break; \
 125                 case EFL: val = UPT_EFLAGS(regs); break; \
 126                 default :  \
 127                         panic("Bad register in UPT_REG : %d\n", reg);  \
 128                         val = -1; \
 129                 } \
 130                 val; \
 131         })
 132
 133
 134 #define UPT_SET(regs, reg, val) \
 135         do { \
 136                 switch(reg){ \
 137                 case EIP: UPT_IP(regs) = val; break; \
 138                 case UESP: UPT_SP(regs) = val; break; \
 139                 case EAX: UPT_EAX(regs) = val; break; \
 140                 case EBX: UPT_EBX(regs) = val; break; \
 141                 case ECX: UPT_ECX(regs) = val; break; \
 142                 case EDX: UPT_EDX(regs) = val; break; \
 143                 case ESI: UPT_ESI(regs) = val; break; \
 144                 case EDI: UPT_EDI(regs) = val; break; \
 145                 case EBP: UPT_EBP(regs) = val; break; \
 146                 case ORIG_EAX: UPT_ORIG_EAX(regs) = val; break; \
 147                 case CS: UPT_CS(regs) = val; break; \
 148                 case SS: UPT_SS(regs) = val; break; \
 149                 case DS: UPT_DS(regs) = val; break; \
 150                 case ES: UPT_ES(regs) = val; break; \
 151                 case FS: UPT_FS(regs) = val; break; \
 152                 case GS: UPT_GS(regs) = val; break; \
 153                 case EFL: UPT_EFLAGS(regs) = val; break; \
 154                 default :  \
 155                         panic("Bad register in UPT_SET : %d\n", reg);  \
 156                         break; \
 157                 } \
 158         } while (0)
 159
 160 #define UPT_SET_SYSCALL_RETURN(r, res) \
 161         CHOOSE_MODE(SC_SET_SYSCALL_RETURN(UPT_SC(r), (res)), \
 162                     REGS_SET_SYSCALL_RETURN((r)->skas.regs, (res)))
 163
 164 #define UPT_RESTART_SYSCALL(r) \
 165         CHOOSE_MODE(SC_RESTART_SYSCALL(UPT_SC(r)), \
 166                     REGS_RESTART_SYSCALL((r)->skas.regs))
 167
 168 #define UPT_ORIG_SYSCALL(r) UPT_EAX(r)
 169 #define UPT_SYSCALL_NR(r) UPT_ORIG_EAX(r)
 170 #define UPT_SYSCALL_RET(r) UPT_EAX(r)
 171
 172 #define UPT_SEGV_IS_FIXABLE(r) \
 173         CHOOSE_MODE(SC_SEGV_IS_FIXABLE(UPT_SC(r)), \
 174                     REGS_SEGV_IS_FIXABLE(&r->skas))
 175
 176 #define UPT_FAULT_ADDR(r) \
 177         CHOOSE_MODE(SC_FAULT_ADDR(UPT_SC(r)), REGS_FAULT_ADDR(&r->skas))
 178
 179 #define UPT_FAULT_WRITE(r) \
 180         CHOOSE_MODE(SC_FAULT_WRITE(UPT_SC(r)), REGS_FAULT_WRITE(&r->skas))
 181
 182 #endif
 183
 184 /*
 185  * Overrides for Emacs so that we follow Linus's tabbing style.
 186  * Emacs will notice this stuff at the end of the file and automatically
 187  * adjust the settings for this buffer only.  This must remain at the end
 188  * of the file.
 189  * ---------------------------------------------------------------------------
 190  * Local variables:
 191  * c-file-style: "linux"
 192  * End:
 193  */