Overview of address space handling:
-For simplicity (so that kernel code doesn't need to change) we map kernel
memory directly from logical to physical addresses.
-Threads are part of the kernel; they use the kernel's page directory and page
table.
-Use each logical address only once over all processes. That should simplify
some things.
HOWEVER:
-Screen memory will be mapped into each process's address space at the same
address for each process.
-Kernel memory will be mapped from logical to physical without translation
everywhere. While a process rarely needs direct access to kernel memory,
this will probably simplify some things like system calls.
-As the stack is pinned we don't need to handle it in paging code. For
simplicity we can have the stack at the same logical address in each process.
If there are problems with that we give it a logical address resulting from
adding a fixed offset to the stack's *physical* address.
-I'm not sure yet how to handle concurrency. We need one spinlock for each
group of data structures that needs internal consistency.
-I have not said anything about privilege bits. The kernel would still work if
every process was allowed access to every memory location. Protection would be
a "nice to have". In a real OS it is vital, of course.
init_memory():
-Set up the page directory and page table for kernel space. We will only need
one page table as it can cover 4 MB which is enough.
-Set the paging flag in CR0 to enable paging
-Set up a data structure to keep track of free pages. As we only have 29 pages
to take care of, a simple bitmap in a (32 bit) integer might suffice.
setup_page_table():
-Set up the page directory, page table, and pages for code and data.
-Mark the code and data pages as not present.
-page_alloc(TRUE) a physical page for the stack and set up a page for the
stack.
-Mark the stack page as present.
page_fault_handler():
-ASSERT() that the fault address actually belongs to the process using the
pcb's swap_size entry. In a real OS we'd terminate the process if that
happened (SIGSEGV on Linux).
-Call page_swap_in()
page_alloc():
-page_swap_out() a random page to floppy if no physical page is available.
To do this we might need to search through all pcbs if we don't keep track
of allocations in some other way. See description of init_memory().
-It is simpler to first choose a random process and then a random page in that
process than to choose a truly random page. The simpler method has the
disadvantage that not every page will have the same chance of getting swapped
out.
page_swap_in():
-We can assume that the page belongs to the current_running process.
-Call page_alloc() to allocate physical page.
-Find the sectors we need to swap in using the pcb's fault_addr and swap_loc
entries.
-Read the sectors from floppy
-Mark the page as present.
page_swap_out():
-Find the process to which the page belongs. This is simplified by the fact
that every logical address in the address range of processes is only mapped
in one process.
Still, we usually need to search through some pcbs until we find the right
one. This can be improved by some special data structure in the kernel...
-Write the page to diskette
-In the data structure keeping track of free pages, mark the physical page as
free. (In practice we can leave it marked as busy because it will be reused
right away.)
-In the page table of the process whose page we swapped out, mark the page as
not present.