/*
 * Copyright (c) 2014-2020 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_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. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * 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_OSREFERENCE_LICENSE_HEADER_END@
 */

#include "panic_hooks.h"

#include <kern/queue.h>
#include <kern/locks.h>
#include <kern/thread.h>
#include <vm/WKdm_new.h>
#include <pexpert/boot.h>

#include "pmap.h"

struct panic_hook {
	uint32_t                        magic1;
	queue_chain_t           chain;
	thread_t                        thread;
	panic_hook_fn_t         hook_fn;
	uint32_t                        magic2;
};

typedef char check1_[sizeof(struct panic_hook)
    <= sizeof(panic_hook_t) ? 1 : -1];
typedef char check2_[PAGE_SIZE == 4096 ? 1 : -1];

static hw_lock_data_t   panic_hooks_lock;
static queue_head_t     panic_hooks;
static uint8_t                  panic_dump_buf[8192];

#define PANIC_HOOK_MAGIC1               0x4A1C400C
#define PANIC_HOOK_MAGIC2               0xC004C1A4

void
panic_hooks_init(void)
{
	hw_lock_init(&panic_hooks_lock);
	queue_init(&panic_hooks);
}

void
panic_hook(panic_hook_t *hook_, panic_hook_fn_t hook_fn)
{
	struct panic_hook *hook = (struct panic_hook *)hook_;

	hook->magic1    = PANIC_HOOK_MAGIC1;
	hook->magic2    = PANIC_HOOK_MAGIC2;
	hook->hook_fn   = hook_fn;
	hook->thread    = current_thread();

	hw_lock_lock(&panic_hooks_lock, LCK_GRP_NULL);
	queue_enter(&panic_hooks, hook, struct panic_hook *, chain);
	hw_lock_unlock(&panic_hooks_lock);
}

void
panic_unhook(panic_hook_t *hook_)
{
	struct panic_hook *hook = (struct panic_hook *)hook_;

	hw_lock_lock(&panic_hooks_lock, LCK_GRP_NULL);
	queue_remove(&panic_hooks, hook, struct panic_hook *, chain);
	hw_lock_unlock(&panic_hooks_lock);
}

void
panic_check_hook(void)
{
	struct panic_hook *hook;
	thread_t thread = current_thread();
	uint32_t count = 0;

	queue_iterate(&panic_hooks, hook, struct panic_hook *, chain) {
		if (++count > 1024
		|| !kvtophys((vm_offset_t)hook)
		|| !kvtophys((vm_offset_t)hook + sizeof(*hook) - 1)
		|| hook->magic1 != PANIC_HOOK_MAGIC1
		|| hook->magic2 != PANIC_HOOK_MAGIC2
		|| !kvtophys((vm_offset_t)hook->hook_fn)) {
			return;
		}

		if (hook->thread == thread) {
			hook->hook_fn((panic_hook_t *)hook);
			return;
		}
	}
}

/*
 * addr should be page aligned and len should be multiple of page
 * size.  This will currently only work if each page can be compressed
 * to no more than 4095 bytes.
 *
 * Remember the debug buffer isn't very big so don't try and dump too
 * much.
 */
void
panic_dump_mem(const void *addr, int len)
{
	void *scratch = panic_dump_buf + 4096;

	for (; len > 0; addr = (const uint8_t *)addr + PAGE_SIZE, len -= PAGE_SIZE) {
		if (!kvtophys((vm_offset_t)addr)) {
			continue;
		}

		// 4095 is multiple of 3 -- see below
		int n = WKdm_compress_new((const WK_word *)addr, (WK_word *)(void *)panic_dump_buf,
		    scratch, 4095);

		if (n == -1) {
			return; // Give up
		}
		kdb_log("%p: ", addr);

		// Dump out base64
		static char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		    "abcdefghijklmnopqrstuvwxyz0123456789+/";

		// Pad to multiple of 3
		switch (n % 3) {
		case 1:
			panic_dump_buf[n++] = 0;
			OS_FALLTHROUGH;
		case 2:
			panic_dump_buf[n++] = 0;
		}

		uint8_t *p = panic_dump_buf;
		while (n) {
			uint8_t c;

			c = p[0] >> 2;
			consdebug_log(base64_table[c]);

			c = (p[0] << 4 | p[1] >> 4) & 0x3f;
			consdebug_log(base64_table[c]);

			c = (p[1] << 2 | p[2] >> 6) & 0x3f;
			consdebug_log(base64_table[c]);

			c = p[2] & 0x3f;
			consdebug_log(base64_table[c]);

			p += 3;
			n -= 3;
		}

		consdebug_log('\n');
	}
}

boolean_t
panic_phys_range_before(const void *addr, uint64_t *pphys,
    panic_phys_range_t *range)
{
	*pphys = kvtophys((vm_offset_t)addr);

	const boot_args *args = PE_state.bootArgs;

	if (!kvtophys((vm_offset_t)args)) {
		return FALSE;
	}

	const EfiMemoryRange *r = PHYSMAP_PTOV((uintptr_t)args->MemoryMap), *closest = NULL;
	const uint32_t size = args->MemoryMapDescriptorSize;
	const uint32_t count = args->MemoryMapSize / size;

	if (count > 1024) {     // Sanity check
		return FALSE;
	}

	for (uint32_t i = 0; i < count; ++i, r = (const EfiMemoryRange *)(const void *)((const uint8_t *)r + size)) {
		if (r->PhysicalStart + r->NumberOfPages * PAGE_SIZE > *pphys) {
			continue;
		}

		if (!closest || r->PhysicalStart > closest->PhysicalStart) {
			closest = r;
		}
	}

	if (!closest) {
		return FALSE;
	}

	range->type             = closest->Type;
	range->phys_start       = closest->PhysicalStart;
	range->len                      = closest->NumberOfPages * PAGE_SIZE;

	return TRUE;
}