8 years agoFixes bug with uthread migration
Barret Rhoden [Tue, 25 Sep 2012 23:35:17 +0000 (16:35 -0700)]
Fixes bug with uthread migration

We were calling functions in uthread_pause that used TLS.  Instead of
making that illegal, I just cut down the time we're in another vcore's
TLS to a very small, controlled region.

8 years agoFixes bug where syscalls were completed twice
Barret Rhoden [Tue, 25 Sep 2012 23:03:02 +0000 (16:03 -0700)]
Fixes bug where syscalls were completed twice

When proc_yield() failed, the syscall would be completed twice.  When
that vcore was preempted and restarted on another core (due to a
change_to, for instance), after the first completion, the vcore would
return up the stack.  When the second completion hits, the kernel would
clobber a small part of the stack (syscalls are usually on the user
stack), which would have disasterous effects (looked like registers were
getting clobbered).

8 years agoUCQ debug code
Barret Rhoden [Tue, 25 Sep 2012 23:00:56 +0000 (16:00 -0700)]
UCQ debug code

Depending on what you want, you'll probably need to update test_ucq().
As is, you can only run it, then reboot.  It's a little better at
testing chains, and we now have some debug helpers (call with kfunc) to
get a better peak at a ucq.

8 years agoFixes preemption handling bug
Barret Rhoden [Wed, 5 Sep 2012 23:48:58 +0000 (16:48 -0700)]
Fixes preemption handling bug

If a vcore comes up while another vcore is stealing its uthread, it
needs to check for preemptions.  There are a bunch of ways to do this.
The old way was wrong, since it assumed the preempt_ev_q had an actual
mbox, which it wasn't.  Given our current preempt_ev_q style, we want to
check our public mbox for any preempt-msg-spam, which we'd get if we
were the last core around.

Note this might not be ideal - we still have a lot of messages being
sent, and we might be able to cut that down by using a different style.
For now, it fixes the bug.

8 years agoFixes list management bug in the ksched
Barret Rhoden [Wed, 16 May 2012 20:59:14 +0000 (13:59 -0700)]
Fixes list management bug in the ksched

A poorly timed death callback was corrupting lists by removing the dying
proc from the primary list twice.  (If death happened while the dying
proc was being serviced by __run_mcp_ksched()).

Also gets rid of the "it must be on a list, but i don't know which one"
style of list removal.

8 years agoProc code locks before disabling IRQs
Barret Rhoden [Mon, 14 May 2012 22:08:09 +0000 (15:08 -0700)]
Proc code locks before disabling IRQs

While we cannot grab the lock with interrupts off, we *can* disable
after grabbing the lock, but only under certain circumstances.  This is
because we send the kmsgs with the lock held.  Once we hold the lock, we
know no one will send proc mgmt kmsgs except us.  And it is really
important that we don't send any in these functions.  (imagine trying to
do a __preempt, when you send something to your own core and then try to
__map_vcore, and never get the message).

Also note that we must use immediate messages (which we've been doing
for a while now).  If we didn't use immediate kmsgs for __preempt,
someone (for instance) yielding or change_to-ing would spin on the lock
til they got the lock, but would never get the message since the lock
holder was waiting on them to do the __preempt.

Btw, in case it wasn't clear, the lock holder is spinning in
__map_vcore(), which is where we wait on the completion of the __preempt

8 years agoEnsures IRQs are enabled when proc_destroy()ing
Barret Rhoden [Mon, 14 May 2012 22:00:49 +0000 (15:00 -0700)]
Ensures IRQs are enabled when proc_destroy()ing

The main reason is that irqs need to be on when grabbing the proclock.
There are some deadlock scenarios where a __preempt (or even __death)
kmsg is sent with the lock held to a core, but if that core has irqs
disabled, it won't process the message (circular waiting, etc).

While I could make proc_destroy() enable irqs, its really up to the
calling code to do that.  I put in asserts where they shouldn't be
disabled, and otherwise turned them on manually.  This mostly applies to
trap handling code.  Note we can't just turn on IRQs immediately - each
case needs to do it where it is possible (preferably sooner than later),
such as after reading cr2() in x86's PF handler.

8 years agoDebug code to see remote kmsgs
Barret Rhoden [Mon, 14 May 2012 21:55:04 +0000 (14:55 -0700)]
Debug code to see remote kmsgs

Mostly useful for resolving deadlocks - you can see what kmsgs are on
remote cores.  It won't deal with races (though I can build that in if
we want).

The easiest way to use it on x86 is to "trace coretf coreid", since I
built it in the NMI handler.  Or you can kfunc print_kmsgs 0xcoreid
(remember, kfunc deals with hex!).

8 years agoLock ordering and ksched callbacks
Barret Rhoden [Mon, 14 May 2012 20:43:24 +0000 (13:43 -0700)]
Lock ordering and ksched callbacks

For now, there is no ordering between the proc lock and the ksched lock.
This commit revises a bunch of the scheduler callbacks (all clearly
prefixed with __sched).  These CBs can be triggered from lots of places,
specifically any proc code, any event code, and any code that kills a
process (like a PF handler!).

Since these grab locks, we needed to make the ksched let go of its lock
before calling into proc/event code (preempt_core() triggers events,
among other things).

This also moves the proc functions (like destroy) back into proc code,
since we no longer need to lock in the ksched before calling proc code.

We also can get rid of the 'ignore_next_idle'.  For now, we just wait
til the core has been given back in __core_req (no deadlock now, just a
race), instead of knowing it will be idle soon and circumventing the CB.
It's a toss-up between these two solutions.

8 years ago__core_request no longer locks and calls proc code
Barret Rhoden [Thu, 10 May 2012 02:18:26 +0000 (19:18 -0700)]
__core_request no longer locks and calls proc code

Part of a move to make the ksched lock not lock-ordered before the proc

__core_req needs to be careful about how things change when it unlocks.
for instance, there might be callbacks for cores yielding or procs
dying, or someone might have called provision_core().  I think I've
covered the cases, but it's a bit fragile.

Also note that I'm relying on __core_req being called once at a time
only (specifically, that there are no other preemptors or allocators).
The poke_tracker gives me that.  (That, and that __core_req is only
called from within the poke).

8 years agoMCP ksched doesn't need to hold the lock forever
Barret Rhoden [Wed, 9 May 2012 23:03:15 +0000 (16:03 -0700)]
MCP ksched doesn't need to hold the lock forever

__core_request() can now let go of the ksched lock.  We only have that
lock held in __run_mcp_ksched() when we need to muck with things the
lock explicitly protects: proc list integrity and membership in this

8 years agoPost-and-poke style sync for the ksched
Barret Rhoden [Wed, 9 May 2012 02:45:27 +0000 (19:45 -0700)]
Post-and-poke style sync for the ksched

Might change some of the details of the "poke-style", but I definitely
want at least a generic version of it (and all of its mb()s) to be

This is the same style of sync used in vcore_request(), though that one
is built in directly.

Note that we still use the ksched lock within in poke func - all this
commit does is create the poke style and use it to trigger the sched
mcp.  I'll deal with the lock holding shortly.

8 years agoFixes up amt_wanted/amt_granted in __core_request
Barret Rhoden [Sat, 5 May 2012 05:50:18 +0000 (22:50 -0700)]
Fixes up amt_wanted/amt_granted in __core_request

I considered holding the proclock the entire time, and it's actually
safe to do so (we make sure we don't preempt the proc we are trying to
give the core to, which would DL).  But this way, we don't sit on the
lock forever, and only do it when we need to.  Now we're just a bit more
clear about things.  (It wasn't clear before, and was a potential issue
when hunting a brutal bug).

Oh, and this was not fixing up amt_wanted like it thought it was.

8 years agoSpinlock depth checking
Barret Rhoden [Fri, 4 May 2012 22:38:03 +0000 (15:38 -0700)]
Spinlock depth checking

This tracks how many locks we acquired on a pcpu basis.  Before we
kthread/block or anything like that, the number better be 0.  Not only
is it bad for perf, but you could deadlock.

Needed this to hunt down a deadlock bug (asserted in some place where I
thought I had no locks), though it had nothing to do with sleeping.

It only does work when CONFIG_SPINLOCK_DEBUG is on, though you can
always test for it (and you'll get 0).

I didn't compile it for RISCV.  YMMV.

8 years agoFixes some deadlock scenarios
Barret Rhoden [Fri, 4 May 2012 22:09:11 +0000 (15:09 -0700)]
Fixes some deadlock scenarios

Can't send messages with the proclock held unless there is an active
vcore.  O/W, event code may attempt to wake up the proc and/or grab the
proc_lock when it makes sure a message gets through.

There are a variety of other related issues, such as the ksched calling
event code (via proc code) that could call proc_wakeup().

8 years agoKsched allocates provisioned cores
Barret Rhoden [Tue, 1 May 2012 22:47:34 +0000 (15:47 -0700)]
Ksched allocates provisioned cores

When servicing a proc (via the ksched's linear scan of all MCPs or via a
poke_ksched()), the ksched will preempt cores provisioned to a process
that are allocated to another process.

We also do a somewhat-ghetto trick when the ksched is attempting to
preempt a core, but is racing with that proc yielding the core.  We
short-circuit put_idle, since the ksched noticed the core is not
allocated before proc code told the ksched.

8 years agoChanges idlecoremap to a list
Barret Rhoden [Tue, 1 May 2012 19:56:22 +0000 (12:56 -0700)]
Changes idlecoremap to a list

Other than cleaning things up (the map was pretty nasty), this allows us
to allocate specific cores and pull them off the idlelist without having
to scan.

8 years agoBetter ksched helpers for pcoreid <-> sched_pcore
Barret Rhoden [Tue, 1 May 2012 19:17:06 +0000 (12:17 -0700)]
Better ksched helpers for pcoreid <-> sched_pcore

Also cleans up some debug/printing code (lists procs as pid (pointer),
instead of pointer (pid)).

8 years agoRemoves option for a dedicated monitor core
Barret Rhoden [Tue, 1 May 2012 18:34:39 +0000 (11:34 -0700)]
Removes option for a dedicated monitor core

This was an old option that only made sense when we couldn't get to the
monitor by interrupt.

8 years agoRenames TAILQ_ENTRY in sched_pcore
Barret Rhoden [Tue, 1 May 2012 18:29:17 +0000 (11:29 -0700)]
Renames TAILQ_ENTRY in sched_pcore

In anticipation of another next/link

8 years agoCleans up proc_preempt_core()
Barret Rhoden [Tue, 1 May 2012 18:16:28 +0000 (11:16 -0700)]
Cleans up proc_preempt_core()

It's now the caller's responsibility to do something with the idle core.

8 years agoproc_yield() and change_to_vcore() use unmapping
Barret Rhoden [Mon, 30 Apr 2012 22:13:27 +0000 (15:13 -0700)]
proc_yield() and change_to_vcore() use unmapping

As their signal, instead of preempt_served.  They were checking the
vcoremap anyway, but for different reasons, and now it's clear what they
are doing.

8 years agoproc_get_vcoreid() usage clarification
Barret Rhoden [Mon, 30 Apr 2012 20:57:36 +0000 (13:57 -0700)]
proc_get_vcoreid() usage clarification

Don't use it to ask about remote cores.  You could, but you'd be getting
potentially old info, so I just removed the option.  This makes the
systracing code a little slower, but things are a little safer for new

8 years agoProc code unmaps vcores when taking cores
Barret Rhoden [Mon, 30 Apr 2012 20:48:29 +0000 (13:48 -0700)]
Proc code unmaps vcores when taking cores

Instead of leaving the mapping up for the __preempt or __death code to
deal with.  That code now uses the pcpui var.  Check out the doc changes
for more info.

8 years agoTracks proc's vcoreids in pcpu info
Barret Rhoden [Mon, 30 Apr 2012 18:06:38 +0000 (11:06 -0700)]
Tracks proc's vcoreids in pcpu info

So k_msgs and other functions running on MCP cores do not need to look
at the pcoremap.

8 years ago__startcore now takes the vcoreid as a parameter
Barret Rhoden [Mon, 30 Apr 2012 17:43:04 +0000 (10:43 -0700)]
__startcore now takes the vcoreid as a parameter

Instead of reading from the vcore/pcoremap to determine the vcoreid.
This is part of a series of patches that will remove accesses of the
vcoremap from unlocked code.  This will clean up a few nasty scenarios.

8 years agoKsched functions to provision cores
Barret Rhoden [Thu, 26 Apr 2012 20:48:01 +0000 (13:48 -0700)]
Ksched functions to provision cores

You can provision cores, and this code will track where each core is
provisioned and/or allocated to.  The scheduler does nothing with this
info yet.

Also some CG/LL changes - notably we don't reserve a core for the NIC
anymore, and if you use any of the other antiquated core reservation
CONFIGs, something will break when you provision that core.  That'll get
sorted out eventually.

8 years agoput_idle_cores() takes a proc * and locking strat
Barret Rhoden [Wed, 25 Apr 2012 23:23:52 +0000 (16:23 -0700)]
put_idle_cores() takes a proc * and locking strat

And is safer about locking (will be needed shortly).  The diff btw the
internal and external versions is the holding of the sched lock.

Now, the sched lock is protecting the sched lists, the 'idlecoremap',
and will soon protect the provisioning lists in proc->ksched_data.

8 years agoCleans up TLS access macros (XCC)
Barret Rhoden [Wed, 5 Sep 2012 20:58:58 +0000 (13:58 -0700)]
Cleans up TLS access macros (XCC)

Documents and cleans up the TLS access macros.  A bunch of the comments
were lost a few commits back.

Since I was changing things, I fixed up the whitespace and formatting
too.  If you want to review this, ignore whitespace.

You need to rebuild glibc, though not because of this patch.  Some of
the previous ones changed a few things (esp 716debe).  I needed to
completely rebuild glibc (delete glibc-XXX directory, the i686
files/directories, etc).

8 years agomake risc-v front-end syscalls asynchronous
Andrew Waterman [Fri, 18 May 2012 23:53:50 +0000 (16:53 -0700)]
make risc-v front-end syscalls asynchronous

also add DEMO mode, where the system waits for
ELFs to be sent over stdin and executes them

8 years agofix risc-v fpu emulation bugs
Andrew Waterman [Fri, 18 May 2012 23:53:34 +0000 (16:53 -0700)]
fix risc-v fpu emulation bugs

8 years agoimplement stdout with cputbuf instead of printk
Andrew Waterman [Fri, 18 May 2012 23:51:38 +0000 (16:51 -0700)]
implement stdout with cputbuf instead of printk

This improves stdout bandwidth.  (Yes, it matters to us :-))

8 years agofix risc-v compiler bug for sin/cos/exp/...
Andrew Waterman [Tue, 29 May 2012 04:59:51 +0000 (21:59 -0700)]
fix risc-v compiler bug for sin/cos/exp/...

8 years agofor RISC-V, emulate missing fdiv/fsqrt instructions
Andrew Waterman [Tue, 29 May 2012 04:36:00 +0000 (21:36 -0700)]
for RISC-V, emulate missing fdiv/fsqrt instructions

8 years agofix more risc-v compiler bugs
Andrew Waterman [Wed, 23 May 2012 17:16:14 +0000 (10:16 -0700)]
fix more risc-v compiler bugs

8 years agofix headers barfing when used in c++ programs
Andrew Waterman [Wed, 23 May 2012 17:15:49 +0000 (10:15 -0700)]
fix headers barfing when used in c++ programs

8 years agoUpdate uthread_init to use uthread_set_tls_var macro
Kevin Klues [Thu, 17 May 2012 18:45:23 +0000 (11:45 -0700)]
Update uthread_init to use uthread_set_tls_var macro

As a side effect, this also removes the reliance on
uthread_init needing to assert that it is called from
vcore context.

8 years agoAdded #include for sys/vcore-tls.h for x86
Kevin Klues [Thu, 17 May 2012 16:10:37 +0000 (09:10 -0700)]
Added #include for sys/vcore-tls.h for x86

8 years agoimprove risc-v console
Andrew Waterman [Thu, 17 May 2012 04:12:52 +0000 (21:12 -0700)]
improve risc-v console

we now explicitly read the keyboard in non-canonical mode.

8 years agofix a riscv gcc bug
Andrew Waterman [Thu, 17 May 2012 03:12:48 +0000 (20:12 -0700)]
fix a riscv gcc bug

8 years agoRISCV uses the no-CAS version of MCS-PDR locks
Andrew Waterman [Wed, 16 May 2012 00:40:51 +0000 (17:40 -0700)]
RISCV uses the no-CAS version of MCS-PDR locks

These ones don't know how to figure out what vcore in particular needs to run,
so they make all (preempted) vcores run.  It'll eventually work out.

Also, the reason we needed to do this was because RISCV's CAS is busted and
does not allow independent access of the variable.  All accesses to (current)
RISCV CAS variables needs to be through CAS.

Note this means that registering event queues for blocking syscalls is busted.

8 years agohandle TLS mostly in glibc, not parlib
Andrew Waterman [Tue, 15 May 2012 12:11:24 +0000 (05:11 -0700)]
handle TLS mostly in glibc, not parlib

8 years agorisc-v bugfix potpourri
Andrew Waterman [Tue, 15 May 2012 12:10:47 +0000 (05:10 -0700)]
risc-v bugfix potpourri

8 years agodon't dereference PC during trap entry
Andrew Waterman [Tue, 15 May 2012 12:06:47 +0000 (05:06 -0700)]
don't dereference PC during trap entry

8 years agoon risc-v, emulate keyboard input using an alarm
Andrew Waterman [Sat, 12 May 2012 00:56:25 +0000 (17:56 -0700)]
on risc-v, emulate keyboard input using an alarm

8 years agoon risc-v, initialize core_stacktops; fix halt
Andrew Waterman [Sat, 12 May 2012 00:55:30 +0000 (17:55 -0700)]
on risc-v, initialize core_stacktops; fix halt

halt needs ints enabled!

8 years agorisc-v supervisor mode updates
Andrew Waterman [Fri, 11 May 2012 04:28:54 +0000 (21:28 -0700)]
risc-v supervisor mode updates

8 years agorisc-v boot process bugfixes
Andrew Waterman [Tue, 24 Jan 2012 02:11:52 +0000 (18:11 -0800)]
risc-v boot process bugfixes

8 years agobig speedups for memcpy/memset
Andrew Waterman [Tue, 24 Jan 2012 02:10:19 +0000 (18:10 -0800)]
big speedups for memcpy/memset

8 years agoWants top of stack, not bottom...
Kevin Klues [Tue, 1 May 2012 02:43:45 +0000 (19:43 -0700)]
Wants top of stack, not bottom...

8 years agoproc_wakeup() replaces schedule_scp()
Barret Rhoden [Wed, 25 Apr 2012 02:17:10 +0000 (19:17 -0700)]
proc_wakeup() replaces schedule_scp()

All places wanting to make sure a proc runs now can spam proc_wakeup().
This commit makes new-proc calls and yield-related calls that aren't
already in the ksched call proc_wakeup().

This should also have cleaned up the last of the deadlockable lock
orderings (ever since we had proc_destroy in the ksched, it was possible
to deadlock during a concurrent sched_scp()).

Finally, this just gets rid of schedule_scp(), which was in no way
related to the __schedule_scp().  Ugh.

8 years agoproc_wakeup() - spammable and starts in the ksched
Barret Rhoden [Wed, 25 Apr 2012 00:16:33 +0000 (17:16 -0700)]
proc_wakeup() - spammable and starts in the ksched

Need to have the ksched lock held while waking up so that we atomically
wake up and alert the ksched (via the callbacks).  If we grab the ksched
lock after the proc lock, we can deadlock.  If we unlock the proc lock
before telling the ksched, we could have another core try a
proc_destroy(), and the ksched would destroy it after the old
__proc_wakeup, but before the ksched finds out about the wakeup.  So we
enter the call via the ksched, and grab its lock first, like with

Note that excessive spamming of proc_wakeup would hurt the ksched a bit
(coarser lock than all the proc locks), but all cases expect it to be a
necessary call.  For instance, the event code all peaks at the state of
p, making sure it was WAITING before bothering the ksched.  We'd have
excessive calls only if two or more cores tried that at the same time
and all saw WAITING before the ksched called __proc_wakeup to change it

8 years agoproc_change_to_m() is now a scheduler function
Barret Rhoden [Mon, 23 Apr 2012 23:16:30 +0000 (16:16 -0700)]
proc_change_to_m() is now a scheduler function

Due to issues of lock ordering.  We need to atomically change process
state and tell the ksched about it.  The way to do this without
deadlocking is to grab the ksched lock first.  Ultimately, we're going
to end up tying proc and ksched code together a bit, where proc code
does the bidding of sched code.

8 years agoProc refcnt no longer needs '+1 for existing'
Barret Rhoden [Fri, 20 Apr 2012 21:26:50 +0000 (14:26 -0700)]
Proc refcnt no longer needs '+1 for existing'

This reference is managed by the kernel scheduler.

8 years agoKernel scheduler tracks procs 'cradle to grave'
Barret Rhoden [Fri, 20 Apr 2012 21:20:02 +0000 (14:20 -0700)]
Kernel scheduler tracks procs 'cradle to grave'

Previously, the ksched would only know about processes whenever it
needed to make a decisions.  For MCPs, this was always.  For SCPs, it
was only when runnable.  Now it knows about them from register_proc()
(called during proc creation) until proc_destroy(), which recently
became a ksched function (this was part of the motivation for that).

This also allows the ksched to not need to poll the queues to detect if
someone is dying or not.  That messiness is gone, and the ksched just
gets called for proc_destroy().

8 years agoFixes TAILQ usage in arsc.c
Barret Rhoden [Fri, 20 Apr 2012 20:24:21 +0000 (13:24 -0700)]
Fixes TAILQ usage in arsc.c

8 years agoproc_destroy() now starts in the ksched
Barret Rhoden [Fri, 20 Apr 2012 00:07:32 +0000 (17:07 -0700)]
proc_destroy() now starts in the ksched

This allows the kernel scheduler to lock first, which helps with some
other lock-ordering trickery we do, and allows the ksched to do
additional cleanup, other than just receiving the idle cores.

Additionally, we have less of a need for put_idle_cores() (the only
caller is an old preemption function, which might get sucked into the
ksched soon).

8 years agoTracks state properly for paused uthreads
Barret Rhoden [Mon, 23 Apr 2012 22:56:39 +0000 (15:56 -0700)]
Tracks state properly for paused uthreads

Pthreads uses a state for threads stopped from below (currently only for
preemptions (either pending or recoverery)).

Uthreads just tracks them as NOT_RUNNABLE.

This patch also provides a helper for the three usages of
copyout/sched_ops->paused.  Depending on what 2LSs need, we might
provide copyout directly again, but for now we'll leave it as an
internal helper.

8 years agoPthread join/exit/yield use the uth_yield func ptr
Barret Rhoden [Wed, 18 Apr 2012 22:23:50 +0000 (15:23 -0700)]
Pthread join/exit/yield use the uth_yield func ptr

Instead of passing info via states and flags, we pass info via the
function pointer, like all other uses of uthread_yield.  This allows us
to clean up join/exit/yield a bit.

Now, all yield paths touch the 2LS, and in those callbacks the 2LS sets
the pthread's state, which it then sees in pth_thread_runnable() later

Fun note: there was a cryptic comment above pthread_exit():

/* This function cannot be migrated to a different vcore by the
userspace scheduler.  Will need to sort that shit out. */

I think that was talking about the old version of exit, back when there
was no uthread library and when exit and yield had separate (but highly
similar) functions for getting into vcore context.

If you're curious, check it out.  It was from a commit 2 years and a day
ago.  (f35c3ed435fd).

8 years agouthread_yield() takes a func* and arg
Barret Rhoden [Wed, 18 Apr 2012 21:34:23 +0000 (14:34 -0700)]
uthread_yield() takes a func* and arg

We had a variety of ways to pass info across the uth_yield->__uth_yield
boundary.  Instead of doing all of that, we just tell uthread_yield to
run a function when it gets to vcore context.

The purpose of this function is to somehow deal with the uthread and its
reason for blocking.  This could be because it blocked on a syscall, or
perhaps for some 'external' reason, such as blocking on a mutex.  This
setup allows the mutex code to not be aware of 2LS-particulars, though
it still needs to know about uthreads.  This will help us with mutexes
and libraries that aren't bound to a particular 2LS, as well as simplify
many different mechanisms (like the pth specific stuff for join/exit).

8 years ago2LS thread_blockon now takes the uthread*
Barret Rhoden [Wed, 18 Apr 2012 20:58:12 +0000 (13:58 -0700)]
2LS thread_blockon now takes the uthread*

Keeps it in line with the other 2LS thread ops.  Need to do some void*
trickery for upcoming patches, and because C is picky about void* vs
struct xme* as parameters in function pointers.

8 years agoPthread state tracking
Barret Rhoden [Wed, 18 Apr 2012 20:52:12 +0000 (13:52 -0700)]
Pthread state tracking

We don't do anything smart in pth_thread_runnable(), but that's where
you can make different decisions on what to do with the thread based on
why it slept/woke up.

All yielding/blocking paths will touch the 2LS (pthread in this case),
and that is where the 2LS can record info (states) for later

8 years agoPthread code calls uthread_runnable() consistently
Barret Rhoden [Wed, 18 Apr 2012 19:23:53 +0000 (12:23 -0700)]
Pthread code calls uthread_runnable() consistently

We were doing a mix of calling the schedop directly and indirectly
(uth_runnable).  This is a little slower, but all paths involving waking
up a uthread go through the same code now.  External code (e.g. mutex
libraries) will use uthread_runnable().

8 years agoUthread code no longer tracks detailed states
Barret Rhoden [Wed, 18 Apr 2012 19:18:16 +0000 (12:18 -0700)]
Uthread code no longer tracks detailed states

Uthread code only cares about RUNNING vs NOT_RUNNING, and this is only
to catch bugs.  The 2LS is responsible for any state it wishes to track,
such as the diff btw blocking on a syscall, joining, exiting, blocking
on a mutex, whatever.

8 years agoFake tcgetattr() to allow busybox to do line edits
Barret Rhoden [Tue, 10 Apr 2012 22:34:10 +0000 (15:34 -0700)]
Fake tcgetattr() to allow busybox to do line edits

This fakes the tcgetattr() call with hard-coded answers from a linux
machine.  This is enough to get busybox to do line editing.  It also
allows us to remove the devfs stdin hacks, and add new ones to stdout!

I added my busybox config to tools/.  If you don't want to use mine, be
sure to turn on FEATURE_EDITING in yours to get backspace working on the
command line.  I'll update it periodically.

8 years agoConfig option to turn off backspace for printk
Barret Rhoden [Tue, 10 Apr 2012 23:00:01 +0000 (16:00 -0700)]
Config option to turn off backspace for printk

If you set CONFIG_PRINTK_NO_BACKSPACE, then the console won't try to go
backwards when you send a \b or \x7f, and will print ^H instead.

8 years agox86 console and readline() honor 0x7f
Barret Rhoden [Tue, 10 Apr 2012 21:02:10 +0000 (14:02 -0700)]
x86 console and readline() honor 0x7f

Qemu sends an 0x7f (DEL) via serial when you hit backspace, and readline
was ignoring it.  Not that readline matters much, but it'll now treat
the 0x7f like a backspace (\b, 0x8).

Note that \b and \x7f get sent directly to userspace, and it is up to
them to parse that.  This means that the KB (qemu and real world)
backspace is sending \b, real-world serial (at least my minicom) is
sending \b, but qemu serial sends \x7f.

Keymaps, terminal settings, and what programs expect are all huge pains
in the ass.

8 years agoAdded calls neessary to get lithe running on ROS
Kevin Klues [Tue, 10 Apr 2012 01:13:22 +0000 (18:13 -0700)]
Added calls neessary to get lithe running on ROS

This also includes some nice helper macros for accessing
and modifying TLS variables in other contexts without
having to remember the entire sequence of things you need
to do to make this happen.

8 years agoAdd symlink of parlib->(current_directory) in include install path
Kevin Klues [Tue, 10 Apr 2012 01:11:41 +0000 (18:11 -0700)]
Add symlink of parlib->(current_directory) in include install path

This allows us to access all header files installed on our system
via either <parlib/*> or just regular <*>

8 years ago__ros_scp_simple_evq should be declared as extern in syscall.h
Kevin Klues [Tue, 10 Apr 2012 01:10:56 +0000 (18:10 -0700)]
__ros_scp_simple_evq should be declared as extern in syscall.h

8 years agoAllow the headers to be used when compiling c++ programs
Kevin Klues [Tue, 10 Apr 2012 01:09:49 +0000 (18:09 -0700)]
Allow the headers to be used when compiling c++ programs

8 years agoFixes x86 LAPIC_ISR/IRR reading
Barret Rhoden [Mon, 9 Apr 2012 21:03:10 +0000 (14:03 -0700)]
Fixes x86 LAPIC_ISR/IRR reading

The ISR and IRR are not bitmaps, but are 8 32-bit registers spaced every
16 bytes in the LAPIC address space.  Thanks

8 years agoStops calling ros_debug in place of printf
Barret Rhoden [Sat, 7 Apr 2012 01:32:50 +0000 (18:32 -0700)]
Stops calling ros_debug in place of printf

Uthread code (not glibc code) was calling ros_debug.  We probably don't
need to do this anymore.  And the whole 'appserver redirection' doesn't
need to happen at all, since writing to stdout will just be a printk
under the hood.

8 years agoFixes mhello, soon to be destroyed
Barret Rhoden [Sat, 7 Apr 2012 01:27:11 +0000 (18:27 -0700)]
Fixes mhello, soon to be destroyed

mhello is pretty ugly, and continues to get uglier as uthread code
becomes more capable.  This keeps it alive a bit longer, allowing it to
deal with blocking syscalls (I have mmap() blocking in some of my
tests).  mhello will just spin til the syscall is done.

8 years agoFixes issues with proc_yield and preempt_pending
Barret Rhoden [Sat, 7 Apr 2012 01:18:38 +0000 (18:18 -0700)]
Fixes issues with proc_yield and preempt_pending

preempt_pending has been neglected a little with some of the recent
kernel/user core management code.

This fix stops the kernel from aborting a yield when a process has a
preempt pending *and* some race happened in userspace where amt_wanted
wasn't decreased.

This also decreases the chance of that race by keeping userspace from
decrementing its amt_wanted when it is being nice (preempt pending).

8 years agox86: handles spurious IRQs from the PIC and LAPIC
Barret Rhoden [Thu, 5 Apr 2012 19:34:51 +0000 (12:34 -0700)]
x86: handles spurious IRQs from the PIC and LAPIC

I put printks in there, since I'm curious to see if this even happens
and haven't been able to test it yet.  Once it happens, we'll turn off
the printks.

Note things get a little confusing when talking about IRQ numbers.
The kernel's IRQs are mapped 32 (PIC1_OFFSET) slots higher than
hardware's IRQs.  For instance, what the PIC things of as IRQ0 comes in
to irq_handler as 32.  When talking to the PIC/hardware, we use their
numbers.  Devices, like the Keyboard on IRQ0 need to get registered at 0
+ PIC1_OFFSET.  Might clean this up over time, but there's no getting
around the offset/remapping.

Also, make sure you never tell the LAPIC/IOAPIC to use a PIC IRQ if you
are also using the PIC; the kernel won't be able to tell the difference.
I might be able to change this, but it's not a real problem.

8 years agoFixes bug with reading LAPIC ISR/IRR
Barret Rhoden [Thu, 5 Apr 2012 00:19:29 +0000 (17:19 -0700)]
Fixes bug with reading LAPIC ISR/IRR

Not sure what I was thinking there.

Be sure to read the documentation if you're using ipi_is_pending().

8 years agoPIC helper functions to read the ISR, IRR, and IMR
Barret Rhoden [Wed, 4 Apr 2012 23:40:39 +0000 (16:40 -0700)]
PIC helper functions to read the ISR, IRR, and IMR

Remember, bit 2 (0x4) will be high on the ISR/IRR when any of the high 8
IRQs are high, due to the chaining of the PICs.  Likewise, the IRR will
show an IRQ when it is masked - the chip will simply never send it.

Also note that these only apply for interrupts coming in via the PIC,
and not the IOAPIC/LAPIC.  You'll need to check the LAPIC for its

8 years agox86 register IRQ handlers for devices that exist
Barret Rhoden [Wed, 4 Apr 2012 00:39:43 +0000 (17:39 -0700)]
x86 register IRQ handlers for devices that exist

Instead of just blindly registering anything that could exist.

Note that we can only register one 'device' per IRQ, so if you have both
COM1 and COM3 (for example, and let alone other devices sharing IRQs),
then the last one to register will get serviced.

8 years agox86 console/serial cleanup
Barret Rhoden [Wed, 4 Apr 2012 00:19:18 +0000 (17:19 -0700)]
x86 console/serial cleanup

Console devices (KB, serial) now have structs associated with them,
which we can later register with interrupt drivers.

Input devices can now get -1 (0xff) and 0.  Not a big deal for the
keyboard, but the serial device might actually get those 'chars' at some

We also look for and initialize COM2, COM3, and COM4, as well as detect
the type of serial device.  For now, our output spams all of these (if

8 years agoFixes serial interrupt enabling on x86 hardware
Barret Rhoden [Tue, 3 Apr 2012 18:24:40 +0000 (11:24 -0700)]
Fixes serial interrupt enabling on x86 hardware

Qemu didn't need the bit set, but our desktops (16550(A)s) do.  Nice to
know that my old IO Ports list called that bit "auxiliary
user-designated output 2".  My bad for clobbering that bit (that was on
by default) when attempting to set the flow control.

8 years agoKsched preempts SCPs on schedule() calls
Barret Rhoden [Fri, 30 Mar 2012 21:24:15 +0000 (14:24 -0700)]
Ksched preempts SCPs on schedule() calls

Also will check for SCPs to run when the core has nothing to do
(cpu_bored()), as opposed to waiting til the next timer tick.

8 years agoFixes static binary init issue (XCC)
Barret Rhoden [Fri, 30 Mar 2012 03:02:22 +0000 (20:02 -0700)]
Fixes static binary init issue (XCC)

Can't call vcore_event_init() before the other C runtime inits (runs
into issues with not having TLS initialized, which vcore_event_init()
needs (some malloc checks/init stuff)).

Rebuild glibc, copying over at least start.c.

8 years agoKernel now halts when there is no work
Barret Rhoden [Sat, 24 Mar 2012 01:39:30 +0000 (18:39 -0700)]
Kernel now halts when there is no work

We had been polling in a variety of places.  This takes away the last
one: spinning in the manager().  Now, the manager doesn't get called
much (it gets called once, and that should be it).

Note that we still poll in the monitor(), which you can always get to
via 'G' (the call of the giraffe).  (so long as interrupts are enabled,
you're not stuck in a loop, etc).

8 years agoReading from /dev/stdin will block
Barret Rhoden [Sat, 24 Mar 2012 01:17:37 +0000 (18:17 -0700)]
Reading from /dev/stdin will block

We read one char at a time now (per syscall).  busybox asks for up to
1023, interestingly enough.  It also doesn't know it is a tty yet, so
I'm sure its behavior will change.  Note that we already fake a bunch of
TTY related things.  Not sure who is supposed to echo the key btw...

And we don't do anything like sending SIGINT or control characters.

8 years agoKeyboard/char input buffering and irq handling
Barret Rhoden [Sat, 24 Mar 2012 01:08:44 +0000 (18:08 -0700)]
Keyboard/char input buffering and irq handling

Each arch needs to have interrupt handlers for their console input that
call the appropriate routine kmsgs, which will handle putting the char
in the console buffer.  Take a look at x86's.  If this is somehow
fundamentally incompatible with RISCV, let me know.

This techincally adds to a kernel header, but no one should need to
rebuild anything.

8 years agosys_trywait() now blocks
Barret Rhoden [Wed, 21 Mar 2012 20:01:15 +0000 (13:01 -0700)]
sys_trywait() now blocks

We actually need a real wait/waitpid() call, which will also allow us to
cleanup glibc's waitpid() and fork() calls.  For now, this will allow us
to have bb block on its children, instead of spinning.

8 years agoGlibc syscalls now block properly (XCC)
Barret Rhoden [Wed, 21 Mar 2012 19:50:38 +0000 (12:50 -0700)]
Glibc syscalls now block properly (XCC)

Glibc wasn't calling out to the proper blockon call.  We deal with this
by having a default blockon, defined in glibc's syscall.c, that
degenerate SCPs can use.  Once they init enough and have access to
parlib symbols, they switch the function ptr to use the 'real' blockon,
which uses glibc's default one for SCPs.

Rebuild glibc and anything in userspace.

8 years agoKernel can detect degenerate SCPs (XCC)
Barret Rhoden [Wed, 21 Mar 2012 19:44:40 +0000 (12:44 -0700)]
Kernel can detect degenerate SCPs (XCC)

Meaning, the SCP can't go into vcore context yet (very early in the life
of a process).  Once userspace turns off the VC_SCP_NOVCCTX flag, the
kernel will put the SCP into vc ctx, when appropriate (notified).

8 years agoSCPs can sleep on events (XCC)
Barret Rhoden [Fri, 16 Mar 2012 19:39:23 +0000 (12:39 -0700)]
SCPs can sleep on events (XCC)

If single-core processes yield that aren't 'being nice', they will block
waiting for an event.  Otherwise, the process is simply giving up the
processor for someone else, even though it has work to do.

The meaning of being_nice differs between SCPs and MCPs.  MCPs will
never give up if they have work to do, unless they think a preemption is
coming in.  Might consider getting rid of the whole SCP 'sched_yield'
approach (arguably, it's the kernel's job) for _Ss, but whatever.

Rebuild your cross compiler, making sure to replace sched_yield.c in
your glibc directory.  Otherwise, sched_yielders (like busybox) will
accidentally block.

8 years agoSCPs can register ev_qs for syscalls (XCC)
Barret Rhoden [Fri, 16 Mar 2012 00:09:22 +0000 (17:09 -0700)]
SCPs can register ev_qs for syscalls (XCC)

Right now, they just yield and get restarted right away, while waiting
for the event (and actually they just check the sysc flag).  Future
patches will have them become WAITING.

Rebuild your cross compiler/userspace.

8 years agoRemoved unnecessary/fauly assert
Barret Rhoden [Thu, 15 Mar 2012 20:15:46 +0000 (13:15 -0700)]
Removed unnecessary/fauly assert

This safely trips if SCPs kthread and yield in a loop while waiting.
Here's what happens:
1) process causes a kthread (sys_block)
2) process yields, leaving the core (no longer current or owning)
3) timer interrupt goes off and unblocks the kthread, which sets current
(but not owning)
4) kthread does not clear current - that's done in the
restartcore/smp_idle path.
5) ksched's timer tick goes off, causing its work to be done in a
routine kmsg
6) proc_restartcore executes the kmsg before abanonding
&) ksched kmsg calls proc_run_s

We actually don't want to abandon early - it's better to stay in that
context til after we check messages (avoid an extra TLB flush).  The old
assert was probably important a long time ago (back when owning_proc and
current were the same thing), or at least a "this is weird, check it

Note the process is current, but not the owning proc.

8 years agoFixes bug in event headers (XCC)
Barret Rhoden [Thu, 15 Mar 2012 18:57:57 +0000 (11:57 -0700)]
Fixes bug in event headers (XCC)

Has been around since 16a868, haven't seen it hit yet, though it might
have been masking other bugs.

8 years agoEvent delivery to _S procs
Barret Rhoden [Thu, 15 Mar 2012 02:59:15 +0000 (19:59 -0700)]
Event delivery to _S procs

If an _S registers an ev_q, the kernel event delivery system will send
events to the process.  Events will go to vcore0's public mbox,
regardless of ev_flags, so long as the proc is an _S.  Processes can set
up ev_qs for whatever they want later, and then when they are MCPs, the
flags will kick in (and you don't have to change things).  That is how
processes should set up ev_qs for POSIX signals.

The code can also handle the process being descheduled, and the _S will
pop into vcore context when it starts up (if it wasn't already in vcore
context when it was stopped).

Receiving an event also should wake an _S, rescheduling it, though that
hasn't been tested yet (_Ss don't WAIT yet).

8 years agoAll apps now must link against parlib (XCC)
Barret Rhoden [Tue, 13 Mar 2012 21:21:29 +0000 (14:21 -0700)]
All apps now must link against parlib (XCC)

Glibc calls out to a low-level parlib function (vcore_event_init(), used
to enable event delivery of *all* processes) that needs to be linked in
to every binary, regardless of whether or not the process will be an

In addition to linking against parlib, applications need to be built
with " -u force_parlib_symbols ", which forces the linker to find the
strong version of symbols weakly used in glibc's start.c.

All test code has these flags/libraries set, but external apps need it
too.  Busybox, in particular, needs the patch in tools/patches to force
linking with parlib.

Rebuild your cross compiler, and install-libs (esp before rebuilding
busybox).  At a minimum, you need to copy start.c to the glibc-2.14.1/
tree and rebuild.  If that doesn't make sense, then just do a full
rebuild of glibc.

8 years agouthread_vcore_entry() can handle not having a 2LS
Barret Rhoden [Tue, 13 Mar 2012 00:38:34 +0000 (17:38 -0700)]
uthread_vcore_entry() can handle not having a 2LS

_Ss that never link in a 2LS will pop up in vcore_entry() when receiving
events.  This patch allows them to restart current_uthread - sort of a
'default 2LS op'.  I thought of making it an actual member of
default_2ls_ops, but I didn't want 2LS writers to think it is actually a
real default choice for them.  It's just to make _S code work.

8 years agouthread_slim_init()
Barret Rhoden [Tue, 13 Mar 2012 00:33:34 +0000 (17:33 -0700)]

Allows the uthread code to manage thread0 in the absence of a 2LS.
Eventually, all processes will call uthread_slim_init(), which will be
useful for event delivery to _Ss.  Then processes that will become MCPs
will call uthread_lib_init and set up the full system (using 2LS
threads, instead of just struct uthreads).

8 years agoproc_yield() will abort if they want the core
Barret Rhoden [Mon, 12 Mar 2012 20:09:29 +0000 (13:09 -0700)]
proc_yield() will abort if they want the core

This saves the kernel scheduler the effort of reallocating the core.
This could trigger if there was a concurrent vcore_requester, though it
should be pretty rare.

8 years agoEvents that wake processes poke the ksched
Barret Rhoden [Sun, 11 Mar 2012 17:47:57 +0000 (10:47 -0700)]
Events that wake processes poke the ksched

Previously, the processes would wake up, but wouldn't tell the ksched.
The ksched would have to notice on its next tick, which could be 10ms
away (current ksched), or never (tickless kscheds).  For block_test,
which sleeps 5ms per loop, without this patch, you'd wait close to 5ms
til the next timer tick.  This patch cuts down block test to about
5.5sec (poke to run when avail), instead of 10sec (run on timer tick).

Unblocking is a big enough deal that it got its own callback, but we're
not using it for anything other than a RES_CORES poke right now.

8 years agoput_idle_core() called without the proc_lock
Barret Rhoden [Fri, 9 Mar 2012 22:18:54 +0000 (14:18 -0800)]
put_idle_core() called without the proc_lock

Minor changes to yield and preempt, we give back the core after
unlocking (like with previous patches).

Now, ksched's should be free to do whatever they want in put_idle.