#include

#include

#include

#include

#include

#include "student$\_$code.h$"$

bool is$\_$entry$\_$valid$($PageTableEntry pte$)\{$

return $($pte & single$\_$bit$\_$mask$($VALID$\_$BIT$))!=0$;

$\}$

bool is$\_$read$\_$enabled$($PageTableEntry pte$)\{$

$//$ todo

$//$ Question: Implement this function. Hint: it can take as little as $1$ line.

return is$\_$bit$\_$set$($pte$,$ READ$\_$BIT$)$;

$\}$

bool is$\_$write$\_$enabled$($PageTableEntry pte$)\{$

$//$ todo

return pte & single$\_$bit$\_$mask$($WRITE$\_$BIT$)$;

$\}$

bool is$\_$execute$\_$enabled$($PageTableEntry pte$)\{$

$//$ todo

return pte & single$\_$bit$\_$mask$($EXEC$\_$BIT$)$;

$\}$

PFN find$\_$free$\_$page$($MMU m$)\{$

for $($PFN i $=0$; i $$ NUM$\_$FRAMES; i$++)\{$

if $(!$m$.$page$\_$used$[$i$])\{//$ Check if the page is not used

return i; $//$ Return the first free page index

$\}$

$\}$

return $-1$; $//$ Indicate no free pages found

$\}$

PFN convert$\_$PageTableEntry$\_$to$\_$PFN$($PageTableEntry pte$)\{$

$//$ todo

PageTableEntry mask $=$ ~$(($PageTableEntry$)0)$; $//$ All bits set to $1$

mask $=$ mask $>>($NUM$\_$BITS$\_$IN$\_$BYTE $*$ sizeof$($PageTableEntry$)-4)$; $//$ Shift to get $4$ least significant bits

return pte & mask;

$\}$

$/*$

$*$ Page Table Functions

$*/$

PageTableEntry get$\_$pagetableentry$\_\_$MMU$\_$pagetable$($MMU m$,$ VPN vpn$)\{$

$//$ todo

return m$.$page$\_$pointer$[$vpn$]$;

$\}$

PFN map$\_$page$\_\_$MMU$\_$pagetable$($MMU$*$ m$,$ VPN vpn$,$ bool can$\_$read, bool can$\_$write, bool can$\_$exec$)\{$

$//$ todo

PFN pfn $=$ find$\_$free$\_$page$(*$m$)$;

if $($pfn $==$ NUM$\_$FRAMES$)\{$

$//$ No free page found

return pfn; $//$ Handle this case accordingly

$\}$

$//$ Set the page as used

m$->$page$\_$used$[$pfn$]=$ true;

PageTableEntry entry $=0$; $//$ Initialize to zero

if $($can$\_$read$)$ entry $|=$ single$\_$bit$\_$mask$($READ$\_$BIT$)$;

if $($can$\_$write$)$ entry $|=$ single$\_$bit$\_$mask$($WRITE$\_$BIT$)$;

if $($can$\_$exec$)$ entry $|=$ single$\_$bit$\_$mask$($EXEC$\_$BIT$)$;

$//$ Set PFN bits

entry $|=$ pfn;

$//$ Assuming page$\_$pointer is a $1$D array representing the page table

m$->$page$\_$pointer$[$vpn$]=$ entry;

return pfn;

$\}$

Page$*$ get$\_$page$($MMU m$,$ VirtualAddress va$,$ bool for$\_$read, bool for$\_$write, bool for$\_$execute$)\{$

$//$ todo

VPN vpn $=$ va $>>$ NUM$\_$OFFSET$\_$BITS; $//$ Extract the VPN from the VirtualAddress

PageTableEntry pte $=$ m$.$get$\_$pagetableentry$($m$,$ vpn$)$;

if $(!$is$\_$entry$\_$valid$($pte$))$ return NULL; $//$ Page not present

if $($for$\_$read && $!$is$\_$read$\_$enabled$($pte$))$ return NULL; $//$ No read permission

if $($for$\_$write && $!$is$\_$write$\_$enabled$($pte$))$ return NULL; $//$ No write permission

if $($for$\_$execute && $!$is$\_$execute$\_$enabled$($pte$))$ return NULL; $//$ No execute permission

PFN pfn $=$ convert$\_$PageTableEntry$\_$to$\_$PFN$($pte$)$;

return $($Page$*)($m$.$physical$\_$memory $+$ pfn $*$ PAGE$\_$SIZE$)$;

$\}$

char read$\_$byte$($MMU m$,$ VirtualAddress va$)\{$

$//$ todo

Page$*$ page $=$ get$\_$page$($m$,$ va$,$ true, false, false$)$;

if $($page$)\{$

OFFSET offset $=$ va & get$\_$mask$($NUM$\_$OFFSET$\_$BITS$)$;

return page$->$data$[$offset$]$;

$\}$

$//$ Handle error if page is NULL, e$.$g$.,$ no read permission or page not present

return $-1$;

$\}$

void write$\_$byte$($MMU m$,$ VirtualAddress va$,$ char val$)\{$

$//$ todo

Page$*$ page $=$ get$\_$page$($m$,$ va$,$ false, true, false$)$;

if $($page$)\{$

OFFSET offset $=$ va & get$\_$mask$($NUM$\_$OFFSET$\_$BITS$)$;

page$->$data$[$offset$]=$ val;

$\}$

$\}$

My two test cases are failing.

These are the taest cases.

"FAILED": $[$

"map$\_$page$\_\_$MMU$\_$pagetable",

"end$\_$to$\_$end"

$]$

These are the test cases.

Test$($MMU$\_$PageTable, map$\_$page$\_\_$MMU$\_$pagetable$)\{$

$//$ See the random number

srand$($ time$($NULL$))$;

$//$ Create a new MMU

MMU m $=$ new$\_\_$MMU$\_$pagetable$()$;

$//$ Create the page pointer $($aka the page pointer$),$ so we can use it

m$.$page$\_$pointer $=$ calloc$($NUM$\_$PAGES, sizeof$($PageTableEntry$))$;

m$.$page$\_$used $=$ calloc$($NUM$\_$FRAMES, sizeof$($bool$))$;

for $($int i $=0$; i $$ NUMBER$\_$OF$\_$REPEATS; i$++)\{$

int page$\_$to$\_$test $=$ rand$()\%$ NUM$\_$PAGES;

map$\_$page$\_\_$MMU$\_$pagetable$($

&m$,//$ The MMU we created

page$\_$to$\_$test, $//$ The page number we're testing

page$\_$to$\_$test $\%2\%3,//$ Something random but repeatable

page$\_$to$\_$test $\%2\%5,//$ Something random but repeatable

page$\_$to$\_$test $\%2\%7//$ Something random but repeatable

$)$;

PageTableEntry pte $=$ m$.$page$\_$pointer$[$page$\_$to$\_$test$]$;

$//$ Check that the PageTableEntry is pointing to the right place

cr$\_$assert$($

$($get$\_$mask$($NUM$\_$PFN$\_$BITS $+$ NUM$\_$OFFSET$\_$BITS$)$ & pte$)$

$==$

$($i$)$

$)$;

cr$\_$assert$($is$\_$entry$\_$valid$($pte$))$;

cr$\_$assert$($is$\_$read$\_$enabled$($pte$)==$ page$\_$to$\_$test $\%2\%3)$;

cr$\_$assert$($is$\_$write$\_$enabled$($pte$)==$ page$\_$to$\_$test $\%2\%5)$;

cr$\_$assert$($is$\_$execute$\_$enabled$($pte$)==$ page$\_$to$\_$test $\%2\%6)$;

$\}$

cleanup$\_$MMU$($m$)$;

$\}$

void write$\_$string$($MMU m$,$ VirtualAddress va$,$ char$*$ str$)\{$

int i;

for $($i $=0$; str$[$i$]!=\text{'}\backslash 0\text{'}$; i$++)\{$

write$\_$byte$($m$,$ va$+$i$,$ str$[$i$])$;

$\}$

write$\_$byte$($m$,$ va$+$i$,\text{'}\backslash 0\text{'})$;

$\}$

Test$($MMU$\_$PageTable, end$\_$to$\_$end$)\{$

$//$ Create a new MMU

MMU m $=$ new$\_\_$MMU$\_$pagetable$()$;

for $($VPN vpn $=0$; vpn $$ NUM$\_$PAGES ; vpn$++)\{$

if $($vpn $==$ NUM$\_$PAGES $-1)\{$

m$.$map$\_$page$($&m$,$ vpn$,$ true, true, true$)$;

$\}$ else $\{$

m$.$map$\_$page$($&m$,$ vpn$,$ vpn $\%$

Can you solve the problem?