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 #  elif defined(VGP_x86_solaris)
 178    /* MAP_ANON with fd==0 is EINVAL. */
 179    if (fd == 0 && (flags & VKI_MAP_ANONYMOUS))
 180       fd = -1;
 181    res = VG_(do_syscall7)(__NR_mmap64, (UWord)start, length, prot, flags,
 182                           (UInt)fd, offset & 0xffffffff, offset >> 32);
 183 #  elif defined(VGP_amd64_solaris)
 184    /* MAP_ANON with fd==0 is EINVAL. */
 185    if (fd == 0 && (flags & VKI_MAP_ANONYMOUS))
 186       fd = -1;
 187    res = VG_(do_syscall6)(__NR_mmap, (UWord)start, length, prot, flags,
 188                           (UInt)fd, offset);
 189 #  else
 190 #    error Unknown platform
 191 #  endif
 192    return res;
 193 }
 194
 195 static
 196 SysRes local_do_mprotect_NO_NOTIFY(Addr start, SizeT length, UInt prot)
 197 {
 198    return VG_(do_syscall3)(__NR_mprotect, (UWord)start, length, prot );
 199 }
 200
 201 SysRes ML_(am_do_munmap_NO_NOTIFY)(Addr start, SizeT length)
 202 {
 203    return VG_(do_syscall2)(__NR_munmap, (UWord)start, length );
 204 }
 205
 206 #if HAVE_MREMAP
 207 /* The following are used only to implement mremap(). */
 208
 209 SysRes ML_(am_do_extend_mapping_NO_NOTIFY)(
 210           Addr  old_addr,
 211           SizeT old_len,
 212           SizeT new_len
 213        )
 214 {
 215    /* Extend the mapping old_addr .. old_addr+old_len-1 to have length
 216       new_len, WITHOUT moving it.  If it can't be extended in place,
 217       fail. */
 218 #  if defined(VGO_linux)
 219    return VG_(do_syscall5)(
 220              __NR_mremap,
 221              old_addr, old_len, new_len,
 222              0/*flags, meaning: must be at old_addr, else FAIL */,
 223              0/*new_addr, is ignored*/
 224           );
 225 #  else
 226 #    error Unknown OS
 227 #  endif
 228 }
 229
 230 SysRes ML_(am_do_relocate_nooverlap_mapping_NO_NOTIFY)(
 231           Addr old_addr, Addr old_len,
 232           Addr new_addr, Addr new_len
 233        )
 234 {
 235    /* Move the mapping old_addr .. old_addr+old_len-1 to the new
 236       location and with the new length.  Only needs to handle the case
 237       where the two areas do not overlap, neither length is zero, and
 238       all args are page aligned. */
 239 #  if defined(VGO_linux)
 240    return VG_(do_syscall5)(
 241              __NR_mremap,
 242              old_addr, old_len, new_len,
 243              VKI_MREMAP_MAYMOVE|VKI_MREMAP_FIXED/*move-or-fail*/,
 244              new_addr
 245           );
 246 #  else
 247 #    error Unknown OS
 248 #  endif
 249 }
 250
 251 #endif
 252
 253 /* --- Pertaining to files --- */
 254
 255 SysRes ML_(am_open) ( const HChar* pathname, Int flags, Int mode )
 256 {
 257 #  if defined(VGP_arm64_linux)
 258    /* ARM64 wants to use __NR_openat rather than __NR_open. */
 259    SysRes res = VG_(do_syscall4)(__NR_openat,
 260                                  VKI_AT_FDCWD, (UWord)pathname, flags, mode);
 261 #  elif defined(VGP_tilegx_linux)
 262    SysRes res = VG_(do_syscall4)(__NR_openat, VKI_AT_FDCWD, (UWord)pathname,
 263                                  flags, mode);
 264 #  elif defined(VGO_linux) || defined(VGO_darwin)
 265    SysRes res = VG_(do_syscall3)(__NR_open, (UWord)pathname, flags, mode);
 266 #  elif defined(VGO_solaris)
 267    SysRes res = VG_(do_syscall4)(__NR_openat, VKI_AT_FDCWD, (UWord)pathname,
 268                                  flags, mode);
 269 #  else
 270 #    error Unknown OS
 271 #  endif
 272    return res;
 273 }
 274
 275 Int ML_(am_read) ( Int fd, void* buf, Int count)
 276 {
 277    SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count);
 278    return sr_isError(res) ? -1 : sr_Res(res);
 279 }
 280
 281 void ML_(am_close) ( Int fd )
 282 {
 283    (void)VG_(do_syscall1)(__NR_close, fd);
 284 }
 285
 286 Int ML_(am_readlink)(const HChar* path, HChar* buf, UInt bufsiz)
 287 {
 288    SysRes res;
 289 #  if defined(VGP_arm64_linux)
 290    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD,
 291                                            (UWord)path, (UWord)buf, bufsiz);
 292 #  elif defined(VGP_tilegx_linux)
 293    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD, (UWord)path,
 294                           (UWord)buf, bufsiz);
 295 #  elif defined(VGO_linux) || defined(VGO_darwin)
 296    res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz);
 297 #  elif defined(VGO_solaris)
 298    res = VG_(do_syscall4)(__NR_readlinkat, VKI_AT_FDCWD, (UWord)path,
 299                           (UWord)buf, bufsiz);
 300 #  else
 301 #    error Unknown OS
 302 #  endif
 303    return sr_isError(res) ? -1 : sr_Res(res);
 304 }
 305
 306 Int ML_(am_fcntl) ( Int fd, Int cmd, Addr arg )
 307 {
 308 #  if defined(VGO_linux) || defined(VGO_solaris)
 309    SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg);
 310 #  elif defined(VGO_darwin)
 311    SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg);
 312 #  else
 313 #  error "Unknown OS"
 314 #  endif
 315    return sr_isError(res) ? -1 : sr_Res(res);
 316 }
 317
 318 /* Get the dev, inode and mode info for a file descriptor, if
 319    possible.  Returns True on success. */
 320 Bool ML_(am_get_fd_d_i_m)( Int fd,
 321                            /*OUT*/ULong* dev,
 322                            /*OUT*/ULong* ino, /*OUT*/UInt* mode )
 323 {
 324 #  if defined(VGO_linux) || defined(VGO_darwin)
 325    SysRes          res;
 326    struct vki_stat buf;
 327 #  if defined(VGO_linux) && defined(__NR_fstat64)
 328    /* Try fstat64 first as it can cope with minor and major device
 329       numbers outside the 0-255 range and it works properly for x86
 330       binaries on amd64 systems where fstat seems to be broken. */
 331    struct vki_stat64 buf64;
 332    res = VG_(do_syscall2)(__NR_fstat64, fd, (UWord)&buf64);
 333    if (!sr_isError(res)) {
 334       *dev  = (ULong)buf64.st_dev;
 335       *ino  = (ULong)buf64.st_ino;
 336       *mode = (UInt) buf64.st_mode;
 337       return True;
 338    }
 339 #  endif
 340    res = VG_(do_syscall2)(__NR_fstat, fd, (UWord)&buf);
 341    if (!sr_isError(res)) {
 342       *dev  = (ULong)buf.st_dev;
 343       *ino  = (ULong)buf.st_ino;
 344       *mode = (UInt) buf.st_mode;
 345       return True;
 346    }
 347    return False;
 348 #  elif defined(VGO_solaris)
 349 #  if defined(VGP_x86_solaris)
 350    struct vki_stat64 buf64;
 351    SysRes res = VG_(do_syscall4)(__NR_fstatat64, fd, 0, (UWord)&buf64, 0);
 352 #  elif defined(VGP_amd64_solaris)
 353    struct vki_stat buf64;
 354    SysRes res = VG_(do_syscall4)(__NR_fstatat, fd, 0, (UWord)&buf64, 0);
 355 #  else
 356 #    error "Unknown platform"
 357 #  endif
 358    if (!sr_isError(res)) {
 359       *dev  = (ULong)buf64.st_dev;
 360       *ino  = (ULong)buf64.st_ino;
 361       *mode = (UInt) buf64.st_mode;
 362       return True;
 363    }
 364    return False;
 365 #  else
 366 #    error Unknown OS
 367 #  endif
 368 }
 369
 370 Bool ML_(am_resolve_filename) ( Int fd, /*OUT*/HChar* buf, Int nbuf )
 371 {
 372 #if defined(VGO_linux)
 373    Int i;
 374    HChar tmp[64];    // large enough
 375    for (i = 0; i < nbuf; i++) buf[i] = 0;
 376    ML_(am_sprintf)(tmp, "/proc/self/fd/%d", fd);
 377    if (ML_(am_readlink)(tmp, buf, nbuf) > 0 && buf[0] == '/')
 378       return True;
 379    else
 380       return False;
 381
 382 #elif defined(VGO_darwin)
 383    HChar tmp[VKI_MAXPATHLEN+1];
 384    if (0 == ML_(am_fcntl)(fd, VKI_F_GETPATH, (UWord)tmp)) {
 385       if (nbuf > 0) {
 386          VG_(strncpy)( buf, tmp, nbuf < sizeof(tmp) ? nbuf : sizeof(tmp) );
 387          buf[nbuf-1] = 0;
 388       }
 389       if (tmp[0] == '/') return True;
 390    }
 391    return False;
 392
 393 #elif defined(VGO_solaris)
 394    Int i;
 395    HChar tmp[64];
 396    for (i = 0; i < nbuf; i++) buf[i] = 0;
 397    ML_(am_sprintf)(tmp, "/proc/self/path/%d", fd);
 398    if (ML_(am_readlink)(tmp, buf, nbuf) > 0 && buf[0] == '/')
 399       return True;
 400    else
 401       return False;
 402
 403 #  else
 404 #     error Unknown OS
 405 #  endif
 406 }
 407
 408
 409
 410
 411 /*-----------------------------------------------------------------*/
 412 /*---                                                           ---*/
 413 /*--- Manage stacks for Valgrind itself.                        ---*/
 414 /*---                                                           ---*/
 415 /*-----------------------------------------------------------------*/
 416 struct _VgStack {
 417    HChar bytes[1];
 418    // We use a fake size of 1. A bigger size is allocated
 419    // by VG_(am_alloc_VgStack).
 420 };
 421
 422 /* Allocate and initialise a VgStack (anonymous valgrind space).
 423    Protect the stack active area and the guard areas appropriately.
 424    Returns NULL on failure, else the address of the bottom of the
 425    stack.  On success, also sets *initial_sp to what the stack pointer
 426    should be set to. */
 427
 428 VgStack* VG_(am_alloc_VgStack)( /*OUT*/Addr* initial_sp )
 429 {
 430    Int      szB;
 431    SysRes   sres;
 432    VgStack* stack;
 433    UInt*    p;
 434    Int      i;
 435
 436    /* Allocate the stack. */
 437    szB = VG_STACK_GUARD_SZB
 438          + VG_(clo_valgrind_stacksize) + VG_STACK_GUARD_SZB;
 439
 440    sres = VG_(am_mmap_anon_float_valgrind)( szB );
 441    if (sr_isError(sres))
 442       return NULL;
 443
 444    stack = (VgStack*)(Addr)sr_Res(sres);
 445
 446    aspacem_assert(VG_IS_PAGE_ALIGNED(szB));
 447    aspacem_assert(VG_IS_PAGE_ALIGNED(stack));
 448
 449    /* Protect the guard areas. */
 450    sres = local_do_mprotect_NO_NOTIFY(
 451              (Addr) &stack[0],
 452              VG_STACK_GUARD_SZB, VKI_PROT_NONE
 453           );
 454    if (sr_isError(sres)) goto protect_failed;
 455    VG_(am_notify_mprotect)(
 456       (Addr) &stack->bytes[0],
 457       VG_STACK_GUARD_SZB, VKI_PROT_NONE
 458    );
 459
 460    sres = local_do_mprotect_NO_NOTIFY(
 461              (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)],
 462              VG_STACK_GUARD_SZB, VKI_PROT_NONE
 463           );
 464    if (sr_isError(sres)) goto protect_failed;
 465    VG_(am_notify_mprotect)(
 466       (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)],
 467       VG_STACK_GUARD_SZB, VKI_PROT_NONE
 468    );
 469
 470    /* Looks good.  Fill the active area with junk so we can later
 471       tell how much got used. */
 472
 473    p = (UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
 474    for (i = 0; i < VG_(clo_valgrind_stacksize)/sizeof(UInt); i++)
 475       p[i] = 0xDEADBEEF;
 476
 477    *initial_sp = (Addr)&stack->bytes[VG_STACK_GUARD_SZB + VG_(clo_valgrind_stacksize)];
 478    *initial_sp -= 8;
 479    *initial_sp &= ~((Addr)0x1F); /* 32-align it */
 480
 481    VG_(debugLog)( 1,"aspacem",
 482                   "allocated valgrind thread stack at 0x%llx size %d\n",
 483                   (ULong)(Addr)stack, szB);
 484    ML_(am_do_sanity_check)();
 485    return stack;
 486
 487   protect_failed:
 488    /* The stack was allocated, but we can't protect it.  Unmap it and
 489       return NULL (failure). */
 490    (void)ML_(am_do_munmap_NO_NOTIFY)( (Addr)stack, szB );
 491    ML_(am_do_sanity_check)();
 492    return NULL;
 493 }
 494
 495
 496 /* Figure out how many bytes of the stack's active area have not
 497    been used.  Used for estimating if we are close to overflowing it. */
 498
 499 SizeT VG_(am_get_VgStack_unused_szB)( const VgStack* stack, SizeT limit )
 500 {
 501    SizeT i;
 502    const UInt* p;
 503
 504    p = (const UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
 505    for (i = 0; i < VG_(clo_valgrind_stacksize)/sizeof(UInt); i++) {
 506       if (p[i] != 0xDEADBEEF)
 507          break;
 508       if (i * sizeof(UInt) >= limit)
 509          break;
 510    }
 511
 512    return i * sizeof(UInt);
 513 }
 514
 515
 516 /*--------------------------------------------------------------------*/
 517 /*--- end                                                          ---*/
 518 /*--------------------------------------------------------------------*/