int proc_create_vm(struct Kernel * kernel, int size) {
    // Fill your codes below.

    int check_valid(int size,struct Kernel * kernel){
        // A process whose memory size larger than the limit, return failure flag
        if(VIRTUAL_SPACE_SIZE<size){
            return -1;
        }
    }

    int check_full(int size,struct Kernel * kernel){
        // Check whether the table is full
        if(kernel->allocated_pages == KERNEL_SPACE_SIZE/PAGE_SIZE){
            return -1;
        }
    }

    // Return how many pages I need
    int pages_demanded_func(int size){
        int pages_num = size/PAGE_SIZE;
        // The size isn't divisible
        if (size % PAGE_SIZE != 0){
            return (pages_num+1);
        }
        // The size is divisible
        else{
            return (((size+PAGE_SIZE)/PAGE_SIZE)-1);
        }
    }

    int process_id = 0;
    //check whther I don't have enough memory to allocate
    if(check_valid(size,kernel) == -1 || check_full(size,kernel) == -1){
        // Fail to create vm
        return -1;
    }
    else if(check_valid(size,kernel) != -1){
        for(process_id;process_id<MAX_PROCESS_NUM;process_id++){
            if(kernel->running[process_id] == 0){
                // Update allocated_pages
                kernel->allocated_pages = kernel->allocated_pages + pages_demanded_func(size);
                // Malloc memory location for table
                kernel->mm[process_id].page_table = (struct PTE *)malloc(sizeof(struct PTE) * pages_demanded_func(size));
                // Update size
                kernel->mm[process_id].size = size;

                for(int index=0;index<pages_demanded_func(size);index++){
                    kernel->mm[process_id].page_table[index].present = 0;
                    kernel->mm[process_id].page_table[index].PFN = -1;
                }
                kernel->running[process_id] = 1;
                return process_id;
            }
        }
    }
}



####### read/write 差唔多, 做左write先, read 係調返轉
####### 下面係錯錯地, 改緊


int vm_write(struct Kernel * kernel, int pid, char * addr, int size, char * buf){
    // Fill your codes below.
    int existPages;

    for(int i=0;i<KERNEL_SPACE_SIZE;i++){
        if(kernel->mm[pid].page_table[i/PAGE_SIZE].present == 0){
            existPages = i;
            break;
        }
    }

    for(int i=(int)addr;i<(int)addr+size;i++){
        if(kernel->occupied_pages[existPages] == 0){
            if(kernel->mm[pid].page_table[i/PAGE_SIZE].present == 0){
                kernel->mm[pid].page_table[i/PAGE_SIZE].present = 1;
                kernel->mm[pid].page_table[i/PAGE_SIZE].present == 0;
                kernel->occupied_pages[existPages] = 1;
                existPages++;
            }
        }
        for(int j=0;j<size;j++){
            buf[j] = kernel->space[kernel->mm[pid].page_table[i/PAGE_SIZE].PFN + j%PAGE_SIZE] ;
        }
    }

    return 0;
}