/* Copyright (c) 2009-13 The Regents of the University of California
 * Barret Rhoden <brho@cs.berkeley.edu>
 * See LICENSE for details.
 *
 * x86 trap.c bit-specific functions. */

#include <arch/mmu.h>
#include <arch/x86.h>
#include <arch/arch.h>
#include <arch/console.h>
#include <arch/apic.h>
#include <ros/common.h>
#include <smp.h>
#include <assert.h>
#include <pmap.h>
#include <trap.h>
#include <monitor.h>
#include <process.h>
#include <mm.h>
#include <stdio.h>
#include <slab.h>
#include <syscall.h>
#include <kdebug.h>
#include <kmalloc.h>

/* Starts running the current TF, just using ret. */
void pop_kernel_ctx(struct kernel_ctx *ctx)
{
	struct sw_trapframe *tf = &ctx->sw_tf;
	/* We're starting at rbx's spot in the sw_tf */
	asm volatile ("movq %0, %%rsp;          "
				  "popq %%rbx;              "
				  "popq %%rbp;              "
				  "popq %%r12;              "
				  "popq %%r13;              "
				  "popq %%r14;              "
				  "popq %%r15;              "
				  "popq %%rax;              " /* pop rip */
				  "popq %%rsp;              "
				  "jmp *%%rax;              " /* stored rip */
				  : : "g"(&ctx->sw_tf.tf_rbx) : "memory");
	panic("ret failed");
}

void print_trapframe(struct hw_trapframe *hw_tf)
{
	static spinlock_t ptf_lock = SPINLOCK_INITIALIZER_IRQSAVE;

	struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
	/* This is only called in debug scenarios, and often when the kernel trapped
	 * and needs to tell us about it.  Disable the lock checker so it doesn't go
	 * nuts when we print/panic */
	pcpui->__lock_checking_enabled--;
	spin_lock_irqsave(&ptf_lock);
	printk("HW TRAP frame at %p on core %d\n", hw_tf, core_id());
	printk("  rax  0x%016lx\n",           hw_tf->tf_rax);
	printk("  rbx  0x%016lx\n",           hw_tf->tf_rbx);
	printk("  rcx  0x%016lx\n",           hw_tf->tf_rcx);
	printk("  rdx  0x%016lx\n",           hw_tf->tf_rdx);
	printk("  rbp  0x%016lx\n",           hw_tf->tf_rbp);
	printk("  rsi  0x%016lx\n",           hw_tf->tf_rsi);
	printk("  rdi  0x%016lx\n",           hw_tf->tf_rdi);
	printk("  r8   0x%016lx\n",           hw_tf->tf_r8);
	printk("  r9   0x%016lx\n",           hw_tf->tf_r9);
	printk("  r10  0x%016lx\n",           hw_tf->tf_r10);
	printk("  r11  0x%016lx\n",           hw_tf->tf_r11);
	printk("  r12  0x%016lx\n",           hw_tf->tf_r12);
	printk("  r13  0x%016lx\n",           hw_tf->tf_r13);
	printk("  r14  0x%016lx\n",           hw_tf->tf_r14);
	printk("  r15  0x%016lx\n",           hw_tf->tf_r15);
	printk("  trap 0x%08x %s\n",          hw_tf->tf_trapno,
	                                      x86_trapname(hw_tf->tf_trapno));
	/* FYI: these aren't physically adjacent to trap and err */
	if (hw_tf->tf_cs == GD_KT)
		printk("  gsbs 0x%016lx\n",       read_msr(MSR_GS_BASE));
	else
		printk("  gsbs 0x%016lx\n",       hw_tf->tf_gsbase);
	printk("  fsbs 0x%016lx\n",           hw_tf->tf_fsbase);
	printk("  err  0x--------%08x\n",     hw_tf->tf_err);
	printk("  rip  0x%016lx\n",           hw_tf->tf_rip);
	printk("  cs   0x------------%04x\n", hw_tf->tf_cs);
	printk("  flag 0x%016lx\n",           hw_tf->tf_rflags);
	printk("  rsp  0x%016lx\n",           hw_tf->tf_rsp);
	printk("  ss   0x------------%04x\n", hw_tf->tf_ss);
	spin_unlock_irqsave(&ptf_lock);
	pcpui->__lock_checking_enabled++;

	/* Used in trapentry64.S */
	static_assert(offsetof(struct hw_trapframe, tf_cs) - 
	              offsetof(struct hw_trapframe, tf_rax) == 0x90);
	/* Used in trap64.h */
	static_assert(offsetof(struct per_cpu_info, stacktop) == 0);
}

void print_swtrapframe(struct sw_trapframe *sw_tf)
{
	static spinlock_t ptf_lock = SPINLOCK_INITIALIZER_IRQSAVE;
	struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
	pcpui->__lock_checking_enabled--;
	spin_lock_irqsave(&ptf_lock);
	printk("SW TRAP frame at %p on core %d\n", sw_tf, core_id());
	printk("  rbx  0x%016lx\n",           sw_tf->tf_rbx);
	printk("  rbp  0x%016lx\n",           sw_tf->tf_rbp);
	printk("  r12  0x%016lx\n",           sw_tf->tf_r12);
	printk("  r13  0x%016lx\n",           sw_tf->tf_r13);
	printk("  r14  0x%016lx\n",           sw_tf->tf_r14);
	printk("  r15  0x%016lx\n",           sw_tf->tf_r15);
	printk("  gsbs 0x%016lx\n",           sw_tf->tf_gsbase);
	printk("  fsbs 0x%016lx\n",           sw_tf->tf_fsbase);
	printk("  rip  0x%016lx\n",           sw_tf->tf_rip);
	printk("  rsp  0x%016lx\n",           sw_tf->tf_rsp);
	printk(" mxcsr 0x%08x\n",             sw_tf->tf_mxcsr);
	printk(" fpucw 0x%04x\n",             sw_tf->tf_fpucw);
	spin_unlock_irqsave(&ptf_lock);
	pcpui->__lock_checking_enabled++;
}

void page_fault_handler(struct hw_trapframe *hw_tf)
{
	uintptr_t fault_va = rcr2();
	int prot = hw_tf->tf_err & PF_ERROR_WRITE ? PROT_WRITE : PROT_READ;
	int err;

	/* TODO - handle kernel page faults */
	if ((hw_tf->tf_cs & 3) == 0) {
		print_trapframe(hw_tf);
		backtrace_kframe(hw_tf);
		panic("Page Fault in the Kernel at 0x%08x!", fault_va);
		/* if we want to do something like kill a process or other code, be
		 * aware we are in a sort of irq-like context, meaning the main kernel
		 * code we 'interrupted' could be holding locks - even irqsave locks. */
	}
	/* safe to reenable after rcr2 */
	enable_irq();
	if ((err = handle_page_fault(current, fault_va, prot))) {
		/* Destroy the faulting process */
		printk("[%08x] user %s fault va %p ip %p on core %d with err %d\n",
		       current->pid, prot & PROT_READ ? "READ" : "WRITE", fault_va,
		       hw_tf->tf_rip, core_id(), err);
		print_trapframe(hw_tf);
		/* Turn this on to help debug bad function pointers */
		printd("rsp %p\n\t 0(rsp): %p\n\t 8(rsp): %p\n\t 16(rsp): %p\n"
		       "\t24(rsp): %p\n", hw_tf->tf_rsp,
		       *(uintptr_t*)(hw_tf->tf_rsp +  0),
		       *(uintptr_t*)(hw_tf->tf_rsp +  8),
		       *(uintptr_t*)(hw_tf->tf_rsp + 16),
		       *(uintptr_t*)(hw_tf->tf_rsp + 24));
		proc_destroy(current);
	}
}