1/*
2  This file is part of drd, a thread error detector.
3
4  Copyright (C) 2006-2013 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_error.h"
26#include "drd_segment.h"
27#include "drd_thread.h"
28#include "pub_tool_basics.h"      // Addr, SizeT
29#include "pub_tool_libcassert.h"  // tl_assert()
30#include "pub_tool_libcbase.h"    // VG_(strlen)()
31#include "pub_tool_libcprint.h"   // VG_(printf)()
32#include "pub_tool_machine.h"     // VG_(get_SP)()
33#include "pub_tool_mallocfree.h"  // VG_(malloc)(), VG_(free)()
34#include "pub_tool_threadstate.h" // VG_INVALID_THREADID
35
36
37/* Global variables. */
38
39Segment* DRD_(g_sg_list);
40
41
42/* Local variables. */
43
44static ULong s_segment_merge_count;
45static ULong s_segments_created_count;
46static ULong s_segments_alive_count;
47static ULong s_max_segments_alive_count;
48static Bool s_trace_segment;
49
50
51/* Function definitions. */
52
53/**
54 * Initialize the memory 'sg' points at.
55 *
56 * @note The creator and created thread ID's may be equal.
57 * @note This function copies the vector clock of thread 'creator', a technique
58 *   also known as clock snooping. This will only work reliably if the thread
59 *   that called pthread_create() waits until the created thread has copied
60 *   the vector clock.
61 */
62static void sg_init(Segment* const sg,
63                    const DrdThreadId creator,
64                    const DrdThreadId created)
65{
66   Segment* creator_sg;
67   ThreadId vg_created = DRD_(DrdThreadIdToVgThreadId)(created);
68
69   tl_assert(sg);
70   tl_assert(creator == DRD_INVALID_THREADID
71             || DRD_(IsValidDrdThreadId)(creator));
72
73   creator_sg = (creator != DRD_INVALID_THREADID
74                 ? DRD_(thread_get_segment)(creator) : 0);
75
76   sg->g_next = NULL;
77   sg->g_prev = NULL;
78   sg->thr_next = NULL;
79   sg->thr_prev = NULL;
80   sg->tid = created;
81   sg->refcnt = 1;
82
83   if (vg_created != VG_INVALID_THREADID && VG_(get_SP)(vg_created) != 0)
84      sg->stacktrace = VG_(record_ExeContext)(vg_created, 0);
85   else
86      sg->stacktrace = 0;
87
88   if (creator_sg)
89      DRD_(vc_copy)(&sg->vc, &creator_sg->vc);
90   else
91      DRD_(vc_init)(&sg->vc, 0, 0);
92   DRD_(vc_increment)(&sg->vc, created);
93   DRD_(bm_init)(&sg->bm);
94
95   if (s_trace_segment)
96   {
97      HChar* vc;
98
99      vc = DRD_(vc_aprint)(&sg->vc);
100      VG_(message)(Vg_DebugMsg, "New segment for thread %d with vc %s\n",
101                   created, vc);
102      VG_(free)(vc);
103   }
104}
105
106/** Deallocate the memory that was allocated by sg_init(). */
107static void DRD_(sg_cleanup)(Segment* const sg)
108{
109   tl_assert(sg);
110   tl_assert(sg->refcnt == 0);
111
112   DRD_(vc_cleanup)(&sg->vc);
113   DRD_(bm_cleanup)(&sg->bm);
114}
115
116/** Allocate and initialize a new segment. */
117Segment* DRD_(sg_new)(const DrdThreadId creator, const DrdThreadId created)
118{
119   Segment* sg;
120
121   s_segments_created_count++;
122   s_segments_alive_count++;
123   if (s_max_segments_alive_count < s_segments_alive_count)
124      s_max_segments_alive_count = s_segments_alive_count;
125
126   sg = VG_(malloc)("drd.segment.sn.1", sizeof(*sg));
127   tl_assert(sg);
128   sg_init(sg, creator, created);
129   if (DRD_(g_sg_list)) {
130      DRD_(g_sg_list)->g_prev = sg;
131      sg->g_next = DRD_(g_sg_list);
132   }
133   DRD_(g_sg_list) = sg;
134   return sg;
135}
136
137static void DRD_(sg_delete)(Segment* const sg)
138{
139   if (DRD_(sg_get_trace)())
140   {
141      HChar* vc;
142
143      vc = DRD_(vc_aprint)(&sg->vc);
144      VG_(message)(Vg_DebugMsg, "Discarding the segment with vector clock %s\n",
145                   vc);
146      VG_(free)(vc);
147   }
148
149   s_segments_alive_count--;
150
151   tl_assert(sg);
152   if (sg->g_next)
153      sg->g_next->g_prev = sg->g_prev;
154   if (sg->g_prev)
155      sg->g_prev->g_next = sg->g_next;
156   else
157      DRD_(g_sg_list) = sg->g_next;
158   DRD_(sg_cleanup)(sg);
159   VG_(free)(sg);
160}
161
162/** Increment the reference count of the specified segment. */
163Segment* DRD_(sg_get)(Segment* const sg)
164{
165   tl_assert(sg);
166
167   sg->refcnt++;
168   return sg;
169}
170
171/**
172 * Decrement the reference count of the specified segment and deallocate the
173 * segment if the reference count became zero.
174 */
175void DRD_(sg_put)(Segment* const sg)
176{
177   if (sg == 0)
178      return;
179
180   if (s_trace_segment)
181   {
182      HChar* vc;
183
184      vc = DRD_(vc_aprint)(&sg->vc);
185      VG_(message)(Vg_DebugMsg,
186                   "Decrementing segment reference count %d -> %d with vc %s\n",
187                   sg->refcnt, sg->refcnt - 1, vc);
188      VG_(free)(vc);
189   }
190
191   tl_assert(sg->refcnt >= 1);
192
193   if (--sg->refcnt == 0)
194   {
195      DRD_(sg_delete)(sg);
196   }
197}
198
199/** Merge sg1 and sg2 into sg1. */
200void DRD_(sg_merge)(Segment* const sg1, Segment* const sg2)
201{
202   tl_assert(sg1);
203   tl_assert(sg1->refcnt == 1);
204   tl_assert(sg2);
205   tl_assert(sg2->refcnt == 1);
206
207   if (s_trace_segment)
208   {
209      HChar *vc1, *vc2;
210
211      vc1 = DRD_(vc_aprint)(&sg1->vc);
212      vc2 = DRD_(vc_aprint)(&sg2->vc);
213
214      VG_(message)(Vg_DebugMsg,
215		   "Merging segments with vector clocks %s and %s\n", vc1, vc2);
216      VG_(free)(vc1);
217      VG_(free)(vc2);
218   }
219
220   s_segment_merge_count++;
221
222   // Keep sg1->stacktrace.
223   // Keep sg1->vc.
224   // Merge sg2->bm into sg1->bm.
225   DRD_(bm_merge2)(&sg1->bm, &sg2->bm);
226}
227
228/** Print the vector clock and the bitmap of the specified segment. */
229void DRD_(sg_print)(Segment* const sg)
230{
231   tl_assert(sg);
232   VG_(printf)("vc: ");
233   DRD_(vc_print)(&sg->vc);
234   VG_(printf)("\n");
235   DRD_(bm_print)(&sg->bm);
236}
237
238/** Query whether segment tracing has been enabled. */
239Bool DRD_(sg_get_trace)(void)
240{
241   return s_trace_segment;
242}
243
244/** Enable or disable segment tracing. */
245void DRD_(sg_set_trace)(Bool const trace_segment)
246{
247   tl_assert(trace_segment == False || trace_segment == True);
248   s_trace_segment = trace_segment;
249}
250
251ULong DRD_(sg_get_segments_created_count)(void)
252{
253   return s_segments_created_count;
254}
255
256ULong DRD_(sg_get_segments_alive_count)(void)
257{
258   return s_segments_alive_count;
259}
260
261ULong DRD_(sg_get_max_segments_alive_count)(void)
262{
263   return s_max_segments_alive_count;
264}
265
266ULong DRD_(sg_get_segment_merge_count)(void)
267{
268   return s_segment_merge_count;
269}
270