server/context_i386.c

   1 /*
   2  * i386 register context support
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #ifdef __i386__
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #ifdef HAVE_SYS_REG_H
  28 #include <sys/reg.h>
  29 #endif
  30 #include <unistd.h>
  31 #ifdef HAVE_SYS_PTRACE_H
  32 # include <sys/ptrace.h>
  33 #endif
  34 #ifdef HAVE_SYS_PARAM_H
  35 # include <sys/param.h>
  36 #endif
  37
  38 #include "winbase.h"
  39 #include "thread.h"
  40 #include "request.h"
  41
  42 #ifndef PTRACE_PEEKUSER
  43 #  ifdef PTRACE_PEEKUSR /* libc5 uses USR not USER */
  44 #    define PTRACE_PEEKUSER PTRACE_PEEKUSR
  45 #  else
  46 #    define PTRACE_PEEKUSER PT_READ_U
  47 #  endif
  48 #endif
  49
  50 #ifndef PTRACE_POKEUSER
  51 #  ifdef PTRACE_POKEUSR /* libc5 uses USR not USER */
  52 #    define PTRACE_POKEUSER PTRACE_POKEUSR
  53 #  else
  54 #    define PTRACE_POKEUSER PT_WRITE_U
  55 #  endif
  56 #endif
  57
  58 #ifndef PTRACE_GETREGS
  59 #define PTRACE_GETREGS PT_GETREGS
  60 #endif
  61 #ifndef PTRACE_GETFPREGS
  62 #define PTRACE_GETFPREGS PT_GETFPREGS
  63 #endif
  64 #ifndef PTRACE_SETREGS
  65 #define PTRACE_SETREGS PT_SETREGS
  66 #endif
  67 #ifndef PTRACE_SETFPREGS
  68 #define PTRACE_SETFPREGS PT_SETFPREGS
  69 #endif
  70
  71 #ifdef linux
  72 #ifdef HAVE_SYS_USER_H
  73 # include <sys/user.h>
  74 #endif
  75
  76 /* user_regs definitions from asm/user.h */
  77 struct kernel_user_regs_struct
  78 {
  79     long ebx, ecx, edx, esi, edi, ebp, eax;
  80     unsigned short ds, __ds, es, __es;
  81     unsigned short fs, __fs, gs, __gs;
  82     long orig_eax, eip;
  83     unsigned short cs, __cs;
  84     long eflags, esp;
  85     unsigned short ss, __ss;
  86 };
  87
  88 /* debug register offset in struct user */
  89 #define DR_OFFSET(dr) ((int)((((struct user *)0)->u_debugreg) + (dr)))
  90
  91 /* retrieve a debug register */
  92 static inline int get_debug_reg( int pid, int num, DWORD *data )
  93 {
  94     int res = ptrace( PTRACE_PEEKUSER, pid, DR_OFFSET(num), 0 );
  95     if ((res == -1) && errno)
  96     {
  97         file_set_error();
  98         return -1;
  99     }
 100     *data = res;
 101     return 0;
 102 }
 103
 104 /* retrieve a thread context */
 105 static void get_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context )
 106 {
 107     int pid = thread->unix_pid;
 108     if (flags & CONTEXT_FULL)
 109     {
 110         struct kernel_user_regs_struct regs;
 111         if (ptrace( PTRACE_GETREGS, pid, 0, &regs ) == -1) goto error;
 112         if (flags & CONTEXT_INTEGER)
 113         {
 114             context->Eax = regs.eax;
 115             context->Ebx = regs.ebx;
 116             context->Ecx = regs.ecx;
 117             context->Edx = regs.edx;
 118             context->Esi = regs.esi;
 119             context->Edi = regs.edi;
 120         }
 121         if (flags & CONTEXT_CONTROL)
 122         {
 123             context->Ebp    = regs.ebp;
 124             context->Esp    = regs.esp;
 125             context->Eip    = regs.eip;
 126             context->SegCs  = regs.cs;
 127             context->SegSs  = regs.ss;
 128             context->EFlags = regs.eflags;
 129         }
 130         if (flags & CONTEXT_SEGMENTS)
 131         {
 132             context->SegDs = regs.ds;
 133             context->SegEs = regs.es;
 134             context->SegFs = regs.fs;
 135             context->SegGs = regs.gs;
 136         }
 137     }
 138     if (flags & CONTEXT_DEBUG_REGISTERS)
 139     {
 140         if (get_debug_reg( pid, 0, &context->Dr0 ) == -1) goto error;
 141         if (get_debug_reg( pid, 1, &context->Dr1 ) == -1) goto error;
 142         if (get_debug_reg( pid, 2, &context->Dr2 ) == -1) goto error;
 143         if (get_debug_reg( pid, 3, &context->Dr3 ) == -1) goto error;
 144         if (get_debug_reg( pid, 6, &context->Dr6 ) == -1) goto error;
 145         if (get_debug_reg( pid, 7, &context->Dr7 ) == -1) goto error;
 146     }
 147     if (flags & CONTEXT_FLOATING_POINT)
 148     {
 149         /* we can use context->FloatSave directly as it is using the */
 150         /* correct structure (the same as fsave/frstor) */
 151         if (ptrace( PTRACE_GETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error;
 152         context->FloatSave.Cr0NpxState = 0;  /* FIXME */
 153     }
 154     return;
 155  error:
 156     file_set_error();
 157 }
 158
 159
 160 /* set a thread context */
 161 static void set_thread_context( struct thread *thread, unsigned int flags, const CONTEXT *context )
 162 {
 163     int pid = thread->unix_pid;
 164     if (flags & CONTEXT_FULL)
 165     {
 166         struct kernel_user_regs_struct regs;
 167
 168         /* need to preserve some registers (at a minimum orig_eax must always be preserved) */
 169         if (ptrace( PTRACE_GETREGS, pid, 0, &regs ) == -1) goto error;
 170
 171         if (flags & CONTEXT_INTEGER)
 172         {
 173             regs.eax = context->Eax;
 174             regs.ebx = context->Ebx;
 175             regs.ecx = context->Ecx;
 176             regs.edx = context->Edx;
 177             regs.esi = context->Esi;
 178             regs.edi = context->Edi;
 179         }
 180         if (flags & CONTEXT_CONTROL)
 181         {
 182             regs.ebp = context->Ebp;
 183             regs.esp = context->Esp;
 184             regs.eip = context->Eip;
 185             regs.cs  = context->SegCs;
 186             regs.ss  = context->SegSs;
 187             regs.eflags = context->EFlags;
 188         }
 189         if (flags & CONTEXT_SEGMENTS)
 190         {
 191             regs.ds = context->SegDs;
 192             regs.es = context->SegEs;
 193             regs.fs = context->SegFs;
 194             regs.gs = context->SegGs;
 195         }
 196         if (ptrace( PTRACE_SETREGS, pid, 0, &regs ) == -1) goto error;
 197     }
 198     if (flags & CONTEXT_DEBUG_REGISTERS)
 199     {
 200         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(0), context->Dr0 ) == -1) goto error;
 201         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(1), context->Dr1 ) == -1) goto error;
 202         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(2), context->Dr2 ) == -1) goto error;
 203         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(3), context->Dr3 ) == -1) goto error;
 204         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(6), context->Dr6 ) == -1) goto error;
 205         if (ptrace( PTRACE_POKEUSER, pid, DR_OFFSET(7), context->Dr7 ) == -1) goto error;
 206     }
 207     if (flags & CONTEXT_FLOATING_POINT)
 208     {
 209         /* we can use context->FloatSave directly as it is using the */
 210         /* correct structure (the same as fsave/frstor) */
 211         if (ptrace( PTRACE_SETFPREGS, pid, 0, &context->FloatSave ) == -1) goto error;
 212     }
 213     return;
 214  error:
 215     file_set_error();
 216 }
 217
 218 #elif defined(__sun) || defined(__sun__)
 219
 220 /* retrieve a thread context */
 221 static void get_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context )
 222 {
 223     int pid = thread->unix_pid;
 224     if (flags & CONTEXT_FULL)
 225     {
 226         struct regs regs;
 227         if (ptrace( PTRACE_GETREGS, pid, 0, (int) &regs ) == -1) goto error;
 228         if (flags & CONTEXT_INTEGER)
 229         {
 230             context->Eax = regs.r_eax;
 231             context->Ebx = regs.r_ebx;
 232             context->Ecx = regs.r_ecx;
 233             context->Edx = regs.r_edx;
 234             context->Esi = regs.r_esi;
 235             context->Edi = regs.r_edi;
 236         }
 237         if (flags & CONTEXT_CONTROL)
 238         {
 239             context->Ebp    = regs.r_ebp;
 240             context->Esp    = regs.r_esp;
 241             context->Eip    = regs.r_eip;
 242             context->SegCs  = regs.r_cs & 0xffff;
 243             context->SegSs  = regs.r_ss & 0xffff;
 244             context->EFlags = regs.r_efl;
 245         }
 246         if (flags & CONTEXT_SEGMENTS)
 247         {
 248             context->SegDs = regs.r_ds & 0xffff;
 249             context->SegEs = regs.r_es & 0xffff;
 250             context->SegFs = regs.r_fs & 0xffff;
 251             context->SegGs = regs.r_gs & 0xffff;
 252         }
 253     }
 254     if (flags & CONTEXT_DEBUG_REGISTERS)
 255     {
 256         /* FIXME: How is this done on Solaris? */
 257     }
 258     if (flags & CONTEXT_FLOATING_POINT)
 259     {
 260         /* we can use context->FloatSave directly as it is using the */
 261         /* correct structure (the same as fsave/frstor) */
 262         if (ptrace( PTRACE_GETFPREGS, pid, 0, (int) &context->FloatSave ) == -1) goto error;
 263         context->FloatSave.Cr0NpxState = 0;  /* FIXME */
 264     }
 265     return;
 266  error:
 267     file_set_error();
 268 }
 269
 270
 271 /* set a thread context */
 272 static void set_thread_context( struct thread *thread, unsigned int flags, const CONTEXT *context )
 273 {
 274     int pid = thread->unix_pid;
 275     if (flags & CONTEXT_FULL)
 276     {
 277         struct regs regs;
 278         if (((flags | CONTEXT_i386) & CONTEXT_FULL) != CONTEXT_FULL)
 279         {
 280             /* need to preserve some registers */
 281             if (ptrace( PTRACE_GETREGS, pid, 0, (int) &regs ) == -1) goto error;
 282         }
 283         if (flags & CONTEXT_INTEGER)
 284         {
 285             regs.r_eax = context->Eax;
 286             regs.r_ebx = context->Ebx;
 287             regs.r_ecx = context->Ecx;
 288             regs.r_edx = context->Edx;
 289             regs.r_esi = context->Esi;
 290             regs.r_edi = context->Edi;
 291         }
 292         if (flags & CONTEXT_CONTROL)
 293         {
 294             regs.r_ebp = context->Ebp;
 295             regs.r_esp = context->Esp;
 296             regs.r_eip = context->Eip;
 297             regs.r_cs = context->SegCs;
 298             regs.r_ss = context->SegSs;
 299             regs.r_efl = context->EFlags;
 300         }
 301         if (flags & CONTEXT_SEGMENTS)
 302         {
 303             regs.r_ds = context->SegDs;
 304             regs.r_es = context->SegEs;
 305             regs.r_fs = context->SegFs;
 306             regs.r_gs = context->SegGs;
 307         }
 308         if (ptrace( PTRACE_SETREGS, pid, 0, (int) &regs ) == -1) goto error;
 309     }
 310     if (flags & CONTEXT_DEBUG_REGISTERS)
 311     {
 312         /* FIXME: How is this done on Solaris? */
 313     }
 314     if (flags & CONTEXT_FLOATING_POINT)
 315     {
 316         /* we can use context->FloatSave directly as it is using the */
 317         /* correct structure (the same as fsave/frstor) */
 318         if (ptrace( PTRACE_SETFPREGS, pid, 0, (int) &context->FloatSave ) == -1) goto error;
 319     }
 320     return;
 321  error:
 322     file_set_error();
 323 }
 324
 325 #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
 326 #include <machine/reg.h>
 327
 328 /* retrieve a thread context */
 329 static void get_thread_context( struct thread *thread, unsigned int flags, CONTEXT *context )
 330 {
 331     int pid = thread->unix_pid;
 332     if (flags & CONTEXT_FULL)
 333     {
 334         struct reg regs;
 335         if (ptrace( PTRACE_GETREGS, pid, 0, (int) &regs ) == -1) goto error;
 336         if (flags & CONTEXT_INTEGER)
 337         {
 338             context->Eax = regs.r_eax;
 339             context->Ebx = regs.r_ebx;
 340             context->Ecx = regs.r_ecx;
 341             context->Edx = regs.r_edx;
 342             context->Esi = regs.r_esi;
 343             context->Edi = regs.r_edi;
 344         }
 345         if (flags & CONTEXT_CONTROL)
 346         {
 347             context->Ebp    = regs.r_ebp;
 348             context->Esp    = regs.r_esp;
 349             context->Eip    = regs.r_eip;
 350             context->SegCs  = regs.r_cs & 0xffff;
 351             context->SegSs  = regs.r_ss & 0xffff;
 352             context->EFlags = regs.r_eflags;
 353         }
 354         if (flags & CONTEXT_SEGMENTS)
 355         {
 356             context->SegDs = regs.r_ds & 0xffff;
 357             context->SegEs = regs.r_es & 0xffff;
 358             context->SegFs = regs.r_fs & 0xffff;
 359             context->SegGs = regs.r_gs & 0xffff;
 360         }
 361     }
 362     if (flags & CONTEXT_DEBUG_REGISTERS)
 363     {
 364         /* FIXME: How is this done on FreeBSD? */
 365     }
 366     if (flags & CONTEXT_FLOATING_POINT)
 367     {
 368         /* we can use context->FloatSave directly as it is using the */
 369         /* correct structure (the same as fsave/frstor) */
 370         if (ptrace( PTRACE_GETFPREGS, pid, 0, (int) &context->FloatSave ) == -1) goto error;
 371         context->FloatSave.Cr0NpxState = 0;  /* FIXME */
 372     }
 373     return;
 374  error:
 375     file_set_error();
 376 }
 377
 378
 379 /* set a thread context */
 380 static void set_thread_context( struct thread *thread, unsigned int flags, const CONTEXT *context )
 381 {
 382     int pid = thread->unix_pid;
 383     if (flags & CONTEXT_FULL)
 384     {
 385         struct reg regs;
 386         if (((flags | CONTEXT_i386) & CONTEXT_FULL) != CONTEXT_FULL)
 387         {
 388             /* need to preserve some registers */
 389             if (ptrace( PTRACE_GETREGS, pid, 0, (int) &regs ) == -1) goto error;
 390         }
 391         if (flags & CONTEXT_INTEGER)
 392         {
 393             regs.r_eax = context->Eax;
 394             regs.r_ebx = context->Ebx;
 395             regs.r_ecx = context->Ecx;
 396             regs.r_edx = context->Edx;
 397             regs.r_esi = context->Esi;
 398             regs.r_edi = context->Edi;
 399         }
 400         if (flags & CONTEXT_CONTROL)
 401         {
 402             regs.r_ebp = context->Ebp;
 403             regs.r_esp = context->Esp;
 404             regs.r_eip = context->Eip;
 405             regs.r_cs = context->SegCs;
 406             regs.r_ss = context->SegSs;
 407             regs.r_eflags = context->EFlags;
 408         }
 409         if (flags & CONTEXT_SEGMENTS)
 410         {
 411             regs.r_ds = context->SegDs;
 412             regs.r_es = context->SegEs;
 413             regs.r_fs = context->SegFs;
 414             regs.r_gs = context->SegGs;
 415         }
 416         if (ptrace( PTRACE_SETREGS, pid, 0, (int) &regs ) == -1) goto error;
 417     }
 418     if (flags & CONTEXT_DEBUG_REGISTERS)
 419     {
 420         /* FIXME: How is this done on FreeBSD? */
 421     }
 422     if (flags & CONTEXT_FLOATING_POINT)
 423     {
 424         /* we can use context->FloatSave directly as it is using the */
 425         /* correct structure (the same as fsave/frstor) */
 426         if (ptrace( PTRACE_SETFPREGS, pid, 0, (int) &context->FloatSave ) == -1) goto error;
 427     }
 428     return;
 429  error:
 430     file_set_error();
 431 }
 432
 433 #else  /* linux || __sun__ || __FreeBSD__ */
 434 #error You must implement get/set_thread_context for your platform
 435 #endif  /* linux || __sun__ || __FreeBSD__ */
 436
 437
 438 /* copy a context structure according to the flags */
 439 static void copy_context( CONTEXT *to, const CONTEXT *from, int flags )
 440 {
 441     if (flags & CONTEXT_CONTROL)
 442     {
 443         to->Ebp    = from->Ebp;
 444         to->Eip    = from->Eip;
 445         to->Esp    = from->Esp;
 446         to->SegCs  = from->SegCs;
 447         to->SegSs  = from->SegSs;
 448         to->EFlags = from->EFlags;
 449     }
 450     if (flags & CONTEXT_INTEGER)
 451     {
 452         to->Eax = from->Eax;
 453         to->Ebx = from->Ebx;
 454         to->Ecx = from->Ecx;
 455         to->Edx = from->Edx;
 456         to->Esi = from->Esi;
 457         to->Edi = from->Edi;
 458     }
 459     if (flags & CONTEXT_SEGMENTS)
 460     {
 461         to->SegDs = from->SegDs;
 462         to->SegEs = from->SegEs;
 463         to->SegFs = from->SegFs;
 464         to->SegGs = from->SegGs;
 465     }
 466     if (flags & CONTEXT_FLOATING_POINT)
 467     {
 468         to->FloatSave = from->FloatSave;
 469     }
 470     /* we don't bother copying the debug registers, since they */
 471     /* always need to be accessed by ptrace anyway */
 472 }
 473
 474 /* retrieve the current instruction pointer of a thread */
 475 void *get_thread_ip( struct thread *thread )
 476 {
 477     CONTEXT context;
 478     context.Eip = 0;
 479     if (suspend_for_ptrace( thread ))
 480     {
 481         get_thread_context( thread, CONTEXT_CONTROL, &context );
 482         resume_thread( thread );
 483     }
 484     return (void *)context.Eip;
 485 }
 486
 487 /* determine if we should continue the thread in single-step mode */
 488 int get_thread_single_step( struct thread *thread )
 489 {
 490     CONTEXT context;
 491     if (thread->context) return 0;  /* don't single-step inside exception event */
 492     get_thread_context( thread, CONTEXT_CONTROL, &context );
 493     return (context.EFlags & 0x100) != 0;
 494 }
 495
 496 /* retrieve the current context of a thread */
 497 DECL_HANDLER(get_thread_context)
 498 {
 499     struct thread *thread;
 500     void *data;
 501     int flags = req->flags & ~CONTEXT_i386;  /* get rid of CPU id */
 502
 503     if (get_reply_max_size() < sizeof(CONTEXT))
 504     {
 505         set_error( STATUS_INVALID_PARAMETER );
 506         return;
 507     }
 508     if (!(thread = get_thread_from_handle( req->handle, THREAD_GET_CONTEXT ))) return;
 509
 510     if ((data = set_reply_data_size( sizeof(CONTEXT) )))
 511     {
 512         /* copy incoming context into reply */
 513         memset( data, 0, sizeof(CONTEXT) );
 514         memcpy( data, get_req_data(), min( get_req_data_size(), sizeof(CONTEXT) ));
 515
 516         if (thread->context)  /* thread is inside an exception event */
 517         {
 518             copy_context( data, thread->context, flags );
 519             flags &= CONTEXT_DEBUG_REGISTERS;
 520         }
 521         if (flags && suspend_for_ptrace( thread ))
 522         {
 523             get_thread_context( thread, flags, data );
 524             resume_thread( thread );
 525         }
 526     }
 527     release_object( thread );
 528 }
 529
 530
 531 /* set the current context of a thread */
 532 DECL_HANDLER(set_thread_context)
 533 {
 534     struct thread *thread;
 535     int flags = req->flags & ~CONTEXT_i386;  /* get rid of CPU id */
 536
 537     if (get_req_data_size() < sizeof(CONTEXT))
 538     {
 539         set_error( STATUS_INVALID_PARAMETER );
 540         return;
 541     }
 542     if ((thread = get_thread_from_handle( req->handle, THREAD_SET_CONTEXT )))
 543     {
 544         if (thread->context)  /* thread is inside an exception event */
 545         {
 546             copy_context( thread->context, get_req_data(), flags );
 547             flags &= CONTEXT_DEBUG_REGISTERS;
 548         }
 549         if (flags && suspend_for_ptrace( thread ))
 550         {
 551             set_thread_context( thread, flags, get_req_data() );
 552             resume_thread( thread );
 553         }
 554         release_object( thread );
 555     }
 556 }
 557
 558 #endif  /* __i386__ */