UCM/TEST: Generate VM_UNMAP event for shmat(REMAP) and mmap(FIXED)

These 2 calls can override an existing memory mapping, so generate a
VM_UNMAP event for the old address range.

Author: yosefe

src/ucm/event/event.c

@@ -198,6 +198,10 @@ void *ucm_mmap(void *addr, size_t length, int prot, int flags, int fd, off_t off
 
     ucm_event_enter();
 
+    if ((flags & MAP_FIXED) && (addr != NULL)) {
+        ucm_dispatch_vm_munmap(addr, length);
+    }
+
     event.mmap.result  = MAP_FAILED;
     event.mmap.address = addr;
     event.mmap.size    = length;
@@ -287,6 +291,7 @@ void *ucm_mremap(void *old_address, size_t old_size, size_t new_size, int flags)
 
 void *ucm_shmat(int shmid, const void *shmaddr, int shmflg)
 {
+    uintptr_t attach_addr;
     ucm_event_t event;
     khiter_t iter;
     size_t size;
@@ -298,6 +303,15 @@ void *ucm_shmat(int shmid, const void *shmaddr, int shmflg)
               shmid, shmaddr, shmflg);
 
     size = ucm_shm_size(shmid);
+
+    if ((shmflg & SHM_REMAP) && (shmaddr != NULL)) {
+        attach_addr = (uintptr_t)shmaddr;
+        if (shmflg & SHM_RND) {
+            attach_addr -= attach_addr % SHMLBA;
+        }
+        ucm_dispatch_vm_munmap((void*)shmaddr, size);
+    }
+
     event.shmat.result  = MAP_FAILED;
     event.shmat.shmid   = shmid;
     event.shmat.shmaddr = shmaddr;

test/gtest/ucm/malloc_hook.cc

@@ -646,3 +646,90 @@ UCS_TEST_F(malloc_hook_cplusplus, mmap_ptrs) {
     unset();
 
 }
+
+UCS_TEST_F(malloc_hook_cplusplus, remap_override) {
+
+    /*
+     * Test memory mapping functions which override an existing mapping
+     */
+
+    size_t size = ucs_get_page_size() * 800;
+    void *buffer;
+    int shmid;
+
+    set();
+
+    EXPECT_EQ(0u, m_mapped_size);
+    EXPECT_EQ(0u, m_unmapped_size);
+
+    /* 1. Map a large buffer */
+    {
+        buffer = mmap(NULL, size, PROT_READ|PROT_WRITE,
+                            MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+        ASSERT_NE(MAP_FAILED, buffer) << strerror(errno);
+
+        EXPECT_EQ(size, m_mapped_size);
+        EXPECT_EQ(0u,   m_unmapped_size);
+    }
+
+    /*
+     * 2. Map another buffer in the same place.
+     *    Expected behavior: unmap event on the old buffer
+     */
+    {
+        m_mapped_size = m_unmapped_size = 0;
+
+        void *remap = mmap(buffer, size, PROT_READ|PROT_WRITE,
+                           MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
+        ASSERT_EQ(buffer, remap);
+
+        EXPECT_EQ(size, m_mapped_size);
+        EXPECT_EQ(size, m_unmapped_size);
+    }
+
+    /* 3. Create a shared memory segment */
+    {
+        shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | SHM_R | SHM_W);
+        ASSERT_NE(-1, shmid) << strerror(errno);
+    }
+
+    /*
+     * 4. Attach the segment at the same buffer address.
+     *    Expected behavior: unmap event on the old buffer
+     */
+    {
+        m_mapped_size = m_unmapped_size = 0;
+
+        void *shmaddr = shmat(shmid, buffer, SHM_REMAP);
+        ASSERT_EQ(buffer, shmaddr);
+
+        EXPECT_EQ(size, m_mapped_size);
+        EXPECT_EQ(size, m_unmapped_size);
+    }
+
+    /* 5. Detach the sysv segment */
+    {
+        m_mapped_size = m_unmapped_size = 0;
+
+        shmdt(buffer);
+
+        EXPECT_EQ(size, m_unmapped_size);
+    }
+
+    /* 6. Remove the shared memory segment */
+    {
+        int ret = shmctl(shmid, IPC_RMID, NULL);
+        ASSERT_NE(-1, ret) << strerror(errno);
+    }
+
+    /* 7. Unmap the buffer */
+    {
+        m_mapped_size = m_unmapped_size = 0;
+
+        munmap(buffer, size);
+
+        EXPECT_EQ(size, m_unmapped_size);
+    }
+
+    unset();
+}