[apple/libplatform.git] / src / simple / asl.c

/*
 * Copyright (c) 2005, 2006, 2009 Apple Computer, 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 <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/syslog.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <crt_externs.h>

#include <TargetConditionals.h>

#include <_simple.h>

#include <os/lock.h>
#include <os/lock_private.h>
#include <os/alloc_once_private.h>
#include <platform/string.h>
#include <platform/compat.h>

#if TARGET_OS_DRIVERKIT
// DriverKit processes log directly to kernel log
#include <sys/log_data.h>
OS_ENUM(os_log_type, uint8_t,
	OS_LOG_TYPE_DEFAULT = 0x00,
	OS_LOG_TYPE_INFO    = 0x01,
	OS_LOG_TYPE_DEBUG   = 0x02,
);
#else // !TARGET_OS_DRIVERKIT

#define ASL_LOG_PATH _PATH_LOG

extern ssize_t __sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t);
extern int __gettimeofday(struct timeval *, struct timezone *);

struct ProgramVars
{
    void*       mh;
    int*        NXArgcPtr;
    char***     NXArgvPtr;
    char***     environPtr;
    char**      __prognamePtr;
};

struct asl_context {
	bool asl_enabled;
	const char *progname;
	int asl_fd;
#if TARGET_OS_SIMULATOR && !TARGET_OS_MACCATALYST
	const char *sim_log_path;
	os_unfair_lock sim_connect_lock;
#else
	os_once_t connect_once;
#endif
};

static struct asl_context* _simple_asl_get_context(void);
static void _simple_asl_init_context(void *ctx);
static int _simple_asl_connect(const char *log_path);
static void _simple_asl_connect_once(void * __unused arg);
static int _simple_asl_get_fd(void);

/*
 * Simplified ASL log interface; does not use malloc.  Unfortunately, this
 * requires knowledge of the format used by ASL.
 */

__attribute__((visibility("hidden")))
void
_simple_asl_init(const char *envp[], const struct ProgramVars *vars)
{
	const char *str;
	struct asl_context *ctx = _simple_asl_get_context();
	str = _simple_getenv(envp, "ASL_DISABLE");
	if ((str != NULL) && (!strcmp(str, "1"))) return;
	ctx->asl_enabled = true;
	if (vars && vars->__prognamePtr) {
		ctx->progname = *(vars->__prognamePtr);
#if TARGET_OS_SIMULATOR
	} else {
		const char * progname = *_NSGetProgname();
		if (progname)
			ctx->progname = progname;
#endif
	}
}

static int
_simple_asl_connect(const char *log_path)
{
	int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if (fd == -1) return -1;

	fcntl(fd, F_SETFD, FD_CLOEXEC);

	struct sockaddr_un addr;
	addr.sun_family = AF_UNIX;

	size_t amt = strlen(log_path) + 1;
	if (sizeof(addr.sun_path) < amt)
		amt = sizeof(addr.sun_path);
	memmove(addr.sun_path, log_path, amt);

	if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
		close(fd);
		return -1;
	}
	return fd;
}

static void
_simple_asl_connect_once(void * __unused once_arg)
{
	struct asl_context *ctx = _simple_asl_get_context();
	ctx->asl_fd = _simple_asl_connect(ASL_LOG_PATH);
}

static int
_simple_asl_get_fd(void)
{
	struct asl_context *ctx = _simple_asl_get_context();
	if (!ctx->asl_enabled) {
		return -1;
	}

#if TARGET_OS_SIMULATOR && !TARGET_OS_MACCATALYST
	os_unfair_lock_lock_with_options(&ctx->sim_connect_lock,
			OS_UNFAIR_LOCK_DATA_SYNCHRONIZATION);
	if (ctx->sim_log_path) {
		// all setup has been done already
		os_unfair_lock_unlock(&ctx->sim_connect_lock);
		return ctx->asl_fd;
	}
	ctx->sim_log_path = _simple_getenv(
			(const char **)*_NSGetEnviron(), "IOS_SIMULATOR_SYSLOG_SOCKET");
	if (ctx->sim_log_path) {
		// the first and only time the envvar is being checked
		// asl_fd procured by the end of this call will be used forever
		int sim_log_fd = _simple_asl_connect(ctx->sim_log_path);
		if (sim_log_fd > -1) {
			// successfully connected to the SIM path
			if (ctx->asl_fd > -1) {
				// close the ASL_LOG_PATH fd
				close(ctx->asl_fd);
			}
			ctx->asl_fd = sim_log_fd;
		}
	}
	if (ctx->asl_fd < 0) {
		// either there is no envvar or it didn't work. fallback to ASL_LOG_PATH
		ctx->asl_fd = _simple_asl_connect(ASL_LOG_PATH);
	}
	os_unfair_lock_unlock(&ctx->sim_connect_lock);
	return ctx->asl_fd;
#else
	os_once(&ctx->connect_once, NULL, _simple_asl_connect_once);
	return ctx->asl_fd;
#endif
}
#endif // !TARGET_OS_DRIVERKIT

static const char *
_simple_asl_escape_key(unsigned char c)
{
	switch(c)
	{
		case '\\': return "\\\\";
		case '[':  return "\\[";
		case ']':  return "\\]";
		case '\n': return "\\n";
		case ' ':  return "\\s";
	}

	return NULL;
}

static const char *
_simple_asl_escape_val(unsigned char c)
{
	switch(c)
	{
		case '\\': return "\\\\";
		case '[':  return "\\[";
		case ']':  return "\\]";
		case '\n': return "\\n";
	}

	return NULL;
}

_SIMPLE_STRING
_simple_asl_msg_new(void)
{
	_SIMPLE_STRING b = _simple_salloc();

	if (b == NULL) return NULL;

	if (_simple_sprintf(b, "         0"))
	{
		_simple_sfree(b);
		return NULL;
	}

	return b;
}

void
_simple_asl_msg_set(_SIMPLE_STRING __b, const char *__key, const char *__val)
{
	if (__b == NULL) return;
	if (__key == NULL) return;

	do
	{
		if (_simple_sprintf(__b, " [")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_key, "%s", __key)) break;
		if (__val != NULL)
		{
			if (_simple_esprintf(__b, _simple_asl_escape_val, " %s", __val)) break;
			if (!strcmp(__key, "Message"))
			{
				char *cp;

				/* remove trailing (escaped) newlines */
				cp = _simple_string(__b);
				cp += strlen(cp);
				for (;;)
				{
					cp -= 2;
					if (strcmp(cp, "\\n") != 0) break;
					*cp = 0;
				}

				_simple_sresize(__b);
			}
		}

		if (_simple_sappend(__b, "]")) break;
		return;
	} while (0);
}

void
_simple_asl_send(_SIMPLE_STRING __b)
{
#if !TARGET_OS_DRIVERKIT
	struct timeval tv;
	int asl_fd = _simple_asl_get_fd();
	if (asl_fd < 0) return;

	__gettimeofday(&tv, NULL);

	do
	{
		char *cp;

		if (_simple_sprintf(__b, " [PID ")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getpid())) break;
		if (_simple_sprintf(__b, "] [UID ")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getuid())) break;
		if (_simple_sprintf(__b, "] [GID ")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getgid())) break;
		if (_simple_sprintf(__b, "] [Time ")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_val, "%lu", tv.tv_sec)) break;
		if (_simple_sappend(__b, "] [TimeNanoSec ")) break;
		if (_simple_esprintf(__b, _simple_asl_escape_val, "%d", tv.tv_usec * 1000)) break;
		if (_simple_sappend(__b, "]\n")) break;

		cp = _simple_string(__b);
		__sendto(asl_fd, cp, strlen(cp), 0, NULL, 0);
    } while (0);
#else // TARGET_OS_DRIVERKIT
	char *cp;
	cp = _simple_string(__b);
	log_data_as_kernel(0, OS_LOG_TYPE_DEFAULT, cp, strlen(cp) + 1);
#endif // TARGET_OS_DRIVERKIT
}

void
_simple_asl_log_prog(int level, const char *facility, const char *message, const char *prog)
{
	_SIMPLE_STRING b = _simple_asl_msg_new();
	if (b == NULL) return;

#if !TARGET_OS_DRIVERKIT
	char lstr[2];
	if (level < 0) level = 0;
	if (level > 7) level = 7;
	lstr[0] = level + '0';
	lstr[1] = '\0';

	_simple_asl_msg_set(b, "Sender", prog);
	_simple_asl_msg_set(b, "Level", lstr);
	_simple_asl_msg_set(b, "Facility", facility);
	_simple_asl_msg_set(b, "Message", message);
	_simple_asl_send(b);
#else // TARGET_OS_DRIVERKIT
	if (prog) _simple_asl_msg_set(b, "Sender", prog);
	_simple_asl_msg_set(b, "Facility", facility);
	_simple_asl_msg_set(b, "Message", message);

	os_log_type_t type = level > ASL_LEVEL_INFO ? OS_LOG_TYPE_DEFAULT :
			(level > ASL_LEVEL_DEBUG ? OS_LOG_TYPE_INFO : OS_LOG_TYPE_DEBUG);

	char *cp;
	cp = _simple_string(b);
	log_data_as_kernel(0, type, cp, strlen(cp) + 1);
#endif // TARGET_OS_DRIVERKIT
	_simple_sfree(b);
}

void
_simple_asl_log(int level, const char *facility, const char *message)
{
#if !TARGET_OS_DRIVERKIT
	_simple_asl_log_prog(level, facility, message,
			_simple_asl_get_context()->progname);
#else // TARGET_OS_DRIVERKIT
	_simple_asl_log_prog(level, facility, message, NULL);
#endif // TARGET_OS_DRIVERKIT
}

#if !TARGET_OS_DRIVERKIT
static struct asl_context *
_simple_asl_get_context(void)
{
	return os_alloc_once(OS_ALLOC_ONCE_KEY_LIBSYSTEM_PLATFORM_ASL,
			sizeof(struct asl_context), _simple_asl_init_context);
}

static void
_simple_asl_init_context(void *arg)
{
	struct asl_context *ctx = (struct asl_context *)arg;
	// ctx is zero-filled when it comes out of _os_alloc_once
	ctx->progname = "unknown";
	ctx->asl_fd = -1;
}
#endif // !TARGET_OS_DRIVERKIT
Commit	Line	Data
ada7c492 A	1	/*
	2	* Copyright (c) 2005, 2006, 2009 Apple Computer, 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
	24	#include <stdlib.h>
	25	#include <stdbool.h>
	26	#include <unistd.h>
	27	#include <fcntl.h>
	28	#include <sys/syslog.h>
	29	#include <sys/time.h>
	30	#include <sys/socket.h>
	31	#include <sys/un.h>
	32	#include <crt_externs.h>
	33
	34	#include <TargetConditionals.h>
	35
	36	#include <_simple.h>
	37
	38	#include <os/lock.h>
	39	#include <os/lock_private.h>
	40	#include <os/alloc_once_private.h>
	41	#include <platform/string.h>
	42	#include <platform/compat.h>
	43
89154bfb A	44	#if TARGET_OS_DRIVERKIT
	45	// DriverKit processes log directly to kernel log
	46	#include <sys/log_data.h>
	47	OS_ENUM(os_log_type, uint8_t,
	48	OS_LOG_TYPE_DEFAULT = 0x00,
	49	OS_LOG_TYPE_INFO = 0x01,
	50	OS_LOG_TYPE_DEBUG = 0x02,
	51	);
	52	#else // !TARGET_OS_DRIVERKIT
	53
ada7c492 A	54	#define ASL_LOG_PATH _PATH_LOG
	55
	56	extern ssize_t __sendto(int, const void , size_t, int, const struct sockaddr , socklen_t);
	57	extern int __gettimeofday(struct timeval , struct timezone );
	58
	59	struct ProgramVars
	60	{
	61	void* mh;
	62	int* NXArgcPtr;
	63	char*** NXArgvPtr;
	64	char*** environPtr;
	65	char** __prognamePtr;
	66	};
	67
	68	struct asl_context {
	69	bool asl_enabled;
	70	const char *progname;
	71	int asl_fd;
442fbc9d	72	#if TARGET_OS_SIMULATOR && !TARGET_OS_MACCATALYST
ada7c492 A	73	const char *sim_log_path;
	74	os_unfair_lock sim_connect_lock;
	75	#else
	76	os_once_t connect_once;
	77	#endif
	78	};
	79
	80	static struct asl_context* _simple_asl_get_context(void);
	81	static void _simple_asl_init_context(void *ctx);
	82	static int _simple_asl_connect(const char *log_path);
	83	static void _simple_asl_connect_once(void * __unused arg);
	84	static int _simple_asl_get_fd(void);
	85
	86	/*
	87	* Simplified ASL log interface; does not use malloc. Unfortunately, this
	88	* requires knowledge of the format used by ASL.
	89	*/
	90
ada7c492 A	91	__attribute__((visibility("hidden")))
	92	void
	93	_simple_asl_init(const char envp[], const struct ProgramVars vars)
	94	{
	95	const char *str;
	96	struct asl_context *ctx = _simple_asl_get_context();
	97	str = _simple_getenv(envp, "ASL_DISABLE");
	98	if ((str != NULL) && (!strcmp(str, "1"))) return;
	99	ctx->asl_enabled = true;
	100	if (vars && vars->__prognamePtr) {
	101	ctx->progname = *(vars->__prognamePtr);
438624e0	102	#if TARGET_OS_SIMULATOR
ada7c492 A	103	} else {
	104	const char * progname = *_NSGetProgname();
	105	if (progname)
	106	ctx->progname = progname;
	107	#endif
	108	}
	109	}
	110
	111	static int
	112	_simple_asl_connect(const char *log_path)
	113	{
	114	int fd = socket(AF_UNIX, SOCK_DGRAM, 0);
89154bfb	115	if (fd == -1) return -1;
ada7c492 A	116
	117	fcntl(fd, F_SETFD, FD_CLOEXEC);
	118
	119	struct sockaddr_un addr;
	120	addr.sun_family = AF_UNIX;
	121
	122	size_t amt = strlen(log_path) + 1;
	123	if (sizeof(addr.sun_path) < amt)
	124	amt = sizeof(addr.sun_path);
	125	memmove(addr.sun_path, log_path, amt);
	126
	127	if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
	128	close(fd);
	129	return -1;
	130	}
	131	return fd;
	132	}
	133
	134	static void
	135	_simple_asl_connect_once(void * __unused once_arg)
	136	{
	137	struct asl_context *ctx = _simple_asl_get_context();
	138	ctx->asl_fd = _simple_asl_connect(ASL_LOG_PATH);
	139	}
	140
	141	static int
	142	_simple_asl_get_fd(void)
	143	{
	144	struct asl_context *ctx = _simple_asl_get_context();
	145	if (!ctx->asl_enabled) {
	146	return -1;
	147	}
	148
442fbc9d	149	#if TARGET_OS_SIMULATOR && !TARGET_OS_MACCATALYST
ada7c492 A	150	os_unfair_lock_lock_with_options(&ctx->sim_connect_lock,
	151	OS_UNFAIR_LOCK_DATA_SYNCHRONIZATION);
	152	if (ctx->sim_log_path) {
	153	// all setup has been done already
	154	os_unfair_lock_unlock(&ctx->sim_connect_lock);
	155	return ctx->asl_fd;
	156	}
	157	ctx->sim_log_path = _simple_getenv(
	158	(const char *)_NSGetEnviron(), "IOS_SIMULATOR_SYSLOG_SOCKET");
	159	if (ctx->sim_log_path) {
	160	// the first and only time the envvar is being checked
	161	// asl_fd procured by the end of this call will be used forever
	162	int sim_log_fd = _simple_asl_connect(ctx->sim_log_path);
	163	if (sim_log_fd > -1) {
	164	// successfully connected to the SIM path
	165	if (ctx->asl_fd > -1) {
	166	// close the ASL_LOG_PATH fd
	167	close(ctx->asl_fd);
	168	}
	169	ctx->asl_fd = sim_log_fd;
	170	}
	171	}
	172	if (ctx->asl_fd < 0) {
	173	// either there is no envvar or it didn't work. fallback to ASL_LOG_PATH
	174	ctx->asl_fd = _simple_asl_connect(ASL_LOG_PATH);
	175	}
	176	os_unfair_lock_unlock(&ctx->sim_connect_lock);
	177	return ctx->asl_fd;
	178	#else
	179	os_once(&ctx->connect_once, NULL, _simple_asl_connect_once);
	180	return ctx->asl_fd;
	181	#endif
	182	}
89154bfb A	183	#endif // !TARGET_OS_DRIVERKIT
	184
	185	static const char *
	186	_simple_asl_escape_key(unsigned char c)
	187	{
	188	switch(c)
	189	{
	190	case '\\': return "\\\\";
	191	case '[': return "\\[";
	192	case ']': return "\\]";
	193	case '\n': return "\\n";
	194	case ' ': return "\\s";
	195	}
	196
	197	return NULL;
	198	}
	199
	200	static const char *
	201	_simple_asl_escape_val(unsigned char c)
	202	{
	203	switch(c)
	204	{
	205	case '\\': return "\\\\";
	206	case '[': return "\\[";
	207	case ']': return "\\]";
	208	case '\n': return "\\n";
	209	}
	210
	211	return NULL;
	212	}
ada7c492 A	213
	214	_SIMPLE_STRING
	215	_simple_asl_msg_new(void)
	216	{
	217	_SIMPLE_STRING b = _simple_salloc();
	218
	219	if (b == NULL) return NULL;
	220
e45b4692	221	if (_simple_sprintf(b, " 0"))
ada7c492 A	222	{
	223	_simple_sfree(b);
	224	return NULL;
	225	}
	226
	227	return b;
	228	}
	229
	230	void
	231	_simple_asl_msg_set(_SIMPLE_STRING __b, const char __key, const char __val)
	232	{
	233	if (__b == NULL) return;
	234	if (__key == NULL) return;
	235
	236	do
	237	{
e45b4692	238	if (_simple_sprintf(__b, " [")) break;
ada7c492 A	239	if (_simple_esprintf(__b, _simple_asl_escape_key, "%s", __key)) break;
	240	if (__val != NULL)
	241	{
	242	if (_simple_esprintf(__b, _simple_asl_escape_val, " %s", __val)) break;
	243	if (!strcmp(__key, "Message"))
	244	{
	245	char *cp;
	246
	247	/* remove trailing (escaped) newlines */
	248	cp = _simple_string(__b);
	249	cp += strlen(cp);
	250	for (;;)
	251	{
	252	cp -= 2;
	253	if (strcmp(cp, "\\n") != 0) break;
	254	*cp = 0;
	255	}
	256
	257	_simple_sresize(__b);
	258	}
	259	}
	260
	261	if (_simple_sappend(__b, "]")) break;
	262	return;
	263	} while (0);
	264	}
	265
	266	void
	267	_simple_asl_send(_SIMPLE_STRING __b)
	268	{
89154bfb	269	#if !TARGET_OS_DRIVERKIT
ada7c492 A	270	struct timeval tv;
	271	int asl_fd = _simple_asl_get_fd();
	272	if (asl_fd < 0) return;
	273
	274	__gettimeofday(&tv, NULL);
	275
	276	do
	277	{
	278	char *cp;
	279
e45b4692	280	if (_simple_sprintf(__b, " [PID ")) break;
ada7c492	281	if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getpid())) break;
e45b4692	282	if (_simple_sprintf(__b, "] [UID ")) break;
ada7c492	283	if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getuid())) break;
e45b4692	284	if (_simple_sprintf(__b, "] [GID ")) break;
ada7c492	285	if (_simple_esprintf(__b, _simple_asl_escape_val, "%u", getgid())) break;
e45b4692	286	if (_simple_sprintf(__b, "] [Time ")) break;
ada7c492 A	287	if (_simple_esprintf(__b, _simple_asl_escape_val, "%lu", tv.tv_sec)) break;
	288	if (_simple_sappend(__b, "] [TimeNanoSec ")) break;
	289	if (_simple_esprintf(__b, _simple_asl_escape_val, "%d", tv.tv_usec * 1000)) break;
	290	if (_simple_sappend(__b, "]\n")) break;
	291
	292	cp = _simple_string(__b);
	293	__sendto(asl_fd, cp, strlen(cp), 0, NULL, 0);
	294	} while (0);
89154bfb A	295	#else // TARGET_OS_DRIVERKIT
	296	char *cp;
	297	cp = _simple_string(__b);
	298	log_data_as_kernel(0, OS_LOG_TYPE_DEFAULT, cp, strlen(cp) + 1);
	299	#endif // TARGET_OS_DRIVERKIT
ada7c492 A	300	}
	301
	302	void
	303	_simple_asl_log_prog(int level, const char facility, const char message, const char *prog)
	304	{
ada7c492 A	305	_SIMPLE_STRING b = _simple_asl_msg_new();
	306	if (b == NULL) return;
	307
89154bfb A	308	#if !TARGET_OS_DRIVERKIT
89154bfb A	309	char lstr[2];
ada7c492 A	310	if (level < 0) level = 0;
	311	if (level > 7) level = 7;
	312	lstr[0] = level + '0';
	313	lstr[1] = '\0';
	314
	315	_simple_asl_msg_set(b, "Sender", prog);
	316	_simple_asl_msg_set(b, "Level", lstr);
	317	_simple_asl_msg_set(b, "Facility", facility);
	318	_simple_asl_msg_set(b, "Message", message);
	319	_simple_asl_send(b);
89154bfb A	320	#else // TARGET_OS_DRIVERKIT
	321	if (prog) _simple_asl_msg_set(b, "Sender", prog);
	322	_simple_asl_msg_set(b, "Facility", facility);
	323	_simple_asl_msg_set(b, "Message", message);
	324
	325	os_log_type_t type = level > ASL_LEVEL_INFO ? OS_LOG_TYPE_DEFAULT :
	326	(level > ASL_LEVEL_DEBUG ? OS_LOG_TYPE_INFO : OS_LOG_TYPE_DEBUG);
	327
	328	char *cp;
	329	cp = _simple_string(b);
	330	log_data_as_kernel(0, type, cp, strlen(cp) + 1);
	331	#endif // TARGET_OS_DRIVERKIT
ada7c492 A	332	_simple_sfree(b);
	333	}
	334
	335	void
	336	_simple_asl_log(int level, const char facility, const char message)
	337	{
89154bfb	338	#if !TARGET_OS_DRIVERKIT
ada7c492 A	339	_simple_asl_log_prog(level, facility, message,
ada7c492 A	340	_simple_asl_get_context()->progname);
89154bfb A	341	#else // TARGET_OS_DRIVERKIT
	342	_simple_asl_log_prog(level, facility, message, NULL);
	343	#endif // TARGET_OS_DRIVERKIT
ada7c492 A	344	}
ada7c492 A	345
89154bfb	346	#if !TARGET_OS_DRIVERKIT
ada7c492 A	347	static struct asl_context *
	348	_simple_asl_get_context(void)
	349	{
	350	return os_alloc_once(OS_ALLOC_ONCE_KEY_LIBSYSTEM_PLATFORM_ASL,
	351	sizeof(struct asl_context), _simple_asl_init_context);
	352	}
	353
	354	static void
	355	_simple_asl_init_context(void *arg)
	356	{
	357	struct asl_context ctx = (struct asl_context )arg;
	358	// ctx is zero-filled when it comes out of _os_alloc_once
	359	ctx->progname = "unknown";
	360	ctx->asl_fd = -1;
	361	}
89154bfb	362	#endif // !TARGET_OS_DRIVERKIT