Moved the mman VG_(*_native)() functions into m_aspacemgr, and removed

the unused init_shadow_page() function.  As a result, m_aspacemgr no longer
depends on m_libcmman, breaking a circular module dependency, good!

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@4015

diff --git a/coregrind/m_aspacemgr/aspacemgr.c b/coregrind/m_aspacemgr/aspacemgr.c
index 4bd4ce8d867337a68c3f6d2eea07ab7b646ae792..1c6d921d92ebf68c7c25dbc6fc02b5144d15f758 100644 (file)
--- a/coregrind/m_aspacemgr/aspacemgr.c
+++ b/coregrind/m_aspacemgr/aspacemgr.c
@@ -36,7 +36,6 @@
 #include "pub_core_libcbase.h"
 #include "pub_core_libcassert.h"
 #include "pub_core_libcfile.h"   // For VG_(fstat), VG_(resolve_filename_nodup)
-#include "pub_core_libcmman.h"
 #include "pub_core_libcprint.h"
 #include "pub_core_syscall.h"
 #include "pub_core_tooliface.h"
@@ -73,6 +72,47 @@ Addr VG_(valgrind_base);      /* valgrind's address range */
 // the VG_(*_end) vars name the byte one past the end of the section.
 Addr VG_(valgrind_last);
 
+/*--------------------------------------------------------------*/
+/*--- The raw mman syscalls                                  ---*/
+/*--------------------------------------------------------------*/
+
+SysRes VG_(mmap_native)(void *start, SizeT length, UInt prot, UInt flags,
+                        UInt fd, OffT offset)
+{
+   SysRes res;
+#if defined(VGP_x86_linux)
+   { 
+      UWord args[6];
+      args[0] = (UWord)start;
+      args[1] = length;
+      args[2] = prot;
+      args[3] = flags;
+      args[4] = fd;
+      args[5] = offset;
+      res = VG_(do_syscall1)(__NR_mmap, (UWord)args );
+   }
+#elif defined(VGP_amd64_linux)
+   res = VG_(do_syscall6)(__NR_mmap, (UWord)start, length, 
+                         prot, flags, fd, offset);
+#elif defined(VGP_ppc32_linux)
+   res = VG_(do_syscall6)(__NR_mmap, (UWord)(start), (length),
+                         prot, flags, fd, offset);
+#else
+#  error Unknown platform
+#endif
+   return res;
+}
+
+SysRes VG_(munmap_native)(void *start, SizeT length)
+{
+   return VG_(do_syscall2)(__NR_munmap, (UWord)start, length );
+}
+
+SysRes VG_(mprotect_native)( void *start, SizeT length, UInt prot )
+{
+   return VG_(do_syscall3)(__NR_mprotect, (UWord)start, length, prot );
+}
+
 /*--------------------------------------------------------------*/
 /*--- A simple, self-contained ordered array of segments.    ---*/
 /*--------------------------------------------------------------*/
@@ -1021,6 +1061,7 @@ void VG_(unpad_address_space)(Addr start)
 
    while (s && addr <= VG_(valgrind_last)) {
       if (addr < s->addr) {
+         //ret = VG_(do_syscall2)(__NR_munmap, addr, s->addr - addr);
          ret = VG_(do_syscall2)(__NR_munmap, addr, s->addr - addr);
       }
       addr = s->addr + s->len;
@@ -1153,30 +1194,6 @@ Bool VG_(is_shadow_addr)(Addr a)
 /*--- Handling shadow memory                                       ---*/
 /*--------------------------------------------------------------------*/
 
-void VG_(init_shadow_range)(Addr p, UInt sz, Bool call_init)
-{
-vg_assert(0);
-   if (0)
-      VG_(printf)("init_shadow_range(%p, %d)\n", p, sz);
-
-   vg_assert(VG_(needs).shadow_memory);
-   vg_assert(VG_(tdict).track_init_shadow_page);
-
-   sz = VG_PGROUNDUP(p+sz) - VG_PGROUNDDN(p);
-   p  = VG_PGROUNDDN(p);
-
-   VG_(mprotect)((void *)p, sz, VKI_PROT_READ|VKI_PROT_WRITE);
-   
-   if (call_init) 
-      while(sz) {
-        /* ask the tool to initialize each page */
-        VG_TRACK( init_shadow_page, VG_PGROUNDDN(p) );
-        
-        p  += VKI_PAGE_SIZE;
-        sz -= VKI_PAGE_SIZE;
-      }
-}
-
 void *VG_(shadow_alloc)(UInt size)
 {
    static Addr shadow_alloc = 0;
@@ -1186,7 +1203,6 @@ void *VG_(shadow_alloc)(UInt size)
    if (0) show_segments("shadow_alloc(before)");
 
    vg_assert(VG_(needs).shadow_memory);
-   vg_assert(!VG_(tdict).track_init_shadow_page);
 
    size = VG_PGROUNDUP(size);
 

diff --git a/coregrind/m_libcmman.c b/coregrind/m_libcmman.c
index a2265d35ec996307b20deb298baf621ee67a5f08..cf4fd3a8f5d2ec56f9eb0499de616b75f23f6092 100644 (file)
--- a/coregrind/m_libcmman.c
+++ b/coregrind/m_libcmman.c
@@ -38,33 +38,6 @@
 #include "pub_core_syscall.h"
 #include "vki_unistd.h"
 
-SysRes VG_(mmap_native)(void *start, SizeT length, UInt prot, UInt flags,
-                        UInt fd, OffT offset)
-{
-   SysRes res;
-#if defined(VGP_x86_linux)
-   { 
-      UWord args[6];
-      args[0] = (UWord)start;
-      args[1] = length;
-      args[2] = prot;
-      args[3] = flags;
-      args[4] = fd;
-      args[5] = offset;
-      res = VG_(do_syscall1)(__NR_mmap, (UWord)args );
-   }
-#elif defined(VGP_amd64_linux)
-   res = VG_(do_syscall6)(__NR_mmap, (UWord)start, length, 
-                         prot, flags, fd, offset);
-#elif defined(VGP_ppc32_linux)
-   res = VG_(do_syscall6)(__NR_mmap, (UWord)(start), (length),
-                         prot, flags, fd, offset);
-#else
-#  error Unknown platform
-#endif
-   return res;
-}
-
 /* Returns -1 on failure. */
 void* VG_(mmap)( void* start, SizeT length,
                  UInt prot, UInt flags, UInt sf_flags, UInt fd, OffT offset)
@@ -106,11 +79,6 @@ void* VG_(mmap)( void* start, SizeT length,
    return res.isError ? (void*)-1 : (void*)res.val;
 }
 
-SysRes VG_(munmap_native)(void *start, SizeT length)
-{
-   return VG_(do_syscall2)(__NR_munmap, (UWord)start, length );
-}
-
 /* Returns -1 on failure. */
 Int VG_(munmap)( void* start, SizeT length )
 {
@@ -123,11 +91,6 @@ Int VG_(munmap)( void* start, SizeT length )
    }
 }
 
-SysRes VG_(mprotect_native)( void *start, SizeT length, UInt prot )
-{
-   return VG_(do_syscall3)(__NR_mprotect, (UWord)start, length, prot );
-}
-
 Int VG_(mprotect)( void *start, SizeT length, UInt prot )
 {
    SysRes res = VG_(mprotect_native)(start, length, prot);

diff --git a/coregrind/m_signals.c b/coregrind/m_signals.c
index a41b48f11854b33e80cd81caab2e383fe2fb6472..9e1c1b54fc8f50d2d61a2a9ed34a02e71a32fc7b 100644 (file)
--- a/coregrind/m_signals.c
+++ b/coregrind/m_signals.c
@@ -1885,28 +1885,8 @@ void sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext *u
         } else
            VG_(message)(Vg_UserMsg, "Stack overflow in thread %d: can't grow stack to %p", 
                         tid, fault);
-
-        /* Fall into normal signal handling for all other cases */
-      } else if (info->si_code == 2 && /* SEGV_ACCERR */
-                VG_(needs).shadow_memory &&
-                VG_(is_shadow_addr)(fault)) {
-        /* If there's a fault within the shadow memory range, and it
-           is a permissions fault, then it means that the client is
-           using some memory which had not previously been used.
-           This catches those faults, makes the memory accessible,
-           and calls the tool to initialize that page.
-        */
-        static Int recursion = 0;
-
-        if (recursion++ == 0) {
-           VG_(init_shadow_range)(VG_PGROUNDDN(fault), VKI_PAGE_SIZE, True);
-           recursion--;
-           return;
-        } else {
-           /* otherwise fall into normal SEGV handling */          
-           recursion--;
-        }
       }
+      /* Fall into normal signal handling for all other cases */
    }
 
    /* OK, this is a signal we really have to deal with.  If it came

diff --git a/coregrind/m_tooliface.c b/coregrind/m_tooliface.c
index d6242c7b61be123d458c00dd0846ecce5ff3752e..a13f3efd8ffadb164fd927057ec3e42e7c786ccc 100644 (file)
--- a/coregrind/m_tooliface.c
+++ b/coregrind/m_tooliface.c
@@ -322,8 +322,6 @@ DEF(track_post_mutex_unlock,     ThreadId, void*)
 DEF(track_pre_deliver_signal,    ThreadId, Int sigNo, Bool)
 DEF(track_post_deliver_signal,   ThreadId, Int sigNo)
 
-DEF(track_init_shadow_page,      Addr)
-
 /*--------------------------------------------------------------------*/
 /*--- end                                                          ---*/
 /*--------------------------------------------------------------------*/

diff --git a/coregrind/pub_core_aspacemgr.h b/coregrind/pub_core_aspacemgr.h
index 703f146141717ba29cfbc5cb764c2acdae096631..7f5af754e85fe5bfdeaaa07fc1b4d1d8be3a0c61 100644 (file)
--- a/coregrind/pub_core_aspacemgr.h
+++ b/coregrind/pub_core_aspacemgr.h
@@ -59,6 +59,12 @@ extern Addr VG_(shadow_end);
 extern Addr VG_(valgrind_base);         // valgrind's address range
 extern Addr VG_(valgrind_last);  // Nb: last byte, rather than one past the end
 
+// Direct access to these system calls.
+extern SysRes VG_(mmap_native)     ( void* start, SizeT length, UInt prot,
+                                     UInt flags, UInt fd, OffT offset );
+extern SysRes VG_(munmap_native)   ( void* start, SizeT length );
+extern SysRes VG_(mprotect_native) ( void *start, SizeT length, UInt prot );
+
 /* A Segment is mapped piece of client memory.  This covers all kinds
    of mapped memory (exe, brk, mmap, .so, shm, stack, etc)
 

diff --git a/coregrind/pub_core_libcmman.h b/coregrind/pub_core_libcmman.h
index a537405ac601b1ef35af86ccf8510bf951f21642..6bc8f0599fec25a7a0499bf9bbcdc3cd1675ae92 100644 (file)
--- a/coregrind/pub_core_libcmman.h
+++ b/coregrind/pub_core_libcmman.h
@@ -43,11 +43,6 @@ extern void* VG_(mmap)   ( void* start, SizeT length, UInt prot, UInt flags,
 extern Int VG_(munmap)   ( void* start, SizeT length );
 extern Int VG_(mprotect) ( void *start, SizeT length, UInt prot );
 
-extern SysRes VG_(mmap_native)     ( void* start, SizeT length, UInt prot,
-                                     UInt flags, UInt fd, OffT offset );
-extern SysRes VG_(munmap_native)   ( void* start, SizeT length );
-extern SysRes VG_(mprotect_native) ( void *start, SizeT length, UInt prot );
-
 extern Addr VG_(get_memory_from_mmap_for_client)
                (Addr base, SizeT len, UInt prot, UInt flags);
 

diff --git a/coregrind/pub_core_tooliface.h b/coregrind/pub_core_tooliface.h
index 5cf9989ad2fc7447658b1d49a6d12ff475b0b841..df9fe260ef6ea2b878ec3e2a5048121d63c79396 100644 (file)
--- a/coregrind/pub_core_tooliface.h
+++ b/coregrind/pub_core_tooliface.h
@@ -201,8 +201,6 @@ typedef struct {
    void (*track_pre_deliver_signal) (ThreadId, Int sigNo, Bool);
    void (*track_post_deliver_signal)(ThreadId, Int sigNo);
 
-   void (*track_init_shadow_page)(Addr);
-
 } VgToolInterface;
 
 extern VgToolInterface VG_(tdict);

diff --git a/include/pub_tool_aspacemgr.h b/include/pub_tool_aspacemgr.h
index b2b4236205984fb86373f81861c1efd24c5985b5..92c102f87b2228510d81f5612d645e66e29e50bf 100644 (file)
--- a/include/pub_tool_aspacemgr.h
+++ b/include/pub_tool_aspacemgr.h
@@ -39,12 +39,6 @@ extern void *VG_(shadow_alloc)(UInt size);
 
 extern Bool VG_(is_addressable)(Addr p, SizeT sz, UInt prot);
 
-/* initialize shadow pages in the range [p, p+sz) This calls
-   init_shadow_page for each one.  It should be a lot more efficient
-   for bulk-initializing shadow pages than faulting on each one. 
-*/
-extern void VG_(init_shadow_range)(Addr p, UInt sz, Bool call_init);
-
 /* Calls into the core used by leak-checking */
 
 /* Calls "add_rootrange" with each range of memory which looks like a

diff --git a/include/pub_tool_tooliface.h b/include/pub_tool_tooliface.h
index 1d166831c590bc37262ca4c80a319428ea539cbe..92e413a0f61ff21ff8470e1ad30bca0efa31eb45 100644 (file)
--- a/include/pub_tool_tooliface.h
+++ b/include/pub_tool_tooliface.h
@@ -398,9 +398,7 @@ void VG_(track_post_deliver_signal)(void(*f)(ThreadId tid, Int sigNo));
 
 /* Others... condition variables...
    ...
-   Shadow memory management
  */
-void VG_(track_init_shadow_page)(void(*f)(Addr p));
 
 #endif   // __PUB_TOOL_TOOLIFACE_H