xref: /xnu-8792.41.9/libsyscall/wrappers/kdebug_trace.c (revision 5c2921b07a2480ab43ec66f5b9e41cb872bc554f)

/*
 * Copyright (c) 2014 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 <mach/mach_time.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdatomic.h>
#include <machine/cpu_capabilities.h>
#include <sys/kdebug.h>
#include <sys/kdebug_private.h>
#include <sys/kdebug_signpost.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/sysctl.h>
#include <mach/mach.h>
#include <mach/mach_vm.h>

extern int __kdebug_typefilter(void** addr, size_t* size);
extern int __kdebug_trace64(uint32_t code, uint64_t arg1, uint64_t arg2,
    uint64_t arg3, uint64_t arg4);
extern uint64_t __kdebug_trace_string(uint32_t debugid, uint64_t str_id,
    const char *str);

static int kdebug_signpost_internal(uint32_t debugid, uintptr_t arg1,
    uintptr_t arg2, uintptr_t arg3, uintptr_t arg4);

/*
 * GENERAL API DESIGN NOTE!
 *
 * Trace API's are expected to avoid performing checks until tracing has
 * been enabled. This includes checks that might cause error codes to be
 * returned.
 *
 * Trace invocations via wrapper and syscall must have the same behavior.
 *
 * Note that the userspace API is chosing to optimize fastpath, non-error
 * performance by eliding validation of each debugid. This means that error
 * cases which could have been caught in userspace will make a syscall
 * before returning with the correct error code. This tradeoff in performance
 * is intentional.
 */

void *
kdebug_typefilter(void)
{
	static void* typefilter;

	/* We expect kdebug_typefilter_bitmap to be valid (the if is not executed) */
	if (__builtin_expect(!typefilter, 0)) {
		// Map the typefilter if it can be mapped.
		void* ptr = NULL;
		size_t ptr_size = 0;

		if (__kdebug_typefilter(&ptr, &ptr_size) == 0) {
			void* old_value = NULL;
			if (ptr && !atomic_compare_exchange_strong((void* _Atomic volatile *)&typefilter, &old_value, ptr)) {
				mach_vm_deallocate(mach_task_self(), (mach_vm_offset_t)ptr, KDBG_TYPEFILTER_BITMAP_SIZE);
			}
		}
	}

	return typefilter;
}

bool
kdebug_is_enabled(uint32_t debugid)
{
	uint32_t state = COMM_PAGE_READ(uint32_t, KDEBUG_ENABLE);

	if (state == 0) {
		return FALSE;
	}

	if ((state & KDEBUG_COMMPAGE_ENABLE_TYPEFILTER) > 0) {
		/*
		 * Typefilter rules...
		 *
		 * If no typefilter is available (even if due to error),
		 * debugids are allowed.
		 *
		 * The typefilter will always allow DBG_TRACE; this is a kernel
		 * invariant. There is no need for an explicit check here.
		 *
		 * NOTE: The typefilter will always allow DBG_TRACE, but
		 * it is not legal to inject DBG_TRACE via kdebug_trace.
		 * Attempts to do so will not be detected here, but will be
		 * detected in the kernel, and an error will be returned. Per
		 * the API design note at the top of this file, this is a
		 * deliberate choice.
		 */
		uint8_t* typefilter = kdebug_typefilter();
		if (typefilter && isset(typefilter, KDBG_EXTRACT_CSC(debugid)) == 0) {
			return FALSE;
		}
	}

	return TRUE;
}

bool
kdebug_using_continuous_time(void)
{
	uint32_t state = COMM_PAGE_READ(uint32_t, KDEBUG_ENABLE);
	return state & KDEBUG_COMMPAGE_CONTINUOUS;
}

uint64_t
kdebug_timestamp(void)
{
	return kdebug_using_continuous_time() ? mach_continuous_time() :
	       mach_absolute_time();
}

uint64_t
kdebug_timestamp_from_absolute(uint64_t abstime)
{
	if (kdebug_using_continuous_time()) {
		return abstime + *(volatile uint64_t*)_COMM_PAGE_CONT_TIMEBASE;
	} else {
		return abstime;
	}
}

uint64_t
kdebug_timestamp_from_continuous(uint64_t conttime)
{
	if (kdebug_using_continuous_time()) {
		return conttime;
	} else {
		return conttime - *(volatile uint64_t*)_COMM_PAGE_CONT_TIMEBASE;
	}
}

int
kdebug_trace(uint32_t debugid, uint64_t arg1, uint64_t arg2, uint64_t arg3,
    uint64_t arg4)
{
	if (!kdebug_is_enabled(debugid)) {
		return 0;
	} else {
		return __kdebug_trace64(debugid, arg1, arg2, arg3, arg4);
	}
}

uint64_t
kdebug_trace_string(uint32_t debugid, uint64_t str_id, const char *str)
{
	if (!kdebug_is_enabled(debugid)) {
		return 0;
	}

	if ((int64_t)str_id == -1) {
		errno = EINVAL;
		return (uint64_t)-1;
	}

	if (str_id == 0 && str == NULL) {
		errno = EINVAL;
		return (uint64_t)-1;
	}

	return __kdebug_trace_string(debugid, str_id, str);
}

static int
kdebug_signpost_internal(uint32_t debugid, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
{
	if (KDBG_EXTRACT_CSC(debugid) != 0) {
		errno = EINVAL;
		return -1;
	}

	debugid |= APPSDBG_CODE(DBG_APP_SIGNPOST, 0);

	return kdebug_trace(debugid, arg1, arg2, arg3, arg4);
}

int
kdebug_signpost(uint32_t code, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
{
	return kdebug_signpost_internal(code << KDBG_CODE_OFFSET, arg1, arg2, arg3, arg4);
}

int
kdebug_signpost_start(uint32_t code, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
{
	return kdebug_signpost_internal((code << KDBG_CODE_OFFSET) | DBG_FUNC_START, arg1, arg2, arg3, arg4);
}

int
kdebug_signpost_end(uint32_t code, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4)
{
	return kdebug_signpost_internal((code << KDBG_CODE_OFFSET) | DBG_FUNC_END, arg1, arg2, arg3, arg4);
}