/*
* Hints:
* - Build kernel page directory and page tables
* - Call Enable_Paging() with the kernel page directory
* - Install an interrupt handler for interrupt 14,
* page fault
* - Do not map a page at address 0; this will help trap
* null pointer references
*/
void Switch_To_Address_Space(struct User_Context *userContext)
{
/*
* - If you are still using an LDT to define your user code and data
* segments, switch to the process's LDT
* -
*/// TODO("Switch_To_Address_Space() using paging");
if (userContext == 0)
{
Print("the userContext is NULL!/n");
return;
}
Load_LDTR(userContext->ldtSelector);
Set_PDBR(userContext->pageDir);
}
structPage {unsigned flags; /* Flags indicating state of page */
DEFINE_LINK(Page_List, Page); /* Link fields for Page_List */
**int clock;**
ulong_t vaddr; /* User virtual address where page is mapped */pte_t *entry; /* Page table entry referring to the page */
};
/*
* Initialize virtual memory by building page tables
* for the kernel and physical memory.
* 树立页目录及页表，装置中止操控
*/voidInit_VM(struct Boot_Info *bootInfo)
void Init_Paging(void)
/**
* Initialize paging file data structures.
* All filesystems should be mounted before this function
* is called, to ensure that the paging file is available.
* 经过Get_Paging_Device()获取页文件所在的设备(paingDevice)、占用磁盘块的范围（扇区数，numSectors)
*/voidInit_Paging(void)
Find_Space_On_Paging_File()
/**
* Find a free bit of disk on the paging file for this page.
* Interrupts must be disabled.
* 在分页文件中找到一个可用的页面大小的磁盘空间块(调用Find_First_Free_Bit)
* @return index of free page sized chunk of disk space in
* the paging file, or -1 if the paging file is full
*/intFind_Space_On_Paging_File(void)
Free_Space_On_Paging_File()
/**
* Free a page-sized chunk of disk space in the paging file.
* Interrupts must be disabled.
* 开释空间，调用Clear_bit
* @param pagefileIndex index of the chunk of disk space
*/voidFree_Space_On_Paging_File(int pagefileIndex)
Write_To_Paging_File()
/**
* Write the contents of given page to the indicated block
* of space in the paging file.
* 如果能写入，调用Block_Write()，并将相应方位1，留意过程中上锁
* @param paddr a pointer to the physical memory of the page
* @param vaddr virtual address where page is mapped in user memory
* @param pagefileIndex the index of the page sized chunk of space
* in the paging file
*/voidWrite_To_Paging_File(void *paddr, ulong_t vaddr, int pagefileIndex)
Read_From_Paging_File()
/**
* Read the contents of the indicated block
* of space in the paging file into the given page.
* 置页的状况
* @param paddr a pointer to the physical memory of the page
* @param vaddr virtual address where page will be re-mapped in
* user memory
* @param pagefileIndex the index of the page sized chunk of space
* in the paging file
*/voidRead_From_Paging_File(void *paddr, ulong_t vaddr, int pagefileIndex)
uservm.c
Destroy_User_Context()
/*
* Destroy a User_Context object, including all memory
* and other resources allocated within it.
*/voidDestroy_User_Context(struct User_Context *context)
{
/*
* Hints:
* - Free all pages, page tables, and page directory for
* the process (interrupts must be disabled while you do this,
* otherwise those pages could be stolen by other processes)
* - Free semaphores, files, and other resources used
* by the process
*/// TODO("Destroy User_Context data structure after process exits");if (context == NULL)
{
return;
}
Free_Segment_Descriptor(context->ldtDescriptor);
Set_PDBR(g_kernel_pde);
if (context->pageDir != NULL)
{
pde_t *page_dir = context->pageDir;
//KASSERT(!Interrupts_Enabled());//Enable_Interrupts();bool flag;
flag = Begin_Int_Atomic();
pde_t *pdir;
if (page_dir == NULL)
{
returntrue;
}
for (pdir = page_dir + NUM_PAGE_DIR_ENTRIES / 2; pdir < page_dir + NUM_PAGE_DIR_ENTRIES; pdir++)
{
pte_t *ptable;
pte_t *ptable_first;
if (!pdir->present)
{
continue;
}
ptable_first = (pte_t *)(pdir->pageTableBaseAddr << 12);
for (ptable = ptable_first; ptable < ptable_first + NUM_PAGE_TABLE_ENTRIES; ptable++)
{
if (ptable->present)
{
Free_Page((void *)(ptable->pageBaseAddr << 12));
}
elseif (ptable->kernelInfo == KINFO_PAGE_ON_DISK)
{
//当页在pagefile上时，pte_t结构中的pageBaseAddr指示了页在pagefile中的方位
Free_Space_On_Paging_File(ptable->pageBaseAddr);
}
}
Free_Page(ptable_first);
}
//Disable_Interrupts();
Free_Page(page_dir);
End_Int_Atomic(flag);
}
context->pageDir = 0;
Free(context);
}
Load_User_Program()loads an executable file into memory, creating a complete, ready-to-execute user address space.
/*
* Load a user executable into memory by creating a User_Context
* data structure.
* Params:
* exeFileData - a buffer containing the executable to load
* exeFileLength - number of bytes in exeFileData
* exeFormat - parsed ELF segment information describing how to
* load the executable's text and data segments, and the
* code entry point address
* command - string containing the complete command to be executed:
* this should be used to create the argument block for the
* process
* pUserContext - reference to the pointer where the User_Context
* should be stored
*
* Returns:
* 0 if successful, or an error code (< 0) if unsuccessful
*/intLoad_User_Program(char *exeFileData, ulong_t exeFileLength,
struct Exe_Format *exeFormat, constchar *command,
struct User_Context **pUserContext)
{
/*
* Hints:
* - This will be similar to the same function in userseg.c
* - Determine space requirements for code, data, argument block,
* and stack
* - Allocate pages for above, map them into user address
* space (allocating page directory and page tables as needed)
* - Fill in initial stack pointer, argument block address,
* and code entry point fields in User_Context
*/// TODO("Load user program into address space");structUser_Context *uContext;
uContext = Create_User_Context(); //创建一个UserContext//处理分页触及的数据pde_t *pageDirectory;
pageDirectory = (pde_t *)Alloc_Page();
if (pageDirectory == NULL)
{
Print("no more page!\n");
return-1;
}
memset(pageDirectory, 0, PAGE_SIZE);
//将内核页目录复制到用户态进程的页目录中memcpy(pageDirectory, g_kernel_pde, PAGE_SIZE);
//将用户态进程对应高2G线性地址的页目录表项置为0，用户态进程中高2G的线性地址在GeekOS中为用户空间memset(pageDirectory + 512, 0, PAGE_SIZE / 2);
uContext->pageDir = pageDirectory;
int i;
int res;
uint_t startAddress = 0;
uint_t sizeInMemory = 0;
uint_t offsetInFile = 0;
uint_t lengthInFile = 0;
for (i = 0; i < exeFormat->numSegments - 1; i++)
{
startAddress = exeFormat->segmentList[i].startAddress;
sizeInMemory = exeFormat->segmentList[i].sizeInMemory;
offsetInFile = exeFormat->segmentList[i].offsetInFile;
lengthInFile = exeFormat->segmentList[i].lengthInFile;
if (!sizeInMemory && !lengthInFile)
{
sizeInMemory = DEFAULT_STACK_SIZE;
lengthInFile = DEFAULT_STACK_SIZE;
}
if (startAddress + sizeInMemory < USER_VM_LEN)
{
//给数据段和代码段分配空间//在GeekOS的分页机制下，用户地址空间默认从线性地址2G开始if (!Alloc_User_Page(pageDirectory, startAddress + USER_VM_START, sizeInMemory) ||
!Copy_User_Page(pageDirectory, startAddress + USER_VM_START, exeFileData + offsetInFile, lengthInFile))
{
return-1;
}
}
else
{
Print("startAddress+sizeInMemory > 2GB in Load_User_Program\n");
return-1;
}
}
//处理参数块uint_t args_num;
uint_t stack_addr;
uint_t arg_addr;
ulong_t arg_size;
Get_Argument_Block_Size(command, &args_num, &arg_size);
if (arg_size > PAGE_SIZE)
{
Print("Argument Block too big for one PAGE_SIZE\n");
return-1;
}
//给参数块在地址空间的尾部分配一页
arg_addr = Round_Down_To_Page(USER_VM_LEN - arg_size);
char *block_buffer = Malloc(arg_size);
KASSERT(block_buffer != NULL);
Format_Argument_Block(block_buffer, args_num, arg_addr, command);
if (!Alloc_User_Page(pageDirectory, arg_addr + USER_VM_START, arg_size) ||
!Copy_User_Page(pageDirectory, arg_addr + USER_VM_START, block_buffer, arg_size))
{
return-1;
}
Free(block_buffer);
//给堆栈在地址空间的尾部分配一页
stack_addr = USER_VM_LEN - Round_Up_To_Page(arg_size) - DEFAULT_STACK_SIZE;
if (!Alloc_User_Page(pageDirectory, stack_addr + USER_VM_START, DEFAULT_STACK_SIZE))
{
return-1;
}
//UserContext中触及分段机制的挑选子,描述符
uContext->ldtDescriptor = Allocate_Segment_Descriptor();
if (uContext->ldtDescriptor == NULL)
{
Print("allocate segment descriptor fail\n");
return-1;
}
Init_LDT_Descriptor(uContext->ldtDescriptor, uContext->ldt, NUM_USER_LDT_ENTRIES);
uContext->ldtSelector = Selector(USER_PRIVILEGE, true, Get_Descriptor_Index(uContext->ldtDescriptor));
//留意，在GeekOS的分页机制下，用户地址空间默认从线性地址2G开始
Init_Code_Segment_Descriptor(&uContext->ldt[0], USER_VM_START, USER_VM_LEN / PAGE_SIZE, USER_PRIVILEGE);
Init_Data_Segment_Descriptor(&uContext->ldt[1], USER_VM_START, USER_VM_LEN / PAGE_SIZE, USER_PRIVILEGE);
uContext->csSelector = Selector(USER_PRIVILEGE, false, 0);
uContext->dsSelector = Selector(USER_PRIVILEGE, false, 1);
//填充UserContext
uContext->entryAddr = exeFormat->entryAddr;
uContext->argBlockAddr = arg_addr;
uContext->size = USER_VM_LEN;
uContext->stackPointerAddr = stack_addr;
*pUserContext = uContext;
DisplayMemory(pageDirectory);
return0;
}
Copy_From_User()copies data from a user buffer into a kernel buffer.
boolCopy_From_User(void *destInKernel, ulong_t srcInUser, ulong_t numBytes)
{
/*
* Hints:
* - Make sure that user page is part of a valid region
* of memory
* - Remember that you need to add 0x80000000 to user addresses
* to convert them to kernel addresses, because of how the
* user code and data segments are defined
* - User pages may need to be paged in from disk before being accessed.
* - Before you touch (read or write) any data in a user
* page, **disable the PAGE_PAGEABLE bit**.
*
* Be very careful with race conditions in reading a page from disk.
* Kernel code must always assume that if the struct Page for
* a page of memory has the PAGE_PAGEABLE bit set,
* IT CAN BE STOLEN AT ANY TIME. The only exception is if
* interrupts are disabled; because no other process can run,
* the page is guaranteed not to be stolen.
*/// TODO("Copy user data to kernel buffer");structUser_Context *userContext = g_currentThread->userContext;
void *user_lin_addr = (void *)(USER_VM_START) + srcInUser;
if ((srcInUser + numBytes) < userContext->size)
{
memcpy(destInKernel, user_lin_addr, numBytes);
returntrue;
}
returnfalse;
}
Copy_To_User()
/*
* Copy data from kernel buffer into user buffer.
* Returns true if successful, false otherwise.
*/boolCopy_To_User(ulong_t destInUser, void *srcInKernel, ulong_t numBytes){
/*
* Hints:
* - Same as for Copy_From_User()
* - Also, make sure the memory is mapped into the user
* address space with write permission enabled
*/// TODO("Copy kernel data to user buffer");structUser_Context *userContext = g_currentThread->userContext;
void *user_lin_addr = (void *)(USER_VM_START) + destInUser;
if ((destInUser + numBytes) < userContext->size)
{
memcpy(user_lin_addr, srcInKernel, numBytes);
returntrue;
}
returnfalse;
}
Switch_To_Address_Space()
void Switch_To_Address_Space(struct User_Context *userContext)
{
/*
* - If you are still using an LDT to define your user code and data
* segments, switch to the process's LDT
* -
*/// TODO("Switch_To_Address_Space() using paging");
if (userContext == 0)
{
Print("the userContext is NULL!/n");
return;
}
Load_LDTR(userContext->ldtSelector);
Set_PDBR(userContext->pageDir);
}
