454 lines
14 KiB
C
454 lines
14 KiB
C
#include "page.h"
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "filesys/file.h"
|
|
#include "threads/pte.h"
|
|
#include "threads/malloc.h"
|
|
#include "threads/palloc.h"
|
|
#include "threads/synch.h"
|
|
#include "devices/swap.h"
|
|
#include "userprog/process.h"
|
|
#include "userprog/pagedir.h"
|
|
#include "vm/frame.h"
|
|
|
|
#define SWAP_FLAG_BIT 9
|
|
#define SHARED_FLAG_BIT 10
|
|
#define ADDR_START_BIT 12
|
|
|
|
struct hash shared_file_pages;
|
|
struct lock shared_file_pages_lock;
|
|
|
|
static unsigned page_hash (const struct hash_elem *e, void *aux UNUSED);
|
|
static bool page_less (const struct hash_elem *a_, const struct hash_elem *b_,
|
|
void *aux UNUSED);
|
|
|
|
static void page_flag_shared (struct thread *owner, void *upage, bool shared);
|
|
static unsigned shared_file_page_hash (const struct hash_elem *e,
|
|
void *aux UNUSED);
|
|
static bool shared_file_page_less (const struct hash_elem *a_,
|
|
const struct hash_elem *b_,
|
|
void *aux UNUSED);
|
|
static struct shared_file_page *shared_file_page_get (struct file *file,
|
|
void *upage);
|
|
|
|
/* Initialise a supplementary page table. */
|
|
bool
|
|
init_pages (struct hash *pages)
|
|
{
|
|
ASSERT (pages != NULL);
|
|
return hash_init (pages, page_hash, page_less, NULL);
|
|
}
|
|
|
|
/* Hashing function needed for the SPT table. Returns a hash for an entry,
|
|
based on its upage. */
|
|
static unsigned
|
|
page_hash (const struct hash_elem *e, void *aux UNUSED)
|
|
{
|
|
struct page_entry *page = hash_entry (e, struct page_entry, elem);
|
|
return hash_ptr (page->upage);
|
|
}
|
|
|
|
/* Comparator function for the SPT table. Compares two entries based on their
|
|
upages. */
|
|
static bool
|
|
page_less (const struct hash_elem *a_, const struct hash_elem *b_,
|
|
void *aux UNUSED)
|
|
{
|
|
const struct page_entry *a = hash_entry (a_, struct page_entry, elem);
|
|
const struct page_entry *b = hash_entry (b_, struct page_entry, elem);
|
|
|
|
return a->upage < b->upage;
|
|
}
|
|
|
|
static void page_flag_swap (uint32_t *pte, bool set);
|
|
static void page_set_swap (struct thread *owner, uint32_t *pte,
|
|
size_t swap_slot);
|
|
|
|
// TODO: Deal with NULL malloc returns
|
|
/* Swap out 'owner' process's 'upage' stored at 'kpage'. Then, allocate and
|
|
insert a new page entry into the user process thread's SPT representing
|
|
this swapped out page. */
|
|
bool
|
|
page_insert_swapped (void *upage, void *kpage, struct list *owners)
|
|
{
|
|
struct file *exec_file = NULL;
|
|
struct list_elem *e;
|
|
for (e = list_begin (owners); e != list_end (owners); e = list_next (e))
|
|
{
|
|
struct thread *owner = list_entry (e, struct frame_owner, elem)->owner;
|
|
uint32_t *pte = lookup_page (owner->pagedir, upage, false);
|
|
if (exec_file != NULL || page_is_shared_pte (pte))
|
|
{
|
|
ASSERT (page_is_shared_pte (pte));
|
|
pagedir_clear_page (owner->pagedir, upage);
|
|
exec_file = owner->exec_file;
|
|
ASSERT (exec_file != NULL);
|
|
continue;
|
|
}
|
|
ASSERT (list_size (owners) == 1);
|
|
|
|
/* 1. Initialize swapped page entry. */
|
|
struct page_entry *page = page_get (owner, upage);
|
|
lock_acquire (&owner->pages_lock);
|
|
if (page == NULL)
|
|
{
|
|
page = malloc (sizeof (struct page_entry));
|
|
if (page == NULL)
|
|
return NULL;
|
|
page->upage = upage;
|
|
lock_init (&page->lock);
|
|
hash_insert (&owner->pages, &page->elem);
|
|
}
|
|
|
|
/* Mark page as 'swapped' and flag the page directory as having
|
|
been modified *before* eviction begins to prevent the owner of the
|
|
victim page from accessing/modifying it mid-eviction. */
|
|
/* TODO: We need to stop the process from destroying pagedir mid-eviction,
|
|
as this could render the page table entry invalid. */
|
|
page_flag_swap (pte, true);
|
|
lock_acquire (&page->lock);
|
|
pagedir_clear_page (owner->pagedir, upage);
|
|
|
|
size_t swap_slot = swap_out (kpage);
|
|
page_set_swap (owner, pte, swap_slot);
|
|
|
|
lock_release (&page->lock);
|
|
lock_release (&owner->pages_lock);
|
|
}
|
|
if (exec_file != NULL)
|
|
{
|
|
lock_acquire (&shared_file_pages_lock);
|
|
struct shared_file_page *sfp = shared_file_page_get (exec_file, upage);
|
|
sfp->frame = NULL;
|
|
sfp->swap_slot = swap_out (kpage);
|
|
lock_release (&shared_file_pages_lock);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Allocate and insert a new page entry into the user process thread's
|
|
SPT representing a file page. */
|
|
struct page_entry *
|
|
page_insert_file (struct file *file, off_t ofs, void *upage,
|
|
uint32_t read_bytes, uint32_t zero_bytes, bool writable,
|
|
enum page_type type)
|
|
{
|
|
/* If page exists, just update it. */
|
|
struct page_entry *existing = page_get (thread_current (), upage);
|
|
if (existing != NULL)
|
|
{
|
|
ASSERT (existing->read_bytes == read_bytes);
|
|
ASSERT (existing->zero_bytes == zero_bytes);
|
|
existing->writable = existing->writable || writable;
|
|
return existing;
|
|
}
|
|
|
|
struct page_entry *page = malloc(sizeof (struct page_entry));
|
|
if (page == NULL)
|
|
return NULL;
|
|
|
|
page->type = type;
|
|
page->file = file;
|
|
page->offset = ofs;
|
|
page->upage = upage;
|
|
page->read_bytes = read_bytes;
|
|
page->zero_bytes = zero_bytes;
|
|
page->writable = writable;
|
|
lock_init (&page->lock);
|
|
|
|
struct thread *t = thread_current ();
|
|
lock_acquire (&t->pages_lock);
|
|
hash_insert (&t->pages, &page->elem);
|
|
lock_release (&t->pages_lock);
|
|
return page;
|
|
}
|
|
|
|
/* Gets a page_entry from the starting address of the page. Returns NULL if no
|
|
such page_entry exists in the hash map.*/
|
|
struct page_entry *
|
|
page_get (struct thread *thread, void *upage)
|
|
{
|
|
struct page_entry fake_page_entry;
|
|
fake_page_entry.upage = upage;
|
|
|
|
lock_acquire (&thread->pages_lock);
|
|
struct hash_elem *e
|
|
= hash_find (&thread->pages, &fake_page_entry.elem);
|
|
lock_release (&thread->pages_lock);
|
|
if (e == NULL)
|
|
return NULL;
|
|
|
|
return hash_entry (e, struct page_entry, elem);
|
|
}
|
|
|
|
bool
|
|
page_load_file (struct page_entry *page)
|
|
{
|
|
/* Allocate a frame for the page. If a frame allocation fails, then
|
|
frame_alloc should try to evict a page. If it is still NULL, the OS
|
|
panics as this should not happen if eviction is working correctly. */
|
|
struct thread *t = thread_current ();
|
|
bool shareable = !page->writable && file_compare (page->file, t->exec_file);
|
|
if (shareable)
|
|
{
|
|
lock_acquire (&shared_file_pages_lock);
|
|
struct shared_file_page *sfp
|
|
= shared_file_page_get (page->file, page->upage);
|
|
if (sfp != NULL)
|
|
{
|
|
/* Frame exists, just install it. */
|
|
if (sfp->frame != NULL)
|
|
{
|
|
if (!install_page (page->upage, sfp->frame, page->writable))
|
|
{
|
|
lock_release (&shared_file_pages_lock);
|
|
return false;
|
|
}
|
|
frame_owner_insert (sfp->frame, t);
|
|
}
|
|
/* Shared page is in swap. Load it. */
|
|
else
|
|
{
|
|
void *frame = frame_alloc (PAL_USER, page->upage, t);
|
|
if (frame == NULL)
|
|
PANIC (
|
|
"Could not allocate a frame to load page into memory.");
|
|
swap_in (frame, sfp->swap_slot);
|
|
|
|
if (!install_page (page->upage, frame, false))
|
|
{
|
|
frame_free (frame);
|
|
lock_release (&shared_file_pages_lock);
|
|
return false;
|
|
}
|
|
}
|
|
page_flag_shared (t, page->upage, true);
|
|
if (page->type != PAGE_SHARED)
|
|
{
|
|
sfp->ref_count++;
|
|
page->type = PAGE_SHARED;
|
|
}
|
|
lock_release (&shared_file_pages_lock);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void *frame = frame_alloc (PAL_USER, page->upage, t);
|
|
pagedir_set_accessed (t->pagedir, page->upage, true);
|
|
if (frame == NULL)
|
|
PANIC ("Could not allocate a frame to load page into memory.");
|
|
|
|
/* Map the page to the frame. */
|
|
if (!install_page (page->upage, frame, page->writable))
|
|
{
|
|
if (shareable)
|
|
lock_release (&shared_file_pages_lock);
|
|
frame_free (frame);
|
|
return false;
|
|
}
|
|
|
|
/* Move the file pointer to the correct location in the file. Then, read the
|
|
data from the file into the frame. Checks that we were able to read the
|
|
expected number of bytes. */
|
|
file_seek (page->file, page->offset);
|
|
if (file_read (page->file, frame, page->read_bytes) != (int) page->read_bytes)
|
|
{
|
|
if (shareable)
|
|
lock_release (&shared_file_pages_lock);
|
|
frame_free (frame);
|
|
return false;
|
|
}
|
|
|
|
/* Zero out the remaining bytes in the frame. */
|
|
memset (frame + page->read_bytes, 0, page->zero_bytes);
|
|
|
|
/* If file page is read-only, make it shared. */
|
|
if (shareable)
|
|
{
|
|
struct shared_file_page *sfp = malloc (sizeof (struct shared_file_page));
|
|
if (sfp == NULL)
|
|
{
|
|
lock_release (&shared_file_pages_lock);
|
|
frame_free (frame);
|
|
return false;
|
|
}
|
|
sfp->file = page->file;
|
|
sfp->upage = page->upage;
|
|
sfp->frame = frame;
|
|
sfp->swap_slot = 0;
|
|
sfp->ref_count = 1;
|
|
hash_insert (&shared_file_pages, &sfp->elem);
|
|
page_flag_shared (t, page->upage, true);
|
|
page->type = PAGE_SHARED;
|
|
lock_release (&shared_file_pages_lock);
|
|
}
|
|
|
|
/* Mark the page as loaded successfully. */
|
|
return true;
|
|
}
|
|
|
|
/* Function to clean up a page_entry. Given the elem of that page_entry, frees
|
|
the page_entry itself. */
|
|
void
|
|
page_cleanup (struct hash_elem *e, void *aux UNUSED)
|
|
{
|
|
struct page_entry *page = hash_entry (e, struct page_entry, elem);
|
|
if (page->type == PAGE_SHARED)
|
|
{
|
|
lock_acquire (&shared_file_pages_lock);
|
|
struct shared_file_page *sfp
|
|
= shared_file_page_get (page->file, page->upage);
|
|
ASSERT (sfp != NULL);
|
|
if (sfp->frame != NULL)
|
|
frame_owner_remove (sfp->frame, thread_current ());
|
|
sfp->ref_count--;
|
|
if (sfp->ref_count == 0)
|
|
{
|
|
hash_delete (&shared_file_pages, &sfp->elem);
|
|
if (sfp->frame != NULL)
|
|
frame_free (sfp->frame);
|
|
else
|
|
swap_drop (sfp->swap_slot);
|
|
free (sfp);
|
|
}
|
|
lock_release (&shared_file_pages_lock);
|
|
}
|
|
free (page);
|
|
}
|
|
|
|
/* Flags the provided page table entry as representing a swapped out page. */
|
|
void
|
|
page_flag_swap (uint32_t *pte, bool set)
|
|
{
|
|
if (set)
|
|
*pte |= (1 << SWAP_FLAG_BIT);
|
|
else
|
|
*pte &= ~(1 << SWAP_FLAG_BIT);
|
|
}
|
|
|
|
/* Sets the address bits of the page table entry to the provided swap slot
|
|
value. To be used for later retrieval of the swap slot when page faulting. */
|
|
static void
|
|
page_set_swap (struct thread *owner, uint32_t *pte, size_t swap_slot)
|
|
{
|
|
/* Store the provided swap slot in the address bits of the page table
|
|
entry, truncating excess bits. */
|
|
*pte |= (1 << SWAP_FLAG_BIT);
|
|
uint32_t swap_slot_bits = (swap_slot << ADDR_START_BIT) & PTE_ADDR;
|
|
*pte = (*pte & PTE_FLAGS) | swap_slot_bits;
|
|
|
|
invalidate_pagedir (owner->pagedir);
|
|
}
|
|
|
|
/* Returns true iff the page with user address 'upage' owned by 'owner'
|
|
is flagged to be in the swap disk via the owner's page table. */
|
|
bool
|
|
page_in_swap (struct thread *owner, void *upage)
|
|
{
|
|
uint32_t *pte = lookup_page (owner->pagedir, upage, false);
|
|
return page_in_swap_pte (pte);
|
|
}
|
|
|
|
/* Returns true iff the page table entry is marked to be in the swap disk. */
|
|
bool
|
|
page_in_swap_pte (uint32_t *pte)
|
|
{
|
|
return pte != NULL && (*pte & (1 << SWAP_FLAG_BIT)) != 0;
|
|
}
|
|
|
|
/* Given that the page with user address 'upage' owned by 'owner' is flagged
|
|
to be in the swap disk via the owner's page table, returns its stored
|
|
swap slot and marks the PTE as not being in swap. */
|
|
size_t
|
|
page_get_swap (struct thread *owner, void *upage)
|
|
{
|
|
uint32_t *pte = lookup_page (owner->pagedir, upage, false);
|
|
|
|
ASSERT (pte != NULL);
|
|
ASSERT ((*pte & PTE_P) == 0);
|
|
|
|
/* Masks the address bits and returns truncated value. */
|
|
page_flag_swap (pte, false);
|
|
return ((*pte & PTE_ADDR) >> ADDR_START_BIT);
|
|
}
|
|
|
|
/* Returns the swap slot stored in a PTE. */
|
|
size_t
|
|
page_get_swap_pte (uint32_t *pte)
|
|
{
|
|
ASSERT (pte != NULL);
|
|
ASSERT ((*pte & PTE_P) == 0);
|
|
return ((*pte & PTE_ADDR) >> ADDR_START_BIT);
|
|
}
|
|
|
|
/* Flags the provided page table entry as representing a shared page. */
|
|
static void
|
|
page_flag_shared (struct thread *owner, void *upage, bool shared)
|
|
{
|
|
uint32_t *pte = lookup_page (owner->pagedir, upage, false);
|
|
ASSERT (pte != NULL);
|
|
|
|
if (shared)
|
|
*pte |= (1 << SHARED_FLAG_BIT);
|
|
else
|
|
*pte &= ~(1 << SHARED_FLAG_BIT);
|
|
}
|
|
|
|
/* Returns true iff the page table entry is marked to be shared. */
|
|
bool
|
|
page_is_shared_pte (uint32_t *pte)
|
|
{
|
|
return pte != NULL && (*pte & (1 << SHARED_FLAG_BIT)) != 0;
|
|
}
|
|
|
|
/* Initializes the shared file pages hash table. */
|
|
void
|
|
shared_file_pages_init ()
|
|
{
|
|
if (!hash_init (&shared_file_pages, shared_file_page_hash,
|
|
shared_file_page_less, NULL))
|
|
PANIC ("Failed to initialize shared file pages hash table.");
|
|
lock_init (&shared_file_pages_lock);
|
|
}
|
|
|
|
/* Hash function for shared file pages, used for storing entries in the
|
|
shared file pages table. */
|
|
static unsigned
|
|
shared_file_page_hash (const struct hash_elem *e, void *aux UNUSED)
|
|
{
|
|
struct shared_file_page *sfp = hash_entry (e, struct shared_file_page, elem);
|
|
void *inode = file_get_inode (sfp->file);
|
|
void *upage = sfp->upage;
|
|
void *bytes[2] = { inode, upage };
|
|
return hash_bytes (bytes, sizeof (bytes));
|
|
}
|
|
|
|
/* 'less_func' comparison function for shared file pages, used for comparing
|
|
the keys of the shared file pages table. */
|
|
static bool
|
|
shared_file_page_less (const struct hash_elem *a_, const struct hash_elem *b_,
|
|
void *aux UNUSED)
|
|
{
|
|
const struct shared_file_page *a
|
|
= hash_entry (a_, struct shared_file_page, elem);
|
|
const struct shared_file_page *b
|
|
= hash_entry (b_, struct shared_file_page, elem);
|
|
|
|
return !file_compare (a->file, b->file) || a->upage < b->upage;
|
|
}
|
|
|
|
static struct shared_file_page *
|
|
shared_file_page_get (struct file *file, void *upage)
|
|
{
|
|
struct shared_file_page fake_sfp;
|
|
fake_sfp.file = file;
|
|
fake_sfp.upage = upage;
|
|
|
|
struct hash_elem *e = hash_find (&shared_file_pages, &fake_sfp.elem);
|
|
if (e == NULL)
|
|
return NULL;
|
|
|
|
return hash_entry (e, struct shared_file_page, elem);
|
|
}
|