[clang-tidy] Add a check for blocking types and functions.

[segoon]

Summary

The check searches for:

• C++ synchronization primitives
• C11 synchronization primitives
• POSIX synchronization primitives
• some POSIX blocking functions
• some blocking Linux syscalls
• some Boost.Thread synchronization primitives

The preemptive functions/types can be separated into the following categories:

• explicit sleep(3)-like functions
• sleeping/waiting synchronization primitives

There are AST matchers for both sync primitives creation and blocking methods calls - we want
the former for user-created mutexes and the latter for mutex usage passed from outside (e.g. via
library global variable or a function parameter).

A simplified version of the check is used in Yandex.Taxi for coroutine code.

The check doesn't include the following:

• Io and filesystem operations. It will be included in a separate checker concurrency-async-fs as a user might have a different policy (e.g. no FS thread pool, so nothing can be improved).
• Creation of new threads. Same here, will be implemented in concurrency-async-no-new-threads, it is OK for some projects and must be changed to async code in others.
• Check for atomic::is_always_lock_free - will be implemented in future patches.

[segoon]

up

[segoon]

fix the mess

[njames93]

Few stylistic nits, Also Theres lots of cases where single stmt if statements have braces, typically we elide those braces.
Is it worth flagging methods with Thread safety analysis attributes.
These are only used in clang, but if a project annotates their methods with these, it would be nice to autodetect these attributes, though I can see this being a big job and likely better for a follow up.

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.cpp

17–22

These go against llvm naming convention of Variables being CamelCase.
Also don't use auto when the type is spelled in the initialization.

24

clang::StringRef is a code smell imo, use llvm::StringRef or move this code into the clang namespace and drop the qualifier.

25

This could take an ArrayRef instead of const vector ref.

34

This and all examples below don't belong on the heap, Just use an array.

36

Is it wise to fully qualify these?
::std::mutex

Also whats with the comments at the end of each line, they don't seem to add anything.

223

No need to case to StringRef, its implicit.

293–294

300–301

303–305

Diagnostics support "%0" style formatting.
That formatting handles NamedDecls.
Stmt has a SourceRange that does the same job as (getBeginLoc(), getEndLoc()]
This can be applied in other places.

309–310

321

From the code, Lockfree can't be null if Atomic binds, maybe make this an assert

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-blocking.cpp

451

Whats this for?

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.cpp

2

Please make length same as end of comment.

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.h

28

Please remove empty line between methods. See other checks as example. Same below.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-blocking.rst

7

Please distribute words more evenly up to 80 characters.

14

See other documentation for example of lists. Same below.

29

Will be good idea to highlight BasicLockable and other with single back-ticks.

31

Please use double beck-ticks for language constructs. Same below.

69

Please highlight std::atomic with double back-ticks.

70

Please highlight std::mutex with double back-ticks.

75

Please use double beck-ticks for language constructs. Same below.

[segoon]

review fixes

[segoon]

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.cpp

36

the comments signal clang-format not to join multiple items into a single line

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-blocking.cpp

451

WIP tests for not yet ready atomic::is_always_lock_free check

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-blocking.rst

8

Please fix double space.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.cpp

320

Please don't use auto when type is not explicitly spelled in same statement or iterator.

[segoon]

• review fixes
• drop of atomic::is_always_lock_free check

[segoon]

friendly ping, any comments on the patch?

[segoon]

Eugene.Zelenko, njames93, any comments on the patch?

[Eugene.Zelenko]

In D93940#2509325, @segoon wrote:

Eugene.Zelenko, njames93, any comments on the patch?

Sorry, you need to wait for approval from one of maintainer mentioned as reviewers. I check only documentation and for minor code issues.

[segoon]

alexfh, hi! any comments on the patch?

[segoon]

• explicitly state in docs that the check must be used only for async code

[segoon]

alexfh, aaron.ballman, hi! Any comments on the patch?

[segoon]

see https://reviews.llvm.org/D94622#2617417

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.h

+//===--- AsyncBlockingCheck.h - clang-tidy ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_ASYNCBLOCKINGCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_ASYNCBLOCKINGCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+/// Checks that non-coroutine-safe functions are not used.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/concurrency-async-blocking.html
+class AsyncBlockingCheck : public ClangTidyCheck {
+public:
+  AsyncBlockingCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const std::string LockableExtra;
+  const std::string WaitableExtra;
+  const std::string FunctionsExtra;
+  const std::string TypesExtra;
+};
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_ASYNCBLOCKINGCHECK_H

clang-tools-extra/clang-tidy/concurrency/AsyncBlockingCheck.cpp

+//===--- AsyncBlockingCheck.cpp - clang-tidy ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "AsyncBlockingCheck.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+static const char Identifier[] = "id";
+static const char Typename[] = "type";
+static const char Function[] = "function";
+static const char Method[] = "method";
+
+static std::vector<llvm::StringRef>
+toVector(llvm::ArrayRef<llvm::StringRef> Base, llvm::StringRef Extra) {
+  llvm::SmallVector<llvm::StringRef, 4> Tmp{Base.begin(), Base.end()};
+  if (!Extra.empty()) {
+    Extra.split(Tmp, ";");
+  }
+
+  return {Tmp.begin(), Tmp.end()};
+}
+
+static constexpr llvm::StringRef LockableBase[] = {
+    /* C++ std */
+    "::std::mutex",                 //
+    "::std::timed_mutex",           //
+    "::std::recursive_mutex",       //
+    "::std::recursive_timed_mutex", //
+    "::std::shared_mutex",          //
+    "::std::shared_timed_mutex",    //
+
+    /* Boost.Thread */
+    "::boost::mutex",                 //
+    "::boost::timed_mutex",           //
+    "::boost::recursive_mutex",       //
+    "::boost::recursive_timed_mutex", //
+    "::boost::shared_mutex",          //
+    "::boost::upgrade_mutex",         //
+};
+
+static constexpr llvm::StringRef LockableMethods[] = {
+    "lock",                  //
+    "try_lock_for",          //
+    "try_lock_until",        //
+    "lock_shared",           //
+    "try_lock_shared_for",   //
+    "try_lock_shared_until", //
+};
+
+static constexpr llvm::StringRef LockGuardTemplates[] = {
+    /* C++ std */
+    "::std::lock_guard",  //
+    "::std::scoped_lock", //
+    "::std::unique_lock", //
+    "::std::shared_lock", //
+
+    /* Boost.Thread */
+    "::boost::unique_lock",            //
+    "::boost::shared_lock",            //
+    "::boost::upgrade_lock",           //
+    "::boost::upgrade_to_unique_lock", //
+};
+
+static constexpr llvm::StringRef AtomicNames[] = {
+    "::std::atomic",
+    "::boost::atomic",
+};
+
+static constexpr llvm::StringRef WaitableBase[] = {
+    /* C++ std */
+    "::std::condition_variable", //
+    "::std::latch",              //
+    "::std::barrier",            //
+    "::std::future",             //
+    "::std::shared_future",      //
+    // TODO: std::condition_variable_any?
+
+    /* Boost.Thread */
+    "::boost::condition_variable", //
+    "::boost::latch",              //
+    "::boost::barrier",            //
+    "::boost::future",             //
+    "::boost::shared_future",      //
+};
+
+static constexpr llvm::StringRef WaitableMethods[] = {
+    "get",             //
+    "wait",            //
+    "wait_for",        //
+    "wait_until",      //
+    "arrive_and_wait", //
+};
+
+static constexpr llvm::StringRef BlockingFunctions[] = {
+    /* C++ std */
+    "::std::this_thread::sleep_for", //
+    "::std::this_thread::sleep_until",
+    // skip std::this_thread::yield()
+
+    "::std::thread::join",     //
+    "::std::jthread::jthread", //
+    "::std::jthread::join",    //
+
+    // std::atomic::wait has a custom matcher
+    "::std::atomic_flag::wait", //
+
+    "::std::atomic_wait",               //
+    "::std::atomic_wait_explicit",      //
+    "::std::atomic_flag_wait",          //
+    "::std::atomic_flag_wait_explicit", //
+
+    /* C11 */
+    "::thrd_sleep", //
+    "::thrd_join",  //
+    // skip thrd_yield()
+
+    "::mtx_lock",      //
+    "::mtx_timedlock", //
+
+    "::cnd_wait",      //
+    "::cnd_timedwait", //
+
+    /* POSIX (pthread) */
+    "::pthread_barrier_wait",   //
+    "::pthread_cond_timedwait", //
+    "::pthread_cond_wait",      //
+    "::pthread_join",           //
+
+    "::pthread_mutex_lock",      //
+    "::pthread_mutex_timedlock", //
+
+    "::pthread_rwlock_timedrdlock", //
+    "::pthread_rwlock_timedwrlock", //
+    "::pthread_rwlock_rdlock",      //
+    "::pthread_rwlock_wrlock",      //
+
+    "::pthread_spin_lock",    //
+    "::pthread_timedjoin_np", //
+
+    /* POSIX */
+    "::wait",            //
+    "::waitpid",         //
+    "::system",          //
+    "::sleep",           //
+    "::usleep",          //
+    "::nanosleep",       //
+    "::clock_nanosleep", //
+    "::accept",          //
+    "::mq_receive",      //
+    "::mq_timedreceive", //
+    "::msgsnd",          //
+    "::msgrcv",          //
+    "::poll",            //
+    "::pselect",         //
+    "::select",          //
+    "::recv",            //
+    "::recvmsg",         //
+    "::recvfrom",        //
+    "::semop",           //
+    "::semtimedop",      //
+    "::openlog",         //
+    "::syslog",          //
+    "::vsyslog",         //
+    "::waitid",          //
+
+    /* Linux syscalls */
+    "::wait3",       //
+    "::wait4",       //
+    "::epoll_wait",  //
+    "::epoll_pwait", //
+    "::ppoll",       //
+
+    /* Boost.Thread */
+    "::boost::this_thread::sleep",     //
+    "::boost::this_thread::sleep_for", //
+    "::boost::this_thread::sleep_until",
+
+    "::boost::thread::join",       //
+    "::boost::thread::timed_join", //
+};
+
+static constexpr llvm::StringRef TypesBase[] = {
+    /* C++ std */
+    "::std::counting_semaphore", //
+    "::std::binary_semaphore",   //
+    "::std::jthread",            // due to dtr
+};
+
+namespace clang {
+namespace tidy {
+namespace concurrency {
+
+AsyncBlockingCheck::AsyncBlockingCheck(StringRef Name,
+                                       ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      LockableExtra(Options.get("LockableExtra", "")),
+      WaitableExtra(Options.get("WaitableExtra", "")),
+      FunctionsExtra(Options.get("FunctionsExtra", "")),
+      TypesExtra(Options.get("TypesExtra", "")) {}
+
+void AsyncBlockingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "LockableExtra", LockableExtra);
+  Options.store(Opts, "WaitableExtra", WaitableExtra);
+  Options.store(Opts, "FunctionsExtra", FunctionsExtra);
+  Options.store(Opts, "TypesExtra", TypesExtra);
+}
+
+void AsyncBlockingCheck::registerMatchers(MatchFinder *Finder) {
+  // std::mutex
+  auto Lockable = toVector(LockableBase, LockableExtra);
+  Finder->addMatcher(
+      valueDecl(hasType(cxxRecordDecl(hasAnyName(Lockable)).bind(Identifier)))
+          .bind(Typename),
+      this);
+
+  // User code may use already created std::mutex, catch its usage
+  // std::mutex::lock()
+  // Note: exception for std::atomic as its type is handled separately
+  Finder->addMatcher(
+      cxxMemberCallExpr(
+          callee(functionDecl(hasAnyName(LockableMethods)).bind(Identifier)),
+          on(hasType(cxxRecordDecl(hasAnyName(Lockable)))))
+          .bind(Method),
+      this);
+
+  // std::future<T>
+  auto Waitable = toVector(WaitableBase, StringRef(WaitableExtra));
+  Finder->addMatcher(
+      valueDecl(hasType(cxxRecordDecl(hasAnyName(Waitable)).bind(Identifier)))
+          .bind(Typename),
+      this);
+
+  // std::future<T>::wait()
+  Finder->addMatcher(
+      cxxMemberCallExpr(
+          callee(functionDecl(hasAnyName(WaitableMethods)).bind(Identifier)),
+          on(hasType(cxxRecordDecl(
+              anyOf(hasAnyName(Waitable), hasAnyName(AtomicNames))))))
+          .bind(Method),
+      this);
+
+  // sleep()
+  auto SleepingFunctionNames =
+      toVector(BlockingFunctions, StringRef(FunctionsExtra));
+  Finder->addMatcher(
+      callExpr(
+          callee(
+              functionDecl(hasAnyName(SleepingFunctionNames)).bind(Identifier)))
+          .bind(Function),
+      this);
+
+  // std::jthread
+  auto TypeNames = toVector(TypesBase, StringRef(TypesExtra));
+  Finder->addMatcher(
+      valueDecl(hasType(cxxRecordDecl(hasAnyName(TypeNames)).bind(Identifier)))
+          .bind(Typename),
+      this);
+
+  // std::unique_lock<std::mutex>
+  Finder->addMatcher(
+      valueDecl(hasType(qualType(hasDeclaration(
+                    classTemplateSpecializationDecl(
+                        hasAnyName(LockGuardTemplates),
+                        hasTemplateArgument(
+                            0, refersToType(qualType(hasDeclaration(
+                                   cxxRecordDecl(hasAnyName(Lockable)))))))
+                        .bind(Identifier)))))
+          .bind(Typename),
+      this);
+}
+
+void AsyncBlockingCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Name = Result.Nodes.getNodeAs<NamedDecl>(Identifier);
+
+  if (const auto *D = Result.Nodes.getNodeAs<ValueDecl>(Typename)) {
+    assert(Name);
+    diag(D->getBeginLoc(), "type %0 may sleep and is not coroutine-safe")
+        << Name << D->getSourceRange();
+  }
+
+  if (const auto *CE = Result.Nodes.getNodeAs<CXXMemberCallExpr>(Method)) {
+    assert(Name);
+    diag(CE->getBeginLoc(), "method %0 may sleep and is not coroutine-safe")
+        << Name << CE->getSourceRange();
+  }
+
+  if (const auto *E = Result.Nodes.getNodeAs<CallExpr>(Function)) {
+    assert(Name);
+    diag(E->getBeginLoc(), "function %0 may sleep and is not coroutine-safe")
+        << Name << E->getSourceRange();
+  }
+}
+
+} // namespace concurrency
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/concurrency/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyConcurrencyModule
+  AsyncBlockingCheck.cpp
   ConcurrencyTidyModule.cpp
   MtUnsafeCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyUtils
   )
 

clang-tools-extra/clang-tidy/concurrency/ConcurrencyTidyModule.cpp

 //===--- ConcurrencyTidyModule.cpp - clang-tidy ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "AsyncBlockingCheck.h"
 #include "MtUnsafeCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace concurrency {
 
 class ConcurrencyModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<AsyncBlockingCheck>(
+        "concurrency-async-blocking");
     CheckFactories.registerCheck<concurrency::MtUnsafeCheck>(
         "concurrency-mt-unsafe");
   }
 };
 
 } // namespace concurrency
 
 // Register the ConcurrencyTidyModule using this statically initialized variable.

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`altera-single-work-item-barrier
   an ID function.
 
 - New :doc:`altera-struct-pack-align
   <clang-tidy/checks/altera-struct-pack-align>` check.
 
   Finds structs that are inefficiently packed or aligned, and recommends
   packing and/or aligning of said structs as needed.
 
+- New :doc:`concurrency-async-blocking
+  <clang-tidy/checks/concurrency-async-blocking>` check.
+
+  Checks for some blocking functions and types that volunteerly preempt
+  system thread.
+
 - New :doc:`cppcoreguidelines-prefer-member-initializer
   <clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
 
   Finds member initializations in the constructor body which can be placed into
   the initialization list instead.
 
 - New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   <clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.

clang-tools-extra/docs/clang-tidy/checks/concurrency-async-blocking.rst

+.. title:: clang-tidy - concurrency-async-blocking
+
+concurrency-async-blocking
+==========================
+
+Checks for some synchronous functions and types that volunteerly preempt system
+thread. Volunteer preemption of a system thread in asynchronous code (e.g. in
+coroutines/fibers/green threads) is a bug that prevents the current thread from
+executing other coroutines/etc. and negatively affects overall process
+performance.
+
+The preemptive functions/types can be separated into the following categories:
+
+* explicit sleeping functions (e.g. ``sleep(3)``)
+* sleeping/waiting synchronization primitives (e.g. ``std::mutex``)
+* io/filesystem stuff (not implemented yet)
+
+The check searches for:
+
+* C++ synchronization primitives
+* C11 synchronization primitives
+* POSIX synchronization primitives
+* some POSIX blocking functions
+* some blocking Linux syscalls
+* some Boost.Thread synchronization primitives
+
+.. option:: LockableExtra
+
+  Specifies additional lock type names separated with semicolon. Usually they
+  implement C++17 `BasicLockable`, `Lockable`, `TimedLockable`, `Mutex`, or
+  `TimedMutex` requirement or has one or several methods from the following
+  list:
+
+  * ``lock``
+  * ``try_lock_for``
+  * ``try_lock_until``
+  * ``lock_shared``
+  * ``try_lock_shared_for``
+  * ``try_lock_shared_until``
+
+  The check searches for explicit method calls from the list above and implicit
+  locking using ``std::lock_guard`` and other RAII sychronization primitive
+  ownership wrappers.
+
+  The list of classes which are already handled (and their ``boost::`` twins):
+
+  * ``std::mutex``
+  * ``std::timed_mutex``
+  * ``std::recursive_mutex``
+  * ``std::recursive_timed_mutex``
+  * ``std::shared_mutex``
+  * ``std::shared_timed_mutex``
+
+.. option:: WaitableExtra
+
+  Specifies additional future-like types separated with semicolon.
+  The type must implement one or several methods from the following list:
+
+  * ``get``
+  * ``wait``
+  * ``wait_for``
+  * ``wait_until``
+  * ``arrive_and_wait``
+
+  The list of classes which are already handled (and their ``boost::`` twins):
+
+  * ``std::condition_variable``
+  * ``std::latch``
+  * ``std::barrier``
+  * ``std::future<T>``
+  * ``std::shared_future``
+
+.. option:: FunctionsExtra
+
+  Extra functions that may block current system thread, separated with semicolon.
+  Usually the function list should be compiled for third-party libraries or
+  user-defined known-to-be-blocking functions.
+
+  Already handled:
+
+  * C11 thread/mutex/condition variable functions
+  * some POSIX functions
+  * some Linux syscalls
+
+.. option:: TypesExtra
+
+  Extra types that may block current system thread, separated with semicolon.
+  Usually the type list should be compiled for third-party libraries or
+  user-defined known-to-be-blocking types.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `clang-analyzer-osx.cocoa.AutoreleaseWrite <clang-analyzer-osx.cocoa.AutoreleaseWrite.html>`_,
    `clang-analyzer-osx.cocoa.Loops <clang-analyzer-osx.cocoa.Loops.html>`_,
    `clang-analyzer-osx.cocoa.MissingSuperCall <clang-analyzer-osx.cocoa.MissingSuperCall.html>`_,
    `clang-analyzer-osx.cocoa.NonNilReturnValue <clang-analyzer-osx.cocoa.NonNilReturnValue.html>`_,
    `clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak <clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak.html>`_,
    `clang-analyzer-valist.CopyToSelf <clang-analyzer-valist.CopyToSelf.html>`_,
    `clang-analyzer-valist.Uninitialized <clang-analyzer-valist.Uninitialized.html>`_,
    `clang-analyzer-valist.Unterminated <clang-analyzer-valist.Unterminated.html>`_,
+   `concurrency-async-blocking <concurrency-async-blocking.html>`_,
    `concurrency-mt-unsafe <concurrency-mt-unsafe.html>`_,
    `cppcoreguidelines-avoid-goto <cppcoreguidelines-avoid-goto.html>`_,
    `cppcoreguidelines-avoid-non-const-global-variables <cppcoreguidelines-avoid-non-const-global-variables.html>`_,
    `cppcoreguidelines-init-variables <cppcoreguidelines-init-variables.html>`_, "Yes"
    `cppcoreguidelines-interfaces-global-init <cppcoreguidelines-interfaces-global-init.html>`_,
    `cppcoreguidelines-macro-usage <cppcoreguidelines-macro-usage.html>`_,
    `cppcoreguidelines-narrowing-conversions <cppcoreguidelines-narrowing-conversions.html>`_,
    `cppcoreguidelines-no-malloc <cppcoreguidelines-no-malloc.html>`_,

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-blocking.c

+// RUN: %check_clang_tidy %s concurrency-async-blocking %t
+
+void mtx_lock(void *);
+void mtx_timedlock(void *, void *);
+int thrd_sleep(void *, void *);
+int thrd_join(void *, int *);
+int cnd_wait(void *, void *);
+int cnd_timedwait(void *, void *, void *);
+
+void test_c11() {
+  mtx_lock(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'mtx_lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  mtx_timedlock(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'mtx_timedlock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  thrd_sleep(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  thrd_join(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_join' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  cnd_wait(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'cnd_wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  cnd_timedwait(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'cnd_timedwait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+void sleep(int);
+void nanosleep(int);
+void usleep(int);
+void xsleep(int);
+void sleepx(int);
+void system(const char *);
+int wait(int *);
+int waitpid(int, int *, int);
+
+struct rusage {};
+#define pid_t int
+pid_t wait3(int *status, int options,
+            struct rusage *rusage);
+
+pid_t wait4(pid_t pid, int *status, int options,
+            struct rusage *rusage);
+
+void test_posix() {
+  sleep(1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  xsleep(1);
+  sleepx(1);
+
+  system("ls");
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'system' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  wait(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  waitpid(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'waitpid' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  wait3(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait3' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  wait4(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait4' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}

clang-tools-extra/test/clang-tidy/checkers/concurrency-async-blocking.cpp

+// RUN: %check_clang_tidy %s concurrency-async-blocking %t -- \
+// RUN: -config='{CheckOptions: [{key: "concurrency-async-blocking.LockableExtra", value: "my::mutex;my::shared_mutex"}, {key: "concurrency-async-blocking.WaitableExtra", value: "my::Future;my::cv"}, {key: "concurrency-async-blocking.LockableExtra", value: "my::mutex;my::shared_mutex"}, {key: "concurrency-async-blocking.FunctionsExtra", value: "my_sleep;my::sleep"}, {key: "concurrency-async-blocking.TypesExtra", value: "my::big_lock;my::other_lock"}]}'
+
+/* Poor man's declaration of std::mutex and friends */
+namespace std {
+namespace chrono {
+class seconds {
+public:
+  seconds(int);
+};
+} // namespace chrono
+
+class mutex {
+public:
+  void lock();
+
+  // non-std methods
+  void lock_suffix();
+  void prefix_lock();
+
+  template <typename Duration>
+  void try_lock_for(Duration);
+};
+class recursive_mutex {};
+class recursive_timed_mutex {};
+class shared_mutex {};
+class shared_timed_mutex {};
+class mutex_suffix {};
+class prefix_mutex {};
+
+template <typename Lock>
+class unique_lock {
+public:
+  unique_lock(Lock &);
+
+  void lock();
+  template <typename Duration>
+  void try_lock_for(Duration);
+
+  // non-std methods
+  void lock_suffix();
+  void prefix_lock();
+};
+
+} // namespace std
+
+namespace ns {
+class mutex {};
+} // namespace ns
+
+class mutex {};
+
+template <typename T>
+class nonlock {};
+
+namespace my {
+class mutex {
+public:
+  void lock();
+};
+class shared_mutex {};
+class non_mutex {
+public:
+  void lock();
+};
+} // namespace my
+
+void test_lockable() {
+  std::mutex m;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  ::std::mutex mns;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::shared_mutex sm;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'shared_mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::recursive_mutex rm;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'recursive_mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::recursive_timed_mutex rtm;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'recursive_timed_mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  my::mutex mym;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::mutex_suffix m1;
+  std::prefix_mutex m2;
+  ns::mutex m3;
+  mutex m4;
+  my::non_mutex myn;
+
+  m.lock();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  mns.lock();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  mym.lock();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  myn.lock();
+
+  m.lock_suffix();
+  m.prefix_lock();
+
+  std::unique_lock<std::mutex> lock(m);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'unique_lock<std::mutex>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::unique_lock<std::mutex_suffix> l1(m1);
+  std::unique_lock<std::prefix_mutex> l2(m2);
+  std::unique_lock<ns::mutex> l3(m3);
+  std::unique_lock<mutex> l4(m4);
+
+  nonlock<std::mutex> nonlock;
+}
+
+void sleep(int);
+void nanosleep(int);
+void usleep(int);
+void xsleep(int);
+void sleepx(int);
+void system(const char *);
+int wait(int *);
+int waitpid(int, int *, int);
+int waitid(int idtype, int id, int *infop, int options);
+
+struct rusage {};
+using pid_t = int;
+pid_t wait3(int *status, int options,
+            struct rusage *rusage);
+
+pid_t wait4(pid_t pid, int *status, int options,
+            struct rusage *rusage);
+
+namespace std {
+namespace this_thread {
+void yield();
+
+template <typename Duration>
+void sleep_for(Duration);
+
+template <typename Duration>
+void sleep_until(Duration);
+} // namespace this_thread
+} // namespace std
+
+void test_std_thread() {
+  std::this_thread::yield();
+
+  std::chrono::seconds s(1);
+
+  std::this_thread::sleep_for(s);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep_for<std::chrono::seconds>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::this_thread::sleep_until(s);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep_until<std::chrono::seconds>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+void my_sleep();
+
+namespace my {
+void sleep();
+}
+
+void test_posix() {
+  sleep(1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  ::sleep(1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  ::xsleep(1);
+  xsleep(1);
+  ::sleepx(1);
+  sleepx(1);
+
+  my_sleep();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'my_sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  my::sleep();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  system("ls");
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'system' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  wait(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  waitpid(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'waitpid' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  wait3(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait3' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  wait4(0, 0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait4' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+namespace std {
+template <typename T>
+class atomic {
+public:
+  void wait(const T &);
+
+  static constexpr bool is_always_lock_free = false;
+};
+
+class atomic_flag {
+public:
+  void wait(bool);
+};
+
+template <>
+class atomic<char> {
+public:
+  void wait(const char &);
+
+  static constexpr bool is_always_lock_free = true;
+};
+
+template <typename T, typename U>
+void atomic_wait(T *, U);
+
+template <typename T, typename U, typename V>
+void atomic_wait_explicit(T *, U, V);
+
+void atomic_flag_wait(atomic_flag *, bool);
+
+template <typename V>
+void atomic_flag_wait_explicit(atomic_flag *, bool, V);
+} // namespace std
+
+namespace boost {
+template <typename T>
+class atomic {
+public:
+  void wait(const T &);
+
+  static constexpr bool is_always_lock_free = true;
+};
+} // namespace boost
+
+void test_atomic() {
+  std::atomic<int> ai;
+  std::atomic<char> ac;
+
+  ai.wait(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  ac.wait(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::atomic_flag flag;
+  flag.wait(false);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::atomic_flag_wait(&flag, false);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'atomic_flag_wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::atomic_flag_wait_explicit(&flag, false, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'atomic_flag_wait_explicit<int>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::atomic_wait(&ac, 1);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'atomic_wait<std::atomic<char>, int>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::atomic_wait_explicit(&ac, 1, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'atomic_wait_explicit<std::atomic<char>, int, int>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  boost::atomic<int> ba;
+  ba.wait(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+namespace std {
+class thread {
+public:
+  void join();
+};
+
+class jthread {
+public:
+  ~jthread();
+  void join();
+};
+} // namespace std
+
+void test_thread() {
+  std::thread t;
+  t.join();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'join' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::jthread j;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'jthread' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  j.join();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'join' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+namespace std {
+class condition_variable {
+public:
+  void wait(unique_lock<std::mutex> &);
+
+  template <typename Duration>
+  void wait_for(unique_lock<std::mutex> &, Duration);
+
+  template <typename Duration>
+  void wait_until(unique_lock<std::mutex> &, Duration);
+};
+class barrier {
+public:
+  void wait();
+  void arrive_and_wait();
+};
+class latch {
+public:
+  void wait();
+  void arrive_and_wait();
+};
+
+template <typename T>
+class future {
+public:
+  void wait();
+
+  void get();
+};
+} // namespace std
+
+namespace my {
+class Future {
+public:
+  void wait();
+  void get();
+};
+class Cv {
+  void wait();
+};
+} // namespace my
+
+void test_waitable() {
+  std::mutex m;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  std::unique_lock<std::mutex> lock(m);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'unique_lock<std::mutex>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::condition_variable cv;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'condition_variable' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  cv.wait(lock);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  cv.wait_for(lock, std::chrono::seconds(1));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait_for<std::chrono::seconds>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  cv.wait_until(lock, std::chrono::seconds(1));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait_until<std::chrono::seconds>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  my::Future myf;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'Future' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  myf.wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  myf.get();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'get' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::mutex_suffix ms;
+  std::unique_lock<std::mutex_suffix> mslock(ms);
+
+  std::latch l;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'latch' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  l.wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  l.arrive_and_wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'arrive_and_wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::barrier b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'barrier' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  b.wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  b.arrive_and_wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'arrive_and_wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::future<int> f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'future<int>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  f.wait();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  f.get();
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'get' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+class X {
+  std::mutex m;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'mutex' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  std::unique_lock<std::mutex> lock;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'unique_lock<std::mutex>' may sleep and is not coroutine-safe [concurrency-async-blocking]
+};
+
+void mtx_lock(void *);
+void mtx_timedlock(void *, void *);
+int thrd_sleep(void *, void *);
+int thrd_join(void *, int *);
+int cnd_wait(void *, void *);
+int cnd_timedwait(void *, void *, void *);
+
+void test_c11() {
+  mtx_lock(0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'mtx_lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  mtx_timedlock(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'mtx_timedlock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  thrd_sleep(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_sleep' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  thrd_join(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'thrd_join' may sleep and is not coroutine-safe [concurrency-async-blocking]
+
+  cnd_wait(0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'cnd_wait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  cnd_timedwait(0, 0, 0);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function 'cnd_timedwait' may sleep and is not coroutine-safe [concurrency-async-blocking]
+}
+
+namespace my {
+class big_lock {};
+
+class other_lock {};
+
+class other {};
+} // namespace my
+
+void test_types() {
+  my::big_lock lock;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'big_lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  my::other_lock other_lock;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: type 'other_lock' may sleep and is not coroutine-safe [concurrency-async-blocking]
+  my::other other;
+}