Skip to content

Commit 89432bf

Browse files
IoanCristianCirsteaIoanCristianCirstea
committed
arch/x86-next: Changed ABI
Instead of pushing and popping arguments on the stack, arguments are passed in registers as on Linux x86 and Tock RISC-V. This new ABI simplifies the implementation of virtual memory. Signed-off-by: Ioan-Cristian CÎRSTEA <ioan.cirstea@oxidos.io>
1 parent bab1368 commit 89432bf

2 files changed

Lines changed: 20 additions & 188 deletions

File tree

‎arch/x86-next/src/boundary/boundary_impl.rs‎

Lines changed: 20 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -27,12 +27,11 @@ impl Default for Boundary {
2727
impl Boundary {
2828
/// Minimum required size for initial process memory.
2929
///
30-
/// Need at least 9 dwords of initial stack space for CRT 0:
30+
/// Need at least 5 dwords of initial stack space for CRT 0:
3131
///
32-
/// - 4 dwords for initial upcall arguments
3332
/// - 1 dword for initial upcall return address (although this will be zero for init_fn)
3433
/// - 4 dwords of scratch space for invoking memop syscalls
35-
const MIN_APP_BRK: u32 = 9 * core::mem::size_of::<usize>() as u32;
34+
const MIN_APP_BRK: u32 = 5 * core::mem::size_of::<usize>() as u32;
3635

3736
/// Constructs a new instance of `SysCall`.
3837
pub fn new() -> Self {
@@ -85,91 +84,35 @@ impl UserspaceKernelBoundary for Boundary {
8584

8685
unsafe fn set_syscall_return_value(
8786
&self,
88-
accessible_memory_start: *const u8,
89-
app_brk: *const u8,
87+
_accessible_memory_start: *const u8,
88+
_app_brk: *const u8,
9089
state: &mut Self::StoredState,
9190
return_value: SyscallReturn,
9291
) -> Result<(), ()> {
93-
let mut ret0 = 0;
94-
let mut ret1 = 0;
95-
let mut ret2 = 0;
96-
let mut ret3 = 0;
97-
98-
// These operations are only safe so long as
99-
// - the pointers are properly aligned. This is guaranteed because the
100-
// pointers are all offset multiples of 4 bytes from the stack
101-
// pointer, which is guaranteed to be properly aligned after
102-
// exception entry on x86. See
103-
// https://github.com/tock/tock/pull/2478#issuecomment-796389747
104-
// for more details.
105-
// - the pointer is dereferencable, i.e. the memory range of
106-
// the given size starting at the pointer must all be within
107-
// the bounds of a single allocated object
108-
// - the pointer must point to an initialized instance of its
109-
// type
110-
// - during the lifetime of the returned reference (of the
111-
// cast, essentially an arbitrary 'a), the memory must not
112-
// get accessed (read or written) through any other pointer.
113-
//
114-
// Refer to
115-
// https://doc.rust-lang.org/std/primitive.pointer.html#safety-13
11692
kernel::utilities::arch_helpers::encode_syscall_return_trd104(
11793
&kernel::utilities::arch_helpers::TRD104SyscallReturn::from_syscall_return(
11894
return_value,
11995
),
120-
&mut ret0,
121-
&mut ret1,
122-
&mut ret2,
123-
&mut ret3,
96+
&mut state.ebx,
97+
&mut state.ecx,
98+
&mut state.edx,
99+
&mut state.edi,
124100
);
125101

126-
// App allocates 16 bytes of stack space for passing syscall arguments. We re-use that stack
127-
// space to pass return values.
128-
//
129-
// Safety: Caller of this function has guaranteed that the memory region is valid.
130-
unsafe {
131-
state.write_stack(0, ret0, accessible_memory_start, app_brk)?;
132-
state.write_stack(1, ret1, accessible_memory_start, app_brk)?;
133-
state.write_stack(2, ret2, accessible_memory_start, app_brk)?;
134-
state.write_stack(3, ret3, accessible_memory_start, app_brk)?;
135-
}
136-
137102
Ok(())
138103
}
139104

140105
unsafe fn set_process_function(
141106
&self,
142-
accessible_memory_start: *const u8,
143-
app_brk: *const u8,
107+
_accessible_memory_start: *const u8,
108+
_app_brk: *const u8,
144109
state: &mut Self::StoredState,
145110
upcall: FunctionCall,
146111
) -> Result<(), ()> {
147-
// Our x86 port expects upcalls to be standard cdecl routines. We push args and return
148-
// address onto the stack accordingly.
149-
//
150-
// Upcall arguments are written directly into the existing stack space (rather than
151-
// being pushed on top). This is safe to do because:
152-
//
153-
// * When the process first starts ESP is initialized to `app_brk - 16`, giving us exactly
154-
// enough space for these arguments.
155-
// * Otherwise, we assume the app is currently issuing a `yield` syscall. We re-use the
156-
// stack space from that syscall. This is okay because `yield` doesn't return anything.
157-
//
158-
// Safety: Caller of this function has guaranteed that the memory region is valid.
159-
// usize is u32 on x86
160-
unsafe {
161-
state.write_stack(0, upcall.argument0 as u32, accessible_memory_start, app_brk)?;
162-
state.write_stack(1, upcall.argument1 as u32, accessible_memory_start, app_brk)?;
163-
state.write_stack(2, upcall.argument2 as u32, accessible_memory_start, app_brk)?;
164-
state.write_stack(
165-
3,
166-
upcall.argument3.as_usize() as u32,
167-
accessible_memory_start,
168-
app_brk,
169-
)?;
170-
171-
state.push_stack(state.eip, accessible_memory_start, app_brk)?;
172-
}
112+
state.ebx = upcall.argument0 as u32;
113+
state.ecx = upcall.argument1 as u32;
114+
state.edx = upcall.argument2 as u32;
115+
state.edi = upcall.argument3.as_usize() as u32;
173116

174117
// The next time we switch to this process, we will directly jump to the upcall. When the
175118
// upcall issues `ret`, it will return to wherever the yield syscall was invoked.
@@ -180,8 +123,8 @@ impl UserspaceKernelBoundary for Boundary {
180123

181124
unsafe fn switch_to_process(
182125
&self,
183-
accessible_memory_start: *const u8,
184-
app_brk: *const u8,
126+
_accessible_memory_start: *const u8,
127+
_app_brk: *const u8,
185128
state: &mut Self::StoredState,
186129
) -> (ContextSwitchReason, Option<*const u8>) {
187130
// Sanity check: don't try to run a faulted app
@@ -203,17 +146,10 @@ impl UserspaceKernelBoundary for Boundary {
203146
SYSCALL_VECTOR => {
204147
let num = state.eax as u8;
205148

206-
// Syscall arguments are passed on the stack using cdecl convention.
207-
//
208-
// Safety: Caller of this function has guaranteed that the memory region is valid.
209-
let arg0 =
210-
unsafe { state.read_stack(0, accessible_memory_start, app_brk) }.unwrap_or(0);
211-
let arg1 =
212-
unsafe { state.read_stack(1, accessible_memory_start, app_brk) }.unwrap_or(0);
213-
let arg2 =
214-
unsafe { state.read_stack(2, accessible_memory_start, app_brk) }.unwrap_or(0);
215-
let arg3 =
216-
unsafe { state.read_stack(3, accessible_memory_start, app_brk) }.unwrap_or(0);
149+
let arg0 = state.ebx;
150+
let arg1 = state.ecx;
151+
let arg2 = state.edx;
152+
let arg3 = state.edi;
217153

218154
Syscall::from_register_arguments(
219155
num,

‎arch/x86-next/src/boundary/context.rs‎

Lines changed: 0 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,6 @@
33
// Copyright Tock Contributors 2024.
44

55
use core::fmt::{self, Display, Formatter};
6-
use core::mem::size_of;
7-
use core::ptr;
86

97
use crate::registers::irq::EXCEPTIONS;
108

@@ -44,108 +42,6 @@ pub struct UserContext {
4442
pub err_code: u32,
4543
}
4644

47-
impl UserContext {
48-
/// Pushes a value onto the user stack.
49-
///
50-
/// Returns an `Err` if the new stack value would fall outside of valid memory.
51-
///
52-
/// ## Safety
53-
///
54-
/// The memory region described by `accessible_memory_start` and `app_brk` must point to memory
55-
/// of the user process. This function will write to that memory.
56-
pub unsafe fn push_stack(
57-
&mut self,
58-
value: u32,
59-
accessible_memory_start: *const u8,
60-
app_brk: *const u8,
61-
) -> Result<(), ()> {
62-
let new_esp = self.esp - 4;
63-
64-
if new_esp < accessible_memory_start as u32 {
65-
return Err(());
66-
}
67-
68-
if new_esp + 4 > app_brk as u32 {
69-
return Err(());
70-
}
71-
72-
// Safety: We have validated above that new_esp lies within the specified memory region, and
73-
// the caller has guaranteed that this region is valid.
74-
unsafe { ptr::write_volatile(new_esp as *mut u32, value) };
75-
76-
self.esp = new_esp;
77-
78-
Ok(())
79-
}
80-
81-
/// Reads a value from `offset` relative to the current user stack pointer.
82-
///
83-
/// `offset` is a DWORD offset (i.e. 4 bytes), not bytes.
84-
///
85-
/// Returns an `Err` if the specified location falls outside of valid memory.
86-
///
87-
/// ## Safety
88-
///
89-
/// The memory region described by `accessible_memory_start` and `app_brk` must point to memory
90-
/// of the user process. This function will read from that memory.
91-
pub unsafe fn read_stack(
92-
&self,
93-
offset: u32,
94-
accessible_memory_start: *const u8,
95-
app_brk: *const u8,
96-
) -> Result<u32, ()> {
97-
let stack_addr = self.esp + (offset * 4);
98-
99-
if stack_addr < accessible_memory_start as u32 {
100-
return Err(());
101-
}
102-
103-
if stack_addr + 4 > app_brk as u32 {
104-
return Err(());
105-
}
106-
107-
// Safety: We have validated above that stack_addr lies within the specified memory region,
108-
// and the caller has guaranteed that this region is valid.
109-
let val = unsafe { ptr::read_volatile(stack_addr as *mut u32) };
110-
111-
Ok(val)
112-
}
113-
114-
/// Writes a value to `offset` relative to the current user stack pointer.
115-
///
116-
/// `offset` is a DWORD offset (i.e. 4 bytes), not bytes.
117-
///
118-
/// Returns an `Err` if the specified location falls outside of valid memory.
119-
///
120-
/// ## Safety
121-
///
122-
/// The memory region described by `accessible_memory_start` and `app_brk` must point to memory
123-
/// of the user process. This function will write to that memory.
124-
pub unsafe fn write_stack(
125-
&self,
126-
offset: u32,
127-
value: u32,
128-
accessible_memory_start: *const u8,
129-
app_brk: *const u8,
130-
) -> Result<(), ()> {
131-
let stack_addr = self.esp + (offset * size_of::<usize>() as u32);
132-
133-
if stack_addr < accessible_memory_start as u32 {
134-
return Err(());
135-
}
136-
137-
if stack_addr + 4 > app_brk as u32 {
138-
return Err(());
139-
}
140-
141-
// Safety: We have validated above that stack_addr lies within the specified memory region,
142-
// and the caller has guaranteed that this region is valid.
143-
unsafe { ptr::write_volatile(stack_addr as *mut u32, value) };
144-
145-
Ok(())
146-
}
147-
}
148-
14945
impl Display for UserContext {
15046
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
15147
writeln!(f)?;

0 commit comments

Comments
 (0)