MachMessageServer test: deal with short receive queue lengths on 10.10

util/mach/mach_message_server_test.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 47 matching lines @@
           parent_wait_for_child_pipe(false),
           server_options(MACH_MSG_OPTION_NONE),
           server_persistent(MachMessageServer::kOneShot),
           server_nonblocking(MachMessageServer::kBlocking),
           server_timeout_ms(MACH_MSG_TIMEOUT_NONE),
           server_mig_retcode(KERN_SUCCESS),
           server_destroy_complex(true),
           expect_server_destroyed_complex(true),
           expect_server_result(KERN_SUCCESS),
           expect_server_transaction_count(1),
+          child_wait_for_parent_pipe_early(false),
           client_send_request_count(1),
           client_send_complex(false),
           client_send_large(false),
           client_reply_port_type(kReplyPortNormal),
           client_expect_reply(true),
           child_send_all_requests_before_receiving_any_replies(false),
-          child_wait_for_parent_pipe(false) {
+          child_wait_for_parent_pipe_late(false) {
     }
 
     // true if MachMessageServerFunction() is expected to be called.
     bool expect_server_interface_method_called;
 
     // true if the parent should wait for the child to write a byte to the pipe
     // as a signal that the child is ready for the parent to begin its side of
     // the test. This is used for nonblocking tests, which require that there
     // be something in the server’s queue before attempting a nonblocking
     // receive if the receive is to be successful.
@@ skipping 26 matching lines @@
     // server_destroy_complex is false, a complex message will be destroyed if
     // the MIG return code was unsuccessful.
     bool expect_server_destroyed_complex;
 
     // The expected return value from MachMessageServer::Run().
     kern_return_t expect_server_result;
 
     // The number of transactions that the server is expected to handle.
     size_t expect_server_transaction_count;
 
+    // true if the child should wait for the parent to signal that it’s ready
+    // for the child to begin sending requests via the pipe. This is done if the
+    // parent needs to perform operations on its receive port before the child
+    // should be permitted to send anything to it. Currently, this is used to
+    // allow the parent to ensure that the receive port’s queue length is high
+    // enough before the child begins attempting to fill it.
+    bool child_wait_for_parent_pipe_early;
+
     // The number of requests that the client should send to the server.
     size_t client_send_request_count;
 
     // true if the client should send a complex message, one that carries a port
     // descriptor in its body. Normally false.
     bool client_send_complex;
 
     // true if the client should send a larger message than the server has
     // allocated space to receive. If server_options contains MACH_RCV_LARGE,
     // the server will resize its buffer to receive the message. Otherwise, the
@@ skipping 17 matching lines @@
     // test, which requires the client to fill the server’s queue before the
     // server can attempt processing it.
     bool child_send_all_requests_before_receiving_any_replies;
 
     // true if the child should wait to receive a byte from the parent before
     // exiting. This can be used to keep a receive right in the child alive
     // until the parent has a chance to verify that it’s holding a send right.
     // Otherwise, the right might appear in the parent as a dead name if the
     // child exited before the parent had a chance to examine it. This would be
     // a race.
-    bool child_wait_for_parent_pipe;
+    bool child_wait_for_parent_pipe_late;
   };
 
   explicit TestMachMessageServer(const Options& options)
       : MachMessageServer::Interface(),
         MachMultiprocess(),
         options_(options),
         child_complex_message_port_(),
         parent_complex_message_port_(MACH_PORT_NULL) {
   }
 
@@ skipping 121 matching lines @@
     uint8_t data[4 * PAGE_SIZE];
   };
 
   struct ReplyMessage : public mig_reply_error_t {
     uint32_t number;
   };
 
   // MachMultiprocess:
 
   virtual void MachMultiprocessParent() override {
+    mach_port_t local_port = LocalPort();
+
+    kern_return_t kr;
+    if (options_.child_send_all_requests_before_receiving_any_replies) {
+      // On Mac OS X 10.10, the queue limit of a new Mach port seems to be 2
+      // by default, which is below the value of MACH_PORT_QLIMIT_DEFAULT. Set
+      // the port’s queue limit explicitly here.
+      mach_port_limits limits;

[Robert Sesek, 2014/09/22 15:15:56]

= {} in case this struct ever grows?

+      limits.mpl_qlimit = MACH_PORT_QLIMIT_DEFAULT;
+      kr = mach_port_set_attributes(mach_task_self(),
+                                    local_port,
+                                    MACH_PORT_LIMITS_INFO,
+                                    reinterpret_cast<mach_port_info_t>(&limits),
+                                    MACH_PORT_LIMITS_INFO_COUNT);
+      ASSERT_EQ(KERN_SUCCESS, kr)
+          << MachErrorMessage(kr, "mach_port_set_attributes");
+    }
+
+    if (options_.child_wait_for_parent_pipe_early) {
+      // Tell the child to begin sending messages.
+      char c = '\0';
+      CheckedWriteFD(WritePipeFD(), &c, 1);
+    }
+
     if (options_.parent_wait_for_child_pipe) {
       // Wait until the child is done sending what it’s going to send.
       char c;
       CheckedReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
-    kern_return_t kr;
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
-                                           LocalPort(),
+                                           local_port,
                                            options_.server_options,
                                            options_.server_persistent,
                                            options_.server_nonblocking,
                                            options_.server_timeout_ms)))
         << MachErrorMessage(kr, "MachMessageServer");
 
     if (options_.client_send_complex) {
       EXPECT_NE(kMachPortNull, parent_complex_message_port_);
       mach_port_type_t type;
 
@@ skipping 15 matching lines @@
       // The kernel won’t have reused the same name for another Mach port in
       // this task so soon. It’s possible that something else in this task could
       // have reused the name, but it’s unlikely for that to have happened in
       // this test environment.
       kr = mach_port_type(
           mach_task_self(), parent_complex_message_port_, &type);
       EXPECT_EQ(KERN_INVALID_NAME, kr)
           << MachErrorMessage(kr, "mach_port_type");
     }
 
-    if (options_.child_wait_for_parent_pipe) {
+    if (options_.child_wait_for_parent_pipe_late) {
       // Let the child know it’s safe to exit.
       char c = '\0';
       CheckedWriteFD(WritePipeFD(), &c, 1);
     }
   }
 
   virtual void MachMultiprocessChild() override {
+    if (options_.child_wait_for_parent_pipe_early) {
+      // Wait until the parent is done setting things up on its end.
+      char c;
+      CheckedReadFD(ReadPipeFD(), &c, 1);
+      EXPECT_EQ('\0', c);
+    }
+
     for (size_t index = 0;
          index < options_.client_send_request_count;
          ++index) {
       if (options_.child_send_all_requests_before_receiving_any_replies) {
         // For this test, all of the messages need to go into the queue before
         // the parent is allowed to start processing them. Don’t attempt to
         // process replies before all of the requests are sent, because the
         // server won’t have sent any replies until all of the requests are in
         // its queue.
         ChildSendRequest();
@@ skipping 17 matching lines @@
       for (size_t index = 0;
            index < options_.client_send_request_count;
            ++index) {
         ChildWaitForReply();
         if (testing::Test::HasFatalFailure()) {
           return;
         }
       }
     }
 
-    if (options_.child_wait_for_parent_pipe) {
+    if (options_.child_wait_for_parent_pipe_late) {
       char c;
       CheckedReadFD(ReadPipeFD(), &c, 1);
       ASSERT_EQ('\0', c);
     }
   }
 
   // In the child process, sends a request message to the server.
   void ChildSendRequest() {
     // local_receive_port_owner will the receive right that is created in this
     // scope and intended to be destroyed when leaving this scope, after it has
@@ skipping 240 matching lines @@
   // that it’s safe to start waiting for them in nonblocking mode. The server
   // then listens for them in nonblocking persistent mode, and receives all of
   // them because they’ve been queued up. The client doesn’t wait for the
   // replies until after it’s put all of its requests into the server’s queue.
   //
   // This test is sensitive to the length of the IPC queue limit. Mach ports
   // normally have a queue length limit of MACH_PORT_QLIMIT_DEFAULT (which is
   // MACH_PORT_QLIMIT_BASIC, or 5). The number of messages sent for this test
   // must be below this, because the server does not begin dequeueing request
   // messages until the client has finished sending them.
+  //
+  // The queue limit on new ports has been seen to be below
+  // MACH_PORT_QLIMIT_DEFAULT, so it will explicitly be set by
+  // mach_port_set_attributes() for this test. This needs to happen before the
+  // child is allowed to begin sending messages, so
+  // child_wait_for_parent_pipe_early is used to make the child wait until the
+  // parent is ready.
   const size_t kTransactionCount = 4;
   COMPILE_ASSERT(kTransactionCount <= MACH_PORT_QLIMIT_DEFAULT,
                  must_not_exceed_queue_limit);
 
   TestMachMessageServer::Options options;
   options.parent_wait_for_child_pipe = true;
   options.server_persistent = MachMessageServer::kPersistent;
   options.server_nonblocking = MachMessageServer::kNonblocking;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
   options.expect_server_transaction_count = kTransactionCount;
+  options.child_wait_for_parent_pipe_early = true;
   options.client_send_request_count = kTransactionCount;
   options.child_send_all_requests_before_receiving_any_replies = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ReturnCodeInvalidArgument) {
   // This tests that the mig_reply_error_t::RetCode field is properly returned
   // to the client.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = KERN_INVALID_ARGUMENT;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ReturnCodeNoReply) {
   // This tests that when mig_reply_error_t::RetCode is set to MIG_NO_REPLY, no
   // response is sent to the client.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = MIG_NO_REPLY;
   options.client_expect_reply = false;
-  options.child_wait_for_parent_pipe = true;
+  options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ReplyPortNull) {
   // The client sets its reply port to MACH_PORT_NULL. The server should see
   // this and avoid sending a message to the null port. No reply message is
   // sent and the server returns success.
   TestMachMessageServer::Options options;
   options.client_reply_port_type =
@@ skipping 22 matching lines @@
 
 TEST(MachMessageServer, Complex) {
   // The client allocates a new receive right and sends a complex request
   // message to the server with a send right made out of this receive right. The
   // server receives this message and is instructed to destroy the send right
   // when it is done handling the request-reply transaction. The former send
   // right is verified to be invalid after the server runs. This test ensures
   // that resources transferred to a server process temporarily aren’t leaked.
   TestMachMessageServer::Options options;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
+  options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexNotDestroyed) {
   // As in MachMessageServer.Complex, but the server is instructed not to
   // destroy the send right. After the server runs, the send right is verified
   // to continue to exist in the server task. The client process is then
   // signalled by pipe that it’s safe to exit so that the send right in the
   // server task doesn’t prematurely become a dead name. This test ensures that
   // rights that are expected to be retained in the server task are properly
   // retained.
   TestMachMessageServer::Options options;
   options.server_destroy_complex = false;
   options.expect_server_destroyed_complex = false;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
+  options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexDestroyedInvalidArgument) {
   // As in MachMessageServer.ComplexNotDestroyed, but the server does not return
   // a successful code via MIG. The server is expected to destroy resources in
   // this case, because server_destroy_complex = false is only honored when a
   // MIG request is handled successfully or with no reply.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = KERN_INVALID_TASK;
   options.server_destroy_complex = false;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
+  options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexNotDestroyedNoReply) {
   // As in MachMessageServer.ComplexNotDestroyed, but the server does not send
   // a reply message and is expected to retain the send right in the server
   // task.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = MIG_NO_REPLY;
   options.server_destroy_complex = false;
   options.expect_server_destroyed_complex = false;
   options.client_send_complex = true;
   options.client_expect_reply = false;
-  options.child_wait_for_parent_pipe = true;
+  options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, LargeUnexpected) {
   // The client sends a request to the server that is larger than the server is
   // expecting. The server did not specify MACH_RCV_LARGE in its options, so the
   // request is destroyed and the server returns a MACH_RCV_TOO_LARGE error. The
   // client does not receive a reply.
   TestMachMessageServer::Options options;
@@ skipping 11 matching lines @@
   // so a new buffer is allocated to receive the message. The server receives
   // the large request message, processes it, and returns a reply to the client.
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace