OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <mach/mach.h> | 5 #include <mach/mach.h> |
6 #include <mach/mach_vm.h> | 6 #include <mach/mach_vm.h> |
7 #include <servers/bootstrap.h> | 7 #include <servers/bootstrap.h> |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 | 10 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
47 MACH_LOG(ERROR, kr) << "Failed to get region info."; | 47 MACH_LOG(ERROR, kr) << "Failed to get region info."; |
48 return false; | 48 return false; |
49 } | 49 } |
50 | 50 |
51 *current = basic_info.protection; | 51 *current = basic_info.protection; |
52 *max = basic_info.max_protection; | 52 *max = basic_info.max_protection; |
53 return true; | 53 return true; |
54 } | 54 } |
55 | 55 |
56 // Creates a new SharedMemory with the given |size|, filled with 'a'. | 56 // Creates a new SharedMemory with the given |size|, filled with 'a'. |
57 scoped_ptr<SharedMemory> CreateSharedMemory(int size) { | 57 std::unique_ptr<SharedMemory> CreateSharedMemory(int size) { |
58 SharedMemoryHandle shm(size); | 58 SharedMemoryHandle shm(size); |
59 if (!shm.IsValid()) { | 59 if (!shm.IsValid()) { |
60 LOG(ERROR) << "Failed to make SharedMemoryHandle"; | 60 LOG(ERROR) << "Failed to make SharedMemoryHandle"; |
61 return nullptr; | 61 return nullptr; |
62 } | 62 } |
63 scoped_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false)); | 63 std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false)); |
64 shared_memory->Map(size); | 64 shared_memory->Map(size); |
65 memset(shared_memory->memory(), 'a', size); | 65 memset(shared_memory->memory(), 'a', size); |
66 return shared_memory; | 66 return shared_memory; |
67 } | 67 } |
68 | 68 |
69 static const std::string g_service_switch_name = "service_name"; | 69 static const std::string g_service_switch_name = "service_name"; |
70 | 70 |
71 // Structs used to pass a mach port from client to server. | 71 // Structs used to pass a mach port from client to server. |
72 struct MachSendPortMessage { | 72 struct MachSendPortMessage { |
73 mach_msg_header_t header; | 73 mach_msg_header_t header; |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
227 | 227 |
228 // Tests that content written to shared memory in the server process can be read | 228 // Tests that content written to shared memory in the server process can be read |
229 // by the child process. | 229 // by the child process. |
230 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) { | 230 TEST_F(SharedMemoryMacMultiProcessTest, MachBasedSharedMemory) { |
231 // Mach-based SharedMemory isn't support on OSX 10.6. | 231 // Mach-based SharedMemory isn't support on OSX 10.6. |
232 if (mac::IsOSSnowLeopard()) | 232 if (mac::IsOSSnowLeopard()) |
233 return; | 233 return; |
234 | 234 |
235 SetUpChild("MachBasedSharedMemoryClient"); | 235 SetUpChild("MachBasedSharedMemoryClient"); |
236 | 236 |
237 scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size)); | 237 std::unique_ptr<SharedMemory> shared_memory( |
| 238 CreateSharedMemory(s_memory_size)); |
238 | 239 |
239 // Send the underlying memory object to the client process. | 240 // Send the underlying memory object to the client process. |
240 SendMachPort(client_port_.get(), shared_memory->handle().GetMemoryObject(), | 241 SendMachPort(client_port_.get(), shared_memory->handle().GetMemoryObject(), |
241 MACH_MSG_TYPE_COPY_SEND); | 242 MACH_MSG_TYPE_COPY_SEND); |
242 int rv = -1; | 243 int rv = -1; |
243 ASSERT_TRUE(child_process_.WaitForExitWithTimeout( | 244 ASSERT_TRUE(child_process_.WaitForExitWithTimeout( |
244 TestTimeouts::action_timeout(), &rv)); | 245 TestTimeouts::action_timeout(), &rv)); |
245 EXPECT_EQ(0, rv); | 246 EXPECT_EQ(0, rv); |
246 } | 247 } |
247 | 248 |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
340 } | 341 } |
341 | 342 |
342 // Tests that Mach shared memory can be mapped and unmapped. | 343 // Tests that Mach shared memory can be mapped and unmapped. |
343 TEST_F(SharedMemoryMacMultiProcessTest, MachUnmapMap) { | 344 TEST_F(SharedMemoryMacMultiProcessTest, MachUnmapMap) { |
344 // Mach-based SharedMemory isn't support on OSX 10.6. | 345 // Mach-based SharedMemory isn't support on OSX 10.6. |
345 if (mac::IsOSSnowLeopard()) | 346 if (mac::IsOSSnowLeopard()) |
346 return; | 347 return; |
347 | 348 |
348 mach_msg_type_number_t active_name_count = GetActiveNameCount(); | 349 mach_msg_type_number_t active_name_count = GetActiveNameCount(); |
349 | 350 |
350 scoped_ptr<SharedMemory> shared_memory = CreateSharedMemory(s_memory_size); | 351 std::unique_ptr<SharedMemory> shared_memory = |
| 352 CreateSharedMemory(s_memory_size); |
351 ASSERT_TRUE(shared_memory->Unmap()); | 353 ASSERT_TRUE(shared_memory->Unmap()); |
352 ASSERT_TRUE(shared_memory->Map(s_memory_size)); | 354 ASSERT_TRUE(shared_memory->Map(s_memory_size)); |
353 shared_memory.reset(); | 355 shared_memory.reset(); |
354 EXPECT_EQ(active_name_count, GetActiveNameCount()); | 356 EXPECT_EQ(active_name_count, GetActiveNameCount()); |
355 } | 357 } |
356 | 358 |
357 // Tests that passing a SharedMemoryHandle to a SharedMemory object also passes | 359 // Tests that passing a SharedMemoryHandle to a SharedMemory object also passes |
358 // ownership, and that destroying the SharedMemory closes the SharedMemoryHandle | 360 // ownership, and that destroying the SharedMemory closes the SharedMemoryHandle |
359 // as well. | 361 // as well. |
360 TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) { | 362 TEST_F(SharedMemoryMacMultiProcessTest, MachSharedMemoryTakesOwnership) { |
361 // Mach-based SharedMemory isn't support on OSX 10.6. | 363 // Mach-based SharedMemory isn't support on OSX 10.6. |
362 if (mac::IsOSSnowLeopard()) | 364 if (mac::IsOSSnowLeopard()) |
363 return; | 365 return; |
364 | 366 |
365 mach_msg_type_number_t active_name_count = GetActiveNameCount(); | 367 mach_msg_type_number_t active_name_count = GetActiveNameCount(); |
366 | 368 |
367 // Making a new SharedMemoryHandle increments the name count. | 369 // Making a new SharedMemoryHandle increments the name count. |
368 SharedMemoryHandle shm(s_memory_size); | 370 SharedMemoryHandle shm(s_memory_size); |
369 ASSERT_TRUE(shm.IsValid()); | 371 ASSERT_TRUE(shm.IsValid()); |
370 EXPECT_EQ(active_name_count + 1, GetActiveNameCount()); | 372 EXPECT_EQ(active_name_count + 1, GetActiveNameCount()); |
371 | 373 |
372 // Name count doesn't change when mapping the memory. | 374 // Name count doesn't change when mapping the memory. |
373 scoped_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false)); | 375 std::unique_ptr<SharedMemory> shared_memory(new SharedMemory(shm, false)); |
374 shared_memory->Map(s_memory_size); | 376 shared_memory->Map(s_memory_size); |
375 EXPECT_EQ(active_name_count + 1, GetActiveNameCount()); | 377 EXPECT_EQ(active_name_count + 1, GetActiveNameCount()); |
376 | 378 |
377 // Destroying the SharedMemory object frees the resource. | 379 // Destroying the SharedMemory object frees the resource. |
378 shared_memory.reset(); | 380 shared_memory.reset(); |
379 EXPECT_EQ(active_name_count, GetActiveNameCount()); | 381 EXPECT_EQ(active_name_count, GetActiveNameCount()); |
380 } | 382 } |
381 | 383 |
382 // Tests that the read-only flag works. | 384 // Tests that the read-only flag works. |
383 TEST_F(SharedMemoryMacMultiProcessTest, MachReadOnly) { | 385 TEST_F(SharedMemoryMacMultiProcessTest, MachReadOnly) { |
384 // Mach-based SharedMemory isn't support on OSX 10.6. | 386 // Mach-based SharedMemory isn't support on OSX 10.6. |
385 if (mac::IsOSSnowLeopard()) | 387 if (mac::IsOSSnowLeopard()) |
386 return; | 388 return; |
387 | 389 |
388 scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size)); | 390 std::unique_ptr<SharedMemory> shared_memory( |
| 391 CreateSharedMemory(s_memory_size)); |
389 | 392 |
390 SharedMemoryHandle shm2 = shared_memory->handle().Duplicate(); | 393 SharedMemoryHandle shm2 = shared_memory->handle().Duplicate(); |
391 ASSERT_TRUE(shm2.IsValid()); | 394 ASSERT_TRUE(shm2.IsValid()); |
392 SharedMemory shared_memory2(shm2, true); | 395 SharedMemory shared_memory2(shm2, true); |
393 shared_memory2.Map(s_memory_size); | 396 shared_memory2.Map(s_memory_size); |
394 ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), ""); | 397 ASSERT_DEATH(memset(shared_memory2.memory(), 'b', s_memory_size), ""); |
395 } | 398 } |
396 | 399 |
397 // Tests that the method ShareToProcess() works. | 400 // Tests that the method ShareToProcess() works. |
398 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcess) { | 401 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcess) { |
399 // Mach-based SharedMemory isn't support on OSX 10.6. | 402 // Mach-based SharedMemory isn't support on OSX 10.6. |
400 if (mac::IsOSSnowLeopard()) | 403 if (mac::IsOSSnowLeopard()) |
401 return; | 404 return; |
402 | 405 |
403 mach_msg_type_number_t active_name_count = GetActiveNameCount(); | 406 mach_msg_type_number_t active_name_count = GetActiveNameCount(); |
404 | 407 |
405 { | 408 { |
406 scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size)); | 409 std::unique_ptr<SharedMemory> shared_memory( |
| 410 CreateSharedMemory(s_memory_size)); |
407 | 411 |
408 SharedMemoryHandle shm2; | 412 SharedMemoryHandle shm2; |
409 ASSERT_TRUE(shared_memory->ShareToProcess(GetCurrentProcId(), &shm2)); | 413 ASSERT_TRUE(shared_memory->ShareToProcess(GetCurrentProcId(), &shm2)); |
410 ASSERT_TRUE(shm2.IsValid()); | 414 ASSERT_TRUE(shm2.IsValid()); |
411 SharedMemory shared_memory2(shm2, true); | 415 SharedMemory shared_memory2(shm2, true); |
412 shared_memory2.Map(s_memory_size); | 416 shared_memory2.Map(s_memory_size); |
413 | 417 |
414 ASSERT_EQ(0, memcmp(shared_memory->memory(), shared_memory2.memory(), | 418 ASSERT_EQ(0, memcmp(shared_memory->memory(), shared_memory2.memory(), |
415 s_memory_size)); | 419 s_memory_size)); |
416 } | 420 } |
417 | 421 |
418 EXPECT_EQ(active_name_count, GetActiveNameCount()); | 422 EXPECT_EQ(active_name_count, GetActiveNameCount()); |
419 } | 423 } |
420 | 424 |
421 // Tests that the method ShareReadOnlyToProcess() creates a memory object that | 425 // Tests that the method ShareReadOnlyToProcess() creates a memory object that |
422 // is read only. | 426 // is read only. |
423 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonly) { | 427 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonly) { |
424 // Mach-based SharedMemory isn't support on OSX 10.6. | 428 // Mach-based SharedMemory isn't support on OSX 10.6. |
425 if (mac::IsOSSnowLeopard()) | 429 if (mac::IsOSSnowLeopard()) |
426 return; | 430 return; |
427 | 431 |
428 scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size)); | 432 std::unique_ptr<SharedMemory> shared_memory( |
| 433 CreateSharedMemory(s_memory_size)); |
429 | 434 |
430 // Check the protection levels. | 435 // Check the protection levels. |
431 int current_prot, max_prot; | 436 int current_prot, max_prot; |
432 ASSERT_TRUE(GetProtections(shared_memory->memory(), | 437 ASSERT_TRUE(GetProtections(shared_memory->memory(), |
433 shared_memory->mapped_size(), ¤t_prot, | 438 shared_memory->mapped_size(), ¤t_prot, |
434 &max_prot)); | 439 &max_prot)); |
435 ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot); | 440 ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, current_prot); |
436 ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot); | 441 ASSERT_EQ(VM_PROT_READ | VM_PROT_WRITE, max_prot); |
437 | 442 |
438 // Make a new memory object. | 443 // Make a new memory object. |
(...skipping 25 matching lines...) Expand all Loading... |
464 | 469 |
465 // Tests that the method ShareReadOnlyToProcess() doesn't leak. | 470 // Tests that the method ShareReadOnlyToProcess() doesn't leak. |
466 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonlyLeak) { | 471 TEST_F(SharedMemoryMacMultiProcessTest, MachShareToProcessReadonlyLeak) { |
467 // Mach-based SharedMemory isn't support on OSX 10.6. | 472 // Mach-based SharedMemory isn't support on OSX 10.6. |
468 if (mac::IsOSSnowLeopard()) | 473 if (mac::IsOSSnowLeopard()) |
469 return; | 474 return; |
470 | 475 |
471 mach_msg_type_number_t active_name_count = GetActiveNameCount(); | 476 mach_msg_type_number_t active_name_count = GetActiveNameCount(); |
472 | 477 |
473 { | 478 { |
474 scoped_ptr<SharedMemory> shared_memory(CreateSharedMemory(s_memory_size)); | 479 std::unique_ptr<SharedMemory> shared_memory( |
| 480 CreateSharedMemory(s_memory_size)); |
475 | 481 |
476 SharedMemoryHandle shm2; | 482 SharedMemoryHandle shm2; |
477 ASSERT_TRUE( | 483 ASSERT_TRUE( |
478 shared_memory->ShareReadOnlyToProcess(GetCurrentProcId(), &shm2)); | 484 shared_memory->ShareReadOnlyToProcess(GetCurrentProcId(), &shm2)); |
479 ASSERT_TRUE(shm2.IsValid()); | 485 ASSERT_TRUE(shm2.IsValid()); |
480 | 486 |
481 // Intentionally map with |readonly| set to |false|. | 487 // Intentionally map with |readonly| set to |false|. |
482 SharedMemory shared_memory2(shm2, false); | 488 SharedMemory shared_memory2(shm2, false); |
483 shared_memory2.Map(s_memory_size); | 489 shared_memory2.Map(s_memory_size); |
484 } | 490 } |
485 | 491 |
486 EXPECT_EQ(active_name_count, GetActiveNameCount()); | 492 EXPECT_EQ(active_name_count, GetActiveNameCount()); |
487 } | 493 } |
488 | 494 |
489 } // namespace base | 495 } // namespace base |
OLD | NEW |