[apple/xnu.git] / libsyscall / wrappers / terminate_with_reason.c

/*
 * Copyright (c) 2016 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */
#include <sys/reason.h>
#include <sys/types.h>
#include <stdint.h>
#include <signal.h>
#include <os/reason_private.h>
#include <unistd.h>

/* Crash simulation */

extern int pthread_current_stack_contains_np(const void *, unsigned long);
int
__darwin_check_fd_set_overflow(int n, const void *fd_set, int unlimited_select)
{
	if (n < 0) {
		os_fault_with_payload(OS_REASON_LIBSYSTEM, OS_REASON_LIBSYSTEM_CODE_FAULT,
		    &n, sizeof(n), "FD_SET underflow", 0);
		return 0;
	}

	if (n >= __DARWIN_FD_SETSIZE) {
		if (pthread_current_stack_contains_np((const void *) fd_set, sizeof(struct fd_set))) {
			if (!unlimited_select) {
				os_fault_with_payload(OS_REASON_LIBSYSTEM, OS_REASON_LIBSYSTEM_CODE_FAULT,
				    &n, sizeof(n), "FD_SET overflow", 0);
				return 0;
			} else {
				return 1;
			}
		} else {
			return 1;
		}
	}

	return 1;
}

/* System call entry points */
int __terminate_with_payload(int pid, uint32_t reason_namespace, uint64_t reason_code,
    void *payload, uint32_t payload_size, const char *reason_string,
    uint64_t reason_flags);

void __abort_with_payload(uint32_t reason_namespace, uint64_t reason_code,
    void *payload, uint32_t payload_size, const char *reason_string,
    uint64_t reason_flags);

static void abort_with_payload_wrapper_internal(uint32_t reason_namespace, uint64_t reason_code,
    void *payload, uint32_t payload_size, const char *reason_string,
    uint64_t reason_flags) __attribute__((noreturn, cold));

/* System call wrappers */
int
terminate_with_reason(int pid, uint32_t reason_namespace, uint64_t reason_code,
    const char *reason_string, uint64_t reason_flags)
{
	return __terminate_with_payload(pid, reason_namespace, reason_code, 0, 0,
	           reason_string, reason_flags);
}

int
terminate_with_payload(int pid, uint32_t reason_namespace, uint64_t reason_code,
    void *payload, uint32_t payload_size,
    const char *reason_string, uint64_t reason_flags)
{
	return __terminate_with_payload(pid, reason_namespace, reason_code, payload,
	           payload_size, reason_string, reason_flags);
}

static void
abort_with_payload_wrapper_internal(uint32_t reason_namespace, uint64_t reason_code,
    void *payload, uint32_t payload_size, const char *reason_string,
    uint64_t reason_flags)
{
	sigset_t unmask_signal;

	/* Try to unmask SIGABRT before trapping to the kernel */
	sigemptyset(&unmask_signal);
	sigaddset(&unmask_signal, SIGABRT);
	sigprocmask(SIG_UNBLOCK, &unmask_signal, NULL);

	__abort_with_payload(reason_namespace, reason_code, payload, payload_size,
	    reason_string, reason_flags);

	/* If sending a SIGABRT failed, we fall back to SIGKILL */
	terminate_with_payload(getpid(), reason_namespace, reason_code, payload, payload_size,
	    reason_string, reason_flags | OS_REASON_FLAG_ABORT);

	__builtin_unreachable();
}

void
abort_with_reason(uint32_t reason_namespace, uint64_t reason_code, const char *reason_string,
    uint64_t reason_flags)
{
	abort_with_payload_wrapper_internal(reason_namespace, reason_code, 0, 0, reason_string, reason_flags);
}

void
abort_with_payload(uint32_t reason_namespace, uint64_t reason_code, void *payload,
    uint32_t payload_size, const char *reason_string,
    uint64_t reason_flags)
{
	abort_with_payload_wrapper_internal(reason_namespace, reason_code, payload, payload_size,
	    reason_string, reason_flags);
}
Commit	Line	Data
39037602 A	1	/*
	2	* Copyright (c) 2016 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23	#include <sys/reason.h>
	24	#include <sys/types.h>
	25	#include <stdint.h>
	26	#include <signal.h>
ea3f0419	27	#include <os/reason_private.h>
39037602 A	28	#include <unistd.h>
39037602 A	29
ea3f0419 A	30	/* Crash simulation */
	31
	32	extern int pthread_current_stack_contains_np(const void *, unsigned long);
	33	int
	34	__darwin_check_fd_set_overflow(int n, const void *fd_set, int unlimited_select)
	35	{
	36	if (n < 0) {
	37	os_fault_with_payload(OS_REASON_LIBSYSTEM, OS_REASON_LIBSYSTEM_CODE_FAULT,
	38	&n, sizeof(n), "FD_SET underflow", 0);
	39	return 0;
	40	}
	41
	42	if (n >= __DARWIN_FD_SETSIZE) {
	43	if (pthread_current_stack_contains_np((const void *) fd_set, sizeof(struct fd_set))) {
	44	if (!unlimited_select) {
	45	os_fault_with_payload(OS_REASON_LIBSYSTEM, OS_REASON_LIBSYSTEM_CODE_FAULT,
	46	&n, sizeof(n), "FD_SET overflow", 0);
	47	return 0;
	48	} else {
	49	return 1;
	50	}
	51	} else {
	52	return 1;
	53	}
	54	}
	55
	56	return 1;
	57	}
	58
39037602 A	59	/* System call entry points */
39037602 A	60	int __terminate_with_payload(int pid, uint32_t reason_namespace, uint64_t reason_code,
0a7de745 A	61	void payload, uint32_t payload_size, const char reason_string,
0a7de745 A	62	uint64_t reason_flags);
39037602 A	63
39037602 A	64	void __abort_with_payload(uint32_t reason_namespace, uint64_t reason_code,
0a7de745 A	65	void payload, uint32_t payload_size, const char reason_string,
0a7de745 A	66	uint64_t reason_flags);
39037602 A	67
39037602 A	68	static void abort_with_payload_wrapper_internal(uint32_t reason_namespace, uint64_t reason_code,
0a7de745	69	void payload, uint32_t payload_size, const char reason_string,
cb323159	70	uint64_t reason_flags) __attribute__((noreturn, cold));
39037602 A	71
	72	/* System call wrappers */
	73	int
	74	terminate_with_reason(int pid, uint32_t reason_namespace, uint64_t reason_code,
0a7de745	75	const char *reason_string, uint64_t reason_flags)
39037602 A	76	{
39037602 A	77	return __terminate_with_payload(pid, reason_namespace, reason_code, 0, 0,
0a7de745	78	reason_string, reason_flags);
39037602 A	79	}
	80
	81	int
	82	terminate_with_payload(int pid, uint32_t reason_namespace, uint64_t reason_code,
0a7de745 A	83	void *payload, uint32_t payload_size,
0a7de745 A	84	const char *reason_string, uint64_t reason_flags)
39037602 A	85	{
39037602 A	86	return __terminate_with_payload(pid, reason_namespace, reason_code, payload,
0a7de745	87	payload_size, reason_string, reason_flags);
39037602 A	88	}
39037602 A	89
0a7de745 A	90	static void
	91	abort_with_payload_wrapper_internal(uint32_t reason_namespace, uint64_t reason_code,
	92	void payload, uint32_t payload_size, const char reason_string,
	93	uint64_t reason_flags)
39037602 A	94	{
	95	sigset_t unmask_signal;
	96
	97	/* Try to unmask SIGABRT before trapping to the kernel */
	98	sigemptyset(&unmask_signal);
	99	sigaddset(&unmask_signal, SIGABRT);
	100	sigprocmask(SIG_UNBLOCK, &unmask_signal, NULL);
	101
	102	__abort_with_payload(reason_namespace, reason_code, payload, payload_size,
0a7de745	103	reason_string, reason_flags);
39037602	104
d190cdc3	105	/* If sending a SIGABRT failed, we fall back to SIGKILL */
39037602	106	terminate_with_payload(getpid(), reason_namespace, reason_code, payload, payload_size,
0a7de745	107	reason_string, reason_flags \| OS_REASON_FLAG_ABORT);
39037602	108
d190cdc3	109	__builtin_unreachable();
39037602 A	110	}
	111
	112	void
	113	abort_with_reason(uint32_t reason_namespace, uint64_t reason_code, const char *reason_string,
0a7de745	114	uint64_t reason_flags)
39037602 A	115	{
	116	abort_with_payload_wrapper_internal(reason_namespace, reason_code, 0, 0, reason_string, reason_flags);
	117	}
	118
	119	void
	120	abort_with_payload(uint32_t reason_namespace, uint64_t reason_code, void *payload,
0a7de745 A	121	uint32_t payload_size, const char *reason_string,
0a7de745 A	122	uint64_t reason_flags)
39037602 A	123	{
39037602 A	124	abort_with_payload_wrapper_internal(reason_namespace, reason_code, payload, payload_size,
0a7de745	125	reason_string, reason_flags);
39037602	126	}