ejung/bsb2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

create copys of appcode in thread constructor

Browse Source
This commit is contained in:
Eggert Jung
2026-02-28 18:01:15 +01:00
parent 1acc652446
commit 4976ea91be
9 changed files with 265 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
kernel/interrupt/handlers.cc
View File

@@ -51,39 +51,39 @@ static void printContext(const InterruptContext *context) {
#include "syscall/skeleton.h"
[[gnu::interrupt]] static void handle_page_fault(InterruptContext *context,
uint64_t error) {
DBG << "Page fault encountered at linear address " << hex
<< Core::CR<2>::read() << endl
<< PageFaultError(error) << endl;
four_lvl_paging_t* paging_tree = Guard::enter().vault().scheduler.active()->paging_tree ;
asm volatile("mov %%cr3, %0" : "=r"(paging_tree));
uint64_t error) {
DBG << "Page fault encountered at linear address " << hex
<< Core::CR<2>::read() << endl
<< PageFaultError(error) << endl;
//four_lvl_paging_t* paging_tree = Guard::enter().vault().scheduler.active()->paging_tree ;
//asm volatile("mov %%cr3, %0" : "=r"(paging_tree));
uintptr_t virt = 0;
asm volatile("mov %%cr2, %0" : "=r"(virt));
if (PageFaultError(error).present && PageFaultError(error).write) {
uintptr_t pf =isMapped(virt, paging_tree);
uint64_t pf_number = uint64_t (pf >> 12 );
//uintptr_t virt = 0;
//asm volatile("mov %%cr2, %0" : "=r"(virt));
//if (PageFaultError(error).present && PageFaultError(error).write) {
// uintptr_t pf =isMapped(virt, paging_tree);
// uint64_t pf_number = uint64_t (pf >> 12 );
if(PageFrameAllocator::PageFrames[pf_number].ref_count==1){
setMapping(virt, (void*) pf , paging_tree, true);
// if(PageFrameAllocator::PageFrames[pf_number].ref_count==1){
// setMapping(virt, (void*) pf , paging_tree, true);
}else{
// }else{
uintptr_t page = (uintptr_t) PageFrameAllocator::alloc(false);
//Syscall::Skeleton::map(page, 4096);
setMapping(virt, (void*) page , paging_tree, true);
// uintptr_t page = (uintptr_t) PageFrameAllocator::alloc(false);
// //Syscall::Skeleton::map(page, 4096);
// setMapping(virt, (void*) page , paging_tree, true);
memcpy( (void*)page, (void*)virt, 4096);
Syscall::Skeleton::invlpg(virt);
}
// memcpy( (void*)page, (void*)virt, 4096);
// Syscall::Skeleton::invlpg(virt);
// }
}
//}
//Syscall::Skeleton::exit(Guard::enter().vault());
//kernelpanic("Page fault!");
Syscall::Skeleton::exit(Guard::enter().vault());
//kernelpanic("Page fault!");
}
/*! \brief Assembly interrupt handler for the keyboard.

8
kernel/main.cc
View File

@@ -56,8 +56,8 @@ extern "C" int main() {
PageFrameAllocator::stats();
Multiboot::Module* initrd = Multiboot::getModule(0);
DBG << "initrd address: " << hex << initrd->getStartAddress() << endl << "initrd size: " << initrd->getSize() << endl;
memcpy((void *)0x4000000, initrd->getStartAddress(), initrd->getSize());
mark_pageframes(0x4000000, 0x4000000 + initrd->getSize(), false);
//memcpy((void *)0x4000000, initrd->getStartAddress(), initrd->getSize());
//mark_pageframes(0x4000000, 0x4000000 + initrd->getSize(), false);
write_identity_map(identity_table, KERNEL_MEMORY_BORDER);
//create_basic_page_table(&paging_tree, identity_table);
@@ -88,8 +88,8 @@ extern "C" int main() {
uint32_t (*apps_header)[1024] = (uint32_t (*)[1024])Multiboot::getModule(0)->getStartAddress();
uint64_t offset = 1;
for(uint16_t i = 1; i <= (*apps_header)[0]; i++){
uint32_t appsize = (*apps_header)[i];
uintptr_t appstart = (0x4000+offset)<<12;
uint64_t appsize = (*apps_header)[i];
uintptr_t appstart = (uintptr_t)apps_header+(offset<<12);
DBG << "app " << i << " size " << appsize << " at " << appstart << endl;
Thread* thread_ptr= new Thread(false, (void*)0x4000000, (void*)appstart, (appsize/4096)+1); //TODO fix edgecase on size=4096

99
kernel/memory/pagetable.cc
View File

@@ -3,10 +3,22 @@
#include "pageframealloc.h"
#include "../utils/string.h"
void invlpg(uintptr_t virt_addr) {
asm volatile("invlpg (%0)" : : "r" (virt_addr) : "memory");
}
void load_cr3( void* cr3_value ) {
asm volatile("mov %0, %%cr3" :: "r"((uint64_t)cr3_value) : "memory");
}
uintptr_t get_cr3() {
uint64_t cr3;
__asm__ __volatile__("mov %%cr3, %0" : "=r"(cr3));
return cr3;
}
void write_identity_map(pagetable_t* identity_table, uint64_t size){
for(uintptr_t i=0; i<size/4096; i++){
identity_table[i/512].entries[i%512] = {
@@ -18,6 +30,41 @@ void write_identity_map(pagetable_t* identity_table, uint64_t size){
}
}
bool copy_page(pagetable_t* l4, uintptr_t src_paddr, void* dest_vaddr) {
//allocate frame and map in given address space
//if no mapping is present
uintptr_t dest_paddr = isMapped((uintptr_t)dest_vaddr, l4);
if(dest_paddr == 0){
dest_paddr = (uintptr_t)PageFrameAllocator::alloc(false);
if(dest_paddr == 0)
return false;
setMapping((uintptr_t)dest_vaddr, (void*)dest_paddr, l4);
}
//get temp page1
void* temp_dest_vaddr = getFreeVirtSpace((pagetable_t*)get_cr3(), 1);
if(temp_dest_vaddr == nullptr)
return false;
setMapping((uintptr_t)temp_dest_vaddr, (void*)dest_paddr, (pagetable_t*)get_cr3());
//get temp page2
void* temp_src_vaddr = getFreeVirtSpace((pagetable_t*)get_cr3(), 1);
if(temp_src_vaddr == nullptr || temp_dest_vaddr == nullptr)
return false;
setMapping((uintptr_t) temp_src_vaddr, (void*)src_paddr, (pagetable_t*)get_cr3());
//copy
memcpy(temp_dest_vaddr, temp_src_vaddr, 4096);
//unmap temp pages
setMapping((uintptr_t)(temp_src_vaddr), 0, (pagetable_t*)get_cr3());
setMapping((uintptr_t)(temp_dest_vaddr), 0, (pagetable_t*)get_cr3());
return true;
}
void create_basic_page_table(four_lvl_paging_t* table, pagetable_t* kernel_identity){
assert(table);
@@ -104,17 +151,19 @@ void create_basic_page_table(four_lvl_paging_t* table, pagetable_t* kernel_ident
kernel_identity[0].entries[0].present = 0;
}
uintptr_t isMapped(uintptr_t vaddr, four_lvl_paging_t* flpt){
uintptr_t isMapped(uintptr_t vaddr, pagetable_t* l4){
uint16_t l4Index = (vaddr>>39) & 0x1FF;
uint16_t l3Index = (vaddr>>30) & 0x1FF;
uint16_t l2Index = (vaddr>>21) & 0x1FF;
uint16_t l1Index = (vaddr>>12) & 0x1FF;
if(flpt->l4->entries[l4Index].present){
pagetable_t* lvl3 = (pagetable_t*)(flpt->l4->entries[l4Index].address<<12);
if(l4->entries[l4Index].present){
pagetable_t* lvl3 = (pagetable_t*)(l4->entries[l4Index].address<<12);
if(lvl3->entries[l3Index].present){
pagetable_t* lvl2 = (pagetable_t*)(lvl3->entries[l3Index].address<<12);
if(lvl2->entries[l2Index].present){
if(lvl2->entries[l2Index].pat)
return (lvl2->entries[l2Index].address<<21)+(l1Index<<12);
pagetable_t* lvl1 = (pagetable_t*)(lvl2->entries[l2Index].address<<12);
if(lvl1->entries[l1Index].present)
return lvl1->entries[l1Index].address<<12;
@@ -124,17 +173,17 @@ uintptr_t isMapped(uintptr_t vaddr, four_lvl_paging_t* flpt){
return 0;
}
void* getFreeVirtSpace(four_lvl_paging_t* search_table, uint8_t num_pages){
uint32_t start_v = 0x4000;
uint32_t stop_v = 0x6000;
static uint32_t next_start_v = 0x4000;
//static uint32_t next_start_v = start_v;
void* getFreeVirtSpace(pagetable_t* l4, uint8_t num_pages){
uint64_t start_v = 0x4000;
uint64_t stop_v = 0x200000;
static uint64_t next_start_v = 0x4000;
//static uint64_t next_start_v = start_v;
//start from last found address
for (uint32_t v=next_start_v; v<stop_v; v++) {
for (uint64_t v=next_start_v; v<stop_v; v++) {
bool space_is_free = true;
for(uint32_t i=0; i<num_pages; i++){
if(isMapped((uintptr_t)(v+i)<<12, search_table)) {
if(isMapped((uintptr_t)(v+i)<<12, l4)) {
space_is_free = false;
}
}
@@ -144,10 +193,10 @@ void* getFreeVirtSpace(four_lvl_paging_t* search_table, uint8_t num_pages){
}
}
//start again from the real start address
for (uint32_t v=start_v; v<next_start_v; v++) {
for (uint64_t v=start_v; v<next_start_v; v++) {
bool space_is_free = true;
for(uint32_t i=0; i<num_pages; i++){
if(isMapped((uintptr_t)(v+i)<<12, search_table)) {
if(isMapped((uintptr_t)(v+i)<<12, l4)) {
space_is_free = false;
}
}
@@ -160,16 +209,16 @@ void* getFreeVirtSpace(four_lvl_paging_t* search_table, uint8_t num_pages){
}
void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt, bool write){
void setMapping(uintptr_t vaddr, void* frame, pagetable_t* l4, bool write, bool remap){
uint16_t l4Index = (vaddr>>39) & 0x1FF;
uint16_t l3Index = (vaddr>>30) & 0x1FF;
uint16_t l2Index = (vaddr>>21) & 0x1FF;
uint16_t l1Index = (vaddr>>12) & 0x1FF;
if(!(flpt->l4->entries[l4Index].present)){
if(!(l4->entries[l4Index].present)){
pagetable_t* newl3 = (pagetable_t*)PageFrameAllocator::alloc(true);
memset(newl3, 0, 4096);
flpt->l4->entries[l4Index] = {
l4->entries[l4Index] = {
.present = 1,
.write = 1,
.user = 1,
@@ -177,7 +226,7 @@ void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt, bool writ
};
}
pagetable_t* lvl3 = (pagetable_t*)(flpt->l4->entries[l4Index].address<<12);
pagetable_t* lvl3 = (pagetable_t*)(l4->entries[l4Index].address<<12);
if(!(lvl3->entries[l3Index].present)){
pagetable_t* newl2 = (pagetable_t*)PageFrameAllocator::alloc(true);
memset(newl2, 0, 4096);
@@ -204,7 +253,8 @@ void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt, bool writ
pagetable_t* lvl1 = (pagetable_t*)(lvl2->entries[l2Index].address<<12);
if(frame){
assert(!(lvl1->entries[l1Index].present)); // should not be present, bc its a new mapping
if(!remap)
assert(!(lvl1->entries[l1Index].present)); // should not be present, bc its a new mapping
lvl1->entries[l1Index] = {
.present = 1,
.write = write,
@@ -212,8 +262,11 @@ void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt, bool writ
.address = (uintptr_t)frame >> 12
};
}
else //unmap if nullptr
else{ //unmap if nullptr
lvl1->entries[l1Index].present = 0;
if((void*)l4 == (void*)get_cr3())
invlpg(vaddr);
}
}
void copy_pagetable(four_lvl_paging_t* parent_table, four_lvl_paging_t* child_table){
@@ -233,17 +286,17 @@ void copy_pagetable(four_lvl_paging_t* parent_table, four_lvl_paging_t* child_ta
((uintptr_t)i1<<12) ;
if(vaddr < 0x4000000)
continue;
if(!isMapped(vaddr, child_table)){
if(!isMapped(vaddr, child_table->l4)){
//only copy if not part of basic pagetable
assert( (i3>0) || (i2>=32)); //assert user memory
void* frame = PageFrameAllocator::alloc(false);
setMapping(vaddr, frame, child_table);
setMapping(vaddr, frame, child_table->l4);
//map to local space for copy
void* dest = getFreeVirtSpace(parent_table, 1);
setMapping((uintptr_t)dest, frame, parent_table);
void* dest = getFreeVirtSpace(parent_table->l4, 1);
setMapping((uintptr_t)dest, frame, parent_table->l4);
memcpy(dest, (void*)vaddr, 4096);
setMapping((uintptr_t)dest, 0, parent_table);
setMapping((uintptr_t)dest, 0, parent_table->l4);
}
}
}

7
kernel/memory/pagetable.h
View File

@@ -50,10 +50,11 @@ typedef struct {
void write_identity_map(pagetable_t* identity_table, uint64_t size);
void create_basic_page_table(four_lvl_paging_t* table, pagetable_t* kernel_identity);
void load_cr3(void* cr3_value);
void setMapping(uintptr_t vaddr, void* frame, four_lvl_paging_t* flpt, bool write=true);
uintptr_t isMapped(uintptr_t vaddr, four_lvl_paging_t* flpt);
void* getFreeVirtSpace(four_lvl_paging_t* search_table, uint8_t num_pages);
void setMapping(uintptr_t vaddr, void* frame, pagetable_t* l4, bool write=true, bool remap=false);
uintptr_t isMapped(uintptr_t vaddr, pagetable_t* l4);
void* getFreeVirtSpace(pagetable_t* l4, uint8_t num_pages);
void copy_pagetable(four_lvl_paging_t* parent_table, four_lvl_paging_t* child_table);
bool copy_page(pagetable_t* l4, uintptr_t src_paddr, void* dest_vaddr);
//typedef struct {
// same

29
kernel/syscall/skeleton.cc
View File

@@ -145,7 +145,7 @@ namespace Syscall {
//pagetable_t* subbytable = vault->scheduler.active()->subtable;
four_lvl_paging_t* search_table = vault->scheduler.active()->paging_tree;
void* ptr = getFreeVirtSpace(search_table, num_pages);
void* ptr = getFreeVirtSpace(search_table->l4, num_pages);
if (ptr == nullptr) {
return nullptr;
}
@@ -154,7 +154,7 @@ namespace Syscall {
for (size_t i = 0; i < num_pages; ++i) {
// allocate each page with allocator
void* frame = PageFrameAllocator::alloc(false);
setMapping((uintptr_t)ptr, frame, search_table);
setMapping((uintptr_t)ptr, frame, search_table->l4);
}
return ptr;
}
@@ -166,8 +166,8 @@ namespace Syscall {
memset(start, 0, size);
for(uint32_t i=startIndex; i<(startIndex+NumberOfPages); i++){
uintptr_t frame = isMapped(i<<12, search_table);
setMapping(i<<12, 0, search_table);
uintptr_t frame = isMapped(i<<12, search_table->l4);
setMapping(i<<12, 0, search_table->l4);
PageFrameAllocator::free(frame);
invlpg(i<<12);
}
@@ -180,17 +180,18 @@ bool copy_from_phys(Vault& vault, uintptr_t phys_ptr, void* virt_ptr, size_t siz
size_t total_size = size + offset;
four_lvl_paging_t* search_table = vault.scheduler.active()->paging_tree;
void* virt_addr = getFreeVirtSpace(search_table, (total_size/4096)+1); // page aligned pointer
void* virt_addr = getFreeVirtSpace(search_table->l4, (total_size/4096)+1); // page aligned pointer
if (virt_addr == nullptr) {
return false;
}
for(uint8_t i =0; i<size/4096 +1; i++){
setMapping((uintptr_t)virt_addr, (void*)phys_ptr, vault.scheduler.active()->paging_tree);
//TODO actually use loop
setMapping((uintptr_t)virt_addr, (void*)phys_ptr, vault.scheduler.active()->paging_tree->l4);
}
memcpy(virt_ptr, (void*)((uintptr_t)(virt_addr)+ (uintptr_t)offset), size);
setMapping((uintptr_t)(virt_addr), 0, search_table);
setMapping((uintptr_t)(virt_addr), 0, search_table->l4);
return true;
}
@@ -201,7 +202,7 @@ bool send(Vault& v, int pid, const void* sbuffer, size_t ssize, void* rbuffer, s
Thread* current_thread = v.scheduler.active();
Thread* target_thread = v.thread_list[pid];
uintptr_t sbuffer_ptr = isMapped((uintptr_t)sbuffer,v.scheduler.active()->paging_tree) + ((uintptr_t)sbuffer&0xFFF);
uintptr_t sbuffer_ptr = isMapped((uintptr_t)sbuffer,v.scheduler.active()->paging_tree->l4) + ((uintptr_t)sbuffer&0xFFF);
IpcStruct msg {
.ptr = sbuffer_ptr,
.size = ssize,
@@ -267,7 +268,7 @@ bool reply(Vault& v, const void* buffer, size_t size) {
Thread* other_thread = v.thread_list[ipc->pid];
if (other_thread == nullptr) return false;
uintptr_t phys_ptr = isMapped((uintptr_t)buffer, current_thread->paging_tree );
uintptr_t phys_ptr = isMapped((uintptr_t)buffer, current_thread->paging_tree->l4 );
ipc->ptr = phys_ptr + ((uintptr_t)buffer & 0xFFF);
ipc->size = size;
ipc->pid = current_thread->id;
@@ -280,19 +281,19 @@ bool reply(Vault& v, const void* buffer, size_t size) {
}
void copy_stack(Thread* parent, Thread* child){
uintptr_t dest_frame = isMapped((uintptr_t)child->StackPointer.user, child->paging_tree);
void* dest_vaddr = getFreeVirtSpace(parent->paging_tree, 1);
setMapping((uintptr_t)dest_vaddr, (void*)dest_frame, parent->paging_tree);
uintptr_t dest_frame = isMapped((uintptr_t)child->StackPointer.user, child->paging_tree->l4);
void* dest_vaddr = getFreeVirtSpace(parent->paging_tree->l4, 1);
setMapping((uintptr_t)dest_vaddr, (void*)dest_frame, parent->paging_tree->l4);
memcpy(dest_vaddr, (void*)0x6000000/*((uintptr_t)parent->StackPointer.user & ~0xFFF)*/, 4096);
setMapping((uintptr_t)dest_vaddr, 0, parent->paging_tree);
setMapping((uintptr_t)dest_vaddr, 0, parent->paging_tree->l4);
}
int fork(Vault &vault, InterruptContext *user_context) {
Thread* parent = vault.scheduler.active();
Thread* child = new Thread(false, (void*)user_context->ip, parent->code_paddr, parent->code_pagenum);
copy_pagetable(parent->paging_tree, child->paging_tree);
//copy_pagetable(parent->paging_tree, child->paging_tree);
copy_stack(parent, child);
child->StackPointer.user = (void*)user_context->sp;

2
kernel/thread/idlethread.h
View File

@@ -19,7 +19,7 @@
*/
class IdleThread : public Thread {
public:
explicit IdleThread() : Thread(true, 0) {}
explicit IdleThread() : Thread(true, 0, 0, 0) {}
/*! \brief Wait for a thread to become ready and sleep in the meantime.
*

6
kernel/thread/thread.cc
View File

@@ -38,14 +38,14 @@ void Thread::map_app(void* code_paddr, uint16_t code_page_num, void* stack_vaddr
memset(paging_tree, 0, 4096);
create_basic_page_table(paging_tree, &identity_table);
// insert app code pages at 0x4000000
// app code pages at 0x4000000
for(uintptr_t i=0; i<(code_page_num*4096); i+=4096){
setMapping(0x4000000+i, (void*)((uintptr_t)code_paddr+i), paging_tree);
copy_page(paging_tree->l4, (uintptr_t)code_paddr+i, (void*)(0x4000000+i));
}
for(uintptr_t i=0; i<(stack_page_num*4096); i+=4096){
uintptr_t user_stackframe_p = ((uintptr_t)PageFrameAllocator::alloc(false));
setMapping((uintptr_t)(stack_vaddr)+i, (void*)((uintptr_t)user_stackframe_p), paging_tree);
setMapping((uintptr_t)(stack_vaddr)+i, (void*)((uintptr_t)user_stackframe_p), paging_tree->l4);
}
}

2
tools/build.mk
View File

@@ -23,7 +23,7 @@ CXXFLAGS_ARCH = -m64
CXXFLAGS_DEFAULT = -std=c++23 -ffreestanding -fno-pic -nodefaultlibs -nostdlib -nostdinc -I. -fno-rtti -fno-exceptions -Wno-write-strings -fno-stack-protector -mno-red-zone -g -gdwarf-2 -fno-use-cxa-atexit -no-pie -nostartfiles
# Enable 16-byte compare-and-exchange instruction for debugging purposes (stack alignment)
CXXFLAGS_DEFAULT += -mcx16
CXXFLAGS_OPT = -O3 -fomit-frame-pointer
CXXFLAGS_OPT = -O0 -fomit-frame-pointer
CXXFLAGS_WARNING = -Wall -Wextra -Werror -Wno-error=unused-parameter -Wno-error=unused-variable -Wno-non-virtual-dtor
CXXFLAGS_CLANG = -Wno-error=unused-private-field -Wno-implicit-exception-spec-mismatch -Wno-error=unused-const-variable -Wno-unused-command-line-argument -Wno-unused-const-variable -fno-strict-aliasing
ifeq ($(shell uname),Darwin)

246
user/app1/appl.cc
View File

@@ -1,113 +1,143 @@
// vim: set noet ts=4 sw=4:
#include "../libsys/stub.h"
#include "../libsys/string.h"
char* itoh(unsigned int value, char* buffer) {
char* ptr = &buffer[11];
*ptr = '\0'; // Nullterminator am Ende setzen
if (value == 0) {
*--ptr = '0';
return ptr;
char sbuf[8194], rbuf[8194]; // (2 * 4KiB) + 2
void main() {
fork();
fork();
int ppid = sys_getpid();
write(1, "app", 3, 0, ppid);
int other = fork();
if (ppid == other) { // child
sbuf[0] = 3;
sbuf[8192] = sys_getpid();
sbuf[8193] = 1;
send(other, sbuf, 8193, rbuf, 8193);
char msg[] = "REPLY: AA\n";
msg[7] += rbuf[0] + sbuf[8193];
msg[8] += 4 + ppid;
write(0, msg, 10);
} else { // parent
receive(rbuf, 8193);
rbuf[0] = rbuf[0] + rbuf[8192];
rbuf[8193] = 7;
reply(rbuf, 8193);
}
do {
ptr--;
*ptr = '0' + (value % 16);
if(*ptr >= 0x3A)
*ptr+=7;
value /= 16;
} while (value != 0);
return ptr;
}
char* itoa(unsigned int value, char* buffer) {
char* ptr = &buffer[11];
*ptr = '\0'; // Nullterminator am Ende setzen
if (value == 0) {
*--ptr = '0';
return ptr;
}
do {
ptr--;
*ptr = '0' + (value % 10);
value /= 10;
} while (value != 0);
return ptr;
}
extern "C" void main() {
// Thread 1 may be an auxiliary thread
//sys_test(1,2,3,4,5);
uint8_t ret = fork();
//ret = fork();
unsigned id = sys_getpid();
char text[] = "appX";
text[3] = 0x30+id;
write(1, text, strlen(text), 0, (int)id);
char msg[] = "forked pid: ";
msg[12] = 0x30+ret;
write(1, msg, strlen(msg), 6, (int)id);
uint8_t cnt = 0;
while(1){
cnt = (cnt+1)%100;
char msg[12];
char* num = itoa(cnt, msg);
write(1, num, strlen(num), 25, (int)id);
sleep(100);
}
for (uint8_t i = 1;; ++i) {
//counter to see app running
cnt=(cnt+1)%100;
char buf[32];
char* msg = itoa(cnt,buf);
write(1, msg, strlen(msg), 6, (int)id);
//test ipc
if((i+50)%100 == 0){
if(id == 2){
char txt[] = "toastbrot ";
itoa(cnt, &txt[1]);
write(2, "send\n", 5);
send(4, txt, strlen(txt), txt, 15);
write(1, txt, strlen(txt), 25, (int)id);
}
}
if(i%100 == 0){
if(id == 4){
char blubb[20];
if(receive(blubb, sizeof(blubb))){
write(1, blubb, strlen(blubb), 25, (int)id);
write(2, "reply\n", 6);
memset(&blubb[10], ' ', 3);
itoa(cnt, &blubb[1]);
reply(blubb, sizeof(blubb));
}
}
}
// test map/unmap and print ptr
void* ptr= map(4096);
uint16_t* val = ((uint16_t*)ptr);
*val = 0x1337;
msg = itoh((uintptr_t)ptr,buf);
write(1, msg, strlen(msg), 12, (int)id);
unmap(ptr, 4096);
sleep(100);
}
sys_exit();
}
//// vim: set noet ts=4 sw=4:
//
//#include "../libsys/stub.h"
//#include "../libsys/string.h"
//
//char* itoh(unsigned int value, char* buffer) {
// char* ptr = &buffer[11];
// *ptr = '\0'; // Nullterminator am Ende setzen
//
// if (value == 0) {
// *--ptr = '0';
// return ptr;
// }
//
// do {
// ptr--;
// *ptr = '0' + (value % 16);
// if(*ptr >= 0x3A)
// *ptr+=7;
// value /= 16;
// } while (value != 0);
//
// return ptr;
//}
//char* itoa(unsigned int value, char* buffer) {
// char* ptr = &buffer[11];
// *ptr = '\0'; // Nullterminator am Ende setzen
//
// if (value == 0) {
// *--ptr = '0';
// return ptr;
// }
//
// do {
// ptr--;
// *ptr = '0' + (value % 10);
// value /= 10;
// } while (value != 0);
//
// return ptr;
//}
//
//extern "C" void main() {
// // Thread 1 may be an auxiliary thread
//
// //sys_test(1,2,3,4,5);
//
// uint8_t ret = fork();
// ret = fork();
//
// unsigned id = sys_getpid();
//
// char text[] = "appX";
// text[3] = 0x30+id;
// write(1, text, strlen(text), 0, (int)id);
//
// char msg[] = "forked pid: ";
// msg[12] = 0x30+ret;
// write(1, msg, strlen(msg), 6, (int)id);
//
// uint8_t cnt = 0;
//
// while(1){
// cnt = (cnt+1)%100;
// char msg[12];
// char* num = itoa(cnt, msg);
// write(1, num, strlen(num), 25, (int)id);
// sleep(100);
// }
//
//
// for (uint8_t i = 1;; ++i) {
// //counter to see app running
// cnt=(cnt+1)%100;
// char buf[32];
// char* msg = itoa(cnt,buf);
// write(1, msg, strlen(msg), 6, (int)id);
//
// //test ipc
// if((i+50)%100 == 0){
// if(id == 2){
// char txt[] = "toastbrot ";
// itoa(cnt, &txt[1]);
// write(2, "send\n", 5);
// send(4, txt, strlen(txt), txt, 15);
// write(1, txt, strlen(txt), 25, (int)id);
// }
// }
// if(i%100 == 0){
// if(id == 4){
// char blubb[20];
// if(receive(blubb, sizeof(blubb))){
// write(1, blubb, strlen(blubb), 25, (int)id);
// write(2, "reply\n", 6);
// memset(&blubb[10], ' ', 3);
// itoa(cnt, &blubb[1]);
// reply(blubb, sizeof(blubb));
// }
// }
// }
//
// // test map/unmap and print ptr
// void* ptr= map(4096);
// uint16_t* val = ((uint16_t*)ptr);
// *val = 0x1337;
//
// msg = itoh((uintptr_t)ptr,buf);
// write(1, msg, strlen(msg), 12, (int)id);
// unmap(ptr, 4096);
//
// sleep(100);
// }
//}