Improvements for MachMultiprocess

util/test/mac/mach_multiprocess.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 49 matching lines @@
 namespace crashpad {
 namespace test {
 
 using namespace testing;
 
 namespace internal {
 
 struct MachMultiprocessInfo {
   MachMultiprocessInfo()
       : service_name(),
-        read_pipe(-1),
-        write_pipe(-1),
+        pipe_c2p_read(-1),
+        pipe_c2p_write(-1),
+        pipe_p2c_read(-1),
+        pipe_p2c_write(-1),
         child_pid(0),
-        pipe_fd(-1),
+        read_pipe_fd(-1),
+        write_pipe_fd(-1),
         local_port(MACH_PORT_NULL),
         remote_port(MACH_PORT_NULL),
         child_task(MACH_PORT_NULL) {}
 
   std::string service_name;
-  base::ScopedFD read_pipe;
-  base::ScopedFD write_pipe;
+  base::ScopedFD pipe_c2p_read;  // child to parent
+  base::ScopedFD pipe_c2p_write;  // child to parent
+  base::ScopedFD pipe_p2c_read;  // parent to child
+  base::ScopedFD pipe_p2c_write;  // parent to child
   pid_t child_pid;  // valid only in parent
-  int pipe_fd;  // read_pipe in parent, write_pipe in child
+  int read_pipe_fd;  // pipe_c2p_read in parent, pipe_p2c_read in child
+  int write_pipe_fd;  // pipe_p2c_write in parent, pipe_c2p_write in child
   base::mac::ScopedMachReceiveRight local_port;
   base::mac::ScopedMachSendRight remote_port;
   base::mac::ScopedMachSendRight child_task;  // valid only in parent
 };
 
 }  // namespace internal
 
 MachMultiprocess::MachMultiprocess() : info_(NULL) {
 }
 
 void MachMultiprocess::Run() {
   ASSERT_EQ(NULL, info_);
   scoped_ptr<internal::MachMultiprocessInfo> info(
       new internal::MachMultiprocessInfo);
   base::AutoReset<internal::MachMultiprocessInfo*> reset_info(&info_,
                                                               info.get());
 
-  int pipe_fds[2];
-  int rv = pipe(pipe_fds);
+  int pipe_fds_c2p[2];
+  int rv = pipe(pipe_fds_c2p);
   ASSERT_EQ(0, rv) << ErrnoMessage("pipe");
 
-  info_->read_pipe.reset(pipe_fds[0]);
-  info_->write_pipe.reset(pipe_fds[1]);
+  info_->pipe_c2p_read.reset(pipe_fds_c2p[0]);
+  info_->pipe_c2p_write.reset(pipe_fds_c2p[1]);
+
+  int pipe_fds_p2c[2];
+  rv = pipe(pipe_fds_p2c);
+  ASSERT_EQ(0, rv) << ErrnoMessage("pipe");
+
+  info_->pipe_p2c_read.reset(pipe_fds_p2c[0]);
+  info_->pipe_p2c_write.reset(pipe_fds_p2c[1]);
 
   // Set up the parent port and register it with the bootstrap server before
   // forking, so that it’s guaranteed to be there when the child attempts to
   // look it up.
   info_->service_name = "com.googlecode.crashpad.test.mach_multiprocess.";
   for (int index = 0; index < 16; ++index) {
     info_->service_name.append(1, base::RandInt('A', 'Z'));
   }
 
   mach_port_t local_port;
@@ skipping 46 matching lines @@
 }
 
 MachMultiprocess::~MachMultiprocess() {
 }
 
 pid_t MachMultiprocess::ChildPID() const {
   EXPECT_NE(0, info_->child_pid);
   return info_->child_pid;
 }
 
-int MachMultiprocess::PipeFD() const {
-  EXPECT_NE(-1, info_->pipe_fd);
-  return info_->pipe_fd;
+int MachMultiprocess::ReadPipeFD() const {
+  EXPECT_NE(-1, info_->read_pipe_fd);
+  return info_->read_pipe_fd;
+}
+
+int MachMultiprocess::WritePipeFD() const {
+  EXPECT_NE(-1, info_->write_pipe_fd);
+  return info_->write_pipe_fd;
 }
 
 mach_port_t MachMultiprocess::LocalPort() const {
   EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL), info_->local_port);
   return info_->local_port;
 }
 
 mach_port_t MachMultiprocess::RemotePort() const {
   EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL), info_->remote_port);
   return info_->remote_port;
 }
 
 mach_port_t MachMultiprocess::ChildTask() const {
   EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL), info_->child_task);
   return info_->child_task;
 }
 
 void MachMultiprocess::RunParent() {
-  // The parent uses the read end of the pipe.
-  info_->write_pipe.reset();
-  info_->pipe_fd = info_->read_pipe.get();
+  // The parent uses the read end of c2p and the write end of p2c.
+  info_->pipe_c2p_write.reset();
+  info_->read_pipe_fd = info_->pipe_c2p_read.get();
+  info_->pipe_p2c_read.reset();
+  info_->write_pipe_fd = info_->pipe_p2c_write.get();
 
   ReceiveHelloMessage message = {};
 
   kern_return_t kr =
       mach_msg(&message.header,
                MACH_RCV_MSG | MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0) |
                    MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT),
                0,
                sizeof(message),
                info_->local_port,
@@ skipping 71 matching lines @@
   int mach_pid;
   kr = pid_for_task(info_->child_task, &mach_pid);
   ASSERT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "pid_for_task");
   ASSERT_EQ(ChildPID(), mach_pid);
 
   Parent();
 
   info_->remote_port.reset();
   info_->local_port.reset();
 
-  info_->pipe_fd = -1;
-  info_->read_pipe.reset();
+  info_->read_pipe_fd = -1;
+  info_->pipe_c2p_read.reset();
+  info_->write_pipe_fd = -1;
+  info_->pipe_p2c_write.reset();
 }
 
 void MachMultiprocess::RunChild() {
   ScopedNotReached must_not_leave_this_scope;
 
   // local_port is not valid in the forked child process.
   ignore_result(info_->local_port.release());
 
-  // The child uses the write end of the pipe.
-  info_->read_pipe.reset();
-  info_->pipe_fd = info_->write_pipe.get();
+  // The child uses the write end of c2p and the read end of p2c.
+  info_->pipe_c2p_read.reset();
+  info_->write_pipe_fd = info_->pipe_c2p_write.get();
+  info_->pipe_p2c_write.reset();
+  info_->read_pipe_fd = info_->pipe_p2c_read.get();
 
   mach_port_t local_port;
   kern_return_t kr = mach_port_allocate(
       mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &local_port);
   ASSERT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "mach_port_allocate");
   info_->local_port.reset(local_port);
 
   // The remote port can be obtained from the bootstrap server.
   mach_port_t remote_port;
   kr = bootstrap_look_up(
@@ skipping 24 matching lines @@
                 MACH_PORT_NULL,
                 MACH_MSG_TIMEOUT_NONE,
                 MACH_PORT_NULL);
   ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
   Child();
 
   info_->remote_port.reset();
   info_->local_port.reset();
 
-  info_->pipe_fd = -1;
-  info_->write_pipe.reset();
+  info_->write_pipe_fd = -1;
+  info_->pipe_c2p_write.reset();
+  info_->read_pipe_fd = -1;
+  info_->pipe_p2c_read.reset();
 
   if (Test::HasFailure()) {
     // Trigger the ScopedNotReached destructor.
     return;
   }
 
   exit(0);
 }
 
 }  // namespace test
 }  // namespace crashpad