l4/pkg/valgrind/src/valgrind-3.6.0-svn/drd/drd_semaphore.c

   1 /* -*- mode: C; c-basic-offset: 3; -*- */
   2 /*
   3   This file is part of drd, a thread error detector.
   4
   5   Copyright (C) 2006-2010 Bart Van Assche <bart.vanassche@gmail.com>.
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License as
   9   published by the Free Software Foundation; either version 2 of the
  10   License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  20   02111-1307, USA.
  21
  22   The GNU General Public License is contained in the file COPYING.
  23 */
  24
  25
  26 #include "drd_clientobj.h"
  27 #include "drd_error.h"
  28 #include "drd_semaphore.h"
  29 #include "drd_suppression.h"
  30 #include "pub_tool_errormgr.h"    // VG_(maybe_record_error)()
  31 #include "pub_tool_libcassert.h"  // tl_assert()
  32 #include "pub_tool_libcprint.h"   // VG_(printf)()
  33 #include "pub_tool_machine.h"     // VG_(get_IP)()
  34 #include "pub_tool_mallocfree.h"  // VG_(malloc), VG_(free)
  35 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
  36
  37
  38 /* Local functions. */
  39
  40 static void semaphore_cleanup(struct semaphore_info* p);
  41
  42
  43 /* Local variables. */
  44
  45 static Bool s_trace_semaphore;
  46 static ULong s_semaphore_segment_creation_count;
  47
  48
  49 /* Function definitions. */
  50
  51 /** Push a segment at the end of the queue 'p->last_sem_post_seg'. */
  52 static void drd_segment_push(struct semaphore_info* p, Segment* sg)
  53 {
  54    Word n;
  55
  56    tl_assert(sg);
  57    n = VG_(addToXA)(p->last_sem_post_seg, &sg);
  58 #if 0
  59    VG_(message)(Vg_UserMsg, "0x%lx push: added at position %ld/%ld",
  60                 p->a1, n, VG_(sizeXA)(p->last_sem_post_seg));
  61 #endif
  62    tl_assert(*(Segment**)VG_(indexXA)(p->last_sem_post_seg, n) == sg);
  63 }
  64
  65 /** Pop a segment from the beginning of the queue 'p->last_sem_post_seg'. */
  66 static Segment* drd_segment_pop(struct semaphore_info* p)
  67 {
  68    Word sz;
  69    Segment* sg;
  70
  71    sz = VG_(sizeXA)(p->last_sem_post_seg);
  72 #if 0
  73    VG_(message)(Vg_UserMsg, "0x%lx pop:  removed from position %ld/%ld",
  74                 p->a1, sz - 1, sz);
  75 #endif
  76    sg = 0;
  77    if (sz > 0)
  78    {
  79       sg = *(Segment**)VG_(indexXA)(p->last_sem_post_seg, sz - 1);
  80       tl_assert(sg);
  81       VG_(dropTailXA)(p->last_sem_post_seg, 1);
  82    }
  83    return sg;
  84 }
  85
  86 /** Enable or disable tracing of semaphore actions. */
  87 void DRD_(semaphore_set_trace)(const Bool trace_semaphore)
  88 {
  89    s_trace_semaphore = trace_semaphore;
  90 }
  91
  92 /**
  93  * Initialize the memory 'p' points at as a semaphore_info structure for the
  94  * client semaphore at client addres 'semaphore'.
  95  */
  96 static
  97 void drd_semaphore_initialize(struct semaphore_info* const p,
  98                               const Addr semaphore)
  99 {
 100    tl_assert(semaphore != 0);
 101    tl_assert(p->a1 == semaphore);
 102    tl_assert(p->type == ClientSemaphore);
 103
 104    p->cleanup           = (void(*)(DrdClientobj*))semaphore_cleanup;
 105    p->delete_thread     = 0;
 106    p->waits_to_skip     = 0;
 107    p->value             = 0;
 108    p->waiters           = 0;
 109    p->last_sem_post_tid = DRD_INVALID_THREADID;
 110    p->last_sem_post_seg = VG_(newXA)(VG_(malloc), "drd.sg-stack",
 111                                      VG_(free), sizeof(Segment*));
 112 }
 113
 114 /**
 115  * Free the memory that was allocated by semaphore_initialize(). Called by
 116  * DRD_(clientobj_remove)().
 117  */
 118 static void semaphore_cleanup(struct semaphore_info* p)
 119 {
 120    Segment* sg;
 121
 122    if (p->waiters > 0)
 123    {
 124       SemaphoreErrInfo sei = { DRD_(thread_get_running_tid)(), p->a1 };
 125       VG_(maybe_record_error)(VG_(get_running_tid)(),
 126                               SemaphoreErr,
 127                               VG_(get_IP)(VG_(get_running_tid)()),
 128                               "Destruction of semaphore that is being waited"
 129                               " upon",
 130                               &sei);
 131    }
 132    while ((sg = drd_segment_pop(p)))
 133       DRD_(sg_put)(sg);
 134    VG_(deleteXA)(p->last_sem_post_seg);
 135 }
 136
 137 /**
 138  * Return a pointer to the structure with information about the specified
 139  * client semaphore. Allocate a new structure if such a structure did not
 140  * yet exist.
 141  */
 142 static
 143 struct semaphore_info*
 144 drd_semaphore_get_or_allocate(const Addr semaphore)
 145 {
 146    struct semaphore_info *p;
 147
 148    tl_assert(offsetof(DrdClientobj, semaphore) == 0);
 149    p = &(DRD_(clientobj_get)(semaphore, ClientSemaphore)->semaphore);
 150    if (p == 0)
 151    {
 152       tl_assert(offsetof(DrdClientobj, semaphore) == 0);
 153       p = &(DRD_(clientobj_add)(semaphore, ClientSemaphore)->semaphore);
 154       drd_semaphore_initialize(p, semaphore);
 155    }
 156    return p;
 157 }
 158
 159 /**
 160  * Return a pointer to the structure with information about the specified
 161  * client semaphore, or null if no such structure was found.
 162  */
 163 static struct semaphore_info* semaphore_get(const Addr semaphore)
 164 {
 165    tl_assert(offsetof(DrdClientobj, semaphore) == 0);
 166    return &(DRD_(clientobj_get)(semaphore, ClientSemaphore)->semaphore);
 167 }
 168
 169 /** Called before sem_init(). */
 170 struct semaphore_info* DRD_(semaphore_init)(const Addr semaphore,
 171                                             const Word pshared,
 172                                             const UInt value)
 173 {
 174    struct semaphore_info* p;
 175    Segment* sg;
 176
 177    if (s_trace_semaphore)
 178    {
 179       VG_(message)(Vg_UserMsg,
 180                    "[%d] sem_init      0x%lx value %u\n",
 181                    DRD_(thread_get_running_tid)(),
 182                    semaphore,
 183                    value);
 184    }
 185    p = semaphore_get(semaphore);
 186    if (p)
 187    {
 188       const ThreadId vg_tid = VG_(get_running_tid)();
 189       SemaphoreErrInfo SEI = { DRD_(thread_get_running_tid)(), semaphore };
 190       VG_(maybe_record_error)(vg_tid,
 191                               SemaphoreErr,
 192                               VG_(get_IP)(vg_tid),
 193                               "Semaphore reinitialization",
 194                               &SEI);
 195       // Remove all segments from the segment stack.
 196       while ((sg = drd_segment_pop(p)))
 197       {
 198          DRD_(sg_put)(sg);
 199       }
 200    }
 201    else
 202    {
 203 #if defined(VGO_darwin)
 204       const ThreadId vg_tid = VG_(get_running_tid)();
 205       GenericErrInfo GEI = { DRD_(thread_get_running_tid)(), NULL };
 206       VG_(maybe_record_error)(vg_tid,
 207                               GenericErr,
 208                               VG_(get_IP)(vg_tid),
 209                               "sem_init() is not yet supported on Darwin",
 210                               &GEI);
 211       return NULL;
 212 #else
 213       p = drd_semaphore_get_or_allocate(semaphore);
 214 #endif
 215    }
 216    tl_assert(p);
 217    p->waits_to_skip = value;
 218    p->value         = value;
 219    return p;
 220 }
 221
 222 /** Called after sem_destroy(). */
 223 void DRD_(semaphore_destroy)(const Addr semaphore)
 224 {
 225    struct semaphore_info* p;
 226
 227    p = semaphore_get(semaphore);
 228
 229    if (s_trace_semaphore)
 230    {
 231       VG_(message)(Vg_UserMsg,
 232                    "[%d] sem_destroy   0x%lx value %u\n",
 233                    DRD_(thread_get_running_tid)(),
 234                    semaphore,
 235                    p ? p->value : 0);
 236    }
 237
 238    if (p == 0)
 239    {
 240       GenericErrInfo GEI = {
 241          .tid  = DRD_(thread_get_running_tid)(),
 242          .addr = semaphore,
 243       };
 244       VG_(maybe_record_error)(VG_(get_running_tid)(),
 245                               GenericErr,
 246                               VG_(get_IP)(VG_(get_running_tid)()),
 247                               "Not a semaphore",
 248                               &GEI);
 249       return;
 250    }
 251
 252    DRD_(clientobj_remove)(semaphore, ClientSemaphore);
 253 }
 254
 255 /** Called after sem_open(). */
 256 struct semaphore_info* DRD_(semaphore_open)(const Addr semaphore,
 257                                             const Char* name, const Word oflag,
 258                                             const Word mode, const UInt value)
 259 {
 260    struct semaphore_info* p;
 261    Segment* sg;
 262
 263    if (s_trace_semaphore)
 264    {
 265       VG_(message)(Vg_UserMsg,
 266                    "[%d] sem_open      0x%lx name %s"
 267                    " oflag %#lx mode %#lo value %u\n",
 268                    DRD_(thread_get_running_tid)(),
 269                    semaphore, name, oflag, mode, value);
 270    }
 271
 272    /* Return if the sem_open() call failed. */
 273    if (! semaphore)
 274       return NULL;
 275
 276    p = semaphore_get(semaphore);
 277    if (p)
 278    {
 279       const ThreadId vg_tid = VG_(get_running_tid)();
 280       SemaphoreErrInfo SEI = { DRD_(thread_get_running_tid)(), semaphore };
 281       VG_(maybe_record_error)(vg_tid,
 282                               SemaphoreErr,
 283                               VG_(get_IP)(vg_tid),
 284                               "Semaphore reinitialization",
 285                               &SEI);
 286       // Remove all segments from the segment stack.
 287       while ((sg = drd_segment_pop(p)))
 288       {
 289          DRD_(sg_put)(sg);
 290       }
 291    }
 292    else
 293    {
 294       p = drd_semaphore_get_or_allocate(semaphore);
 295    }
 296    tl_assert(p);
 297    p->waits_to_skip = value;
 298    p->value         = value;
 299    return p;
 300 }
 301
 302 /** Called before sem_close(). */
 303 void DRD_(semaphore_close)(const Addr semaphore)
 304 {
 305    struct semaphore_info* p;
 306
 307    p = semaphore_get(semaphore);
 308
 309    if (s_trace_semaphore)
 310    {
 311       VG_(message)(Vg_UserMsg,
 312                    "[%d] sem_close     0x%lx value %u\n",
 313                    DRD_(thread_get_running_tid)(),
 314                    semaphore,
 315                    p ? p->value : 0);
 316    }
 317
 318    if (p == 0)
 319    {
 320       GenericErrInfo GEI = {
 321          .tid  = DRD_(thread_get_running_tid)(),
 322          .addr = semaphore,
 323       };
 324       VG_(maybe_record_error)(VG_(get_running_tid)(),
 325                               GenericErr,
 326                               VG_(get_IP)(VG_(get_running_tid)()),
 327                               "Not a semaphore",
 328                               &GEI);
 329       return;
 330    }
 331
 332    DRD_(clientobj_remove)(semaphore, ClientSemaphore);
 333 }
 334
 335 /** Called before sem_wait(). */
 336 void DRD_(semaphore_pre_wait)(const Addr semaphore)
 337 {
 338    struct semaphore_info* p;
 339
 340    p = drd_semaphore_get_or_allocate(semaphore);
 341    tl_assert(p);
 342    p->waiters++;
 343
 344    if ((Word)(p->waiters) <= 0)
 345    {
 346       SemaphoreErrInfo sei = { DRD_(thread_get_running_tid)(), semaphore };
 347       VG_(maybe_record_error)(VG_(get_running_tid)(),
 348                               SemaphoreErr,
 349                               VG_(get_IP)(VG_(get_running_tid)()),
 350                               "Invalid semaphore",
 351                               &sei);
 352    }
 353 }
 354
 355 /**
 356  * Called after sem_wait() finished.
 357  * @note Do not rely on the value of 'waited' -- some glibc versions do
 358  *       not set it correctly.
 359  */
 360 void DRD_(semaphore_post_wait)(const DrdThreadId tid, const Addr semaphore,
 361                                const Bool waited)
 362 {
 363    struct semaphore_info* p;
 364    Segment* sg;
 365
 366    p = semaphore_get(semaphore);
 367    if (s_trace_semaphore)
 368    {
 369       VG_(message)(Vg_UserMsg,
 370                    "[%d] sem_wait      0x%lx value %u -> %u\n",
 371                    DRD_(thread_get_running_tid)(),
 372                    semaphore,
 373                    p ? p->value : 0,
 374                    p ? p->value - 1 : 0);
 375    }
 376
 377    if (p)
 378    {
 379       p->waiters--;
 380       p->value--;
 381    }
 382
 383    /*
 384     * Note: if another thread destroyed and reinitialized a semaphore while
 385     * the current thread was waiting in sem_wait, p->waiters may have been
 386     * set to zero by drd_semaphore_initialize() after
 387     * DRD_(semaphore_pre_wait)() has finished before
 388     * DRD_(semaphore_post_wait)() has been called.
 389     */
 390    if (p == NULL || (Int)(p->value) < 0 || (Word)(p->waiters) < 0)
 391    {
 392       SemaphoreErrInfo sei = { DRD_(thread_get_running_tid)(), semaphore };
 393       VG_(maybe_record_error)(VG_(get_running_tid)(),
 394                               SemaphoreErr,
 395                               VG_(get_IP)(VG_(get_running_tid)()),
 396                               "Invalid semaphore",
 397                               &sei);
 398       return;
 399    }
 400
 401    if (p->waits_to_skip > 0)
 402       p->waits_to_skip--;
 403    else
 404    {
 405       sg = drd_segment_pop(p);
 406       tl_assert(sg);
 407       if (sg)
 408       {
 409          if (p->last_sem_post_tid != tid
 410              && p->last_sem_post_tid != DRD_INVALID_THREADID)
 411          {
 412             DRD_(thread_new_segment_and_combine_vc)(tid, sg);
 413          }
 414          else
 415             DRD_(thread_new_segment)(tid);
 416          s_semaphore_segment_creation_count++;
 417          DRD_(sg_put)(sg);
 418       }
 419    }
 420 }
 421
 422 /** Called before sem_post(). */
 423 void DRD_(semaphore_pre_post)(const DrdThreadId tid, const Addr semaphore)
 424 {
 425    struct semaphore_info* p;
 426    Segment* sg;
 427
 428    p = drd_semaphore_get_or_allocate(semaphore);
 429    p->value++;
 430
 431    if (s_trace_semaphore)
 432    {
 433       VG_(message)(Vg_UserMsg,
 434                    "[%d] sem_post      0x%lx value %u -> %u\n",
 435                    DRD_(thread_get_running_tid)(),
 436                    semaphore,
 437                    p->value - 1, p->value);
 438    }
 439
 440    p->last_sem_post_tid = tid;
 441    sg = 0;
 442    DRD_(thread_get_latest_segment)(&sg, tid);
 443    tl_assert(sg);
 444    drd_segment_push(p, sg);
 445    DRD_(thread_new_segment)(tid);
 446    s_semaphore_segment_creation_count++;
 447 }
 448
 449 /** Called after sem_post() finished. */
 450 void DRD_(semaphore_post_post)(const DrdThreadId tid, const Addr semaphore,
 451                                const Bool succeeded)
 452 {
 453    /*
 454     * Note: it is hard to implement the sem_post() wrapper correctly in
 455     * case sem_post() returns an error code. This is because handling this
 456     * case correctly requires restoring the vector clock associated with
 457     * the semaphore to its original value here. In order to do that without
 458     * introducing a race condition, extra locking has to be added around
 459     * each semaphore call. Such extra locking would have to be added in
 460     * drd_pthread_intercepts.c. However, it is hard to implement
 461     * synchronization in drd_pthread_intercepts.c in a portable way without
 462     * calling already redirected functions.
 463     */
 464 }
 465
 466 ULong DRD_(get_semaphore_segment_creation_count)(void)
 467 {
 468    return s_semaphore_segment_creation_count;
 469 }