File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/compiler-rt/lib/sanitizer_common

usr / src / contrib / llvm-project / compiler-rt / lib / sanitizer_common /

📁 ..
📄 sancov_flags.cpp(1.64 KB)
📄 sancov_flags.h(1.08 KB)
📄 sancov_flags.inc(777 B)
📄 sanitizer_addrhashmap.h(9.19 KB)
📄 sanitizer_allocator.cpp(8.73 KB)
📄 sanitizer_allocator.h(2.69 KB)
📄 sanitizer_allocator_bytemap.h(3.12 KB)
📄 sanitizer_allocator_checks.cpp(686 B)
📄 sanitizer_allocator_checks.h(2.67 KB)
📄 sanitizer_allocator_combined.h(6.29 KB)
📄 sanitizer_allocator_interface.h(1.83 KB)
📄 sanitizer_allocator_internal.h(2.03 KB)
📄 sanitizer_allocator_local_cache.h(8.95 KB)
📄 sanitizer_allocator_primary32.h(12.64 KB)
📄 sanitizer_allocator_primary64.h(32.71 KB)
📄 sanitizer_allocator_report.cpp(4.68 KB)
📄 sanitizer_allocator_report.h(1.72 KB)
📄 sanitizer_allocator_secondary.h(10.78 KB)
📄 sanitizer_allocator_size_class_map.h(10.12 KB)
📄 sanitizer_allocator_stats.h(2.76 KB)
📄 sanitizer_asm.h(2.57 KB)
📄 sanitizer_atomic.h(1.97 KB)
📄 sanitizer_atomic_clang.h(3.42 KB)
📄 sanitizer_atomic_clang_mips.h(3.77 KB)
📄 sanitizer_atomic_clang_other.h(3.02 KB)
📄 sanitizer_atomic_clang_x86.h(3.77 KB)
📄 sanitizer_atomic_msvc.h(8.53 KB)
📄 sanitizer_bitvector.h(9.43 KB)
📄 sanitizer_bvgraph.h(4.62 KB)
📄 sanitizer_common.cpp(10.13 KB)
📄 sanitizer_common.h(30.64 KB)
📄 sanitizer_common_interceptors.inc(348.66 KB)
📄 sanitizer_common_interceptors_format.inc(16.84 KB)
📄 sanitizer_common_interceptors_ioctl.inc(22.13 KB)
📄 sanitizer_common_interceptors_netbsd_compat.inc(4.07 KB)
📄 sanitizer_common_interceptors_vfork_aarch64.inc.S(1.23 KB)
📄 sanitizer_common_interceptors_vfork_arm.inc.S(1.24 KB)
📄 sanitizer_common_interceptors_vfork_i386.inc.S(1.66 KB)
📄 sanitizer_common_interceptors_vfork_x86_64.inc.S(1.03 KB)
📄 sanitizer_common_interface.inc(2.05 KB)
📄 sanitizer_common_interface_posix.inc(732 B)
📄 sanitizer_common_libcdep.cpp(5.4 KB)
📄 sanitizer_common_nolibc.cpp(1.12 KB)
📄 sanitizer_common_syscalls.inc(85 KB)
📄 sanitizer_coverage_fuchsia.cpp(10.1 KB)
📄 sanitizer_coverage_interface.inc(1.73 KB)
📄 sanitizer_coverage_libcdep_new.cpp(7.39 KB)
📄 sanitizer_coverage_win_dll_thunk.cpp(1.03 KB)
📄 sanitizer_coverage_win_dynamic_runtime_thunk.cpp(1.16 KB)
📄 sanitizer_coverage_win_sections.cpp(3.36 KB)
📄 sanitizer_coverage_win_weak_interception.cpp(1.17 KB)
📄 sanitizer_dbghelp.h(1.44 KB)
📄 sanitizer_deadlock_detector.h(13.28 KB)
📄 sanitizer_deadlock_detector1.cpp(5.6 KB)
📄 sanitizer_deadlock_detector2.cpp(10.84 KB)
📄 sanitizer_deadlock_detector_interface.h(2.66 KB)
📄 sanitizer_errno.cpp(1.09 KB)
📄 sanitizer_errno.h(1.3 KB)
📄 sanitizer_errno_codes.h(1.1 KB)
📄 sanitizer_file.cpp(6.24 KB)
📄 sanitizer_file.h(3.67 KB)
📄 sanitizer_flag_parser.cpp(5.55 KB)
📄 sanitizer_flag_parser.h(5.71 KB)
📄 sanitizer_flags.cpp(3.95 KB)
📄 sanitizer_flags.h(2.13 KB)
📄 sanitizer_flags.inc(12.73 KB)
📄 sanitizer_freebsd.h(3.31 KB)
📄 sanitizer_fuchsia.cpp(16.58 KB)
📄 sanitizer_fuchsia.h(1.03 KB)
📄 sanitizer_getauxval.h(1.73 KB)
📄 sanitizer_glibc_version.h(748 B)
📄 sanitizer_hash.h(1.04 KB)
📄 sanitizer_interceptors_ioctl_netbsd.inc(68.81 KB)
📄 sanitizer_interface_internal.h(5.28 KB)
📄 sanitizer_internal_defs.h(14.28 KB)
📄 sanitizer_lfstack.h(2.08 KB)
📄 sanitizer_libc.cpp(7.21 KB)
📄 sanitizer_libc.h(3.23 KB)
📄 sanitizer_libignore.cpp(4.24 KB)
📄 sanitizer_libignore.h(3.5 KB)
📄 sanitizer_linux.cpp(71.58 KB)
📄 sanitizer_linux.h(5.47 KB)
📄 sanitizer_linux_libcdep.cpp(25.67 KB)
📄 sanitizer_linux_s390.cpp(6.91 KB)
📄 sanitizer_list.h(3.81 KB)
📄 sanitizer_local_address_space_view.h(3.67 KB)
📄 sanitizer_mac.cpp(38.67 KB)
📄 sanitizer_mac.h(2.49 KB)
📄 sanitizer_mac_libcdep.cpp(968 B)
📄 sanitizer_malloc_mac.inc(13.06 KB)
📄 sanitizer_mutex.h(5.17 KB)
📄 sanitizer_netbsd.cpp(9.95 KB)
📄 sanitizer_openbsd.cpp(3.17 KB)
📄 sanitizer_persistent_allocator.cpp(687 B)
📄 sanitizer_persistent_allocator.h(2.31 KB)
📄 sanitizer_placement_new.h(885 B)
📄 sanitizer_platform.h(10.11 KB)
📄 sanitizer_platform_interceptors.h(24.93 KB)
📄 sanitizer_platform_limits_freebsd.cpp(19.79 KB)
📄 sanitizer_platform_limits_freebsd.h(18.41 KB)
📄 sanitizer_platform_limits_linux.cpp(3.32 KB)
📄 sanitizer_platform_limits_netbsd.cpp(109.73 KB)
📄 sanitizer_platform_limits_netbsd.h(81.54 KB)
📄 sanitizer_platform_limits_openbsd.cpp(8.69 KB)
📄 sanitizer_platform_limits_openbsd.h(8.68 KB)
📄 sanitizer_platform_limits_posix.cpp(48.89 KB)
📄 sanitizer_platform_limits_posix.h(40.65 KB)
📄 sanitizer_platform_limits_solaris.cpp(11.93 KB)
📄 sanitizer_platform_limits_solaris.h(12.26 KB)
📄 sanitizer_posix.cpp(11.93 KB)
📄 sanitizer_posix.h(5.14 KB)
📄 sanitizer_posix_libcdep.cpp(16.21 KB)
📄 sanitizer_printf.cpp(12.07 KB)
📄 sanitizer_procmaps.h(2.93 KB)
📄 sanitizer_procmaps_bsd.cpp(3.81 KB)
📄 sanitizer_procmaps_common.cpp(5.27 KB)
📄 sanitizer_procmaps_fuchsia.cpp(2.51 KB)
📄 sanitizer_procmaps_linux.cpp(2.9 KB)
📄 sanitizer_procmaps_mac.cpp(13.7 KB)
📄 sanitizer_procmaps_solaris.cpp(2.18 KB)
📄 sanitizer_ptrauth.h(720 B)
📄 sanitizer_quarantine.h(9.57 KB)
📄 sanitizer_report_decorator.h(1.89 KB)
📄 sanitizer_ring_buffer.h(4.7 KB)
📄 sanitizer_rtems.cpp(7.61 KB)
📄 sanitizer_rtems.h(772 B)
📄 sanitizer_signal_interceptors.inc(2.89 KB)
📄 sanitizer_solaris.cpp(6.6 KB)
📄 sanitizer_stackdepot.cpp(4.54 KB)
📄 sanitizer_stackdepot.h(2.13 KB)
📄 sanitizer_stackdepotbase.h(5.58 KB)
📄 sanitizer_stacktrace.cpp(4.58 KB)
📄 sanitizer_stacktrace.h(5.65 KB)
📄 sanitizer_stacktrace_libcdep.cpp(5.54 KB)
📄 sanitizer_stacktrace_printer.cpp(9.08 KB)
📄 sanitizer_stacktrace_printer.h(3.08 KB)
📄 sanitizer_stacktrace_sparc.cpp(3.05 KB)
📄 sanitizer_stoptheworld.h(2.34 KB)
📄 sanitizer_stoptheworld_fuchsia.cpp(1.28 KB)
📄 sanitizer_stoptheworld_linux_libcdep.cpp(20.8 KB)
📄 sanitizer_stoptheworld_mac.cpp(5.29 KB)
📄 sanitizer_stoptheworld_netbsd_libcdep.cpp(11.02 KB)
📄 sanitizer_suppressions.cpp(5.67 KB)
📄 sanitizer_suppressions.h(1.69 KB)
📄 sanitizer_symbolizer.cpp(3.65 KB)
📄 sanitizer_symbolizer.h(6.62 KB)
📄 sanitizer_symbolizer_fuchsia.h(1.56 KB)
📄 sanitizer_symbolizer_internal.h(5.8 KB)
📄 sanitizer_symbolizer_libbacktrace.cpp(6.1 KB)
📄 sanitizer_symbolizer_libbacktrace.h(1.49 KB)
📄 sanitizer_symbolizer_libcdep.cpp(17.45 KB)
📄 sanitizer_symbolizer_mac.cpp(8.48 KB)
📄 sanitizer_symbolizer_mac.h(1.37 KB)
📄 sanitizer_symbolizer_markup.cpp(5.39 KB)
📄 sanitizer_symbolizer_posix_libcdep.cpp(16.5 KB)
📄 sanitizer_symbolizer_report.cpp(10.01 KB)
📄 sanitizer_symbolizer_rtems.h(1.56 KB)
📄 sanitizer_symbolizer_win.cpp(11.59 KB)
📄 sanitizer_syscall_generic.inc(1.06 KB)
📄 sanitizer_syscall_linux_aarch64.inc(4.58 KB)
📄 sanitizer_syscall_linux_arm.inc(4.58 KB)
📄 sanitizer_syscall_linux_x86_64.inc(3.07 KB)
📄 sanitizer_syscalls_netbsd.inc(120.97 KB)
📄 sanitizer_termination.cpp(2.86 KB)
📄 sanitizer_thread_registry.cpp(10.31 KB)
📄 sanitizer_thread_registry.h(5.44 KB)
📄 sanitizer_tls_get_addr.cpp(5.29 KB)
📄 sanitizer_tls_get_addr.h(2.21 KB)
📄 sanitizer_type_traits.cpp(708 B)
📄 sanitizer_type_traits.h(1.49 KB)
📄 sanitizer_unwind_linux_libcdep.cpp(6.13 KB)
📄 sanitizer_unwind_win.cpp(2.41 KB)
📄 sanitizer_vector.h(2.57 KB)
📄 sanitizer_win.cpp(33.3 KB)
📄 sanitizer_win.h(851 B)
📄 sanitizer_win_defs.h(7.23 KB)
📄 sanitizer_win_dll_thunk.cpp(3.41 KB)
📄 sanitizer_win_dll_thunk.h(11.13 KB)
📄 sanitizer_win_dynamic_runtime_thunk.cpp(1.16 KB)
📄 sanitizer_win_weak_interception.cpp(3.49 KB)
📄 sanitizer_win_weak_interception.h(1.64 KB)
📁 symbolizer
📄 weak_symbols.txt(230 B)

Editing: sanitizer_netbsd.cpp

//===-- sanitizer_netbsd.cpp ----------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file is shared between Sanitizer run-time libraries and implements
// NetBSD-specific functions from sanitizer_libc.h.
//===----------------------------------------------------------------------===//

#include "sanitizer_platform.h"

#if SANITIZER_NETBSD

#include "sanitizer_common.h"
#include "sanitizer_flags.h"
#include "sanitizer_getauxval.h"
#include "sanitizer_internal_defs.h"
#include "sanitizer_libc.h"
#include "sanitizer_linux.h"
#include "sanitizer_mutex.h"
#include "sanitizer_placement_new.h"
#include "sanitizer_procmaps.h"

#include <sys/param.h>
#include <sys/types.h>

#include <sys/exec.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/sysctl.h>
#include <sys/time.h>

#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <link.h>
#include <lwp.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <ucontext.h>
#include <unistd.h>

extern "C" void *__mmap(void *, size_t, int, int, int, int,
                        off_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int __sysctl(const int *, unsigned int, void *, size_t *,
                        const void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys_close(int) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys_open(const char *, int, ...) SANITIZER_WEAK_ATTRIBUTE;
extern "C" ssize_t _sys_read(int, void *, size_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" ssize_t _sys_write(int, const void *,
                              size_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int __ftruncate(int, int, off_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" ssize_t _sys_readlink(const char *, char *,
                                 size_t) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys_sched_yield() SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys___nanosleep50(const void *,
                                  void *) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys_execve(const char *, char *const[],
                           char *const[]) SANITIZER_WEAK_ATTRIBUTE;
extern "C" off_t __lseek(int, int, off_t, int) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int __fork() SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys___sigprocmask14(int, const void *,
                                    void *) SANITIZER_WEAK_ATTRIBUTE;
extern "C" int _sys___wait450(int wpid, int *, int,
                              void *) SANITIZER_WEAK_ATTRIBUTE;

namespace __sanitizer {

static void *GetRealLibcAddress(const char *symbol) {
  void *real = dlsym(RTLD_NEXT, symbol);
  if (!real)
    real = dlsym(RTLD_DEFAULT, symbol);
  if (!real) {
    Printf("GetRealLibcAddress failed for symbol=%s", symbol);
    Die();
  }
  return real;
}

#define _REAL(func, ...) real##_##func(__VA_ARGS__)
#define DEFINE__REAL(ret_type, func, ...)                              \
  static ret_type (*real_##func)(__VA_ARGS__) = NULL;                  \
  if (!real_##func) {                                                  \
    real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
  }                                                                    \
  CHECK(real_##func);

// --------------- sanitizer_libc.h
uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                   u64 offset) {
  CHECK(&__mmap);
  return (uptr)__mmap(addr, length, prot, flags, fd, 0, offset);
}

uptr internal_munmap(void *addr, uptr length) {
  DEFINE__REAL(int, munmap, void *a, uptr b);
  return _REAL(munmap, addr, length);
}

int internal_mprotect(void *addr, uptr length, int prot) {
  DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
  return _REAL(mprotect, addr, length, prot);
}

uptr internal_close(fd_t fd) {
  CHECK(&_sys_close);
  return _sys_close(fd);
}

uptr internal_open(const char *filename, int flags) {
  CHECK(&_sys_open);
  return _sys_open(filename, flags);
}

uptr internal_open(const char *filename, int flags, u32 mode) {
  CHECK(&_sys_open);
  return _sys_open(filename, flags, mode);
}

uptr internal_read(fd_t fd, void *buf, uptr count) {
  sptr res;
  CHECK(&_sys_read);
  HANDLE_EINTR(res, (sptr)_sys_read(fd, buf, (size_t)count));
  return res;
}

uptr internal_write(fd_t fd, const void *buf, uptr count) {
  sptr res;
  CHECK(&_sys_write);
  HANDLE_EINTR(res, (sptr)_sys_write(fd, buf, count));
  return res;
}

uptr internal_ftruncate(fd_t fd, uptr size) {
  sptr res;
  CHECK(&__ftruncate);
  HANDLE_EINTR(res, __ftruncate(fd, 0, (s64)size));
  return res;
}

uptr internal_stat(const char *path, void *buf) {
  DEFINE__REAL(int, __stat50, const char *a, void *b);
  return _REAL(__stat50, path, buf);
}

uptr internal_lstat(const char *path, void *buf) {
  DEFINE__REAL(int, __lstat50, const char *a, void *b);
  return _REAL(__lstat50, path, buf);
}

uptr internal_fstat(fd_t fd, void *buf) {
  DEFINE__REAL(int, __fstat50, int a, void *b);
  return _REAL(__fstat50, fd, buf);
}

uptr internal_filesize(fd_t fd) {
  struct stat st;
  if (internal_fstat(fd, &st))
    return -1;
  return (uptr)st.st_size;
}

uptr internal_dup(int oldfd) {
  DEFINE__REAL(int, dup, int a);
  return _REAL(dup, oldfd);
}

uptr internal_dup2(int oldfd, int newfd) {
  DEFINE__REAL(int, dup2, int a, int b);
  return _REAL(dup2, oldfd, newfd);
}

uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
  CHECK(&_sys_readlink);
  return (uptr)_sys_readlink(path, buf, bufsize);
}

uptr internal_unlink(const char *path) {
  DEFINE__REAL(int, unlink, const char *a);
  return _REAL(unlink, path);
}

uptr internal_rename(const char *oldpath, const char *newpath) {
  DEFINE__REAL(int, rename, const char *a, const char *b);
  return _REAL(rename, oldpath, newpath);
}

uptr internal_sched_yield() {
  CHECK(&_sys_sched_yield);
  return _sys_sched_yield();
}

void internal__exit(int exitcode) {
  DEFINE__REAL(void, _exit, int a);
  _REAL(_exit, exitcode);
  Die();  // Unreachable.
}

unsigned int internal_sleep(unsigned int seconds) {
  struct timespec ts;
  ts.tv_sec = seconds;
  ts.tv_nsec = 0;
  CHECK(&_sys___nanosleep50);
  int res = _sys___nanosleep50(&ts, &ts);
  if (res)
    return ts.tv_sec;
  return 0;
}

uptr internal_execve(const char *filename, char *const argv[],
                     char *const envp[]) {
  CHECK(&_sys_execve);
  return _sys_execve(filename, argv, envp);
}

tid_t GetTid() {
  DEFINE__REAL(int, _lwp_self);
  return _REAL(_lwp_self);
}

int TgKill(pid_t pid, tid_t tid, int sig) {
  DEFINE__REAL(int, _lwp_kill, int a, int b);
  (void)pid;
  return _REAL(_lwp_kill, tid, sig);
}

u64 NanoTime() {
  timeval tv;
  DEFINE__REAL(int, __gettimeofday50, void *a, void *b);
  internal_memset(&tv, 0, sizeof(tv));
  _REAL(__gettimeofday50, &tv, 0);
  return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
}

uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
  DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
  return _REAL(__clock_gettime50, clk_id, tp);
}

uptr internal_ptrace(int request, int pid, void *addr, int data) {
  DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
  return _REAL(ptrace, request, pid, addr, data);
}

uptr internal_waitpid(int pid, int *status, int options) {
  CHECK(&_sys___wait450);
  return _sys___wait450(pid, status, options, 0 /* rusage */);
}

uptr internal_getpid() {
  DEFINE__REAL(int, getpid);
  return _REAL(getpid);
}

uptr internal_getppid() {
  DEFINE__REAL(int, getppid);
  return _REAL(getppid);
}

int internal_dlinfo(void *handle, int request, void *p) {
  DEFINE__REAL(int, dlinfo, void *a, int b, void *c);
  return _REAL(dlinfo, handle, request, p);
}

uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
  DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
  return _REAL(__getdents30, fd, dirp, count);
}

uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
  CHECK(&__lseek);
  return __lseek(fd, 0, offset, whence);
}

uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
  Printf("internal_prctl not implemented for NetBSD");
  Die();
  return 0;
}

uptr internal_sigaltstack(const void *ss, void *oss) {
  DEFINE__REAL(int, __sigaltstack14, const void *a, void *b);
  return _REAL(__sigaltstack14, ss, oss);
}

int internal_fork() {
  CHECK(&__fork);
  return __fork();
}

int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                    uptr *oldlenp, const void *newp, uptr newlen) {
  CHECK(&__sysctl);
  return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
}

int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,
                          const void *newp, uptr newlen) {
  DEFINE__REAL(int, sysctlbyname, const char *a, void *b, size_t *c,
               const void *d, size_t e);
  return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
               (size_t)newlen);
}

uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
                          __sanitizer_sigset_t *oldset) {
  CHECK(&_sys___sigprocmask14);
  return _sys___sigprocmask14(how, set, oldset);
}

void internal_sigfillset(__sanitizer_sigset_t *set) {
  DEFINE__REAL(int, __sigfillset14, const void *a);
  (void)_REAL(__sigfillset14, set);
}

void internal_sigemptyset(__sanitizer_sigset_t *set) {
  DEFINE__REAL(int, __sigemptyset14, const void *a);
  (void)_REAL(__sigemptyset14, set);
}

void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
  DEFINE__REAL(int, __sigdelset14, const void *a, int b);
  (void)_REAL(__sigdelset14, set, signo);
}

uptr internal_clone(int (*fn)(void *), void *child_stack, int flags,
                    void *arg) {
  DEFINE__REAL(int, clone, int (*a)(void *b), void *c, int d, void *e);

return _REAL(clone, fn, child_stack, flags, arg);
}

}  // namespace __sanitizer

#endif

003 File Manager

Editing: sanitizer_netbsd.cpp

Upload File

Create Folder