#include "../../context.h"
#interface "vm.h"

// ----
// typedef struct vm_impl<Impl, Isa> impl vm{
//     __code kpt_alloc_check_impl(Type* vm_impl, __code next(...));
//     __code loaduvm_ptesize_checkvm_impl(Type* vm_impl, __code next(int ret, ...));
//     __code loaduvm_check_PTE_SZ(Type* vm_impl, __code next(int ret, ...));
//     __code copyout_loop_check_n(Type* vm_impl, pde_t* pgdir, uint va, void* pp, uint len, uint va0, char* pa0, uint n, char* buf, __code next(...));
//     __code clearpteu_check_ptevm_impl(Type* vm_impl, pde_t* pgdir, char* uva, __code next(int ret, ...));
//     __code uva2ka_check_pe_types(Type* vm, pde_t* pgdir, char* uva, __code next(int ret, ...));
//     __code copyout_loopvm_impl(Type* vm_impl, pde_t* pgdir, uint va, void* pp, uint len, uint va0, char* pa0,  __code next(int ret, ...));
//     __code switchuvm_check_pgdirvm_impl(Type* vm_impl, proc_struct* p, __code next(...));
//     __code init_inituvm_check_sz(Type* vm_impl, pde_t* pgdir, char* init, uint sz, __code next(...));
//
//     __code loaduvm_loopvm_impl(Type* vm_impl, __code next(int ret, ...));
//     __code loaduvm_check_pgdir(Type* vm_impl, __code next(int ret, ...));
//     __code loaduvm_exit(Type* vm_impl, __code next(int ret, ...));
//     __code allocuvm_check_newszvm_impl(Type* vm_impl, pde_t* pgdir, uint oldsz, uint newsz, __code next(int ret, ...));
//     __code allocuvm_loopvm_impl(Type* vm_impl, pde_t* pgdir, uint oldsz, uint newsz, char* mem, uint a, __code next(int ret, ...));
//     __code copyuvm_check_nullvm_impl(Type* vm_impl, pde_t* pgdir, uint sz, __code next(int ret, ...));
//     __code copyuvm_loopvm_impl(Type* vm_impl, pde_t* pgdir, uint sz, pde_t* d, pte_t* pte, uint pa, uint i, uint ap, char* mem, __code next(int ret, ...));
//     __code copyuvm_loop_check_walkpgdir(Type* vm_impl, pde_t* pgdir, uint sz, pde_t* d, pte_t* pte, uint pa, uint i, uint ap, char* mem, __code next(int ret, ...));
//     __code copyuvm_loop_check_pte(Type* vm_impl, pde_t* pgdir, uint sz, pde_t* d, pte_t* pte, uint pa, uint i, uint ap, char* mem, __code next(int ret, ...));
//     __code copyuvm_loop_check_mem(Type* vm_impl, pde_t* pgdir, uint sz, pde_t* d, pte_t* pte, uint pa, uint i, uint ap, char* mem, __code next(int ret, ...));
//     __code copyuvm_loop_check_mappages(Type* vm_impl, pde_t* pgdir, uint sz, pde_t* d, pte_t* pte, uint pa, uint i, uint ap, char* mem, __code next(int ret, ...));
//     __code copyuvm_loop_bad(Type* vm_impl, pde_t* d, __code next(int ret, ...));
//     __code uva2ka_check_pte_ap(Type* vm, pde_t* pgdir, char* uva, pte_t* pte, __code next(int ret, ...));
//     __code paging_intvmvm_impl(Type* vm_impl, uint phy_low, uint phy_hi, __code next(...));
//     __code copyout_loop_check_pa0(Type* vm_impl, pde_t* pgdir, uint va, void* pp, uint len, uint va0, char* pa0, uint n, __code next(int ret, ...));
// } vm_impl;
// ----

vm* createvm_impl(struct Context* cbc_context) {
    struct vm* vm  = new vm();
    struct vm_impl* vm_impl = new vm_impl();
    vm->vm = (union Data*)vm_impl;
    vm_impl->vm_impl = NULL;
    vm_impl->ret  = 0;
    vm_impl->pgdir = NULL;
    vm_impl->va  = 0;
    vm_impl->pp = NULL;
    vm_impl->len  = 0;
    vm_impl->va0  = 0;
    vm_impl->pa0 = NULL;
    vm_impl->n  = 0;
    vm_impl->buf = NULL;
    vm_impl->uva = NULL;
    vm_impl->vm = NULL;
    vm_impl->p = NULL;
    vm_impl->init = NULL;
    vm_impl->sz  = 0;
    vm_impl->oldsz  = 0;
    vm_impl->newsz  = 0;
    vm_impl->mem = NULL;
    vm_impl->a  = 0;
    vm_impl->d = NULL;
    vm_impl->pte = NULL;
    vm_impl->pa  = 0;
    vm_impl->i  = 0;
    vm_impl->ap  = 0;
    vm_impl->phy_low  = 0;
    vm_impl->phy_hi  = 0;
    vm_impl->kpt_alloc_check_impl = C_kpt_alloc_check_impl;
    vm_impl->loaduvm_ptesize_checkvm_impl = C_loaduvm_ptesize_checkvm_impl;
    vm_impl->loaduvm_check_PTE_SZ = C_loaduvm_check_PTE_SZ;
    vm_impl->copyout_loop_check_n = C_copyout_loop_check_n;
    vm_impl->clearpteu_check_ptevm_impl = C_clearpteu_check_ptevm_impl;
    vm_impl->uva2ka_check_pe_types = C_uva2ka_check_pe_types;
    vm_impl->copyout_loopvm_impl = C_copyout_loopvm_impl;
    vm_impl->switchuvm_check_pgdirvm_impl = C_switchuvm_check_pgdirvm_impl;
    vm_impl->init_inituvm_check_sz = C_init_inituvm_check_sz;
    vm_impl->loaduvm_loopvm_impl = C_loaduvm_loopvm_impl;
    vm_impl->loaduvm_check_pgdir = C_loaduvm_check_pgdir;
    vm_impl->loaduvm_exit = C_loaduvm_exit;
    vm_impl->allocuvm_check_newszvm_impl = C_allocuvm_check_newszvm_impl;
    vm_impl->allocuvm_loopvm_impl = C_allocuvm_loopvm_impl;
    vm_impl->copyuvm_check_nullvm_impl = C_copyuvm_check_nullvm_impl;
    vm_impl->copyuvm_loopvm_impl = C_copyuvm_loopvm_impl;
    vm_impl->copyuvm_loop_check_walkpgdir = C_copyuvm_loop_check_walkpgdir;
    vm_impl->copyuvm_loop_check_pte = C_copyuvm_loop_check_pte;
    vm_impl->copyuvm_loop_check_mem = C_copyuvm_loop_check_mem;
    vm_impl->copyuvm_loop_check_mappages = C_copyuvm_loop_check_mappages;
    vm_impl->copyuvm_loop_bad = C_copyuvm_loop_bad;
    vm_impl->uva2ka_check_pte_ap = C_uva2ka_check_pte_ap;
    vm_impl->paging_intvmvm_impl = C_paging_intvmvm_impl;
    vm_impl->copyout_loop_check_pa0 = C_copyout_loop_check_pa0;
    vm->init_vmm = C_init_vmmvm_impl;
    vm->kpt_freerange = C_kpt_freerangevm_impl;
    vm->kpt_alloc = C_kpt_allocvm_impl;
    vm->switchuvm = C_switchuvmvm_impl;
    vm->init_inituvm = C_init_inituvmvm_impl;
    vm->loaduvm = C_loaduvmvm_impl;
    vm->allocuvm = C_allocuvmvm_impl;
    vm->clearpteu = C_clearpteuvm_impl;
    vm->copyuvm = C_copyuvmvm_impl;
    vm->uva2ka = C_uva2kavm_impl;
    vm->copyout = C_copyoutvm_impl;
    vm->paging_int = C_paging_intvm_impl;
    vm->void_ret = C_vm_void_ret;
    return vm;
}


extern struct {
    struct spinlock lock;
    struct run *freelist;
} kpt_mem;

__code init_vmmvm_impl(struct vm_impl* vm,__code next(...)) {
    initlock(&kpt_mem.lock, "vm");
    kpt_mem.freelist = NULL;
    
    goto next(...);
}

extern struct run {
    struct run *next;
};

static void _kpt_free (char *v)
{
    struct run *r;

    r = (struct run*) v;
    r->next = kpt_mem.freelist;
    kpt_mem.freelist = r;
}

__code kpt_freerangevm_impl(struct vm_impl* vm, uint low, uint hi, __code next(...)) { 
 
   if (low < hi) { 
     _kpt_free((char*)low);
     goto kpt_freerangevm_impl(vm, low + PT_SZ, hi, next(...));  
  
   } 
  goto next(...);
}
__code kpt_allocvm_impl(struct vm_impl* vm, __code next(...)) {
  acquire(&kpt_mem.lock);

  goto kpt_alloc_check_impl(vm_impl, next(...));
}

typedef struct proc proc;
__code switchuvmvm_impl(struct vm_impl* vm , struct proc* p, __code next(...)) { //:skip
    Gearef(cbc_context, vm_impl)->p = p;
    Gearef(cbc_context, vm_impl)->next = next;
    goto switchuvm_check_pgdirvm_impl(vm, p, next(...));
}

__code init_inituvmvm_impl(struct vm_impl* vm, pde_t* pgdir, char* init, uint sz, __code next(...)) { 

    Gearef(cbc_context, vm_impl)->pgdir = pgdir;
    Gearef(cbc_context, vm_impl)->init = init;
    Gearef(cbc_context, vm_impl)->sz = sz;
    Gearef(cbc_context, vm_impl)->next = next;
    goto init_inituvm_check_sz(vm, pgdir, init, sz, next(...));
}

__code loaduvmvm_impl(struct vm_impl* vm, pde_t* pgdir, char* addr, struct inode* ip, uint offset, uint sz,  __code next(...)) {
    Gearef(cbc_context, vm_impl)->pgdir = pgdir;
    Gearef(cbc_context, vm_impl)->addr = addr;
    Gearef(cbc_context, vm_impl)->ip = ip;
    Gearef(cbc_context, vm_impl)->offset = offset;
    Gearef(cbc_context, vm_impl)->sz = sz;
    Gearef(cbc_context, vm_impl)->next = next;

    goto loaduvm_ptesize_checkvm_impl(vm, next(...));
}

__code allocuvmvm_impl(struct vm_impl* vm, pde_t* pgdir, uint oldsz, uint newsz, __code next(...)) {

    goto allocuvm_check_newszvm_impl(vm, pgdir, oldsz, newsz, next(...));
}

__code clearpteuvm_impl(struct vm_impl* vm, pde_t* pgdir, char* uva,  __code next(...)) {

    goto clearpteu_check_ptevm_impl(vm, pgdir, uva, next(...));
}

__code copyuvmvm_impl(struct vm_impl* vm, pde_t* pgdir, uint sz, __code next(...)) {

    goto copyuvm_check_nullvm_impl(vm, pgdir, sz, __code next(...));
}

__code uva2kavm_impl(struct vm_impl* vm, pde_t* pgdir, char* uva, __code next(...)) {

    goto uva2ka_check_pe_types(vm, pgdir, uva, next(...));
}

__code copyoutvm_impl(struct vm_impl* vm, pde_t* pgdir, uint va, void* pp, uint len, __code next(...)) {

    vm->buf = (char*) pp;    

    goto copyout_loopvm_impl(vm, pgdir, va, pp, len, va0, pa0, next(...));
}

__code paging_intvm_impl(struct vm_impl* vm, uint phy_low, uint phy_hi, __code next(...)) {

    goto paging_intvmvm_impl(vm, phy_low, phy_hi, next(...));
}

__code vm_void_ret(struct vm_impl* vm) {
    return;
}