1 2 /*--------------------------------------------------------------------*/ 3 /*--- The scheduler. pub_core_scheduler.h ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 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_SCHEDULER_H 32 #define __PUB_CORE_SCHEDULER_H 33 34 #include "pub_core_basics.h" // VG_ macro 35 #include "pub_core_threadstate.h" // VgSchedReturnCode 36 37 //-------------------------------------------------------------------- 38 // PURPOSE: This module is the scheduler, which is the main loop 39 // controlling the running of all the program's threads. 40 // It's at the centre of everything. 41 //-------------------------------------------------------------------- 42 43 /* Allocate a new ThreadState */ 44 extern ThreadId VG_(alloc_ThreadState)(void); 45 46 /* A thread exits. tid must currently be running. */ 47 extern void VG_(exit_thread)(ThreadId tid); 48 49 /* If 'tid' is blocked in a syscall, send it SIGVGKILL so as to get it 50 out of the syscall and onto doing the next thing, whatever that is. 51 If it isn't blocked in a syscall, has no effect on the thread. */ 52 extern void VG_(get_thread_out_of_syscall)(ThreadId tid); 53 54 /* This causes all threads except tid to forceably exit. They aren't actually 55 dead by the time this returns; you need to call 56 VG_(reap_threads)() to wait for them. */ 57 extern void VG_(nuke_all_threads_except) ( ThreadId me, 58 VgSchedReturnCode reason ); 59 60 /* Make a thread the running thread. The thread must previously been 61 sleeping, and not holding the CPU lock. This will set the 62 thread state to VgTs_Runnable, and the thread will attempt to take 63 the CPU lock. By the time it returns, tid will be the running 64 thread. */ 65 extern void VG_(acquire_BigLock) ( ThreadId tid, const HChar* who ); 66 67 /* Simple version, which simply acquires the lock, but does not mess 68 with the guest state in the same way as the non _LL version 69 does. */ 70 extern void VG_(acquire_BigLock_LL) ( const HChar* who ); 71 72 /* Set a thread into a sleeping state. Before the call, the thread 73 must be runnable, and holding the CPU lock. When this call 74 returns, the thread will be set to the specified sleeping state, 75 and will not be holding the CPU lock. Note that another 76 thread could be running by the time this call returns, so the 77 caller must be careful not to touch any shared state. It is also 78 the caller's responsibility to actually block until the thread is 79 ready to run again. */ 80 extern void VG_(release_BigLock) ( ThreadId tid, 81 ThreadStatus state, const HChar* who ); 82 83 /* Matching function to acquire_BigLock_LL. */ 84 extern void VG_(release_BigLock_LL) ( const HChar* who ); 85 86 /* Whether the specified thread owns the big lock. */ 87 extern Bool VG_(owns_BigLock_LL) ( ThreadId tid ); 88 89 /* Yield the CPU for a while. Drops/acquires the lock using the 90 normal (non _LL) functions. */ 91 extern void VG_(vg_yield)(void); 92 93 // The scheduler. 94 extern VgSchedReturnCode VG_(scheduler) ( ThreadId tid ); 95 96 // Initialise, phase 1. Zero out VG_(threads), decide on the root 97 // ThreadId and initialise the bigLock. 98 extern ThreadId VG_(scheduler_init_phase1) ( void ); 99 100 // Initialise, phase 2. Is passed the extent of the root thread's 101 // client stack end (highest addressable byte) and the root ThreadId 102 // decided on by phase 1. 103 extern void VG_(scheduler_init_phase2) ( ThreadId main_tid, 104 Addr clstack_end, 105 SizeT clstack_size ); 106 107 // Allows to disable the polling done to detect vgdb input 108 // or to force a poll at next scheduler call. 109 extern void VG_(disable_vgdb_poll) (void ); 110 extern void VG_(force_vgdb_poll) ( void ); 111 112 /* Stats ... */ 113 extern void VG_(print_scheduler_stats) ( void ); 114 115 /* If False, a fault is Valgrind-internal (ie, a bug) */ 116 extern Bool VG_(in_generated_code); 117 118 /* Sanity checks which may be done at any time. The scheduler decides when. */ 119 extern void VG_(sanity_check_general) ( Bool force_expensive ); 120 121 #endif // __PUB_CORE_SCHEDULER_H 122 123 /*--------------------------------------------------------------------*/ 124 /*--- end ---*/ 125 /*--------------------------------------------------------------------*/ 126