sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 1 | /* |
bart | 86562bd | 2009-02-16 19:43:56 +0000 | [diff] [blame] | 2 | This file is part of drd, a thread error detector. |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 3 | |
Elliott Hughes | ed39800 | 2017-06-21 14:41:24 -0700 | [diff] [blame] | 4 | Copyright (C) 2006-2017 Bart Van Assche <bvanassche@acm.org>. |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 5 | |
| 6 | This program is free software; you can redistribute it and/or |
| 7 | modify it under the terms of the GNU General Public License as |
| 8 | published by the Free Software Foundation; either version 2 of the |
| 9 | License, or (at your option) any later version. |
| 10 | |
| 11 | This program is distributed in the hope that it will be useful, but |
| 12 | WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | General Public License for more details. |
| 15 | |
| 16 | You should have received a copy of the GNU General Public License |
| 17 | along with this program; if not, write to the Free Software |
| 18 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 19 | 02111-1307, USA. |
| 20 | |
| 21 | The GNU General Public License is contained in the file COPYING. |
| 22 | */ |
| 23 | |
| 24 | |
bart | 09dc13f | 2009-02-14 15:13:31 +0000 | [diff] [blame] | 25 | #include "drd_barrier.h" |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 26 | #include "drd_clientreq.h" |
| 27 | #include "drd_cond.h" |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 28 | #include "drd_error.h" |
bart | 62cc232 | 2010-03-07 10:54:21 +0000 | [diff] [blame] | 29 | #include "drd_hb.h" |
bart | 83c1780 | 2009-03-10 09:26:07 +0000 | [diff] [blame] | 30 | #include "drd_load_store.h" |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 31 | #include "drd_malloc_wrappers.h" |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 32 | #include "drd_mutex.h" |
bart | 09dc13f | 2009-02-14 15:13:31 +0000 | [diff] [blame] | 33 | #include "drd_rwlock.h" |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 34 | #include "drd_semaphore.h" |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 35 | #include "drd_suppression.h" // drd_start_suppression() |
| 36 | #include "drd_thread.h" |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 37 | #include "pub_tool_basics.h" // Bool |
| 38 | #include "pub_tool_libcassert.h" |
| 39 | #include "pub_tool_libcassert.h" // tl_assert() |
| 40 | #include "pub_tool_libcprint.h" // VG_(message)() |
| 41 | #include "pub_tool_machine.h" // VG_(get_SP)() |
| 42 | #include "pub_tool_threadstate.h" |
| 43 | #include "pub_tool_tooliface.h" // VG_(needs_...)() |
| 44 | |
| 45 | |
bart | 7d5f523 | 2011-03-13 09:08:10 +0000 | [diff] [blame] | 46 | /* Global variables. */ |
| 47 | |
| 48 | Bool DRD_(g_free_is_write); |
| 49 | |
| 50 | |
bart | 09dc13f | 2009-02-14 15:13:31 +0000 | [diff] [blame] | 51 | /* Local function declarations. */ |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 52 | |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 53 | static Bool handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret); |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 54 | |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 55 | |
bart | 03ffb2e | 2009-02-15 10:36:32 +0000 | [diff] [blame] | 56 | /* Function definitions. */ |
| 57 | |
bart | 09dc13f | 2009-02-14 15:13:31 +0000 | [diff] [blame] | 58 | /** |
bart | 03ffb2e | 2009-02-15 10:36:32 +0000 | [diff] [blame] | 59 | * Tell the Valgrind core the address of the DRD function that processes |
| 60 | * client requests. Must be called before any client code is run. |
bart | f1ac71a | 2008-04-04 16:54:37 +0000 | [diff] [blame] | 61 | */ |
bart | 03ffb2e | 2009-02-15 10:36:32 +0000 | [diff] [blame] | 62 | void DRD_(clientreq_init)(void) |
bart | f1ac71a | 2008-04-04 16:54:37 +0000 | [diff] [blame] | 63 | { |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 64 | VG_(needs_client_requests)(handle_client_request); |
bart | f1ac71a | 2008-04-04 16:54:37 +0000 | [diff] [blame] | 65 | } |
| 66 | |
bart | 09dc13f | 2009-02-14 15:13:31 +0000 | [diff] [blame] | 67 | /** |
| 68 | * DRD's handler for Valgrind client requests. The code below handles both |
| 69 | * DRD's public and tool-internal client requests. |
| 70 | */ |
Elliott Hughes | ed39800 | 2017-06-21 14:41:24 -0700 | [diff] [blame] | 71 | #if defined(VGP_mips32_linux) || defined(VGP_mips64_linux) |
sewardj | 5db1540 | 2012-06-07 09:13:21 +0000 | [diff] [blame] | 72 | /* There is a cse related issue in gcc for MIPS. Optimization level |
| 73 | has to be lowered, so cse related optimizations are not |
| 74 | included. */ |
| 75 | __attribute__((optimize("O1"))) |
| 76 | #endif |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 77 | static Bool handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret) |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 78 | { |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 79 | UWord result = 0; |
| 80 | const DrdThreadId drd_tid = DRD_(thread_get_running_tid)(); |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 81 | |
Elliott Hughes | a0664b9 | 2017-04-18 17:46:52 -0700 | [diff] [blame] | 82 | tl_assert(vg_tid == VG_(get_running_tid)()); |
philippe | 1371595 | 2013-12-21 16:57:26 +0000 | [diff] [blame] | 83 | tl_assert(DRD_(VgThreadIdToDrdThreadId)(vg_tid) == drd_tid |
| 84 | || (VG_USERREQ__GDB_MONITOR_COMMAND == arg[0] |
| 85 | && vg_tid == VG_INVALID_THREADID)); |
| 86 | /* Check the consistency of vg_tid and drd_tid, unless |
Elliott Hughes | ed39800 | 2017-06-21 14:41:24 -0700 | [diff] [blame] | 87 | vgdb has forced the invocation of a gdb monitor cmd |
philippe | 1371595 | 2013-12-21 16:57:26 +0000 | [diff] [blame] | 88 | when no threads was running (i.e. all threads blocked |
| 89 | in a syscall. In such a case, vg_tid is invalid, |
| 90 | its conversion to a drd thread id gives also an invalid |
| 91 | drd thread id, but drd_tid is not invalid (probably |
| 92 | equal to the last running drd thread. */ |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 93 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 94 | switch (arg[0]) |
| 95 | { |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 96 | case VG_USERREQ__MALLOCLIKE_BLOCK: |
bart | 7d5f523 | 2011-03-13 09:08:10 +0000 | [diff] [blame] | 97 | if (DRD_(g_free_is_write)) { |
| 98 | GenericErrInfo GEI = { |
| 99 | .tid = DRD_(thread_get_running_tid)(), |
| 100 | .addr = 0, |
| 101 | }; |
| 102 | VG_(maybe_record_error)(vg_tid, |
| 103 | GenericErr, |
| 104 | VG_(get_IP)(vg_tid), |
| 105 | "--free-is-write=yes is incompatible with" |
| 106 | " custom memory allocator client requests", |
| 107 | &GEI); |
| 108 | } |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 109 | if (arg[1]) |
| 110 | DRD_(malloclike_block)(vg_tid, arg[1]/*addr*/, arg[2]/*size*/); |
| 111 | break; |
| 112 | |
bart | 9134738 | 2011-03-25 20:07:25 +0000 | [diff] [blame] | 113 | case VG_USERREQ__RESIZEINPLACE_BLOCK: |
| 114 | if (!DRD_(freelike_block)(vg_tid, arg[1]/*addr*/, False)) |
| 115 | { |
| 116 | GenericErrInfo GEI = { |
| 117 | .tid = DRD_(thread_get_running_tid)(), |
| 118 | .addr = 0, |
| 119 | }; |
| 120 | VG_(maybe_record_error)(vg_tid, |
| 121 | GenericErr, |
| 122 | VG_(get_IP)(vg_tid), |
| 123 | "Invalid VG_USERREQ__RESIZEINPLACE_BLOCK request", |
| 124 | &GEI); |
| 125 | } |
| 126 | DRD_(malloclike_block)(vg_tid, arg[1]/*addr*/, arg[3]/*newSize*/); |
| 127 | break; |
| 128 | |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 129 | case VG_USERREQ__FREELIKE_BLOCK: |
bart | fc08a53 | 2011-03-12 12:43:39 +0000 | [diff] [blame] | 130 | if (arg[1] && ! DRD_(freelike_block)(vg_tid, arg[1]/*addr*/, False)) |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 131 | { |
bart | 62cc232 | 2010-03-07 10:54:21 +0000 | [diff] [blame] | 132 | GenericErrInfo GEI = { |
| 133 | .tid = DRD_(thread_get_running_tid)(), |
| 134 | .addr = 0, |
| 135 | }; |
bart | b48bde2 | 2009-07-31 08:26:17 +0000 | [diff] [blame] | 136 | VG_(maybe_record_error)(vg_tid, |
| 137 | GenericErr, |
| 138 | VG_(get_IP)(vg_tid), |
| 139 | "Invalid VG_USERREQ__FREELIKE_BLOCK request", |
| 140 | &GEI); |
bart | 6c7c76e | 2009-05-01 12:23:47 +0000 | [diff] [blame] | 141 | } |
| 142 | break; |
| 143 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 144 | case VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID: |
| 145 | result = vg_tid; |
| 146 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 147 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 148 | case VG_USERREQ__DRD_GET_DRD_THREAD_ID: |
| 149 | result = drd_tid; |
| 150 | break; |
bart | 5f57be9 | 2008-07-01 08:48:56 +0000 | [diff] [blame] | 151 | |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 152 | case VG_USERREQ__DRD_SET_THREAD_NAME: |
florian | 19f91bb | 2012-11-10 22:29:54 +0000 | [diff] [blame] | 153 | DRD_(thread_set_name)(drd_tid, (const HChar*)arg[1]); |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 154 | break; |
| 155 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 156 | case VG_USERREQ__DRD_START_SUPPRESSION: |
bart | d3a300d | 2010-08-29 16:20:54 +0000 | [diff] [blame] | 157 | /*_VG_USERREQ__HG_ARANGE_MAKE_UNTRACKED*/ |
| 158 | case VG_USERREQ_TOOL_BASE('H','G') + 256 + 39: |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 159 | DRD_(start_suppression)(arg[1], arg[1] + arg[2], "client"); |
| 160 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 161 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 162 | case VG_USERREQ__DRD_FINISH_SUPPRESSION: |
bart | d3a300d | 2010-08-29 16:20:54 +0000 | [diff] [blame] | 163 | /*_VG_USERREQ__HG_ARANGE_MAKE_TRACKED*/ |
| 164 | case VG_USERREQ_TOOL_BASE('H','G') + 256 + 40: |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 165 | DRD_(finish_suppression)(arg[1], arg[1] + arg[2]); |
| 166 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 167 | |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 168 | case VG_USERREQ__DRD_ANNOTATE_HAPPENS_BEFORE: |
bart | 62cc232 | 2010-03-07 10:54:21 +0000 | [diff] [blame] | 169 | DRD_(hb_happens_before)(drd_tid, arg[1]); |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 170 | break; |
| 171 | |
| 172 | case VG_USERREQ__DRD_ANNOTATE_HAPPENS_AFTER: |
bart | 62cc232 | 2010-03-07 10:54:21 +0000 | [diff] [blame] | 173 | DRD_(hb_happens_after)(drd_tid, arg[1]); |
| 174 | break; |
| 175 | |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 176 | case VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE: |
| 177 | if (arg[1]) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 178 | { |
| 179 | struct mutex_info* const mutex_p = DRD_(mutex_get)(arg[1]); |
| 180 | if (mutex_p && mutex_p->mutex_type == mutex_type_spinlock) |
| 181 | break; |
| 182 | } |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 183 | DRD_(rwlock_pre_init)(arg[1], user_rwlock); |
| 184 | break; |
| 185 | |
| 186 | case VG_USERREQ__DRD_ANNOTATE_RWLOCK_DESTROY: |
| 187 | if (arg[1]) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 188 | { |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 189 | struct mutex_info* const mutex_p = DRD_(mutex_get)(arg[1]); |
| 190 | if (mutex_p && mutex_p->mutex_type == mutex_type_spinlock) |
| 191 | break; |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 192 | } |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 193 | DRD_(rwlock_post_destroy)(arg[1], user_rwlock); |
| 194 | break; |
| 195 | |
| 196 | case VG_USERREQ__DRD_ANNOTATE_RWLOCK_ACQUIRED: |
| 197 | if (arg[1]) |
| 198 | { |
| 199 | struct mutex_info* const mutex_p = DRD_(mutex_get)(arg[1]); |
| 200 | if (mutex_p && mutex_p->mutex_type == mutex_type_spinlock) |
| 201 | break; |
| 202 | } |
| 203 | tl_assert(arg[2] == !! arg[2]); |
| 204 | if (arg[2]) |
| 205 | { |
| 206 | DRD_(rwlock_pre_wrlock)(arg[1], user_rwlock); |
| 207 | DRD_(rwlock_post_wrlock)(arg[1], user_rwlock, True); |
| 208 | } |
| 209 | else |
| 210 | { |
| 211 | DRD_(rwlock_pre_rdlock)(arg[1], user_rwlock); |
| 212 | DRD_(rwlock_post_rdlock)(arg[1], user_rwlock, True); |
| 213 | } |
| 214 | break; |
| 215 | |
| 216 | case VG_USERREQ__DRD_ANNOTATE_RWLOCK_RELEASED: |
| 217 | if (arg[1]) |
| 218 | { |
| 219 | struct mutex_info* const mutex_p = DRD_(mutex_get)(arg[1]); |
| 220 | if (mutex_p && mutex_p->mutex_type == mutex_type_spinlock) |
| 221 | break; |
| 222 | } |
| 223 | tl_assert(arg[2] == !! arg[2]); |
| 224 | DRD_(rwlock_pre_unlock)(arg[1], user_rwlock); |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 225 | break; |
| 226 | |
bart | cb48672 | 2014-05-18 19:32:26 +0000 | [diff] [blame] | 227 | case VG_USERREQ__DRD_ANNOTATE_SEM_INIT_PRE: |
| 228 | DRD_(semaphore_init)(arg[1], 0, arg[2]); |
| 229 | break; |
| 230 | |
| 231 | case VG_USERREQ__DRD_ANNOTATE_SEM_DESTROY_POST: |
| 232 | DRD_(semaphore_destroy)(arg[1]); |
| 233 | break; |
| 234 | |
| 235 | case VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_PRE: |
| 236 | DRD_(semaphore_pre_wait)(arg[1]); |
| 237 | break; |
| 238 | |
| 239 | case VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_POST: |
| 240 | DRD_(semaphore_post_wait)(drd_tid, arg[1], True /* waited */); |
| 241 | break; |
| 242 | |
| 243 | case VG_USERREQ__DRD_ANNOTATE_SEM_POST_PRE: |
| 244 | DRD_(semaphore_pre_post)(drd_tid, arg[1]); |
| 245 | break; |
| 246 | |
bart | 850f199 | 2010-05-29 18:43:21 +0000 | [diff] [blame] | 247 | case VG_USERREQ__SET_PTHREAD_COND_INITIALIZER: |
| 248 | DRD_(pthread_cond_initializer) = (Addr)arg[1]; |
| 249 | DRD_(pthread_cond_initializer_size) = arg[2]; |
| 250 | break; |
| 251 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 252 | case VG_USERREQ__DRD_START_NEW_SEGMENT: |
| 253 | DRD_(thread_new_segment)(DRD_(PtThreadIdToDrdThreadId)(arg[1])); |
| 254 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 255 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 256 | case VG_USERREQ__DRD_START_TRACE_ADDR: |
bart | 41a378a | 2012-01-24 18:39:29 +0000 | [diff] [blame] | 257 | DRD_(start_tracing_address_range)(arg[1], arg[1] + arg[2], False); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 258 | break; |
bart | 005dc97 | 2008-03-29 14:42:59 +0000 | [diff] [blame] | 259 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 260 | case VG_USERREQ__DRD_STOP_TRACE_ADDR: |
| 261 | DRD_(stop_tracing_address_range)(arg[1], arg[1] + arg[2]); |
| 262 | break; |
bart | 5bd9f2d | 2008-03-03 20:31:58 +0000 | [diff] [blame] | 263 | |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 264 | case VG_USERREQ__DRD_RECORD_LOADS: |
| 265 | DRD_(thread_set_record_loads)(drd_tid, arg[1]); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 266 | break; |
bart | bf3a60c | 2008-04-04 19:10:21 +0000 | [diff] [blame] | 267 | |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 268 | case VG_USERREQ__DRD_RECORD_STORES: |
| 269 | DRD_(thread_set_record_stores)(drd_tid, arg[1]); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 270 | break; |
bart | bf3a60c | 2008-04-04 19:10:21 +0000 | [diff] [blame] | 271 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 272 | case VG_USERREQ__SET_PTHREADID: |
| 273 | // pthread_self() returns 0 for programs not linked with libpthread.so. |
| 274 | if (arg[1] != INVALID_POSIX_THREADID) |
| 275 | DRD_(thread_set_pthreadid)(drd_tid, arg[1]); |
| 276 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 277 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 278 | case VG_USERREQ__SET_JOINABLE: |
bart | 5668d4e | 2011-03-09 17:53:28 +0000 | [diff] [blame] | 279 | { |
| 280 | const DrdThreadId drd_joinable = DRD_(PtThreadIdToDrdThreadId)(arg[1]); |
| 281 | if (drd_joinable != DRD_INVALID_THREADID) |
| 282 | DRD_(thread_set_joinable)(drd_joinable, (Bool)arg[2]); |
| 283 | else { |
| 284 | InvalidThreadIdInfo ITI = { DRD_(thread_get_running_tid)(), arg[1] }; |
| 285 | VG_(maybe_record_error)(vg_tid, |
| 286 | InvalidThreadId, |
| 287 | VG_(get_IP)(vg_tid), |
| 288 | "pthread_detach(): invalid thread ID", |
| 289 | &ITI); |
| 290 | } |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 291 | break; |
bart | 5668d4e | 2011-03-09 17:53:28 +0000 | [diff] [blame] | 292 | } |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 293 | |
bart | dd75cdf | 2009-07-24 08:20:10 +0000 | [diff] [blame] | 294 | case VG_USERREQ__ENTERING_PTHREAD_CREATE: |
| 295 | DRD_(thread_entering_pthread_create)(drd_tid); |
| 296 | break; |
| 297 | |
| 298 | case VG_USERREQ__LEFT_PTHREAD_CREATE: |
| 299 | DRD_(thread_left_pthread_create)(drd_tid); |
| 300 | break; |
| 301 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 302 | case VG_USERREQ__POST_THREAD_JOIN: |
bart | b48bde2 | 2009-07-31 08:26:17 +0000 | [diff] [blame] | 303 | { |
| 304 | const DrdThreadId thread_to_join = DRD_(PtThreadIdToDrdThreadId)(arg[1]); |
| 305 | if (thread_to_join == DRD_INVALID_THREADID) |
| 306 | { |
| 307 | InvalidThreadIdInfo ITI = { DRD_(thread_get_running_tid)(), arg[1] }; |
| 308 | VG_(maybe_record_error)(vg_tid, |
| 309 | InvalidThreadId, |
| 310 | VG_(get_IP)(vg_tid), |
| 311 | "pthread_join(): invalid thread ID", |
| 312 | &ITI); |
| 313 | } |
| 314 | else |
| 315 | { |
| 316 | DRD_(thread_post_join)(drd_tid, thread_to_join); |
| 317 | } |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 318 | break; |
bart | b48bde2 | 2009-07-31 08:26:17 +0000 | [diff] [blame] | 319 | } |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 320 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 321 | case VG_USERREQ__PRE_THREAD_CANCEL: |
bart | b48bde2 | 2009-07-31 08:26:17 +0000 | [diff] [blame] | 322 | { |
| 323 | const DrdThreadId thread_to_cancel =DRD_(PtThreadIdToDrdThreadId)(arg[1]); |
| 324 | if (thread_to_cancel == DRD_INVALID_THREADID) |
| 325 | { |
| 326 | InvalidThreadIdInfo ITI = { DRD_(thread_get_running_tid)(), arg[1] }; |
| 327 | VG_(maybe_record_error)(vg_tid, |
| 328 | InvalidThreadId, |
| 329 | VG_(get_IP)(vg_tid), |
| 330 | "pthread_cancel(): invalid thread ID", |
| 331 | &ITI); |
| 332 | } |
| 333 | else |
| 334 | { |
| 335 | DRD_(thread_pre_cancel)(thread_to_cancel); |
| 336 | } |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 337 | break; |
bart | b48bde2 | 2009-07-31 08:26:17 +0000 | [diff] [blame] | 338 | } |
bart | 0f099cd | 2008-09-27 12:36:48 +0000 | [diff] [blame] | 339 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 340 | case VG_USERREQ__POST_THREAD_CANCEL: |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 341 | break; |
bart | 0f099cd | 2008-09-27 12:36:48 +0000 | [diff] [blame] | 342 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 343 | case VG_USERREQ__PRE_MUTEX_INIT: |
| 344 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 345 | DRD_(mutex_init)(arg[1], arg[2]); |
| 346 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 347 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 348 | case VG_USERREQ__POST_MUTEX_INIT: |
| 349 | DRD_(thread_leave_synchr)(drd_tid); |
| 350 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 351 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 352 | case VG_USERREQ__PRE_MUTEX_DESTROY: |
| 353 | DRD_(thread_enter_synchr)(drd_tid); |
| 354 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 355 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 356 | case VG_USERREQ__POST_MUTEX_DESTROY: |
| 357 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 358 | DRD_(mutex_post_destroy)(arg[1]); |
| 359 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 360 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 361 | case VG_USERREQ__PRE_MUTEX_LOCK: |
| 362 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 363 | DRD_(mutex_pre_lock)(arg[1], arg[2], arg[3]); |
| 364 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 365 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 366 | case VG_USERREQ__POST_MUTEX_LOCK: |
| 367 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 368 | DRD_(mutex_post_lock)(arg[1], arg[2], False/*post_cond_wait*/); |
| 369 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 370 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 371 | case VG_USERREQ__PRE_MUTEX_UNLOCK: |
| 372 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 373 | DRD_(mutex_unlock)(arg[1], arg[2]); |
| 374 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 375 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 376 | case VG_USERREQ__POST_MUTEX_UNLOCK: |
| 377 | DRD_(thread_leave_synchr)(drd_tid); |
| 378 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 379 | |
bart | 3cc2620 | 2014-06-09 09:19:26 +0000 | [diff] [blame] | 380 | case VG_USERREQ__DRD_IGNORE_MUTEX_ORDERING: |
| 381 | DRD_(mutex_ignore_ordering)(arg[1]); |
| 382 | break; |
| 383 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 384 | case VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK: |
| 385 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 386 | DRD_(spinlock_init_or_unlock)(arg[1]); |
| 387 | break; |
bart | f4f0581 | 2008-07-07 08:10:56 +0000 | [diff] [blame] | 388 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 389 | case VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK: |
| 390 | DRD_(thread_leave_synchr)(drd_tid); |
| 391 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 392 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 393 | case VG_USERREQ__PRE_COND_INIT: |
| 394 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 395 | DRD_(cond_pre_init)(arg[1]); |
| 396 | break; |
bart | 3f4623e | 2008-07-07 16:53:07 +0000 | [diff] [blame] | 397 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 398 | case VG_USERREQ__POST_COND_INIT: |
| 399 | DRD_(thread_leave_synchr)(drd_tid); |
| 400 | break; |
bart | 3f4623e | 2008-07-07 16:53:07 +0000 | [diff] [blame] | 401 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 402 | case VG_USERREQ__PRE_COND_DESTROY: |
| 403 | DRD_(thread_enter_synchr)(drd_tid); |
| 404 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 405 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 406 | case VG_USERREQ__POST_COND_DESTROY: |
| 407 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
bart | d36fa80 | 2012-12-24 10:22:14 +0000 | [diff] [blame] | 408 | DRD_(cond_post_destroy)(arg[1], arg[2]); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 409 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 410 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 411 | case VG_USERREQ__PRE_COND_WAIT: |
| 412 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 413 | { |
| 414 | const Addr cond = arg[1]; |
| 415 | const Addr mutex = arg[2]; |
| 416 | const MutexT mutex_type = arg[3]; |
| 417 | DRD_(mutex_unlock)(mutex, mutex_type); |
| 418 | DRD_(cond_pre_wait)(cond, mutex); |
| 419 | } |
| 420 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 421 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 422 | case VG_USERREQ__POST_COND_WAIT: |
| 423 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 424 | { |
| 425 | const Addr cond = arg[1]; |
| 426 | const Addr mutex = arg[2]; |
| 427 | const Bool took_lock = arg[3]; |
| 428 | DRD_(cond_post_wait)(cond); |
| 429 | DRD_(mutex_post_lock)(mutex, took_lock, True); |
| 430 | } |
| 431 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 432 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 433 | case VG_USERREQ__PRE_COND_SIGNAL: |
| 434 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 435 | DRD_(cond_pre_signal)(arg[1]); |
| 436 | break; |
bart | 3f4623e | 2008-07-07 16:53:07 +0000 | [diff] [blame] | 437 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 438 | case VG_USERREQ__POST_COND_SIGNAL: |
| 439 | DRD_(thread_leave_synchr)(drd_tid); |
| 440 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 441 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 442 | case VG_USERREQ__PRE_COND_BROADCAST: |
| 443 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 444 | DRD_(cond_pre_broadcast)(arg[1]); |
| 445 | break; |
bart | 3f4623e | 2008-07-07 16:53:07 +0000 | [diff] [blame] | 446 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 447 | case VG_USERREQ__POST_COND_BROADCAST: |
| 448 | DRD_(thread_leave_synchr)(drd_tid); |
| 449 | break; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 450 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 451 | case VG_USERREQ__PRE_SEM_INIT: |
| 452 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 453 | DRD_(semaphore_init)(arg[1], arg[2], arg[3]); |
| 454 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 455 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 456 | case VG_USERREQ__POST_SEM_INIT: |
| 457 | DRD_(thread_leave_synchr)(drd_tid); |
| 458 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 459 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 460 | case VG_USERREQ__PRE_SEM_DESTROY: |
| 461 | DRD_(thread_enter_synchr)(drd_tid); |
| 462 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 463 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 464 | case VG_USERREQ__POST_SEM_DESTROY: |
| 465 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 466 | DRD_(semaphore_destroy)(arg[1]); |
| 467 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 468 | |
bart | 25f9f54 | 2009-07-23 16:31:39 +0000 | [diff] [blame] | 469 | case VG_USERREQ__PRE_SEM_OPEN: |
| 470 | DRD_(thread_enter_synchr)(drd_tid); |
| 471 | break; |
| 472 | |
| 473 | case VG_USERREQ__POST_SEM_OPEN: |
| 474 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
florian | 19f91bb | 2012-11-10 22:29:54 +0000 | [diff] [blame] | 475 | DRD_(semaphore_open)(arg[1], (HChar*)arg[2], arg[3], arg[4], arg[5]); |
bart | 25f9f54 | 2009-07-23 16:31:39 +0000 | [diff] [blame] | 476 | break; |
| 477 | |
| 478 | case VG_USERREQ__PRE_SEM_CLOSE: |
| 479 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 480 | DRD_(semaphore_close)(arg[1]); |
| 481 | break; |
| 482 | |
| 483 | case VG_USERREQ__POST_SEM_CLOSE: |
| 484 | DRD_(thread_leave_synchr)(drd_tid); |
| 485 | break; |
| 486 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 487 | case VG_USERREQ__PRE_SEM_WAIT: |
| 488 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 489 | DRD_(semaphore_pre_wait)(arg[1]); |
| 490 | break; |
bart | 28230a3 | 2008-02-29 17:27:03 +0000 | [diff] [blame] | 491 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 492 | case VG_USERREQ__POST_SEM_WAIT: |
| 493 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 494 | DRD_(semaphore_post_wait)(drd_tid, arg[1], arg[2]); |
| 495 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 496 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 497 | case VG_USERREQ__PRE_SEM_POST: |
| 498 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 499 | DRD_(semaphore_pre_post)(drd_tid, arg[1]); |
| 500 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 501 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 502 | case VG_USERREQ__POST_SEM_POST: |
| 503 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 504 | DRD_(semaphore_post_post)(drd_tid, arg[1], arg[2]); |
| 505 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 506 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 507 | case VG_USERREQ__PRE_BARRIER_INIT: |
| 508 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 509 | DRD_(barrier_init)(arg[1], arg[2], arg[3], arg[4]); |
| 510 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 511 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 512 | case VG_USERREQ__POST_BARRIER_INIT: |
| 513 | DRD_(thread_leave_synchr)(drd_tid); |
| 514 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 515 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 516 | case VG_USERREQ__PRE_BARRIER_DESTROY: |
| 517 | DRD_(thread_enter_synchr)(drd_tid); |
| 518 | break; |
bart | 0268dfa | 2008-03-11 20:10:21 +0000 | [diff] [blame] | 519 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 520 | case VG_USERREQ__POST_BARRIER_DESTROY: |
| 521 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 522 | DRD_(barrier_destroy)(arg[1], arg[2]); |
| 523 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 524 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 525 | case VG_USERREQ__PRE_BARRIER_WAIT: |
| 526 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 527 | DRD_(barrier_pre_wait)(drd_tid, arg[1], arg[2]); |
| 528 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 529 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 530 | case VG_USERREQ__POST_BARRIER_WAIT: |
| 531 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 532 | DRD_(barrier_post_wait)(drd_tid, arg[1], arg[2], arg[3], arg[4]); |
| 533 | break; |
sewardj | 8564292 | 2008-01-14 11:54:56 +0000 | [diff] [blame] | 534 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 535 | case VG_USERREQ__PRE_RWLOCK_INIT: |
bart | 63eb989 | 2014-03-19 18:48:01 +0000 | [diff] [blame] | 536 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
| 537 | DRD_(rwlock_pre_init)(arg[1], pthread_rwlock); |
| 538 | break; |
| 539 | |
| 540 | case VG_USERREQ__POST_RWLOCK_INIT: |
| 541 | DRD_(thread_leave_synchr)(drd_tid); |
| 542 | break; |
| 543 | |
| 544 | case VG_USERREQ__PRE_RWLOCK_DESTROY: |
| 545 | DRD_(thread_enter_synchr)(drd_tid); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 546 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 547 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 548 | case VG_USERREQ__POST_RWLOCK_DESTROY: |
bart | 63eb989 | 2014-03-19 18:48:01 +0000 | [diff] [blame] | 549 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
| 550 | DRD_(rwlock_post_destroy)(arg[1], pthread_rwlock); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 551 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 552 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 553 | case VG_USERREQ__PRE_RWLOCK_RDLOCK: |
| 554 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 555 | DRD_(rwlock_pre_rdlock)(arg[1], pthread_rwlock); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 556 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 557 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 558 | case VG_USERREQ__POST_RWLOCK_RDLOCK: |
| 559 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 560 | DRD_(rwlock_post_rdlock)(arg[1], pthread_rwlock, arg[2]); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 561 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 562 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 563 | case VG_USERREQ__PRE_RWLOCK_WRLOCK: |
| 564 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 565 | DRD_(rwlock_pre_wrlock)(arg[1], pthread_rwlock); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 566 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 567 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 568 | case VG_USERREQ__POST_RWLOCK_WRLOCK: |
| 569 | if (DRD_(thread_leave_synchr)(drd_tid) == 0) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 570 | DRD_(rwlock_post_wrlock)(arg[1], pthread_rwlock, arg[2]); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 571 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 572 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 573 | case VG_USERREQ__PRE_RWLOCK_UNLOCK: |
| 574 | if (DRD_(thread_enter_synchr)(drd_tid) == 0) |
bart | d45d995 | 2009-05-31 18:53:54 +0000 | [diff] [blame] | 575 | DRD_(rwlock_pre_unlock)(arg[1], pthread_rwlock); |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 576 | break; |
bart | 31b983d | 2010-02-21 14:52:59 +0000 | [diff] [blame] | 577 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 578 | case VG_USERREQ__POST_RWLOCK_UNLOCK: |
| 579 | DRD_(thread_leave_synchr)(drd_tid); |
| 580 | break; |
bart | 0034464 | 2008-03-01 15:27:41 +0000 | [diff] [blame] | 581 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 582 | case VG_USERREQ__DRD_CLEAN_MEMORY: |
| 583 | if (arg[2] > 0) |
| 584 | DRD_(clean_memory)(arg[1], arg[2]); |
| 585 | break; |
bart | 83c1780 | 2009-03-10 09:26:07 +0000 | [diff] [blame] | 586 | |
bart | 141a7ed | 2010-03-21 17:28:10 +0000 | [diff] [blame] | 587 | case VG_USERREQ__HELGRIND_ANNOTATION_UNIMP: |
| 588 | { |
| 589 | /* Note: it is assumed below that the text arg[1] points to is never |
| 590 | * freed, e.g. because it points to static data. |
| 591 | */ |
| 592 | UnimpClReqInfo UICR = |
florian | 19f91bb | 2012-11-10 22:29:54 +0000 | [diff] [blame] | 593 | { DRD_(thread_get_running_tid)(), (HChar*)arg[1] }; |
bart | 141a7ed | 2010-03-21 17:28:10 +0000 | [diff] [blame] | 594 | VG_(maybe_record_error)(vg_tid, |
| 595 | UnimpHgClReq, |
| 596 | VG_(get_IP)(vg_tid), |
| 597 | "", |
| 598 | &UICR); |
| 599 | } |
| 600 | break; |
| 601 | |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 602 | case VG_USERREQ__DRD_ANNOTATION_UNIMP: |
| 603 | { |
| 604 | /* Note: it is assumed below that the text arg[1] points to is never |
| 605 | * freed, e.g. because it points to static data. |
| 606 | */ |
| 607 | UnimpClReqInfo UICR = |
florian | 19f91bb | 2012-11-10 22:29:54 +0000 | [diff] [blame] | 608 | { DRD_(thread_get_running_tid)(), (HChar*)arg[1] }; |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 609 | VG_(maybe_record_error)(vg_tid, |
bart | 141a7ed | 2010-03-21 17:28:10 +0000 | [diff] [blame] | 610 | UnimpDrdClReq, |
bart | 66f196d | 2009-08-15 10:50:35 +0000 | [diff] [blame] | 611 | VG_(get_IP)(vg_tid), |
| 612 | "", |
| 613 | &UICR); |
| 614 | } |
| 615 | break; |
| 616 | |
sewardj | 8eb8bab | 2015-07-21 14:44:28 +0000 | [diff] [blame] | 617 | #if defined(VGO_solaris) |
| 618 | case VG_USERREQ__RTLD_BIND_GUARD: |
| 619 | DRD_(thread_entering_rtld_bind_guard)(drd_tid, arg[1]); |
| 620 | break; |
| 621 | |
| 622 | case VG_USERREQ__RTLD_BIND_CLEAR: |
| 623 | DRD_(thread_leaving_rtld_bind_clear)(drd_tid, arg[1]); |
| 624 | break; |
| 625 | #endif /* VGO_solaris */ |
| 626 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 627 | default: |
bart | 5c0251e | 2009-05-02 08:06:53 +0000 | [diff] [blame] | 628 | #if 0 |
| 629 | VG_(message)(Vg_DebugMsg, "Unrecognized client request 0x%lx 0x%lx", |
| 630 | arg[0], arg[1]); |
| 631 | tl_assert(0); |
| 632 | #endif |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 633 | return False; |
| 634 | } |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 635 | |
bart | bedfd23 | 2009-03-26 19:07:15 +0000 | [diff] [blame] | 636 | *ret = result; |
| 637 | return True; |
sewardj | af44c82 | 2007-11-25 14:01:38 +0000 | [diff] [blame] | 638 | } |