Add a ReceiveLarge parameter to MachMessageServer::Run()

util/mach/mach_message_server.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/mach_message_server.h"
 
 #include <limits>
 
+#include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_vm.h"
 #include "util/misc/clock.h"
 
 namespace crashpad {
 
 namespace {
 
 const int kNanosecondsPerMillisecond = 1E6;
 
 // TimerRunning determines whether |deadline| has passed. If |deadline| is in
@@ skipping 46 matching lines @@
 // mach_msg_server(), the |nonblocking| parameter to control blocking directly,
 // and the |timeout_ms| parameter allowing this function to not block
 // indefinitely.
 //
 // static
 mach_msg_return_t MachMessageServer::Run(Interface* interface,
                                          mach_port_t receive_port,
                                          mach_msg_options_t options,
                                          Persistent persistent,
                                          Nonblocking nonblocking,
+                                         ReceiveLarge receive_large,
                                          mach_msg_timeout_t timeout_ms) {
   options &= ~(MACH_RCV_MSG | MACH_SEND_MSG);
 
   mach_msg_options_t timeout_options = MACH_RCV_TIMEOUT | MACH_SEND_TIMEOUT |
                                        MACH_RCV_INTERRUPT | MACH_SEND_INTERRUPT;
 
   uint64_t deadline;
   if (nonblocking == kNonblocking) {
     options |= timeout_options;
     deadline = 0;
   } else if (timeout_ms != MACH_MSG_TIMEOUT_NONE) {
     options |= timeout_options;
     deadline = ClockMonotonicNanoseconds() +
                implicit_cast<uint64_t>(timeout_ms) * kNanosecondsPerMillisecond;
   } else {
     options &= ~timeout_options;
     deadline = 0;
   }
 
+  if (receive_large == kReceiveLargeResize) {
+    options |= MACH_RCV_LARGE;
+  } else {
+    options &= ~MACH_RCV_LARGE;
+  }
+
   mach_msg_size_t trailer_alloc = REQUESTED_TRAILER_SIZE(options);
   mach_msg_size_t max_request_size = interface->MachMessageServerRequestSize();
   mach_msg_size_t request_alloc = round_page(max_request_size + trailer_alloc);
-  mach_msg_size_t request_size = (options & MACH_RCV_LARGE)
+  mach_msg_size_t request_size = (receive_large == kReceiveLargeResize)
                                      ? request_alloc
                                      : max_request_size + trailer_alloc;
 
   mach_msg_size_t max_reply_size = interface->MachMessageServerReplySize();
   mach_msg_size_t reply_alloc = round_page(
       (options & MACH_SEND_TRAILER) ? (max_reply_size + MAX_TRAILER_SIZE)
                                     : max_reply_size);
 
   kern_return_t kr;
 
@@ skipping 10 matching lines @@
                        &request_addr,
                        this_request_alloc,
                        VM_FLAGS_ANYWHERE | VM_MAKE_TAG(VM_MEMORY_MACH_MSG));
       if (kr != KERN_SUCCESS) {
         return kr;
       }
       base::mac::ScopedMachVM trial_request_scoper(request_addr,
                                                    this_request_alloc);
       request_header = reinterpret_cast<mach_msg_header_t*>(request_addr);
 
+      bool run_mach_msg_receive = false;
       do {
         // If |options| contains MACH_RCV_INTERRUPT, retry mach_msg() in a loop
         // when it returns MACH_RCV_INTERRUPTED to recompute |remaining_ms|
         // rather than allowing mach_msg() to retry using the original timeout
         // value. See 10.9.4 xnu-2422.110.17/libsyscall/mach/mach_msg.c
         // mach_msg().
         mach_msg_timeout_t remaining_ms;
         if (!TimerRunning(deadline, &remaining_ms)) {
           return MACH_RCV_TIMED_OUT;
         }
 
         kr = mach_msg(request_header,
                       options | MACH_RCV_MSG,
                       0,
                       this_request_size,
                       receive_port,
                       remaining_ms,
                       MACH_PORT_NULL);
-      } while (kr == MACH_RCV_INTERRUPTED);
+
+        if (kr == MACH_RCV_TOO_LARGE && receive_large == kReceiveLargeIgnore) {
+          MACH_LOG(WARNING, kr) << "mach_msg: ignoring large message";
+          run_mach_msg_receive = true;
+        } else if (kr == MACH_RCV_INTERRUPTED) {
+          run_mach_msg_receive = true;
+        }
+      } while (run_mach_msg_receive);
 
       if (kr == MACH_MSG_SUCCESS) {
         request_scoper.swap(trial_request_scoper);
-      } else if (kr == MACH_RCV_TOO_LARGE && options & MACH_RCV_LARGE) {
+      } else if (kr == MACH_RCV_TOO_LARGE &&
+                 receive_large == kReceiveLargeResize) {
         this_request_size =
             round_page(request_header->msgh_size + trailer_alloc);
         this_request_alloc = this_request_size;
       } else {
         return kr;
       }
     }
 
     vm_address_t reply_addr;
     kr = vm_allocate(mach_task_self(),
@@ skipping 86 matching lines @@
         // persistent mode, and just return success when not in persistent mode.
         return (persistent == kPersistent) ? MACH_RCV_TIMED_OUT : kr;
       }
     }
   } while (persistent == kPersistent);
 
   return kr;
 }
 
 }  // namespace crashpad