drd_semaphore.c revision 389e7f9caa5526c4629150942699c6a60bcc8057 
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)(), 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(). */
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 = {
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(). */
256struct 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(). */
303void 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(). */
336void 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 */
360void 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(). */
423void 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. */
450void 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
466ULong DRD_(get_semaphore_segment_creation_count)(void)
467{
468   return s_semaphore_segment_creation_count;
469}
470