• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2   This file is part of drd, a thread error detector.
3 
4   Copyright (C) 2006-2012 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_suppression.h"
28 #include "pub_tool_basics.h"
29 #include "pub_tool_libcassert.h"
30 #include "pub_tool_libcbase.h"
31 #include "pub_tool_libcprint.h"   // VG_(message)()
32 #include "pub_tool_mallocfree.h"
33 #include "pub_tool_options.h"     // VG_(clo_backtrace_size)
34 #include "pub_tool_oset.h"
35 #include "pub_tool_stacktrace.h"
36 #include "pub_tool_threadstate.h" // VG_(get_running_tid)()
37 
38 
39 /* Local variables. */
40 
41 static OSet* s_clientobj_set;
42 static Bool s_trace_clientobj;
43 
44 
45 /* Local functions. */
46 
47 static Bool clientobj_remove_obj(DrdClientobj* const p);
48 
49 
50 /* Function definitions. */
51 
DRD_(clientobj_set_trace)52 void DRD_(clientobj_set_trace)(const Bool trace)
53 {
54    s_trace_clientobj = trace;
55 }
56 
57 /** Initialize the client object set. */
DRD_(clientobj_init)58 void DRD_(clientobj_init)(void)
59 {
60    tl_assert(s_clientobj_set == 0);
61    s_clientobj_set = VG_(OSetGen_Create)(0, 0, VG_(malloc),
62                                          "drd.clientobj.ci.1", VG_(free));
63    tl_assert(s_clientobj_set);
64 }
65 
66 /**
67  * Free the memory allocated for the client object set.
68  *
69  * @pre Client object set is empty.
70  */
DRD_(clientobj_cleanup)71 void DRD_(clientobj_cleanup)(void)
72 {
73    tl_assert(s_clientobj_set);
74    tl_assert(VG_(OSetGen_Size)(s_clientobj_set) == 0);
75    VG_(OSetGen_Destroy)(s_clientobj_set);
76    s_clientobj_set = 0;
77 }
78 
79 /**
80  * Return the data associated with the client object at client address addr.
81  * Return 0 if there is no client object in the set with the specified start
82  * address.
83  */
DRD_(clientobj_get_any)84 DrdClientobj* DRD_(clientobj_get_any)(const Addr addr)
85 {
86    return VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
87 }
88 
89 /**
90  * Return the data associated with the client object at client address addr
91  * and that has object type t. Return 0 if there is no client object in the
92  * set with the specified start address.
93  */
DRD_(clientobj_get)94 DrdClientobj* DRD_(clientobj_get)(const Addr addr, const ObjType t)
95 {
96    DrdClientobj* p;
97    p = VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
98    if (p && p->any.type == t)
99       return p;
100    return 0;
101 }
102 
103 /** Return true if and only if the address range of any client object overlaps
104  *  with the specified address range.
105  */
DRD_(clientobj_present)106 Bool DRD_(clientobj_present)(const Addr a1, const Addr a2)
107 {
108    DrdClientobj *p;
109 
110    tl_assert(a1 <= a2);
111    VG_(OSetGen_ResetIter)(s_clientobj_set);
112    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0; )
113    {
114       if (a1 <= p->any.a1 && p->any.a1 < a2)
115       {
116          return True;
117       }
118    }
119    return False;
120 }
121 
122 /**
123  * Add state information for the client object at client address addr and
124  * of type t. Suppress data race reports on the address range [addr,addr+size[.
125  *
126  * @pre No other client object is present in the address range [addr,addr+size[.
127  */
DRD_(clientobj_add)128 DrdClientobj* DRD_(clientobj_add)(const Addr a1, const ObjType t)
129 {
130    DrdClientobj* p;
131 
132    tl_assert(! DRD_(clientobj_present)(a1, a1 + 1));
133    tl_assert(VG_(OSetGen_Lookup)(s_clientobj_set, &a1) == 0);
134 
135    if (s_trace_clientobj)
136       DRD_(trace_msg)("Adding client object 0x%lx of type %d", a1, t);
137 
138    p = VG_(OSetGen_AllocNode)(s_clientobj_set, sizeof(*p));
139    VG_(memset)(p, 0, sizeof(*p));
140    p->any.a1   = a1;
141    p->any.type = t;
142    p->any.first_observed_at = VG_(record_ExeContext)(VG_(get_running_tid)(), 0);
143    VG_(OSetGen_Insert)(s_clientobj_set, p);
144    tl_assert(VG_(OSetGen_Lookup)(s_clientobj_set, &a1) == p);
145    if (t == ClientHbvar)
146       DRD_(mark_hbvar)(a1);
147    else
148       DRD_(start_suppression)(a1, a1 + 1, "clientobj");
149    return p;
150 }
151 
152 /**
153  * Remove the information that was stored about the client object.
154  *
155  * @param[in] addr Address of the client object in the client address space.
156  * @param[in] t    Type of the client object.
157  */
DRD_(clientobj_remove)158 Bool DRD_(clientobj_remove)(const Addr addr, const ObjType t)
159 {
160    DrdClientobj* p;
161 
162    p = VG_(OSetGen_Lookup)(s_clientobj_set, &addr);
163    tl_assert(p);
164    tl_assert(p->any.type == t);
165    return clientobj_remove_obj(p);
166 }
167 
168 /**
169  * Remove the information that was stored about the client object p.
170  *
171  * @note The order of operations below is important. The client object is
172  *   removed from the client object set after the cleanup function has been
173  *   called such that if the cleanup function can still use the function
174  *   DRD_(clientobj_get_any)(). This happens e.g. in the function
175  *   first_observed() in drd_error.c.
176  */
clientobj_remove_obj(DrdClientobj * const p)177 static Bool clientobj_remove_obj(DrdClientobj* const p)
178 {
179    tl_assert(p);
180 
181    if (s_trace_clientobj) {
182       DRD_(trace_msg)("Removing client object 0x%lx of type %d", p->any.a1,
183                       p->any.type);
184 #if 0
185       VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(),
186                                  VG_(clo_backtrace_size));
187 #endif
188    }
189 
190    tl_assert(p->any.cleanup);
191    (*p->any.cleanup)(p);
192    VG_(OSetGen_Remove)(s_clientobj_set, &p->any.a1);
193    VG_(OSetGen_FreeNode)(s_clientobj_set, p);
194    return True;
195 }
196 
197 /**
198  * Clean up all client objects p for which their start address p->any.a1 fits
199  * inside the address range [ a1, a2 [.
200  *
201  * @note The implementation of this function relies on the fact that the
202  *   data in s_clientobj_set is sorted on the start address of client objects.
203  */
DRD_(clientobj_stop_using_mem)204 void DRD_(clientobj_stop_using_mem)(const Addr a1, const Addr a2)
205 {
206    Addr removed_at;
207    DrdClientobj* p;
208 
209    tl_assert(s_clientobj_set);
210 
211    if (! DRD_(range_contains_suppression_or_hbvar)(a1, a2))
212       return;
213 
214    VG_(OSetGen_ResetIterAt)(s_clientobj_set, &a1);
215    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0 && p->any.a1 < a2; )
216    {
217       tl_assert(a1 <= p->any.a1);
218       removed_at = p->any.a1;
219       clientobj_remove_obj(p);
220       /*
221        * The above call removes an element from the oset and hence
222        * invalidates the iterator. Restore the iterator.
223        */
224       VG_(OSetGen_ResetIterAt)(s_clientobj_set, &removed_at);
225    }
226 }
227 
228 /**
229  * Delete the per-thread information stored in client objects for the
230  * specified thread.
231  */
DRD_(clientobj_delete_thread)232 void DRD_(clientobj_delete_thread)(const DrdThreadId tid)
233 {
234    DrdClientobj *p;
235 
236    VG_(OSetGen_ResetIter)(s_clientobj_set);
237    for ( ; (p = VG_(OSetGen_Next)(s_clientobj_set)) != 0; )
238    {
239       if (p->any.delete_thread)
240       {
241          (*p->any.delete_thread)(p, tid);
242       }
243    }
244 }
245 
DRD_(clientobj_type_name)246 const char* DRD_(clientobj_type_name)(const ObjType t)
247 {
248    switch (t)
249    {
250    case ClientMutex:     return "mutex";
251    case ClientCondvar:   return "cond";
252    case ClientHbvar:     return "order annotation";
253    case ClientSemaphore: return "semaphore";
254    case ClientBarrier:   return "barrier";
255    case ClientRwlock:    return "rwlock";
256    }
257    return "(unknown)";
258 }
259