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