base/memory/shared_memory_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/atomicops.h"
   6 #include "base/basictypes.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/memory/shared_memory.h"
   9 #include "base/process/kill.h"
  10 #include "base/rand_util.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/sys_info.h"
  13 #include "base/test/multiprocess_test.h"
  14 #include "base/threading/platform_thread.h"
  15 #include "base/time/time.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "testing/multiprocess_func_list.h"
  18
  19 #if defined(OS_MACOSX)
  20 #include "base/mac/scoped_nsautorelease_pool.h"
  21 #endif
  22
  23 #if defined(OS_POSIX)
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <sys/mman.h>
  27 #include <sys/stat.h>
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30 #endif
  31
  32 #if defined(OS_WIN)
  33 #include "base/win/scoped_handle.h"
  34 #endif
  35
  36 static const int kNumThreads = 5;
  37 #if !defined(OS_IOS) && !defined(OS_ANDROID)
  38 static const int kNumTasks = 5;
  39 #endif
  40
  41 namespace base {
  42
  43 namespace {
  44
  45 // Each thread will open the shared memory.  Each thread will take a different 4
  46 // byte int pointer, and keep changing it, with some small pauses in between.
  47 // Verify that each thread's value in the shared memory is always correct.
  48 class MultipleThreadMain : public PlatformThread::Delegate {
  49  public:
  50   explicit MultipleThreadMain(int16 id) : id_(id) {}
  51   ~MultipleThreadMain() override {}
  52
  53   static void CleanUp() {
  54     SharedMemory memory;
  55     memory.Delete(s_test_name_);
  56   }
  57
  58   // PlatformThread::Delegate interface.
  59   void ThreadMain() override {
  60 #if defined(OS_MACOSX)
  61     mac::ScopedNSAutoreleasePool pool;
  62 #endif
  63     const uint32 kDataSize = 1024;
  64     SharedMemory memory;
  65     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, kDataSize);
  66     EXPECT_TRUE(rv);
  67     rv = memory.Map(kDataSize);
  68     EXPECT_TRUE(rv);
  69     int *ptr = static_cast<int*>(memory.memory()) + id_;
  70     EXPECT_EQ(0, *ptr);
  71
  72     for (int idx = 0; idx < 100; idx++) {
  73       *ptr = idx;
  74       PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
  75       EXPECT_EQ(*ptr, idx);
  76     }
  77     // Reset back to 0 for the next test that uses the same name.
  78     *ptr = 0;
  79
  80     memory.Close();
  81   }
  82
  83  private:
  84   int16 id_;
  85
  86   static const char* const s_test_name_;
  87
  88   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
  89 };
  90
  91 const char* const MultipleThreadMain::s_test_name_ =
  92     "SharedMemoryOpenThreadTest";
  93
  94 }  // namespace
  95
  96 // Android doesn't support SharedMemory::Open/Delete/
  97 // CreateNamedDeprecated(openExisting=true)
  98 #if !defined(OS_ANDROID)
  99 TEST(SharedMemoryTest, OpenClose) {
 100   const uint32 kDataSize = 1024;
 101   std::string test_name = "SharedMemoryOpenCloseTest";
 102
 103   // Open two handles to a memory segment, confirm that they are mapped
 104   // separately yet point to the same space.
 105   SharedMemory memory1;
 106   bool rv = memory1.Delete(test_name);
 107   EXPECT_TRUE(rv);
 108   rv = memory1.Delete(test_name);
 109   EXPECT_TRUE(rv);
 110   rv = memory1.Open(test_name, false);
 111   EXPECT_FALSE(rv);
 112   rv = memory1.CreateNamedDeprecated(test_name, false, kDataSize);
 113   EXPECT_TRUE(rv);
 114   rv = memory1.Map(kDataSize);
 115   EXPECT_TRUE(rv);
 116   SharedMemory memory2;
 117   rv = memory2.Open(test_name, false);
 118   EXPECT_TRUE(rv);
 119   rv = memory2.Map(kDataSize);
 120   EXPECT_TRUE(rv);
 121   EXPECT_NE(memory1.memory(), memory2.memory());  // Compare the pointers.
 122
 123   // Make sure we don't segfault. (it actually happened!)
 124   ASSERT_NE(memory1.memory(), static_cast<void*>(NULL));
 125   ASSERT_NE(memory2.memory(), static_cast<void*>(NULL));
 126
 127   // Write data to the first memory segment, verify contents of second.
 128   memset(memory1.memory(), '1', kDataSize);
 129   EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);
 130
 131   // Close the first memory segment, and verify the second has the right data.
 132   memory1.Close();
 133   char *start_ptr = static_cast<char *>(memory2.memory());
 134   char *end_ptr = start_ptr + kDataSize;
 135   for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
 136     EXPECT_EQ(*ptr, '1');
 137
 138   // Close the second memory segment.
 139   memory2.Close();
 140
 141   rv = memory1.Delete(test_name);
 142   EXPECT_TRUE(rv);
 143   rv = memory2.Delete(test_name);
 144   EXPECT_TRUE(rv);
 145 }
 146
 147 TEST(SharedMemoryTest, OpenExclusive) {
 148   const uint32 kDataSize = 1024;
 149   const uint32 kDataSize2 = 2048;
 150   std::ostringstream test_name_stream;
 151   test_name_stream << "SharedMemoryOpenExclusiveTest."
 152                    << Time::Now().ToDoubleT();
 153   std::string test_name = test_name_stream.str();
 154
 155   // Open two handles to a memory segment and check that
 156   // open_existing_deprecated works as expected.
 157   SharedMemory memory1;
 158   bool rv = memory1.CreateNamedDeprecated(test_name, false, kDataSize);
 159   EXPECT_TRUE(rv);
 160
 161   // Memory1 knows it's size because it created it.
 162   EXPECT_EQ(memory1.requested_size(), kDataSize);
 163
 164   rv = memory1.Map(kDataSize);
 165   EXPECT_TRUE(rv);
 166
 167   // The mapped memory1 must be at least the size we asked for.
 168   EXPECT_GE(memory1.mapped_size(), kDataSize);
 169
 170   // The mapped memory1 shouldn't exceed rounding for allocation granularity.
 171   EXPECT_LT(memory1.mapped_size(),
 172             kDataSize + base::SysInfo::VMAllocationGranularity());
 173
 174   memset(memory1.memory(), 'G', kDataSize);
 175
 176   SharedMemory memory2;
 177   // Should not be able to create if openExisting is false.
 178   rv = memory2.CreateNamedDeprecated(test_name, false, kDataSize2);
 179   EXPECT_FALSE(rv);
 180
 181   // Should be able to create with openExisting true.
 182   rv = memory2.CreateNamedDeprecated(test_name, true, kDataSize2);
 183   EXPECT_TRUE(rv);
 184
 185   // Memory2 shouldn't know the size because we didn't create it.
 186   EXPECT_EQ(memory2.requested_size(), 0U);
 187
 188   // We should be able to map the original size.
 189   rv = memory2.Map(kDataSize);
 190   EXPECT_TRUE(rv);
 191
 192   // The mapped memory2 must be at least the size of the original.
 193   EXPECT_GE(memory2.mapped_size(), kDataSize);
 194
 195   // The mapped memory2 shouldn't exceed rounding for allocation granularity.
 196   EXPECT_LT(memory2.mapped_size(),
 197             kDataSize2 + base::SysInfo::VMAllocationGranularity());
 198
 199   // Verify that opening memory2 didn't truncate or delete memory 1.
 200   char *start_ptr = static_cast<char *>(memory2.memory());
 201   char *end_ptr = start_ptr + kDataSize;
 202   for (char* ptr = start_ptr; ptr < end_ptr; ptr++) {
 203     EXPECT_EQ(*ptr, 'G');
 204   }
 205
 206   memory1.Close();
 207   memory2.Close();
 208
 209   rv = memory1.Delete(test_name);
 210   EXPECT_TRUE(rv);
 211 }
 212 #endif
 213
 214 // Check that memory is still mapped after its closed.
 215 TEST(SharedMemoryTest, CloseNoUnmap) {
 216   const size_t kDataSize = 4096;
 217
 218   SharedMemory memory;
 219   ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
 220   char* ptr = static_cast<char*>(memory.memory());
 221   ASSERT_NE(ptr, static_cast<void*>(NULL));
 222   memset(ptr, 'G', kDataSize);
 223
 224   memory.Close();
 225
 226   EXPECT_EQ(ptr, memory.memory());
 227   EXPECT_EQ(SharedMemory::NULLHandle(), memory.handle());
 228
 229   for (size_t i = 0; i < kDataSize; i++) {
 230     EXPECT_EQ('G', ptr[i]);
 231   }
 232
 233   memory.Unmap();
 234   EXPECT_EQ(nullptr, memory.memory());
 235 }
 236
 237 // Create a set of N threads to each open a shared memory segment and write to
 238 // it. Verify that they are always reading/writing consistent data.
 239 TEST(SharedMemoryTest, MultipleThreads) {
 240   MultipleThreadMain::CleanUp();
 241   // On POSIX we have a problem when 2 threads try to create the shmem
 242   // (a file) at exactly the same time, since create both creates the
 243   // file and zerofills it.  We solve the problem for this unit test
 244   // (make it not flaky) by starting with 1 thread, then
 245   // intentionally don't clean up its shmem before running with
 246   // kNumThreads.
 247
 248   int threadcounts[] = { 1, kNumThreads };
 249   for (size_t i = 0; i < arraysize(threadcounts); i++) {
 250     int numthreads = threadcounts[i];
 251     scoped_ptr<PlatformThreadHandle[]> thread_handles;
 252     scoped_ptr<MultipleThreadMain*[]> thread_delegates;
 253
 254     thread_handles.reset(new PlatformThreadHandle[numthreads]);
 255     thread_delegates.reset(new MultipleThreadMain*[numthreads]);
 256
 257     // Spawn the threads.
 258     for (int16 index = 0; index < numthreads; index++) {
 259       PlatformThreadHandle pth;
 260       thread_delegates[index] = new MultipleThreadMain(index);
 261       EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
 262       thread_handles[index] = pth;
 263     }
 264
 265     // Wait for the threads to finish.
 266     for (int index = 0; index < numthreads; index++) {
 267       PlatformThread::Join(thread_handles[index]);
 268       delete thread_delegates[index];
 269     }
 270   }
 271   MultipleThreadMain::CleanUp();
 272 }
 273
 274 // Allocate private (unique) shared memory with an empty string for a
 275 // name.  Make sure several of them don't point to the same thing as
 276 // we might expect if the names are equal.
 277 TEST(SharedMemoryTest, AnonymousPrivate) {
 278   int i, j;
 279   int count = 4;
 280   bool rv;
 281   const uint32 kDataSize = 8192;
 282
 283   scoped_ptr<SharedMemory[]> memories(new SharedMemory[count]);
 284   scoped_ptr<int*[]> pointers(new int*[count]);
 285   ASSERT_TRUE(memories.get());
 286   ASSERT_TRUE(pointers.get());
 287
 288   for (i = 0; i < count; i++) {
 289     rv = memories[i].CreateAndMapAnonymous(kDataSize);
 290     EXPECT_TRUE(rv);
 291     int *ptr = static_cast<int*>(memories[i].memory());
 292     EXPECT_TRUE(ptr);
 293     pointers[i] = ptr;
 294   }
 295
 296   for (i = 0; i < count; i++) {
 297     // zero out the first int in each except for i; for that one, make it 100.
 298     for (j = 0; j < count; j++) {
 299       if (i == j)
 300         pointers[j][0] = 100;
 301       else
 302         pointers[j][0] = 0;
 303     }
 304     // make sure there is no bleeding of the 100 into the other pointers
 305     for (j = 0; j < count; j++) {
 306       if (i == j)
 307         EXPECT_EQ(100, pointers[j][0]);
 308       else
 309         EXPECT_EQ(0, pointers[j][0]);
 310     }
 311   }
 312
 313   for (int i = 0; i < count; i++) {
 314     memories[i].Close();
 315   }
 316 }
 317
 318 TEST(SharedMemoryTest, ShareReadOnly) {
 319   StringPiece contents = "Hello World";
 320
 321   SharedMemory writable_shmem;
 322   SharedMemoryCreateOptions options;
 323   options.size = contents.size();
 324   options.share_read_only = true;
 325   ASSERT_TRUE(writable_shmem.Create(options));
 326   ASSERT_TRUE(writable_shmem.Map(options.size));
 327   memcpy(writable_shmem.memory(), contents.data(), contents.size());
 328   EXPECT_TRUE(writable_shmem.Unmap());
 329
 330   SharedMemoryHandle readonly_handle;
 331   ASSERT_TRUE(writable_shmem.ShareReadOnlyToProcess(GetCurrentProcessHandle(),
 332                                                     &readonly_handle));
 333   SharedMemory readonly_shmem(readonly_handle, /*readonly=*/true);
 334
 335   ASSERT_TRUE(readonly_shmem.Map(contents.size()));
 336   EXPECT_EQ(contents,
 337             StringPiece(static_cast<const char*>(readonly_shmem.memory()),
 338                         contents.size()));
 339   EXPECT_TRUE(readonly_shmem.Unmap());
 340
 341   // Make sure the writable instance is still writable.
 342   ASSERT_TRUE(writable_shmem.Map(contents.size()));
 343   StringPiece new_contents = "Goodbye";
 344   memcpy(writable_shmem.memory(), new_contents.data(), new_contents.size());
 345   EXPECT_EQ(new_contents,
 346             StringPiece(static_cast<const char*>(writable_shmem.memory()),
 347                         new_contents.size()));
 348
 349   // We'd like to check that if we send the read-only segment to another
 350   // process, then that other process can't reopen it read/write.  (Since that
 351   // would be a security hole.)  Setting up multiple processes is hard in a
 352   // unittest, so this test checks that the *current* process can't reopen the
 353   // segment read/write.  I think the test here is stronger than we actually
 354   // care about, but there's a remote possibility that sending a file over a
 355   // pipe would transform it into read/write.
 356   SharedMemoryHandle handle = readonly_shmem.handle();
 357
 358 #if defined(OS_ANDROID)
 359   // The "read-only" handle is still writable on Android:
 360   // http://crbug.com/320865
 361   (void)handle;
 362 #elif defined(OS_POSIX)
 363   int handle_fd = SharedMemory::GetFdFromSharedMemoryHandle(handle);
 364   EXPECT_EQ(O_RDONLY, fcntl(handle_fd, F_GETFL) & O_ACCMODE)
 365       << "The descriptor itself should be read-only.";
 366
 367   errno = 0;
 368   void* writable = mmap(NULL, contents.size(), PROT_READ | PROT_WRITE,
 369                         MAP_SHARED, handle_fd, 0);
 370   int mmap_errno = errno;
 371   EXPECT_EQ(MAP_FAILED, writable)
 372       << "It shouldn't be possible to re-mmap the descriptor writable.";
 373   EXPECT_EQ(EACCES, mmap_errno) << strerror(mmap_errno);
 374   if (writable != MAP_FAILED)
 375     EXPECT_EQ(0, munmap(writable, readonly_shmem.mapped_size()));
 376
 377 #elif defined(OS_WIN)
 378   EXPECT_EQ(NULL, MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, 0))
 379       << "Shouldn't be able to map memory writable.";
 380
 381   HANDLE temp_handle;
 382   BOOL rv = ::DuplicateHandle(GetCurrentProcess(),
 383                               handle,
 384                               GetCurrentProcess(),
 385                               &temp_handle,
 386                               FILE_MAP_ALL_ACCESS,
 387                               false,
 388                               0);
 389   EXPECT_EQ(FALSE, rv)
 390       << "Shouldn't be able to duplicate the handle into a writable one.";
 391   if (rv)
 392     base::win::ScopedHandle writable_handle(temp_handle);
 393   rv = ::DuplicateHandle(GetCurrentProcess(),
 394                          handle,
 395                          GetCurrentProcess(),
 396                          &temp_handle,
 397                          FILE_MAP_READ,
 398                          false,
 399                          0);
 400   EXPECT_EQ(TRUE, rv)
 401       << "Should be able to duplicate the handle into a readable one.";
 402   if (rv)
 403     base::win::ScopedHandle writable_handle(temp_handle);
 404 #else
 405 #error Unexpected platform; write a test that tries to make 'handle' writable.
 406 #endif  // defined(OS_POSIX) || defined(OS_WIN)
 407 }
 408
 409 TEST(SharedMemoryTest, ShareToSelf) {
 410   StringPiece contents = "Hello World";
 411
 412   SharedMemory shmem;
 413   ASSERT_TRUE(shmem.CreateAndMapAnonymous(contents.size()));
 414   memcpy(shmem.memory(), contents.data(), contents.size());
 415   EXPECT_TRUE(shmem.Unmap());
 416
 417   SharedMemoryHandle shared_handle;
 418   ASSERT_TRUE(shmem.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 419   SharedMemory shared(shared_handle, /*readonly=*/false);
 420
 421   ASSERT_TRUE(shared.Map(contents.size()));
 422   EXPECT_EQ(
 423       contents,
 424       StringPiece(static_cast<const char*>(shared.memory()), contents.size()));
 425
 426   ASSERT_TRUE(shmem.ShareToProcess(GetCurrentProcessHandle(), &shared_handle));
 427   SharedMemory readonly(shared_handle, /*readonly=*/true);
 428
 429   ASSERT_TRUE(readonly.Map(contents.size()));
 430   EXPECT_EQ(contents,
 431             StringPiece(static_cast<const char*>(readonly.memory()),
 432                         contents.size()));
 433 }
 434
 435 TEST(SharedMemoryTest, MapAt) {
 436   ASSERT_TRUE(SysInfo::VMAllocationGranularity() >= sizeof(uint32));
 437   const size_t kCount = SysInfo::VMAllocationGranularity();
 438   const size_t kDataSize = kCount * sizeof(uint32);
 439
 440   SharedMemory memory;
 441   ASSERT_TRUE(memory.CreateAndMapAnonymous(kDataSize));
 442   uint32* ptr = static_cast<uint32*>(memory.memory());
 443   ASSERT_NE(ptr, static_cast<void*>(NULL));
 444
 445   for (size_t i = 0; i < kCount; ++i) {
 446     ptr[i] = i;
 447   }
 448
 449   memory.Unmap();
 450
 451   off_t offset = SysInfo::VMAllocationGranularity();
 452   ASSERT_TRUE(memory.MapAt(offset, kDataSize - offset));
 453   offset /= sizeof(uint32);
 454   ptr = static_cast<uint32*>(memory.memory());
 455   ASSERT_NE(ptr, static_cast<void*>(NULL));
 456   for (size_t i = offset; i < kCount; ++i) {
 457     EXPECT_EQ(ptr[i - offset], i);
 458   }
 459 }
 460
 461 TEST(SharedMemoryTest, MapTwice) {
 462   const uint32 kDataSize = 1024;
 463   SharedMemory memory;
 464   bool rv = memory.CreateAndMapAnonymous(kDataSize);
 465   EXPECT_TRUE(rv);
 466
 467   void* old_address = memory.memory();
 468
 469   rv = memory.Map(kDataSize);
 470   EXPECT_FALSE(rv);
 471   EXPECT_EQ(old_address, memory.memory());
 472 }
 473
 474 #if defined(OS_POSIX)
 475 // This test is not applicable for iOS (crbug.com/399384).
 476 #if !defined(OS_IOS)
 477 // Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
 478 TEST(SharedMemoryTest, AnonymousExecutable) {
 479   const uint32 kTestSize = 1 << 16;
 480
 481   SharedMemory shared_memory;
 482   SharedMemoryCreateOptions options;
 483   options.size = kTestSize;
 484   options.executable = true;
 485
 486   EXPECT_TRUE(shared_memory.Create(options));
 487   EXPECT_TRUE(shared_memory.Map(shared_memory.requested_size()));
 488
 489   EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.requested_size(),
 490                         PROT_READ | PROT_EXEC));
 491 }
 492 #endif  // !defined(OS_IOS)
 493
 494 // Android supports a different permission model than POSIX for its "ashmem"
 495 // shared memory implementation. So the tests about file permissions are not
 496 // included on Android.
 497 #if !defined(OS_ANDROID)
 498
 499 // Set a umask and restore the old mask on destruction.
 500 class ScopedUmaskSetter {
 501  public:
 502   explicit ScopedUmaskSetter(mode_t target_mask) {
 503     old_umask_ = umask(target_mask);
 504   }
 505   ~ScopedUmaskSetter() { umask(old_umask_); }
 506  private:
 507   mode_t old_umask_;
 508   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedUmaskSetter);
 509 };
 510
 511 // Create a shared memory object, check its permissions.
 512 TEST(SharedMemoryTest, FilePermissionsAnonymous) {
 513   const uint32 kTestSize = 1 << 8;
 514
 515   SharedMemory shared_memory;
 516   SharedMemoryCreateOptions options;
 517   options.size = kTestSize;
 518   // Set a file mode creation mask that gives all permissions.
 519   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
 520
 521   EXPECT_TRUE(shared_memory.Create(options));
 522
 523   int shm_fd =
 524       SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
 525   struct stat shm_stat;
 526   EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
 527   // Neither the group, nor others should be able to read the shared memory
 528   // file.
 529   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
 530   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 531 }
 532
 533 // Create a shared memory object, check its permissions.
 534 TEST(SharedMemoryTest, FilePermissionsNamed) {
 535   const uint32 kTestSize = 1 << 8;
 536
 537   SharedMemory shared_memory;
 538   SharedMemoryCreateOptions options;
 539   options.size = kTestSize;
 540   std::string shared_mem_name = "shared_perm_test-" + IntToString(getpid()) +
 541       "-" + Uint64ToString(RandUint64());
 542   options.name_deprecated = &shared_mem_name;
 543   // Set a file mode creation mask that gives all permissions.
 544   ScopedUmaskSetter permissive_mask(S_IWGRP | S_IWOTH);
 545
 546   EXPECT_TRUE(shared_memory.Create(options));
 547   // Clean-up the backing file name immediately, we don't need it.
 548   EXPECT_TRUE(shared_memory.Delete(shared_mem_name));
 549
 550   int shm_fd =
 551       SharedMemory::GetFdFromSharedMemoryHandle(shared_memory.handle());
 552   struct stat shm_stat;
 553   EXPECT_EQ(0, fstat(shm_fd, &shm_stat));
 554   // Neither the group, nor others should have been able to open the shared
 555   // memory file while its name existed.
 556   EXPECT_FALSE(shm_stat.st_mode & S_IRWXO);
 557   EXPECT_FALSE(shm_stat.st_mode & S_IRWXG);
 558 }
 559 #endif  // !defined(OS_ANDROID)
 560
 561 #endif  // defined(OS_POSIX)
 562
 563 // Map() will return addresses which are aligned to the platform page size, this
 564 // varies from platform to platform though.  Since we'd like to advertise a
 565 // minimum alignment that callers can count on, test for it here.
 566 TEST(SharedMemoryTest, MapMinimumAlignment) {
 567   static const int kDataSize = 8192;
 568
 569   SharedMemory shared_memory;
 570   ASSERT_TRUE(shared_memory.CreateAndMapAnonymous(kDataSize));
 571   EXPECT_EQ(0U, reinterpret_cast<uintptr_t>(
 572       shared_memory.memory()) & (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
 573   shared_memory.Close();
 574 }
 575
 576 // iOS does not allow multiple processes.
 577 // Android ashmem doesn't support named shared memory.
 578 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 579
 580 // On POSIX it is especially important we test shmem across processes,
 581 // not just across threads.  But the test is enabled on all platforms.
 582 class SharedMemoryProcessTest : public MultiProcessTest {
 583  public:
 584
 585   static void CleanUp() {
 586     SharedMemory memory;
 587     memory.Delete(s_test_name_);
 588   }
 589
 590   static int TaskTestMain() {
 591     int errors = 0;
 592 #if defined(OS_MACOSX)
 593     mac::ScopedNSAutoreleasePool pool;
 594 #endif
 595     SharedMemory memory;
 596     bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
 597     EXPECT_TRUE(rv);
 598     if (rv != true)
 599       errors++;
 600     rv = memory.Map(s_data_size_);
 601     EXPECT_TRUE(rv);
 602     if (rv != true)
 603       errors++;
 604     int *ptr = static_cast<int*>(memory.memory());
 605
 606     // This runs concurrently in multiple processes. Writes need to be atomic.
 607     base::subtle::Barrier_AtomicIncrement(ptr, 1);
 608     memory.Close();
 609     return errors;
 610   }
 611
 612   static const char* const s_test_name_;
 613   static const uint32 s_data_size_;
 614 };
 615
 616 const char* const SharedMemoryProcessTest::s_test_name_ = "MPMem";
 617 const uint32 SharedMemoryProcessTest::s_data_size_ = 1024;
 618
 619 TEST_F(SharedMemoryProcessTest, SharedMemoryAcrossProcesses) {
 620   SharedMemoryProcessTest::CleanUp();
 621
 622   // Create a shared memory region. Set the first word to 0.
 623   SharedMemory memory;
 624   bool rv = memory.CreateNamedDeprecated(s_test_name_, true, s_data_size_);
 625   ASSERT_TRUE(rv);
 626   rv = memory.Map(s_data_size_);
 627   ASSERT_TRUE(rv);
 628   int* ptr = static_cast<int*>(memory.memory());
 629   *ptr = 0;
 630
 631   // Start |kNumTasks| processes, each of which atomically increments the first
 632   // word by 1.
 633   Process processes[kNumTasks];
 634   for (int index = 0; index < kNumTasks; ++index) {
 635     processes[index] = SpawnChild("SharedMemoryTestMain");
 636     ASSERT_TRUE(processes[index].IsValid());
 637   }
 638
 639   // Check that each process exited correctly.
 640   int exit_code = 0;
 641   for (int index = 0; index < kNumTasks; ++index) {
 642     EXPECT_TRUE(processes[index].WaitForExit(&exit_code));
 643     EXPECT_EQ(0, exit_code);
 644   }
 645
 646   // Check that the shared memory region reflects |kNumTasks| increments.
 647   ASSERT_EQ(kNumTasks, *ptr);
 648
 649   memory.Close();
 650   SharedMemoryProcessTest::CleanUp();
 651 }
 652
 653 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
 654   return SharedMemoryProcessTest::TaskTestMain();
 655 }
 656
 657 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
 658
 659 }  // namespace base