modify test

Author: rishabhBudhouliya

tests/unit-tests/memory_tests/deterministic/munmap_adjacent_shm.c

@@ -2,32 +2,24 @@
 //
 // Regression test for the bug fixed in PR #1075:
 //   munmap_syscall rounded `len` up to a page multiple and issued a single
-//   mmap(MAP_FIXED|PROT_NONE) over the whole rounded range. When that
-//   range crossed into a SharedMemory-backed vmmap entry, the host-level
-//   PROT_NONE silently clobbered the shm page.
+//   mmap(MAP_FIXED|PROT_NONE) over the whole rounded range. When that range
+//   crossed into a SharedMemory-backed vmmap entry, the host-level PROT_NONE
+//   silently clobbered the shm page.
 //
-// Layout strategy (no MAP_FIXED, no shmat hint):
-//   lind's allocator places NULL-addr shmat / mmap at the top of a free
-//   gap, and empirically leaves a 1-page stride between consecutive
-//   NULL-addr allocations. So:
-//
-//     shmat(NULL) -> shm at top page T
-//     mmap (NULL) -> anon at T - 2*PAGE
-//     page at   T - PAGE  -> unmapped gap
+// Layout strategy:
+//   1. shmat(NULL) -> shm lands at some address T (allocator decides)
+//   2. mmap(T - 2*PAGE, ..., MAP_FIXED) -> anon forced to exactly T - 2*PAGE
+//   3. Gap page at T - PAGE is unmapped
 //
 //     [ anon @ T-2P ][ gap @ T-P ][ shm @ T ]
 //
-// munmap(anon, 2*PAGE+1) rounds up to 3*PAGE and targets [T-2P .. T+P),
-// covering {anon, gap, shm}. The shm entry's backing is SharedMemory, so:
+//   munmap(anon, 2*PAGE+1) rounds up to 3*PAGE and targets [T-2P .. T+P),
+//   covering {anon, gap, shm}.
 //
 //   Buggy path: one mmap(PROT_NONE, MAP_FIXED) over the full 3*PAGE range
 //               clobbers shm's host memory -> reading shm[0] faults.
 //   Fixed path: the overlap loop filters out the SharedMemory entry;
-//               only the anon page gets PROT_NONE'd. shm stays readable.
-//
-// The stride is asserted explicitly — if allocator behavior ever changes
-// and anon doesn't land at T - 2*PAGE, the test fails loudly instead of
-// silently passing.
+//               only the anon/gap pages get PROT_NONE'd. shm stays readable.
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <sys/mman.h>
@@ -48,35 +40,59 @@ int main(void) {
     assert(((uintptr_t)shm % PAGE_SIZE) == 0 && "shm not page-aligned");
     memset(shm, 0xAB, PAGE_SIZE);
 
-    char *anon = (char *)mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE,
-                              MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    assert(anon != MAP_FAILED && "anon mmap failed");
-    memset(anon, 0xCD, PAGE_SIZE);
+    // Force anon exactly 2 pages below shm using MAP_FIXED.
+    // We control anon's address; we don't need the allocator to cooperate.
+    char *anon_target = shm - 2 * PAGE_SIZE;
+    char *anon = (char *)mmap(anon_target, PAGE_SIZE, PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
 
-    // Precondition on allocator layout: anon must land exactly 2 pages
-    // below shm (one page of unmapped gap between them). If this ever
-    // changes, fail loudly instead of passing by accident.
-    assert(shm == anon + 2 * PAGE_SIZE &&
-           "allocator layout changed: anon is not at shm - 2*PAGE");
+    fprintf(stderr, "  DIAG: shm       @ %p\n", (void *)shm);
+    fprintf(stderr, "  DIAG: anon_target= %p\n", (void *)anon_target);
+    fprintf(stderr, "  DIAG: anon actual= %p\n", (void *)anon);
+    fprintf(stderr, "  DIAG: gap        @ %p\n", (void *)(shm - PAGE_SIZE));
+    fprintf(stderr, "  DIAG: munmap range [%p, %p) — rounded len = 3 pages\n",
+            (void *)anon, (void *)(anon + 3 * PAGE_SIZE));
 
-    // Unaligned munmap starting at anon, ending one byte past the gap:
-    //   len = 2*PAGE+1  ->  rounded length = 3*PAGE
-    //   rounded range   =  [anon, anon + 3*PAGE) = [anon, shm + PAGE)
-    // Buggy runtime PROT_NONEs the whole range (clobbering shm).
-    // Fixed runtime skips the SharedMemory-backed page.
+    if (anon == MAP_FAILED) {
+        fprintf(stderr, "FAIL: MAP_FIXED mmap for anon failed\n");
+        shmdt(shm);
+        shmctl(shmid, IPC_RMID, NULL);
+        return 1;
+    }
+    if (anon != anon_target) {
+        fprintf(stderr,
+                "FAIL: MAP_FIXED returned %p instead of %p — "
+                "kernel rejected the fixed placement\n",
+                (void *)anon, (void *)anon_target);
+        munmap(anon, PAGE_SIZE);
+        shmdt(shm);
+        shmctl(shmid, IPC_RMID, NULL);
+        return 1;
+    }
+
+    memset(anon, 0xCD, PAGE_SIZE);
+
+    // munmap(anon, 2*PAGE+1):
+    //   rounded length = 3*PAGE
+    //   rounded range  = [anon, anon+3*PAGE) = [T-2P, T+P)
+    // Buggy runtime: PROT_NONEs the full range including shm at T.
+    // Fixed runtime: skips the SharedMemory-backed page at T.
     int rc = munmap(anon, 2 * PAGE_SIZE + 1);
     assert(rc == 0 && "trigger munmap failed");
 
+    fprintf(stderr, "  DIAG: munmap returned 0, checking shm integrity\n");
+
     for (int i = 0; i < PAGE_SIZE; i++) {
         if ((unsigned char)shm[i] != 0xAB) {
-            printf("FAIL: shm[%d] = 0x%02x, expected 0xAB\n",
-                   i, (unsigned char)shm[i]);
+            fprintf(stderr, "FAIL: shm[%d] = 0x%02x, expected 0xAB\n",
+                    i, (unsigned char)shm[i]);
             shmdt(shm);
             shmctl(shmid, IPC_RMID, NULL);
             return 1;
         }
     }
 
+    fprintf(stderr, "  DIAG: all %d shm bytes intact\n", PAGE_SIZE);
     printf("PASS: shm page intact after unaligned munmap of nearby anon\n");
     shmdt(shm);
     shmctl(shmid, IPC_RMID, NULL);