diff options
Diffstat (limited to 'src')
29 files changed, 474 insertions, 101 deletions
diff --git a/src/include/gc/obj.h b/src/include/gc/obj.h index 10651f5..fcb60cd 100644 --- a/src/include/gc/obj.h +++ b/src/include/gc/obj.h @@ -5,10 +5,6 @@ #define ME_UNHANDLED -32767 #define ME_INTERRUPTED -32766 -struct object_cli { - int id; -}; - -typedef struct object_cli Object; +typedef int Object; #endif diff --git a/src/include/gc/server.h b/src/include/gc/server.h index 36597c7..3612a1d 100644 --- a/src/include/gc/server.h +++ b/src/include/gc/server.h @@ -16,11 +16,13 @@ struct method_data { union { int i; void* p; - } val; + }; int type; int keepShm; //for messages : keep shared memory segment after return or unmap ? (default : 0 = unmap) + size_t shmsize; } parameters[3]; uint32_t func; + int pid; int blocking; //1 : blocking request, 0 : message struct object_srv *obj; }; @@ -37,11 +39,19 @@ struct method_ret { //helper function for creating return values struct method_ret mr_long(int val); struct method_ret mr_llong(int64_t val); -struct method_ret mr_obj(Object* obj); +struct method_ret mr_obj(Object obj); struct method_ret mr_srv(struct object_srv* obj); struct method_ret mr_void(); struct method_ret mr_err(int error); +// for checking if a string passed in shared memory is valid +#define CHKSSTR(md, n) { size_t _i, _ok = 0; if (md->parameters[n].p == 0) return mr_err(-1); \ + for (_i = 0; _i < md->parameters[n].shmsize; _i++) { \ + if (*((char*)md->parameters[n].p + _i) == 0) { \ + _ok = 1; break; \ + } } \ + if (!_ok && md->parameters[n].shmsize != 0) return mr_err(-1); } + typedef struct method_ret (*method_handler)(struct method_data*); struct method_srv { diff --git a/src/include/gm/call.h b/src/include/gm/call.h new file mode 100644 index 0000000..5c3849d --- /dev/null +++ b/src/include/gm/call.h @@ -0,0 +1,18 @@ +#ifndef DEF_CALL_H +#define DEF_CALL_H + +/* + * This file and all files in include/call/ define prototypes to helper functions for calling methods on objects. + */ + +#include <gc/obj.h> + +#define _CHP Object o, int block +#define _CHC if (block) request(o, &sr); else send_msg(o, &sr); + +int c_handleCheck(_CHP, int method); +int c_handleCheckA(_CHP, int* methods, int number); + +int c_nothing(_CHP); + +#endif diff --git a/src/include/gm/call/manager.h b/src/include/gm/call/manager.h new file mode 100644 index 0000000..49aafe7 --- /dev/null +++ b/src/include/gm/call/manager.h @@ -0,0 +1,14 @@ +#ifndef DEF_CALL_MANAGER_H +#define DEF_CALL_MANAGER_H + +#include <gm/call.h> +#include <gc/obj.h> + +Object c_open(_CHP, char *c); +Object open(char *c); //calls c_open with object 1 + +void c_registerSvc(char *name); //automatically calls with objecct id 0 + +void c_logSvc(char *log, int level); + +#endif diff --git a/src/include/gm/method.h b/src/include/gm/method.h index 6206f07..13d3f16 100644 --- a/src/include/gm/method.h +++ b/src/include/gm/method.h @@ -22,4 +22,6 @@ #define M_NOTHING_VVVV (2) /* This method does nothing, it just checks message transmission to an object. */ +#include "method/manager.h" + #endif diff --git a/src/include/gm/method/manager.h b/src/include/gm/method/manager.h new file mode 100644 index 0000000..2066093 --- /dev/null +++ b/src/include/gm/method/manager.h @@ -0,0 +1,20 @@ +#ifdef DEF_METHOD_H + +#define M_OPEN_OMVV (10 | MP(1, 3, 0, 0)) +/* This function opens a distant ressource. Example : open("file:Root/Public/test.txt"); */ + +#define M_REGISTERSVC_VMOV (11 | MP(0, 3, 1, 0)) +/* This function registers a service. + * parameter 1 : service name; + * parameter 2 : service root object. */ + +#define M_LOGSVC_VMIV (12 | MP(0, 3, 2, 0)) +/* This parameters logs an entry for service with corresponding PID. Parameter 2 is : */ +#define LL_CRITICAL 0 +#define LL_ERROR 1 +#define LL_WARNING 2 +#define LL_NOTICE 3 +#define LL_STATUS 4 +#define LL_DEBUG 5 + +#endif diff --git a/src/include/stdlib.h b/src/include/stdlib.h index b232649..3a2b42c 100644 --- a/src/include/stdlib.h +++ b/src/include/stdlib.h @@ -1,7 +1,12 @@ #ifndef _DEF_STDLIB_H #define _DEF_STDLIB_H +#define NULL 0 + //includes malloc/free #include <gc/mem.h> +void printk_int(int number); +void printk_hex(unsigned number); + #endif diff --git a/src/include/string.h b/src/include/string.h index 15ec3f3..24ac216 100644 --- a/src/include/string.h +++ b/src/include/string.h @@ -2,10 +2,17 @@ #define _DEF_STRING_H #include <gc/syscall.h> +#include <stdlib.h> void *memcpy(void *dest, const void *src, int count); uint8_t *memset(uint8_t *dest, uint8_t val, int count); uint16_t *memsetw(uint16_t *dest, uint16_t val, int count); + int strlen(const char *str); +char *strcpy(char *dest, const char *src); +char *strdup(const char *src); +char *strchr(const char *str, char c); +char *strcat(char *dest, const char *src); +int strcmp(const char *s1, const char *s2); #endif diff --git a/src/kernel/Makefile b/src/kernel/Makefile index 6d0b7f3..d7a6a57 100644 --- a/src/kernel/Makefile +++ b/src/kernel/Makefile @@ -1,7 +1,7 @@ .PHONY: clean, mrproper CC = gcc -CFLAGS = -nostdlib -nostartfiles -nodefaultlibs -fno-builtin -fno-stack-protector -Wall -Wextra -I . -I ./lib +CFLAGS = -nostdlib -nostartfiles -nodefaultlibs -fno-builtin -fno-stack-protector -Wall -Wextra -I . -I ./lib -g LD = ld LDFLAGS = -T link.ld diff --git a/src/kernel/core/kmain.c b/src/kernel/core/kmain.c index 9fb1397..1577ac7 100644 --- a/src/kernel/core/kmain.c +++ b/src/kernel/core/kmain.c @@ -50,10 +50,11 @@ void kmain(struct multiboot_info_t* mbd, int32_t magic) { if (elf_check((uint8_t*)mods[i].mod_start)) { monitor_write(" : Invalid ELF file\n"); } else { - if (elf_exec((uint8_t*)mods[i].mod_start, PL_DRIVER) == 0) { + struct process *pr = elf_exec((uint8_t*)mods[i].mod_start, PL_DRIVER); + if (pr == 0) { monitor_write(" : Error loading\n"); } else { - monitor_write(" : OK\n"); + monitor_write(" : OK pid:"); monitor_writeDec(pr->pid); monitor_write("\n"); } } } diff --git a/src/kernel/core/loader_.asm b/src/kernel/core/loader_.asm index d3b92cf..5ee998a 100644 --- a/src/kernel/core/loader_.asm +++ b/src/kernel/core/loader_.asm @@ -31,7 +31,7 @@ loader: ;here, we load our false GDT, used for having the kernel in higher half section .text higherhalf: ; now we're running in higher half - mov esp, tasking_tmpStack+0x4000 ; set up the stack + mov esp, tasking_tmpStack+0x8000 ; set up the stack push eax ; pass Multiboot magic number add ebx, 0xE0000000 ; update the MB info structure so that it is in the new seg push ebx ; pass Multiboot info structure diff --git a/src/kernel/ipc/object.c b/src/kernel/ipc/object.c index e381c89..cfb9652 100644 --- a/src/kernel/ipc/object.c +++ b/src/kernel/ipc/object.c @@ -8,6 +8,7 @@ struct object* obj_new(struct process* owner) { ret->descriptors = 0; ret->busyMutex = MUTEX_UNLOCKED; ret->request = 0; + ret->wakeupOnRq = 0; return ret; } diff --git a/src/kernel/ipc/object.h b/src/kernel/ipc/object.h index 9dd3a1e..4577615 100644 --- a/src/kernel/ipc/object.h +++ b/src/kernel/ipc/object.h @@ -8,6 +8,7 @@ struct object { int descriptors; uint32_t busyMutex; //if busy, either a blocking request is being processed, or a sent message is waiting for being recieved struct request *request; + struct thread *wakeupOnRq; }; struct obj_descriptor { diff --git a/src/kernel/ipc/request.c b/src/kernel/ipc/request.c index 9ca724e..7fe8f2b 100644 --- a/src/kernel/ipc/request.c +++ b/src/kernel/ipc/request.c @@ -15,15 +15,19 @@ int request_get(int id, uint32_t ptr, int wait) { if (obj->request != 0 && obj->request->acknowledged != RS_PENDING) return -3; //if not (busymutex unlocked and request==0) && wait, then wait, else return -1 if (wait == 0 && obj->request == 0) return -1; - while (obj->busyMutex != MUTEX_LOCKED && (obj->request == 0 || obj->request->acknowledged != RS_PENDING)) thread_sleep(1); + while (obj->busyMutex != MUTEX_LOCKED && (obj->request == 0 || obj->request->acknowledged != RS_PENDING)) { + //set thread to be waked up on request + obj->wakeupOnRq = current_thread; + //go to sleep + thread_goInactive(); + } obj->request->acknowledged = RS_PROCESSED; //when request pending (wait finished), write it to ptr struct user_request *p = (struct user_request*)ptr; p->func = obj->request->func; for (i = 0; i < 3; i++) { p->params[i] = obj->request->params[i]; - if (obj->request->shm_sndr[i] != 0) p->shmsize[i] = obj->request->shm_sndr[i]->len; - else p->shmsize[i] = 0; + p->shmsize[i] = obj->request->shmsize[i]; } p->isBlocking = (obj->request->requester != 0); p->pid = obj->request->pid; @@ -69,15 +73,19 @@ void request_answer(int id, uint32_t answer, uint32_t answer2, int errcode) { obj->request->acknowledged = RS_FINISHED; switch (obj->request->func >> 30) { case PT_OBJDESC: - if ((int)answer <= 0) { + if ((int)answer < 0) { obj->request->answer.n = answer; } else { if (obj->owner == obj->request->requester->process) { obj->request->answer.n = answer; } else { - int n = objdesc_get(obj->request->requester->process, objdesc_read(obj->owner, answer)); - if (n == -1) { - n = objdesc_add(obj->request->requester->process, objdesc_read(obj->owner, answer)); + struct object *o = objdesc_read(obj->owner, answer); + int n = -1; + if (o != 0) { + n = objdesc_get(obj->request->requester->process, o); + if (n == -1) { + n = objdesc_add(obj->request->requester->process, o); + } } obj->request->answer.n = n; } @@ -110,11 +118,12 @@ int request_mapShm(int id, uint32_t pos, int number) { int n = (obj->request->func >> (28 - (2 * number))) & 3; if (n != PT_SHM) return -4; //check if sender process is different from receiver process, if not return -7 - if (obj->owner == obj->request->requester->process) return -7; + if (obj->request->requester != 0 && obj->owner == obj->request->requester->process) return -7; //check if sender sent a shm seg in parameter [number], if not return -5 if (obj->request->shm_sndr[number] == 0) return -5; //map shm to position obj->request->shm_rcv[number] = seg_map(obj->request->shm_sndr[number]->seg, obj->owner->pagedir, pos); + obj->request->shm_sndr[number]->seg->mappings--; //if request is nonblocking and no more shm is to be mapped, delete request and free object busymutex if (obj->request->requester != 0) return 0; for (i = 0; i < 3; i++) { @@ -161,7 +170,7 @@ static struct request *mkrequest(int id, struct thread *requester, uint32_t v = (i == 0 ? a : (i == 1 ? b : c)); switch (n) { case PT_OBJDESC: - if ((int)v <= 0) { + if ((int)v < 0) { rq->params[i] = v; } else { if (obj->owner == current_thread->process) { @@ -180,16 +189,25 @@ static struct request *mkrequest(int id, struct thread *requester, rq->params[i] = v; break; case PT_SHM: + rq->shmsize[i] = 0; if (obj->owner == current_thread->process) { rq->params[i] = v; + struct segment_map *t = shmseg_getByOff(current_thread->process, v); + if (t != 0) rq->shmsize[i] = t->len; } else { rq->shm_sndr[i] = shmseg_getByOff(current_thread->process, v); + rq->shm_sndr[i]->seg->mappings++; + if (rq->shm_sndr[i] != 0) rq->shmsize[i] = rq->shm_sndr[i]->len; } break; } } // reference request from object obj->request = rq; + if (obj->wakeupOnRq != 0) { + thread_wakeUp(obj->wakeupOnRq); + obj->wakeupOnRq = 0; + } // return request return rq; } @@ -230,5 +248,6 @@ int send_msg(int obj, uint32_t rq_ptr) { //if returned value is 0, return -1 else return 0 if (e != 0) return e; if (rq == 0) return -1; + urq->errcode = 0; return 0; } diff --git a/src/kernel/ipc/request.h b/src/kernel/ipc/request.h index 18eaf84..760a159 100644 --- a/src/kernel/ipc/request.h +++ b/src/kernel/ipc/request.h @@ -17,7 +17,7 @@ struct request { struct object *obj; struct thread *requester; //0 if nonblocking message - uint32_t func, params[3], obj_close[3]; //obj_close : object descriptors to close when requests yields an answer + uint32_t func, params[3], obj_close[3], shmsize[3]; //obj_close : object descriptors to close when requests yields an answer struct segment_map *shm_sndr[3], *shm_rcv[3]; int acknowledged; // (only for blocking requests) 0 : request is pending, 1 : request is being processes, 2 : finished, 3 : interrupted union { diff --git a/src/kernel/ipc/shm.c b/src/kernel/ipc/shm.c index 1cdacfb..e760a0f 100644 --- a/src/kernel/ipc/shm.c +++ b/src/kernel/ipc/shm.c @@ -2,6 +2,7 @@ #include <mem/mem.h> #include <mem/seg.h> #include <task/task.h> +#include <core/sys.h> struct segment* shmseg_make(size_t len, struct process* owner) { struct shmseg *ss = kmalloc(sizeof(struct shmseg)); @@ -29,8 +30,9 @@ struct segment_map *shmseg_map(struct segment *seg, struct page_directory *paged void shmseg_unmap(struct segment_map *sm) { size_t i; - for (i = sm->start; i < sm->start + sm->len; i += 0x1000) { - page_unmap(pagedir_getPage(sm->pagedir, i, 0)); + for (i = 0; i < sm->len; i += 0x1000) { + struct page *page = pagedir_getPage(sm->pagedir, sm->start + i, 0); + if (page != 0) page_unmap(page); } } diff --git a/src/kernel/mem/paging.c b/src/kernel/mem/paging.c index 9972b2a..4992d5e 100644 --- a/src/kernel/mem/paging.c +++ b/src/kernel/mem/paging.c @@ -121,7 +121,7 @@ uint32_t paging_fault(struct registers *regs) { if (regs->err_code & 0x4) monitor_write("user "); if (regs->err_code & 0x8) monitor_write("rsvd "); if (regs->err_code & 0x10) monitor_write("instructionfetch "); - monitor_write("@"); monitor_writeHex(addr); monitor_write("\n"); + monitor_write("cr2:"); monitor_writeHex(addr); monitor_write("\n"); return 1; } return 0; diff --git a/src/kernel/mem/seg.c b/src/kernel/mem/seg.c index ffaa84c..e3eca67 100644 --- a/src/kernel/mem/seg.c +++ b/src/kernel/mem/seg.c @@ -1,5 +1,6 @@ #include "seg.h" #include "mem.h" +#include <core/sys.h> struct segment_map *seg_map(struct segment* seg, struct page_directory *pagedir, size_t offset) { struct segment_map *sm = seg->map(seg, pagedir, offset); diff --git a/src/kernel/task/syscall.c b/src/kernel/task/syscall.c index 9a1ce81..a5142eb 100644 --- a/src/kernel/task/syscall.c +++ b/src/kernel/task/syscall.c @@ -12,6 +12,7 @@ #define CALL1V(name, scname) static void scname(struct registers* r) { name(r->ebx); } #define CALL2V(name, scname) static void scname(struct registers* r) { name(r->ebx, r->ecx); } #define CALL3V(name, scname) static void scname(struct registers* r) { name(r->ebx, r->ecx, r->edx); } +#define CALL4V(name, scname) static void scname(struct registers* r) { name(r->ebx, r->ecx, r->edx, r->esi); } CALL0V(thread_exit, thread_exit_sc); CALL0V(tasking_switch, schedule_sc); @@ -27,7 +28,7 @@ CALL1(object_owned, object_owned_sc); CALL1V(object_close, object_close_sc); CALL3(request_get, request_get_sc); CALL1(request_has, request_has_sc); -CALL3V(request_answer, request_answer_sc); +CALL4V(request_answer, request_answer_sc); CALL3(request_mapShm, request_mapShm_sc); CALL2(request, request_sc); CALL2(send_msg, send_msg_sc); diff --git a/src/kernel/task/task.c b/src/kernel/task/task.c index f10ec6f..8afc609 100644 --- a/src/kernel/task/task.c +++ b/src/kernel/task/task.c @@ -28,7 +28,7 @@ static uint32_t nextpid = 1; struct process *processes = 0, *kernel_process; struct thread *threads = 0, *current_thread = 0, *idle_thread; -uint32_t tasking_tmpStack[0x4000]; +uint32_t tasking_tmpStack[KSTACKSIZE]; void tasking_init() { cli(); @@ -54,7 +54,9 @@ static struct thread *thread_next() { if (thread_runnable(ret)) { return ret; } - if (ret == current_thread) return idle_thread; + if (ret == current_thread) { + return idle_thread; + } } } @@ -110,8 +112,17 @@ uint32_t tasking_handleException(struct registers *regs) { "Coprocessor Segment Overrun","Bad TSS","Segment Not Present","Stack Fault","General Protection Fault", "Page Fault","Unknown Interrupt","Coprocessor Fault","Alignment Check","Machine Check"}; monitor_write(exception_messages[regs->int_no]); - monitor_write(" at "); monitor_writeHex(regs->eip); - PANIC("kk"); + monitor_write(" eip:"); monitor_writeHex(regs->eip); + if (regs->eip >= 0xE0000000) { + monitor_write("\n Stack trace :"); + uint32_t *stack = (uint32_t*)regs->ebp, i; + for (i = 0; i < 5 && stack > 0xE0000000 && stack < (regs->useresp + 0x8000); i++) { + monitor_write("\nframe@"); monitor_writeHex(stack); + monitor_write(" next:"); monitor_writeHex(stack[0]); monitor_write(" ret:"); monitor_writeHex(stack[1]); + stack = (uint32_t*)stack[0]; + } + PANIC("Kernel error'd."); + } if (regs->int_no == 14) { monitor_write("\n>>> Process exiting.\n"); thread_exit_stackJmp(EX_PR_EXCEPTION); @@ -140,7 +151,7 @@ void thread_wakeUp(struct thread* t) { } int proc_priv() { - if (current_thread == 0) return PL_UNKNOWN; + if (current_thread == 0 || current_thread->process == 0) return PL_UNKNOWN; return current_thread->process->privilege; } @@ -151,20 +162,21 @@ void thread_exit2(uint32_t reason) { //See EX_TH_* defines in task.h * if reason is none of the two cases above, it is the whole process exiting (with error code = reason) */ struct thread *th = current_thread; + if (th == 0 || th->process == 0) goto retrn; struct process *pr = th->process; if ((reason == EX_TH_NORMAL || reason == EX_TH_EXCEPTION) && pr->threads > 1) { thread_delete(th); } else { process_delete(pr); } - sti(); + retrn: tasking_switch(); } void thread_exit_stackJmp(uint32_t reason) { - uint32_t *stack; cli(); - stack = tasking_tmpStack + 0x4000; + uint32_t *stack; + stack = tasking_tmpStack + (KSTACKSIZE / 4); stack--; *stack = reason; stack--; *stack = 0; asm volatile(" \ @@ -296,36 +308,49 @@ struct process *process_new(struct process* parent, uint32_t uid, uint32_t privi } static void thread_delete(struct thread *th) { - kfree(th->kernelStack_addr); - if (th->userStack_seg != 0) seg_unmap(th->userStack_seg); - th->process->threads--; if (threads == th) { threads = th->next; } else { struct thread *it = threads; - while (it->next != th && it->next != 0) it = it->next; - if (it->next == th) it->next = th->next; + while (it) { + if (it->next == th) { + it->next = th->next; + break; + } + it = it->next; + } } + if (current_thread == th) current_thread = 0; + th->process->threads--; + kfree(th->kernelStack_addr); + if (th->userStack_seg != 0) seg_unmap(th->userStack_seg); kfree(th); } static void process_delete(struct process *pr) { - struct thread *it; - while (threads != 0 && threads->process == pr) thread_delete(threads); - it = threads; - while (it != 0 && it->next != 0) { - while (it->next != 0 && it->next->process == pr) thread_delete(it->next); - it = it->next; + struct thread *it = threads; + while (it != 0) { + if (it->process == pr) { + thread_delete(it); + it = threads; + } else { + it = it->next; + } } obj_closeall(pr); - pagedir_delete(pr->pagedir); if (processes == pr) { processes = pr->next; } else { struct process *it = processes; - while (it != 0 && it->next != pr) it = it->next; - if (it != 0 && it->next == pr) it->next = pr->next; + while (it) { + if (it->next == pr) { + it->next = pr->next; + break; + } + it = it->next; + } } + pagedir_delete(pr->pagedir); kfree(pr); } diff --git a/src/library/Makefile b/src/library/Makefile index 1451c26..3d55354 100644 --- a/src/library/Makefile +++ b/src/library/Makefile @@ -8,8 +8,9 @@ LDFLAGS = -r Library = grapes.o Objects = gc/syscall.o gc/server.o \ + gm/call.o gm/call/manager.o \ gc/mem.o gc/shm.o \ - std/mutex.o std/string.o \ + std/mutex.o std/string.o std/stdio.o \ start.o all: $(Library) diff --git a/src/library/gc/server.c b/src/library/gc/server.c index 9fd1616..96c3180 100644 --- a/src/library/gc/server.c +++ b/src/library/gc/server.c @@ -47,25 +47,27 @@ void srv_handle(Server *o, int act) { md.func = rq.func; md.blocking = rq.isBlocking; md.obj = o; + md.pid = rq.pid; //get parameters for (i = 0; i < 3; i++) { md.parameters[i].type = (rq.func >> (28 - (2 * i))) & 3; switch (md.parameters[i].type) { case PT_LONG: case PT_OBJDESC: - md.parameters[i].val.i = rq.params[i]; + md.parameters[i].i = rq.params[i]; break; case PT_SHM: //all the fuss about keepShm only applies to messages. md.parameters[i].keepShm = 1; //if local memory or if nothing, do not unmap it + md.parameters[i].shmsize = rq.shmsize[i]; if (rq.params[i] == 0) { //TODO : map shm (shm manager) !!! void* p = shm_alloc(rq.shmsize[i]); - md.parameters[i].val.p = p; + md.parameters[i].p = p; if (p != 0) { request_mapShm(o->id, (size_t)p, i); md.parameters[i].keepShm = 0; //we had to map it, so mark it to be unmapped } } else { - md.parameters[i].val.p = (void*)rq.params[i]; + md.parameters[i].p = (void*)rq.params[i]; } break; } @@ -77,10 +79,15 @@ void srv_handle(Server *o, int act) { if (ret.type == PT_OBJDESC || ret.type == PT_LONG) a = ret.i; if (ret.type == PT_LONGLONG) a = (uint32_t)ret.l, b = (uint32_t)((uint64_t)ret.l >> 32); request_answer(o->id, a, b, ret.status); + for (i = 0; i < 3; i++) { + if (md.parameters[i].type == PT_SHM && md.parameters[i].p != 0) { + shm_free(md.parameters[i].p); + } + } } else { for (i = 0; i < 3; i++) { if (md.parameters[i].type == PT_SHM && md.parameters[i].keepShm == 0) { - shm_freeDel(md.parameters[i].val.p); + shm_freeDel(md.parameters[i].p); } } } @@ -156,7 +163,7 @@ method_handler getHandler(Server *o, uint32_t m) { } struct method_ret checkIfHandles(struct method_data *d) { - if (getHandler(d->obj, d->parameters[0].val.i) == 0) { + if (getHandler(d->obj, d->parameters[0].i) == 0) { return mr_long(0); } return mr_long(1); @@ -165,9 +172,9 @@ struct method_ret checkIfHandles(struct method_data *d) { struct method_ret checkIfHandlesMany(struct method_data *d) { if (d->parameters[0].type != PT_SHM) return mr_err(-1); if (d->parameters[1].type != PT_LONG) return mr_err(-1); - uint32_t *data = d->parameters[0].val.p, i; + uint32_t *data = d->parameters[0].p, i; if (data == 0) return mr_long(0); - for (i = 0; i < d->parameters[1].val.i; i++) { + for (i = 0; i < d->parameters[1].i; i++) { if (getHandler(d->obj, data[i]) == 0) return mr_long(0); } return mr_long(1); @@ -185,8 +192,8 @@ struct method_ret mr_llong(int64_t val) { return r; } -struct method_ret mr_obj(Object* obj) { - struct method_ret r; r.status = 0; r.type = PT_OBJDESC; r.i = obj->id; +struct method_ret mr_obj(Object obj) { + struct method_ret r; r.status = 0; r.type = PT_OBJDESC; r.i = obj; return r; } diff --git a/src/library/gc/shm.c b/src/library/gc/shm.c index 8077352..7f8609a 100644 --- a/src/library/gc/shm.c +++ b/src/library/gc/shm.c @@ -28,7 +28,7 @@ void* shm_alloc(size_t size) { //go through all blocks, get the one with the closest size struct shm_block *i = blocks, *block = 0; while (i) { - if (i->size >= size && i->is_hole == 1 && i->size < block->size) block = i; + if (i->size >= size && i->is_hole == 1 && (block == 0 || i->size < block->size)) block = i; i = i->next; } if (block == 0) { @@ -57,7 +57,7 @@ static void unify (struct shm_block *b) { if (b->next == 0 || b->is_hole == 0 || b->next->is_hole == 0) return; struct shm_block *n = b->next; b->size += n->size; - n->next->prev = b; + if (n->next != 0) n->next->prev = b; b->next = n->next; free(n); } diff --git a/src/library/gm/call.c b/src/library/gm/call.c new file mode 100644 index 0000000..553fbaf --- /dev/null +++ b/src/library/gm/call.c @@ -0,0 +1,34 @@ +#include <syscall.h> +#include <gm/call.h> +#include <gm/method.h> +#include <gc/shm.h> +#include <string.h> + +int c_handleCheck(_CHP, int method) { + struct user_sendrequest sr; + sr.func = M_HANDLECHECK_BIVV; + sr.a = method; + _CHC; + if (sr.errcode) return 0; + return sr.answeri; +} + +int c_handleCheckA(_CHP, int* methods, int number) { + struct user_sendrequest sr; + sr.func = M_HANDLECHECK_BMIV; + void* ptr = shm_allocNew(sizeof(int) * number); + memcpy(ptr, methods, sizeof(int) * number); + sr.a = (uint32_t)methods; + sr.b = number; + _CHC; + shm_freeDel(ptr); + if (sr.errcode) return 0; + return sr.answeri; +} + +int c_nothing(_CHP) { + struct user_sendrequest sr; + sr.func = M_NOTHING_VVVV; + _CHC; + return sr.errcode; +} diff --git a/src/library/gm/call/manager.c b/src/library/gm/call/manager.c new file mode 100644 index 0000000..4b296f7 --- /dev/null +++ b/src/library/gm/call/manager.c @@ -0,0 +1,44 @@ +#include <syscall.h> +#include <gm/call/manager.h> +#include <gm/method.h> +#include <gc/shm.h> +#include <string.h> + +Object c_open(_CHP, char *c) { + struct user_sendrequest sr; + sr.func = M_OPEN_OMVV; + void* ptr = shm_allocNew(strlen(c) + 1); + strcpy(ptr, c); + sr.a = (uint32_t)ptr; + _CHC; + shm_freeDel(ptr); + if (sr.errcode) return -1; + return sr.answeri; +} + +Object open(char *c) { + return c_open(1, 1, c); +} + +void c_registerSvc(char *name) { + struct user_sendrequest sr; + sr.func = M_REGISTERSVC_VMOV; + void* ptr = shm_allocNew(strlen(name) + 1); + strcpy(ptr, name); + sr.a = (uint32_t)ptr; + sr.b = 0; + send_msg(1, &sr); + shm_freeDel(ptr); +} + +void c_logSvc(char *log, int level) { + struct user_sendrequest sr; + sr.func = M_LOGSVC_VMIV; + void* ptr = shm_allocNew(strlen(log) + 1); + if (ptr == 0) return; + strcpy(ptr, log); + sr.a = (uint32_t)ptr; + sr.b = level; + request(1, &sr); + shm_freeDel(ptr); +} diff --git a/src/library/std/stdio.c b/src/library/std/stdio.c new file mode 100644 index 0000000..3b24da1 --- /dev/null +++ b/src/library/std/stdio.c @@ -0,0 +1,51 @@ +#include <stdlib.h> + +void printk_int(int number) { + if (number == 0) { + printk("0"); + return; + } + int negative = 0; + if (number < 0) { + negative = 1; + number = 0 - number; + } + int order = 0, temp = number, i; + char numbers[] = "0123456789"; + while (temp > 0) { + order++; + temp /= 10; + } + + char *s, *r; + s = malloc(order + (negative ? 2 : 1)); + if (negative) { + s[0] = '-'; + r = s + 1; + } else { + r = s; + } + + for (i = order; i > 0; i--) { + r[i - 1] = numbers[number % 10]; + number /= 10; + } + r[order] = 0; + printk(s); + free(s); +} + +void printk_hex(unsigned v) { + char s[11] = {'0', 'x', 0}; + + int i; + + char hexdigits[] = "0123456789ABCDEF"; + + for (i = 0; i < 8; i++) { + s[i + 2] = (hexdigits[v >> 28]); + v = v << 4; + } + s[11] = 0; + printk(s); +} diff --git a/src/library/std/string.c b/src/library/std/string.c index 869256a..4c374ad 100644 --- a/src/library/std/string.c +++ b/src/library/std/string.c @@ -6,6 +6,46 @@ int strlen(const char *str) { return i; } +char *strchr(const char *str, char c) { + while (*str) { + if (*str == c) return (char*)str; + str++; + } + return NULL; +} + +char *strcpy(char *dest, const char *src) { + memcpy(dest, src, strlen(src) + 1); + return (char*)src; +} + +char *strdup(const char *src) { + char* ret = malloc(strlen(src) + 1); + if (ret == NULL) return ret; + strcpy(ret, src); + return ret; +} + +char *strcat(char *dest, const char *src) { + char *dest2 = dest; + dest2 += strlen(dest) - 1; + while (*src) { + *dest2 = *src; + src++; + dest2++; + } + *dest2 = 0; + return dest; +} + +int strcmp(const char *s1, const char *s2) { + while ((*s1) && (*s1 == *s2)) { + s1++; + s2++; + } + return (* (unsigned char*)s1 - *(unsigned char*)s2); +} + void *memcpy(void *vd, const void *vs, int count) { uint8_t *dest = (uint8_t*)vd, *src = (uint8_t*)vs; uint32_t f = count % 4, n = count / 4, i; diff --git a/src/modules/manager/main.c b/src/modules/manager/main.c index 9e23097..d211831 100644 --- a/src/modules/manager/main.c +++ b/src/modules/manager/main.c @@ -2,20 +2,107 @@ #include <gc/mem.h> #include <gc/server.h> #include <gm/method.h> +#include <gm/call/manager.h> +#include <string.h> +char *loglevels[] = {"Critical", "Error", "Warning", "Notice", "Status", "Debug"}; +int loglevel = LL_DEBUG; + +struct service { + char* name; + int pid; + Object obj; + struct service *next; +}; + +struct service *services = 0; + +//************************ FUNCTIONS THAT DO STUFF ******************** +void logsvc(int pid, char* log, int level) { + if (level > loglevel || level < 0) return; + struct service *svc = services; + while (svc) { + if (svc->pid == pid) break; + svc = svc->next; + } + if (svc == 0) { + printk("[log:??] "); + } else { + printk("[log:"); printk(svc->name); printk("] "); + } + printk(loglevels[level]); printk(": "); + printk(log); printk("\n"); +} + +void registersvc(int pid, char* name, Object descriptor) { + struct service *svc = malloc(sizeof(struct service)); + svc->name = strdup(name); + svc->pid = pid; + svc->obj = descriptor; + svc->next = services; + services = svc; + char msg[100] = "Service registered: "; + strcat(msg, svc->name); + logsvc(1, msg, LL_NOTICE); +} + +//****************************** HANDLING METHODS ON MAIN OBJECT ***************** struct method_ret handle_nothing(struct method_data *d) { - if (d->blocking) printk("[manager] Received a {nothing} request.\n"); - else printk("[manager] Received a {nothing} message.\n"); + if (d->blocking) logsvc(1, "Received a {nothing} request.", LL_DEBUG); + else logsvc(1, "Received a {nothing} message.", LL_DEBUG); + return mr_void(); +} + +struct method_ret handle_open(struct method_data *d) { + CHKSSTR(d, 0); + char *svc = d->parameters[0].p; + printk("open: "); printk(svc); printk("\n"); + char *sep, *res; + sep = strchr(svc, ':'); + if (sep != 0) *sep = '0'; + struct service *s = services; + while (s) { + if (strcmp(s->name, svc) == 0) break; + s = s->next; + } + if (s == 0) return mr_err(-2); + if (sep == 0) { + return mr_obj(s->obj); + } else { + *sep = ':'; + res = sep + 1; + // open service svc, ressource res + Object r = c_open(s->obj, 1, res); + if (r == -1) return mr_err(-3); + return mr_obj(r); + } +} + +struct method_ret handle_registersvc(struct method_data *d) { + CHKSSTR(d, 0); + if (d->parameters[1].i == 0) return mr_err(-1); + registersvc(d->pid, d->parameters[0].p, d->parameters[1].i); + return mr_void(); +} + +struct method_ret handle_logsvc(struct method_data *d) { + CHKSSTR(d, 0); + logsvc(d->pid, d->parameters[0].p, d->parameters[1].i); return mr_void(); } int main() { - printk("[manager] Manager module configuring...\n"); - Server *mgr = srv_get(0); + logsvc(1, "Manager module configuring...", LL_NOTICE); + registersvc(1, "manager", 0); + Server *mgr = srv_get(0); srv_addHandler(mgr, M_NOTHING_VVVV, handle_nothing); - printk("[manager] Manager module configured : starting request handling.\n"); + srv_addHandler(mgr, M_OPEN_OMVV, handle_open); + srv_addHandler(mgr, M_REGISTERSVC_VMOV, handle_registersvc); + srv_addHandler(mgr, M_LOGSVC_VMIV, handle_logsvc); + + logsvc(1, "Manager module configured : starting request handling.", LL_STATUS); srv_handle(mgr, HA_LOOP); printk("[manager] Manager EPIC FAIL.\n"); diff --git a/src/modules/test/main.c b/src/modules/test/main.c index 148490b..88242e5 100644 --- a/src/modules/test/main.c +++ b/src/modules/test/main.c @@ -2,60 +2,46 @@ #include <gc/mem.h> #include <gc/server.h> #include <gm/method.h> +#include <gm/call.h> +#include <gm/call/manager.h> +#include <stdlib.h> #define FACTOR 4 -int obj = -1; - struct method_ret nulhandle(struct method_data *d) { - if (d->blocking) printk("[test:2?] Handling a request.\n"); - else printk("[test:2?] Handling a message.\n"); + if (d->blocking) c_logSvc("Handling a nothing request.", LL_STATUS); + else c_logSvc("Handling a nothing message.", LL_STATUS); return mr_void(); } +struct method_ret openhandle(struct method_data *d) { + CHKSSTR(d, 0); + printk("test.open: "); printk(d->parameters[0].p); printk("\n"); + return mr_err(-1); +} + void thread2(void* d) { - printk("[test:2] Creating new object...\n"); - Server *s = srv_create(); + Server *s = srv_get(0); srv_addHandler(s, M_NOTHING_VVVV, nulhandle); - obj = s->id; + srv_addHandler(s, M_OPEN_OMVV, openhandle); while (1) { - printk("[test:2] Waiting for a request...\n"); + c_logSvc("{2} Waiting for a request on main object...", LL_STATUS); srv_handle(s, HA_WAIT); } } int main() { - int i; - - printk("[test:1] Hi world !\n"); - printk("[test:1] Creating new thread...\n"); + c_logSvc("Hi world from unregistered test module !", LL_NOTICE); + c_registerSvc("test"); + c_logSvc("Creating new thread...", LL_STATUS); thread_new(thread2, 0); - while (obj == -1); - printk("[test:1] Object was created. Sending request...\n"); - struct user_sendrequest sr; - sr.func = M_NOTHING_VVVV; - request(obj, &sr); - printk("[test:1] Got answer. Now sending request to manager...\n"); - request(1, &sr); - printk("[test:1] And now a message to manager...\n"); - send_msg(1, &sr); + c_logSvc("{1} Sending a test message to manager", LL_STATUS); + c_nothing(1, 0); - printk("[test:1] testing malloc and free..."); - int* v = malloc(10 * sizeof(int)); - if (v == 0) printk("zero"); - int* vv = malloc(10 * sizeof(int)); - for (i = 0; i < 10; i++) { v[i] = i * 1243; } - for (i = 0; i < 10; i++) { vv[i] = i * 2; } - for (i = 0; i < 10; i++) { - if (v[i] != i * 1243) printk("FAIL"); - } - for (i = 0; i < 10; i++) { - if (vv[i] != i * 2) printk("fail"); - } - free(v); free(vv); - printk("nothing bad happened :)\n"); + Object t = open("test"); + printk("Open 'test' : "); printk_int(t); printk("\n"); - printk("[test:1] HAHA !!! Death of [test] in 1 seconds!\n"); - thread_sleep(1000); + c_logSvc("{1} Thread now sleeping...", LL_WARNING); + while (1) thread_sleep(1000); return 0; } |