1786

Committed 28 Oct 2023 12:35PM UTC coverage: 91.562% (-0.02%) from 91.582%

Build # 1786

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Improve configurations for sanitized builds (#6911)

* Refactor sanitizer flags for different build types:

** Enable address sanitizer for msvc
** Allow to build with sanitizer for diffent optimized build (also Debug)
** Make RelASAN, RelTSAN, RelUSAN, RelUSAN just shortcuts for half-optimized builds

* Fix usage of moved object for fuzz tester
* Check asan/tsan on macos x64/arm64
* Check asan with msvc 2019
* Remove Jenkins sanitized builders replaced by evergreen configs
* Work-around stack-use-after-scope with msvc2019 and mpark
* Fix crash on check with staled ColKeys
* fix a buffer overrun in a test
* fix a race in async_open_realm test util
* Add some logger related test fixes
* Work around catch2 limmitation with not thread safe asserts and TSAN races
* Run multiprocesses tests under sanitizers
* add assert for an error reported by undefined sanitizer
* Workaround uv scheduler main thread only constraint for callbacks called from non main thread and requesting a realm

---------

Co-authored-by: James Stone <james.stone@mongodb.com>

Run Details

94310 of 173648 branches covered (0.0%)

54 of 63 new or added lines in 15 files covered. (85.71%)

2212 existing lines in 52 files now uncovered.

230602 of 251853 relevant lines covered (91.56%)

6943670.77 hits per line

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

0.0

/src/realm/util/terminate.cpp

/*************************************************************************
 *
 * Copyright 2016 Realm Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************/

#include <realm/util/terminate.hpp>

#include <iostream>
#include <sstream>
#include <realm/util/features.h>
#include <realm/util/thread.hpp>
#include <realm/util/backtrace.hpp>
#include <realm/version.hpp>

#if REALM_PLATFORM_APPLE

#include <os/log.h>
#include <asl.h>

#include <dlfcn.h>
#include <execinfo.h>
#include <CoreFoundation/CoreFoundation.h>
#endif

#if REALM_ANDROID
#include <android/log.h>
#endif

// extern "C" and noinline so that a readable message shows up in the stack trace
// of the crash
// prototype here to silence warning
// The macro indirection here puts the core version number in the actual stack trace

// LCOV_EXCL_START
#define REALM_DEFINE_TERMINATE_VERSIONED_(x)                                                                         \
    extern "C" REALM_NORETURN REALM_NOINLINE void please_report_this_issue_in_github_realm_realm_core_v##x();        \
                                                                                                                     \
    extern "C" REALM_NORETURN REALM_NOINLINE void please_report_this_issue_in_github_realm_realm_core_v##x()         \
    {                                                                                                                \
        std::abort();                                                                                                \
    }

#define REALM_DEFINE_TERMINATE_VERSIONED(x) REALM_DEFINE_TERMINATE_VERSIONED_(x)
#define REALM_EVALUATE_(x) _##x
#define REALM_EVALUATE(x) REALM_EVALUATE_(x)
#define REALM_MACRO_CONCAT(A, B) REALM_MACRO_CONCAT_(A, B)
#define REALM_MACRO_CONCAT_(A, B) A##B
#define REALM_VERSION_SUFFIX_CONCAT                                                                                  \
    REALM_MACRO_CONCAT(REALM_EVALUATE(REALM_VERSION_MAJOR),                                                          \
                       REALM_MACRO_CONCAT(REALM_EVALUATE(REALM_VERSION_MINOR), REALM_EVALUATE(REALM_VERSION_PATCH)))

REALM_DEFINE_TERMINATE_VERSIONED(REALM_VERSION_SUFFIX_CONCAT)

#define REALM_TERMINATE_VERSIONED_(x) please_report_this_issue_in_github_realm_realm_core_v##x()
#define REALM_TERMINATE_VERSIONED(x) REALM_TERMINATE_VERSIONED_(x)
#define REALM_TERMINATE_AUTO_VERSIONED() REALM_TERMINATE_VERSIONED(REALM_VERSION_SUFFIX_CONCAT)

// LCOV_EXCL_STOP

namespace {

#if REALM_PLATFORM_APPLE
void nslog(const char* message) noexcept
{
    // Standard error goes nowhere for applications managed by launchd,
    // so log to ASL/unified logging system logs as well.
    fputs(message, stderr);
    if (__builtin_available(iOS 10.0, macOS 10.12, tvOS 10.0, watchOS 3.0, *)) {
        // The unified logging system considers dynamic strings to be private in
        // order to protect users. This means we must specify "%{public}s" to get
        // the message here. See `man os_log` for more details.
        os_log_error(OS_LOG_DEFAULT, "%{public}s", message);
    }
    else {
        REALM_DIAG_PUSH();
        REALM_DIAG(ignored "-Wdeprecated");
        asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", message);
        REALM_DIAG_POP();
    }
    // Log the message to Crashlytics if it's loaded into the process
    void* addr = dlsym(RTLD_DEFAULT, "CLSLog");
    if (addr) {
        CFStringRef str =
            CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, message, kCFStringEncodingUTF8, kCFAllocatorNull);
        auto fn = reinterpret_cast<void (*)(CFStringRef, ...)>(reinterpret_cast<size_t>(addr));
        fn(CFSTR("%@"), str);
        CFRelease(str);
    }
}

void (*termination_notification_callback)(const char*) noexcept = nslog;

#elif REALM_ANDROID

void android_log(const char* message) noexcept
{
    __android_log_write(ANDROID_LOG_ERROR, "REALM", message);
}

void (*termination_notification_callback)(const char*) noexcept = android_log;

#else

void (*termination_notification_callback)(const char*) noexcept = nullptr;

#endif

} // unnamed namespace

namespace realm {
namespace util {

// LCOV_EXCL_START
REALM_NORETURN static void terminate_internal(std::stringstream& ss) noexcept
{
    util::Backtrace::capture().print(ss);

    ss << "\n!!! IMPORTANT: Please report this at https://github.com/realm/realm-core/issues/new/choose";

    if (termination_notification_callback) {
        termination_notification_callback(ss.str().c_str());
    }
    else {
        std::cerr << ss.rdbuf();
        std::string thread_name;
        if (Thread::get_name(thread_name))
            std::cerr << "\nThread name: " << thread_name;
    }

    REALM_TERMINATE_AUTO_VERSIONED();
}

REALM_NORETURN void terminate(const char* message, const char* file, long line,
                              std::initializer_list<Printable>&& values) noexcept
{
    terminate_with_info(message, file, line, nullptr, std::move(values));
}

REALM_NORETURN void terminate_with_info(const char* message, const char* file, long line,
                                        const char* interesting_names,
                                        std::initializer_list<Printable>&& values) noexcept
{
    std::stringstream ss;
    ss << file << ':' << line << ": " REALM_VER_CHUNK " " << message;
    if (interesting_names)
        ss << " with " << interesting_names << " = ";
    Printable::print_all(ss, values, bool(interesting_names));
    ss << '\n';
    terminate_internal(ss);
}
// LCOV_EXCL_STOP

} // namespace util
} // namespace realm

1	/*************************************************************************
2	*
3	* Copyright 2016 Realm Inc.
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	**************************************************************************/
18
19	#include <realm/util/terminate.hpp>
20
21	#include <iostream>
22	#include <sstream>
23	#include <realm/util/features.h>
24	#include <realm/util/thread.hpp>
25	#include <realm/util/backtrace.hpp>
26	#include <realm/version.hpp>
27
28	#if REALM_PLATFORM_APPLE
29
30	#include <os/log.h>
31	#include <asl.h>
32
33	#include <dlfcn.h>
34	#include <execinfo.h>
35	#include <CoreFoundation/CoreFoundation.h>
36	#endif
37
38	#if REALM_ANDROID
39	#include <android/log.h>
40	#endif
41
42	// extern "C" and noinline so that a readable message shows up in the stack trace
43	// of the crash
44	// prototype here to silence warning
45	// The macro indirection here puts the core version number in the actual stack trace
46
47	// LCOV_EXCL_START
48	#define REALM_DEFINE_TERMINATE_VERSIONED_(x) \
49	extern "C" REALM_NORETURN REALM_NOINLINE void please_report_this_issue_in_github_realm_realm_core_v##x(); \
50	\
51	extern "C" REALM_NORETURN REALM_NOINLINE void please_report_this_issue_in_github_realm_realm_core_v##x() \
52	{ \	×
53	std::abort(); \	×
UNCOV 54	}	×
55
56	#define REALM_DEFINE_TERMINATE_VERSIONED(x) REALM_DEFINE_TERMINATE_VERSIONED_(x)
57	#define REALM_EVALUATE_(x) _##x
58	#define REALM_EVALUATE(x) REALM_EVALUATE_(x)
59	#define REALM_MACRO_CONCAT(A, B) REALM_MACRO_CONCAT_(A, B)
60	#define REALM_MACRO_CONCAT_(A, B) A##B
61	#define REALM_VERSION_SUFFIX_CONCAT \
62	REALM_MACRO_CONCAT(REALM_EVALUATE(REALM_VERSION_MAJOR), \
63	REALM_MACRO_CONCAT(REALM_EVALUATE(REALM_VERSION_MINOR), REALM_EVALUATE(REALM_VERSION_PATCH)))
64
65	REALM_DEFINE_TERMINATE_VERSIONED(REALM_VERSION_SUFFIX_CONCAT)
66
67	#define REALM_TERMINATE_VERSIONED_(x) please_report_this_issue_in_github_realm_realm_core_v##x()	×
68	#define REALM_TERMINATE_VERSIONED(x) REALM_TERMINATE_VERSIONED_(x)	×
UNCOV 69	#define REALM_TERMINATE_AUTO_VERSIONED() REALM_TERMINATE_VERSIONED(REALM_VERSION_SUFFIX_CONCAT)	×
70
71	// LCOV_EXCL_STOP
72
73	namespace {
74
75	#if REALM_PLATFORM_APPLE
76	void nslog(const char* message) noexcept
77	{
78	// Standard error goes nowhere for applications managed by launchd,
79	// so log to ASL/unified logging system logs as well.
80	fputs(message, stderr);
81	if (__builtin_available(iOS 10.0, macOS 10.12, tvOS 10.0, watchOS 3.0, *)) {	×
82	// The unified logging system considers dynamic strings to be private in
83	// order to protect users. This means we must specify "%{public}s" to get
84	// the message here. See `man os_log` for more details.
85	os_log_error(OS_LOG_DEFAULT, "%{public}s", message);
86	}
87	else {
88	REALM_DIAG_PUSH();
89	REALM_DIAG(ignored "-Wdeprecated");
90	asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", message);
91	REALM_DIAG_POP();
92	}
93	// Log the message to Crashlytics if it's loaded into the process
94	void* addr = dlsym(RTLD_DEFAULT, "CLSLog");
95	if (addr) {	×
96	CFStringRef str =
97	CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, message, kCFStringEncodingUTF8, kCFAllocatorNull);
98	auto fn = reinterpret_cast<void (*)(CFStringRef, ...)>(reinterpret_cast<size_t>(addr));
99	fn(CFSTR("%@"), str);
100	CFRelease(str);
101	}
102	}
103
104	void (termination_notification_callback)(const char) noexcept = nslog;
105
106	#elif REALM_ANDROID
107
108	void android_log(const char* message) noexcept
109	{
110	__android_log_write(ANDROID_LOG_ERROR, "REALM", message);
111	}
112
113	void (termination_notification_callback)(const char) noexcept = android_log;
114
115	#else
116
117	void (termination_notification_callback)(const char) noexcept = nullptr;
118
119	#endif
120
121	} // unnamed namespace
122
123	namespace realm {
124	namespace util {
125
126	// LCOV_EXCL_START
127	REALM_NORETURN static void terminate_internal(std::stringstream& ss) noexcept
128	{	×
129	util::Backtrace::capture().print(ss);	×
130
131	ss << "\n!!! IMPORTANT: Please report this at https://github.com/realm/realm-core/issues/new/choose";	×
132
133	if (termination_notification_callback) {	×
134	termination_notification_callback(ss.str().c_str());	×
UNCOV 135	}	×
136	else {	×
137	std::cerr << ss.rdbuf();	×
UNCOV 138	std::string thread_name;	×
UNCOV 139	if (Thread::get_name(thread_name))	×
UNCOV 140	std::cerr << "\nThread name: " << thread_name;	×
141	}	×
142
143	REALM_TERMINATE_AUTO_VERSIONED();	×
UNCOV 144	}	×
145
146	REALM_NORETURN void terminate(const char* message, const char* file, long line,
147	std::initializer_list<Printable>&& values) noexcept
148	{	×
UNCOV 149	terminate_with_info(message, file, line, nullptr, std::move(values));	×
UNCOV 150	}	×
151
152	REALM_NORETURN void terminate_with_info(const char* message, const char* file, long line,
153	const char* interesting_names,
154	std::initializer_list<Printable>&& values) noexcept
155	{	×
156	std::stringstream ss;	×
157	ss << file << ':' << line << ": " REALM_VER_CHUNK " " << message;	×
158	if (interesting_names)	×
159	ss << " with " << interesting_names << " = ";	×
160	Printable::print_all(ss, values, bool(interesting_names));	×
161	ss << '\n';	×
UNCOV 162	terminate_internal(ss);	×
UNCOV 163	}	×
164	// LCOV_EXCL_STOP
165
166	} // namespace util
167	} // namespace realm

realm / realm-core / 1786

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