mirror of
https://github.com/zephyrproject-rtos/zephyr
synced 2025-08-09 22:26:49 +00:00
0f16d98b32
The CPU first checks the page directory entry for write or user permissions on a particular page before looking at the page table entry. If a region configured all pages to be non user accessible, and this was changed for a page within it to be accessible, the PDE would not be updated and any access would still return a page fault. The least amount of runtime logic to deal with this is to indicate at build time that some pages within a region may be marked writable or user accessible at runtime, and to pre-set the flags in the page directory entry accordingly. The driving need for this is the region configuration for kernel memory, which will have user permissions set at runtime for stacks and user-configured memory domains. Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
566 lines
19 KiB
Python
566 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
|
|
import os
|
|
import sys
|
|
import struct
|
|
import parser
|
|
from collections import namedtuple
|
|
import ctypes
|
|
import argparse
|
|
|
|
############# global variables
|
|
pd_complete = ''
|
|
inputfile = ''
|
|
outputfile = ''
|
|
list_of_pde = {}
|
|
num_of_regions = 0
|
|
read_buff=''
|
|
|
|
struct_mmu_regions_tuple = {"start_addr","size","permissions"}
|
|
mmu_region_details = namedtuple("mmu_region_details", "pde_index page_entries_info")
|
|
|
|
valid_pages_inside_pde = namedtuple("valid_pages_inside_pde","start_addr size \
|
|
pte_valid_addr_start \
|
|
pte_valid_addr_end \
|
|
permissions")
|
|
|
|
page_tables_list = []
|
|
pd_start_addr = 0
|
|
validation_issue_memory_overlap = [False, 0, -1]
|
|
output_offset = 0
|
|
print_string_pde_list = ''
|
|
pde_pte_string = {}
|
|
FourMB = (1024*4096) #In Bytes
|
|
#############
|
|
|
|
#return the page directory number for the give address
|
|
def get_pde_number(value):
|
|
return( (value >> 22 ) & 0x3FF)
|
|
|
|
#return the page table number for the given address
|
|
def get_pte_number(value):
|
|
return( (value >> 12 ) & 0x3FF)
|
|
|
|
|
|
# update the tuple values for the memory regions needed
|
|
def set_pde_pte_values(pde_index, address, mem_size,
|
|
pte_valid_addr_start, pte_valid_addr_end, perm):
|
|
|
|
pages_tuple = valid_pages_inside_pde(
|
|
start_addr = address,
|
|
size = mem_size,
|
|
pte_valid_addr_start = pte_valid_addr_start,
|
|
pte_valid_addr_end = pte_valid_addr_end,
|
|
permissions = perm)
|
|
|
|
mem_region_values = mmu_region_details(pde_index = pde_index,
|
|
page_entries_info = [])
|
|
|
|
mem_region_values.page_entries_info.append(pages_tuple)
|
|
|
|
if pde_index in list_of_pde.keys():
|
|
# this step adds the new page info to the exsisting pages info
|
|
list_of_pde[pde_index].page_entries_info.append(pages_tuple)
|
|
else:
|
|
list_of_pde[pde_index] = mem_region_values
|
|
|
|
def print_list_of_pde(list_of_pde):
|
|
for key, value in list_of_pde.items():
|
|
print(key,value)
|
|
print('\n')
|
|
|
|
|
|
# read the binary from the input file and populate a dict for
|
|
# start address of mem region
|
|
# size of the region - so page tables entries will be created with this
|
|
# read write permissions
|
|
raw_info=[]
|
|
def read_mmu_list_marshal_param():
|
|
|
|
global read_buff
|
|
global page_tables_list
|
|
global pd_start_addr
|
|
global validation_issue_memory_overlap
|
|
read_buff = input_file.read()
|
|
input_file.close()
|
|
|
|
|
|
# read contents of the binary file first 2 values read are
|
|
# num_of_regions and page directory start address both calculated and
|
|
# populated by the linker
|
|
num_of_regions, pd_start_addr = struct.unpack_from(header_values_format,read_buff,0);
|
|
|
|
# a offset used to remember next location to read in the binary
|
|
size_read_from_binary = struct.calcsize(header_values_format);
|
|
|
|
# for each of the regions mentioned in the binary loop and populate all the
|
|
# required parameters
|
|
for region in range(num_of_regions):
|
|
basic_mem_region_values = struct.unpack_from(struct_mmu_regions_format,
|
|
read_buff,
|
|
size_read_from_binary);
|
|
size_read_from_binary += struct.calcsize(struct_mmu_regions_format);
|
|
|
|
#validate for memory overlap here
|
|
for i in raw_info:
|
|
start_location = basic_mem_region_values[0]
|
|
end_location = basic_mem_region_values[0] + basic_mem_region_values[1]
|
|
|
|
overlap_occurred = ( (start_location >= i[0]) and \
|
|
(start_location <= (i[0]+i[1]))) and \
|
|
((end_location >= i[0]) and \
|
|
(end_location <= i[0]+i[1]))
|
|
|
|
if overlap_occurred:
|
|
validation_issue_memory_overlap = [True,
|
|
start_location,
|
|
get_pde_number(start_location)]
|
|
return
|
|
|
|
# add the retrived info another list
|
|
raw_info.append(basic_mem_region_values)
|
|
|
|
for region in raw_info:
|
|
pde_index = get_pde_number(region[0])
|
|
pte_valid_addr_start = get_pte_number(region[0])
|
|
|
|
# Get the end of the page table entries
|
|
# Since a memory region can take up only a few entries in the Page
|
|
# table, this helps us get the last valid PTE.
|
|
pte_valid_addr_end = get_pte_number(region[0] +
|
|
region[1] - 1)
|
|
|
|
mem_size = region[1]
|
|
|
|
# In-case the start address aligns with a page table entry other than zero
|
|
# and the mem_size is greater than (1024*4096) i.e 4MB
|
|
# in case where it overflows the currenty PDE's range then limit the
|
|
# PTE to 1024 and so make the mem_size reflect the actual size taken up
|
|
# in the current PDE
|
|
if (region[1] + (pte_valid_addr_start * 4096) ) >= (FourMB):
|
|
pte_valid_addr_end = 1023
|
|
mem_size = ( (1024 - pte_valid_addr_start)*4096)
|
|
|
|
set_pde_pte_values(pde_index, region[0], mem_size,
|
|
pte_valid_addr_start, pte_valid_addr_end, region[2])
|
|
|
|
|
|
if pde_index not in page_tables_list:
|
|
page_tables_list.append(pde_index)
|
|
|
|
# IF the current pde couldn't fit the entire requested region size then
|
|
# there is a need to create new PDEs to match the size.
|
|
# Here the overflow_size represents the size that couldn't be fit inside
|
|
# the current PDE, this is will now to used to create a new PDE/PDEs
|
|
# so the size remaining will be
|
|
# requested size - allocated size(in the current PDE)
|
|
|
|
overflow_size = region[1] - mem_size
|
|
|
|
|
|
# create all the extra PDEs needed to fit the requested size
|
|
# this loop starts from the current pde till the last pde that is needed
|
|
# the last pde is calcualted as the (start_addr + size) >> 22
|
|
if overflow_size != 0:
|
|
for extra_pde in range(pde_index+1, get_pde_number(
|
|
region[0] + region[1])+1):
|
|
|
|
# new pde's start address
|
|
# each page directory entry has a addr range of (1024 *4096)
|
|
# thus the new PDE start address is a multiple of that number
|
|
extra_pde_start_address = extra_pde*(FourMB)
|
|
|
|
# the start address of and extra pde will always be 0
|
|
# and the end address is calculated with the new pde's start address
|
|
# and the overflow_size
|
|
extra_pte_valid_addr_end = get_pte_number(extra_pde_start_address
|
|
+ overflow_size - 1)
|
|
|
|
# if the overflow_size couldn't be fit inside this new pde then
|
|
# need another pde and so we now need to limit the end of the PTE
|
|
# to 1024 and set the size of this new region to the max possible
|
|
extra_region_size = overflow_size
|
|
if overflow_size >= (FourMB):
|
|
extra_region_size = FourMB
|
|
extra_pte_valid_addr_end = 1023
|
|
|
|
# load the new PDE's details
|
|
|
|
set_pde_pte_values(extra_pde, extra_pde_start_address,
|
|
extra_region_size,
|
|
0, extra_pte_valid_addr_end, region[2] )
|
|
|
|
|
|
# for the next iteration of the loop the size needs to decreased
|
|
overflow_size -= extra_region_size
|
|
|
|
# print(hex_32(overflow_size),extra_pde)
|
|
if extra_pde not in page_tables_list:
|
|
page_tables_list.append(extra_pde)
|
|
|
|
if overflow_size == 0:
|
|
break
|
|
|
|
page_tables_list.sort()
|
|
|
|
|
|
def validate_pde_regions():
|
|
#validation for correct page alignment of the regions
|
|
for key, value in list_of_pde.items():
|
|
for pages_inside_pde in value.page_entries_info:
|
|
if pages_inside_pde.start_addr & (0xFFF) != 0:
|
|
print("Memory Regions are not page aligned",
|
|
hex(pages_inside_pde.start_addr))
|
|
sys.exit(2)
|
|
|
|
#validation for correct page alignment of the regions
|
|
if pages_inside_pde.size & (0xFFF) != 0:
|
|
print("Memory Regions size is not page aligned",
|
|
hex(pages_inside_pde.size))
|
|
sys.exit(2)
|
|
|
|
#validation for spiling of the regions across various
|
|
if validation_issue_memory_overlap[0] == True:
|
|
print("Memory Regions are overlapping at memory address " +
|
|
str(hex(validation_issue_memory_overlap[1]))+
|
|
" with Page directory Entry number " +
|
|
str(validation_issue_memory_overlap[2]))
|
|
sys.exit(2)
|
|
|
|
|
|
|
|
|
|
|
|
# the return value will have the page address and it is assumed to be a 4096 boundary
|
|
# hence the output of this API will be a 20bit address of the page table
|
|
def address_of_page_table(page_table_number):
|
|
global pd_start_addr
|
|
|
|
# location from where the Page tables will be written
|
|
PT_start_addr = pd_start_addr + 4096
|
|
return ( (PT_start_addr + (page_tables_list.index(page_table_number)*4096) >>12))
|
|
|
|
# union x86_mmu_pde_pt {
|
|
# u32_t value;
|
|
# struct {
|
|
# u32_t p:1;
|
|
# u32_t rw:1;
|
|
# u32_t us:1;
|
|
# u32_t pwt:1;
|
|
# u32_t pcd:1;
|
|
# u32_t a:1;
|
|
# u32_t ignored1:1;
|
|
# u32_t ps:1;
|
|
# u32_t ignored2:4;
|
|
# u32_t page_table:20;
|
|
# };
|
|
# };
|
|
|
|
|
|
def check_bits(val, bits):
|
|
for b in bits:
|
|
if val & (1 << b):
|
|
return 1
|
|
return 0
|
|
|
|
def page_directory_create_binary_file():
|
|
global output_buffer
|
|
global output_offset
|
|
for pde in range(1024):
|
|
binary_value = 0 # the page directory entry is not valid
|
|
|
|
# if i have a valid entry to populate
|
|
if pde in sorted(list_of_pde.keys()):
|
|
value = list_of_pde[pde]
|
|
|
|
perms = value.page_entries_info[0].permissions
|
|
|
|
present = 1 << 0;
|
|
read_write = check_bits(perms, [1, 29]) << 1;
|
|
user_mode = check_bits(perms, [2, 28]) << 2;
|
|
|
|
pwt = 0 << 3;
|
|
pcd = 0 << 4;
|
|
a = 0 << 5; # this is a read only field
|
|
ps = 0 << 7; # this is a read only field
|
|
page_table = address_of_page_table(value.pde_index) << 12;
|
|
binary_value = (present | read_write | user_mode | pwt | pcd | a | ps | page_table)
|
|
pde_verbose_output(pde, binary_value)
|
|
|
|
struct.pack_into(write_4byte_bin,output_buffer, output_offset, binary_value)
|
|
output_offset += struct.calcsize(write_4byte_bin)
|
|
|
|
|
|
# union x86_mmu_pte {
|
|
# u32_t value;
|
|
# struct {
|
|
# u32_t p:1;
|
|
# u32_t rw:1;
|
|
# u32_t us:1;
|
|
# u32_t pwt:1;
|
|
# u32_t pcd:1;
|
|
# u32_t a:1;
|
|
# u32_t d:1;
|
|
# u32_t pat:1;
|
|
# u32_t g:1;
|
|
# u32_t alloc:1;
|
|
# u32_t custom:2;
|
|
# u32_t page:20;
|
|
# };
|
|
# };
|
|
|
|
def page_table_create_binary_file():
|
|
global output_buffer
|
|
global output_offset
|
|
|
|
for key, value in sorted(list_of_pde.items()):
|
|
for pte in range(1024):
|
|
binary_value = 0 # the page directory entry is not valid
|
|
|
|
valid_pte = 0
|
|
for i in value.page_entries_info:
|
|
temp_value = ((pte >= i.pte_valid_addr_start) and (pte <= i.pte_valid_addr_end))
|
|
if temp_value:
|
|
perm_for_pte = i.permissions
|
|
valid_pte |= temp_value
|
|
|
|
# if i have a valid entry to populate
|
|
if valid_pte:
|
|
present = 1 << 0;
|
|
read_write = ( ( perm_for_pte >> 1) & 0x1) << 1;
|
|
user_mode = ( ( perm_for_pte >> 2) & 0x1) << 2;
|
|
pwt = 0 << 3;
|
|
pcd = 0 << 4;
|
|
a = 0 << 5; # this is a read only field
|
|
d = 0 << 6; # this is a read only field
|
|
pat = 0 << 7
|
|
g = 0<< 8
|
|
alloc = 1 << 9
|
|
custom = 0 <<10
|
|
|
|
# This points to the actual memory in the HW
|
|
# totally 20 bits to rep the phy address
|
|
# first 10 is the number got from pde and next 10 is pte
|
|
page_table = ((value.pde_index <<10) |pte) << 12;
|
|
|
|
binary_value = (present | read_write | user_mode |
|
|
pwt | pcd | a | d | pat | g | alloc | custom |
|
|
page_table)
|
|
|
|
pte_verbose_output(key,pte,binary_value)
|
|
|
|
struct.pack_into(write_4byte_bin, output_buffer, output_offset, binary_value)
|
|
output_offset += struct.calcsize(write_4byte_bin)
|
|
|
|
|
|
# Read the parameters passed to the file
|
|
def parse_args():
|
|
global args
|
|
|
|
parser = argparse.ArgumentParser(description = __doc__,
|
|
formatter_class = argparse.RawDescriptionHelpFormatter)
|
|
|
|
parser.add_argument("-e", "--big-endian", action="store_true",
|
|
help="Target encodes data in big-endian format"
|
|
"(little endian is the default)")
|
|
|
|
parser.add_argument("-i", "--input",
|
|
help="Input file from which MMU regions are read.")
|
|
parser.add_argument("-o", "--output",
|
|
help="Output file into which the page tables are written.")
|
|
parser.add_argument("-v", "--verbose", action="store_true",
|
|
help="Lists all the relavent data generated.")
|
|
args = parser.parse_args()
|
|
|
|
# the format for writing in the binary file would be decided by the
|
|
# endian selected
|
|
def set_struct_endian_format():
|
|
endian_string = "<"
|
|
if args.big_endian == True:
|
|
endian_string = ">"
|
|
global struct_mmu_regions_format
|
|
global header_values_format
|
|
global write_4byte_bin
|
|
|
|
struct_mmu_regions_format = endian_string + "III"
|
|
header_values_format = endian_string + "II"
|
|
write_4byte_bin = endian_string + "I"
|
|
|
|
|
|
def format_string(input_str):
|
|
output_str = '{0: <5}'.format(str(input_str))
|
|
return(output_str)
|
|
|
|
#format for 32bit hex value
|
|
def hex_32(input_value):
|
|
output_value ="{0:#0{1}x}".format(input_value,10)
|
|
return(output_value)
|
|
|
|
#format for 20bit hex value
|
|
def hex_20(input_value):
|
|
output_value ="{0:#0{1}x}".format(input_value,7)
|
|
return(output_value)
|
|
|
|
def pde_verbose_output(pde, binary_value):
|
|
if args.verbose == False:
|
|
return
|
|
|
|
global print_string_pde_list
|
|
|
|
present = format_string(binary_value & 0x1 )
|
|
read_write = format_string((binary_value >> 1 ) & 0x1 )
|
|
user_mode = format_string((binary_value >> 2 ) & 0x1 )
|
|
pwt = format_string((binary_value >> 3 ) & 0x1 )
|
|
pcd = format_string((binary_value >> 4 ) & 0x1 )
|
|
a = format_string((binary_value >> 5 ) & 0x1 )
|
|
ignored1 = format_string(0)
|
|
ps = format_string((binary_value >> 7 ) & 0x1 )
|
|
ignored2 = format_string(0000)
|
|
page_table_addr = format_string( hex((binary_value >> 12 ) & 0xFFFFF))
|
|
|
|
print_string_pde_list += ( format_string(str(pde))+" | "+(present)+ " | "+\
|
|
(read_write)+ " | "+\
|
|
(user_mode)+ " | "+\
|
|
(pwt)+ " | "+\
|
|
(pcd)+ " | "+\
|
|
(a)+ " | "+\
|
|
(ps)+ " | "+
|
|
page_table_addr +"\n"
|
|
)
|
|
|
|
def pde_print_elements():
|
|
global print_string_pde_list
|
|
print("PAGE DIRECTORY ")
|
|
print(format_string("PDE")+" | "+ \
|
|
format_string('P') +" | "+ \
|
|
format_string('rw') +" | "+ \
|
|
format_string('us') +" | "+ \
|
|
format_string('pwt') +" | "+ \
|
|
format_string('pcd') +" | "+ \
|
|
format_string('a') +" | "+ \
|
|
format_string('ps') +" | "+ \
|
|
format_string('Addr page table'))
|
|
print(print_string_pde_list)
|
|
print("END OF PAGE DIRECTORY")
|
|
|
|
|
|
def pte_verbose_output(pde, pte, binary_value):
|
|
global pde_pte_string
|
|
|
|
present = format_string( str((binary_value >> 0) & 0x1))
|
|
read_write = format_string( str((binary_value >> 1) & 0x1))
|
|
user_mode = format_string( str((binary_value >> 2) & 0x1))
|
|
pwt = format_string( str((binary_value >> 3) & 0x1))
|
|
pcd = format_string( str((binary_value >> 4) & 0x1))
|
|
a = format_string( str((binary_value >> 5) & 0x1))
|
|
d = format_string( str((binary_value >> 6) & 0x1))
|
|
pat = format_string( str((binary_value >> 7) & 0x1))
|
|
g = format_string( str((binary_value >> 8) & 0x1))
|
|
alloc = format_string( str((binary_value >> 9) & 0x1))
|
|
custom = format_string( str((binary_value >> 10) & 0x3))
|
|
page_table_addr = hex_20((binary_value >> 12) & 0xFFFFF)
|
|
|
|
print_string_list = ( format_string(str(pte))+" | "+(present)+ " | "+\
|
|
(read_write)+ " | "+\
|
|
(user_mode)+ " | "+\
|
|
(pwt)+ " | "+\
|
|
(pcd)+ " | "+\
|
|
(a)+ " | "+\
|
|
(d)+ " | "+\
|
|
(pat)+ " | "+\
|
|
(g)+ " | "+\
|
|
(alloc)+ " | "+\
|
|
(custom)+ " | "+\
|
|
page_table_addr +"\n"
|
|
)
|
|
|
|
if pde in pde_pte_string.keys():
|
|
pde_pte_string[pde] += (print_string_list)
|
|
else:
|
|
pde_pte_string[pde] = print_string_list
|
|
|
|
|
|
def pte_print_elements():
|
|
global pde_pte_string
|
|
|
|
for pde,print_string in sorted(pde_pte_string.items()):
|
|
print("\nPAGE TABLE "+str(pde))
|
|
|
|
print(format_string("PTE")+" | "+ \
|
|
format_string('P') +" | "+ \
|
|
format_string('rw') +" | "+ \
|
|
format_string('us') +" | "+ \
|
|
format_string('pwt') +" | "+ \
|
|
format_string('pcd') +" | "+ \
|
|
format_string('a') +" | "+ \
|
|
format_string('d') +" | "+ \
|
|
format_string('pat') +" | "+ \
|
|
format_string('g') +" | "+ \
|
|
format_string('alloc') +" | "+ \
|
|
format_string('custom') +" | "+ \
|
|
format_string('page addr'))
|
|
print(print_string)
|
|
print("END OF PAGE TABLE "+ str(pde))
|
|
|
|
def verbose_output():
|
|
if args.verbose == False:
|
|
return
|
|
|
|
print("\nMemory Regions as defined:")
|
|
for info in raw_info:
|
|
print("Memory region start address = " + hex_32(info[0]) +\
|
|
", Memory size = " + hex_32(info[1]) +\
|
|
", Permission = "+ hex(info[2]))
|
|
|
|
print("\nTotal Page directory entries " + str(len(list_of_pde.keys())))
|
|
count =0
|
|
for key, value in list_of_pde.items():
|
|
for i in value.page_entries_info:
|
|
count+=1
|
|
print("In Page directory entry "+format_string(value.pde_index) +\
|
|
": valid start address = "+ \
|
|
hex_32(i.start_addr) + ", end address = " + \
|
|
hex_32((i.pte_valid_addr_end +1 )*4096 -1 +\
|
|
(value.pde_index * (FourMB))))
|
|
|
|
|
|
pde_print_elements()
|
|
pte_print_elements()
|
|
|
|
def main():
|
|
global output_buffer
|
|
parse_args()
|
|
|
|
set_struct_endian_format()
|
|
|
|
global input_file
|
|
input_file = open(args.input, 'rb')
|
|
|
|
global binary_output_file
|
|
binary_output_file = open(args.output, 'wb')
|
|
|
|
# inputfile= file_name
|
|
read_mmu_list_marshal_param()
|
|
|
|
#validate the inputs
|
|
validate_pde_regions()
|
|
|
|
# The size of the output buffer has to match the number of bytes we write
|
|
# this corresponds to the number of page tables gets created.
|
|
output_buffer = ctypes.create_string_buffer((4096)+
|
|
(len(list_of_pde.keys()) *
|
|
4096))
|
|
|
|
page_directory_create_binary_file()
|
|
page_table_create_binary_file()
|
|
|
|
#write the binary data into the file
|
|
binary_output_file.write(output_buffer);
|
|
binary_output_file.close()
|
|
|
|
# verbose output needed by the build system
|
|
verbose_output()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|