coregrind/m_aspacemgr/aspacemgr-common.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- The address space manager: stuff common to all platforms     ---*/
   4 /*---                                                              ---*/
   5 /*---                                         m_aspacemgr-common.c ---*/
   6 /*--------------------------------------------------------------------*/
   7
   8 /*
   9    This file is part of Valgrind, a dynamic binary instrumentation
  10    framework.
  11
  12    Copyright (C) 2006-2013 OpenWorks LLP
  13       info@open-works.co.uk
  14
  15    This program is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation; either version 2 of the
  18    License, or (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  28    02111-1307, USA.
  29
  30    The GNU General Public License is contained in the file COPYING.
  31 */
  32
  33 /* *************************************************************
  34    DO NOT INCLUDE ANY OTHER FILES HERE.
  35    ADD NEW INCLUDES ONLY TO priv_aspacemgr.h
  36    AND THEN ONLY AFTER READING DIRE WARNINGS THERE TOO.
  37    ************************************************************* */
  38
  39 #include "priv_aspacemgr.h"
  40 #include "config.h"
  41
  42
  43 /*-----------------------------------------------------------------*/
  44 /*---                                                           ---*/
  45 /*--- Stuff to make aspacem almost completely independent of    ---*/
  46 /*--- the rest of Valgrind.                                     ---*/
  47 /*---                                                           ---*/
  48 /*-----------------------------------------------------------------*/
  49
  50 //--------------------------------------------------------------
  51 // Simple assert and assert-like fns, which avoid dependence on
  52 // m_libcassert, and hence on the entire debug-info reader swamp
  53
  54 __attribute__ ((noreturn))
  55 void ML_(am_exit)( Int status )
  56 {
  57    VG_(exit_now) (status);
  58 }
  59
  60 void ML_(am_barf) ( const HChar* what )
  61 {
  62    VG_(debugLog)(0, "aspacem", "Valgrind: FATAL: %s\n", what);
  63    VG_(debugLog)(0, "aspacem", "Exiting now.\n");
  64    ML_(am_exit)(1);
  65 }
  66
  67 void ML_(am_barf_toolow) ( const HChar* what )
  68 {
  69    VG_(debugLog)(0, "aspacem",
  70                     "Valgrind: FATAL: %s is too low.\n", what);
  71    VG_(debugLog)(0, "aspacem", "  Increase it and rebuild.  "
  72                                "Exiting now.\n");
  73    ML_(am_exit)(1);
  74 }
  75
  76 void ML_(am_assert_fail)( const HChar* expr,
  77                           const HChar* file,
  78                           Int line,
  79                           const HChar* fn )
  80 {
  81    VG_(debugLog)(0, "aspacem",
  82                     "Valgrind: FATAL: aspacem assertion failed:\n");
  83    VG_(debugLog)(0, "aspacem", "  %s\n", expr);
  84    VG_(debugLog)(0, "aspacem", "  at %s:%d (%s)\n", file,line,fn);
  85    VG_(debugLog)(0, "aspacem", "Exiting now.\n");
  86    ML_(am_exit)(1);
  87 }
  88
  89 Int ML_(am_getpid)( void )
  90 {
  91    SysRes sres = VG_(do_syscall0)(__NR_getpid);
  92    aspacem_assert(!sr_isError(sres));
  93    return sr_Res(sres);
  94 }
  95
  96
  97 //--------------------------------------------------------------
  98 // A simple sprintf implementation, so as to avoid dependence on
  99 // m_libcprint.
 100
 101 static void local_add_to_aspacem_sprintf_buf ( HChar c, void *p )
 102 {
 103    HChar** aspacem_sprintf_ptr = p;
 104    *(*aspacem_sprintf_ptr)++ = c;
 105 }
 106
 107 static
 108 UInt local_vsprintf ( HChar* buf, const HChar *format, va_list vargs )
 109 {
 110    Int ret;
 111    HChar *aspacem_sprintf_ptr = buf;
 112
 113    ret = VG_(debugLog_vprintf)
 114             ( local_add_to_aspacem_sprintf_buf,
 115               &aspacem_sprintf_ptr, format, vargs );
 116    local_add_to_aspacem_sprintf_buf('\0', &aspacem_sprintf_ptr);
 117
 118    return ret;
 119 }
 120
 121 UInt ML_(am_sprintf) ( HChar* buf, const HChar *format, ... )
 122 {
 123    UInt ret;
 124    va_list vargs;
 125
 126    va_start(vargs,format);
 127    ret = local_vsprintf(buf, format, vargs);
 128    va_end(vargs);
 129
 130    return ret;
 131 }
 132
 133
 134 //--------------------------------------------------------------
 135 // Direct access to a handful of syscalls.  This avoids dependence on
 136 // m_libc*.  THESE DO NOT UPDATE THE aspacem-internal DATA
 137 // STRUCTURES (SEGMENT ARRAY).  DO NOT USE THEM UNLESS YOU KNOW WHAT
 138 // YOU ARE DOING.
 139
 140 /* --- Pertaining to mappings --- */
 141
 142 /* Note: this is VG_, not ML_. */
 143 SysRes VG_(am_do_mmap_NO_NOTIFY)( Addr start, SizeT length, UInt prot,
 144                                   UInt flags, Int fd, Off64T offset)
 145 {
 146    SysRes res;
 147    aspacem_assert(VG_IS_PAGE_ALIGNED(offset));
 148
 149 #  if defined(VGP_arm64_linux)
 150    res = VG_(do_syscall6)(__NR3264_mmap, (UWord)start, length,
 151                          prot, flags, fd, offset);
 152 #  elif defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
 153         || defined(VGP_arm_linux)
 154    /* mmap2 uses 4096 chunks even if actual page size is bigger. */
 155    aspacem_assert((offset % 4096) == 0);
 156    res = VG_(do_syscall6)(__NR_mmap2, (UWord)start, length,
 157                           prot, flags, fd, offset / 4096);
 158 #  elif defined(VGP_amd64_linux) \
 159         || defined(VGP_ppc64be_linux)  || defined(VGP_ppc64le_linux) \
 160         || defined(VGP_s390x_linux) || defined(VGP_mips32_linux) \
 161         || defined(VGP_mips64_linux) || defined(VGP_arm64_linux) \
 162         || defined(VGP_tilegx_linux)
 163    res = VG_(do_syscall6)(__NR_mmap, (UWord)start, length,
 164                          prot, flags, fd, offset);
 165 #  elif defined(VGP_x86_darwin)
 166    if (fd == 0  &&  (flags & VKI_MAP_ANONYMOUS)) {
 167        fd = -1;  // MAP_ANON with fd==0 is EINVAL
 168    }
 169    res = VG_(do_syscall7)(__NR_mmap, (UWord)start, length,
 170                           prot, flags, fd, offset & 0xffffffff, offset >> 32);
 171 #  elif defined(VGP_amd64_darwin)
 172    if (fd == 0  &&  (flags & VKI_MAP_ANONYMOUS)) {
 173        fd = -1;  // MAP_ANON with fd==0 is EINVAL
 174    }
 175    res = VG_(do_syscall6)(__NR_mmap, (UWord)start, length,
 176                           prot, flags, (UInt)fd, offset);
 177 #  else
 178 #    error Unknown platform
 179 #  endif
 180    return res;
 181 }
 182
 183 static
 184 SysRes local_do_mprotect_NO_NOTIFY(Addr start, SizeT length, UInt prot)
 185 {
 186    return VG_(do_syscall3)(__NR_mprotect, (UWord)start, length, prot );
 187 }
 188
 189 SysRes ML_(am_do_munmap_NO_NOTIFY)(Addr start, SizeT length)
 190 {
 191    return VG_(do_syscall2)(__NR_munmap, (UWord)start, length );
 192 }
 193
 194 #if HAVE_MREMAP
 195 /* The following are used only to implement mremap(). */
 196
 197 SysRes ML_(am_do_extend_mapping_NO_NOTIFY)(
 198           Addr  old_addr,
 199           SizeT old_len,
 200           SizeT new_len
 201        )
 202 {
 203    /* Extend the mapping old_addr .. old_addr+old_len-1 to have length
 204       new_len, WITHOUT moving it.  If it can't be extended in place,
 205       fail. */
 206 #  if defined(VGO_linux)
 207    return VG_(do_syscall5)(
 208              __NR_mremap,
 209              old_addr, old_len, new_len,
 210              0/*flags, meaning: must be at old_addr, else FAIL */,
 211              0/*new_addr, is ignored*/
 212           );
 213 #  else
 214 #    error Unknown OS
 215 #  endif
 216 }
 217
 218 SysRes ML_(am_do_relocate_nooverlap_mapping_NO_NOTIFY)(
 219           Addr old_addr, Addr old_len,
 220           Addr new_addr, Addr new_len
 221        )
 222 {
 223    /* Move the mapping old_addr .. old_addr+old_len-1 to the new
 224       location and with the new length.  Only needs to handle the case
 225       where the two areas do not overlap, neither length is zero, and
 226       all args are page aligned. */
 227 #  if defined(VGO_linux)
 228    return VG_(do_syscall5)(
 229              __NR_mremap,
 230              old_addr, old_len, new_len,
 231              VKI_MREMAP_MAYMOVE|VKI_MREMAP_FIXED/*move-or-fail*/,
 232              new_addr
 233           );
 234 #  else
 235 #    error Unknown OS
 236 #  endif
 237 }
 238
 239 #endif
 240
 241 /* --- Pertaining to files --- */
 242
 243 SysRes ML_(am_open) ( const HChar* pathname, Int flags, Int mode )
 244 {
 245 #  if defined(VGP_arm64_linux)
 246    /* ARM64 wants to use __NR_openat rather than __NR_open. */
 247    SysRes res = VG_(do_syscall4)(__NR_openat,
 248                                  VKI_AT_FDCWD, (UWord)pathname, flags, mode);
 249 #  elif defined(VGP_tilegx_linux)
 250    SysRes res = VG_(do_syscall4)(__NR_openat, VKI_AT_FDCWD, (UWord)pathname,
 251                                  flags, mode);
 252 #  else
 253    SysRes res = VG_(do_syscall3)(__NR_open, (UWord)pathname, flags, mode);
 254 #  endif
 255    return res;
 256 }
 257
 258 Int ML_(am_read) ( Int fd, void* buf, Int count)
 259 {
 260    SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count);
 261    return sr_isError(res) ? -1 : sr_Res(res);
 262 }
 263
 264 void ML_(am_close) ( Int fd )
 265 {
 266    (void)VG_(do_syscall1)(__NR_close, fd);
 267 }
 268
 269 Int ML_(am_readlink)(const HChar* path, HChar* buf, UInt bufsiz)
 270 {
 271    SysRes res;
 272 #  if defined(VGP_arm64_linux)
 273    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD,
 274                                            (UWord)path, (UWord)buf, bufsiz);
 275 #  elif defined(VGP_tilegx_linux)
 276    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD, (UWord)path,
 277                           (UWord)buf, bufsiz);
 278 #  else
 279    res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz);
 280 #  endif
 281    return sr_isError(res) ? -1 : sr_Res(res);
 282 }
 283
 284 Int ML_(am_fcntl) ( Int fd, Int cmd, Addr arg )
 285 {
 286 #  if defined(VGO_linux)
 287    SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg);
 288 #  elif defined(VGO_darwin)
 289    SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg);
 290 #  else
 291 #  error "Unknown OS"
 292 #  endif
 293    return sr_isError(res) ? -1 : sr_Res(res);
 294 }
 295
 296 /* Get the dev, inode and mode info for a file descriptor, if
 297    possible.  Returns True on success. */
 298 Bool ML_(am_get_fd_d_i_m)( Int fd,
 299                            /*OUT*/ULong* dev,
 300                            /*OUT*/ULong* ino, /*OUT*/UInt* mode )
 301 {
 302    SysRes          res;
 303    struct vki_stat buf;
 304 #  if defined(VGO_linux) && defined(__NR_fstat64)
 305    /* Try fstat64 first as it can cope with minor and major device
 306       numbers outside the 0-255 range and it works properly for x86
 307       binaries on amd64 systems where fstat seems to be broken. */
 308    struct vki_stat64 buf64;
 309    res = VG_(do_syscall2)(__NR_fstat64, fd, (UWord)&buf64);
 310    if (!sr_isError(res)) {
 311       *dev  = (ULong)buf64.st_dev;
 312       *ino  = (ULong)buf64.st_ino;
 313       *mode = (UInt) buf64.st_mode;
 314       return True;
 315    }
 316 #  endif
 317    res = VG_(do_syscall2)(__NR_fstat, fd, (UWord)&buf);
 318    if (!sr_isError(res)) {
 319       *dev  = (ULong)buf.st_dev;
 320       *ino  = (ULong)buf.st_ino;
 321       *mode = (UInt) buf.st_mode;
 322       return True;
 323    }
 324    return False;
 325 }
 326
 327 Bool ML_(am_resolve_filename) ( Int fd, /*OUT*/HChar* buf, Int nbuf )
 328 {
 329 #if defined(VGO_linux)
 330    Int i;
 331    HChar tmp[64];    // large enough
 332    for (i = 0; i < nbuf; i++) buf[i] = 0;
 333    ML_(am_sprintf)(tmp, "/proc/self/fd/%d", fd);
 334    if (ML_(am_readlink)(tmp, buf, nbuf) > 0 && buf[0] == '/')
 335       return True;
 336    else
 337       return False;
 338
 339 #elif defined(VGO_darwin)
 340    HChar tmp[VKI_MAXPATHLEN+1];
 341    if (0 == ML_(am_fcntl)(fd, VKI_F_GETPATH, (UWord)tmp)) {
 342       if (nbuf > 0) {
 343          VG_(strncpy)( buf, tmp, nbuf < sizeof(tmp) ? nbuf : sizeof(tmp) );
 344          buf[nbuf-1] = 0;
 345       }
 346       if (tmp[0] == '/') return True;
 347    }
 348    return False;
 349
 350 #  else
 351 #     error Unknown OS
 352 #  endif
 353 }
 354
 355
 356
 357
 358 /*-----------------------------------------------------------------*/
 359 /*---                                                           ---*/
 360 /*--- Manage stacks for Valgrind itself.                        ---*/
 361 /*---                                                           ---*/
 362 /*-----------------------------------------------------------------*/
 363 struct _VgStack {
 364    HChar bytes[1];
 365    // We use a fake size of 1. A bigger size is allocated
 366    // by VG_(am_alloc_VgStack).
 367 };
 368
 369 /* Allocate and initialise a VgStack (anonymous valgrind space).
 370    Protect the stack active area and the guard areas appropriately.
 371    Returns NULL on failure, else the address of the bottom of the
 372    stack.  On success, also sets *initial_sp to what the stack pointer
 373    should be set to. */
 374
 375 VgStack* VG_(am_alloc_VgStack)( /*OUT*/Addr* initial_sp )
 376 {
 377    Int      szB;
 378    SysRes   sres;
 379    VgStack* stack;
 380    UInt*    p;
 381    Int      i;
 382
 383    /* Allocate the stack. */
 384    szB = VG_STACK_GUARD_SZB
 385          + VG_(clo_valgrind_stacksize) + VG_STACK_GUARD_SZB;
 386
 387    sres = VG_(am_mmap_anon_float_valgrind)( szB );
 388    if (sr_isError(sres))
 389       return NULL;
 390
 391    stack = (VgStack*)(Addr)sr_Res(sres);
 392
 393    aspacem_assert(VG_IS_PAGE_ALIGNED(szB));
 394    aspacem_assert(VG_IS_PAGE_ALIGNED(stack));
 395
 396    /* Protect the guard areas. */
 397    sres = local_do_mprotect_NO_NOTIFY(
 398              (Addr) &stack[0],
 399              VG_STACK_GUARD_SZB, VKI_PROT_NONE
 400           );
 401    if (sr_isError(sres)) goto protect_failed;
 402    VG_(am_notify_mprotect)(
 403       (Addr) &stack->bytes[0],
 404       VG_STACK_GUARD_SZB, VKI_PROT_NONE
 405    );
 406
 407    sres = local_do_mprotect_NO_NOTIFY(
 408              (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)],
 409              VG_STACK_GUARD_SZB, VKI_PROT_NONE
 410           );
 411    if (sr_isError(sres)) goto protect_failed;
 412    VG_(am_notify_mprotect)(
 413       (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)],
 414       VG_STACK_GUARD_SZB, VKI_PROT_NONE
 415    );
 416
 417    /* Looks good.  Fill the active area with junk so we can later
 418       tell how much got used. */
 419
 420    p = (UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
 421    for (i = 0; i < VG_(clo_valgrind_stacksize)/sizeof(UInt); i++)
 422       p[i] = 0xDEADBEEF;
 423
 424    *initial_sp = (Addr)&stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)];
 425    *initial_sp -= 8;
 426    *initial_sp &= ~((Addr)0x1F); /* 32-align it */
 427
 428    VG_(debugLog)( 1,"aspacem",
 429                   "allocated valgrind thread stack at 0x%llx size %d\n",
 430                   (ULong)(Addr)stack, szB);
 431    ML_(am_do_sanity_check)();
 432    return stack;
 433
 434   protect_failed:
 435    /* The stack was allocated, but we can't protect it.  Unmap it and
 436       return NULL (failure). */
 437    (void)ML_(am_do_munmap_NO_NOTIFY)( (Addr)stack, szB );
 438    ML_(am_do_sanity_check)();
 439    return NULL;
 440 }
 441
 442
 443 /* Figure out how many bytes of the stack's active area have not
 444    been used.  Used for estimating if we are close to overflowing it. */
 445
 446 SizeT VG_(am_get_VgStack_unused_szB)( const VgStack* stack, SizeT limit )
 447 {
 448    SizeT i;
 449    const UInt* p;
 450
 451    p = (const UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
 452    for (i = 0; i < VG_(clo_valgrind_stacksize)/sizeof(UInt); i++) {
 453       if (p[i] != 0xDEADBEEF)
 454          break;
 455       if (i * sizeof(UInt) >= limit)
 456          break;
 457    }
 458
 459    return i * sizeof(UInt);
 460 }
 461
 462
 463 /*--------------------------------------------------------------------*/
 464 /*--- end                                                          ---*/
 465 /*--------------------------------------------------------------------*/