Home | History | Annotate | Download | only in m_aspacemgr
      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-2012 OpenWorks LLP
     13       info (at) 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 #  if defined(VGO_linux)
     58    (void)VG_(do_syscall1)(__NR_exit_group, status);
     59 #  endif
     60    (void)VG_(do_syscall1)(__NR_exit, status);
     61    /* Why are we still alive here? */
     62    /*NOTREACHED*/
     63    *(volatile Int *)0 = 'x';
     64    aspacem_assert(2+2 == 5);
     65 }
     66 
     67 void ML_(am_barf) ( HChar* what )
     68 {
     69    VG_(debugLog)(0, "aspacem", "Valgrind: FATAL: %s\n", what);
     70    VG_(debugLog)(0, "aspacem", "Exiting now.\n");
     71    ML_(am_exit)(1);
     72 }
     73 
     74 void ML_(am_barf_toolow) ( HChar* what )
     75 {
     76    VG_(debugLog)(0, "aspacem",
     77                     "Valgrind: FATAL: %s is too low.\n", what);
     78    VG_(debugLog)(0, "aspacem", "  Increase it and rebuild.  "
     79                                "Exiting now.\n");
     80    ML_(am_exit)(1);
     81 }
     82 
     83 void ML_(am_assert_fail)( const HChar* expr,
     84                           const Char* file,
     85                           Int line,
     86                           const Char* fn )
     87 {
     88    VG_(debugLog)(0, "aspacem",
     89                     "Valgrind: FATAL: aspacem assertion failed:\n");
     90    VG_(debugLog)(0, "aspacem", "  %s\n", expr);
     91    VG_(debugLog)(0, "aspacem", "  at %s:%d (%s)\n", file,line,fn);
     92    VG_(debugLog)(0, "aspacem", "Exiting now.\n");
     93    ML_(am_exit)(1);
     94 }
     95 
     96 Int ML_(am_getpid)( void )
     97 {
     98    SysRes sres = VG_(do_syscall0)(__NR_getpid);
     99    aspacem_assert(!sr_isError(sres));
    100    return sr_Res(sres);
    101 }
    102 
    103 
    104 //--------------------------------------------------------------
    105 // A simple sprintf implementation, so as to avoid dependence on
    106 // m_libcprint.
    107 
    108 static void local_add_to_aspacem_sprintf_buf ( HChar c, void *p )
    109 {
    110    HChar** aspacem_sprintf_ptr = p;
    111    *(*aspacem_sprintf_ptr)++ = c;
    112 }
    113 
    114 static
    115 UInt local_vsprintf ( HChar* buf, const HChar *format, va_list vargs )
    116 {
    117    Int ret;
    118    Char *aspacem_sprintf_ptr = buf;
    119 
    120    ret = VG_(debugLog_vprintf)
    121             ( local_add_to_aspacem_sprintf_buf,
    122               &aspacem_sprintf_ptr, format, vargs );
    123    local_add_to_aspacem_sprintf_buf('\0', &aspacem_sprintf_ptr);
    124 
    125    return ret;
    126 }
    127 
    128 UInt ML_(am_sprintf) ( HChar* buf, const HChar *format, ... )
    129 {
    130    UInt ret;
    131    va_list vargs;
    132 
    133    va_start(vargs,format);
    134    ret = local_vsprintf(buf, format, vargs);
    135    va_end(vargs);
    136 
    137    return ret;
    138 }
    139 
    140 
    141 //--------------------------------------------------------------
    142 // Direct access to a handful of syscalls.  This avoids dependence on
    143 // m_libc*.  THESE DO NOT UPDATE THE aspacem-internal DATA
    144 // STRUCTURES (SEGMENT ARRAY).  DO NOT USE THEM UNLESS YOU KNOW WHAT
    145 // YOU ARE DOING.
    146 
    147 /* --- Pertaining to mappings --- */
    148 
    149 /* Note: this is VG_, not ML_. */
    150 SysRes VG_(am_do_mmap_NO_NOTIFY)( Addr start, SizeT length, UInt prot,
    151                                   UInt flags, Int fd, Off64T offset)
    152 {
    153    SysRes res;
    154    aspacem_assert(VG_IS_PAGE_ALIGNED(offset));
    155 #  if defined(VGP_x86_linux) || defined(VGP_ppc32_linux) \
    156       || defined(VGP_arm_linux)
    157    /* mmap2 uses 4096 chunks even if actual page size is bigger. */
    158    aspacem_assert((offset % 4096) == 0);
    159    res = VG_(do_syscall6)(__NR_mmap2, (UWord)start, length,
    160                           prot, flags, fd, offset / 4096);
    161 #  elif defined(VGP_amd64_linux) || defined(VGP_ppc64_linux) \
    162         || defined(VGP_s390x_linux) || defined(VGP_mips32_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 Char* pathname, Int flags, Int mode )
    244 {
    245    SysRes res = VG_(do_syscall3)(__NR_open, (UWord)pathname, flags, mode);
    246    return res;
    247 }
    248 
    249 Int ML_(am_read) ( Int fd, void* buf, Int count)
    250 {
    251    SysRes res = VG_(do_syscall3)(__NR_read, fd, (UWord)buf, count);
    252    return sr_isError(res) ? -1 : sr_Res(res);
    253 }
    254 
    255 void ML_(am_close) ( Int fd )
    256 {
    257    (void)VG_(do_syscall1)(__NR_close, fd);
    258 }
    259 
    260 Int ML_(am_readlink)(HChar* path, HChar* buf, UInt bufsiz)
    261 {
    262    SysRes res;
    263    res = VG_(do_syscall3)(__NR_readlink, (UWord)path, (UWord)buf, bufsiz);
    264    return sr_isError(res) ? -1 : sr_Res(res);
    265 }
    266 
    267 Int ML_(am_fcntl) ( Int fd, Int cmd, Addr arg )
    268 {
    269 #  if defined(VGO_linux)
    270    SysRes res = VG_(do_syscall3)(__NR_fcntl, fd, cmd, arg);
    271 #  elif defined(VGO_darwin)
    272    SysRes res = VG_(do_syscall3)(__NR_fcntl_nocancel, fd, cmd, arg);
    273 #  else
    274 #  error "Unknown OS"
    275 #  endif
    276    return sr_isError(res) ? -1 : sr_Res(res);
    277 }
    278 
    279 /* Get the dev, inode and mode info for a file descriptor, if
    280    possible.  Returns True on success. */
    281 Bool ML_(am_get_fd_d_i_m)( Int fd,
    282                            /*OUT*/ULong* dev,
    283                            /*OUT*/ULong* ino, /*OUT*/UInt* mode )
    284 {
    285    SysRes          res;
    286    struct vki_stat buf;
    287 #  if defined(VGO_linux) && defined(__NR_fstat64)
    288    /* Try fstat64 first as it can cope with minor and major device
    289       numbers outside the 0-255 range and it works properly for x86
    290       binaries on amd64 systems where fstat seems to be broken. */
    291    struct vki_stat64 buf64;
    292    res = VG_(do_syscall2)(__NR_fstat64, fd, (UWord)&buf64);
    293    if (!sr_isError(res)) {
    294       *dev  = (ULong)buf64.st_dev;
    295       *ino  = (ULong)buf64.st_ino;
    296       *mode = (UInt) buf64.st_mode;
    297       return True;
    298    }
    299 #  endif
    300    res = VG_(do_syscall2)(__NR_fstat, fd, (UWord)&buf);
    301    if (!sr_isError(res)) {
    302       *dev  = (ULong)buf.st_dev;
    303       *ino  = (ULong)buf.st_ino;
    304       *mode = (UInt) buf.st_mode;
    305       return True;
    306    }
    307    return False;
    308 }
    309 
    310 Bool ML_(am_resolve_filename) ( Int fd, /*OUT*/HChar* buf, Int nbuf )
    311 {
    312 #if defined(VGO_linux)
    313    Int i;
    314    HChar tmp[64];
    315    for (i = 0; i < nbuf; i++) buf[i] = 0;
    316    ML_(am_sprintf)(tmp, "/proc/self/fd/%d", fd);
    317    if (ML_(am_readlink)(tmp, buf, nbuf) > 0 && buf[0] == '/')
    318       return True;
    319    else
    320       return False;
    321 
    322 #elif defined(VGO_darwin)
    323    HChar tmp[VKI_MAXPATHLEN+1];
    324    if (0 == ML_(am_fcntl)(fd, VKI_F_GETPATH, (UWord)tmp)) {
    325       if (nbuf > 0) {
    326          VG_(strncpy)( buf, tmp, nbuf < sizeof(tmp) ? nbuf : sizeof(tmp) );
    327          buf[nbuf-1] = 0;
    328       }
    329       if (tmp[0] == '/') return True;
    330    }
    331    return False;
    332 
    333 #  else
    334 #     error Unknown OS
    335 #  endif
    336 }
    337 
    338 
    339 
    340 
    341 /*-----------------------------------------------------------------*/
    342 /*---                                                           ---*/
    343 /*--- Manage stacks for Valgrind itself.                        ---*/
    344 /*---                                                           ---*/
    345 /*-----------------------------------------------------------------*/
    346 
    347 /* Allocate and initialise a VgStack (anonymous valgrind space).
    348    Protect the stack active area and the guard areas appropriately.
    349    Returns NULL on failure, else the address of the bottom of the
    350    stack.  On success, also sets *initial_sp to what the stack pointer
    351    should be set to. */
    352 
    353 VgStack* VG_(am_alloc_VgStack)( /*OUT*/Addr* initial_sp )
    354 {
    355    Int      szB;
    356    SysRes   sres;
    357    VgStack* stack;
    358    UInt*    p;
    359    Int      i;
    360 
    361    /* Allocate the stack. */
    362    szB = VG_STACK_GUARD_SZB
    363          + VG_STACK_ACTIVE_SZB + VG_STACK_GUARD_SZB;
    364 
    365    sres = VG_(am_mmap_anon_float_valgrind)( szB );
    366    if (sr_isError(sres))
    367       return NULL;
    368 
    369    stack = (VgStack*)(AddrH)sr_Res(sres);
    370 
    371    aspacem_assert(VG_IS_PAGE_ALIGNED(szB));
    372    aspacem_assert(VG_IS_PAGE_ALIGNED(stack));
    373 
    374    /* Protect the guard areas. */
    375    sres = local_do_mprotect_NO_NOTIFY(
    376              (Addr) &stack[0],
    377              VG_STACK_GUARD_SZB, VKI_PROT_NONE
    378           );
    379    if (sr_isError(sres)) goto protect_failed;
    380    VG_(am_notify_mprotect)(
    381       (Addr) &stack->bytes[0],
    382       VG_STACK_GUARD_SZB, VKI_PROT_NONE
    383    );
    384 
    385    sres = local_do_mprotect_NO_NOTIFY(
    386              (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_STACK_ACTIVE_SZB],
    387              VG_STACK_GUARD_SZB, VKI_PROT_NONE
    388           );
    389    if (sr_isError(sres)) goto protect_failed;
    390    VG_(am_notify_mprotect)(
    391       (Addr) &stack->bytes[VG_STACK_GUARD_SZB + VG_STACK_ACTIVE_SZB],
    392       VG_STACK_GUARD_SZB, VKI_PROT_NONE
    393    );
    394 
    395    /* Looks good.  Fill the active area with junk so we can later
    396       tell how much got used. */
    397 
    398    p = (UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
    399    for (i = 0; i < VG_STACK_ACTIVE_SZB/sizeof(UInt); i++)
    400       p[i] = 0xDEADBEEF;
    401 
    402    *initial_sp = (Addr)&stack->bytes[VG_STACK_GUARD_SZB + VG_STACK_ACTIVE_SZB];
    403    *initial_sp -= 8;
    404    *initial_sp &= ~((Addr)0x1F); /* 32-align it */
    405 
    406    VG_(debugLog)( 1,"aspacem","allocated thread stack at 0x%llx size %d\n",
    407                   (ULong)(Addr)stack, szB);
    408    ML_(am_do_sanity_check)();
    409    return stack;
    410 
    411   protect_failed:
    412    /* The stack was allocated, but we can't protect it.  Unmap it and
    413       return NULL (failure). */
    414    (void)ML_(am_do_munmap_NO_NOTIFY)( (Addr)stack, szB );
    415    ML_(am_do_sanity_check)();
    416    return NULL;
    417 }
    418 
    419 
    420 /* Figure out how many bytes of the stack's active area have not
    421    been used.  Used for estimating if we are close to overflowing it. */
    422 
    423 SizeT VG_(am_get_VgStack_unused_szB)( VgStack* stack, SizeT limit )
    424 {
    425    SizeT i;
    426    UInt* p;
    427 
    428    p = (UInt*)&stack->bytes[VG_STACK_GUARD_SZB];
    429    for (i = 0; i < VG_STACK_ACTIVE_SZB/sizeof(UInt); i++) {
    430       if (p[i] != 0xDEADBEEF)
    431          break;
    432       if (i * sizeof(UInt) >= limit)
    433          break;
    434    }
    435 
    436    return i * sizeof(UInt);
    437 }
    438 
    439 
    440 /*--------------------------------------------------------------------*/
    441 /*--- end                                                          ---*/
    442 /*--------------------------------------------------------------------*/
    443