Give base::SharedMemory::CreateAnonymous an executable flag

base/shared_memory_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/test/multiprocess_test.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
+#if defined(OS_POSIX)
+#include <sys/mman.h>
+#endif
+
 static const int kNumThreads = 5;
 static const int kNumTasks = 5;
 
 namespace base {
 
 namespace {
 
 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
   explicit MultipleThreadMain(int16 id) : id_(id) {}
   ~MultipleThreadMain() {}
 
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   // PlatformThread::Delegate interface.
   void ThreadMain() {
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
-    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
+    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize, false);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memory.memory()) + id_;
     EXPECT_EQ(0, *ptr);
 
     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
       PlatformThread::Sleep(1);  // Short wait.
       EXPECT_EQ(*ptr, idx);
@@ skipping 28 matching lines @@
   explicit MultipleLockThread(int id) : id_(id) {}
   ~MultipleLockThread() {}
 
   // PlatformThread::Delegate interface.
   void ThreadMain() {
     const uint32 kDataSize = sizeof(int);
     SharedMemoryHandle handle = NULL;
     {
       SharedMemory memory1;
       EXPECT_TRUE(memory1.CreateNamed("SharedMemoryMultipleLockThreadTest",
-                                 true, kDataSize));
+                                      true, kDataSize, false));
       EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
       // TODO(paulg): Implement this once we have a posix version of
       // SharedMemory::ShareToProcess.
       EXPECT_TRUE(true);
     }
 
     SharedMemory memory2(handle, false);
     EXPECT_TRUE(memory2.Map(kDataSize));
     volatile int* const ptr = static_cast<int*>(memory2.memory());
 
@@ skipping 24 matching lines @@
 
   // Open two handles to a memory segment, confirm that they are mapped
   // separately yet point to the same space.
   SharedMemory memory1;
   bool rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Open(test_name, false);
   EXPECT_FALSE(rv);
-  rv = memory1.CreateNamed(test_name, false, kDataSize);
+  rv = memory1.CreateNamed(test_name, false, kDataSize, false);
   EXPECT_TRUE(rv);
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
   SharedMemory memory2;
   rv = memory2.Open(test_name, false);
   EXPECT_TRUE(rv);
   rv = memory2.Map(kDataSize);
   EXPECT_TRUE(rv);
   EXPECT_NE(memory1.memory(), memory2.memory());  // Compare the pointers.
 
@@ skipping 25 matching lines @@
   const uint32 kDataSize = 1024;
   const uint32 kDataSize2 = 2048;
   std::ostringstream test_name_stream;
   test_name_stream << "SharedMemoryOpenExclusiveTest."
                    << Time::Now().ToDoubleT();
   std::string test_name = test_name_stream.str();
 
   // Open two handles to a memory segment and check that open_existing works
   // as expected.
   SharedMemory memory1;
-  bool rv = memory1.CreateNamed(test_name, false, kDataSize);
+  bool rv = memory1.CreateNamed(test_name, false, kDataSize, false);
   EXPECT_TRUE(rv);
 
   // Memory1 knows it's size because it created it.
   EXPECT_EQ(memory1.created_size(), kDataSize);
 
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
 
   memset(memory1.memory(), 'G', kDataSize);
 
   SharedMemory memory2;
   // Should not be able to create if openExisting is false.
-  rv = memory2.CreateNamed(test_name, false, kDataSize2);
+  rv = memory2.CreateNamed(test_name, false, kDataSize2, false);
   EXPECT_FALSE(rv);
 
   // Should be able to create with openExisting true.
-  rv = memory2.CreateNamed(test_name, true, kDataSize2);
+  rv = memory2.CreateNamed(test_name, true, kDataSize2, false);
   EXPECT_TRUE(rv);
 
   // Memory2 shouldn't know the size because we didn't create it.
   EXPECT_EQ(memory2.created_size(), 0U);
 
   // We should be able to map the original size.
   rv = memory2.Map(kDataSize);
   EXPECT_TRUE(rv);
 
   // Verify that opening memory2 didn't truncate or delete memory 1.
@@ skipping 112 matching lines @@
       else
         EXPECT_EQ(0, pointers[j][0]);
     }
   }
 
   for (int i = 0; i < count; i++) {
     memories[i].Close();
   }
 }
 
+#if defined(OS_POSIX)
+// Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
+TEST(SharedMemoryTest, AnonymousExecutable) {
+  const uint32 kTestSize = 1 << 16;
+
+  SharedMemory shared_memory;
+
+  EXPECT_TRUE(shared_memory.CreateAnonymous(kTestSize, true));
+  EXPECT_TRUE(shared_memory.Map(shared_memory.created_size()));
+
+  EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.created_size(),
+                        PROT_READ | PROT_EXEC));
+}
+#endif
+
 // On POSIX it is especially important we test shmem across processes,
 // not just across threads.  But the test is enabled on all platforms.
 class SharedMemoryProcessTest : public MultiProcessTest {
  public:
 
   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }
 
   static int TaskTestMain() {
     int errors = 0;
 #if defined(OS_MACOSX)
     mac::ScopedNSAutoreleasePool pool;
 #endif
     const uint32 kDataSize = 1024;
     SharedMemory memory;
-    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize);
+    bool rv = memory.CreateNamed(s_test_name_, true, kDataSize, false);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     int *ptr = static_cast<int*>(memory.memory());
 
     for (int idx = 0; idx < 20; idx++) {
@@ skipping 39 matching lines @@
   }
 
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 }  // namespace base