Fix implementation of clone and exec. Now the init process can load and execute the pci driver
This commit is contained in:
Jeremy Soller
parent
b01a918556
commit
33e098c124
9 changed files with 233 additions and 78 deletions
|
|
@ -9,6 +9,7 @@ use arch::paging::{ActivePageTable, InactivePageTable, Page, VirtualAddress, ent
|
|||
use arch::paging::temporary_page::TemporaryPage;
|
||||
use context;
|
||||
use elf;
|
||||
use scheme;
|
||||
use syscall::{self, Error, Result};
|
||||
|
||||
pub fn brk(address: usize) -> Result<usize> {
|
||||
|
|
@ -46,82 +47,201 @@ pub fn brk(address: usize) -> Result<usize> {
|
|||
}
|
||||
|
||||
pub fn clone(flags: usize, stack_base: usize) -> Result<usize> {
|
||||
//TODO: Implement flags
|
||||
//TODO: Copy on write?
|
||||
println!("Clone {:X}: {:X}", flags, stack_base);
|
||||
|
||||
let arch;
|
||||
let mut kstack_option = None;
|
||||
let mut offset = 0;
|
||||
let mut stack_option = None;
|
||||
|
||||
// Copy from old process
|
||||
{
|
||||
let contexts = context::contexts();
|
||||
let context_lock = contexts.current().ok_or(Error::NoProcess)?;
|
||||
let context = context_lock.read();
|
||||
arch = context.arch.clone();
|
||||
if let Some(ref stack) = context.kstack {
|
||||
offset = stack_base - stack.as_ptr() as usize - mem::size_of::<usize>(); // Add clone ret
|
||||
let mut new_stack = stack.clone();
|
||||
unsafe {
|
||||
let func_ptr = new_stack.as_mut_ptr().offset(offset as isize);
|
||||
*(func_ptr as *mut usize) = arch::interrupt::syscall::clone_ret as usize;
|
||||
}
|
||||
kstack_option = Some(new_stack);
|
||||
}
|
||||
if let Some(ref stack) = context.stack {
|
||||
let new_stack = context::memory::Memory::new(
|
||||
VirtualAddress::new(arch::USER_TMP_STACK_OFFSET),
|
||||
stack.size(),
|
||||
entry::NO_EXECUTE | entry::WRITABLE | entry::USER_ACCESSIBLE,
|
||||
true,
|
||||
true //TODO: Don't clear stack?
|
||||
);
|
||||
unsafe {
|
||||
arch::externs::memcpy(new_stack.start_address().get() as *mut u8,
|
||||
stack.start_address().get() as *const u8,
|
||||
stack.size());
|
||||
}
|
||||
stack_option = Some(new_stack);
|
||||
}
|
||||
}
|
||||
|
||||
// Set up new process
|
||||
let pid;
|
||||
{
|
||||
let mut contexts = context::contexts_mut();
|
||||
let context_lock = contexts.new_context()?;
|
||||
let mut context = context_lock.write();
|
||||
context.arch = arch;
|
||||
let arch;
|
||||
let mut kstack_option = None;
|
||||
let mut offset = 0;
|
||||
let mut image = vec![];
|
||||
let mut heap_option = None;
|
||||
let mut stack_option = None;
|
||||
let mut files = vec![];
|
||||
|
||||
let mut active_table = unsafe { ActivePageTable::new() };
|
||||
// Copy from old process
|
||||
{
|
||||
let contexts = context::contexts();
|
||||
let context_lock = contexts.current().ok_or(Error::NoProcess)?;
|
||||
let context = context_lock.read();
|
||||
arch = context.arch.clone();
|
||||
|
||||
let mut temporary_page = TemporaryPage::new(Page::containing_address(VirtualAddress::new(0x8_0000_0000)));
|
||||
println!("Clone kstack");
|
||||
if let Some(ref stack) = context.kstack {
|
||||
offset = stack_base - stack.as_ptr() as usize - mem::size_of::<usize>(); // Add clone ret
|
||||
let mut new_stack = stack.clone();
|
||||
unsafe {
|
||||
let func_ptr = new_stack.as_mut_ptr().offset(offset as isize);
|
||||
*(func_ptr as *mut usize) = arch::interrupt::syscall::clone_ret as usize;
|
||||
}
|
||||
kstack_option = Some(new_stack);
|
||||
}
|
||||
|
||||
let mut new_table = {
|
||||
let frame = allocate_frame().expect("no more frames in syscall::clone new_table");
|
||||
InactivePageTable::new(frame, &mut active_table, &mut temporary_page)
|
||||
};
|
||||
println!("Clone image");
|
||||
for memory in context.image.iter() {
|
||||
let mut new_memory = context::memory::Memory::new(
|
||||
VirtualAddress::new(memory.start_address().get() + arch::USER_TMP_OFFSET),
|
||||
memory.size(),
|
||||
entry::PRESENT | entry::NO_EXECUTE | entry::WRITABLE,
|
||||
true,
|
||||
false
|
||||
);
|
||||
unsafe {
|
||||
arch::externs::memcpy(new_memory.start_address().get() as *mut u8,
|
||||
memory.start_address().get() as *const u8,
|
||||
memory.size());
|
||||
}
|
||||
new_memory.remap(memory.flags(), true);
|
||||
image.push(new_memory);
|
||||
}
|
||||
|
||||
// Copy kernel mapping
|
||||
let kernel_frame = active_table.p4()[510].pointed_frame().expect("kernel table not mapped");
|
||||
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
|
||||
mapper.p4_mut()[510].set(kernel_frame, entry::PRESENT | entry::WRITABLE);
|
||||
});
|
||||
println!("Clone heap");
|
||||
if let Some(ref heap) = context.heap {
|
||||
let mut new_heap = context::memory::Memory::new(
|
||||
VirtualAddress::new(arch::USER_TMP_HEAP_OFFSET),
|
||||
heap.size(),
|
||||
entry::PRESENT | entry::NO_EXECUTE | entry::WRITABLE,
|
||||
true,
|
||||
false
|
||||
);
|
||||
unsafe {
|
||||
arch::externs::memcpy(new_heap.start_address().get() as *mut u8,
|
||||
heap.start_address().get() as *const u8,
|
||||
heap.size());
|
||||
}
|
||||
new_heap.remap(heap.flags(), true);
|
||||
heap_option = Some(new_heap);
|
||||
}
|
||||
|
||||
if let Some(stack) = kstack_option.take() {
|
||||
context.arch.set_stack(stack.as_ptr() as usize + offset);
|
||||
context.kstack = Some(stack);
|
||||
println!("Clone stack");
|
||||
if let Some(ref stack) = context.stack {
|
||||
let mut new_stack = context::memory::Memory::new(
|
||||
VirtualAddress::new(arch::USER_TMP_STACK_OFFSET),
|
||||
stack.size(),
|
||||
entry::PRESENT | entry::NO_EXECUTE | entry::WRITABLE,
|
||||
true,
|
||||
false
|
||||
);
|
||||
unsafe {
|
||||
arch::externs::memcpy(new_stack.start_address().get() as *mut u8,
|
||||
stack.start_address().get() as *const u8,
|
||||
stack.size());
|
||||
}
|
||||
new_stack.remap(stack.flags(), true);
|
||||
stack_option = Some(new_stack);
|
||||
}
|
||||
|
||||
println!("Clone files");
|
||||
for (fd, file_option) in context.files.iter().enumerate() {
|
||||
if let Some(file) = *file_option {
|
||||
let result = {
|
||||
let schemes = scheme::schemes();
|
||||
let scheme_mutex = schemes.get(file.scheme).ok_or(Error::BadFile)?;
|
||||
let result = scheme_mutex.lock().dup(file.number);
|
||||
result
|
||||
};
|
||||
match result {
|
||||
Ok(new_number) => {
|
||||
files.push(Some(context::file::File { scheme: file.scheme, number: new_number }));
|
||||
},
|
||||
Err(err) => {
|
||||
println!("clone: failed to dup {}: {:?}", fd, err);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
files.push(None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(mut stack) = stack_option.take() {
|
||||
stack.move_to(VirtualAddress::new(arch::USER_STACK_OFFSET), &mut new_table, &mut temporary_page, true);
|
||||
context.stack = Some(stack);
|
||||
// Set up new process
|
||||
{
|
||||
let mut contexts = context::contexts_mut();
|
||||
let context_lock = contexts.new_context()?;
|
||||
let mut context = context_lock.write();
|
||||
|
||||
pid = context.id;
|
||||
|
||||
context.arch = arch;
|
||||
|
||||
let mut active_table = unsafe { ActivePageTable::new() };
|
||||
|
||||
let mut temporary_page = TemporaryPage::new(Page::containing_address(VirtualAddress::new(0x8_0000_0000)));
|
||||
|
||||
let mut new_table = {
|
||||
let frame = allocate_frame().expect("no more frames in syscall::clone new_table");
|
||||
InactivePageTable::new(frame, &mut active_table, &mut temporary_page)
|
||||
};
|
||||
|
||||
// Copy kernel mapping
|
||||
println!("Set kernel mapping");
|
||||
{
|
||||
let kernel_frame = active_table.p4()[510].pointed_frame().expect("kernel table not mapped");
|
||||
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
|
||||
mapper.p4_mut()[510].set(kernel_frame, entry::PRESENT | entry::WRITABLE);
|
||||
});
|
||||
}
|
||||
|
||||
// Copy percpu mapping
|
||||
println!("Set kernel percpu");
|
||||
{
|
||||
extern {
|
||||
/// The starting byte of the thread data segment
|
||||
static mut __tdata_start: u8;
|
||||
/// The ending byte of the thread BSS segment
|
||||
static mut __tbss_end: u8;
|
||||
}
|
||||
|
||||
let size = unsafe { & __tbss_end as *const _ as usize - & __tdata_start as *const _ as usize };
|
||||
|
||||
let start = arch::KERNEL_PERCPU_OFFSET + arch::KERNEL_PERCPU_SIZE * ::cpu_id();
|
||||
let end = start + size;
|
||||
|
||||
let start_page = Page::containing_address(VirtualAddress::new(start));
|
||||
let end_page = Page::containing_address(VirtualAddress::new(end - 1));
|
||||
for page in Page::range_inclusive(start_page, end_page) {
|
||||
let frame = active_table.translate_page(page).expect("kernel percpu not mapped");
|
||||
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
|
||||
mapper.map_to(page, frame, entry::PRESENT | entry::NO_EXECUTE | entry::WRITABLE);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
println!("Set kstack");
|
||||
if let Some(stack) = kstack_option.take() {
|
||||
context.arch.set_stack(stack.as_ptr() as usize + offset);
|
||||
context.kstack = Some(stack);
|
||||
}
|
||||
|
||||
println!("Set image");
|
||||
for memory in image.iter_mut() {
|
||||
let start = VirtualAddress::new(memory.start_address().get() - arch::USER_TMP_OFFSET + arch::USER_OFFSET);
|
||||
memory.move_to(start, &mut new_table, &mut temporary_page, true);
|
||||
}
|
||||
context.image = image;
|
||||
|
||||
println!("Set heap");
|
||||
if let Some(mut heap) = heap_option.take() {
|
||||
heap.move_to(VirtualAddress::new(arch::USER_HEAP_OFFSET), &mut new_table, &mut temporary_page, true);
|
||||
context.heap = Some(heap);
|
||||
}
|
||||
|
||||
println!("Set stack");
|
||||
if let Some(mut stack) = stack_option.take() {
|
||||
stack.move_to(VirtualAddress::new(arch::USER_STACK_OFFSET), &mut new_table, &mut temporary_page, true);
|
||||
context.stack = Some(stack);
|
||||
}
|
||||
|
||||
println!("Set files");
|
||||
context.files = files;
|
||||
|
||||
context.arch.set_page_table(unsafe { new_table.address() });
|
||||
|
||||
context.blocked = false;
|
||||
}
|
||||
|
||||
context.arch.set_page_table(unsafe { new_table.address() });
|
||||
|
||||
context.blocked = false;
|
||||
pid = context.id;
|
||||
}
|
||||
|
||||
unsafe { context::switch(); }
|
||||
|
|
@ -153,8 +273,10 @@ pub fn exec(path: &[u8], _args: &[[usize; 2]]) -> Result<usize> {
|
|||
//TODO: Drop data vec
|
||||
println!("Exec {}", unsafe { str::from_utf8_unchecked(path) });
|
||||
|
||||
println!("Open");
|
||||
let file = syscall::open(path, 0)?;
|
||||
let mut data = vec![];
|
||||
println!("Reading");
|
||||
loop {
|
||||
let mut buf = [0; 4096];
|
||||
let count = syscall::read(file, &mut buf)?;
|
||||
|
|
@ -164,10 +286,15 @@ pub fn exec(path: &[u8], _args: &[[usize; 2]]) -> Result<usize> {
|
|||
break;
|
||||
}
|
||||
}
|
||||
println!("Close");
|
||||
let _ = syscall::close(file);
|
||||
|
||||
println!("Parse");
|
||||
match elf::Elf::from(&data) {
|
||||
Ok(elf) => elf.run().and(Ok(0)),
|
||||
Ok(elf) => {
|
||||
println!("Run");
|
||||
elf.run().and(Ok(0))
|
||||
},
|
||||
Err(err) => {
|
||||
println!("failed to execute {}: {}", unsafe { str::from_utf8_unchecked(path) }, err);
|
||||
Err(Error::NoExec)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue