| Age | Commit message (Collapse) | Author |
|---|
|
|
|
+ Slightly unsure if it should be a syscall, or if assign would be
enough. Also, which thread should run in a fork/spawn? For now, old
thread, though this might increase latency. Or add swap flag to these
calls?
|
|
|
|
+ Prefer over unixy fork/exec for speed since I don't want to support
cow. Shell redirection should be done with env server and cooperating
libc.
|
|
+ Skip cow for now, maybe implement later but try to keep things simple.
|
|
|
|
+ Multiple notify signals at the same time, or queued ones waiting for
ipc_req/fwd to finish would require a notify stack of some kind, which
is maybe too complex for my liking. Not impossible by any means, but I
want to keep things simple.
Let's say a client wants the server to do some async operation. First,
the client calls ipc_req to inform the server that it would like the
operation to be done. The server sets this task in some work queue or
whatever, and returns to the client as quickly as possible. Later on,
when the task is finished, the server does a ipc_req to the client,
with data about what was just finished. The client is responsible for
noting this data down somewhere, either reacting to the operation
directly in the callback, or calling ipc_notify to the thread that
requested the operation. Other possible notifications at the same time
should be handled at the same time, whichever way the client wants to
handle them.
Note that ipc_notify triggers only when the thread it targets is in
its base state, i.e. not doing an ipc_req. This makes things a bit
easier.
|
|
|
|
+ Now to actually start implementing shit. :)
|
|
|
|
+ In total, a syscall is built up of 6 values, with the first being the
syscall number. Symmetrically, the first value is now a status and the
following five values return "values". This allows us to cram in more
info into the ipc_* functions. The performance difference is
absolutely minimal, at least from my testing in qemu.
|
|
|
|
+ Note that it is NOT intended for end user usage, just for debugging.
|
|
|
|
|
|
|
|
+ Does not mean documentation is done, but it's a nice little
achievement nonetheless.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
+ Essentially, separate root process and remote procedure call handling.
I really should write down some documentation so I don't forget, but
essentially: All threads share a common process virtual memory, and
when a thread wants to make an rpc, it switches over to its own rpc
vmem space that is linked to the remote process.
|
|
|
|
|
|
|
|
|
|
The output is close enough, and I like that uncrustify is a third-party
tool, so people can install a single tool for formatting instead of
having to lug around a whole toolchain. I fully expect to have to add
settings to uncrustify.conf, but let's see how this goes.
|
|
|
|
+ Next step, start documenting contents of each file.
|
|
|
|
|
|
+ next up would probably be to start working on process/thread
relationships, largely as documented. Still not entirely sure about
how I want to handle fork, but I suppose I might figure it out at some
point.
|
|
|
|
+ Should document this better but essentially a server requests a shared
buffer, and chan then share this buffer to a thread. Freeing the
buffer is done through normal means. MR_SHARED is used for buffers
that are shared, and MR_OWNED tells whoever is freeing that region
that it is allowed to free the physical memory behind the shared
buffer.
|
|
|
|
|
|
|
|
|
|
+ GCC seems to provide this even on 32bit platforms, though I should
really check.
|
|
|
|
|
|
|
|
|
|
+ Added automated categories to debugging, bug/info/warn/error etc. Now
I should just try to use them here and there :D
|
|
+ Mainly just moving stuff out or arch/riscv/ that should be handled in
common/
+ Prepared separate process stack/call stack for server callbacks, rest
to be implemeted soon ish
|
|
|
