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