2c54b29337
An option is added to the check to select wich set of functions is defined as asynchronous-safe functions. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D90851
416 lines
11 KiB
C++
416 lines
11 KiB
C++
//===--- SignalHandlerCheck.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 "SignalHandlerCheck.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/RecursiveASTVisitor.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/Analysis/CallGraph.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include <iterator>
|
|
#include <queue>
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
|
|
template <>
|
|
struct OptionEnumMapping<
|
|
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetType> {
|
|
static llvm::ArrayRef<std::pair<
|
|
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetType, StringRef>>
|
|
getEnumMapping() {
|
|
static constexpr std::pair<
|
|
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetType, StringRef>
|
|
Mapping[] = {
|
|
{bugprone::SignalHandlerCheck::AsyncSafeFunctionSetType::Minimal,
|
|
"minimal"},
|
|
{bugprone::SignalHandlerCheck::AsyncSafeFunctionSetType::POSIX,
|
|
"POSIX"},
|
|
};
|
|
return makeArrayRef(Mapping);
|
|
}
|
|
};
|
|
|
|
namespace bugprone {
|
|
|
|
static bool isSystemCall(const FunctionDecl *FD) {
|
|
// Find a possible redeclaration in system header.
|
|
// FIXME: Looking at the canonical declaration is not the most exact way
|
|
// to do this.
|
|
|
|
// Most common case will be inclusion directly from a header.
|
|
// This works fine by using canonical declaration.
|
|
// a.c
|
|
// #include <sysheader.h>
|
|
|
|
// Next most common case will be extern declaration.
|
|
// Can't catch this with either approach.
|
|
// b.c
|
|
// extern void sysfunc(void);
|
|
|
|
// Canonical declaration is the first found declaration, so this works.
|
|
// c.c
|
|
// #include <sysheader.h>
|
|
// extern void sysfunc(void); // redecl won't matter
|
|
|
|
// This does not work with canonical declaration.
|
|
// Probably this is not a frequently used case but may happen (the first
|
|
// declaration can be in a non-system header for example).
|
|
// d.c
|
|
// extern void sysfunc(void); // Canonical declaration, not in system header.
|
|
// #include <sysheader.h>
|
|
|
|
return FD->getASTContext().getSourceManager().isInSystemHeader(
|
|
FD->getCanonicalDecl()->getLocation());
|
|
}
|
|
|
|
AST_MATCHER(FunctionDecl, isSystemCall) { return isSystemCall(&Node); }
|
|
|
|
SignalHandlerCheck::SignalHandlerCheck(StringRef Name,
|
|
ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context),
|
|
AsyncSafeFunctionSet(
|
|
Options.get("AsyncSafeFunctionSet", AsyncSafeFunctionSetType::POSIX)),
|
|
ConformingFunctions(AsyncSafeFunctionSet ==
|
|
AsyncSafeFunctionSetType::Minimal
|
|
? MinimalConformingFunctions
|
|
: POSIXConformingFunctions) {}
|
|
|
|
void SignalHandlerCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
|
|
Options.store(Opts, "AsyncSafeFunctionSet", AsyncSafeFunctionSet);
|
|
}
|
|
|
|
bool SignalHandlerCheck::isLanguageVersionSupported(
|
|
const LangOptions &LangOpts) const {
|
|
// FIXME: Make the checker useful on C++ code.
|
|
if (LangOpts.CPlusPlus)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void SignalHandlerCheck::registerMatchers(MatchFinder *Finder) {
|
|
auto SignalFunction = functionDecl(hasAnyName("::signal", "::std::signal"),
|
|
parameterCountIs(2), isSystemCall());
|
|
auto HandlerExpr =
|
|
declRefExpr(hasDeclaration(functionDecl().bind("handler_decl")),
|
|
unless(isExpandedFromMacro("SIG_IGN")),
|
|
unless(isExpandedFromMacro("SIG_DFL")))
|
|
.bind("handler_expr");
|
|
Finder->addMatcher(
|
|
callExpr(callee(SignalFunction), hasArgument(1, HandlerExpr))
|
|
.bind("register_call"),
|
|
this);
|
|
}
|
|
|
|
void SignalHandlerCheck::check(const MatchFinder::MatchResult &Result) {
|
|
const auto *SignalCall = Result.Nodes.getNodeAs<CallExpr>("register_call");
|
|
const auto *HandlerDecl =
|
|
Result.Nodes.getNodeAs<FunctionDecl>("handler_decl");
|
|
const auto *HandlerExpr = Result.Nodes.getNodeAs<DeclRefExpr>("handler_expr");
|
|
|
|
// Visit each function encountered in the callgraph only once.
|
|
llvm::DenseSet<const FunctionDecl *> SeenFunctions;
|
|
|
|
// The worklist of the callgraph visitation algorithm.
|
|
std::deque<const CallExpr *> CalledFunctions;
|
|
|
|
auto ProcessFunction = [&](const FunctionDecl *F, const Expr *CallOrRef) {
|
|
// Ensure that canonical declaration is used.
|
|
F = F->getCanonicalDecl();
|
|
|
|
// Do not visit function if already encountered.
|
|
if (!SeenFunctions.insert(F).second)
|
|
return true;
|
|
|
|
// Check if the call is allowed.
|
|
// Non-system calls are not considered.
|
|
if (isSystemCall(F)) {
|
|
if (isSystemCallAllowed(F))
|
|
return true;
|
|
|
|
reportBug(F, CallOrRef, SignalCall, HandlerDecl);
|
|
|
|
return false;
|
|
}
|
|
|
|
// Get the body of the encountered non-system call function.
|
|
const FunctionDecl *FBody;
|
|
if (!F->hasBody(FBody)) {
|
|
reportBug(F, CallOrRef, SignalCall, HandlerDecl);
|
|
return false;
|
|
}
|
|
|
|
// Collect all called functions.
|
|
auto Matches = match(decl(forEachDescendant(callExpr().bind("call"))),
|
|
*FBody, FBody->getASTContext());
|
|
for (const auto &Match : Matches) {
|
|
const auto *CE = Match.getNodeAs<CallExpr>("call");
|
|
if (isa<FunctionDecl>(CE->getCalleeDecl()))
|
|
CalledFunctions.push_back(CE);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
if (!ProcessFunction(HandlerDecl, HandlerExpr))
|
|
return;
|
|
|
|
// Visit the definition of every function referenced by the handler function.
|
|
// Check for allowed function calls.
|
|
while (!CalledFunctions.empty()) {
|
|
const CallExpr *FunctionCall = CalledFunctions.front();
|
|
CalledFunctions.pop_front();
|
|
// At insertion we have already ensured that only function calls are there.
|
|
const auto *F = cast<FunctionDecl>(FunctionCall->getCalleeDecl());
|
|
|
|
if (!ProcessFunction(F, FunctionCall))
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool SignalHandlerCheck::isSystemCallAllowed(const FunctionDecl *FD) const {
|
|
const IdentifierInfo *II = FD->getIdentifier();
|
|
// Unnamed functions are not explicitly allowed.
|
|
if (!II)
|
|
return false;
|
|
|
|
// FIXME: Improve for C++ (check for namespace).
|
|
if (ConformingFunctions.count(II->getName()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void SignalHandlerCheck::reportBug(const FunctionDecl *CalledFunction,
|
|
const Expr *CallOrRef,
|
|
const CallExpr *SignalCall,
|
|
const FunctionDecl *HandlerDecl) {
|
|
diag(CallOrRef->getBeginLoc(),
|
|
"%0 may not be asynchronous-safe; "
|
|
"calling it from a signal handler may be dangerous")
|
|
<< CalledFunction;
|
|
diag(SignalCall->getSourceRange().getBegin(),
|
|
"signal handler registered here", DiagnosticIDs::Note);
|
|
diag(HandlerDecl->getBeginLoc(), "handler function declared here",
|
|
DiagnosticIDs::Note);
|
|
}
|
|
|
|
// This is the minimal set of safe functions.
|
|
// https://wiki.sei.cmu.edu/confluence/display/c/SIG30-C.+Call+only+asynchronous-safe+functions+within+signal+handlers
|
|
llvm::StringSet<> SignalHandlerCheck::MinimalConformingFunctions{
|
|
"signal", "abort", "_Exit", "quick_exit"};
|
|
|
|
// The POSIX-defined set of safe functions.
|
|
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04_03
|
|
// 'quick_exit' is added to the set additionally because it looks like the
|
|
// mentioned POSIX specification was not updated after 'quick_exit' appeared
|
|
// in the C11 standard.
|
|
// Also, we want to keep the "minimal set" a subset of the "POSIX set".
|
|
llvm::StringSet<> SignalHandlerCheck::POSIXConformingFunctions{
|
|
"_Exit",
|
|
"_exit",
|
|
"abort",
|
|
"accept",
|
|
"access",
|
|
"aio_error",
|
|
"aio_return",
|
|
"aio_suspend",
|
|
"alarm",
|
|
"bind",
|
|
"cfgetispeed",
|
|
"cfgetospeed",
|
|
"cfsetispeed",
|
|
"cfsetospeed",
|
|
"chdir",
|
|
"chmod",
|
|
"chown",
|
|
"clock_gettime",
|
|
"close",
|
|
"connect",
|
|
"creat",
|
|
"dup",
|
|
"dup2",
|
|
"execl",
|
|
"execle",
|
|
"execv",
|
|
"execve",
|
|
"faccessat",
|
|
"fchdir",
|
|
"fchmod",
|
|
"fchmodat",
|
|
"fchown",
|
|
"fchownat",
|
|
"fcntl",
|
|
"fdatasync",
|
|
"fexecve",
|
|
"ffs",
|
|
"fork",
|
|
"fstat",
|
|
"fstatat",
|
|
"fsync",
|
|
"ftruncate",
|
|
"futimens",
|
|
"getegid",
|
|
"geteuid",
|
|
"getgid",
|
|
"getgroups",
|
|
"getpeername",
|
|
"getpgrp",
|
|
"getpid",
|
|
"getppid",
|
|
"getsockname",
|
|
"getsockopt",
|
|
"getuid",
|
|
"htonl",
|
|
"htons",
|
|
"kill",
|
|
"link",
|
|
"linkat",
|
|
"listen",
|
|
"longjmp",
|
|
"lseek",
|
|
"lstat",
|
|
"memccpy",
|
|
"memchr",
|
|
"memcmp",
|
|
"memcpy",
|
|
"memmove",
|
|
"memset",
|
|
"mkdir",
|
|
"mkdirat",
|
|
"mkfifo",
|
|
"mkfifoat",
|
|
"mknod",
|
|
"mknodat",
|
|
"ntohl",
|
|
"ntohs",
|
|
"open",
|
|
"openat",
|
|
"pause",
|
|
"pipe",
|
|
"poll",
|
|
"posix_trace_event",
|
|
"pselect",
|
|
"pthread_kill",
|
|
"pthread_self",
|
|
"pthread_sigmask",
|
|
"quick_exit",
|
|
"raise",
|
|
"read",
|
|
"readlink",
|
|
"readlinkat",
|
|
"recv",
|
|
"recvfrom",
|
|
"recvmsg",
|
|
"rename",
|
|
"renameat",
|
|
"rmdir",
|
|
"select",
|
|
"sem_post",
|
|
"send",
|
|
"sendmsg",
|
|
"sendto",
|
|
"setgid",
|
|
"setpgid",
|
|
"setsid",
|
|
"setsockopt",
|
|
"setuid",
|
|
"shutdown",
|
|
"sigaction",
|
|
"sigaddset",
|
|
"sigdelset",
|
|
"sigemptyset",
|
|
"sigfillset",
|
|
"sigismember",
|
|
"siglongjmp",
|
|
"signal",
|
|
"sigpause",
|
|
"sigpending",
|
|
"sigprocmask",
|
|
"sigqueue",
|
|
"sigset",
|
|
"sigsuspend",
|
|
"sleep",
|
|
"sockatmark",
|
|
"socket",
|
|
"socketpair",
|
|
"stat",
|
|
"stpcpy",
|
|
"stpncpy",
|
|
"strcat",
|
|
"strchr",
|
|
"strcmp",
|
|
"strcpy",
|
|
"strcspn",
|
|
"strlen",
|
|
"strncat",
|
|
"strncmp",
|
|
"strncpy",
|
|
"strnlen",
|
|
"strpbrk",
|
|
"strrchr",
|
|
"strspn",
|
|
"strstr",
|
|
"strtok_r",
|
|
"symlink",
|
|
"symlinkat",
|
|
"tcdrain",
|
|
"tcflow",
|
|
"tcflush",
|
|
"tcgetattr",
|
|
"tcgetpgrp",
|
|
"tcsendbreak",
|
|
"tcsetattr",
|
|
"tcsetpgrp",
|
|
"time",
|
|
"timer_getoverrun",
|
|
"timer_gettime",
|
|
"timer_settime",
|
|
"times",
|
|
"umask",
|
|
"uname",
|
|
"unlink",
|
|
"unlinkat",
|
|
"utime",
|
|
"utimensat",
|
|
"utimes",
|
|
"wait",
|
|
"waitpid",
|
|
"wcpcpy",
|
|
"wcpncpy",
|
|
"wcscat",
|
|
"wcschr",
|
|
"wcscmp",
|
|
"wcscpy",
|
|
"wcscspn",
|
|
"wcslen",
|
|
"wcsncat",
|
|
"wcsncmp",
|
|
"wcsncpy",
|
|
"wcsnlen",
|
|
"wcspbrk",
|
|
"wcsrchr",
|
|
"wcsspn",
|
|
"wcsstr",
|
|
"wcstok",
|
|
"wmemchr",
|
|
"wmemcmp",
|
|
"wmemcpy",
|
|
"wmemmove",
|
|
"wmemset",
|
|
"write"};
|
|
|
|
} // namespace bugprone
|
|
} // namespace tidy
|
|
} // namespace clang
|