24050268850

Committed 06 Apr 2026 08:41PM UTC coverage: 91.441%. Remained the same

Build # 24050268850

Build Type

push

github

Committed by

igor-krechetov

Commit Message

[1.0.4][r] fix potential multithreading issues

Fix
- Fixed potential race-conditions in dispatchers
- Replaced copy with move operations in hsm

Coverage Stats

22 of 39 new or added lines in 7 files covered. (56.41%)

16 existing lines in 4 files now uncovered.

2329 of 2547 relevant lines covered (91.44%)

1622.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.91

/src/os/common/UniqueLock.cpp

// Copyright (C) 2022 Igor Krechetov
// Distributed under MIT license. See file LICENSE for details
#include "hsmcpp/os/common/UniqueLock.hpp"

#include "hsmcpp/os/Mutex.hpp"

namespace hsmcpp {

UniqueLock::UniqueLock(Mutex& sync)
    // NOTE: false-positive. thinks that ':' is arithmetic operation
    // cppcheck-suppress misra-c2012-10.4
    : mSync(&sync) {
    lock();
}

UniqueLock::~UniqueLock() {
    unlock();
}

UniqueLock::UniqueLock(UniqueLock&& src) noexcept
    : mSync(src.mSync) {
    if (true == src.mOwnsLock.test_and_set(std::memory_order_acquire)) {
        mOwnsLock.test_and_set(std::memory_order_release);
    } else {
        mOwnsLock.clear(std::memory_order_release);
    }

    src.mSync = nullptr;
    src.mOwnsLock.clear(std::memory_order_release);
}

UniqueLock& UniqueLock::operator=(UniqueLock&& src) noexcept {
    if (this != &src) {
        if (nullptr != mSync) {
            if (true == mOwnsLock.test_and_set(std::memory_order_acquire)) {
                mSync->unlock();
            } else {
                mOwnsLock.clear(std::memory_order_release);
            }
        }

        mSync = src.mSync;

        if (true == src.mOwnsLock.test_and_set(std::memory_order_acquire)) {
            mOwnsLock.test_and_set(std::memory_order_release);
        } else {
            mOwnsLock.clear(std::memory_order_release);
        }

        src.mSync = nullptr;
        src.mOwnsLock.clear(std::memory_order_release);
    }

    return *this;
}

void UniqueLock::lock() {
    if ((nullptr != mSync) && (false == mOwnsLock.test_and_set(std::memory_order_acq_rel))) {
        mSync->lock();
    }
}

void UniqueLock::unlock() {
    if (nullptr != mSync) {
        if (true == mOwnsLock.test_and_set(std::memory_order_acquire)) {
            mSync->unlock();
            mOwnsLock.clear(std::memory_order_release);
        } else {
            mOwnsLock.clear(std::memory_order_release);
        }
    }
}

Mutex* UniqueLock::release() noexcept {
    Mutex* res = mSync;

    mSync = nullptr;
    mOwnsLock.clear(std::memory_order_release);

    return res;
}

}  // namespace hsmcpp

1	// Copyright (C) 2022 Igor Krechetov
2	// Distributed under MIT license. See file LICENSE for details
3	#include "hsmcpp/os/common/UniqueLock.hpp"
4
5	#include "hsmcpp/os/Mutex.hpp"
6
7	namespace hsmcpp {
8
9	UniqueLock::UniqueLock(Mutex& sync)	7,786✔
10	// NOTE: false-positive. thinks that ':' is arithmetic operation
11	// cppcheck-suppress misra-c2012-10.4
12	: mSync(&sync) {	7,786✔
13	lock();	7,786✔
14	}	7,786✔
15
16	UniqueLock::~UniqueLock() {	7,786✔
17	unlock();	7,786✔
18	}	7,786✔
19
20	UniqueLock::UniqueLock(UniqueLock&& src) noexcept	×
NEW 21	: mSync(src.mSync) {	×
NEW 22	if (true == src.mOwnsLock.test_and_set(std::memory_order_acquire)) {	×
NEW 23	mOwnsLock.test_and_set(std::memory_order_release);	×
24	} else {
NEW 25	mOwnsLock.clear(std::memory_order_release);	×
26	}
27
UNCOV 28	src.mSync = nullptr;	×
NEW 29	src.mOwnsLock.clear(std::memory_order_release);	×
30	}	×
31
UNCOV 32	UniqueLock& UniqueLock::operator=(UniqueLock&& src) noexcept {	×
NEW 33	if (this != &src) {	×
NEW 34	if (nullptr != mSync) {	×
NEW 35	if (true == mOwnsLock.test_and_set(std::memory_order_acquire)) {	×
NEW 36	mSync->unlock();	×
37	} else {
NEW 38	mOwnsLock.clear(std::memory_order_release);	×
39	}
40	}
41
NEW 42	mSync = src.mSync;	×
43
NEW 44	if (true == src.mOwnsLock.test_and_set(std::memory_order_acquire)) {	×
NEW 45	mOwnsLock.test_and_set(std::memory_order_release);	×
46	} else {
NEW 47	mOwnsLock.clear(std::memory_order_release);	×
48	}
49
NEW 50	src.mSync = nullptr;	×
NEW 51	src.mOwnsLock.clear(std::memory_order_release);	×
52	}
53
54	return *this;	×
55	}
56
57	void UniqueLock::lock() {	7,786✔
58	if ((nullptr != mSync) && (false == mOwnsLock.test_and_set(std::memory_order_acq_rel))) {	7,786✔
59	mSync->lock();	7,786✔
60	}
61	}	7,786✔
62
63	void UniqueLock::unlock() {	11,617✔
64	if (nullptr != mSync) {	11,617✔
65	if (true == mOwnsLock.test_and_set(std::memory_order_acquire)) {	11,617✔
66	mSync->unlock();	7,786✔
67	mOwnsLock.clear(std::memory_order_release);	7,786✔
68	} else {
69	mOwnsLock.clear(std::memory_order_release);	3,831✔
70	}
71	}
72	}	11,617✔
73
UNCOV 74	Mutex* UniqueLock::release() noexcept {	×
UNCOV 75	Mutex* res = mSync;	×
76
UNCOV 77	mSync = nullptr;	×
NEW 78	mOwnsLock.clear(std::memory_order_release);	×
79
UNCOV 80	return res;	×
81	}
82
83	} // namespace hsmcpp

igor-krechetov / hsmcpp / 24050268850

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous