mirror of
git://projects.qi-hardware.com/iris.git
synced 2025-04-21 12:27:27 +03:00
things seem to start working again
This commit is contained in:
Bas Wijnen
@@ -27,24 +27,24 @@ static unsigned _free
|
||||
extern unsigned _end
|
||||
|
||||
void init_alloc ():
|
||||
_free = (unsigned)&_end
|
||||
_free = ((unsigned)&_end + PAGE_SIZE - 1) & PAGE_MASK
|
||||
|
||||
char *alloc_space (unsigned pages):
|
||||
unsigned ret = (_free + PAGE_SIZE - 1) & PAGE_MASK
|
||||
_free = ret + pages * PAGE_SIZE
|
||||
_free = ret + (pages << PAGE_BITS)
|
||||
return (char *)ret
|
||||
|
||||
void *operator new[] (unsigned size):
|
||||
//kdebug ("new ")
|
||||
void *ret = (void *)_free
|
||||
size = (size + 3) & ~3
|
||||
unsigned rest = PAGE_SIZE - (((_free - 1) & ~PAGE_MASK) + 1)
|
||||
if rest < size:
|
||||
unsigned pages = ((size - rest) + PAGE_SIZE - 1) >> PAGE_BITS
|
||||
char *space = alloc_space (pages)
|
||||
for unsigned p = 0; p < pages; ++p:
|
||||
Kernel::Page page = Kernel::my_memory.create_page ()
|
||||
page.set_flags (Kernel::Page::PAYING | Kernel::Page::FRAME, Kernel::Page::PAYING | Kernel::Page::FRAME)
|
||||
Kernel::my_memory.map (page, (unsigned)&space[p << PAGE_BITS])
|
||||
Kernel::my_memory.map (page, _free + rest + (p << PAGE_BITS))
|
||||
Kernel::free_cap (page)
|
||||
_free += size
|
||||
//kdebug_num ((unsigned)ret)
|
||||
@@ -125,9 +125,6 @@ static void list_files (Directory root):
|
||||
kdebug ("\n")
|
||||
Kernel::panic (0)
|
||||
num_files = fullsize.l
|
||||
kdebug ("files in directory: ")
|
||||
kdebug_num (num_files)
|
||||
kdebug ("\n")
|
||||
files = new file[num_files]
|
||||
Kernel::Caps caps = Kernel::my_memory.create_caps (num_files)
|
||||
unsigned slot = Kernel::alloc_slot ()
|
||||
@@ -184,15 +181,14 @@ static void run (file *f, bool priv):
|
||||
Kernel::Memory mem = top_memory.create_memory ()
|
||||
unsigned num_pages = (f->size + PAGE_SIZE - 1) >> PAGE_BITS
|
||||
for unsigned p = 0; p < num_pages; ++p:
|
||||
kdebug_num (p)
|
||||
kdebug ("/")
|
||||
kdebug_num (num_pages)
|
||||
kdebug ("\n")
|
||||
//kdebug_num (p)
|
||||
//kdebug ("/")
|
||||
//kdebug_num (num_pages)
|
||||
//kdebug ("\n")
|
||||
Kernel::set_recv_arg (Kernel::Cap (slot, p))
|
||||
Kernel::my_memory.create_page ()
|
||||
Kernel::Page (slot, p).set_flags (Kernel::Page::PAYING, Kernel::Page::PAYING)
|
||||
f->string.get_page (p << PAGE_BITS, Kernel::Cap (slot, p))
|
||||
kdebug_line ()
|
||||
Kernel::my_memory.map (Kernel::Cap (slot, p), (unsigned)&mapping[p << PAGE_BITS])
|
||||
Kernel::Thread thread = mem.create_thread (NUM_SLOTS)
|
||||
if priv:
|
||||
@@ -229,24 +225,18 @@ static void run (file *f, bool priv):
|
||||
return
|
||||
thread.set_pc (header->e_entry)
|
||||
thread.set_sp (0x80000000)
|
||||
kdebug_line ()
|
||||
for unsigned section = 0; section < header->e_shnum; ++section:
|
||||
kdebug_line ()
|
||||
Elf32_Shdr *shdr = (Elf32_Shdr *)((unsigned)mapping + header->e_shoff + section * header->e_shentsize)
|
||||
if ~shdr->sh_flags & SHF_ALLOC:
|
||||
continue
|
||||
kdebug_line ()
|
||||
bool readonly = !(shdr->sh_flags & SHF_WRITE)
|
||||
//bool executable = shdr->sh_flags & SHF_EXEC_INSTR
|
||||
kdebug_line ()
|
||||
if shdr->sh_type != SHT_NOBITS:
|
||||
kdebug_line ()
|
||||
unsigned file_offset = shdr->sh_offset >> PAGE_BITS
|
||||
if (file_offset + ((shdr->sh_size + PAGE_SIZE - 1) >> PAGE_BITS)) >= (PAGE_SIZE >> 2):
|
||||
kdebug ("thread too large\n")
|
||||
Kernel::panic (0)
|
||||
return
|
||||
kdebug_line ()
|
||||
for unsigned p = (shdr->sh_addr & PAGE_MASK); p < shdr->sh_addr + shdr->sh_size; p += PAGE_SIZE:
|
||||
unsigned section_offset = (p - (shdr->sh_addr & PAGE_MASK)) >> PAGE_BITS
|
||||
unsigned idx = file_offset + section_offset
|
||||
@@ -257,24 +247,28 @@ static void run (file *f, bool priv):
|
||||
continue
|
||||
Kernel::free_cap (page)
|
||||
page = mem.create_page ()
|
||||
page.set_flags (Kernel::Page::PAYING, Kernel::Page::PAYING)
|
||||
unsigned f
|
||||
if readonly:
|
||||
f = Kernel::Page::PAYING | Kernel::Page::MAPPED_READONLY
|
||||
else:
|
||||
f = Kernel::Page::PAYING
|
||||
page.set_flags (f, f)
|
||||
Kernel::Page (slot, idx).share (page, 0)
|
||||
kdebug ("mapping at ")
|
||||
kdebug_num (p)
|
||||
kdebug ("\n")
|
||||
if !mem.map (page, p, readonly):
|
||||
//kdebug ("mapping at ")
|
||||
//kdebug_num (p)
|
||||
//if readonly:
|
||||
// kdebug (" (readonly)")
|
||||
//kdebug ("\n")
|
||||
if !mem.map (page, p):
|
||||
kdebug ("unable to map page\n")
|
||||
Kernel::panic (0)
|
||||
return
|
||||
Kernel::free_cap (page)
|
||||
kdebug_line ()
|
||||
else:
|
||||
kdebug_line ()
|
||||
if readonly:
|
||||
kdebug ("unwritable bss section\n")
|
||||
Kernel::panic (0)
|
||||
return
|
||||
kdebug_line ()
|
||||
for unsigned p = (shdr->sh_addr & PAGE_MASK); p < shdr->sh_addr + shdr->sh_size; p += PAGE_SIZE:
|
||||
Kernel::Page page = mem.mapping ((void *)p)
|
||||
if Kernel::recv.data[0].l == Kernel::NO_ERROR:
|
||||
@@ -302,103 +296,53 @@ static void run (file *f, bool priv):
|
||||
Kernel::panic (0)
|
||||
return
|
||||
Kernel::free_cap (page)
|
||||
kdebug_line ()
|
||||
kdebug_line ()
|
||||
for unsigned p = 0; p <= num_pages; ++p:
|
||||
for unsigned p = 0; p < num_pages; ++p:
|
||||
Kernel::my_memory.destroy (Kernel::Page (slot, p))
|
||||
kdebug_line ()
|
||||
Kernel::Page stackpage = mem.create_page ()
|
||||
kdebug_line ()
|
||||
stackpage.set_flags (Kernel::Page::PAYING | Kernel::Page::FRAME, Kernel::Page::PAYING | Kernel::Page::FRAME)
|
||||
kdebug_line ()
|
||||
if Kernel::recv.data[0].l != Kernel::NO_ERROR || !mem.map (stackpage, 0x7ffff000):
|
||||
kdebug ("unable to map initial stack page\n")
|
||||
Kernel::panic (0)
|
||||
return
|
||||
kdebug_line ()
|
||||
Kernel::free_cap (stackpage)
|
||||
Kernel::Caps caps = mem.create_caps (NUM_CAPS)
|
||||
kdebug_line ()
|
||||
thread.use (caps, 0)
|
||||
thread.set_info (Kernel::Thread::A0, NUM_SLOTS)
|
||||
thread.set_info (Kernel::Thread::A1, NUM_CAPS)
|
||||
kdebug_line ()
|
||||
Kernel::Receiver receiver = mem.create_receiver ()
|
||||
receiver.set_owner (thread.copy ())
|
||||
Kernel::Cap call = receiver.create_call_capability ()
|
||||
Kernel::Cap parent = Kernel::my_receiver.create_capability (++current_thread)
|
||||
kdebug_line ()
|
||||
caps.set (__receiver_num, receiver.copy ())
|
||||
caps.set (__thread_num, thread.copy ())
|
||||
caps.set (__memory_num, mem.copy ())
|
||||
caps.set (__call_num, call.copy ())
|
||||
caps.set (__parent_num, parent.copy ())
|
||||
kdebug_line ()
|
||||
thread.run ()
|
||||
kdebug_line ()
|
||||
Kernel::free_cap (receiver)
|
||||
Kernel::free_cap (thread)
|
||||
Kernel::free_cap (mem)
|
||||
Kernel::free_cap (call)
|
||||
Kernel::free_cap (parent)
|
||||
kdebug_line ()
|
||||
Kernel::print_caps ()
|
||||
|
||||
static void dump_devices ():
|
||||
kdebug ("String: ")
|
||||
kdebug_num (String::ID, 3)
|
||||
kdebug ("\nWString: ")
|
||||
kdebug_num (WString::ID, 3)
|
||||
kdebug ("\nDevice: ")
|
||||
kdebug_num (Device::ID, 3)
|
||||
kdebug ("\nParent: ")
|
||||
kdebug_num (Parent::ID, 3)
|
||||
kdebug ("\nKeyboard: ")
|
||||
kdebug_num (Keyboard::ID, 3)
|
||||
kdebug ("\nBuzzer: ")
|
||||
kdebug_num (Buzzer::ID, 3)
|
||||
kdebug ("\nDisplay: ")
|
||||
kdebug_num (Display::ID, 3)
|
||||
kdebug ("\nSetting: ")
|
||||
kdebug_num (Setting::ID, 3)
|
||||
kdebug ("\nDirectory: ")
|
||||
kdebug_num (Directory::ID, 3)
|
||||
kdebug ("\nWDirectory: ")
|
||||
kdebug_num (WDirectory::ID, 3)
|
||||
kdebug ("\nFilesystem: ")
|
||||
kdebug_num (Filesystem::ID, 3)
|
||||
kdebug ("\nStream: ")
|
||||
kdebug_num (Stream::ID, 3)
|
||||
kdebug ("\n")
|
||||
Kernel::free_cap (caps)
|
||||
|
||||
Kernel::Num start ():
|
||||
// Wait for the debugging device to be active, in case there is one.
|
||||
Kernel::schedule ()
|
||||
init_alloc ()
|
||||
dump_devices ()
|
||||
top_memory = Kernel::get_top_memory ()
|
||||
Directory root = receive_devices ()
|
||||
root.lock_ro ()
|
||||
kdebug_line ()
|
||||
list_files (root)
|
||||
kdebug_line ()
|
||||
sort ()
|
||||
kdebug_line ()
|
||||
Kernel::Caps caps = Kernel::my_memory.create_caps (max_pages)
|
||||
kdebug ("max pages: ")
|
||||
kdebug_num (max_pages)
|
||||
kdebug ("\n")
|
||||
slot = caps.use ()
|
||||
mapping = alloc_space (max_pages)
|
||||
for unsigned i = 0; i < num_files; ++i:
|
||||
kdebug_line ()
|
||||
run (&files[index[i]], files[index[i]].name[0] == '#')
|
||||
kdebug_line ()
|
||||
kdebug_line ()
|
||||
root.unlock_ro ()
|
||||
kdebug_line ()
|
||||
Kernel::free_slot (slot)
|
||||
kdebug_line ()
|
||||
Kernel::my_memory.destroy (caps)
|
||||
kdebug_line ()
|
||||
return 0
|
||||
while true:
|
||||
Kernel::wait ()
|
||||
kdebug ("request!\n")
|
||||
|
||||
Reference in New Issue
Block a user