coregrind/pub_core_threadstate.h

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- The thread state.                     pub_core_threadstate.h ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2015 Julian Seward
  11       jseward@acm.org
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 #ifndef __PUB_CORE_THREADSTATE_H
  32 #define __PUB_CORE_THREADSTATE_H
  33
  34 //--------------------------------------------------------------------
  35 // PURPOSE: This module defines the ThreadState type and the
  36 // VG_(threads)[] data structure which holds all the important thread
  37 // state.  It also defines some simple operations on the data structure
  38 // that don't require any external help.  (m_scheduler does the complex
  39 // stuff).
  40 //--------------------------------------------------------------------
  41
  42 #include "pub_tool_threadstate.h"
  43 #include "pub_core_libcsetjmp.h"   // VG_MINIMAL_JMP_BUF
  44 #include "pub_core_vki.h"          // vki_sigset_t
  45 #include "pub_core_guest.h"        // VexGuestArchState
  46 #include "libvex.h"                // LibVEX_N_SPILL_BYTES
  47
  48
  49 /*------------------------------------------------------------*/
  50 /*--- Types                                                ---*/
  51 /*------------------------------------------------------------*/
  52
  53 /*
  54    Thread state machine:
  55
  56    Empty -> Init -> Runnable <=> WaitSys/Yielding
  57      ^                 |
  58      \---- Zombie -----/
  59  */
  60 typedef
  61    enum ThreadStatus {
  62       VgTs_Empty,      /* this slot is not in use */
  63       VgTs_Init,       /* just allocated */
  64       VgTs_Runnable,   /* ready to run */
  65       VgTs_WaitSys,    /* waiting for a syscall to complete */
  66       VgTs_Yielding,   /* temporarily yielding the CPU */
  67       VgTs_Zombie,     /* transient state just before exiting */
  68    }
  69    ThreadStatus;
  70
  71 /* Return codes from the scheduler. */
  72 typedef
  73    enum {
  74       VgSrc_None,        /* not exiting yet */
  75       VgSrc_ExitThread,  /* just this thread is exiting */
  76       VgSrc_ExitProcess, /* this thread is exiting due to another thread
  77                             calling exit() */
  78       VgSrc_FatalSig     /* Killed by the default action of a fatal
  79                             signal */
  80    }
  81    VgSchedReturnCode;
  82
  83
  84 /* Forward declarations */
  85 struct SyscallStatus;
  86 struct SyscallArgs;
  87
  88 /* Architecture-specific thread state */
  89 typedef
  90    struct {
  91       /* --- BEGIN vex-mandated guest state --- */
  92
  93       /* Note that for code generation reasons, we require that the
  94          guest state area, its two shadows, and the spill area, are
  95          aligned on LibVEX_GUEST_STATE_ALIGN and have sizes, such that
  96          there are no holes in between. This is checked by do_pre_run_checks()
  97          in scheduler.c. */
  98
  99       /* Saved machine context. */
 100       VexGuestArchState vex __attribute__((aligned(LibVEX_GUEST_STATE_ALIGN)));
 101
 102       /* Saved shadow context (2 copies). */
 103       VexGuestArchState vex_shadow1
 104                         __attribute__((aligned(LibVEX_GUEST_STATE_ALIGN)));
 105       VexGuestArchState vex_shadow2
 106                         __attribute__((aligned(LibVEX_GUEST_STATE_ALIGN)));
 107
 108       /* Spill area. */
 109       UChar vex_spill[LibVEX_N_SPILL_BYTES]
 110             __attribute__((aligned(LibVEX_GUEST_STATE_ALIGN)));
 111
 112       /* --- END vex-mandated guest state --- */
 113    }
 114    ThreadArchState;
 115
 116
 117 /* OS-specific thread state.  IMPORTANT: if you add fields to this,
 118    you _must_ add code to os_state_clear() to initialise those
 119    fields. */
 120 typedef
 121    struct {
 122       /* who we are */
 123       Int lwpid;        // PID of kernel task  (Darwin: Mach thread)
 124       Int threadgroup;  // thread group id
 125
 126       ThreadId parent;  // parent tid (if any)
 127
 128       /* runtime details */
 129       Addr valgrind_stack_base;    // Valgrind's stack (VgStack*)
 130       Addr valgrind_stack_init_SP; // starting value for SP
 131
 132       /* exit details */
 133       Word exitcode; // in the case of exitgroup, set by someone else
 134       Int  fatalsig; // fatal signal
 135
 136 #     if defined(VGO_darwin)
 137       // Mach trap POST handler as chosen by PRE
 138       void (*post_mach_trap_fn)(ThreadId tid,
 139                                 struct SyscallArgs *, struct SyscallStatus *);
 140
 141       // This thread's pthread
 142       Addr pthread;
 143
 144       // Argument passed when thread started
 145       Addr func_arg;
 146
 147       // Synchronization between child thread and parent thread's POST wrapper
 148       semaphore_t child_go;
 149       semaphore_t child_done;
 150
 151       // Workqueue re-entry
 152       // (setjmp in PRE(workq_ops), longjmp in wqthread_hijack)
 153       // DDD: JRS fixme: this comment is no longer correct; wq_jmpbuf is
 154       // never used, and there is no such setjmp or longjmp pair.
 155       // I guess we could leave wq_jmpbuf_valid in place though, since
 156       // it does allow for an assertion in ML_(wqthread_continue_NORETURN).
 157       Bool wq_jmpbuf_valid;
 158       //jmp_buf wq_jmpbuf;
 159
 160       // Values saved from transient Mach RPC messages
 161       Addr remote_port;  // destination for original message
 162       Int msgh_id;       // outgoing message id
 163       union {
 164          struct {
 165             Addr port;
 166          } mach_port;
 167          struct {
 168             Int right;
 169          } mach_port_allocate;
 170          struct {
 171             Addr port;
 172             Int right;
 173             Int delta;
 174          } mach_port_mod_refs;
 175          struct {
 176             Addr task;
 177             Addr name;
 178             Int disposition;
 179          } mach_port_insert_right;
 180          struct {
 181             Addr size;
 182             int flags;
 183          } vm_allocate;
 184          struct {
 185             Addr address;
 186             Addr size;
 187          } vm_deallocate;
 188          struct {
 189             Addr src;
 190             Addr dst;
 191             Addr size;
 192          } vm_copy;
 193          struct {
 194             Addr address;
 195             Addr size;
 196             int set_maximum;
 197             UWord new_protection;
 198          } vm_protect;
 199          struct {
 200             Addr addr;
 201             SizeT size;
 202          } vm_read;
 203          struct {
 204             ULong addr;
 205             ULong size;
 206          } mach_vm_read;
 207          struct {
 208             Addr addr;
 209             SizeT size;
 210             Addr data;
 211          } vm_read_overwrite;
 212          struct {
 213             Addr size;
 214             int copy;
 215             UWord protection;
 216          } vm_map;
 217          struct {
 218             Addr size;
 219          } vm_remap;
 220          struct {
 221             ULong size;
 222             int flags;
 223          } mach_vm_allocate;
 224          struct {
 225             ULong address;
 226             ULong size;
 227          } mach_vm_deallocate;
 228          struct {
 229             ULong address;
 230             ULong size;
 231             int set_maximum;
 232             unsigned int new_protection;
 233          } mach_vm_protect;
 234          struct {
 235             ULong size;
 236             int copy;
 237             UWord protection;
 238          } mach_vm_map;
 239          struct {
 240             ULong size;
 241             int copy;
 242          } mach_vm_remap;
 243          struct {
 244             Addr thread;
 245             UWord flavor;
 246          } thread_get_state;
 247          struct {
 248             Addr address;
 249          } io_connect_unmap_memory;
 250          struct {
 251             int which_port;
 252          } task_get_special_port;
 253          struct {
 254             int which;
 255          } host_get_special_port;
 256          struct {
 257             char *service_name;
 258          } bootstrap_look_up;
 259          struct {
 260             vki_size_t size;
 261          } WindowServer_29828;
 262          struct {
 263             Int access_rights;
 264          } WindowServer_29831;
 265          struct {
 266             char *path;
 267          } io_registry_entry_from_path;
 268       } mach_args;
 269
 270 #     elif defined(VGO_solaris)
 271 #     if defined(VGP_x86_solaris)
 272       /* A pointer to thread related data. The pointer is used to set up
 273          a segment descriptor (GDT[VKI_GDT_LWPGS]) when the thread is about to
 274          be run. A client program sets this value explicitly by calling the
 275          lwp_private syscall or it can be passed as a part of ucontext_t when
 276          a new thread is created (the lwp_create syscall). */
 277       Addr thrptr;
 278 #     elif defined(VGP_amd64_solaris)
 279       /* GDT is not fully simulated by AMD64/Solaris. The %fs segment
 280          register is assumed to be always zero and vex->guest_FS_CONST holds
 281          the 64-bit offset associated with a %fs value of zero. */
 282 #     endif
 283
 284       /* Stack id (value (UWord)(-1) means that there is no stack). This
 285          tracks a stack that is set in restore_stack(). */
 286       UWord stk_id;
 287
 288       /* Simulation of the kernel's lwp->lwp_ustack. Set in the PRE wrapper
 289          of the getsetcontext syscall, for SETUSTACK. Used in
 290          VG_(save_context)(), VG_(restore_context)() and
 291          VG_(sigframe_create)(). */
 292       vki_stack_t *ustack;
 293
 294       /* Flag saying if the current call is in the door_return() variant of
 295          the door() syscall. */
 296       Bool in_door_return;
 297
 298       /* Address of the door server procedure corresponding to the current
 299          thread. Used to keep track which door call the current thread
 300          services. Valid only between subsequent door_return() invocations. */
 301       Addr door_return_procedure;
 302
 303       /* Simulation of the kernel's lwp->lwp_oldcontext. Set in
 304          VG_(restore_context)() and VG_(sigframe_create)(). Used in
 305          VG_(save_context)(). */
 306       vki_ucontext_t *oldcontext;
 307
 308       /* Address of sc_shared_t struct shared between kernel and libc.
 309          Set in POST(sys_schedctl). Every thread gets its own address
 310          but typically many are squeezed on a singled mapped page.
 311          Cleaned in the child atfork handler. */
 312       Addr schedctl_data;
 313
 314       /* True if this is daemon thread. */
 315       Bool daemon_thread;
 316 #     endif
 317
 318    }
 319    ThreadOSstate;
 320
 321
 322 /* Overall thread state */
 323 typedef struct {
 324    /* ThreadId == 0 (and hence vg_threads[0]) is NEVER USED.
 325       The thread identity is simply the index in vg_threads[].
 326       ThreadId == 1 is the root thread and has the special property
 327       that we don't try and allocate or deallocate its stack.  For
 328       convenience of generating error message, we also put the
 329       ThreadId in this tid field, but be aware that it should
 330       ALWAYS == the index in vg_threads[]. */
 331    ThreadId tid;
 332
 333    /* Current scheduling status. */
 334    ThreadStatus status;
 335
 336    /* This is set if the thread is in the process of exiting for any
 337       reason.  The precise details of the exit are in the OS-specific
 338       state. */
 339    VgSchedReturnCode exitreason;
 340
 341    /* Architecture-specific thread state. */
 342    ThreadArchState arch;
 343
 344    /* This thread's blocked-signals mask.  Semantics is that for a
 345       signal to be delivered to this thread, the signal must not be
 346       blocked by this signal mask.  If more than one thread accepts a
 347       signal, then it will be delivered to one at random.  If all
 348       threads block the signal, it will remain pending until either a
 349       thread unblocks it or someone uses sigwaitsig/sigtimedwait. */
 350    vki_sigset_t sig_mask;
 351
 352    /* tmp_sig_mask is usually the same as sig_mask, and is kept in
 353       sync whenever sig_mask is changed.  The only time they have
 354       different values is during the execution of a sigsuspend, where
 355       tmp_sig_mask is the temporary mask which sigsuspend installs.
 356       It is only consulted to compute the signal mask applied to a
 357       signal handler. */
 358    vki_sigset_t tmp_sig_mask;
 359
 360    /* A little signal queue for signals we can't get the kernel to
 361       queue for us.  This is only allocated as needed, since it should
 362       be rare. */
 363    struct SigQueue *sig_queue;
 364
 365    /* Client stacks.  When a thread slot is freed, we don't deallocate its
 366       stack; we just leave it lying around for the next use of the
 367       slot.  If the next use of the slot requires a larger stack,
 368       only then is the old one deallocated and a new one
 369       allocated.
 370
 371       For the main thread (threadid == 1), this mechanism doesn't
 372       apply.  We don't know the size of the stack since we didn't
 373       allocate it, and furthermore we never reallocate it. */
 374
 375    /* The allocated size of this thread's stack */
 376    SizeT client_stack_szB;
 377
 378    /* Address of the highest legitimate byte in this stack.  This is
 379       used for error messages only -- not critical for execution
 380       correctness.  Is is set for all stacks, specifically including
 381       ThreadId == 1 (the main thread). */
 382    Addr client_stack_highest_byte;
 383
 384    /* Alternate signal stack */
 385    vki_stack_t altstack;
 386
 387    /* OS-specific thread state */
 388    ThreadOSstate os_state;
 389
 390    /* Error disablement level.  A counter which allows selectively
 391       disabling error reporting in threads.  When zero, reporting is
 392       enabled.  When nonzero, it is disabled.  This is controlled by
 393       the client request 'VG_USERREQ__CHANGE_ERR_DISABLEMENT'.  New
 394       threads are always created with this as zero (errors
 395       enabled). */
 396    UInt err_disablement_level;
 397
 398    /* Per-thread jmp_buf to resume scheduler after a signal */
 399    Bool               sched_jmpbuf_valid;
 400    VG_MINIMAL_JMP_BUF(sched_jmpbuf);
 401
 402    /* This thread's name. NULL, if no name. */
 403    HChar *thread_name;
 404 }
 405 ThreadState;
 406
 407
 408 /*------------------------------------------------------------*/
 409 /*--- The thread table.                                    ---*/
 410 /*------------------------------------------------------------*/
 411
 412 /* A statically allocated array of threads.  NOTE: [0] is
 413    never used, to simplify the simulation of initialisers for
 414    LinuxThreads. */
 415 extern ThreadState *VG_(threads);
 416
 417 // The running thread.  m_scheduler should be the only other module
 418 // to write to this.
 419 extern ThreadId VG_(running_tid);
 420
 421
 422 /*------------------------------------------------------------*/
 423 /*--- Basic operations on the thread table.                ---*/
 424 /*------------------------------------------------------------*/
 425
 426 /* Initialize the m_threadstate module. */
 427 void VG_(init_Threads)(void);
 428
 429 // Convert a ThreadStatus to a string.
 430 const HChar* VG_(name_of_ThreadStatus) ( ThreadStatus status );
 431
 432 // Convert a VgSchedReturnCode to a string.
 433 const HChar* VG_(name_of_VgSchedReturnCode) ( VgSchedReturnCode retcode );
 434
 435 /* Get the ThreadState for a particular thread */
 436 extern ThreadState *VG_(get_ThreadState) ( ThreadId tid );
 437
 438 /* Check that tid is in range and denotes a non-Empty thread. */
 439 extern Bool VG_(is_valid_tid) ( ThreadId tid );
 440
 441 /* Returns true if a thread is currently running (ie, has the CPU lock) */
 442 extern Bool VG_(is_running_thread)(ThreadId tid);
 443
 444 /* Returns true if the thread is in the process of exiting */
 445 extern Bool VG_(is_exiting)(ThreadId tid);
 446
 447 /* Return the number of non-dead Threads */
 448 extern Int VG_(count_living_threads)(void);
 449
 450 /* Return the number of threads in VgTs_Runnable state */
 451 extern Int VG_(count_runnable_threads)(void);
 452
 453 /* Given an LWP id (ie, real kernel thread id), find the corresponding
 454    ThreadId */
 455 extern ThreadId VG_(lwpid_to_vgtid)(Int lwpid);
 456
 457 #endif   // __PUB_CORE_THREADSTATE_H
 458
 459 /*--------------------------------------------------------------------*/
 460 /*--- end                                                          ---*/
 461 /*--------------------------------------------------------------------*/