blob: a52facc49c89a64b154e38d529cc754d59b39b06 [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/threading/thread_restrictions.h"
#include "base/check.h"
#include "base/threading/hang_watcher.h"
#include "base/trace_event/base_tracing.h"
#include "build/build_config.h"
namespace base {
BooleanWithOptionalStack::BooleanWithOptionalStack(bool value) : value_(value) {
#if CAPTURE_THREAD_RESTRICTIONS_STACK_TRACES()
stack_.emplace();
#endif // CAPTURE_THREAD_RESTRICTIONS_STACK_TRACES()
}
std::ostream& operator<<(std::ostream& out,
const BooleanWithOptionalStack& bws) {
out << bws.value_;
#if CAPTURE_THREAD_RESTRICTIONS_STACK_TRACES()
if (bws.stack_.has_value()) {
out << " set by\n" << bws.stack_.value();
} else {
out << " (value by default)";
}
#endif // CAPTURE_THREAD_RESTRICTIONS_STACK_TRACES()
return out;
}
// A macro that dumps in official builds (non-fatal) if the condition is false,
// or behaves as DCHECK in DCHECK-enabled builds. Unlike DUMP_WILL_BE_CHECK,
// there is no intent to transform those into CHECKs. Used to report potential
// performance issues.
//
// TODO(crbug.com/363049758): This is temporarily a `DCHECK` to avoid getting a
// lot of crash reports while known issues are being addressed. Change to
// `DUMP_WILL_BE_CHECK` once known issues are addressed.
#define DUMP_OR_DCHECK DCHECK
namespace {
constinit thread_local BooleanWithOptionalStack tls_blocking_disallowed;
constinit thread_local BooleanWithOptionalStack tls_singleton_disallowed;
constinit thread_local BooleanWithOptionalStack
tls_base_sync_primitives_disallowed;
constinit thread_local BooleanWithOptionalStack
tls_cpu_intensive_work_disallowed;
} // namespace
void AssertBlockingAllowed() {
DUMP_OR_DCHECK(!tls_blocking_disallowed)
<< "Function marked as blocking was called from a scope that disallows "
"blocking! If this task is running inside the ThreadPool, it needs "
"to have MayBlock() in its TaskTraits. Otherwise, consider making "
"this blocking work asynchronous or, as a last resort, you may use "
"ScopedAllowBlocking (see its documentation for best practices).\n"
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
}
void AssertBlockingDisallowedForTesting() {
DCHECK(tls_blocking_disallowed)
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
}
void DisallowBlocking() {
tls_blocking_disallowed = BooleanWithOptionalStack(true);
}
ScopedDisallowBlocking::ScopedDisallowBlocking()
: resetter_(&tls_blocking_disallowed, BooleanWithOptionalStack(true)) {}
ScopedDisallowBlocking::~ScopedDisallowBlocking() {
DCHECK(tls_blocking_disallowed)
<< "~ScopedDisallowBlocking() running while surprisingly already no "
"longer disallowed.\n"
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
}
void DisallowBaseSyncPrimitives() {
tls_base_sync_primitives_disallowed = BooleanWithOptionalStack(true);
}
ScopedDisallowBaseSyncPrimitives::ScopedDisallowBaseSyncPrimitives()
: resetter_(&tls_base_sync_primitives_disallowed,
BooleanWithOptionalStack(true)) {}
ScopedDisallowBaseSyncPrimitives::~ScopedDisallowBaseSyncPrimitives() {
DCHECK(tls_base_sync_primitives_disallowed)
<< "~ScopedDisallowBaseSyncPrimitives() running while surprisingly "
"already no longer disallowed.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed;
}
ScopedAllowBaseSyncPrimitives::ScopedAllowBaseSyncPrimitives()
: resetter_(&tls_base_sync_primitives_disallowed,
BooleanWithOptionalStack(false)) {
DCHECK(!tls_blocking_disallowed)
<< "To allow //base sync primitives in a scope where blocking is "
"disallowed use ScopedAllowBaseSyncPrimitivesOutsideBlockingScope.\n"
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
}
ScopedAllowBaseSyncPrimitives::~ScopedAllowBaseSyncPrimitives() {
DCHECK(!tls_base_sync_primitives_disallowed)
<< "~ScopedAllowBaseSyncPrimitives() running while surprisingly already "
"no longer allowed.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed;
}
ScopedAllowBaseSyncPrimitivesForTesting::
ScopedAllowBaseSyncPrimitivesForTesting()
: resetter_(&tls_base_sync_primitives_disallowed,
BooleanWithOptionalStack(false)) {}
ScopedAllowBaseSyncPrimitivesForTesting::
~ScopedAllowBaseSyncPrimitivesForTesting() {
DCHECK(!tls_base_sync_primitives_disallowed)
<< "~ScopedAllowBaseSyncPrimitivesForTesting() running while " // IN-TEST
"surprisingly already no longer allowed.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed;
}
ScopedAllowUnresponsiveTasksForTesting::ScopedAllowUnresponsiveTasksForTesting()
: base_sync_resetter_(&tls_base_sync_primitives_disallowed,
BooleanWithOptionalStack(false)),
blocking_resetter_(&tls_blocking_disallowed,
BooleanWithOptionalStack(false)),
cpu_resetter_(&tls_cpu_intensive_work_disallowed,
BooleanWithOptionalStack(false)) {}
ScopedAllowUnresponsiveTasksForTesting::
~ScopedAllowUnresponsiveTasksForTesting() {
DCHECK(!tls_base_sync_primitives_disallowed)
<< "~ScopedAllowUnresponsiveTasksForTesting() running while " // IN-TEST
"surprisingly already no longer allowed.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed;
DCHECK(!tls_blocking_disallowed)
<< "~ScopedAllowUnresponsiveTasksForTesting() running while " // IN-TEST
"surprisingly already no longer allowed.\n"
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
DCHECK(!tls_cpu_intensive_work_disallowed)
<< "~ScopedAllowUnresponsiveTasksForTesting() running while " // IN-TEST
"surprisingly already no longer allowed.\n"
<< "tls_cpu_intensive_work_disallowed "
<< tls_cpu_intensive_work_disallowed;
}
namespace internal {
void AssertBaseSyncPrimitivesAllowed() {
DUMP_OR_DCHECK(!tls_base_sync_primitives_disallowed)
<< "Waiting on a //base sync primitive is not allowed on this thread to "
"prevent jank and deadlock. If waiting on a //base sync primitive is "
"unavoidable, do it within the scope of a "
"ScopedAllowBaseSyncPrimitives. If in a test, use "
"ScopedAllowBaseSyncPrimitivesForTesting.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed
<< "It can be useful to know that tls_blocking_disallowed is "
<< tls_blocking_disallowed;
}
void ResetThreadRestrictionsForTesting() {
tls_blocking_disallowed = BooleanWithOptionalStack(false);
tls_singleton_disallowed = BooleanWithOptionalStack(false);
tls_base_sync_primitives_disallowed = BooleanWithOptionalStack(false);
tls_cpu_intensive_work_disallowed = BooleanWithOptionalStack(false);
}
void AssertSingletonAllowed() {
DUMP_OR_DCHECK(!tls_singleton_disallowed)
<< "LazyInstance/Singleton is not allowed to be used on this thread. "
"Most likely it's because this thread is not joinable (or the current "
"task is running with TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN "
"semantics), so AtExitManager may have deleted the object on "
"shutdown, leading to a potential shutdown crash. If you need to use "
"the object from this context, it'll have to be updated to use Leaky "
"traits.\n"
<< "tls_singleton_disallowed " << tls_singleton_disallowed;
}
} // namespace internal
void DisallowSingleton() {
tls_singleton_disallowed = BooleanWithOptionalStack(true);
}
ScopedDisallowSingleton::ScopedDisallowSingleton()
: resetter_(&tls_singleton_disallowed, BooleanWithOptionalStack(true)) {}
ScopedDisallowSingleton::~ScopedDisallowSingleton() {
DCHECK(tls_singleton_disallowed)
<< "~ScopedDisallowSingleton() running while surprisingly already no "
"longer disallowed.\n"
<< "tls_singleton_disallowed " << tls_singleton_disallowed;
}
void AssertLongCPUWorkAllowed() {
DUMP_OR_DCHECK(!tls_cpu_intensive_work_disallowed)
<< "Function marked as CPU intensive was called from a scope that "
"disallows this kind of work! Consider making this work "
"asynchronous.\n"
<< "tls_cpu_intensive_work_disallowed "
<< tls_cpu_intensive_work_disallowed;
}
void DisallowUnresponsiveTasks() {
DisallowBlocking();
DisallowBaseSyncPrimitives();
tls_cpu_intensive_work_disallowed = BooleanWithOptionalStack(true);
}
// static
void PermanentThreadAllowance::AllowBlocking() {
tls_blocking_disallowed = BooleanWithOptionalStack(false);
}
// static
void PermanentThreadAllowance::AllowBaseSyncPrimitives() {
tls_base_sync_primitives_disallowed = BooleanWithOptionalStack(false);
}
ScopedAllowBlocking::ScopedAllowBlocking(const Location& from_here)
: resetter_(&tls_blocking_disallowed, BooleanWithOptionalStack(false)) {
TRACE_EVENT_BEGIN(
"base", "ScopedAllowBlocking", [&](perfetto::EventContext ctx) {
ctx.event()->set_source_location_iid(
base::trace_event::InternedSourceLocation::Get(&ctx, from_here));
});
}
ScopedAllowBlocking::~ScopedAllowBlocking() {
TRACE_EVENT_END0("base", "ScopedAllowBlocking");
DCHECK(!tls_blocking_disallowed)
<< "~ScopedAllowBlocking() running while surprisingly already no longer "
"allowed.\n"
<< "tls_blocking_disallowed " << tls_blocking_disallowed;
}
ScopedAllowBaseSyncPrimitivesOutsideBlockingScope::
ScopedAllowBaseSyncPrimitivesOutsideBlockingScope(const Location& from_here)
: resetter_(&tls_base_sync_primitives_disallowed,
BooleanWithOptionalStack(false)) {
TRACE_EVENT_BEGIN(
"base", "ScopedAllowBaseSyncPrimitivesOutsideBlockingScope",
[&](perfetto::EventContext ctx) {
ctx.event()->set_source_location_iid(
base::trace_event::InternedSourceLocation::Get(&ctx, from_here));
});
// Since this object is used to indicate that sync primitives will be used to
// wait for an event ignore the current operation for hang watching purposes
// since the wait time duration is unknown.
base::HangWatcher::InvalidateActiveExpectations();
}
ScopedAllowBaseSyncPrimitivesOutsideBlockingScope::
~ScopedAllowBaseSyncPrimitivesOutsideBlockingScope() {
TRACE_EVENT_END0("base", "ScopedAllowBaseSyncPrimitivesOutsideBlockingScope");
DCHECK(!tls_base_sync_primitives_disallowed)
<< "~ScopedAllowBaseSyncPrimitivesOutsideBlockingScope() running while "
"surprisingly already no longer allowed.\n"
<< "tls_base_sync_primitives_disallowed "
<< tls_base_sync_primitives_disallowed;
}
} // namespace base