drd_semaphore.c revision c4b56747db5d3a6f850366f9e033cf77861dce41 
1/* -*- mode: C; c-basic-offset: 3; -*- */
2/*
3  This file is part of drd, a thread error detector.
4
5  Copyright (C) 2006-2009 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
40static void semaphore_cleanup(struct semaphore_info* p);
41
42
43/* Local variables. */
44
45static Bool s_trace_semaphore;
46static 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'. */
52static 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'. */
66static 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. */
87void 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 */
96static
97void 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 */
118static 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 */
142static
143struct semaphore_info*
144drd_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 */
163static 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(). */
170struct 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)() };
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(). */
223void 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 = { DRD_(thread_get_running_tid)() };
241      VG_(maybe_record_error)(VG_(get_running_tid)(),
242                              GenericErr,
243                              VG_(get_IP)(VG_(get_running_tid)()),
244                              "Not a semaphore",
245                              &GEI);
246      return;
247   }
248
249   DRD_(clientobj_remove)(semaphore, ClientSemaphore);
250}
251
252/** Called after sem_open(). */
253struct semaphore_info* DRD_(semaphore_open)(const Addr semaphore,
254                                            const Char* name, const Word oflag,
255                                            const Word mode, const UInt value)
256{
257   struct semaphore_info* p;
258   Segment* sg;
259
260   if (s_trace_semaphore)
261   {
262      VG_(message)(Vg_UserMsg,
263                   "[%d] sem_open      0x%lx name %s"
264                   " oflag %ld mode 0x%lx value %u\n",
265                   DRD_(thread_get_running_tid)(),
266                   semaphore, name, oflag, mode, value);
267   }
268
269   /* Return if the sem_open() call failed. */
270   if (! semaphore)
271      return NULL;
272
273   p = semaphore_get(semaphore);
274   if (p)
275   {
276      const ThreadId vg_tid = VG_(get_running_tid)();
277      SemaphoreErrInfo SEI = { DRD_(thread_get_running_tid)(), semaphore };
278      VG_(maybe_record_error)(vg_tid,
279                              SemaphoreErr,
280                              VG_(get_IP)(vg_tid),
281                              "Semaphore reinitialization",
282                              &SEI);
283      // Remove all segments from the segment stack.
284      while ((sg = drd_segment_pop(p)))
285      {
286         DRD_(sg_put)(sg);
287      }
288   }
289   else
290   {
291      p = drd_semaphore_get_or_allocate(semaphore);
292   }
293   tl_assert(p);
294   p->waits_to_skip = value;
295   p->value         = value;
296   return p;
297}
298
299/** Called before sem_close(). */
300void DRD_(semaphore_close)(const Addr semaphore)
301{
302   struct semaphore_info* p;
303
304   p = semaphore_get(semaphore);
305
306   if (s_trace_semaphore)
307   {
308      VG_(message)(Vg_UserMsg,
309                   "[%d] sem_close     0x%lx value %u\n",
310                   DRD_(thread_get_running_tid)(),
311                   semaphore,
312                   p ? p->value : 0);
313   }
314
315   if (p == 0)
316   {
317      GenericErrInfo GEI = { DRD_(thread_get_running_tid)() };
318      VG_(maybe_record_error)(VG_(get_running_tid)(),
319                              GenericErr,
320                              VG_(get_IP)(VG_(get_running_tid)()),
321                              "Not a semaphore",
322                              &GEI);
323      return;
324   }
325
326   DRD_(clientobj_remove)(semaphore, ClientSemaphore);
327}
328
329/** Called before sem_wait(). */
330void DRD_(semaphore_pre_wait)(const Addr semaphore)
331{
332   struct semaphore_info* p;
333
334   p = drd_semaphore_get_or_allocate(semaphore);
335   tl_assert(p);
336   p->waiters++;
337
338   if ((Word)(p->waiters) <= 0)
339   {
340      SemaphoreErrInfo sei = { DRD_(thread_get_running_tid)(), semaphore };
341      VG_(maybe_record_error)(VG_(get_running_tid)(),
342                              SemaphoreErr,
343                              VG_(get_IP)(VG_(get_running_tid)()),
344                              "Invalid semaphore",
345                              &sei);
346   }
347}
348
349/**
350 * Called after sem_wait() finished.
351 * @note Do not rely on the value of 'waited' -- some glibc versions do
352 *       not set it correctly.
353 */
354void DRD_(semaphore_post_wait)(const DrdThreadId tid, const Addr semaphore,
355                               const Bool waited)
356{
357   struct semaphore_info* p;
358   Segment* sg;
359
360   p = semaphore_get(semaphore);
361   if (s_trace_semaphore)
362   {
363      VG_(message)(Vg_UserMsg,
364                   "[%d] sem_wait      0x%lx value %u -> %u\n",
365                   DRD_(thread_get_running_tid)(),
366                   semaphore,
367                   p ? p->value : 0,
368                   p ? p->value - 1 : 0);
369   }
370
371   if (p)
372   {
373      p->waiters--;
374      p->value--;
375   }
376
377   /*
378    * Note: if another thread destroyed and reinitialized a semaphore while
379    * the current thread was waiting in sem_wait, p->waiters may have been
380    * set to zero by drd_semaphore_initialize() after
381    * DRD_(semaphore_pre_wait)() has finished before
382    * DRD_(semaphore_post_wait)() has been called.
383    */
384   if (p == NULL || (Int)(p->value) < 0 || (Word)(p->waiters) < 0)
385   {
386      SemaphoreErrInfo sei = { DRD_(thread_get_running_tid)(), semaphore };
387      VG_(maybe_record_error)(VG_(get_running_tid)(),
388                              SemaphoreErr,
389                              VG_(get_IP)(VG_(get_running_tid)()),
390                              "Invalid semaphore",
391                              &sei);
392      return;
393   }
394
395   if (p->waits_to_skip > 0)
396      p->waits_to_skip--;
397   else
398   {
399      sg = drd_segment_pop(p);
400      tl_assert(sg);
401      if (sg)
402      {
403         if (p->last_sem_post_tid != tid
404             && p->last_sem_post_tid != DRD_INVALID_THREADID)
405         {
406            DRD_(thread_new_segment_and_combine_vc)(tid, sg);
407         }
408         else
409            DRD_(thread_new_segment)(tid);
410         s_semaphore_segment_creation_count++;
411         DRD_(sg_put)(sg);
412      }
413   }
414}
415
416/** Called before sem_post(). */
417void DRD_(semaphore_pre_post)(const DrdThreadId tid, const Addr semaphore)
418{
419   struct semaphore_info* p;
420   Segment* sg;
421
422   p = drd_semaphore_get_or_allocate(semaphore);
423   p->value++;
424
425   if (s_trace_semaphore)
426   {
427      VG_(message)(Vg_UserMsg,
428                   "[%d] sem_post      0x%lx value %u -> %u\n",
429                   DRD_(thread_get_running_tid)(),
430                   semaphore,
431                   p->value - 1, p->value);
432   }
433
434   p->last_sem_post_tid = tid;
435   sg = 0;
436   DRD_(thread_get_latest_segment)(&sg, tid);
437   tl_assert(sg);
438   drd_segment_push(p, sg);
439   DRD_(thread_new_segment)(tid);
440   s_semaphore_segment_creation_count++;
441}
442
443/** Called after sem_post() finished. */
444void DRD_(semaphore_post_post)(const DrdThreadId tid, const Addr semaphore,
445                               const Bool succeeded)
446{
447   /*
448    * Note: it is hard to implement the sem_post() wrapper correctly in
449    * case sem_post() returns an error code. This is because handling this
450    * case correctly requires restoring the vector clock associated with
451    * the semaphore to its original value here. In order to do that without
452    * introducing a race condition, extra locking has to be added around
453    * each semaphore call. Such extra locking would have to be added in
454    * drd_pthread_intercepts.c. However, it is hard to implement
455    * synchronization in drd_pthread_intercepts.c in a portable way without
456    * calling already redirected functions.
457    */
458}
459
460ULong DRD_(get_semaphore_segment_creation_count)(void)
461{
462   return s_semaphore_segment_creation_count;
463}
464