drd/drd_segment.c

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