#define phys_to_virt(x) ((vaddr_t)((paddr_t)(x) + KBASE))
#define virt_to_phys(x) ((paddr_t)((vaddr_t)(x) - KBASE))

/** TTBR1_EL1 0-1G* KERNEL_VADDR: L0 pte index: 510; L1 pte index: 0; L2 pte index: 0.*/
kva = KERNEL_VADDR;
boot_ttbr1_l0[GET_L0_INDEX(kva)] = ((u64) boot_ttbr1_l1)| IS_TABLE | IS_VALID;
boot_ttbr1_l1[GET_L1_INDEX(kva)] = ((u64) boot_ttbr1_l2)| IS_TABLE | IS_VALID;start_entry_idx = GET_L2_INDEX(kva);
/* Note: assert(start_entry_idx == 0) */
end_entry_idx = start_entry_idx + PHYSMEM_BOOT_END / SIZE_2M;
/* Note: assert(end_entry_idx < PTP_ENTIRES) */

/** Map each 2M page* Usuable memory: PHYSMEM_START ~ PERIPHERAL_BASE*/
for (idx = start_entry_idx; idx < end_entry_idx; ++idx) {boot_ttbr1_l2[idx] = (PHYSMEM_START + idx * SIZE_2M)| UXN  /* Unprivileged execute never */| ACCESSED  /* Set access flag */| INNER_SHARABLE   /* Sharebility */| NORMAL_MEMORY    /* Normal memory */| IS_VALID;
}

/* Peripheral memory: PERIPHERAL_BASE ~ PHYSMEM_END */
start_entry_idx = start_entry_idx + PERIPHERAL_BASE / SIZE_2M;
end_entry_idx = PHYSMEM_END / SIZE_2M;/* Map each 2M page */
for (idx = start_entry_idx; idx < end_entry_idx; ++idx) {boot_ttbr1_l2[idx] = (PHYSMEM_START + idx * SIZE_2M)| UXN  /* Unprivileged execute never */| ACCESSED  /* Set access flag */| DEVICE_MEMORY    /* Device memory */| IS_VALID;
}

/** Local peripherals, e.g., ARM timer, IRQs, and mailboxes** 0x4000_0000 .. 0xFFFF_FFFF* 1G is enough. Map 1G page here.*/
kva = KERNEL_VADDR + PHYSMEM_END;
boot_ttbr1_l1[GET_L1_INDEX(kva)] = PHYSMEM_END | UXN   /* Unprivileged execute never */| ACCESSED      /* Set access flag */| DEVICE_MEMORY    /* Device memory */| IS_VALID;

free_mem_start = phys_to_virt(ROUND_UP((vaddr_t) (&img_end), PAGE_SIZE));

static struct page *get_buddy_chunk(struct phys_mem_pool *pool,struct page *chunk)
{u64 chunk_addr;u64 buddy_chunk_addr;int order;/* Get the address of the chunk. */chunk_addr = (u64) page_to_virt(pool, chunk);order = chunk->order;/** Calculate the address of the buddy chunk according to the address* relationship between buddies.*/
#define BUDDY_PAGE_SIZE_ORDER (12)buddy_chunk_addr = chunk_addr ^(1UL << (order + BUDDY_PAGE_SIZE_ORDER));/* Check whether the buddy_chunk_addr belongs to pool. */if ((buddy_chunk_addr < pool->pool_start_addr) ||(buddy_chunk_addr >= (pool->pool_start_addr +pool->pool_mem_size))) {return NULL;}return virt_to_page(pool, (void *)buddy_chunk_addr);
}

/* `struct page` is the metadata of one physical 4k page. */
struct page {/* Free list */struct list_head node;/* Whether the correspond physical page is free now. */int allocated;/* The order of the memory chunck that this page belongs to. */int order;/* Used for ChCore slab allocator. */void *slab;
};

struct page *virt_to_page(struct phys_mem_pool *pool, void *addr)
{struct page *page;page = pool->page_metadata +(((u64) addr - pool->pool_start_addr) / BUDDY_PAGE_SIZE);return page;
}

void buddy_free_pages(struct phys_mem_pool *pool, struct page *page)
static struct page *merge_page(struct phys_mem_pool *pool, struct page *page)
struct page *buddy_get_pages(struct phys_mem_pool *pool, u64 order)
static struct page *split_page(struct phys_mem_pool *pool, u64 order, struct page *page)

/** split_page: split the memory block into two smaller sub-block, whose order* is half of the origin page.* pool @ physical memory structure reserved in the kernel* order @ order for origin page block* page @ splitted page* * Hints: don't forget to substract the free page number for the corresponding free_list.* you can invoke split_page recursively until the given page can not be splitted into two* smaller sub-pages.*/
static struct page *split_page(struct phys_mem_pool *pool, u64 order,struct page *page)
{// <lab2>if(order == page->order)return page;/* delete the page need to be split */list_del(&page->node);pool->free_lists[page->order].nr_free--;struct page *head = page;int half_order = head->order-1;/* spilt the page into two equal parts *//* first part, modify the order */for(int i = 0; i < (1 << half_order); i++){head->order = half_order;head++;}list_add(&page->node, &pool->free_lists[page->order].free_list);pool->free_lists[page->order].nr_free++;/* second part */head->order = half_order;list_add(&head->node, &pool->free_lists[head->order].free_list);pool->free_lists[head->order].nr_free++;/* modify the order */for(int i = 0; i < (1 << half_order); i++){head->order = half_order;head++;}/* continue to split the first part */return split_page(pool, order, page);// </lab2>
}/** buddy_get_pages: get free page from buddy system.* pool @ physical memory structure reserved in the kernel* order @ get the (1<<order) continous pages from the buddy system* * Hints: Find the corresonding free_list which can allocate 1<<order* continuous pages and don't forget to split the list node after allocation   */
struct page *buddy_get_pages(struct phys_mem_pool *pool, u64 order)
{// <lab2>/* find the first index of free_lists whose size larger than the (1 << order) */int list_index = order;while(list_index < BUDDY_MAX_ORDER && pool->free_lists[list_index].nr_free == 0){list_index++;}/* not found */if(list_index == BUDDY_MAX_ORDER)return NULL;/* get the page based on the list node */struct page *page = list_entry(pool->free_lists[list_index].free_list.next, struct page, node);/* split the page to best fit the size */page = split_page(pool, order, page);/* delete from the list and modify the nr_free field */list_del(&page->node);pool->free_lists[page->order].nr_free--;/* modify the allocated flag */struct page *head = page;for(int i = 0; i < (1 << page->order); i++){head->allocated = 1;head++;}return page;// </lab2>
}/** merge_page: merge the given page with the buddy page* pool @ physical memory structure reserved in the kernel* page @ merged page (attempted)* * Hints: you can invoke the merge_page recursively until* there is not corresponding buddy page. get_buddy_chunk* is helpful in this function.*/
static struct page *merge_page(struct phys_mem_pool *pool, struct page *page)
{// <lab2>struct page *buddy_chunk = get_buddy_chunk(pool, page);/* no need to merge */if(buddy_chunk == NULL || buddy_chunk->allocated==1 || page->order == BUDDY_MAX_ORDER-1|| buddy_chunk->order != page->order){return page;}/* merge *//* delete the buddy chunk from its free list */list_del(&buddy_chunk->node);pool->free_lists[buddy_chunk->order].nr_free--;/* delete the page chunk from its free list */list_del(&page->node);pool->free_lists[page->order].nr_free--;/* choose lower address to continue merge */if(buddy_chunk < page){buddy_chunk->order++;list_add(&buddy_chunk->node, &pool->free_lists[buddy_chunk->order].free_list);pool->free_lists[buddy_chunk->order].nr_free++;return merge_page(pool, buddy_chunk);} else {page->order++;list_add(&page->node, &pool->free_lists[page->order].free_list);pool->free_lists[page->order].nr_free++;return merge_page(pool, page);}// </lab2>
}/** buddy_free_pages: give back the pages to buddy system* pool @ physical memory structure reserved in the kernel* page @ free page structure* * Hints: you can invoke merge_page.*/
void buddy_free_pages(struct phys_mem_pool *pool, struct page *page)
{// <lab2>/* set the allocated flag */struct page *head = page;for(int i = 0; i < (1 << page->order); i++){head->allocated = 0;head++;}/* add to the free list */list_add(&page->node, &pool->free_lists[page->order].free_list);pool->free_lists[page->order].nr_free++;/* merge with other free blocks */head = merge_page(pool, page);/* modify the order field at one time, notice merge_page returned head pags's order is always correct */int order = head->order;for(int i = 0; i < (1 << order); i++){head->order = order;head++;}return;// </lab2>
}