Imperial-MEng/pintos_22
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement MMU-based user memory validation

Browse Source
This commit is contained in:
EDiasAlberto
2024-11-29 23:03:31 +00:00
parent 4f84a83611 59e7a64f8e
commit 5f40d83e66
2 changed files with 89 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/userprog/exception.c
View File

@@ -146,6 +146,14 @@ page_fault (struct intr_frame *f)
write = (f->error_code & PF_W) != 0; write = (f->error_code & PF_W) != 0;
user = (f->error_code & PF_U) != 0; user = (f->error_code & PF_U) != 0;
/* Kernel page fault is further handled by the kernel itself. */
if (kernel)
{
f->eip = (void *)f->eax;
f->eax = 0xffffffff;
return;
}
if (user) if (user)
{ {
if (try_alloc_new_page (fault_addr, f->esp)) if (try_alloc_new_page (fault_addr, f->esp))

161
src/userprog/syscall.c
View File

@@ -14,6 +14,7 @@
#include "vm/stackgrowth.h" #include "vm/stackgrowth.h"
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <stdbool.h>
#include <syscall-nr.h> #include <syscall-nr.h>
#define MAX_SYSCALL_ARGS 3 #define MAX_SYSCALL_ARGS 3
@@ -49,8 +50,11 @@ static unsigned syscall_tell (int fd);
static void syscall_close (int fd); static void syscall_close (int fd);
static struct open_file *fd_get_file (int fd); static struct open_file *fd_get_file (int fd);
static void validate_user_pointer (const void *start, size_t size); static void validate_user_pointer (const void *ptr, size_t size,
static void validate_user_string (const char *str); bool check_write);
static void validate_user_string (const char *str, bool check_write);
static int get_user (const uint8_t *);
static bool put_user (uint8_t *, uint8_t);
/* A struct defining a syscall_function pointer along with its arity. */ /* A struct defining a syscall_function pointer along with its arity. */
struct syscall_arguments struct syscall_arguments
@@ -99,8 +103,8 @@ static void
syscall_handler (struct intr_frame *f) syscall_handler (struct intr_frame *f)
{ {
/* First, read the system call number from the stack. */ /* First, read the system call number from the stack. */
validate_user_pointer (f->esp, sizeof (uintptr_t)); validate_user_pointer (f->esp, sizeof (uintptr_t), false);
uintptr_t syscall_number = *(int *) f->esp; uintptr_t syscall_number = *(int *)f->esp;
thread_current ()->curr_esp = f->esp; thread_current ()->curr_esp = f->esp;
/* Ensures the number corresponds to a system call that can be handled. */ /* Ensures the number corresponds to a system call that can be handled. */
@@ -111,11 +115,10 @@ syscall_handler (struct intr_frame *f)
/* Next, read and copy the arguments from the stack pointer. */ /* Next, read and copy the arguments from the stack pointer. */
validate_user_pointer (f->esp + sizeof (uintptr_t), validate_user_pointer (f->esp + sizeof (uintptr_t),
syscall.arity * sizeof (uintptr_t)); syscall.arity * sizeof (uintptr_t), false);
uintptr_t args[MAX_SYSCALL_ARGS] = { 0 };
uintptr_t args[MAX_SYSCALL_ARGS] = {0};
for (int i = 0; i < syscall.arity && i < MAX_SYSCALL_ARGS; i++) for (int i = 0; i < syscall.arity && i < MAX_SYSCALL_ARGS; i++)
args[i] = *(uintptr_t *) (f->esp + sizeof (uintptr_t) * (i + 1)); args[i] = *(uintptr_t *)(f->esp + sizeof (uintptr_t) * (i + 1));
/* Call the function that handles this system call with the arguments. When /* Call the function that handles this system call with the arguments. When
there is a return value it is stored in f->eax. */ there is a return value it is stored in f->eax. */
@@ -144,8 +147,7 @@ syscall_exit (int status)
static pid_t static pid_t
syscall_exec (const char *cmd_line) syscall_exec (const char *cmd_line)
{ {
/* Validate the user string before executing the process. */ validate_user_string (cmd_line, false);
validate_user_string (cmd_line);
return process_execute (cmd_line); /* Returns the PID of the new process */ return process_execute (cmd_line); /* Returns the PID of the new process */
} }
@@ -164,8 +166,7 @@ syscall_wait (pid_t pid)
static bool static bool
syscall_create (const char *file, unsigned initial_size) syscall_create (const char *file, unsigned initial_size)
{ {
/* Validate the user string before creating the file. */ validate_user_string (file, false);
validate_user_string (file);
/* Acquire the file system lock to prevent race conditions. */ /* Acquire the file system lock to prevent race conditions. */
lock_acquire (&filesys_lock); lock_acquire (&filesys_lock);
@@ -182,8 +183,7 @@ syscall_create (const char *file, unsigned initial_size)
static bool static bool
syscall_remove (const char *file) syscall_remove (const char *file)
{ {
/* Validate the user string before removing the file. */ validate_user_string (file, false);
validate_user_string (file);
/* Acquire the file system lock to prevent race conditions. */ /* Acquire the file system lock to prevent race conditions. */
lock_acquire (&filesys_lock); lock_acquire (&filesys_lock);
@@ -201,8 +201,7 @@ syscall_remove (const char *file)
static int static int
syscall_open (const char *file) syscall_open (const char *file)
{ {
/* Validate the user string before opening the file. */ validate_user_string (file, false);
validate_user_string (file);
/* Acquire the file system lock to prevent race conditions. */ /* Acquire the file system lock to prevent race conditions. */
lock_acquire (&filesys_lock); lock_acquire (&filesys_lock);
@@ -268,8 +267,7 @@ syscall_read (int fd, void *buffer, unsigned size)
if (fd < STDIN_FILENO || fd == STDOUT_FILENO) if (fd < STDIN_FILENO || fd == STDOUT_FILENO)
return EXIT_FAILURE; return EXIT_FAILURE;
/* Validate the user buffer for the provided size before reading. */ validate_user_pointer (buffer, size, true);
validate_user_pointer (buffer, size);
if (fd == STDIN_FILENO) if (fd == STDIN_FILENO)
{ {
@@ -312,8 +310,7 @@ syscall_write (int fd, const void *buffer, unsigned size)
if (fd <= 0) if (fd <= 0)
return 0; return 0;
/* Validate the user buffer for the provided size before writing. */ validate_user_pointer (buffer, size, false);
validate_user_pointer (buffer, size);
if (fd == STDOUT_FILENO) if (fd == STDOUT_FILENO)
{ {
@@ -455,72 +452,76 @@ fd_get_file (int fd)
return hash_entry (e, struct open_file, elem); return hash_entry (e, struct open_file, elem);
} }
/* Validates if a block of memory starting at START and of size SIZE bytes is /* Validates if a block of memory starting at PTR and of size SIZE bytes is
fully contained within user virtual memory. Kills the thread (by exiting with fully contained within valid user virtual memory. thread_exit () if the
failure) if the memory is invalid. Otherwise, returns (nothing) normally. memory is invalid.
If the size is 0, the function does no checks and returns the given ptr. */ If the size is 0, the function does no checks and returns PTR. */
static void static void
validate_user_pointer (const void *start, size_t size) validate_user_pointer (const void *ptr, size_t size, bool check_write)
{ {
/* If the size is 0, we do not need to check anything. */
if (size == 0) if (size == 0)
return; return;
/* ptr < ptr + size - 1, so sufficient to check that (ptr + size -1) is a
struct thread *t = thread_current (); valid user virtual memory address. */
void *last = ptr + size - 1;
const void *end = start + size - 1; if (!is_user_vaddr (last))
thread_exit ();
/* Check if the start and end pointers are valid user virtual addresses. */ ptr = pg_round_down (ptr);
if (start == NULL || !is_user_vaddr (start) || !is_user_vaddr (end)) while (ptr <= last)
syscall_exit (EXIT_FAILURE); {
int result;
/* We now need to check if the entire memory block is mapped to physical /* Check read access to pointer. */
memory by the page table. */ if ((result = get_user (ptr)) == -1)
for (const void *ptr = pg_round_down (start); ptr <= end; ptr += PGSIZE) thread_exit ();
if (pagedir_get_page (t->pagedir, ptr) == NULL) /* Check write access to pointer (if required). */
{ if (check_write && !put_user (ptr, result))
if (!try_alloc_new_page (ptr, t->curr_esp)) thread_exit ();
syscall_exit (EXIT_FAILURE); ptr += PGSIZE;
} }
} }
/* Validates if a string is fully contained within user virtual memory. Kills /* Validates of a C-string starting at ptr is fully contained within valid
the thread (by exiting with failure) if the memory is invalid. Otherwise, user virtual memory. thread_exit () if the memory is invalid. */
returns (nothing) normally. */
static void static void
validate_user_string (const char *str) validate_user_string (const char *ptr, bool check_write)
{ {
/* Check if the string pointer is a valid user virtual address. */ while (true)
if (str == NULL || !is_user_vaddr (str)) {
syscall_exit (EXIT_FAILURE); if (!is_user_vaddr (ptr))
thread_exit ();
/* Calculate the offset of the string within the (first) page. */ int result;
size_t offset = (uintptr_t) str % PGSIZE; if ((result = get_user ((const uint8_t *)ptr)) == -1)
struct thread *t = thread_current (); thread_exit ();
if (check_write && !put_user ((uint8_t *)ptr, result))
/* We move page by page, checking if the page is mapped to physical memory. */ thread_exit ();
for (;;) if (*ptr == '\0')
{ return;
void *page = pg_round_down (str); ptr++;
}
/* If we reach addresses that are not mapped to physical memory before the
end of the string, the thread is terminated. */
if (!is_user_vaddr(page))
syscall_exit (EXIT_FAILURE);
if (pagedir_get_page (t->pagedir, page) == NULL)
if (!try_alloc_new_page (str, t->curr_esp))
syscall_exit (EXIT_FAILURE);
while (offset < PGSIZE)
{
if (*str == '\0')
return; /* We reached the end of the string without issues. */
str++;
offset++;
}
offset = 0; /* Next page will start at the beginning. */
}
} }
/* PROVIDED BY SPEC.
Reads a byte at user virtual address UADDR.
UADDR must be below PHYS_BASE.
Returns the byte value if successful, -1 if a segfault occurred. */
static int
get_user (const uint8_t *uaddr)
{
int result;
asm ("movl $1f, %0; movzbl %1, %0; 1:" : "=&a"(result) : "m"(*uaddr));
return result;
}
/* PROVIDED BY SPEC.
Writes BYTE to user address UDST.
UDST must be below PHYS_BASE.
Returns true if successful, false if a segfault occurred. */
static bool
put_user (uint8_t *udst, uint8_t byte)
{
int error_code;
asm ("movl $1f, %0; movb %b2, %1; 1:"
: "=&a"(error_code), "=m"(*udst)
: "q"(byte));
return error_code != -1;
}