Don’t trigger EXC_CORPSE_NOTIFY on OS X 10.11

util/mach/exc_server_variants.h

 // 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 132 matching lines @@
 //! search for other exception handlers. An exception handler should return the
 //! value returned by this function.
 //!
 //! This function is useful even for `EXC_CRASH` handlers, where returning
 //! `KERN_SUCCESS` and allowing the kernel to set a new thread state has been
 //! observed to cause a perceptible and unnecessary waste of time. The victim
 //! task in an `EXC_CRASH` handler is already being terminated and is no longer
 //! schedulable, so there is no point in setting the states of any of its
 //! threads.
 //!
+//! On OS X 10.11, the `MACH_RCV_PORT_DIED` mechanism cannot be used with an
+//! `EXC_CRASH` handler without triggering an undesirable `EXC_CORPSE_NOTIFY`
+//! exception. In that case, `KERN_SUCCESS` is always returned. Because this
+//! function may return `KERN_SUCCESS` for a state-carrying exception, it is
+//! important to ensure that the state returned by a state-carrying exception
+//! handler is valid, because it will be passed to `thread_set_status()`.

[Robert Sesek, 2015/09/04 17:29:49]

Do you need the `` here since thread_set_status has the () ?

[Mark Mentovai, 2015/09/04 18:26:01]

Robert Sesek wrote:
thread_set_status isn’t special to Doxygen because it’s in a system header that
it never sees and doesn’t have documentation for. The () doesn’t make Doxygen
render it any differently, but the `` does.

+//! ExcServerCopyState() may be used to achieve this.
+//!
+//! \param[in] exception The exception type passed to the exception handler.
+//!     This may be taken directly from the \a exception parameter of
+//!     internal::SimplifiedExcServer::Interface::CatchException(), for example.
 //! \param[in] behavior The behavior of the exception handler as invoked. This
 //!     may be taken directly from the \a behavior parameter of
 //!     internal::SimplifiedExcServer::Interface::CatchException(), for example.
 //! \param[in] set_thread_state `true` if the handler would like its caller to
 //!     set the new thread state using the \a flavor, \a new_state, and \a
 //!     new_state_count out parameters. This can only happen when \a behavior is
 //!     a state-carrying behavior.
 //!
 //! \return `KERN_SUCCESS` or `MACH_RCV_PORT_DIED`. `KERN_SUCCESS` is used when
 //!     \a behavior is not a state-carrying behavior, or when it is a
-//!     state-carrying behavior and \a set_thread_state is `true`.
-//!     `MACH_RCV_PORT_DIED` is used when \a behavior is a state-carrying
-//!     behavior and \a set_thread_state is `false`.
-kern_return_t ExcServerSuccessfulReturnValue(exception_behavior_t behavior,
+//!     state-carrying behavior and \a set_thread_state is `true`, or for
+//!     `EXC_CRASH` exceptions on OS X 10.11 and later. Otherwise,
+//!     `MACH_RCV_PORT_DIED` is used.
+kern_return_t ExcServerSuccessfulReturnValue(exception_type_t exception,
+                                             exception_behavior_t behavior,
                                              bool set_thread_state);
 
 //! \brief Copies the old state to the new state for state-carrying exceptions.
 //!
 //! When the kernel sends a state-carrying exception request and the response is
 //! successful (`MACH_MSG_SUCCESS`, a synonym for `KERN_SUCCESS`), it will set
 //! a new thread state based on \a new_state and \a new_state_count. To ease
 //! initialization of the new state, this function copies \a old_state and
 //! \a old_state_count. This is only done if \a behavior indicates a
 //! state-carrying exception.
@@ skipping 22 matching lines @@
 //!     large as \a old_state_count.
 void ExcServerCopyState(exception_behavior_t behavior,
                         ConstThreadState old_state,
                         mach_msg_type_number_t old_state_count,
                         thread_state_t new_state,
                         mach_msg_type_number_t* new_state_count);
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MACH_EXC_SERVER_VARIANTS_H_