Please add in the following four lines of code: #include  #include  // This file implements a naive 32-bits memory management unit(MMU) simulator // to do virtual memory control. // // NOTE1: The number of bits of virtual (offset) for each layer may be different // from the real Intel CPU. We are creating our own MMU. // // NOTE2: Please treat all unsigned long long as 4 bytes here because we are using // a 64-bit program to simulate a 32-bit MMU. // // APIs: // init_root(): Initialize the L0 page table (root page table). In modern // OS, a similar API is called in the early stage of the // booting process of the OS. // // page_fault_get_physical_page(address): Gets a physical memory page. // // translate(address): Translates a virtual address to the corresponding // physical address. // // // #define BITS_IN_L0 (3) #define ENTRIES_IN_L0 (1 << BITS_IN_L0) #define BITS_IN_L1 (4) #define ENTRIES_IN_L1 (1 << BITS_IN_L1) #define BITS_IN_L2 (5) #define ENTRIES_IN_L2 (1 << BITS_IN_L2) #define BITS_IN_OFFSETS (20) unsigned long long root_page_table[ENTRIES_IN_L0]; unsigned long long page_fault_count = 0; void init_root() { for (int i = 0; i < ENTRIES_IN_L0; i++) { root_page_table[i] = 0; } } // NOTE: You don't need to understand how this API generates a physical memory // page (because it's fake). But you need to understand why we need this // API. unsigned int page_fault_get_physical_page(unsigned int address) { unsigned long long addr = address; return (unsigned int)((((addr >> BITS_IN_OFFSETS) << BITS_IN_OFFSETS) + 0x20000000) % 0x100000000); } unsigned int translate(unsigned int address) { unsigned long long* l1_page_table; unsigned long long* l2_page_table; // Layer 0, root int index_in_l0 = address >> (32 - BITS_IN_L0); printf("Index in L0(root) page table : %X ", index_in_l0); if (root_page_table[index_in_l0] == 0) { // page fault printf("L0 page fault "); page_fault_count += 1; root_page_table[index_in_l0] = (unsigned long long)malloc(sizeof(unsigned long long) * ENTRIES_IN_L1); l1_page_table = (unsigned long long*)root_page_table[index_in_l0]; for (int i = 0; i < ENTRIES_IN_L1; i++) { l1_page_table[i] = 0; } } else { l1_page_table = (unsigned long long*)root_page_table[index_in_l0]; } // Layer 1 // FIXME: index_in_l1 is incorrect. int index_in_l1 = 0; printf("Index in L1 page table : %X ", index_in_l1); if (l1_page_table[index_in_l1] == 0) { // page fault page_fault_count += 1; printf("L1 page fault "); // FIXME: Constructs the missing L2 page table (yes, it's L2 not L1). } else { // FIXME: Gets the existing L2 page table (yes, it's L2 not L1). } // Layer 2 int index_in_l2 = (address << (BITS_IN_L0 + BITS_IN_L1)) >> (32 - BITS_IN_L2); printf("Index in L2 page table : %X ", index_in_l2); if (l2_page_table[index_in_l2] == 0) { printf("L2 page fault "); // page fault page_fault_count += 1; l2_page_table[index_in_l2] = page_fault_get_physical_page(address); } // FIXME: page_offset is incorrect. int page_offset = 0; printf("Page offset : %X ", page_offset); // FIXME: return value is incorrect; return 0; } unsigned long long get_page_fault_count() { return page_fault_count; }