From f95829cb521c076eebee345a1007e9fc912a0765 Mon Sep 17 00:00:00 2001 From: Scott Wood Date: Wed, 11 Apr 2007 19:00:48 -0500 Subject: [PATCH] random kernel stuff --- kernel/include/kern/orb.h | 20 +++++++++++++++--- kernel/include/kern/radix.h | 17 +++++++-------- kernel/include/kern/rmap.h | 8 +++++++- kernel/lib/libc.cc | 5 +++-- kernel/mem/orbmm.cc | 11 +++++++--- kernel/mem/rmap.cc | 8 ++++---- kernel/orb/invoke.cc | 41 +++++++++++++++++++++++++++---------- kernel/tests/aspace.cc | 3 ++- 8 files changed, 80 insertions(+), 33 deletions(-) diff --git a/kernel/include/kern/orb.h b/kernel/include/kern/orb.h index e420fc7..f90d051 100644 --- a/kernel/include/kern/orb.h +++ b/kernel/include/kern/orb.h @@ -7,6 +7,9 @@ #include #include +#include +#include + #include namespace Mem { @@ -54,9 +57,7 @@ namespace ORB { struct ObjectHdr; struct Object; - typedef u32 ID; - typedef Util::RadixTree IDRMap; struct ObjectHdr { ID id; @@ -78,14 +79,27 @@ namespace ORB { struct ObjectPtr : public ObjectHdr { Object *object; }; + + union ObjTableEntry { + ObjectHdr hdr; + Object obj; + ObjectPtr ptr; + }; + + typedef Util::RadixTree IDTable; + typedef Util::RadixTree IDRMap; + typedef Util::BitmapTree IDAlloc; class IDSpace { // Reverse mapping of object pointers to local IDs - IDRMap idrmap; + IDTable table; + IDRMap rmap; + IDAlloc alloc; public: Object *lookup(u32 id); ObjectHdr *get_local_hdr(Object *obj); + Object *newobj(Mem::ProcAddrSpace *aspace, uintptr_t entry); }; } diff --git a/kernel/include/kern/radix.h b/kernel/include/kern/radix.h index 1399356..f596fea 100644 --- a/kernel/include/kern/radix.h +++ b/kernel/include/kern/radix.h @@ -1,7 +1,7 @@ -// Generic radix tree implementation. It's only kernel-specific because -// it uses the kernel page allocator; each node takes up one page. The -// depth of the tree is dynamically growable (but not currently -// shrinkable). +// This is like RadixTree, but it uses the kernel page allocator; each +// node takes up one page. The depth of the tree is dynamically growable +// (but not currently shrinkable). It also auto-guesses radix_bits based +// on the size of T, so as to fit a page. #ifndef _KERN_RADIX_H #define _KERN_RADIX_H @@ -17,7 +17,7 @@ namespace Util { // Key must be an integer. template - class RadixTree { + class PageRadixTree { void *toplevel; uint depth; // in bits @@ -85,11 +85,12 @@ namespace Util { node = new_node; } - assert(shift == RADIX_final_shift - dir_shift); - return static_cast(node) + key_to_offset(key); + assert(shift == 0 || shift == RADIX_final_shift - dir_shift); + return (T *)((unsigned long)node + + (key_to_offset(key) << RADIX_data_bits)); } - RadixTree() + PageRadixTree() { toplevel = Mem::alloc_pages(1); bzero(toplevel, Arch::page_size); diff --git a/kernel/include/kern/rmap.h b/kernel/include/kern/rmap.h index 86dacd6..6124fdf 100644 --- a/kernel/include/kern/rmap.h +++ b/kernel/include/kern/rmap.h @@ -3,6 +3,7 @@ #include #include +#include namespace Mem { struct RMapNode { @@ -32,7 +33,12 @@ namespace Mem { class Page; class RMapTable { - Util::RadixTree tree; + Util::PageRadixTree tree; + + RMapNode *lookup(u64 vaddr, bool add = false) + { + return tree.lookup(vaddr >> Arch::page_shift, add); + } public: // rmap_lock must be held. diff --git a/kernel/lib/libc.cc b/kernel/lib/libc.cc index 60bdee2..e571384 100644 --- a/kernel/lib/libc.cc +++ b/kernel/lib/libc.cc @@ -539,6 +539,8 @@ void *memset(void *b, int ch, size_t len) void *malloc(size_t len) { + assert(len <= Arch::page_size - sizeof(size_t)); + len = (len + sizeof(size_t) + Arch::page_size - 1) / Arch::page_size; Mem::Page *page = Mem::PageAlloc::alloc(len); @@ -551,8 +553,7 @@ void *malloc(size_t len) void free(void *addr) { if (addr) { - size_t *ptr = (size_t *)addr; - ptr--; + size_t *ptr = (size_t *)addr - 1; size_t len = *ptr; Mem::Page *page = Mem::kvirt_to_page(addr); Mem::PageAlloc::free(page, len); diff --git a/kernel/mem/orbmm.cc b/kernel/mem/orbmm.cc index 49502d2..deb8689 100644 --- a/kernel/mem/orbmm.cc +++ b/kernel/mem/orbmm.cc @@ -25,17 +25,22 @@ namespace RunTime { priv = NULL; } - void *ORBMM::alloc(size_t size, AllocGroup *group) + void *ORBMM::alloc(size_t size, int refs) { return reinterpret_cast(new u8[size]); } - void ORBMM::retain(Region region) + void ORBMM::retain(void *ptr, int refs) { // FIXME } - void ORBMM::release(Region region) + void ORBMM::release(void *ptr, int refs) + { + // FIXME + } + + void ORBMM::add_region(Region rgn, bool unmap, int refs) { // FIXME } diff --git a/kernel/mem/rmap.cc b/kernel/mem/rmap.cc index 2ef4a03..dc9e256 100644 --- a/kernel/mem/rmap.cc +++ b/kernel/mem/rmap.cc @@ -28,7 +28,7 @@ namespace Mem { u64 dsvaddr, u64 usvaddr) { RMapNode *dsrmap = dsva->aspace->page_table-> - rmap_table.tree.lookup(dsvaddr, true); + rmap_table.lookup(dsvaddr, true); assert(!dsrmap->va); dsrmap->va = dsva; @@ -37,7 +37,7 @@ namespace Mem { dsrmap->tail.init(); if (usptbl) { - RMapNode *usrmap = usptbl->rmap_table.tree.lookup(usvaddr); + RMapNode *usrmap = usptbl->rmap_table.lookup(usvaddr); assert(usrmap); assert(usrmap->va->aspace->page_table == usptbl); @@ -53,7 +53,7 @@ namespace Mem { void RMapTable::unmap(u64 virtaddr) { Lock::AutoLock autolock(rmap_lock); - RMapNode *head = tree.lookup(virtaddr); + RMapNode *head = lookup(virtaddr); if (!head || !head->va) return; @@ -87,7 +87,7 @@ namespace Mem { void RMapTable::break_copy_on_write(u64 virtaddr, Page *new_page) { assert(rmap_lock.held_by_curthread()); - RMapNode *head = tree.lookup(virtaddr); + RMapNode *head = lookup(virtaddr); RMapNode *still_cow = NULL; assert(head && head->va); diff --git a/kernel/orb/invoke.cc b/kernel/orb/invoke.cc index 27a1ebe..102ea95 100644 --- a/kernel/orb/invoke.cc +++ b/kernel/orb/invoke.cc @@ -46,31 +46,50 @@ namespace ORB { return &hdr->frames[++thread->orbstack_top]; } - + ObjectHdr *IDSpace::get_local_hdr(Object *obj) { - ObjectHdr *hdr = idrmap.lookup(obj->id); + ObjectHdr *hdr = *rmap.lookup(obj->id); + if (hdr) + return hdr; - if (!hdr) - return 0; + int id = alloc.alloc(); + ObjectPtr *ptr = &table.lookup(id, true)->ptr; + + ptr->id = id; + ptr->flags = 0; + ptr->Pointer = 1; + ptr->object = obj; + + *rmap.lookup(id, true) = ptr; + return ptr; + } + + Object *IDSpace::newobj(Mem::ProcAddrSpace *aspace, uintptr_t entry) + { + int id = alloc.alloc(); + Object *obj = &table.lookup(id, true)->obj; + + obj->id = id; + obj->flags = 0; + obj->aspace = aspace; + obj->entry = entry; - return hdr->id; + return obj; } } -extern "C" void invoke_method(u32 objid, u32 methid, ParamInfoBlock *user_pib, - ulong ret_pc) +extern "C" void invoke_method(ParamInfoBlock *user_pib, ulong ret_pc) { ParamInfoBlock pib = Arch::copyin(user_pib); CallFrame *frame = new_frame(curthread); - frame->object = objid; - frame->method = methid; +// frame->object = objid; frame->caller_user_pib = user_pib; frame->ret_pc = ret_pc; - printf("invoke_method: frame %p object %x method %x pib %p ret %lx\n", - frame, frame->object, frame->method, frame->caller_user_pib, + printf("invoke_method: frame %p pib %p ret %lx\n", + frame, frame->caller_user_pib, frame->ret_pc); diff --git a/kernel/tests/aspace.cc b/kernel/tests/aspace.cc index 694021e..8471c37 100644 --- a/kernel/tests/aspace.cc +++ b/kernel/tests/aspace.cc @@ -57,7 +57,8 @@ void thread(void *arg) (void *)stacked[0], (void *)stacked[1], (void *)mappables[0], (void *)mappables[1]); - char *buf = new char[100000]; +// char *buf = new char[100000]; + char *buf = (char *)alloc_pages(25); printf("buf %p\n", buf); char *abuf = (char *)((((ulong)buf) + 4095) & ~4095); -- 2.39.2