sleep syscall !!! (blocks and shit)
emulate blocking read/write's etc
writev/readv/recvmsg/sendmsg

--



lots of shit.. one day i'll try to compile it
	* heh.. well it kinda runs

!!! convert circular lists to non circular (so memcpy on mutex/thread etc
doesnt screw up)
	* fixed by using pointers to thread structures, not stoppers

the wakeup/wait stuff is getting a bit messy (again). rewrite wait.c 

!!! thread needs _list_ of rwlock's it owns.. so it can do recursive read
locks for multiple locks

rwlock's starve
in net.c check for timeouts/ready etc
!!!! select needs to be hooked
	use fdsets in the io_t
	* done

implement semaphores
	* done

the scheduler is compltely fucked up...!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	* fixed

ok.. how the fuck do i force a yield now? signal handler?
	* silly.. fixed

get the code to actually use cancel.c

need to make sure the run queue is correctly locked so that the io stuff
doesnt cause races
	* fixed

ok.. we need BOTH manager and initial thread. manager thread acts like
an idle loop.. initial thread is for the main code etc.
	* ok.. done.. but its not exactly neat.. not exactly crap either,
	but it sure needs a clean

ok.. the scheduling is complete shit and fragile as hell.. probably
because i dont really know what i'm doing
	* fixed

make the initial thread a static initialization.. ie, no malloc
	* done

dont use malloc for stack/thread descriptor.. mmap 1 area and use it for
both
	* done

create.c was using some shitty code for setting up stack etc
	* fixed

have to move over the io code soon i think..

should i bother with time slicing for scheduling?  i guess i have to if i
want this to be a complete replacement.. but what am i intending to use
this code for anyway? just the ml? just for myself? for everyone?

if we dont timeslice, when do we schedule?  obviously blocking io should
force a schedule, but what about things like mutex locking/unlocking etc?

the code isnt too clean in a few places.. have to organize shit later i think.

the initial thread isnt thread safe
what we need to do, is forgot about clone for the time being, and make the
initital thread just a regular user thread..  saves us 1 process slot,
and makes us portable (no kernel assistance somewhat) for the time being..
which means we would only use 2 process slots when we start using completion
ports thingo's for io handling etc.
	* ok.. this is done.. i was getting some segfaults with a certain
	case of code, but now i cant reproduce it :(
	anyway.. everything is 1 process now.. dont use clone anywhere :)

***** the bug i describe is the stack handling for manager thread etc
	* all this has been fixed.. though its still not very clean

manager code now uses some arch specific stuff for the initital thread
context.. fix this one day

the wakeup shit isnt exactly solid.. rewrite it once its thought out a bit
better
	* mostly fixed
mutex's are broken or something.. if u yield in a locked region
	all of this is completely broken
	* mostly fixed

need locking on the manager/main thread etc
	* a little done on the running_queue list

use 2 types of list.. 1 circular for the running_queue, and a regular
one for wait queues..
	this is all really screwed up

sync the initialization for manager threads
manager.c should move arch specific into context.c etc
wait.c and manager.c share some stuff.. i dont like this.
