coregrind/vg_preloaded.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Client-space code for the core.               vg_preloaded.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2017 Julian Seward
  11       jseward@acm.org
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, see <http://www.gnu.org/licenses/>.
  25
  26    The GNU General Public License is contained in the file COPYING.
  27 */
  28
  29
  30 /* ---------------------------------------------------------------------
  31    ALL THE CODE IN THIS FILE RUNS ON THE SIMULATED CPU.
  32
  33    These functions are not called directly - they're the targets of code
  34    redirection or load notifications (see pub_core_redir.h for info).
  35    They're named weirdly so that the intercept code can find them when the
  36    shared object is initially loaded.
  37
  38    Note that this filename has the "vg_" prefix because it can appear
  39    in stack traces, and the "vg_" makes it a little clearer that it
  40    originates from Valgrind.
  41    ------------------------------------------------------------------ */
  42
  43 #include "pub_core_basics.h"
  44 #include "pub_core_clreq.h"
  45 #include "pub_core_debuginfo.h"  // Needed for pub_core_redir.h
  46 #include "pub_core_redir.h"      // For VG_NOTIFY_ON_LOAD
  47
  48 #ifdef HAVE_HEADER_FEATURES_H
  49 #include <features.h>
  50 #endif
  51
  52 #if !defined(VGO_darwin)
  53 /* Instruct GDB via a .debug_gdb_scripts section to load the valgrind and tool
  54    front-end commands.  */
  55 /* Note: The "MS" section flags are to remove duplicates.  */
  56 #define DEFINE_GDB_PY_SCRIPT(script_name) \
  57   asm("\
  58 .pushsection \".debug_gdb_scripts\", \"MS\",@progbits,1\n\
  59 .byte 1 /* Python */\n\
  60 .asciz \"" script_name "\"\n\
  61 .popsection \n\
  62 ");
  63
  64 DEFINE_GDB_PY_SCRIPT(VG_LIBDIR "/valgrind-monitor.py")
  65 #endif
  66
  67 #if defined(VGO_linux) || defined(VGO_solaris) || defined(VGO_freebsd)
  68
  69 /* ---------------------------------------------------------------------
  70    Hook for running __gnu_cxx::__freeres() and __libc_freeres() once
  71    the program exits.
  72    ------------------------------------------------------------------ */
  73
  74 void VG_NOTIFY_ON_LOAD(freeres)(Vg_FreeresToRun to_run);
  75 void VG_NOTIFY_ON_LOAD(freeres)(Vg_FreeresToRun to_run)
  76 {
  77 #  if !defined(__UCLIBC__) && !defined(MUSL_LIBC) \
  78       && !defined(VGPV_arm_linux_android) \
  79       && !defined(VGPV_x86_linux_android) \
  80       && !defined(VGPV_mips32_linux_android) \
  81       && !defined(VGPV_arm64_linux_android)
  82
  83    /* g++ mangled __gnu_cxx::__freeres yields -> _ZN9__gnu_cxx9__freeresEv */
  84    extern void _ZN9__gnu_cxx9__freeresEv(void) __attribute__((weak));
  85    if (((to_run & VG_RUN__GNU_CXX__FREERES) != 0) &&
  86        (_ZN9__gnu_cxx9__freeresEv != NULL)) {
  87       _ZN9__gnu_cxx9__freeresEv();
  88    }
  89
  90    extern void __libc_freeres(void) __attribute__((weak));
  91    if (((to_run & VG_RUN__LIBC_FREERES) != 0) &&
  92        (__libc_freeres != NULL)) {
  93       __libc_freeres();
  94    }
  95
  96 #  endif
  97
  98    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREERES_DONE, 0, 0, 0, 0, 0);
  99    /*NOTREACHED*/
 100    *(volatile int *)0 = 'x';
 101 }
 102
 103 #endif // VGO_linux || VGO_solaris
 104
 105 #if defined(VGO_linux)
 106
 107 /* ---------------------------------------------------------------------
 108    Wrapper for indirect functions which need to be redirected.
 109    ------------------------------------------------------------------ */
 110
 111 void * VG_NOTIFY_ON_LOAD(ifunc_wrapper) (void);
 112 void * VG_NOTIFY_ON_LOAD(ifunc_wrapper) (void)
 113 {
 114     OrigFn fn;
 115     Addr result = 0;
 116     Addr fnentry;
 117
 118     /* Call the original indirect function and get it's result */
 119     VALGRIND_GET_ORIG_FN(fn);
 120     CALL_FN_W_v(result, fn);
 121
 122 #if defined(VGP_ppc64be_linux)
 123    /* ppc64be uses function descriptors, so get the actual function entry
 124       address for the client request, but return the function descriptor
 125       from this function.
 126       result points to the function descriptor, which starts with the
 127       function entry. */
 128     fnentry = *(Addr*)result;
 129 #else
 130     fnentry = result;
 131 #endif
 132
 133     /* Ask the valgrind core running on the real CPU (as opposed to this
 134        code which runs on the emulated CPU) to update the redirection that
 135        led to this function. This client request eventually gives control to
 136        the function VG_(redir_add_ifunc_target) in m_redir.c  */
 137     VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__ADD_IFUNC_TARGET,
 138                                     fn.nraddr, fnentry, 0, 0, 0);
 139     return (void*)result;
 140 }
 141
 142 #elif defined(VGO_darwin)
 143
 144 #include "config.h" /* VERSION */
 145
 146 /* ---------------------------------------------------------------------
 147    Darwin crash log hints
 148    ------------------------------------------------------------------ */
 149
 150 /* This string will be inserted into crash logs, so crashes while
 151    running under Valgrind can be distinguished from other crashes. */
 152 __private_extern__ const char *__crashreporter_info__ = "Instrumented by Valgrind " VERSION;
 153
 154 /* ---------------------------------------------------------------------
 155    Darwin environment cleanup
 156    ------------------------------------------------------------------ */
 157
 158 /* Scrubbing DYLD_INSERT_LIBRARIES from envp during exec is insufficient,
 159    as there are other ways to launch a process with environment that
 160    valgrind can't catch easily (i.e. launchd).
 161    Instead, scrub DYLD_INSERT_LIBRARIES from the parent process once
 162    dyld is done loading vg_preload.so.
 163 */
 164 #include <string.h>
 165 #include <crt_externs.h>
 166
 167 // GrP fixme copied from m_libcproc
 168 static void env_unsetenv ( HChar **env, const HChar *varname )
 169 {
 170    HChar **from;
 171    HChar **to = NULL;
 172    Int len = strlen(varname);
 173
 174    for (from = to = env; from && *from; from++) {
 175       if (!(strncmp(varname, *from, len) == 0 && (*from)[len] == '=')) {
 176          *to = *from;
 177          to++;
 178       }
 179    }
 180    *(to++) = *(from++);
 181    /* fix the 4th "char* apple" pointer (aka. executable path pointer) */
 182    *(to++) = *(from++);
 183    *to = NULL;
 184 }
 185
 186 static void vg_cleanup_env(void)  __attribute__((constructor));
 187 static void vg_cleanup_env(void)
 188 {
 189     HChar **envp = (HChar**)*_NSGetEnviron();
 190     env_unsetenv(envp, "VALGRIND_LAUNCHER");
 191     env_unsetenv(envp, "DYLD_SHARED_REGION");
 192     // GrP fixme should be more like mash_colon_env()
 193     env_unsetenv(envp, "DYLD_INSERT_LIBRARIES");
 194 }
 195
 196 /* ---------------------------------------------------------------------
 197    Darwin arc4random (rdar://6166275)
 198    ------------------------------------------------------------------ */
 199
 200 #include <fcntl.h>
 201 #include <unistd.h>
 202
 203 int VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random)(void);
 204 int VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random)(void)
 205 {
 206     static int rnd = -1;
 207     int result;
 208
 209     if (rnd < 0) rnd = open("/dev/random", O_RDONLY);
 210
 211     read(rnd, &result, sizeof(result));
 212     return result;
 213 }
 214
 215 void VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random_stir)(void);
 216 void VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random_stir)(void)
 217 {
 218     // do nothing
 219 }
 220
 221 void VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random_addrandom)(unsigned char *dat, int datlen);
 222 void VG_REPLACE_FUNCTION_ZU(libSystemZdZaZddylib, arc4random_addrandom)(unsigned char *dat, int datlen)
 223 {
 224     // do nothing
 225     // GrP fixme ought to check [dat..dat+datlen) is defined
 226     // but don't care if it's initialized
 227 }
 228
 229 #elif defined(VGO_freebsd)
 230
 231 // nothing specific currently
 232
 233 #elif defined(VGO_solaris)
 234
 235 /* Declare the errno and environ symbols weakly in case the client is not
 236    linked against libc. In such a case it also cannot run replacement
 237    functions for set_error() and spawnveg() where these two variables are
 238    needed so this is ok. */
 239 __attribute__((weak)) extern int errno;
 240 __attribute__((weak)) extern char **environ;
 241
 242 #include <assert.h>
 243 #include <errno.h>
 244 #include <spawn.h>
 245 #include <sys/syscall.h>
 246 #include <sys/signal.h>
 247 #include <unistd.h>
 248
 249 /* Replace function block_all_signals() from libc. When the client program is
 250    not running under valgrind, the function blocks all signals by setting
 251    sc_sigblock flag in the schedctl control block. When run under Valgrind
 252    this would bypass Valgrind's syscall and signal machinery.
 253    Valgrind's signal machinery needs to retain control over which signals are
 254    blocked and which not (see m_signals.c and m_scheduler/scheduler.c for more
 255    information - typically synchronous signals should not be blocked).
 256    Therefore this function replacement emulates lwp_sigmask syscall.
 257 */
 258 void VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, block_all_signals)(/*ulwp_t*/ void *self);
 259 void VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, block_all_signals)(/*ulwp_t*/ void *self)
 260 {
 261    syscall(SYS_lwp_sigmask, SIG_SETMASK, ~0U, ~0U, ~0U, ~0U);
 262 }
 263
 264 /* Replace functions get_error() and set_error() in libc. These functions are
 265    internal to the library and are used to work with an error value returned
 266    by posix_spawn() (when it is implemented using vfork()). A child calls
 267    set_error() to set an error code and the parent then calls get_error() to
 268    read it. Accessor functions are used so these trivial store+load operations
 269    are not changed by the compiler in any way.
 270
 271    Since Valgrind translates vfork() to a normal fork(), calling set_error()
 272    by the child would have no effect on the error value in the parent so
 273    something must be done to fix this problem.
 274
 275    A pipe is created between a child and its parent in the forksys pre-wrapper
 276    when a vfork() is encountered. The child's end of the pipe is closed when
 277    the child exits or execs (because close-on-exec is set on the file
 278    descriptor). Valgrind (the parent) waits on the child's end of the pipe to
 279    be closed which preserves the vfork() behaviour that the parent process is
 280    suspended while the child is using its resources.
 281
 282    The pipe is then used to send an eventual error code set by the child in
 283    posix_spawn() to the parent. If there is any error Valgrind returns it as
 284    an error from the vfork() syscall. This means the syscall can return errors
 285    that it would normally never return but this is not a problem in practice
 286    because any error is directly propagated as a return code from
 287    posix_spawn().
 288
 289    Address of vg_vfork_fildes is found by Valgrind when debug information for
 290    vgpreload_core.so is being processed. A value of this variable is set in
 291    the forksys pre-wrapper before a fork() call is made and set back to -1
 292    before returning from the wrapper by the parent.
 293
 294    Newer Solaris versions introduce the spawn syscall and posix_spawn() is
 295    implemented using it. The redirect is not needed for these versions.
 296 */
 297 int vg_vfork_fildes = -1;
 298
 299 int VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, get_error)(int *errp);
 300 int VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, get_error)(int *errp)
 301 {
 302    /* Always return 0 when the parent tries to call get_error(). Any error
 303       from the child is returned directly as an error from the vfork child.
 304       Value pointed by errp is initialized only by the child so not
 305       redirecting this function would mean that the parent gets an
 306       uninitialized/garbage value when it calls this function. */
 307    return 0;
 308 }
 309
 310 int VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, set_error)(int *errp, int err);
 311 int VG_REPLACE_FUNCTION_ZU(VG_Z_LIBC_SONAME, set_error)(int *errp, int err)
 312 {
 313    *errp = err;
 314
 315    /* Libc should always call set_error() only after doing a vfork() syscall
 316       in posix_spawn(). The forksys pre-wrapper saves a descriptor of the
 317       child's end of the pipe in vg_vfork_fildes so it is an error if it is
 318       not a valid file descriptor at this point. */
 319    assert(vg_vfork_fildes >= 0);
 320    /* Current protocol between this function and the forksys pre-wrapper
 321       allows to send only errors in range [0, 255] (one byte values). */
 322    assert(err >= 0 && err <= 0xff);
 323
 324    if (err != 0) {
 325       unsigned char w = (unsigned char)(err & 0xff);
 326       ssize_t res;
 327       do {
 328          res = write(vg_vfork_fildes, &w, 1);
 329          assert(res == 1 || (errno == EINTR || errno == ERESTART));
 330       } while (res != 1);
 331    }
 332
 333    return err;
 334 }
 335
 336 /* Replace spawnveg() in libast.so.1. This function is used by ksh to spawn
 337    new processes. The library has a build time option to select between
 338    several variants of this function based on behaviour of vfork() and
 339    posix_spawn() on the system for which the library is being compiled.
 340    Unfortunately, Solaris and illumos use the real vfork() variant which does
 341    not work correctly with the vfork() -> fork() translation done by Valgrind
 342    (see the forksys pre-wrapper for details). Therefore the function is
 343    replaced here with an implementation that uses posix_spawn(). This
 344    replacement can be removed when a configuration of libast in Solaris and
 345    illumos is changed to use the posix_spawn() implementation.
 346 */
 347 pid_t VG_REPLACE_FUNCTION_ZU(libastZdsoZd1, spawnveg)(const char *command,
 348                                                       char **argv,
 349                                                       char **envv,
 350                                                       pid_t pgid);
 351 pid_t VG_REPLACE_FUNCTION_ZU(libastZdsoZd1, spawnveg)(const char *command,
 352                                                       char **argv,
 353                                                       char **envp,
 354                                                       pid_t pgid)
 355 {
 356    int err = 0;
 357    pid_t pid;
 358    posix_spawnattr_t attr;
 359    int attr_init_done = 0;
 360
 361    err = posix_spawnattr_init(&attr);
 362    if (err != 0)
 363       goto out;
 364    attr_init_done = 1;
 365
 366    err = posix_spawnattr_init(&attr);
 367    if (err != 0)
 368       goto out;
 369
 370    if (pgid != 0) {
 371       if (pgid <= 1)
 372          pgid = 0;
 373       err = posix_spawnattr_setpgroup(&attr, pgid);
 374       if (err != 0)
 375          goto out;
 376       err = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETPGROUP);
 377       if (err != 0)
 378          goto out;
 379    }
 380
 381    err = posix_spawn(&pid, command, NULL, &attr, argv, envp ? envp : environ);
 382
 383 out:
 384    if (attr_init_done)
 385       posix_spawnattr_destroy(&attr);
 386    if (err != 0) {
 387       errno = err;
 388       return -1;
 389    }
 390    return pid;
 391 }
 392
 393 #else
 394 #  error Unknown OS
 395 #endif
 396
 397 /*--------------------------------------------------------------------*/
 398 /*--- end                                                          ---*/
 399 /*--------------------------------------------------------------------*/