llvm/compiler-rt/lib/rtsan/rtsan_context.cpp

//===--- rtsan_context.cpp - Realtime Sanitizer -----------------*- 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
//
//===----------------------------------------------------------------------===//
//
//===----------------------------------------------------------------------===//

#include <rtsan/rtsan.h>
#include <rtsan/rtsan_context.h>

#include <rtsan/rtsan_stack.h>

#include <sanitizer_common/sanitizer_allocator_internal.h>
#include <sanitizer_common/sanitizer_stacktrace.h>

#include <new>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

usingnamespace__sanitizer;

static pthread_key_t context_key;
static pthread_once_t key_once = …;

// InternalFree cannot be passed directly to pthread_key_create
// because it expects a signature with only one arg
static void InternalFreeWrapper(void *ptr) { … }

static __rtsan::Context &GetContextForThisThreadImpl() { … }

/*
    This is a placeholder stub for a future feature that will allow
    a user to configure RTSan's behaviour when a real-time safety
    violation is detected. The RTSan developers intend for the
    following choices to be made available, via a RTSAN_OPTIONS
    environment variable, in a future PR:

        i) exit,
       ii) continue, or
      iii) wait for user input from stdin.

    Until then, and to keep the first PRs small, only the exit mode
    is available.
*/
static void InvokeViolationDetectedAction() { … }

__rtsan::Context::Context() = default;

void __rtsan::Context::RealtimePush() { … }

void __rtsan::Context::RealtimePop() { … }

void __rtsan::Context::BypassPush() { … }

void __rtsan::Context::BypassPop() { … }

void __rtsan::ExpectNotRealtime(Context &context,
                                const char *intercepted_function_name) { … }

bool __rtsan::Context::InRealtimeContext() const { … }

bool __rtsan::Context::IsBypassed() const { … }

void __rtsan::PrintDiagnostics(const char *intercepted_function_name, uptr pc,
                               uptr bp) { … }

__rtsan::Context &__rtsan::GetContextForThisThread() { … }