drd/drd_clientreq.c

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