tst-mmap.so: Fix mmap() flags

Fix tst-mmap test on Linux by passing MAP_PRIVATE as a mmap flag.

Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>

tests/tst-mmap.cc

@@ -76,14 +76,14 @@ int main(int argc, char **argv)
     // Test that munmap actually recycles the physical memory allocated by mmap
     for (int i = 0; i < 1000; i++) {
         constexpr size_t size = 1<<20;
-        void *buf = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+        void *buf = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
         assert(buf != MAP_FAILED);
         munmap(buf, size);
     }
     // Do the same for allocations large enough to use huge-pages
     for (int i = 0; i < 100; i++) {
         constexpr size_t size = 30 * 1<<20;
-        void *buf = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+        void *buf = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
         assert(buf != MAP_FAILED);
         munmap(buf, size);
     }
@@ -91,7 +91,7 @@ int main(int argc, char **argv)
     // physical memory. Mix in small page and huge page allocations for
     // more fun.
     int hugepagesize = 1<<21;
-    void *buf = mmap(NULL, hugepagesize*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    void *buf = mmap(NULL, hugepagesize*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     for (int i=0; i<100; i++) {
         mmap(buf, hugepagesize-4096, PROT_READ, MAP_ANONYMOUS|MAP_FIXED, -1, 0);
@@ -102,7 +102,7 @@ int main(int argc, char **argv)
     munmap(buf, hugepagesize*9+4096);
 
     // test mprotect making a read-only page.
-    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     mprotect(buf, 4096, PROT_READ);
     assert(!try_write(buf));
@@ -110,7 +110,7 @@ int main(int argc, char **argv)
 
     // test mprotect again, with part of huge page, and see that it only
     // modifies the desired part and not anything else
-    buf = mmap(NULL, 3*hugepagesize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 3*hugepagesize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     void *hp = (void*) (((uintptr_t)buf&~(hugepagesize-1))+hugepagesize);
     mprotect(hp+4096, 4096, PROT_READ);
@@ -120,7 +120,7 @@ int main(int argc, char **argv)
     munmap(buf, 3*hugepagesize);
 
     // test that mprotect with PROT_NONE disables even read
-    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     mprotect(buf, 4096, PROT_NONE);
     assert(!try_read(buf));
@@ -128,17 +128,17 @@ int main(int argc, char **argv)
 
     // Tests similar to the above, but giving reduced permissions on
     // mmap() itself instead of calling mprotect
-    buf = mmap(NULL, 4096, PROT_READ, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     assert(!try_write(buf));
     munmap(buf, 4096);
 
-    buf = mmap(NULL, 4096, PROT_NONE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_NONE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     assert(!try_read(buf));
     munmap(buf, 4096);
 
-    buf = mmap(NULL, 4096, PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     assert(try_write(buf));
     munmap(buf, 4096);
@@ -147,7 +147,7 @@ int main(int argc, char **argv)
     // Try successfully writing to an address, and immediately trying to
     // forbid it. If we don't TLB flush correctly, it might erroneously
     // succeed!
-    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     *(char*)buf = 0; // write will succeed
     mprotect(buf, 4096, PROT_READ);
@@ -162,7 +162,7 @@ int main(int argc, char **argv)
     // running mprotect.
     assert(sched::cpus.size() >= 2); // this test can't work without 2 cpus...
     std::atomic_int state(0);
-    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     sched::thread *t2 = nullptr;
     sched::thread *t1 = new sched::thread([&]{
@@ -193,7 +193,7 @@ int main(int argc, char **argv)
 #endif
 
     // Test that mprotect() only hides memory, doesn't free it
-    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     *(char*)buf = 123;
     mprotect(buf, 4096, PROT_NONE); // hide the memory - but don't unmap
@@ -209,7 +209,7 @@ int main(int argc, char **argv)
 
     // Test that msync() can tell if a range of memory is mapped.
     // libunwind's functions which we use for backtrace() require this.
-    buf = mmap(NULL, 4096*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     assert(msync(buf, 4096*10, MS_ASYNC) == 0);
     assert(msync(buf, 4096*9, MS_ASYNC) == 0);
@@ -228,7 +228,7 @@ int main(int argc, char **argv)
 
     // Similarly test mincore().
     unsigned char vec[20];
-    buf = mmap(NULL, 4096*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS, -1, 0);
+    buf = mmap(NULL, 4096*10, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
     assert(buf != MAP_FAILED);
     assert(mincore(buf, 4096*10, vec) == 0);
     assert(mincore(buf, 4096*9, vec) == 0);