Prevent UB in DeleteLock() function #18881

pull hebasto wants to merge 6 commits into bitcoin:master from hebasto:200505-cofu changing 2 files +75 −50
  1. hebasto commented at 6:05 AM on May 5, 2020: member

    Tracking our instrumented mutexes (Mutex and RecursiveMutex types) requires that all involved objects should not be destroyed until after their last use. On master (ec79b5f86b22ad8f77c736f9bb76c2e4d7faeaa4) we have two problems related to the object destroying order:

    • the function-local static lockdata object that is destroyed at program exit
    • the thread_local g_lockstack that is destroyed at thread exit

    Both cases could cause UB at program exit in so far as mutexes are used in other static object destructors.

    Fix #18824

  2. hebasto commented at 6:06 AM on May 5, 2020: member

    cc @sipa

  3. DrahtBot added the label Docs on May 5, 2020
  4. in src/sync.cpp:87 in 5a406f7603 outdated 
      92 |  };
  93 |  LockData& GetLockData() {
  94 | -    static LockData lockdata;
  95 | -    return lockdata;
  96 | +    // See doc/developers-notes.md#construct-on-first-use-idiom
  97 | +    static auto lockdata = new LockData();
    MarcoFalke commented at 10:35 AM on May 5, 2020: 
        static LockData* lockdata = new LockData();

    not sure why auto needs to hide both the type and the pointer-ness. The additional 5 chars don't seem overly verbose.

    hebasto commented at 10:53 AM on May 5, 2020:

    Updated.

  5. MarcoFalke approved
  6. MarcoFalke commented at 10:35 AM on May 5, 2020: member

    ACK

  7. MarcoFalke removed the label Docs on May 5, 2020
  8. hebasto force-pushed on May 5, 2020
  9. hebasto commented at 10:52 AM on May 5, 2020: member

    Updated 5a406f76030263c1c4e5335cea3be022263426f2 -> 7e3f40dd594d81b37458f9f5d36d4d7df99f8917 (pr18881.01 -> pr18881.02, diff):

    not sure why auto needs to hide both the type and the pointer-ness. The additional 5 chars don't seem overly verbose.

  10. in doc/developer-notes.md:864 in 7e3f40dd59 outdated 
     859 | +    static BCLog::Logger* g_logger{new BCLog::Logger()};
 860 | +    return *g_logger;
 861 | +}
 862 | +```
 863 | +
 864 | +*Rationale*: This approache guaranties that:
    jonatack commented at 11:43 AM on May 5, 2020:

    approach guarantees

    hebasto commented at 11:49 AM on May 5, 2020:

    Thank you! Updated.

    jonatack commented at 11:58 AM on May 5, 2020:

    oops, somehow that comment was published before the review...GitHub :man_shrugging:

  11. in doc/developer-notes.md:847 in 7e3f40dd59 outdated 
     839 | @@ -839,6 +840,37 @@ namespace {
 840 |  #endif // BITCOIN_FOO_BAR_H
 841 |  ```
 842 |  
 843 | +Construct On First Use idiom
 844 | +------------------------------
 845 | +
 846 | +It is not possible to control the order in which non-local static objects in *different* translation units are initialized.
 847 | +This is the so-called "`static` initialization order problem". It could cause the use of an object:
    jonatack commented at 11:44 AM on May 5, 2020:

    I think the markdown is more readable without wrapping "static" in code markup (same for line 853 below)

  12. in doc/developer-notes.md:843 in 7e3f40dd59 outdated 
     839 | @@ -839,6 +840,37 @@ namespace {
 840 |  #endif // BITCOIN_FOO_BAR_H
 841 |  ```
 842 |  
 843 | +Construct On First Use idiom
    jonatack commented at 11:45 AM on May 5, 2020:

    can drop "idiom"? or maybe more clear with quotes: "Construct On First Use" idiom, but I personally prefer without "idiom"

    (same for line 853 below)

  13. in doc/developer-notes.md:866 in 7e3f40dd59 outdated 
     861 | +}
 862 | +```
 863 | +
 864 | +*Rationale*: This approache guaranties that:
 865 | +
 866 | +- an object gets constructed prior to its first use
    jonatack commented at 11:46 AM on May 5, 2020:

    s/gets/is/

  14. in doc/developer-notes.md:867 in 7e3f40dd59 outdated 
     862 | +```
 863 | +
 864 | +*Rationale*: This approache guaranties that:
 865 | +
 866 | +- an object gets constructed prior to its first use
 867 | +- an object doesn’t get destructed until after its last use
    jonatack commented at 11:47 AM on May 5, 2020:

    s/doesn't get/is not/

  15. hebasto force-pushed on May 5, 2020
  16. hebasto commented at 11:49 AM on May 5, 2020: member

    Updated 7e3f40dd594d81b37458f9f5d36d4d7df99f8917 -> a2234071ddc633cf92ba501126b74bf78731f676 (pr18881.02 -> pr18881.03, diff):

    approach guarantees

  17. in src/logging.cpp:16 in a2234071dd outdated 
      26 | - * have a trivial destructor.
  27 | - *
  28 | - * This method of initialization was originally introduced in
  29 | - * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
  30 | - */
  31 | +    // See doc/developers-notes.md#construct-on-first-use-idiom
    jonatack commented at 11:50 AM on May 5, 2020:

    developer

  18. in src/random.cpp:439 in a2234071dd outdated 
     435 | @@ -436,8 +436,7 @@ class RNGState {
 436 |  
 437 |  RNGState& GetRNGState() noexcept
 438 |  {
 439 | -    // This C++11 idiom relies on the guarantee that static variable are initialized
 440 | -    // on first call, even when multiple parallel calls are permitted.
 441 | +    // See doc/developers-notes.md#construct-on-first-use-idiom
    jonatack commented at 11:51 AM on May 5, 2020:

    developer

  19. in doc/developer-notes.md:872 in a2234071dd outdated 
     867 | +- an object doesn’t get destructed until after its last use
 868 | +- the initialization of an object is thread-safe
 869 | +
 870 | +*Note 1*: Even though the object pointed to by a pointer is never deleted, the memory doesn't actually "leak" since the operating system automatically reclaims all the memory in a program's heap when that program exits.
 871 | +
 872 | +*Note 2*: If it is required that the destructor for an object is called while the program is exiting, other approaches must be used.
    jonatack commented at 11:52 AM on May 5, 2020:

    If the destructor for an object needs to be called

  20. in src/sync.cpp:86 in a2234071dd outdated 
      91 |      std::mutex dd_mutex;
  92 |  };
  93 |  LockData& GetLockData() {
  94 | -    static LockData lockdata;
  95 | -    return lockdata;
  96 | +    // See doc/developers-notes.md#construct-on-first-use-idiom
    jonatack commented at 11:52 AM on May 5, 2020:

    developer

  21. jonatack commented at 11:52 AM on May 5, 2020: member

    Concept ACK/ACK

  22. hebasto force-pushed on May 5, 2020
  23. hebasto commented at 12:14 PM on May 5, 2020: member

    Updated a2234071ddc633cf92ba501126b74bf78731f676 -> d3c26862e263fea7d49df7f9bc9acef30a84c1ca (pr18881.03 -> pr18881.04, diff):

  24. DrahtBot added the label Docs on May 5, 2020
  25. in doc/developer-notes.md:864 in d3c26862e2 outdated 
     859 | +    static BCLog::Logger* g_logger{new BCLog::Logger()};
 860 | +    return *g_logger;
 861 | +}
 862 | +```
 863 | +
 864 | +*Rationale*: This approache guarantees that:
    jonatack commented at 12:50 PM on May 5, 2020:

    approach

    hebasto commented at 1:26 PM on May 5, 2020:

    Updated.

  26. in doc/developer-notes.md:853 in d3c26862e2 outdated 
     848 | +- before it is constructed (on program startup)
 849 | +- after it is destructed (at program exit)
 850 | +
 851 | +Both cases lead to undefined behavior.
 852 | +
 853 | +To prevent the static initialization order problem, use the Construct On First Use:
    jonatack commented at 12:50 PM on May 5, 2020:

    s/use the/be sure to/

    hebasto commented at 1:27 PM on May 5, 2020:

    Updated.

  27. in doc/developer-notes.md:858 in d3c26862e2 outdated 
     853 | +To prevent the static initialization order problem, use the Construct On First Use:
 854 | +
 855 | +```C++
 856 | +BCLog::Logger& LogInstance()
 857 | +{
 858 | +    // See doc/developer-notes.md#construct-on-first-use
    jonatack commented at 12:53 PM on May 5, 2020:

    comment seems unneeded?

    hebasto commented at 1:17 PM on May 5, 2020:

    It seems developers need multi-line comments to describe rationale of using COFU :) This oneliner is just a pointer to docs with detailed explanation and pitfalls (like not calling a destructor). I'd prefer keep it as is.

    jonatack commented at 1:29 PM on May 5, 2020:

    Yes, in the codebase it's fine but here it's a pointer to itself :) edit: reading the rendered doc I guess it's fine

    hebasto commented at 1:33 PM on May 5, 2020:

    As it is an "example", the presence of the comment line seems reasonable, no?

  28. in doc/developer-notes.md:856 in d3c26862e2 outdated 
     851 | +Both cases lead to undefined behavior.
 852 | +
 853 | +To prevent the static initialization order problem, use the Construct On First Use:
 854 | +
 855 | +```C++
 856 | +BCLog::Logger& LogInstance()
    jonatack commented at 12:53 PM on May 5, 2020:

    is this code snippet a good explanation of the concept?

    hebasto commented at 1:19 PM on May 5, 2020:

    Why not? I'd say "example" rather "explanation".

    jonatack commented at 1:33 PM on May 5, 2020:

    Sure; people can look it up anyway for more info.

  29. in doc/developer-notes.md:866 in d3c26862e2 outdated 
     861 | +}
 862 | +```
 863 | +
 864 | +*Rationale*: This approache guarantees that:
 865 | +
 866 | +- an object is constructed prior to its first use
    jonatack commented at 12:56 PM on May 5, 2020:

    sorry to re-review the same area, but I think this could be reduced to two points and would be better written as:

    • the object is constructed before first use and not destroyed until after last use
    • the object initialization is thread-safe

    (also: destructed -> destroyed and the "its" can be removed)

    hebasto commented at 1:27 PM on May 5, 2020:

    Updated.

    hebasto commented at 1:30 PM on May 5, 2020:

    "its" seems prevent any ambiguation :)

  30. jonatack commented at 12:58 PM on May 5, 2020: member

    Iterative re-review (apologies)

  31. hebasto force-pushed on May 5, 2020
  32. hebasto commented at 1:26 PM on May 5, 2020: member

    Updated d3c26862e263fea7d49df7f9bc9acef30a84c1ca -> 86ce03c53e22f0ce2c4bfbabd4aae5cf62dcb0fc (pr18881.04 -> pr18881.05, diff):

  33. jonatack commented at 1:31 PM on May 5, 2020: member

    ACK

  34. in doc/developer-notes.md:859 in 86ce03c53e outdated 
     854 | +
 855 | +```C++
 856 | +BCLog::Logger& LogInstance()
 857 | +{
 858 | +    // See doc/developer-notes.md#construct-on-first-use
 859 | +    static BCLog::Logger* g_logger{new BCLog::Logger()};
    sipa commented at 4:29 PM on May 5, 2020:

    It's nicer to use std::unique_pointer here, so that the object also gets destroyed on shutdown (in reserve order compared to initialization).

    MarcoFalke commented at 4:36 PM on May 5, 2020:

    Agree that the docs should recommend the version that doesn't leak. An additional note can say that a version that leaks might be preferable in rare circumstances.

    hebasto commented at 11:45 PM on May 5, 2020:

    IMO, destroying an object via std::unique_pointer:

    • is not required as no actual memory leak happens at program exit (C++ FAQ-a and FAQ-b); in another words, not destroying an object does not implies memory leaks in that case
    • is not safe as this object could (potentially) be destroyed before its last use at program exit sequence, e.g., instances of BCLog::Logger and LockData classes.
    hebasto commented at 11:57 PM on May 5, 2020:

    The initial intention of changing the docs was to drop every long explanation in the source, and just re-direct a code reader to the docs. If these changes seem controversial, all doc-change commits could be dropped :)

    promag commented at 12:59 AM on May 6, 2020:

    👀

    static BCLog::Logger logger;
return logger;
    hebasto commented at 1:46 AM on May 6, 2020: 
    static BCLog::Logger logger;
return logger;

    The logger object could (potentially) be destroyed before its last use at program exit sequence that leads to undefined behavior.

    hebasto commented at 1:48 AM on May 6, 2020:

    Actually, the d954f7c8c017c7e9bf60f48a8c41da8c498239f7 commit in this PR fixes such issue for the lockdata object.

    MarcoFalke commented at 6:21 PM on May 6, 2020:
    • Some tools check for leaked memory at exit, so making that the default increases verbosity for those tools.
    • The destructor must be trivial to be able to do that in the first place. I am not sure why you remove that requirement in the docs.
    sipa commented at 6:26 PM on May 6, 2020:

    Not doing that is not a leak. It's just memory that's still reachable at exit (which at least valgrind classifies differently than leaked memory, and doesn't warn about).

    I think it's just cleaner to clean things up too; for example this makes it easier to move globals into a class if that ever makes sense. Also, if that works, it means there exists a clear layering between which modules depend on which others in terms of initialization order, which is a low-priority nice-to-have if possible.

    laanwj commented at 12:54 PM on May 7, 2020:

    Right, unique_ptr won't work here. It was the same destruction order (thougn not initialization order) problem as using a global directly.

    hebasto commented at 2:43 PM on May 7, 2020:

    Changes to the developer-notes.md dropped.

    hebasto commented at 2:44 PM on May 7, 2020:

    Changes to the developer-notes.md dropped.

  35. in doc/developer-notes.md:853 in 86ce03c53e outdated 
     848 | +- before it is constructed (on program startup)
 849 | +- after it is destructed (at program exit)
 850 | +
 851 | +Both cases lead to undefined behavior.
 852 | +
 853 | +To prevent the static initialization order problem, be sure to Construct On First Use:
    laanwj commented at 12:52 PM on May 7, 2020:

    I don't think you should make this suggestion in general. This solution, while valuable in rare cases such as logging and tracking locks, is a brute-force one that does not belong in actual application code. It's messy and assumes we don't actually know what's going on (in regard to initialization dependencies) or what are all the edge cases.

    You're supposed to expliclty allocate things in a deterministic order during initialization and destroy it in a (usually reversed) deterministic order on shutdown in the appropriate functions in init.cpp, not rely on global initialization order nor first use.

  36. laanwj commented at 12:53 PM on May 7, 2020: member

    ACK on using this solution in this specific place but NACK on suggesting its use in general.

  37. jonatack commented at 2:23 PM on May 7, 2020: member

    <details><summary>looked more deeply into this to try to understand it better</summary> <p>

    I didn't find a direct reference to a "COFU" or "Construct on First Use" idiom in any of these books. The best references online seemed to be:

    and I agree with not suggesting it in general.

  38. hebasto force-pushed on May 7, 2020
  39. hebasto commented at 2:40 PM on May 7, 2020: member

    Updated 86ce03c53e22f0ce2c4bfbabd4aae5cf62dcb0fc -> 6bc686839a7cc09e3586e2a47ae4f16b5d918d3a (pr18881.05 -> pr18881.06, diff):

    • only the fix of UB in the DeleteLock() function remains
  40. MarcoFalke commented at 2:41 PM on May 7, 2020: member

    ACK 6bc686839a7cc09e3586e2a47ae4f16b5d918d3a

  41. jonatack commented at 3:16 PM on May 7, 2020: member

    Light code review ACK 6bc6868, this commit appears to be an implementation of the solution in https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use-members

  42. hebasto commented at 3:19 PM on May 7, 2020: member

    Light code review ACK 6bc6868, this commit appears to be an implementation of the solution in https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use-members

    To be exact: https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use

  43. jonatack commented at 3:23 PM on May 7, 2020: member

    To be exact: https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use

    Yes.

  44. MarcoFalke removed the label Docs on May 12, 2020
  45. MarcoFalke added the label Refactoring on May 12, 2020
  46. in src/sync.cpp:92 in 6bc686839a outdated 
      97 | +    // The operating system automatically reclaims all the memory in a program's heap when that program exits.
  98 | +    static LockData* lockdata{new LockData()};
  99 | +    return *lockdata;
 100 |  }
 101 |  
 102 |  static thread_local LockStack g_lockstack;
    MarcoFalke commented at 3:04 PM on May 12, 2020:

    Why is the above UB, but this not?

    hebasto commented at 5:52 AM on May 13, 2020:

    The g_lockstack variable is involved in locking and unlocking AnnotatedMixin<> mutexes.

    But lockdata is used in AnnotatedMixin<> destructor: https://github.com/bitcoin/bitcoin/blob/8da1e43b63cb36759eeb1fcfd6768163265c44e2/src/sync.h#L84-L86

    and we have global AnnotatedMixin<> mutexes.

    MarcoFalke commented at 10:45 AM on May 13, 2020:

    So it would make sense to fix both occurrences of UB in one pull

    hebasto commented at 11:37 AM on May 13, 2020:

    Sorry for my poor English... I meant that only lockdata could be a source of UB because it is used in the ~AnnotatedMixin<> and the destroy order itself is not predictable in any way.

    The destroying of g_lockstack couldn't cause UB, IMO.

    MarcoFalke commented at 11:51 AM on May 13, 2020:

    Ok, I have deleted my comment. Here is the backtrace (same backtrace on master and this pull):

    <details><summary>backtrace</summary>

    valgrind /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn -runs=1 /bitcoin-core/ci/scratch/qa-assets/fuzz_seed_corpus/process_message_blocktxn
==51564== Memcheck, a memory error detector
==51564== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==51564== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==51564== Command: /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn -runs=1 /bitcoin-core/ci/scratch/qa-assets/fuzz_seed_corpus/process_message_blocktxn
==51564== 
INFO: Seed: 2408119127
INFO: Loaded 1 modules   (115207 inline 8-bit counters): 115207 [0x1357748, 0x137394f), 
INFO: Loaded 1 PC tables (115207 PCs): 115207 [0x1373950,0x15359c0), 
INFO:      304 files found in /bitcoin-core/ci/scratch/qa-assets/fuzz_seed_corpus/process_message_blocktxn
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1007323 bytes
INFO: seed corpus: files: 304 min: 1b max: 1007323b total: 7665972b rss: 245Mb
[#64](/bitcoin-bitcoin/64/)	pulse  cov: 3446 ft: 4828 corp: 45/2817b exec/s: 32 rss: 271Mb
[#128](/bitcoin-bitcoin/128/)	pulse  cov: 3507 ft: 6576 corp: 103/13967b exec/s: 42 rss: 277Mb
[#256](/bitcoin-bitcoin/256/)	pulse  cov: 3511 ft: 8158 corp: 211/121Kb exec/s: 32 rss: 277Mb
[#305](/bitcoin-bitcoin/305/)	INITED cov: 3511 ft: 8241 corp: 229/480Kb exec/s: 30 rss: 280Mb
[#305](/bitcoin-bitcoin/305/)	DONE   cov: 3511 ft: 8241 corp: 229/480Kb lim: 301441 exec/s: 30 rss: 280Mb
Done 305 runs in 10 second(s)
==51564== Invalid write of size 8
==51564==    at 0xA5D451: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==  Address 0x5170be0 is 0 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 1
==51564==    at 0xA5D505: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==  Address 0x5170be8 is 8 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D88: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D525: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170bf0 is 16 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991DC5: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D525: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170c00 is 32 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991DB1: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D525: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170bf8 is 24 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D88: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D540: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170c10 is 48 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991DC5: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D540: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170c20 is 64 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991DB1: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D540: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==  Address 0x5170c18 is 56 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 4
==51564==    at 0xA5D54D: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==  Address 0x5170c38 is 88 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0xA5D555: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==  Address 0x5170c30 is 80 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid read of size 8
==51564==    at 0xA57487: push_lock(void*, CLockLocation const&) (sync.cpp:138)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA18954: CScheduler::stop(bool) (scheduler.cpp:77)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Address 0x5170be0 is 0 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid read of size 8
==51564==    at 0x4991E34: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string() (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA57AD0: CLockLocation::~CLockLocation() (sync.cpp:43)
==51564==    by 0xA5C3B9: std::pair<void*, CLockLocation>::~pair() (stl_iterator.h:1286)
==51564==    by 0xA5E64E: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::destroy<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*) (new_allocator.h:153)
==51564==    by 0xA5E5B2: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::destroy<std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*) (alloc_traits.h:497)
==51564==    by 0xA659B5: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::pop_back() (stl_vector.h:1226)
==51564==    by 0xA5855A: pop_lock() (sync.cpp:155)
==51564==    by 0xA584D2: LeaveCritical() (sync.cpp:177)
==51564==    by 0x4DF72C: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::~UniqueLock() (sync.h:169)
==51564==    by 0xA1899E: CScheduler::stop(bool) (scheduler.cpp:82)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==  Address 0x5170c10 is 48 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid read of size 8
==51564==    at 0x4991E34: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string() (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA57AE0: CLockLocation::~CLockLocation() (sync.cpp:43)
==51564==    by 0xA5C3B9: std::pair<void*, CLockLocation>::~pair() (stl_iterator.h:1286)
==51564==    by 0xA5E64E: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::destroy<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*) (new_allocator.h:153)
==51564==    by 0xA5E5B2: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::destroy<std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*) (alloc_traits.h:497)
==51564==    by 0xA659B5: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::pop_back() (stl_vector.h:1226)
==51564==    by 0xA5855A: pop_lock() (sync.cpp:155)
==51564==    by 0xA584D2: LeaveCritical() (sync.cpp:177)
==51564==    by 0x4DF72C: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::~UniqueLock() (sync.h:169)
==51564==    by 0xA1899E: CScheduler::stop(bool) (scheduler.cpp:82)
==51564==    by 0xB05A9D: TestingSetup::~TestingSetup() (setup_common.cpp:174)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==  Address 0x5170bf0 is 16 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D97: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D525: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA1A5E8: SingleThreadedSchedulerClient::ProcessQueue() (scheduler.cpp:161)
==51564==  Address 0x5170bf0 is 16 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D9E: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D525: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA1A5E8: SingleThreadedSchedulerClient::ProcessQueue() (scheduler.cpp:161)
==51564==  Address 0x5170c00 is 32 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid read of size 8
==51564==    at 0xA57487: push_lock(void*, CLockLocation const&) (sync.cpp:138)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA1A5E8: SingleThreadedSchedulerClient::ProcessQueue() (scheduler.cpp:161)
==51564==    by 0xA1B0CF: SingleThreadedSchedulerClient::EmptyQueue() (scheduler.cpp:201)
==51564==    by 0x8DE049: CMainSignals::FlushBackgroundCallbacks() (validationinterface.cpp:103)
==51564==    by 0xB05B4A: TestingSetup::~TestingSetup() (setup_common.cpp:177)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Address 0x5170be0 is 0 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D97: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D540: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA68C2B: CThreadInterrupt::operator()() (threadinterrupt.cpp:25)
==51564==  Address 0x5170c10 is 48 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid write of size 8
==51564==    at 0x4991D9E: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
==51564==    by 0xA5D540: CLockLocation::CLockLocation(CLockLocation&&) (sync.cpp:43)
==51564==    by 0xA5D467: std::pair<void*, CLockLocation>::pair(std::pair<void*, CLockLocation>&&) (stl_pair.h:304)
==51564==    by 0xA5D3B1: void __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (new_allocator.h:147)
==51564==    by 0xA5D00D: void std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::construct<std::pair<void*, CLockLocation>, std::pair<void*, CLockLocation> >(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, std::pair<void*, CLockLocation>&&) (alloc_traits.h:484)
==51564==    by 0xA5CE86: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:115)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5559B8: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4DF455: UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::UniqueLock(AnnotatedMixin<std::mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA68C2B: CThreadInterrupt::operator()() (threadinterrupt.cpp:25)
==51564==  Address 0x5170c20 is 64 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== Invalid read of size 8
==51564==    at 0xA5EB4A: std::pair<void*, void*>::pair<void*&, true>(void* const&, void*&) (stl_pair.h:326)
==51564==    by 0xA5C46B: std::pair<std::__decay_and_strip<void* const&>::__type, std::__decay_and_strip<void*&>::__type> std::make_pair<void* const&, void*&>(void* const&, void*&) (stl_pair.h:529)
==51564==    by 0xA57515: push_lock(void*, CLockLocation const&) (sync.cpp:141)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0x6C7727: CTxMemPool::clear() (txmempool.cpp:600)
==51564==    by 0x81D4D5: UnloadBlockIndex() (validation.cpp:4584)
==51564==    by 0xB05BF8: TestingSetup::~TestingSetup() (setup_common.cpp:185)
==51564==    by 0x4CC5A26: __run_exit_handlers (exit.c:108)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Address 0x5170be0 is 0 bytes inside a block of size 768 free'd
==51564==    at 0x483CFBF: operator delete(void*) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E79A: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::deallocate(std::pair<void*, CLockLocation>*, unsigned long) (new_allocator.h:128)
==51564==    by 0xA5E6F2: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::deallocate(std::allocator<std::pair<void*, CLockLocation> >&, std::pair<void*, CLockLocation>*, unsigned long) (alloc_traits.h:470)
==51564==    by 0xA5DB99: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_deallocate(std::pair<void*, CLockLocation>*, unsigned long) (stl_vector.h:351)
==51564==    by 0xA60D20: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~_Vector_base() (stl_vector.h:332)
==51564==    by 0xA57104: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::~vector() (stl_vector.h:680)
==51564==    by 0x4CC643E: __call_tls_dtors (cxa_thread_atexit_impl.c:155)
==51564==    by 0x4CC5B8C: __run_exit_handlers (exit.c:46)
==51564==    by 0x4CC5BDF: exit (exit.c:139)
==51564==    by 0x4236D8: fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==    by 0x44C322: main (in /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn)
==51564==  Block was alloc'd at
==51564==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==51564==    by 0xA5E095: __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) (new_allocator.h:114)
==51564==    by 0xA5DF94: std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) (alloc_traits.h:444)
==51564==    by 0xA5D90D: std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) (stl_vector.h:343)
==51564==    by 0xA5D17F: void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_realloc_insert<std::pair<void*, CLockLocation> >(__gnu_cxx::__normal_iterator<std::pair<void*, CLockLocation>*, std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > > >, std::pair<void*, CLockLocation>&&) (vector.tcc:440)
==51564==    by 0xA5CED2: std::pair<void*, CLockLocation>& std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) (vector.tcc:121)
==51564==    by 0xA5C255: std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::push_back(std::pair<void*, CLockLocation>&&) (stl_vector.h:1201)
==51564==    by 0xA573FE: push_lock(void*, CLockLocation const&) (sync.cpp:135)
==51564==    by 0xA572A4: EnterCritical(char const*, char const*, int, void*, bool) (sync.cpp:160)
==51564==    by 0x5160A8: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::Enter(char const*, char const*, int) (sync.h:126)
==51564==    by 0x4BB885: UniqueLock<AnnotatedMixin<std::recursive_mutex>, std::unique_lock<std::recursive_mutex> >::UniqueLock(AnnotatedMixin<std::recursive_mutex>&, char const*, char const*, int, bool) (sync.h:152)
==51564==    by 0xA7479F: ArgsManager::GetSetting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const (system.cpp:861)
==51564== 
==51564== 
==51564== HEAP SUMMARY:
==51564==     in use at exit: 23,172,862 bytes in 1,487 blocks
==51564==   total heap usage: 138,583 allocs, 137,096 frees, 324,726,925 bytes allocated
==51564== 
==51564== LEAK SUMMARY:
==51564==    definitely lost: 0 bytes in 0 blocks
==51564==    indirectly lost: 0 bytes in 0 blocks
==51564==      possibly lost: 304 bytes in 1 blocks
==51564==    still reachable: 23,172,558 bytes in 1,486 blocks
==51564==         suppressed: 0 bytes in 0 blocks
==51564== Rerun with --leak-check=full to see details of leaked memory
==51564== 
==51564== For lists of detected and suppressed errors, rerun with: -s
==51564== ERROR SUMMARY: 167 errors from 19 contexts (suppressed: 0 from 0)

    </details>

    hebasto commented at 11:54 AM on May 13, 2020:
    • struct desctructor locks the global mutex -> Reads free'd lockstack

    I can see only locking of lockdata.dd_mutex, or did I miss?

    MarcoFalke commented at 1:24 PM on May 16, 2020:

    So reading from the bt, it looks like g_lockstack is initialized on first use. Not sure why, though. Because it is initialized on first use, it leads to invalid memory access.

    Donating the memory to the operating system at the end instead of calling the destructor fixes the problem for me.

    MarcoFalke commented at 1:26 PM on May 16, 2020:

    Is this something inherent to thread_local to construct on first use?

    Running this example program:

    struct Foo {
    Mutex m_mut;
    Foo()
    {
        std::cout << __LINE__ << __func__ << std::endl;
        LOCK(m_mut);
    }
    ~Foo()
    {
        std::cout << __LINE__ << __func__ << std::endl;
        LOCK(m_mut);
    }
};

void initialize()
{
}

void test_one_input(const std::vector<uint8_t>& buffer)
{
    static Foo bar;
}

    gives me

    14Foo
80LockStack
84~LockStack
19~Foo
    MarcoFalke commented at 1:27 PM on May 16, 2020:

    How I expect it to work from reading the code was

    LockStack
Foo
~Foo
~LockStack
    hebasto commented at 5:18 AM on May 17, 2020:

    As I understand, ~TestingSetup() locks Mutex newTaskMutex, and, consequently, uses LockStack g_lockstack.

    Having a static instance of the TestingSetup makes the destroying order unpredictable that leads to UB due to the possible usage of (writing to and reading from) g_lockstack.

    I found two cases of a static instance of the TestingSetup: https://github.com/bitcoin/bitcoin/blob/f8123d483caaee64c28be77fb5b6ae12293ddc4a/src/test/fuzz/process_messages.cpp#L19 https://github.com/bitcoin/bitcoin/blob/f8123d483caaee64c28be77fb5b6ae12293ddc4a/src/test/fuzz/process_message.cpp#L44 @MarcoFalke

    Donating the memory to the operating system at the end instead of calling the destructor fixes the problem for me.

    Which object are you talking about?

    hebasto commented at 8:23 AM on May 17, 2020:

    @MarcoFalke

    I can confirm that the following patch fixes all of the memory errors mentioned in this pull:

    diff --git a/src/sync.cpp b/src/sync.cpp
index 41c75302d..9b99f5cfa 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -89,7 +89,12 @@ LockData& GetLockData() {
     return *lockdata;
 }
 
-static thread_local LockStack g_lockstack;
+LockStack& GetLockStack() {
+    // This approach guarantees that the *lockstack object is not destroyed until after its last use.
+    // The operating system automatically reclaims all the memory in a program's heap when that program exits.
+    static thread_local LockStack* lockstack{new LockStack()};
+    return *lockstack;
+}
 
 static void potential_deadlock_detected(const std::pair<void*, void*>& mismatch, const LockStack& s1, const LockStack& s2)
 {
@@ -126,16 +131,17 @@ static void push_lock(void* c, const CLockLocation& locklocation)
     LockData& lockdata = GetLockData();
     std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
 
-    g_lockstack.push_back(std::make_pair(c, locklocation));
+    LockStack& lockstack = GetLockStack();
+    lockstack.push_back(std::make_pair(c, locklocation));
 
-    for (const std::pair<void*, CLockLocation>& i : g_lockstack) {
+    for (const std::pair<void*, CLockLocation>& i : lockstack) {
         if (i.first == c)
             break;
 
         std::pair<void*, void*> p1 = std::make_pair(i.first, c);
         if (lockdata.lockorders.count(p1))
             continue;
-        lockdata.lockorders.emplace(p1, g_lockstack);
+        lockdata.lockorders.emplace(p1, lockstack);
 
         std::pair<void*, void*> p2 = std::make_pair(c, i.first);
         lockdata.invlockorders.insert(p2);
@@ -146,7 +152,7 @@ static void push_lock(void* c, const CLockLocation& locklocation)
 
 static void pop_lock()
 {
-    g_lockstack.pop_back();
+    GetLockStack().pop_back();
 }
 
 void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry)
@@ -156,8 +162,9 @@ void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs
 
 void CheckLastCritical(void* cs, std::string& lockname, const char* guardname, const char* file, int line)
 {
-    if (!g_lockstack.empty()) {
-        const auto& lastlock = g_lockstack.back();
+    LockStack& lockstack = GetLockStack();
+    if (!lockstack.empty()) {
+        const auto& lastlock = lockstack.back();
         if (lastlock.first == cs) {
             lockname = lastlock.second.Name();
             return;
@@ -174,14 +181,16 @@ void LeaveCritical()
 std::string LocksHeld()
 {
     std::string result;
-    for (const std::pair<void*, CLockLocation>& i : g_lockstack)
+    LockStack& lockstack = GetLockStack();
+    for (const std::pair<void*, CLockLocation>& i : lockstack)
         result += i.second.ToString() + std::string("\n");
     return result;
 }
 
 void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
 {
-    for (const std::pair<void*, CLockLocation>& i : g_lockstack)
+    LockStack& lockstack = GetLockStack();
+    for (const std::pair<void*, CLockLocation>& i : lockstack)
         if (i.first == cs)
             return;
     tfm::format(std::cerr, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld());
@@ -190,7 +199,8 @@ void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine,
 
 void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
 {
-    for (const std::pair<void*, CLockLocation>& i : g_lockstack) {
+    LockStack& lockstack = GetLockStack();
+    for (const std::pair<void*, CLockLocation>& i : lockstack) {
         if (i.first == cs) {
             tfm::format(std::cerr, "Assertion failed: lock %s held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld());
             abort();

    Going to investigate for any regression.

    MarcoFalke commented at 10:37 AM on May 17, 2020:

    Having a static instance of the TestingSetup makes the destroying order unpredictable

    I wasn't aware of that. I assumed that the order globals are destroyed is the inverse order of how they were constructed.

    hebasto commented at 10:42 AM on May 17, 2020:

    I wasn't aware of that. I assumed that the order globals are destroyed is the inverse order of how they were constructed.

    That is correct. But if globals are defined in different translation units then the order of how them are constructed is unpredictable.

    MarcoFalke commented at 10:48 AM on May 17, 2020:

    TIL

    Anyway, I did the same changes as in your comment and for me that fixed the problems.

    promag commented at 10:48 AM on May 17, 2020:

    Lets move them all to same unit :trollface:

    MarcoFalke commented at 10:49 AM on May 17, 2020:

    main.cpp, maybe?

    hebasto commented at 11:24 AM on May 17, 2020:

    Lets move them all to same unit :trollface:

    main.cpp, maybe?

    What about unit tests?

    hebasto commented at 12:11 PM on May 17, 2020:

    Updated.

  47. MarcoFalke changes_requested
  48. MarcoFalke commented at 3:06 PM on May 12, 2020: member

    I still get the error free(): corrupted unsorted chunks when fuzzing on focal with enable-debug:

    root@042ac26113c2:/bitcoin-core# /bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn -runs=1 /bitcoin-core/ci/scratch/qa-assets/fuzz_seed_corpus/process_message_blocktxn
INFO: Seed: 2368542291
INFO: Loaded 1 modules   (115207 inline 8-bit counters): 115207 [0x55d1f460d748, 0x55d1f462994f), 
INFO: Loaded 1 PC tables (115207 PCs): 115207 [0x55d1f4629950,0x55d1f47eb9c0), 
INFO:      304 files found in /bitcoin-core/ci/scratch/qa-assets/fuzz_seed_corpus/process_message_blocktxn
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1007323 bytes
INFO: seed corpus: files: 304 min: 1b max: 1007323b total: 7665972b rss: 76Mb
[#305](/bitcoin-bitcoin/305/)	INITED cov: 3511 ft: 8239 corp: 229/480Kb exec/s: 0 rss: 84Mb
[#305](/bitcoin-bitcoin/305/)	DONE   cov: 3511 ft: 8239 corp: 229/480Kb lim: 301441 exec/s: 0 rss: 84Mb
Done 305 runs in 0 second(s)
free(): corrupted unsorted chunks
==51558== ERROR: libFuzzer: deadly signal
    [#0](/bitcoin-bitcoin/0/) 0x55d1f3755930 in __sanitizer_print_stack_trace (/bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn+0x397930)
    [#1](/bitcoin-bitcoin/1/) 0x55d1f3701c38 in fuzzer::PrintStackTrace() (/bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn+0x343c38)
    [#2](/bitcoin-bitcoin/2/) 0x55d1f36e6d83 in fuzzer::Fuzzer::CrashCallback() (/bitcoin-core/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/fuzz/process_message_blocktxn+0x328d83)
    [#3](/bitcoin-bitcoin/3/) 0x7f7660b583bf  (/lib/x86_64-linux-gnu/libpthread.so.0+0x153bf)
    [#4](/bitcoin-bitcoin/4/) 0x7f76607bf18a in __libc_signal_restore_set /build/glibc-YYA7BZ/glibc-2.31/signal/../sysdeps/unix/sysv/linux/internal-signals.h:86:3
    [#5](/bitcoin-bitcoin/5/) 0x7f76607bf18a in raise /build/glibc-YYA7BZ/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:48:3
    [#6](/bitcoin-bitcoin/6/) 0x7f766079e858 in abort /build/glibc-YYA7BZ/glibc-2.31/stdlib/abort.c:79:7
    [#7](/bitcoin-bitcoin/7/) 0x7f76608093ed in __libc_message /build/glibc-YYA7BZ/glibc-2.31/libio/../sysdeps/posix/libc_fatal.c:155:5
    [#8](/bitcoin-bitcoin/8/) 0x7f766081147b in malloc_printerr /build/glibc-YYA7BZ/glibc-2.31/malloc/malloc.c:5347:3
    [#9](/bitcoin-bitcoin/9/) 0x7f76608131c1 in _int_free /build/glibc-YYA7BZ/glibc-2.31/malloc/malloc.c:4356:2
    [#10](/bitcoin-bitcoin/10/) 0x7f7660816a0c in __GI___libc_free /build/glibc-YYA7BZ/glibc-2.31/malloc/malloc.c:3125:3
    [#11](/bitcoin-bitcoin/11/) 0x7f7660816a0c in tcache_thread_shutdown /build/glibc-YYA7BZ/glibc-2.31/malloc/malloc.c:2964:4
    [#12](/bitcoin-bitcoin/12/) 0x7f7660816a0c in __malloc_arena_thread_freeres /build/glibc-YYA7BZ/glibc-2.31/malloc/arena.c:951:3
    [#13](/bitcoin-bitcoin/13/) 0x7f7660b4c62e in start_thread /build/glibc-YYA7BZ/glibc-2.31/nptl/pthread_create.c:491:3
    [#14](/bitcoin-bitcoin/14/) 0x7f766089b102 in clone /build/glibc-YYA7BZ/glibc-2.31/misc/../sysdeps/unix/sysv/linux/x86_64/clone.S:95

NOTE: libFuzzer has rudimentary signal handlers.
      Combine libFuzzer with AddressSanitizer or similar for better crash reports.
SUMMARY: libFuzzer: deadly signal
MS: 0 ; base unit: 0000000000000000000000000000000000000000


artifact_prefix='./'; Test unit written to ./crash-da39a3ee5e6b4b0d3255bfef95601890afd80709
Base64:
  49. hebasto commented at 12:11 PM on May 17, 2020: member

    Updated 6bc686839a7cc09e3586e2a47ae4f16b5d918d3a -> d34871883ce116b8ba4e3add5d5330215a0b16f3 (pr18881.06 -> pr18881.07, diff):

  50. in src/sync.cpp:97 in d34871883c outdated 
     100 |  }
 101 |  
 102 | -static thread_local LockStack g_lockstack;
 103 | +LockStack& GetLockStack() {
 104 | +    // This approach guarantees that the *lockstack object is not destroyed until after its last use.
 105 | +    // The operating system automatically reclaims all the memory in a program's heap when that program exits.
    MarcoFalke commented at 12:15 PM on May 17, 2020:

    Maybe also mention that this is only safe to do because the object happens to have a trivial destructor?

  51. in src/sync.cpp:165 in d34871883c outdated 
     161 | @@ -162,8 +162,9 @@ void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs
 162 |  
 163 |  void CheckLastCritical(void* cs, std::string& lockname, const char* guardname, const char* file, int line)
 164 |  {
 165 | -    if (!g_lockstack.empty()) {
 166 | -        const auto& lastlock = g_lockstack.back();
 167 | +    LockStack& lockstack = GetLockStack();
    MarcoFalke commented at 12:15 PM on May 17, 2020: 
        const LockStack& lockstack = GetLockStack();
  52. in src/sync.cpp:184 in d34871883c outdated 
     180 | @@ -180,14 +181,16 @@ void LeaveCritical()
 181 |  std::string LocksHeld()
 182 |  {
 183 |      std::string result;
 184 | -    for (const std::pair<void*, CLockLocation>& i : g_lockstack)
 185 | +    LockStack& lockstack = GetLockStack();
    MarcoFalke commented at 12:16 PM on May 17, 2020: 
        const LockStack& lockstack = GetLockStack();
  53. in src/sync.cpp:192 in d34871883c outdated 
     189 |  }
 190 |  
 191 |  void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
 192 |  {
 193 | -    for (const std::pair<void*, CLockLocation>& i : g_lockstack)
 194 | +    LockStack& lockstack = GetLockStack();
    MarcoFalke commented at 12:16 PM on May 17, 2020:

    same

  54. in src/sync.cpp:202 in d34871883c outdated 
     198 | @@ -196,7 +199,8 @@ void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine,
 199 |  
 200 |  void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs)
 201 |  {
 202 | -    for (const std::pair<void*, CLockLocation>& i : g_lockstack) {
 203 | +    LockStack& lockstack = GetLockStack();
    MarcoFalke commented at 12:16 PM on May 17, 2020:

    same

  55. MarcoFalke approved
  56. MarcoFalke commented at 12:16 PM on May 17, 2020: member

    might test later ACK

  57. hebasto force-pushed on May 17, 2020
  58. hebasto commented at 1:01 PM on May 17, 2020: member

    Updated d34871883ce116b8ba4e3add5d5330215a0b16f3 -> f5c00ba32a041108d0c7c7c8f4c5709b82e1e91a (pr18881.07 -> pr18881.08, diff):

  59. MarcoFalke commented at 1:13 PM on May 17, 2020: member

    ACK f5c00ba32a041108d0c7c7c8f4c5709b82e1e91a

  60. MarcoFalke commented at 1:30 PM on May 17, 2020: member 
    =================================================================

==28222==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 240 byte(s) in 10 object(s) allocated from:

    [#0](/bitcoin-bitcoin/0/) 0x5559dd5b8762 in operator new(unsigned long) (/home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/test_bitcoin+0x2e23762)

    [#1](/bitcoin-bitcoin/1/) 0x5559ded68cff in GetLockStack() /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:97:46

    [#2](/bitcoin-bitcoin/2/) 0x5559ded68eb9 in EnterCritical(char const*, char const*, int, void*, bool) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:162:5

    [#3](/bitcoin-bitcoin/3/) 0x5559ddcf94f9 in UniqueLock<AnnotatedMixin<std::mutex>, std::unique_lock<std::mutex> >::Enter(char const*, char const*, int) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/./sync.h:126:9

Direct leak of 96 byte(s) in 4 object(s) allocated from:

    [#0](/bitcoin-bitcoin/0/) 0x5559dd5b8762 in operator new(unsigned long) (/home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/test_bitcoin+0x2e23762)

    [#1](/bitcoin-bitcoin/1/) 0x5559ded68cff in GetLockStack() /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:97:46

    [#2](/bitcoin-bitcoin/2/) 0x5559ded68eb9 in EnterCritical(char const*, char const*, int, void*, bool) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:162:5

    [#3](/bitcoin-bitcoin/3/) 0x5559dd8f1455 in CCheckQueueControl<checkqueue_tests::FakeCheck>::CCheckQueueControl(CCheckQueue<checkqueue_tests::FakeCheck>*) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/./checkqueue.h:184:13

    [#4](/bitcoin-bitcoin/4/) 0x7fa81886cbcc  (/usr/lib/x86_64-linux-gnu/libboost_thread.so.1.65.1+0x11bcc)

Direct leak of 24 byte(s) in 1 object(s) allocated from:

    [#0](/bitcoin-bitcoin/0/) 0x5559dd5b8762 in operator new(unsigned long) (/home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/test_bitcoin+0x2e23762)

    [#1](/bitcoin-bitcoin/1/) 0x5559ded68cff in GetLockStack() /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:97:46

    [#2](/bitcoin-bitcoin/2/) 0x5559ded68eb9 in EnterCritical(char const*, char const*, int, void*, bool) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/sync.cpp:162:5

    [#3](/bitcoin-bitcoin/3/) 0x5559dd8ede65 in CCheckQueueControl<checkqueue_tests::FrozenCleanupCheck>::CCheckQueueControl(CCheckQueue<checkqueue_tests::FrozenCleanupCheck>*) /home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/./checkqueue.h:184:13

    [#4](/bitcoin-bitcoin/4/) 0x5559dd8aa640 in std::__invoke_result<checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5>::type std::__invoke<checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5>(checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5&&) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/bits/invoke.h:95:14

    [#5](/bitcoin-bitcoin/5/) 0x5559dd8aa640 in decltype(std::__invoke(_S_declval<0ul>())) std::thread::_Invoker<std::tuple<checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5> >::_M_invoke<0ul>(std::_Index_tuple<0ul>) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/thread:234

    [#6](/bitcoin-bitcoin/6/) 0x5559dd8aa640 in std::thread::_Invoker<std::tuple<checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5> >::operator()() /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/thread:243

    [#7](/bitcoin-bitcoin/7/) 0x5559dd8aa640 in std::thread::_State_impl<std::thread::_Invoker<std::tuple<checkqueue_tests::test_CheckQueue_FrozenCleanup::test_method()::$_5> > >::_M_run() /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/thread:186

Indirect leak of 1440 byte(s) in 15 object(s) allocated from:

    [#0](/bitcoin-bitcoin/0/) 0x5559dd5b8762 in operator new(unsigned long) (/home/travis/build/bitcoin/bitcoin/ci/scratch/build/bitcoin-x86_64-pc-linux-gnu/src/test/test_bitcoin+0x2e23762)

    [#1](/bitcoin-bitcoin/1/) 0x5559ded721ff in __gnu_cxx::new_allocator<std::pair<void*, CLockLocation> >::allocate(unsigned long, void const*) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/ext/new_allocator.h:111:27

    [#2](/bitcoin-bitcoin/2/) 0x5559ded721ff in std::allocator_traits<std::allocator<std::pair<void*, CLockLocation> > >::allocate(std::allocator<std::pair<void*, CLockLocation> >&, unsigned long) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/bits/alloc_traits.h:436

    [#3](/bitcoin-bitcoin/3/) 0x5559ded721ff in std::_Vector_base<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::_M_allocate(unsigned long) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/bits/stl_vector.h:172

    [#4](/bitcoin-bitcoin/4/) 0x5559ded70a61 in void std::vector<std::pair<void*, CLockLocation>, std::allocator<std::pair<void*, CLockLocation> > >::emplace_back<std::pair<void*, CLockLocation> >(std::pair<void*, CLockLocation>&&) /usr/bin/../lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/bits/vector.tcc:105:4

SUMMARY: AddressSanitizer: 1800 byte(s) leaked in 30 allocation(s).

Makefile:17661: recipe for target 'test/checkqueue_tests.cpp.test' failed

make[3]: *** [test/checkqueue_tests.cpp.test] Error 1
  61. hebasto force-pushed on May 18, 2020
  62. hebasto force-pushed on May 18, 2020
  63. MarcoFalke commented at 10:27 AM on May 18, 2020: member

    Was this a false positive or a true one? If false, we shouldn't change our code for their bug, but add it to the suppressions.

  64. hebasto commented at 10:30 AM on May 18, 2020: member

    @MarcoFalke

    Was this a false positive or a true one? If false, we shouldn't change our code for their bug, but add it to the suppressions.

    The main reason why thread_local is not usable to track mutexes that are used in destructors is the following statement from https://en.cppreference.com/w/cpp/utility/program/exit:

    The last destructor for thread-local objects is sequenced-before the first destructor for a static object

  65. MarcoFalke commented at 10:43 AM on May 18, 2020: member

    Ok, fair enough. I think I am giving up on C++. Is your work based on #18851? If yes, maybe add the comment that the map is append only (theoretically unbounded growth) and optionally a co-author.

    Otherwise Concept ACK. Will test if this fixes my problem when this is ready for review.

  66. hebasto commented at 10:48 AM on May 18, 2020: member

    Is your work based on #18851?

    Yes. The commit message is borrowed from #18851 as I keep improving my English :D

    If yes, maybe add the comment that the map is append only (theoretically unbounded growth) and optionally a co-author.

    That is not the case due to the map shrinking: https://github.com/bitcoin/bitcoin/blob/daa2bcc8e55b4ccc41bec55cbd6a7d6f633e9e6f/src/sync.cpp#L163-L165

  67. hebasto force-pushed on May 18, 2020
  68. hebasto commented at 10:53 AM on May 18, 2020: member

    Updated daa2bcc8e55b4ccc41bec55cbd6a7d6f633e9e6f -> 77b41b79d2e09ff774624a73cda7213abf26c420 (pr18881.09 -> pr18881.11, diff):

    If yes, maybe add ... a co-author.

  69. hebasto force-pushed on May 18, 2020
  70. in src/sync.cpp:198 in 77b41b79d2 outdated 
     192 | @@ -179,15 +193,23 @@ void LeaveCritical()
 193 |  
 194 |  std::string LocksHeld()
 195 |  {
 196 | +    LockData& lockdata = GetLockData();
 197 | +    std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
    MarcoFalke commented at 1:57 PM on May 18, 2020:

    Locking a non-recursive mutex that is already locked is undefined behavior

    hebasto commented at 3:27 PM on May 18, 2020:

    Fixed.

  71. MarcoFalke approved
  72. MarcoFalke commented at 1:57 PM on May 18, 2020: member

    Tested ACK 77b41b79d2e09ff774624a73cda7213abf26c420, beside newly introduced UB 🏞

    <details><summary>Show signature and timestamp</summary>

    Signature:

    -----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

Tested ACK 77b41b79d2e09ff774624a73cda7213abf26c420, beside newly introduced UB 🏞
-----BEGIN PGP SIGNATURE-----

iQGzBAEBCgAdFiEE+rVPoUahrI9sLGYTzit1aX5ppUgFAlwqrYAACgkQzit1aX5p
pUgdEQv9FPHYulbA/8DmnWuyrbLw3yJKdfzAe2KP8HlCPqO72ALPWkueZye0ePXs
slutkyOVRR/xUeQFzDDtxvlhhyNzX3hE2lnGXtlphK9UT117J/XtvDFYcNEcyVag
SfMJGI83O6AXl6pWh6tLs8iex7LgsRMgW4D7k4BbYrn6j5+p3DSw4JsZOMa8Dow+
CSa69TecquL+VXxcLTvw7TPkJAEp8LwqLyPpbxXrWW/CVfasvhAkaN6DgznH/F2U
tgoo5gQeHrdQaaPvDRRg5w9681MPXD9dknbhnO7spdMNyU9A226pYHd9yXlXX7ci
Gd2N+STZPN1wEw9yq8zfKy1yKWBmeIsDXBoihbOyCNw2cGC22K5QV9S5U80htz2O
cSbE7tJlg4KGtHydh30PCBb+vJ0OiLvjCnienfn9aFpsLq+h1DUH6xA4o4DevrzJ
snvrDo3Szwmn63YCfFQpsJejJf+rq3Q5Bz+mRs8OpM1mwepu1raj/2XIWwR5Ps+W
NWCBbF3y
=u6qk
-----END PGP SIGNATURE-----

    Timestamp of file with hash 5480a24c35f54d72074b6b4f29e9e36383f47a92ab417d18a34b223ba64f996f -

    </details>

  73. hebasto force-pushed on May 18, 2020
  74. hebasto force-pushed on May 18, 2020
  75. hebasto force-pushed on May 18, 2020
  76. hebasto commented at 3:35 PM on May 18, 2020: member

    Updated 77b41b79d2e09ff774624a73cda7213abf26c420 -> 068264fcbb8af47f0df676cd088154d7956819d2 (pr18881.11 -> pr18881.13, diff):

    Locking a non-recursive mutex that is already locked is undefined behavior

  77. Prevent UB in DeleteLock() function 458992b06d
  78. refactor: Add LockStackItem type alias 8d8921abd3
  79. refactor: Add LockPair type alias f511f61dda
  80. refactor: Refactor duplicated code into LockHeld() 58e6881bc5
  81. Replace thread_local g_lockstack with a mutex-protected map
    This change prevents UB in case of early g_lockstack destroying.

Co-authored-by: Wladimir J. van der Laan <laanwj@protonmail.com>
    26c093a995
  82. hebasto force-pushed on May 18, 2020
  83. hebasto commented at 10:41 PM on May 18, 2020: member

    Updated 068264fcbb8af47f0df676cd088154d7956819d2 -> 26c093a9957756f3743c2347fe0abd90f81159c4 (pr18881.13 -> pr18881.14, diff):

    • dropped technically incorrect mention of "trivial destructors"
    • replaced the raw pointer to the instance of LockData with a reference as we are not going to apply delete operator to that pointer
  84. MarcoFalke commented at 10:48 PM on May 18, 2020: member

    What do you mean with "technically incorrect"? https://en.cppreference.com/w/cpp/language/destructor#Trivial_destructor

  85. hebasto commented at 11:11 PM on May 18, 2020: member

    What do you mean with "technically incorrect"? https://en.cppreference.com/w/cpp/language/destructor#Trivial_destructor

    1. ibid:

    A trivial destructor is a destructor that performs no action. Objects with trivial destructors don't require a delete-expression and may be disposed of by simply deallocating their storage.

    1. having a trivial destructor is important for the destroying order. As we are not going to destroy LockData instance, this requirement is not relevant

    2. with the latest push the static function-local lock_data variable is a reference and is not an object

    More details: https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables

  86. MarcoFalke commented at 1:00 AM on May 19, 2020: member

    As we are not going to destroy LockData instance, this requirement is not relevant

    Why not? Assuming ~LockData had side effects, then not calling the destructor is going to miss those side effects.

  87. DrahtBot commented at 1:27 AM on May 19, 2020: member

    <!--e57a25ab6845829454e8d69fc972939a-->

    The following sections might be updated with supplementary metadata relevant to reviewers and maintainers.

    <!--174a7506f384e20aa4161008e828411d-->

    Conflicts

    Reviewers, this pull request conflicts with the following ones:

    • #18635 (Replace -Wthread-safety-analysis with broader -Wthread-safety by hebasto)

    If you consider this pull request important, please also help to review the conflicting pull requests. Ideally, start with the one that should be merged first.

  88. MarcoFalke commented at 12:25 PM on May 19, 2020: member

    And if this was somehow "incorrect" then LogInstance should also be adjusted to be consistent

  89. hebasto commented at 5:35 AM on May 20, 2020: member

    I'll try to elaborate my opinion :)

    https://github.com/bitcoin/bitcoin/blob/068264fcbb8af47f0df676cd088154d7956819d2/src/sync.cpp#L98 @MarcoFalke

    What do you mean with "technically incorrect"? https://en.cppreference.com/w/cpp/language/destructor#Trivial_destructor

    1. I mean that among LockData type and its subtypes only using LockPair = std::pair<void*, void*>; and std::mutex have trivial desctructors. This could be easily verified with the std::is_trivially_destructible type trait.

    An implicitly-defined destructor, i.e., generated by the compiler, is not the same as a trivial one.

    1. Agree that if we are going do not destruct a heap-allocated object until the program termination, it is pointless to provide a user-defined destructor with any side effects. If this statement is required to be added to the code as a comment, that comment should refer to "not having an explicit desctructor" or "having a implicit desctructor", but not to "a trivial desctructor".

    And if this was somehow "incorrect" then LogInstance should also be adjusted to be consistent

    The only difference is that the function-local static g_logger is a raw pointer that, in theory, should be deleted.

    In this PR the function-local static lock_data is a reference, and this approach explicitly shows our intention do not delete the heap-allocated object at all.

    If the above arguments are convincing for our community, I agree that making g_logger a reference is good for consistency.

  90. MarcoFalke commented at 11:38 AM on May 22, 2020: member

    If this statement is required to be added to the code as a comment, that comment should refer to "not having an explicit desctructor" or "having a implicit desctructor", but not to "a trivial desctructor".

    The statement has been added to the logger, so I don't see why it shouldn't be added here.

    reference, and this approach explicitly shows our intention do not delete the heap-allocated object at all.

    I wasn't aware that this style is used to indicate that delete will not be applied, but fine with me. Functionally * and & are identical.

    #include <iostream>

struct A {
  A() { std::cout << __func__ << std::endl; }
  ~A() { std::cout << __func__ << std::endl; }
};

int main() {
  std::cout << "start " << __func__ << std::endl;
  static A a;
  static A *b = new A();
  static A &c = *new A();
  std::cout << "end   " << __func__ << std::endl;
}

    start main
A
A
A
end   main
~A
  91. MarcoFalke commented at 11:50 AM on May 22, 2020: member

    re-ACK 26c093a9957756f3743c2347fe0abd90f81159c4 only change since last review is removing undefined behaviour 🚗

    <details><summary>Show signature and timestamp</summary>

    Signature:

    -----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

re-ACK 26c093a9957756f3743c2347fe0abd90f81159c4 only change since last review is removing undefined behaviour 🚗
-----BEGIN PGP SIGNATURE-----

iQGzBAEBCgAdFiEE+rVPoUahrI9sLGYTzit1aX5ppUgFAlwqrYAACgkQzit1aX5p
pUifmwwAs+llsO+ADQ05xZMwCoY0YQ5Zi4w65QVdoRIq9rrajfvDOSyJT09/p2d/
SiJN1SbB1PWFpxW0xPpT9CfAs1AhSnMGtEtm7xsllv5m/X+lsDPHqgsbN0DcfUeE
Q3CnDFklxI7JUOJkcHusmRB9ETxWRJPQ0Hx79OGImUbubdB32rLdsSqfw4oraFzn
bUY1TV76e+IB37zbYiCwiTr1EUOBu1DUV7FBr6AycYRrKMWXO2lPAGqlrOD+Orwo
fyWA2RAcVUbItktWDfy2D9zB8m2DT/HUYr/3DY7P7J6SotirPYQAbaHQO51K4NAo
PAAss/uwkX1zpXhP3hxgLBtKvixOTvZANHf6ch1dSvRrz3XyY0xCT0Z4XuL7dCJk
aGE6AcLzer5h46dfM2Bu3exFSRSaSvqLYks0Jv+b50m9U25+2W7XvJ4IhPovPlpY
/DiOQwMX1DteOd4h9PHSFl6BTLr8eDzPnNDpTue4EzQxXV7BtG++d3nyI1Uhp8OX
VVDT2gg9
=UHOn
-----END PGP SIGNATURE-----

    Timestamp of file with hash 27744a6864db90d25a36be70b128da2a91330c24db6afd49a7dd4c0d2c53111c -

    </details>

  92. hebasto commented at 12:03 PM on May 22, 2020: member

    @MarcoFalke

    If this statement is required to be added to the code as a comment, that comment should refer to "not having an explicit desctructor" or "having a implicit desctructor", but not to "a trivial desctructor".

    The statement has been added to the logger, so I don't see why it shouldn't be added here.

    https://github.com/bitcoin/bitcoin/blob/b5c423c48e094bd098e11c3d1f57acae7502a4da/src/logging.cpp#L25-L26

    That is not the case in so far as the Logger class has no trivial destructor. One could check this with a patch:

    --- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -8,6 +8,8 @@
 #include <util/time.h>
 
 #include <mutex>
+#include <type_traits>
+static_assert(std::is_trivially_destructible<BCLog::Logger>::value, "Logger has no trivial ctor.");
 
 const char * const DEFAULT_DEBUGLOGFILE = "debug.log";

    and compile with an error:

    logging.cpp:12:1: error: static assertion failed: Logger has no trivial ctor.
  93. in src/sync.cpp:88 in 458992b06d outdated 
      93 | +
  94 |  LockData& GetLockData() {
  95 | -    static LockData lockdata;
  96 | -    return lockdata;
  97 | +    // This approach guarantees that the object is not destroyed until after its last use.
  98 | +    // The operating system automatically reclaims all the memory in a program's heap when that program exits.
    MarcoFalke commented at 12:09 PM on May 22, 2020: 
        // The operating system automatically reclaims all the memory in a program's heap when that program exits.
    // Since the destructor is never called, the object and all its members must have an implicit destructor.
    hebasto commented at 12:49 PM on May 22, 2020:

    Updated.

  94. doc: Add and fix comments about never destroyed objects 90eb027204
  95. hebasto commented at 12:49 PM on May 22, 2020: member

    Updated 26c093a9957756f3743c2347fe0abd90f81159c4 -> 90eb027204f5a9d7c00fa97d4112243bd37a9012 (pr18881.14 -> pr18881.15, diff):

  96. MarcoFalke commented at 1:41 PM on May 22, 2020: member

    re-ACK 90eb027204, only change is new doc commit 👠

    <details><summary>Show signature and timestamp</summary>

    Signature:

    -----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

re-ACK 90eb027204, only change is new doc commit 👠
-----BEGIN PGP SIGNATURE-----

iQGzBAEBCgAdFiEE+rVPoUahrI9sLGYTzit1aX5ppUgFAlwqrYAACgkQzit1aX5p
pUjBJQv8D4l/8DutA799ti+iOrxhVDJh48fWd71nn2WKqcyVFJ9Y6G18v2ASlNOz
SrVnXhIUv/8jWgT5kOlqNw+UBMSLxNvv5NvYkchjQNYvHe5UfMrS8kWSqC6BYubc
UuPt+g6wV/Y+I9umkuH46Pk26iwqmVTJh86WbA1syjclNTCm1PEfs6tEbxB5bn7+
fBJQBQaV4J886hy1tRGK1FDNGQ93pNg88fgHdyoVMFsA4kP6utK/E93WshfV238i
Q9d3jiZSVzX5rZSId3Z3cYJMhGcXqC76ZT8tl+v3IX7ErS4Rf+AFyp813L/eWpDD
mHkImUprvIUtNkkZkjBPfAFeKWWG0gsLcfGU4/e+TAZ7R4vIm4v6fVmcunY5WEbE
64Qm5nq7LYOeOXi8XvvHug2l3zS67ZoTeEtGJhEiF0+rcqTgsv/bACr8FksBheu9
SZxUADkbahNnUv+22sEd+Nj2k50dGJOev/H50od1/gvt0E8vydUSz/P+g9NfXJyo
uiKec1Pw
=oyNZ
-----END PGP SIGNATURE-----

    Timestamp of file with hash 5124182a0b09070ce2424a477f0c8ebc1bc2c756ae24de2a66e6948ffd673c33 -

    </details>

  97. MarcoFalke commented at 1:42 PM on May 22, 2020: member

    Would be nice to get this merged soon, so that I don't have to pull in this branch every time for fuzzing.

  98. ryanofsky approved
  99. ryanofsky commented at 4:33 PM on May 22, 2020: member

    Concept ACK +0.5. The DeleteLock fix makes sense and I really like the code cleanups, but I don't understand the thread_local change.

    Code review ACK 90eb027204f5a9d7c00fa97d4112243bd37a9012 because all the changes look correct and safe. But I don't know the purpose of commit 26c093a9957756f3743c2347fe0abd90f81159c4 "Replace thread_local g_lockstack with a mutex-protected map (5/6)." It seems like it could have a bad impact on debug performance, and the commit message and PR description don't give a reason for the change.

    re: PR Description #18881#issue-413323554

    This PR:

    • fixes #18824
    • ~adds Construct On First Use idiom documentation~

    Related to #15233.

    Would suggest updating the PR description to:

    • Summarize what the UB behavior is so it isn't necessary to read a different github issue
    • Give a rationale for replacing the thread_local in the last commit
    • Drop the construct idiom text if it's no longer relevant
    • Link to #18824 and #15233 at the bottom, and clarify if only the first commit is needed to fix bug #18824, or if the thread_local commit is needed too
  100. MarcoFalke commented at 4:51 PM on May 22, 2020: member

    Several cases of UB are fixed here.

    • The first commit fixes the one described in #18824
    • The 26c093a commit fixes one described in #18881#pullrequestreview-410137892
  101. ryanofsky commented at 5:05 PM on May 22, 2020: member

    Several cases of UB are fixed here.

    Thanks, I definitely think the PR description needs to be improved here and summarize what it is changing and give a clue about how the thread_local change fixes the second problem. If we don't know why the thread local change fixes it, the PR description should say that and not try to be mysterious

  102. hebasto commented at 5:05 PM on May 22, 2020: member

    @ryanofsky

    Would suggest updating the PR description to:

    • Summarize what the UB behavior is so it isn't necessary to read a different github issue

    • Give a rationale for replacing the thread_local in the last commit

    • Drop the construct idiom text if it's no longer relevant

    • Link to #18824 and #15233 at the bottom, and clarify if only the first commit is needed to fix bug #18824, or if the thread_local commit is needed too

    Thank you for review. The PR description has been updated. Sometimes it seems the C++ is much easier to express ideas than English :)

  103. ryanofsky commented at 5:16 PM on May 22, 2020: member

    re-ACK. Thanks for updating the PR description, this looks good to me. I'm pretty sure there should be a more efficient way to stop referencing the thread_local after it is destroyed (perhaps just resetting the reference in the thread_local destructor) without replacing the thread_local with a map with frequently added & removed entries. But this only affects debugging and probably isn't a big deal.

  104. MarcoFalke commented at 6:04 PM on May 22, 2020: member

    I am planning to merge this next week unless there are objections or outstanding action items

  105. ryanofsky commented at 6:40 PM on May 22, 2020: member

    I am planning to merge this next week unless there are objections or outstanding action items

    :+1: and seems fine to merge earlier, too. None of this code is even compiled unless debugging is turned on.

  106. MarcoFalke merged this on May 26, 2020
  107. MarcoFalke closed this on May 26, 2020
  108. hebasto deleted the branch on May 26, 2020
  109. sidhujag referenced this in commit c8b5293c9b on May 27, 2020
  110. jasonbcox referenced this in commit 8b4530e454 on Sep 22, 2020
  111. kittywhiskers referenced this in commit 6bf96e2660 on Oct 8, 2021
  112. kittywhiskers referenced this in commit ec2753a8ba on Oct 12, 2021
  113. PastaPastaPasta referenced this in commit 08418c582a on Oct 12, 2021
  114. pravblockc referenced this in commit 6b43103f1a on Nov 18, 2021
  115. DrahtBot locked this on Feb 15, 2022
Contributors
hebastoMarcoFalkejonatacksipapromaglaanwjDrahtBotryanofsky
Labels
Refactoring
Linked (view graph)
#18824 Possible UB in DeleteLock() function
github-metadata-mirror

This is a metadata mirror of the GitHub repository bitcoin/bitcoin. This site is not affiliated with GitHub. Content is generated from a GitHub metadata backup.
generated: 2026-05-02 15:14 UTC
This site is hosted by @0xB10C
More mirrored repositories can be found on mirror.b10c.me