lib/sanitizer_common/sanitizer_common_interceptors.inc

   1 //===-- sanitizer_common_interceptors.inc -----------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Common function interceptors for tools like AddressSanitizer,
  11 // ThreadSanitizer, MemorySanitizer, etc.
  12 //
  13 // This file should be included into the tool's interceptor file,
  14 // which has to define it's own macros:
  15 //   COMMON_INTERCEPTOR_ENTER
  16 //   COMMON_INTERCEPTOR_READ_RANGE
  17 //   COMMON_INTERCEPTOR_WRITE_RANGE
  18 //   COMMON_INTERCEPTOR_FD_ACQUIRE
  19 //   COMMON_INTERCEPTOR_FD_RELEASE
  20 //   COMMON_INTERCEPTOR_SET_THREAD_NAME
  21 //===----------------------------------------------------------------------===//
  22 #include "interception/interception.h"
  23 #include "sanitizer_platform_interceptors.h"
  24
  25 #include <stdarg.h>
  26
  27 #if SANITIZER_INTERCEPT_READ
  28 INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
  29   void* ctx;
  30   COMMON_INTERCEPTOR_ENTER(ctx, read, fd, ptr, count);
  31   SSIZE_T res = REAL(read)(fd, ptr, count);
  32   if (res > 0)
  33     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
  34   if (res >= 0 && fd >= 0)
  35     COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
  36   return res;
  37 }
  38 # define INIT_READ INTERCEPT_FUNCTION(read)
  39 #else
  40 # define INIT_READ
  41 #endif
  42
  43 #if SANITIZER_INTERCEPT_PREAD
  44 INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
  45   void* ctx;
  46   COMMON_INTERCEPTOR_ENTER(ctx, pread, fd, ptr, count, offset);
  47   SSIZE_T res = REAL(pread)(fd, ptr, count, offset);
  48   if (res > 0)
  49     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
  50   if (res >= 0 && fd >= 0)
  51     COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
  52   return res;
  53 }
  54 # define INIT_PREAD INTERCEPT_FUNCTION(pread)
  55 #else
  56 # define INIT_PREAD
  57 #endif
  58
  59 #if SANITIZER_INTERCEPT_PREAD64
  60 INTERCEPTOR(SSIZE_T, pread64, int fd, void *ptr, SIZE_T count, OFF64_T offset) {
  61   void* ctx;
  62   COMMON_INTERCEPTOR_ENTER(ctx, pread64, fd, ptr, count, offset);
  63   SSIZE_T res = REAL(pread64)(fd, ptr, count, offset);
  64   if (res > 0)
  65     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, res);
  66   if (res >= 0 && fd >= 0)
  67     COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
  68   return res;
  69 }
  70 # define INIT_PREAD64 INTERCEPT_FUNCTION(pread64)
  71 #else
  72 # define INIT_PREAD64
  73 #endif
  74
  75 #if SANITIZER_INTERCEPT_WRITE
  76 INTERCEPTOR(SSIZE_T, write, int fd, void *ptr, SIZE_T count) {
  77   void* ctx;
  78   COMMON_INTERCEPTOR_ENTER(ctx, write, fd, ptr, count);
  79   if (fd >= 0)
  80     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
  81   SSIZE_T res = REAL(write)(fd, ptr, count);
  82   if (res > 0)
  83     COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
  84   return res;
  85 }
  86 # define INIT_WRITE INTERCEPT_FUNCTION(write)
  87 #else
  88 # define INIT_WRITE
  89 #endif
  90
  91 #if SANITIZER_INTERCEPT_PWRITE
  92 INTERCEPTOR(SSIZE_T, pwrite, int fd, void *ptr, SIZE_T count, OFF_T offset) {
  93   void* ctx;
  94   COMMON_INTERCEPTOR_ENTER(ctx, pwrite, fd, ptr, count, offset);
  95   if (fd >= 0)
  96     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
  97   SSIZE_T res = REAL(pwrite)(fd, ptr, count, offset);
  98   if (res > 0)
  99     COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
 100   return res;
 101 }
 102 # define INIT_PWRITE INTERCEPT_FUNCTION(pwrite)
 103 #else
 104 # define INIT_PWRITE
 105 #endif
 106
 107 #if SANITIZER_INTERCEPT_PWRITE64
 108 INTERCEPTOR(SSIZE_T, pwrite64, int fd, void *ptr, OFF64_T count,
 109             OFF64_T offset) {
 110   void* ctx;
 111   COMMON_INTERCEPTOR_ENTER(ctx, pwrite64, fd, ptr, count, offset);
 112   if (fd >= 0)
 113     COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd);
 114   SSIZE_T res = REAL(pwrite64)(fd, ptr, count, offset);
 115   if (res > 0)
 116     COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, res);
 117   return res;
 118 }
 119 # define INIT_PWRITE64 INTERCEPT_FUNCTION(pwrite64)
 120 #else
 121 # define INIT_PWRITE64
 122 #endif
 123
 124 #if SANITIZER_INTERCEPT_PRCTL
 125 INTERCEPTOR(int, prctl, int option,
 126             unsigned long arg2, unsigned long arg3,  // NOLINT
 127             unsigned long arg4, unsigned long arg5) {  // NOLINT
 128   void* ctx;
 129   COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);
 130   static const int PR_SET_NAME = 15;
 131   int res = REAL(prctl(option, arg2, arg3, arg4, arg5));
 132   if (option == PR_SET_NAME) {
 133     char buff[16];
 134     internal_strncpy(buff, (char*)arg2, 15);
 135     buff[15] = 0;
 136     COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, buff);
 137   }
 138   return res;
 139 }
 140 # define INIT_PRCTL INTERCEPT_FUNCTION(prctl)
 141 #else
 142 # define INIT_PRCTL
 143 #endif  // SANITIZER_INTERCEPT_PRCTL
 144
 145
 146 #if SANITIZER_INTERCEPT_SCANF
 147
 148 #include "sanitizer_common_interceptors_scanf.inc"
 149
 150 INTERCEPTOR(int, vscanf, const char *format, va_list ap) {  // NOLINT
 151   void* ctx;
 152   COMMON_INTERCEPTOR_ENTER(ctx, vscanf, format, ap);
 153   scanf_common(ctx, format, ap);
 154   int res = REAL(vscanf)(format, ap);  // NOLINT
 155   return res;
 156 }
 157
 158 INTERCEPTOR(int, vsscanf, const char *str, const char *format,  // NOLINT
 159     va_list ap) {
 160   void* ctx;
 161   COMMON_INTERCEPTOR_ENTER(ctx, vsscanf, str, format, ap);
 162   scanf_common(ctx, format, ap);
 163   int res = REAL(vsscanf)(str, format, ap);  // NOLINT
 164   // FIXME: read of str
 165   return res;
 166 }
 167
 168 INTERCEPTOR(int, vfscanf, void *stream, const char *format,  // NOLINT
 169     va_list ap) {
 170   void* ctx;
 171   COMMON_INTERCEPTOR_ENTER(ctx, vfscanf, stream, format, ap);
 172   scanf_common(ctx, format, ap);
 173   int res = REAL(vfscanf)(stream, format, ap);  // NOLINT
 174   return res;
 175 }
 176
 177 INTERCEPTOR(int, scanf, const char *format, ...) {  // NOLINT
 178   void* ctx;
 179   COMMON_INTERCEPTOR_ENTER(ctx, scanf, format);
 180   va_list ap;
 181   va_start(ap, format);
 182   int res = vscanf(format, ap);  // NOLINT
 183   va_end(ap);
 184   return res;
 185 }
 186
 187 INTERCEPTOR(int, fscanf, void* stream, const char *format, ...) {  // NOLINT
 188   void* ctx;
 189   COMMON_INTERCEPTOR_ENTER(ctx, fscanf, stream, format);
 190   va_list ap;
 191   va_start(ap, format);
 192   int res = vfscanf(stream, format, ap);  // NOLINT
 193   va_end(ap);
 194   return res;
 195 }
 196
 197 INTERCEPTOR(int, sscanf, const char *str, const char *format, ...) {  // NOLINT
 198   void* ctx;
 199   COMMON_INTERCEPTOR_ENTER(ctx, sscanf, str, format);  // NOLINT
 200   va_list ap;
 201   va_start(ap, format);
 202   int res = vsscanf(str, format, ap);  // NOLINT
 203   va_end(ap);
 204   return res;
 205 }
 206
 207 #define INIT_SCANF \
 208   INTERCEPT_FUNCTION(scanf);                    \
 209   INTERCEPT_FUNCTION(sscanf);  /* NOLINT */     \
 210   INTERCEPT_FUNCTION(fscanf);                   \
 211   INTERCEPT_FUNCTION(vscanf);                   \
 212   INTERCEPT_FUNCTION(vsscanf);                  \
 213   INTERCEPT_FUNCTION(vfscanf)
 214
 215 #else
 216 #define INIT_SCANF
 217 #endif
 218
 219 #define SANITIZER_COMMON_INTERCEPTORS_INIT \
 220   INIT_READ;                               \
 221   INIT_PREAD;                              \
 222   INIT_PREAD64;                            \
 223   INIT_PRCTL;                              \
 224   INIT_WRITE;                              \
 225   INIT_PWRITE;                             \
 226   INIT_PWRITE64;                           \
 227   INIT_SCANF;