[apple/libc.git] / os / assumes.c

/*
 * Copyright (c) 2011, 2012 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 <TargetConditionals.h>
#include <dispatch/dispatch.h>
#include <uuid/uuid.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>
#include <mach-o/arch.h>
#include <mach-o/getsect.h>
#include <pthread.h>
#include <sys/types.h>
#include <execinfo.h>
#include <stdio.h>
#include <dlfcn.h>
#include <_simple.h>
#include <errno.h>
#include <pthread.h>
#include <string.h>
#include "os/assumes.h"
#include "gen/assumes.h"
#include <os/debug_private.h>

#define OSX_ASSUMES_LOG_REDIRECT_SECT_NAME "__osx_log_func"
#define os_atomic_cmpxchg(p, o, n) __sync_bool_compare_and_swap((p), (o), (n))

static bool _os_should_abort_on_assumes = false;

static const char *
_os_basename(const char *p)
{
	return ((strrchr(p, '/') ? : p - 1) + 1);
}

static void
_os_get_build(char *build, size_t sz)
{
	/* Get the build every time. We used to cache it, but if PID 1 experiences
	 * an assumes() failure before the build has been set, that would mean that
	 * all future failures would get bad build info. So we fetch it every time.
	 * Since assumes() failures are on the slow path anyway, not a huge deal.
	 */
	int mib[] = { CTL_KERN, KERN_OSVERSION };

	size_t oldsz = sz;
	int r = sysctl(mib, 2, build, &sz, NULL, 0);
	if (r == 0 && sz == 1) {
		(void)strlcpy(build, "99Z999", oldsz);
	}
#if TARGET_IPHONE_SIMULATOR
        char *simVersion = getenv("SIMULATOR_RUNTIME_BUILD_VERSION");
        if (simVersion) {
            strlcat(build, " ", oldsz);
            strlcat(build, simVersion, oldsz);
        }
#endif
}

static void
_os_get_image_uuid(void *hdr, uuid_t uuid)
{
#if __LP64__
	struct mach_header_64 *hdr32or64 = (struct mach_header_64 *)hdr;
#else
	struct mach_header *hdr32or64 = (struct mach_header *)hdr;
#endif /* __LP64__ */

	size_t i = 0;
	size_t next = sizeof(*hdr32or64);
	struct load_command *cur = NULL;
	for (i = 0; i < hdr32or64->ncmds; i++) {
		cur = (struct load_command *)((uintptr_t)hdr32or64 + next);
		if (cur->cmd == LC_UUID) {
			struct uuid_command *cmd = (struct uuid_command *)cur;
			uuid_copy(uuid, cmd->uuid);
			break;
		}

		next += cur->cmdsize;
	}

	if (i == hdr32or64->ncmds) {
		uuid_clear(uuid);
	}
}

static void
_os_abort_on_assumes_once(void)
{
	/* Embedded boot-args can get pretty long. Let's just hope this is big
	 * enough.
	 */
	char bootargs[2048];
	size_t len = sizeof(bootargs) - 1;

	if (sysctlbyname("kern.bootargs", bootargs, &len, NULL, 0) == 0) {
		if (strnstr(bootargs, "-os_assumes_fatal", len)) {
			_os_should_abort_on_assumes = true;
		}
	}
}

static bool
_os_abort_on_assumes(void)
{
	static pthread_once_t once = PTHREAD_ONCE_INIT;
	bool result = false;

	if (getpid() != 1) {
		if (getenv("OS_ASSUMES_FATAL")) {
			result = true;
		} else {
			pthread_once(&once, _os_abort_on_assumes_once);
			result = _os_should_abort_on_assumes;
		}
	} else {
		if (getenv("OS_ASSUMES_FATAL_PID1")) {
			result = true;
		}
	}

	return result;
}

#if __LP64__
typedef struct mach_header_64 os_mach_header;
#else
typedef struct mach_header os_mach_header;
#endif

static os_redirect_t
_os_find_log_redirect_func(os_mach_header *hdr)
{
	os_redirect_t result = NULL;

	char name[128];
	unsigned long size = 0;
	uint8_t *data = getsectiondata(hdr, OS_ASSUMES_REDIRECT_SEG, OS_ASSUMES_REDIRECT_SECT, &size);
	if (!data) {
		data = getsectiondata(hdr, "__TEXT", OSX_ASSUMES_LOG_REDIRECT_SECT_NAME, &size);

		if (data && size < sizeof(name) - 2) {
			(void)strlcpy(name, (const char *)data, size + 1);
			result = dlsym(RTLD_DEFAULT, name);
		}
	} else if (size == sizeof(struct _os_redirect_assumes_s)) {
		struct _os_redirect_assumes_s *redirect = (struct _os_redirect_assumes_s *)data;
		result = redirect->redirect;
	}

	return result;
}

static bool
_os_log_redirect(void *hdr, const char *msg)
{
	bool result = false;

	os_redirect_t redirect_func = _os_find_log_redirect_func(hdr);
	if (redirect_func) {
		result = redirect_func(msg);
	}

	return result;
}

__attribute__((always_inline))
static void
_os_construct_message(uint64_t code, _SIMPLE_STRING asl_message, Dl_info *info, char *buff, size_t sz)
{
	const char *image_name = NULL;
	uintptr_t offset = 0;
	uuid_string_t uuid_str;

	void *ret = __builtin_return_address(0);
	if (dladdr(ret, info)) {
		uuid_t uuid;
		_os_get_image_uuid(info->dli_fbase, uuid);
		
		uuid_unparse(uuid, uuid_str);
		image_name = _os_basename(info->dli_fname);
		
		offset = ret - info->dli_fbase;
	}

	char sig[64];
	(void)snprintf(sig, sizeof(sig), "%s:%lu", uuid_str, offset);

	char result[24];
	(void)snprintf(result, sizeof(result), "0x%llx", code);

	char build[32];
	size_t bsz = sizeof(build);
	_os_get_build(build, bsz);

	(void)snprintf(buff, sz, "assertion failed: %s: %s + %lu [%s]: %s", build, image_name, offset, uuid_str, result);

	_simple_asl_msg_set(asl_message, "com.apple.message.domain", "com.apple.assumes.failure");
	_simple_asl_msg_set(asl_message, "com.apple.message.signature", sig);
	_simple_asl_msg_set(asl_message, "com.apple.message.signature2", result);
	_simple_asl_msg_set(asl_message, "com.apple.message.signature3", image_name);
	_simple_asl_msg_set(asl_message, "com.apple.message.summarize", "YES");
}

#pragma mark Internal Implementations

os_crash_callback_t _os_crash_callback = NULL;

__attribute__((always_inline))
static inline void
_os_crash_impl(const char *message) {
	os_set_crash_message(message);
	if (!_os_crash_callback) {
		_os_crash_callback = dlsym(RTLD_MAIN_ONLY, "os_crash_function");
	}
	if (_os_crash_callback) {
		_os_crash_callback(message);
	}
}

__attribute__((always_inline))
static inline void
_os_assumes_log_impl(uint64_t code)
{
	char message[256] = "";

	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	if (asl_message) {
		Dl_info info;
		_os_construct_message(code, asl_message, &info, message, sizeof(message));
		if (!_os_log_redirect(info.dli_fbase, message)) {
			_os_debug_log_error_str(message);
			_simple_asl_msg_set(asl_message, "Level", "Error");
			_simple_asl_msg_set(asl_message, "Message", "");
			_simple_asl_send(asl_message);
		}

		_simple_sfree(asl_message);
	}

	if (_os_abort_on_assumes()) {
		os_crash(message);
	}
}

__attribute__((always_inline))
static inline char *
_os_assert_log_impl(uint64_t code)
{
	char *result = NULL;

	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	if (asl_message) {
		Dl_info info;
		char message[256];
		_os_construct_message(code, asl_message, &info, message, sizeof(message));
		if (!_os_log_redirect(info.dli_fbase, message)) {
			_os_debug_log_error_str(message);
			_simple_asl_msg_set(asl_message, "Level", "Error");
			_simple_asl_msg_set(asl_message, "Message", "");
			_simple_asl_send(asl_message);
		}

		_simple_sfree(asl_message);
		result = strdup(message);
	}

#if LIBC_NO_LIBCRASHREPORTERCLIENT
	/* There is no crash report information facility on embedded, which is
	 * really regrettable. Fortunately, all we need to capture is the value
	 * which tripped up the assertion. We can just stuff that into the thread's 
	 * name.
	 */
	char name[64];
	(void)pthread_getname_np(pthread_self(), name, sizeof(name));

	char newname[64];
	if (strlen(name) == 0) {
		(void)snprintf(newname, sizeof(newname), "[Fatal bug: 0x%llx]", code);
	} else {
		(void)snprintf(newname, sizeof(newname), "%s [Fatal bug: 0x%llx]", name, code);
	}

	(void)pthread_setname_np(newname);
#endif

	return result;
}

__attribute__((always_inline))
static inline void
_os_assumes_log_ctx_impl(os_log_callout_t callout, void *ctx, uint64_t code)
{
	char message[256] = "";

	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	if (asl_message) {
		Dl_info info;
		_os_construct_message(code, asl_message, &info, message, sizeof(message));

		(void)callout(asl_message, ctx, message);
		_simple_sfree(asl_message);
	}

	if (_os_abort_on_assumes()) {
		os_crash(message);
	}
}

__attribute__((always_inline))
static inline char *
_os_assert_log_ctx_impl(os_log_callout_t callout, void *ctx, uint64_t code)
{
	char *result = NULL;

	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	if (asl_message) {
		Dl_info info;
		char message[256];
		_os_construct_message(code, asl_message, &info, message, sizeof(message));

		(void)callout(asl_message, ctx, message);
		_simple_sfree(asl_message);
		result = strdup(message);
	}
	return result;
}

#pragma mark Public Interfaces
void _os_crash(const char *message)
{
	_os_crash_impl(message);
}

void
_os_assumes_log(uint64_t code)
{
	_os_assumes_log_impl(code);
}

char *
_os_assert_log(uint64_t code)
{
	return _os_assert_log_impl(code);
}

void
_os_assumes_log_ctx(os_log_callout_t callout, void *ctx, uint64_t code)
{
	_os_assumes_log_ctx_impl(callout, ctx, code);
}

char *
_os_assert_log_ctx(os_log_callout_t callout, void *ctx, uint64_t code)
{
	return _os_assert_log_ctx_impl(callout, ctx, code);
}

void
_os_avoid_tail_call(void)
{
	// no-op
}

#pragma mark Legacy
void
_osx_assumes_log(uint64_t code)
{
	_os_assumes_log(code);
}

char *
_osx_assert_log(uint64_t code)
{
	return _os_assert_log_impl(code);
}

void
_osx_assumes_log_ctx(osx_log_callout_t callout, void *ctx, uint64_t code)
{
	_os_assumes_log_ctx_impl(callout, ctx, code);
}

char *
_osx_assert_log_ctx(osx_log_callout_t callout, void *ctx, uint64_t code)
{
	return _os_assert_log_ctx_impl(callout, ctx, code);
}

void
_osx_avoid_tail_call(void)
{
	_os_avoid_tail_call();
}
Commit	Line	Data
6465356a A	1	/*
	2	* Copyright (c) 2011, 2012 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
23e20b00	24	#include <TargetConditionals.h>
6465356a A	25	#include <dispatch/dispatch.h>
	26	#include <uuid/uuid.h>
	27	#include <sys/types.h>
	28	#include <sys/sysctl.h>
	29	#include <mach-o/loader.h>
	30	#include <mach-o/fat.h>
	31	#include <mach-o/arch.h>
	32	#include <mach-o/getsect.h>
	33	#include <pthread.h>
	34	#include <sys/types.h>
	35	#include <execinfo.h>
	36	#include <stdio.h>
	37	#include <dlfcn.h>
	38	#include <_simple.h>
	39	#include <errno.h>
	40	#include <pthread.h>
	41	#include <string.h>
	42	#include "os/assumes.h"
	43	#include "gen/assumes.h"
23e20b00	44	#include <os/debug_private.h>
6465356a A	45
	46	#define OSX_ASSUMES_LOG_REDIRECT_SECT_NAME "__osx_log_func"
	47	#define os_atomic_cmpxchg(p, o, n) __sync_bool_compare_and_swap((p), (o), (n))
	48
	49	static bool _os_should_abort_on_assumes = false;
	50
	51	static const char *
	52	_os_basename(const char *p)
	53	{
	54	return ((strrchr(p, '/') ? : p - 1) + 1);
	55	}
	56
	57	static void
	58	_os_get_build(char *build, size_t sz)
	59	{
	60	/* Get the build every time. We used to cache it, but if PID 1 experiences
	61	* an assumes() failure before the build has been set, that would mean that
	62	* all future failures would get bad build info. So we fetch it every time.
	63	* Since assumes() failures are on the slow path anyway, not a huge deal.
	64	*/
	65	int mib[] = { CTL_KERN, KERN_OSVERSION };
	66
	67	size_t oldsz = sz;
	68	int r = sysctl(mib, 2, build, &sz, NULL, 0);
	69	if (r == 0 && sz == 1) {
	70	(void)strlcpy(build, "99Z999", oldsz);
	71	}
23e20b00 A	72	#if TARGET_IPHONE_SIMULATOR
	73	char *simVersion = getenv("SIMULATOR_RUNTIME_BUILD_VERSION");
	74	if (simVersion) {
	75	strlcat(build, " ", oldsz);
	76	strlcat(build, simVersion, oldsz);
	77	}
	78	#endif
6465356a A	79	}
	80
	81	static void
	82	_os_get_image_uuid(void *hdr, uuid_t uuid)
	83	{
	84	#if __LP64__
	85	struct mach_header_64 hdr32or64 = (struct mach_header_64 )hdr;
	86	#else
	87	struct mach_header hdr32or64 = (struct mach_header )hdr;
	88	#endif /* __LP64__ */
	89
	90	size_t i = 0;
	91	size_t next = sizeof(*hdr32or64);
	92	struct load_command *cur = NULL;
	93	for (i = 0; i < hdr32or64->ncmds; i++) {
	94	cur = (struct load_command *)((uintptr_t)hdr32or64 + next);
	95	if (cur->cmd == LC_UUID) {
	96	struct uuid_command cmd = (struct uuid_command )cur;
	97	uuid_copy(uuid, cmd->uuid);
	98	break;
	99	}
	100
	101	next += cur->cmdsize;
	102	}
	103
	104	if (i == hdr32or64->ncmds) {
	105	uuid_clear(uuid);
	106	}
	107	}
	108
	109	static void
	110	_os_abort_on_assumes_once(void)
	111	{
	112	/* Embedded boot-args can get pretty long. Let's just hope this is big
	113	* enough.
	114	*/
	115	char bootargs[2048];
	116	size_t len = sizeof(bootargs) - 1;
	117
	118	if (sysctlbyname("kern.bootargs", bootargs, &len, NULL, 0) == 0) {
	119	if (strnstr(bootargs, "-os_assumes_fatal", len)) {
	120	_os_should_abort_on_assumes = true;
	121	}
	122	}
	123	}
	124
	125	static bool
	126	_os_abort_on_assumes(void)
	127	{
	128	static pthread_once_t once = PTHREAD_ONCE_INIT;
	129	bool result = false;
	130
	131	if (getpid() != 1) {
	132	if (getenv("OS_ASSUMES_FATAL")) {
	133	result = true;
	134	} else {
	135	pthread_once(&once, _os_abort_on_assumes_once);
	136	result = _os_should_abort_on_assumes;
	137	}
	138	} else {
	139	if (getenv("OS_ASSUMES_FATAL_PID1")) {
	140	result = true;
	141	}
	142	}
143
144	return result;
145	}
146
147	#if __LP64__
148	typedef struct mach_header_64 os_mach_header;
149	#else
150	typedef struct mach_header os_mach_header;
151	#endif
152
153	static os_redirect_t
154	_os_find_log_redirect_func(os_mach_header *hdr)
155	{
156	os_redirect_t result = NULL;
157
158	char name[128];
159	unsigned long size = 0;
160	uint8_t *data = getsectiondata(hdr, OS_ASSUMES_REDIRECT_SEG, OS_ASSUMES_REDIRECT_SECT, &size);
161	if (!data) {
162	data = getsectiondata(hdr, "__TEXT", OSX_ASSUMES_LOG_REDIRECT_SECT_NAME, &size);
163
164	if (data && size < sizeof(name) - 2) {
165	(void)strlcpy(name, (const char *)data, size + 1);
166	result = dlsym(RTLD_DEFAULT, name);
167	}
168	} else if (size == sizeof(struct _os_redirect_assumes_s)) {
169	struct _os_redirect_assumes_s redirect = (struct _os_redirect_assumes_s )data;
170	result = redirect->redirect;
171	}
172
173	return result;
174	}
175
176	static bool
177	_os_log_redirect(void hdr, const char msg)
178	{
179	bool result = false;
180
181	os_redirect_t redirect_func = _os_find_log_redirect_func(hdr);
182	if (redirect_func) {
183	result = redirect_func(msg);
184	}
185
186	return result;
187	}
188
189	__attribute__((always_inline))
190	static void
191	_os_construct_message(uint64_t code, _SIMPLE_STRING asl_message, Dl_info info, char buff, size_t sz)
192	{
193	const char *image_name = NULL;
194	uintptr_t offset = 0;
195	uuid_string_t uuid_str;
196
197	void *ret = __builtin_return_address(0);
198	if (dladdr(ret, info)) {
199	uuid_t uuid;
200	_os_get_image_uuid(info->dli_fbase, uuid);
201
202	uuid_unparse(uuid, uuid_str);
203	image_name = _os_basename(info->dli_fname);
204
205	offset = ret - info->dli_fbase;
206	}
207
208	char sig[64];
209	(void)snprintf(sig, sizeof(sig), "%s:%lu", uuid_str, offset);
210
211	char result[24];
212	(void)snprintf(result, sizeof(result), "0x%llx", code);
213
23e20b00	214	char build[32];
6465356a A	215	size_t bsz = sizeof(build);
	216	_os_get_build(build, bsz);
	217
	218	(void)snprintf(buff, sz, "assertion failed: %s: %s + %lu [%s]: %s", build, image_name, offset, uuid_str, result);
	219
	220	_simple_asl_msg_set(asl_message, "com.apple.message.domain", "com.apple.assumes.failure");
	221	_simple_asl_msg_set(asl_message, "com.apple.message.signature", sig);
	222	_simple_asl_msg_set(asl_message, "com.apple.message.signature2", result);
	223	_simple_asl_msg_set(asl_message, "com.apple.message.signature3", image_name);
	224	_simple_asl_msg_set(asl_message, "com.apple.message.summarize", "YES");
	225	}
	226
	227	#pragma mark Internal Implementations
5f125488 A	228
	229	os_crash_callback_t _os_crash_callback = NULL;
	230
	231	__attribute__((always_inline))
	232	static inline void
	233	_os_crash_impl(const char *message) {
	234	os_set_crash_message(message);
	235	if (!_os_crash_callback) {
	236	_os_crash_callback = dlsym(RTLD_MAIN_ONLY, "os_crash_function");
	237	}
	238	if (_os_crash_callback) {
	239	_os_crash_callback(message);
	240	}
	241	}
	242
6465356a A	243	__attribute__((always_inline))
	244	static inline void
	245	_os_assumes_log_impl(uint64_t code)
	246	{
5f125488 A	247	char message[256] = "";
5f125488 A	248
6465356a A	249	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	250	if (asl_message) {
	251	Dl_info info;
6465356a A	252	_os_construct_message(code, asl_message, &info, message, sizeof(message));
6465356a A	253	if (!_os_log_redirect(info.dli_fbase, message)) {
23e20b00	254	_os_debug_log_error_str(message);
6465356a A	255	_simple_asl_msg_set(asl_message, "Level", "Error");
	256	_simple_asl_msg_set(asl_message, "Message", "");
	257	_simple_asl_send(asl_message);
	258	}
	259
	260	_simple_sfree(asl_message);
	261	}
	262
	263	if (_os_abort_on_assumes()) {
5f125488	264	os_crash(message);
6465356a A	265	}
	266	}
	267
	268	__attribute__((always_inline))
	269	static inline char *
	270	_os_assert_log_impl(uint64_t code)
	271	{
	272	char *result = NULL;
	273
	274	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	275	if (asl_message) {
	276	Dl_info info;
	277	char message[256];
	278	_os_construct_message(code, asl_message, &info, message, sizeof(message));
	279	if (!_os_log_redirect(info.dli_fbase, message)) {
23e20b00	280	_os_debug_log_error_str(message);
6465356a A	281	_simple_asl_msg_set(asl_message, "Level", "Error");
	282	_simple_asl_msg_set(asl_message, "Message", "");
	283	_simple_asl_send(asl_message);
	284	}
	285
	286	_simple_sfree(asl_message);
	287	result = strdup(message);
	288	}
	289
	290	#if LIBC_NO_LIBCRASHREPORTERCLIENT
	291	/* There is no crash report information facility on embedded, which is
	292	* really regrettable. Fortunately, all we need to capture is the value
	293	* which tripped up the assertion. We can just stuff that into the thread's
	294	* name.
	295	*/
	296	char name[64];
	297	(void)pthread_getname_np(pthread_self(), name, sizeof(name));
	298
	299	char newname[64];
	300	if (strlen(name) == 0) {
	301	(void)snprintf(newname, sizeof(newname), "[Fatal bug: 0x%llx]", code);
	302	} else {
	303	(void)snprintf(newname, sizeof(newname), "%s [Fatal bug: 0x%llx]", name, code);
	304	}
	305
	306	(void)pthread_setname_np(newname);
	307	#endif
	308
	309	return result;
	310	}
	311
	312	__attribute__((always_inline))
	313	static inline void
	314	_os_assumes_log_ctx_impl(os_log_callout_t callout, void *ctx, uint64_t code)
	315	{
5f125488 A	316	char message[256] = "";
5f125488 A	317
6465356a A	318	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	319	if (asl_message) {
	320	Dl_info info;
6465356a A	321	_os_construct_message(code, asl_message, &info, message, sizeof(message));
	322
	323	(void)callout(asl_message, ctx, message);
	324	_simple_sfree(asl_message);
	325	}
	326
	327	if (_os_abort_on_assumes()) {
5f125488	328	os_crash(message);
6465356a A	329	}
	330	}
	331
	332	__attribute__((always_inline))
	333	static inline char *
	334	_os_assert_log_ctx_impl(os_log_callout_t callout, void *ctx, uint64_t code)
	335	{
	336	char *result = NULL;
	337
	338	_SIMPLE_STRING asl_message = _simple_asl_msg_new();
	339	if (asl_message) {
	340	Dl_info info;
	341	char message[256];
	342	_os_construct_message(code, asl_message, &info, message, sizeof(message));
	343
	344	(void)callout(asl_message, ctx, message);
	345	_simple_sfree(asl_message);
	346	result = strdup(message);
	347	}
	348	return result;
	349	}
	350
	351	#pragma mark Public Interfaces
5f125488 A	352	void _os_crash(const char *message)
	353	{
	354	_os_crash_impl(message);
	355	}
	356
6465356a A	357	void
	358	_os_assumes_log(uint64_t code)
	359	{
	360	_os_assumes_log_impl(code);
	361	}
	362
	363	char *
	364	_os_assert_log(uint64_t code)
	365	{
	366	return _os_assert_log_impl(code);
	367	}
	368
	369	void
	370	_os_assumes_log_ctx(os_log_callout_t callout, void *ctx, uint64_t code)
	371	{
	372	_os_assumes_log_ctx_impl(callout, ctx, code);
	373	}
	374
	375	char *
	376	_os_assert_log_ctx(os_log_callout_t callout, void *ctx, uint64_t code)
	377	{
	378	return _os_assert_log_ctx_impl(callout, ctx, code);
	379	}
	380
	381	void
	382	_os_avoid_tail_call(void)
	383	{
	384	// no-op
	385	}
	386
	387	#pragma mark Legacy
	388	void
	389	_osx_assumes_log(uint64_t code)
	390	{
	391	_os_assumes_log(code);
	392	}
	393
	394	char *
	395	_osx_assert_log(uint64_t code)
	396	{
	397	return _os_assert_log_impl(code);
	398	}
	399
	400	void
	401	_osx_assumes_log_ctx(osx_log_callout_t callout, void *ctx, uint64_t code)
	402	{
	403	_os_assumes_log_ctx_impl(callout, ctx, code);
	404	}
	405
	406	char *
	407	_osx_assert_log_ctx(osx_log_callout_t callout, void *ctx, uint64_t code)
	408	{
	409	return _os_assert_log_ctx_impl(callout, ctx, code);
	410	}
	411
	412	void
	413	_osx_avoid_tail_call(void)
	414	{
	415	_os_avoid_tail_call();
	416	}