UserIPC.cpp inc/UserIPC.hpp @@ -1,6 +1,7 @@ #include <Syscall.hpp> #include <Akari.hpp> #include <UserCalls.hpp> +#include <UserIPC.hpp> #include <Descriptor.hpp> Syscall::Syscall(): _syscalls_assigned(0) { @@ -13,19 +14,22 @@ Syscall::Syscall(): _syscalls_assigned(0) { addSyscall(4, (void *)&User::irqWait); addSyscall(5, (void *)&User::irqListen); addSyscall(6, (void *)&User::panic); - addSyscall(7, (void *)&User::registerName); - addSyscall(8, (void *)&User::registerStream); - addSyscall(9, (void *)&User::exit); - addSyscall(10, (void *)&User::obtainStreamWriter); - addSyscall(11, (void *)&User::obtainStreamListener); - addSyscall(12, (void *)&User::readStream); - addSyscall(13, (void *)&User::readStreamUnblock); - addSyscall(14, (void *)&User::writeStream); - addSyscall(15, (void *)&User::defer); - addSyscall(16, (void *)&User::malloc); - addSyscall(17, (void *)&User::free); - addSyscall(18, (void *)&User::memcpy); - addSyscall(19, (void *)&User::registerQueue); + addSyscall(7, (void *)&User::exit); + addSyscall(8, (void *)&User::defer); + addSyscall(9, (void *)&User::malloc); + addSyscall(10, (void *)&User::free); + addSyscall(11, (void *)&User::memcpy); + + addSyscall(12, (void *)&User::IPC::registerName); + + addSyscall(13, (void *)&User::IPC::registerStream); + addSyscall(14, (void *)&User::IPC::obtainStreamWriter); + addSyscall(15, (void *)&User::IPC::obtainStreamListener); + addSyscall(16, (void *)&User::IPC::readStream); + addSyscall(17, (void *)&User::IPC::readStreamUnblock); + addSyscall(18, (void *)&User::IPC::writeStream); + + addSyscall(19, (void *)&User::IPC::registerQueue); } u8 Syscall::versionMajor() const { return 0; } Syscall.cpp @@ -118,6 +118,11 @@ void ATAProcess() { if (!SYSCALL_BOOL(syscall_registerQueue("command"))) syscall_panic("could not register system.io.ata:command"); + + syscall_puts("ATA driver entering loop\n"); + while (true) { + + } } void ata_read_data(u32 sector_offset, u16 offset, u32 length, u8 *buffer) TmpATA.cpp @@ -73,10 +73,10 @@ void KeyboardProcess() { if (!SYSCALL_BOOL(syscall_registerName("system.io.keyboard"))) syscall_panic("could not register system.io.keyboard"); - if (!SYSCALL_BOOL(syscall_registerNode("input"))) + if (!SYSCALL_BOOL(syscall_registerStream("input"))) syscall_panic("could not register system.io.keyboard:input"); - u32 writer = syscall_obtainNodeWriter("system.io.keyboard", "input", true); + u32 writer = syscall_obtainStreamWriter("system.io.keyboard", "input", true); if (writer == (u32)-1) { // This shouldn't be possible if we just initialised the damn thing. syscall_panic("could not obtain writer on system.io.keyboard:input"); @@ -127,7 +127,7 @@ void KeyboardProcess() { syscall_putc(scancode); // Now actually dispatch this. - syscall_writeNode("system.io.keyboard", "input", writer, (const char *)&scancode, 1); + syscall_writeStream("system.io.keyboard", "input", writer, (const char *)&scancode, 1); } if (mustUpdateLEDs) { TmpKb.cpp @@ -5,7 +5,7 @@ static char *getline(u32 in) { char *kbbuf = (char *)syscall_malloc(cs); while (true) { - u32 incoming = syscall_readNode("system.io.keyboard", "input", in, kbbuf + n, 1); + u32 incoming = syscall_readStream("system.io.keyboard", "input", in, kbbuf + n, 1); syscall_putc(kbbuf[n]); if (kbbuf[n] == '\n') break; @@ -60,7 +60,7 @@ int strpos(const char *haystack, const char *needle) { void ShellProcess() { u32 stdin = (u32)-1; while (stdin == (u32)-1) { - stdin = syscall_obtainNodeListener("system.io.keyboard", "input"); + stdin = syscall_obtainStreamListener("system.io.keyboard", "input"); } syscall_puts("\nstdin is 0x"); TmpShell.cpp @@ -6,7 +6,7 @@ #include <Console.hpp> #include <Tasks.hpp> #include <Syscall.hpp> - +#include <BlockingCall.hpp> namespace User { void putc(char c) { @@ -49,52 +49,6 @@ namespace User { AkariPanic(s); } - bool registerName(const char *name) { - Symbol sName(name); - if (Akari->tasks->registeredTasks->hasKey(sName)) - return false; - - (*Akari->tasks->registeredTasks)[sName] = Akari->tasks->current; - Akari->tasks->current->registeredName = sName; - return true; - } - - bool registerStream(const char *name) { - Symbol sNode(name); - if (!Akari->tasks->current->registeredName) { - // TODO: just kill the process, don't kill the system. - // TODO: is this correct behaviour? Or could we have registered nodes - // on no particular name? Why not?.. think about it. - AkariPanic("name not registered - cannot register node"); - } - - if (Akari->tasks->current->streamsByName->hasKey(name)) { - AkariPanic("node already registered - cannot register atop it"); - } - - Tasks::Task::Stream *target = new Tasks::Task::Stream(); - - (*Akari->tasks->current->streamsByName)[sNode] = target; - return true; - } - - bool registerQueue(const char *name) { - Symbol sNode(name); - if (!Akari->tasks->current->registeredName) { - // TODO - AkariPanic("name not registered - cannot register node"); - } - - if (Akari->tasks->current->streamsByName->hasKey(name)) { - AkariPanic("node already registered - cannot register atop it"); - } - - Tasks::Task::Queue *target = new Tasks::Task::Queue(); - - (*Akari->tasks->current->queuesByName)[sNode] = target; - return true; - } - void exit() { Akari->syscall->returnToNextTask(); // Find the Task* which refers to Akari->tasks->current, and get it to skip it. @@ -113,65 +67,6 @@ namespace User { // Gone! XXX what happens when the last task exists!? Everything probably goes to hell ... } - static inline Tasks::Task::Stream *getStream(const char *name, const char *node) { - Symbol sName(name), sNode(node); - - if (!Akari->tasks->registeredTasks->hasKey(sName)) - return 0; - - Tasks::Task *task = (*Akari->tasks->registeredTasks)[sName]; - if (!task->streamsByName->hasKey(sNode)) - return 0; - - return (*task->streamsByName)[sNode]; - } - - u32 obtainStreamWriter(const char *name, const char *node, bool exclusive) { - Tasks::Task::Stream *target = getStream(name, node); - if (!target) return -1; - return target->registerWriter(exclusive); - } - - u32 obtainStreamListener(const char *name, const char *node) { - Tasks::Task::Stream *target = getStream(name, node); - if (!target) return -1; - return target->registerListener(); - } - - // Keeping in mind that `buffer''s data probably isn't asciz. - u32 readStream_impl(const char *name, const char *node, u32 listener, char *buffer, u32 n, bool block) { - ReadCall c(name, node, listener, buffer, n); - u32 r = c(); - if (!block || !c.shallBlock()) - return r; - - // block && r.shallBlock() - // Block until such time as some data is available. - Tasks::Task::Stream::Listener *l = c.getListener(); - - Akari->tasks->current->userWaiting = true; - Akari->tasks->current->userCall = new ReadCall(c); - l->hook(Akari->tasks->current); - Akari->syscall->returnToNextTask(); - return 0; - } - - u32 readStream(const char *name, const char *node, u32 listener, char *buffer, u32 n) { - return readStream_impl(name, node, listener, buffer, n, true); - } - - u32 readStreamUnblock(const char *name, const char *node, u32 listener, char *buffer, u32 n) { - return readStream_impl(name, node, listener, buffer, n, false); - } - u32 writeStream(const char *name, const char *node, u32 writer, const char *buffer, u32 n) { - Tasks::Task::Stream *target = getStream(name, node); - if (!target || !target->hasWriter(writer)) return -1; - - // We do have a writer, so we can go ahead and write to all listeners. - target->writeAllListeners(buffer, n); - return n; // what else?! - } - void defer() { Akari->syscall->returnToNextTask(); } @@ -194,33 +89,5 @@ namespace User { *w++ = *r++; return dest; } - - ReadCall::ReadCall(const char *name, const char *node, u32 listener, char *buffer, u32 n): - _listener(&getStream(name, node)->getListener(listener)), _buffer(buffer), _n(n) - { } - - Tasks::Task::Stream::Listener *ReadCall::getListener() const { - return _listener; - } - - u32 ReadCall::operator ()() { - if (_n == 0) { - _wontBlock(); - return 0; - } - - u32 len = _listener->length(); - if (len == 0) { - _willBlock(); - return 0; - } - - if (len > _n) len = _n; - POSIX::memcpy(_buffer, _listener->view(), len); - _listener->cut(len); - - _wontBlock(); - return len; - } } UserCalls.cpp @@ -51,16 +51,19 @@ DEFN_SYSCALL0(getProcessId, 3); DEFN_SYSCALL0(irqWait, 4); DEFN_SYSCALL1(irqListen, 5, u32); DEFN_SYSCALL1(panic, 6, const char *); -DEFN_SYSCALL1(registerName, 7, const char *); -DEFN_SYSCALL1(registerNode, 8, const char *); -DEFN_SYSCALL0(exit, 9); -DEFN_SYSCALL3(obtainNodeWriter, 10, const char *, const char *, bool); -DEFN_SYSCALL2(obtainNodeListener, 11, const char *, const char *); -DEFN_SYSCALL5(readNode, 12, const char *, const char *, u32, char *, u32); -DEFN_SYSCALL5(readNodeUnblock, 13, const char *, const char *, u32, char *, u32); -DEFN_SYSCALL5(writeNode, 14, const char *, const char *, u32, const char *, u32); -DEFN_SYSCALL0(defer, 15); -DEFN_SYSCALL1(malloc, 16, u32); -DEFN_SYSCALL1(free, 17, void *); -DEFN_SYSCALL3(memcpy, 18, void *, const void *, u32); +DEFN_SYSCALL0(exit, 7); +DEFN_SYSCALL0(defer, 8); +DEFN_SYSCALL1(malloc, 9, u32); +DEFN_SYSCALL1(free, 10, void *); +DEFN_SYSCALL3(memcpy, 11, void *, const void *, u32); + +DEFN_SYSCALL1(registerName, 12, const char *); + +DEFN_SYSCALL1(registerStream, 13, const char *); +DEFN_SYSCALL3(obtainStreamWriter, 14, const char *, const char *, bool); +DEFN_SYSCALL2(obtainStreamListener, 15, const char *, const char *); +DEFN_SYSCALL5(readStream, 16, const char *, const char *, u32, char *, u32); +DEFN_SYSCALL5(readStreamUnblock, 17, const char *, const char *, u32, char *, u32); +DEFN_SYSCALL5(writeStream, 18, const char *, const char *, u32, const char *, u32); + DEFN_SYSCALL1(registerQueue, 19, const char *); UserGates.cpp @@ -2,9 +2,7 @@ #define __USER_CALLS_HPP__ #include <arch.hpp> -#include <Symbol.hpp> #include <Tasks.hpp> -#include <BlockingCall.hpp> namespace User { void putc(char c); @@ -14,33 +12,11 @@ namespace User { void irqWait(); void irqListen(u32 irq); void panic(const char *s); - bool registerName(const char *name); - bool registerStream(const char *name); - bool registerQueue(const char *name); void exit(); - u32 obtainStreamWriter(const char *name, const char *node, bool exclusive); - u32 obtainStreamListener(const char *name, const char *node); - u32 readStream(const char *name, const char *node, u32 listener, char *buffer, u32 n); - u32 readStreamUnblock(const char *name, const char *node, u32 listener, char *buffer, u32 n); - u32 writeStream(const char *name, const char *node, u32 writer, const char *buffer, u32 n); void defer(); void *malloc(u32 n); void free(void *p); void *memcpy(void *dest, const void *src, u32 n); - - class ReadCall : public BlockingCall { - public: - ReadCall(const char *name, const char *node, u32 listener, char *buffer, u32 n); - - Tasks::Task::Stream::Listener *getListener() const; - - u32 operator ()(); - - protected: - Tasks::Task::Stream::Listener *_listener; - char *_buffer; - u32 _n; - }; } #endif inc/UserCalls.hpp @@ -19,18 +19,21 @@ DECL_SYSCALL0(getProcessId); DECL_SYSCALL0(irqWait); DECL_SYSCALL1(irqListen, u32); DECL_SYSCALL1(panic, const char *); -DECL_SYSCALL1(registerName, const char *); -DECL_SYSCALL1(registerNode, const char *); DECL_SYSCALL0(exit); -DECL_SYSCALL3(obtainNodeWriter, const char *, const char *, bool); -DECL_SYSCALL2(obtainNodeListener, const char *, const char *); -DECL_SYSCALL5(readNode, const char *, const char *, u32, char *, u32); -DECL_SYSCALL5(readNodeUnblock, const char *, const char *, u32, char *, u32); -DECL_SYSCALL5(writeNode, const char *, const char *, u32, const char *, u32); DECL_SYSCALL0(defer); DECL_SYSCALL1(malloc, u32); DECL_SYSCALL1(free, void *); DECL_SYSCALL3(memcpy, void *, const void *, u32); + +DECL_SYSCALL1(registerName, const char *); + +DECL_SYSCALL1(registerStream, const char *); +DECL_SYSCALL3(obtainStreamWriter, const char *, const char *, bool); +DECL_SYSCALL2(obtainStreamListener, const char *, const char *); +DECL_SYSCALL5(readStream, const char *, const char *, u32, char *, u32); +DECL_SYSCALL5(readStreamUnblock, const char *, const char *, u32, char *, u32); +DECL_SYSCALL5(writeStream, const char *, const char *, u32, const char *, u32); + DECL_SYSCALL1(registerQueue, const char *); #define SYSCALL_BOOL(x) ((bool)((x) & 0xFF)) inc/UserGates.hpp eaed73dbbcc8cfb778edec21e8642a29cd4ce933 Arlen Cuss celtic@sairyx.org http://github.com/celtic/akari/commit/f1431c27f62bd35caee306d3c13c7aeae272d93c f1431c27f62bd35caee306d3c13c7aeae272d93c 2009-11-06T22:26:51-08:00 2009-11-06T22:26:51-08:00 Reworking the way I'm organising system calls, they're all getting a bit cramped in there. Now it doesn't work, fuck it. 7fdcc2f8caef069104b2e861884c9cf0652a7cb1 Arlen Cuss celtic@sairyx.org