7 years agoAdds a microbenchmark test program
Barret Rhoden [Sat, 26 Jan 2013 01:08:36 +0000 (17:08 -0800)]
Adds a microbenchmark test program

It can run some basic functions and measure the time elapsed.  Check the
top of microb_test.c for more details.

7 years agoRemoves side effects from assert() in userspace
Barret Rhoden [Thu, 24 Jan 2013 23:18:01 +0000 (15:18 -0800)]
Removes side effects from assert() in userspace

This way we can remove all asserts without affecting the logic of
the program, at the expense of a couple lines here and there.

7 years agoBasic POSIX signal handling (XCC)
Barret Rhoden [Wed, 23 Jan 2013 00:30:32 +0000 (16:30 -0800)]
Basic POSIX signal handling (XCC)

Can register sighandlers/sigactions for POSIX signals.  You can signal
with kill or raise.

Check signal.c for details, esp concerning all the things we don't do.

Rebuild your cross compiler.

7 years agoAdded GETTING_STARTED file
Kevin Klues [Tue, 22 Jan 2013 22:07:27 +0000 (14:07 -0800)]

7 years agoFixes memset() bug
Barret Rhoden [Wed, 9 Jan 2013 02:54:46 +0000 (18:54 -0800)]
Fixes memset() bug

When you cast an int such as 0xfe to a char, you get 0xfffffffe, and not

7 years agoRemoves excessive notif_pending check
Barret Rhoden [Wed, 9 Jan 2013 01:26:45 +0000 (17:26 -0800)]
Removes excessive notif_pending check

The check, signal, check-again pattern is excessive there, unlike below
when we muck with the vcore list.

7 years agoLock depth checking allows panicy prints
Barret Rhoden [Wed, 9 Jan 2013 01:00:01 +0000 (17:00 -0800)]
Lock depth checking allows panicy prints

We use locks when printing, so once one lock failed, it would
recursively fail if the condition remained true (such as having a bad
kernel stack depth).  This would happen for any kernel trap or trace
coretf, or any other place where I don't care about the deadlock but
want to get the printf.

Note that there are a couple locks involved in printing - two on the
printk path.  If we fail (e.g. for IRQSAVE reasons) on the SECOND lock
(after grabbing the first lock), we will still deadlock, since we
basically grabbed lock 1, failed when getting 2, then attempted to get 1
again for another printk.  In lieu of making this debug code more
robust, we just will leave those locks as irqsave for a long time.

7 years agoAdd MCS qnode static initializer, assumed by Lithe
Andrew Waterman [Tue, 8 Jan 2013 20:01:01 +0000 (12:01 -0800)]
Add MCS qnode static initializer, assumed by Lithe

7 years agoAdd helper that reenters vcore context at top of stack
Andrew Waterman [Tue, 8 Jan 2013 20:00:02 +0000 (12:00 -0800)]
Add helper that reenters vcore context at top of stack

7 years agoIn libc, execute vcore_event_init before ctors
Andrew Waterman [Tue, 8 Jan 2013 19:57:55 +0000 (11:57 -0800)]
In libc, execute vcore_event_init before ctors

Otherwise, ctors can't spawn uthreads.

7 years agoDon't declare gettimeofday in parlib.h
Andrew Waterman [Tue, 8 Jan 2013 08:56:03 +0000 (00:56 -0800)]
Don't declare gettimeofday in parlib.h

sys/time.h does so, and it uses a different signature, causing an error
for c++ programs.

7 years agonotif_pending short circuits handle_events()
Barret Rhoden [Tue, 8 Jan 2013 01:14:40 +0000 (17:14 -0800)]
notif_pending short circuits handle_events()

The kernel always sets notif_pending after posting to a VC mbox, so we
can use this check to avoid checking the full mbox (UCQs and other

This also cleans up a couple things and removes clear_notif_pending(),
which was doing basically what the new handle_events does.  Also,
clear_notif had a bug in it, where it would never return TRUE.

Finally, note that it is only required to have one handle_events() call
when we're in VC context.  Right now we have one in uth_vc_entry and
another in the 2LS (in pth's loop).  Due to how the pth code is set up,
we need the uth one at least (in case we immediately call run_cur_uth).

We also have a few 'optimization' locations when leaving VC ctx (either
by cur_uth or by yielding/idling).

Slimming these down yielded a couple ns on the pth_test benchmark, so we
might go with that in the future.

7 years agoDon't boot RISC-V cores with coreid >= num_cpus
Andrew Waterman [Tue, 8 Jan 2013 00:21:12 +0000 (16:21 -0800)]
Don't boot RISC-V cores with coreid >= num_cpus

7 years agoFields of struct timeval have sizeof(long)
Andrew Waterman [Tue, 8 Jan 2013 00:19:36 +0000 (16:19 -0800)]
Fields of struct timeval have sizeof(long)

7 years agoMake pthread_test use only fixed-point computation
Andrew Waterman [Tue, 8 Jan 2013 00:17:53 +0000 (16:17 -0800)]
Make pthread_test use only fixed-point computation

7 years agoChanges BITMASK_FOR_EACH to a macro
Barret Rhoden [Mon, 7 Jan 2013 23:36:14 +0000 (15:36 -0800)]
Changes BITMASK_FOR_EACH to a macro

Need this to avoid needlessly taking the address of the function being
executed on each bit.  Helps with performance, esp on RISCV.

7 years agoTemporarily add RISC-V GCC CAS routines to parlib
Andrew Waterman [Mon, 7 Jan 2013 03:39:13 +0000 (19:39 -0800)]
Temporarily add RISC-V GCC CAS routines to parlib

7 years agoAdd memory clobber to RISC-V set_stack_pointer
Andrew Waterman [Mon, 7 Jan 2013 03:38:52 +0000 (19:38 -0800)]
Add memory clobber to RISC-V set_stack_pointer

7 years agoFor manager_waterman, just run busybox
Andrew Waterman [Mon, 7 Jan 2013 03:37:10 +0000 (19:37 -0800)]
For manager_waterman, just run busybox

7 years agoFix logic bug in RISC_V env_user_mem_walk
Andrew Waterman [Mon, 7 Jan 2013 03:33:43 +0000 (19:33 -0800)]
Fix logic bug in RISC_V env_user_mem_walk

Manifested itself as sys_fork causing a kernel page fault

7 years agoFor RISC-V, don't save/restore FP regs
Andrew Waterman [Mon, 7 Jan 2013 03:32:38 +0000 (19:32 -0800)]
For RISC-V, don't save/restore FP regs

Before making this work correctly for no-FP machines, we need to sort out how
we handle silly state.  I think the plan is to only ever restore it lazily,
but that requires many changes to the mainline kernel.

7 years agoFix outdated printd statements that didn't compile
Andrew Waterman [Sun, 6 Jan 2013 09:54:41 +0000 (01:54 -0800)]
Fix outdated printd statements that didn't compile

7 years agoRemoves the -ros folder updating in gcc/glibc(XCC)
Barret Rhoden [Thu, 3 Jan 2013 21:25:26 +0000 (13:25 -0800)]
Removes the -ros folder updating in gcc/glibc(XCC)

The old change doesn't work well with the riscv patches.  Until one day
when we get rid of the -ros directories and have separate repos for
glibc/gcc, we'll stick with the current style:

If there are changes to files in the -ros directory and you don't want
to make clean / whatever, then you need to manually copy those files
over from the -ros directory to the untarred directory (e.g.

7 years agoupdate risc-v gcc, enabling riscv-ros-gccgo
Andrew Waterman [Thu, 27 Dec 2012 23:55:28 +0000 (15:55 -0800)]
update risc-v gcc, enabling riscv-ros-gccgo

7 years agoRename libgomp's local futex.h to libgomp_futex.h
Kevin Klues [Fri, 21 Dec 2012 20:35:11 +0000 (12:35 -0800)]
Rename libgomp's local futex.h to libgomp_futex.h

I would think the visibility changes would allow us to use the same file
name, but apparently not...

7 years agoFixes bug with semaphores and futexes
Barret Rhoden [Fri, 21 Dec 2012 04:15:28 +0000 (20:15 -0800)]
Fixes bug with semaphores and futexes

All code using the pthread 2LS that calls uthread_yield() needs to call
the pthread generic yield helper.  It was static, but since we have sync
methods in other files (sem/futex), we should have it available.

omp_hello was getting corrupt lists, since simply putting it on the
sem's queue without first removing it from the active list ends up with
the threads being on multiple lists.  Once again, the active list keeps
us honest.

7 years agoMoves futex.h to user/pthread (XCC)
Barret Rhoden [Fri, 21 Dec 2012 04:09:20 +0000 (20:09 -0800)]
Moves futex.h to user/pthread (XCC)

As far as I can tell, libgomp isn't even building with the ros/bar.c or
ros/futex.h (garbage in those files still compiles), and if it does for
some configuration, then libgomp.a doesn't have futex as an undefined
symbol, which is a bad configuration.

For now, just move it out of the kernel headers, since it isn't helping
much there at all.

The linux version of futex.h seems to think we need to change the
visibility too, so putting that in for now.

Reinstall your kernel headers.  I'd also remove the old ros/futex.h

7 years agoFixes bug with debugged spinlocks
Barret Rhoden [Fri, 21 Dec 2012 00:39:16 +0000 (16:39 -0800)]
Fixes bug with debugged spinlocks

Left over from moving the ifdefs around...

7 years agoInlines spinlocks when not using SPINLOCK_DEBUG
Barret Rhoden [Thu, 20 Dec 2012 03:20:34 +0000 (19:20 -0800)]
Inlines spinlocks when not using SPINLOCK_DEBUG

This one's for Andrew.  =)  Additionally, this moves the responsibility
for memory barriers to the architectures, which cuts down on the number
of full mb()s needed by RISCV (esp since Andrew was already doing one in

Also, I imagine sparc wasn't compiling, so this might work for them too,
if anyone still uses it.

7 years agoOptimizes run_once(_safe) (XCC)
Barret Rhoden [Thu, 20 Dec 2012 02:57:52 +0000 (18:57 -0800)]
Optimizes run_once(_safe) (XCC)

Takes the old run_once_safe and optimizes it for being completed, so we
don't hit an atomic_swap (and a couple branches) each time through.
Given this, I don't mind using it in more places, so the non-safe
version is now the 'racy' version (same with init_once()).

Reinstall your kernel headers.

7 years agoCleans up vcore/uth/pth init code
Barret Rhoden [Thu, 20 Dec 2012 02:37:56 +0000 (18:37 -0800)]
Cleans up vcore/uth/pth init code

All init routines fail loudly, instead of passing values back where we
just assert or printf profanities.

Some of the code can be called from a few places - some for testing
reasons (pth), and others for todo-reasons (vcore, in case we have a
separate vc slim init).

7 years agoGcc/Glibc make will patch in the -ros files
Barret Rhoden [Thu, 20 Dec 2012 01:28:49 +0000 (17:28 -0800)]
Gcc/Glibc make will patch in the -ros files

When rebuilding gcc/glibc after commits that add or modify files in the
-ros directories (e.g. glibc-XXX-ros), you no longer need to worry about
copying the changed files from the -ros directories into the main
directory; the make process will patch it for you.

One thing it won't do is restore files that were overwritten by -ros
files if the -ros file is subsequently removed.  Meaning, if a commit
removes files from a -ros directory, you need to either blow away the
main directory (glibc-XXX, for instance), or extract the original
version of the specific file from the tarball and put it in the
appropriate place in the main directory.

7 years agoIfdefs out the kernel from futex.h
Barret Rhoden [Wed, 19 Dec 2012 20:06:35 +0000 (12:06 -0800)]
Ifdefs out the kernel from futex.h

I'm not a fan of having a file in the kernel headers that is not part of
our kernel interface.

7 years agoCleans up run_once and friends (XCC)
Barret Rhoden [Wed, 19 Dec 2012 19:56:42 +0000 (11:56 -0800)]
Cleans up run_once and friends (XCC)

run_once() -> run_once_safe().  The safe one can handle races.  The
others (run_once and init_once) are for known-single-threaded areas.

Reinstall your kernel headers.

7 years agoFixes slab page allocators
Barret Rhoden [Wed, 19 Dec 2012 19:31:12 +0000 (11:31 -0800)]
Fixes slab page allocators

The user space one was wrong; the freeing side would free a rounded up
value.  We don't need the power-of-2 allocation at all in userspace.

In the kernel, I've clarified how the allocation works a little bit.

7 years agoUse run_once() macro for initialization
Kevin Klues [Tue, 18 Dec 2012 20:15:40 +0000 (12:15 -0800)]
Use run_once() macro for initialization

7 years agoRace in kmem_cache_init fixed
Kevin Klues [Tue, 18 Dec 2012 20:13:33 +0000 (12:13 -0800)]
Race in kmem_cache_init fixed

We need to make sure that one one else starts using the slab allocatior
until it has fully initialized.  There was a race on one guy starting to
initialize it, not finishing, and another one starting to use it.

I fixed up the logic and am using the new run_once() macro in
ros/common.h to accomplish this task properly.

7 years agoAdded generic macro for running a function exactly once (XCC)
Kevin Klues [Tue, 18 Dec 2012 20:12:45 +0000 (12:12 -0800)]
Added generic macro for running a function exactly once (XCC)

7 years agoAdded futex barriers to libgomp for ros
Kevin Klues [Tue, 18 Dec 2012 08:39:40 +0000 (00:39 -0800)]
Added futex barriers to libgomp for ros

7 years agoImplementation of the futex interface for pthreads
Kevin Klues [Tue, 18 Dec 2012 08:39:03 +0000 (00:39 -0800)]
Implementation of the futex interface for pthreads

7 years agoAdd header file for proper compilation
Kevin Klues [Tue, 18 Dec 2012 08:35:31 +0000 (00:35 -0800)]
Add header file for proper compilation

7 years agoMove position of blocking state in semaphore impl
Kevin Klues [Tue, 18 Dec 2012 08:32:44 +0000 (00:32 -0800)]
Move position of blocking state in semaphore impl

7 years agoBug in emaphoe implementation now fixed
Kevin Klues [Sat, 15 Dec 2012 21:51:10 +0000 (13:51 -0800)]
Bug in emaphoe implementation now fixed

7 years agoTest for omp hello world (not yet working)
Kevin Klues [Sat, 15 Dec 2012 05:22:09 +0000 (21:22 -0800)]
Test for omp hello world (not yet working)

7 years agoAllow sysconf to get numcpus as max_vcores() (XCC)
Kevin Klues [Sat, 15 Dec 2012 05:19:18 +0000 (21:19 -0800)]
Allow sysconf to get numcpus as max_vcores() (XCC)

7 years agofix risc-v userspace atomics
Andrew Waterman [Sat, 15 Dec 2012 05:23:33 +0000 (21:23 -0800)]
fix risc-v userspace atomics

7 years agoimplement spinlock_t without atomic_t
Andrew Waterman [Sat, 15 Dec 2012 05:18:58 +0000 (21:18 -0800)]
implement spinlock_t without atomic_t

on 64b architectures, there's no reason to use a 64b var for a 1b lock

7 years agouse spinlock_t instead of atomic_t
Andrew Waterman [Sat, 15 Dec 2012 05:17:40 +0000 (21:17 -0800)]
use spinlock_t instead of atomic_t

7 years agofor risc-v, add __spin_lock and __spin_unlock
Andrew Waterman [Sat, 15 Dec 2012 00:35:14 +0000 (16:35 -0800)]
for risc-v, add __spin_lock and __spin_unlock

7 years agouse new risc-v i/o abi
Andrew Waterman [Sat, 15 Dec 2012 00:10:00 +0000 (16:10 -0800)]
use new risc-v i/o abi

7 years agofor risc-v, assume all cores boot at same time
Andrew Waterman [Sat, 15 Dec 2012 00:08:55 +0000 (16:08 -0800)]
for risc-v, assume all cores boot at same time

7 years agofor risc-v, don't store irq mask in trapframe
Andrew Waterman [Sat, 15 Dec 2012 00:08:19 +0000 (16:08 -0800)]
for risc-v, don't store irq mask in trapframe

7 years agouse test-and-test-and-set lock
Andrew Waterman [Fri, 14 Dec 2012 23:59:56 +0000 (15:59 -0800)]
use test-and-test-and-set lock

7 years agoNeed to blow out the parlib archive before building glibc
Kevin Klues [Sat, 15 Dec 2012 03:32:17 +0000 (19:32 -0800)]
Need to blow out the parlib archive before building glibc

7 years agoPsuh dtls stuff into pthread_get/set specific
Kevin Klues [Sat, 15 Dec 2012 00:53:02 +0000 (16:53 -0800)]
Psuh dtls stuff into pthread_get/set specific

7 years agoAdd dynamic-tls (dtls) implementation to parlib
Kevin Klues [Fri, 14 Dec 2012 22:45:34 +0000 (14:45 -0800)]
Add dynamic-tls (dtls) implementation to parlib

7 years agoAdd userspace spinlock implementation
Kevin Klues [Fri, 14 Dec 2012 22:45:09 +0000 (14:45 -0800)]
Add userspace spinlock implementation

7 years agoNeeded to remove -lparlib from cp30's Makefrag
Kevin Klues [Fri, 14 Dec 2012 20:35:24 +0000 (12:35 -0800)]
Needed to remove -lparlib from cp30's Makefrag

7 years agoRemove force_parlib_symbols.
Kevin Klues [Fri, 14 Dec 2012 04:24:04 +0000 (20:24 -0800)]
Remove force_parlib_symbols.


7 years agoUse --whole-archive instead of -u for -lparlib
Kevin Klues [Fri, 14 Dec 2012 04:21:50 +0000 (20:21 -0800)]
Use --whole-archive instead of -u for -lparlib

For reasons unknown, dynamically-linked busybox simply failed to respond
to keypresses with -u force_parlib_symbols as the mechanism to force
linkage against libparlib--even though the symbols appeared not to be
weak!  This other mechanism works, and it's also cleanear since we can
remove force_parlib_symbols.

7 years agoremove old bthread library
Kevin Klues [Fri, 14 Dec 2012 03:52:57 +0000 (19:52 -0800)]
remove old bthread library

We don't use bthreads anymore, and some symbols conflicted
with those in libpthread.

7 years agoFixes mmap assertion check
Barret Rhoden [Thu, 13 Dec 2012 22:33:31 +0000 (14:33 -0800)]
Fixes mmap assertion check

Check for MAP_FAILED (-1), not 0, like other allocations...

7 years agoUserspace slab allocator
Barret Rhoden [Tue, 11 Dec 2012 00:42:36 +0000 (16:42 -0800)]
Userspace slab allocator

Note the caches lock use MCS-PDR locks, which for now call malloc() when
initializing.  So you can't currently use the slabs for something that
you need to implement malloc().

7 years agoAdded force_parlib_symbols as default param to gcc
Kevin Klues [Mon, 10 Dec 2012 23:23:53 +0000 (15:23 -0800)]
Added force_parlib_symbols as default param to gcc

Allowed us to remove the busybox patch that diabled looping over
included libs and not including them if they wre not needed.

We previously had to override this because we always wanted parlib
included, but now it is included by default as part of invoking gcc.

7 years agoAdded gcc compiler magic to get libgomp to build for akaros
Kevin Klues [Wed, 5 Dec 2012 04:31:18 +0000 (20:31 -0800)]
Added gcc compiler magic to get libgomp to build for akaros

Still need to implement stubs for pthread_key nonsense, but hopefully
after that, things will just work.

7 years agoMake exit call _exit instead of syscall directly
Kevin Klues [Wed, 5 Dec 2012 04:27:14 +0000 (20:27 -0800)]
Make exit call _exit instead of syscall directly

Needed to get libgomp to work correctly because it required its call to
exit() to be for a function that had a noreturn attribute.  Arguably, we
should have been doing this all along, and the direct syscall was
probably extreme legacy code before we had glibc properly integrated.

7 years agoMake procinfo.h c89 compliant (i.e. no gnu99isms)
Kevin Klues [Wed, 5 Dec 2012 04:25:11 +0000 (20:25 -0800)]
Make procinfo.h c89 compliant (i.e. no gnu99isms)

7 years agoChange default directory for installing riscv
Kevin Klues [Wed, 5 Dec 2012 04:24:10 +0000 (20:24 -0800)]
Change default directory for installing riscv

7 years agoImplemented a few more stubs for PTHREAD compliance
Kevin Klues [Wed, 5 Dec 2012 04:23:06 +0000 (20:23 -0800)]
Implemented a few more stubs for PTHREAD compliance

(Including signal stuff)

7 years agoAdd semaphore stuff for pthreads
Kevin Klues [Wed, 5 Dec 2012 04:21:27 +0000 (20:21 -0800)]
Add semaphore stuff for pthreads

7 years agoSpinlock irqsave usage checks
Barret Rhoden [Thu, 15 Nov 2012 19:46:32 +0000 (11:46 -0800)]
Spinlock irqsave usage checks

Controlled with CONFIG_SPINLOCK_DEBUG.  One big issue is that we usually
need locks to tell ourselves about the deadlock - print locks, kmsgs
locks, etc.  We'll need something else to deal with this.

Here's a list of all irqsave locks.  A few of them weren't even
initialized.  Others probably don't need to be irqsave.  And a few are
from some really ancient code.  Some of these were only detected at
runtime by the usage checks.

Take a look at these and any of your other locks, and fix them up

 /* sync stuff */
 list->lock (checklists)

 /* page allocation / coloring */
 colored_page_free_list_lock (arch dependent btw)

 /* slab allocator */

 /* riscv/sparc */
 cas_lock (needs attention, might not compile)

 /* console printing and reading */
 lock (x86 console lock, cons_putc needs renamed)
 output_lock (serializes all printks)
 print_info_lock (testing.c)
 ptf_lock (x86 trapframe printing lock)

 /* kmsg */

 /* misc */
 systrace_lock (does this need irqsave?)
 ucq hash locks

7 years agoSemaphores and CVs have irqsave initializers
Barret Rhoden [Thu, 15 Nov 2012 18:34:29 +0000 (10:34 -0800)]
Semaphores and CVs have irqsave initializers

We also now assert we can block when blocking.  We don't enforce the
spinlock checks yet.

7 years agoNo longer inlines spin_lock
Barret Rhoden [Thu, 15 Nov 2012 03:40:08 +0000 (19:40 -0800)]
No longer inlines spin_lock

Arch-specific locking is done in __spin_{lock,unlock,init}.  Debugging
and whatnot is all done in k/s/atomic.c.

Also adds irq_okay fields and different types of spinlock inits, based
on whether or not it is okay to use the lock in IRQ context or not.  We
don't enforce anything yet (wait for the next patch or three).

7 years agoAsserts/checks for early RKMSG context
Barret Rhoden [Wed, 14 Nov 2012 23:53:04 +0000 (15:53 -0800)]
Asserts/checks for early RKMSG context

The kernel tracks if it is in 'early routine kernel message context,'
which is an RKMSG before it blocks.  Once it blocks/kthreads, the core
leaves that context (in smp_idle), never to return for that kthread.
When the kthread starts up again, it'll be in default context.

Other than allowing us to assert messages that must be routine are in
fact routine, we can detect when a kmsg blocked, thus removing the
restriction on kmsg handler writers to put smp_idle at the bottom of
their functions.

There might be a better way to do this (permanent kthreads, track
whether it blocked in there?), but the basics are the same: when we come
back in to PRKM, we need to detect if we blocked or not, and if so, we
smp_idle.  And if not, we clear whatever flag we were using.  And that
same flag gets cleared in smp_idle as well.

7 years agoKernel context (IRQ, etc) tracking
Barret Rhoden [Wed, 14 Nov 2012 23:29:02 +0000 (15:29 -0800)]
Kernel context (IRQ, etc) tracking

We can now detect what sort of context we are in.  The main use for this
is deadlock detection.

RISC/SPARC people, take a look at your architectures please.

7 years agoKernel message overhaul
Barret Rhoden [Tue, 13 Nov 2012 22:31:12 +0000 (14:31 -0800)]
Kernel message overhaul

We no longer run routines from the IRQ handler, and no longer run
immediates from PRKM().

The difference in the former is in cases where we are in userspace and
we receive an IPI to run kernel messages.  Previously, we handled the
routine messages in the IRQ handler.  Now we do nothing, and handle them
"on the way out" (in the proc_restartcore() / smp_idle() path).

The differences in the latter are that we simply wait til we actually
get the KMSG IPI to run the immediate handlers.  Note there is no
ordering guarantees between different KMSG classes.

7 years agoMakes kmsg code arch independent
Barret Rhoden [Tue, 13 Nov 2012 22:01:37 +0000 (14:01 -0800)]
Makes kmsg code arch independent

Should be no change to functionality.  SPARC/RISCV people: see if this
works for you.  I don't have a working RISCV compiler, and does anyone
even use SPARC?  =)

7 years agoRISCV/SPARC: send_ipi() takes a vector
Barret Rhoden [Tue, 13 Nov 2012 21:52:07 +0000 (13:52 -0800)]
RISCV/SPARC: send_ipi() takes a vector

We could either make an arch-function that is "send a kernel message
IPI", which is what the current versions are doing, or extend send_ipi()
to take other vectors.

Since we might have other IPI vectors in the future, I went with this.
If it's something that is completely impossible for these architectures,
then we can do something else.

Haven't compiled this btw - I still can't run the RISCV compiler on my

7 years agox86: send_ipi takes an OS coreid
Barret Rhoden [Tue, 13 Nov 2012 21:07:35 +0000 (13:07 -0800)]
x86: send_ipi takes an OS coreid

Instead of a hw_coreid, making like the other architectures.

7 years agoKMSGs no longer self-ipi for routine messages
Barret Rhoden [Sun, 11 Nov 2012 09:07:22 +0000 (01:07 -0800)]
KMSGs no longer self-ipi for routine messages

We used to need this when we had routine messages that popped into
userspace.  The self-ipi forced us to trap back into the kernel to
process the rest of the messages.  Now that our proc management kmsgs
all return (let alone not popping into userspace), this isn't a concern.

We can still have kmsgs that don't return (like __launch_kthread()),
since we'll always run our routine KMSGs at some point in the future
(smp_idle() or proc_restartcore()).

I'd normally wait til combining all the KMSG code to do this, but the
non-x86 arches didn't have ipi_is_pending().

7 years agox86: sends the EOI earlier in the IRQ path
Barret Rhoden [Sun, 11 Nov 2012 08:58:44 +0000 (00:58 -0800)]
x86: sends the EOI earlier in the IRQ path

This makes it easier to merge all the architecture's KMSG code.  Also,
Linux does this, at least it looks like they do based on a cursory
glance a few months ago.

7 years agoGhetto benchmark test
Barret Rhoden [Wed, 21 Nov 2012 02:50:02 +0000 (18:50 -0800)]
Ghetto benchmark test

Juan had a problem with code similar to this.  If you don't do
res += whatever
and juse do
res = whatever
(his example code), then you could get varying results based on what
else you put in the loop.  Specifically, if you do some extra stuff like
a read_tsc() and track the number of loop iterations, then the critical
path of the inner loop is actually shorter than without, leading to a
10-20% performance difference.

7 years agopthread_test() and supporting changes
Barret Rhoden [Mon, 19 Nov 2012 23:56:20 +0000 (15:56 -0800)]
pthread_test() and supporting changes

The ugly bit is that the pthread 2LS wants to adjust the number of
vcores, but for testing, we want a fixed amount.  Hence the function to
toggle the bool.  We can sort out something better once we have a real

7 years agoKernel message nested function scoping
Barret Rhoden [Fri, 9 Nov 2012 16:09:47 +0000 (08:09 -0800)]
Kernel message nested function scoping

Sometimes when we define kernel message functions inside another
function, the compiler will put function's code on the stack.

This happens now with the __test_cv functions in testing.c.  It doesn't
seem to do it for others, and as far as I can tell, it will do so when
the function references stack variables.  Makes sense, since
stack-relative addresses are the only way to know where the variables

Anyway, I don't know if the compiler will ever put those functions on
the stack for other reasons.  Since it's probably a bad idea to refer to
items after their scope disappears, move the KMSG handlers outside the
scope of their caller.  If you don't, be careful.

It's tempting to use some form of synchronization to keep the
encapsulating function alive til the handlers complete, say with a flag
variable or something (which we tend to do anyways).  However, there's
still a slight race after the handler function signals and before that
code returns/pops its stack frame.

7 years agoRemoves SPARC ifdefs from blockdev code
Barret Rhoden [Fri, 9 Nov 2012 15:14:17 +0000 (07:14 -0800)]
Removes SPARC ifdefs from blockdev code

If SPARC or any other arch can't kthread, then many other things won't
work and that needs to be fixed ASAP.

7 years agoChanges semaphore API
Barret Rhoden [Fri, 9 Nov 2012 15:10:20 +0000 (07:10 -0800)]
Changes semaphore API

There now is an irqsave API, same as CVs.  All semaphore users need to
change and use irqsave if they will be called from irq context.  This
also renames sleep_on() to sem_down().  There's no awesome way to name
it, other than to know what it means to down a semaphore.

Also, we now only disable irqs when blocking a kthread for the smallest
amount of time (unless its irqsave): when we need to atomically sleep
and change to a new thread (stack).

7 years agoFixes irqsave issue with CVs
Barret Rhoden [Mon, 5 Nov 2012 21:22:34 +0000 (13:22 -0800)]
Fixes irqsave issue with CVs

Using spinlock_irqsave like that isn't sufficient.  The spinlock_irqsave
really only works across a single lock/unlock pair (it saves the irq
state in the lock).  When we unlock, we potentially reenable irqs.

During the while loop (which enforces ordering), we basically are
holding a sort of lock.  Signallers run from irq context could interrupt
us, deadlocking the system.

Instead, we just have the caller of the CV tell us if we want IRQs off
or not.  Pay attention to the note in trap.c.

In the future, I might rewrite the kthread code to use CVs instead of
semaphores, which would get rid of the while loop/ordering.  Regardless,
I still prefer having the cv_*_irqsave() functions.

7 years agoFixes sys_waitpid() to handle concurrent waiters
Barret Rhoden [Mon, 5 Nov 2012 16:11:07 +0000 (08:11 -0800)]
Fixes sys_waitpid() to handle concurrent waiters

As mentioned before, we could have concurrent syscalls from the parent
waiting on a child or any child.  The issues were trying to reap a child
that has been already reaped (by a -1 or a particular wait call), and
having the children list get emptied while sleeping (for waitpid(-1)).
Additionally, we had to be careful about syscalls blocking and never
getting a wakeup signal.

None of our apps do multiple waiting syscalls, so I haven't tested the
corner cases.

This all is an example of complications arising with concurrent syscalls in
code that would be easier with just synchronous SCPs.  Not a
deal-breaker, just a minor pain.

8 years agosys_waitpid() improvements (XCC)
Barret Rhoden [Tue, 30 Oct 2012 17:10:59 +0000 (10:10 -0700)]
sys_waitpid() improvements (XCC)

Cleans up the glibc fork/wait mess by supporting waitpid(-1).  This will
allow shells (busybox/ash) to do some decent job control with
backgrounding tasks.  Previously, we'd wait on our children in order,
instead of waiting on any available child.

This does not handle concurrent wait calls from the parent (even SCPs
could do async calls).  I'm working on that, and will have it in another
commit to serve as an example of the pain caused by concurrent process
management syscalls (whether due to async syscalls by an SCP or parallel
calls from an MCP).

Rebuild glibc.

8 years agoCondition variables
Barret Rhoden [Thu, 25 Oct 2012 21:08:13 +0000 (14:08 -0700)]
Condition variables

Built with semaphores.  This is notoriously tricky, and I might not have
done it correctly.

See http://research.microsoft.com/pubs/64242/implementingcvs.pdf for a
discussion of some of the issues.

I get around it by peaking in the semaphore and using its count as a
'lock' to enforce an ordering on waiters so that the order in which you
hit the CV is the order that you hit the internal sem.  And since it's
the sem's count, we can atomically sleep on the sem and 'release' that

8 years agoSemaphore upping done with irqsave
Barret Rhoden [Thu, 25 Oct 2012 19:39:27 +0000 (12:39 -0700)]
Semaphore upping done with irqsave

So this isn't actually necessary, but might help us in the future.

If the semaphore is never locked and then potentially interrupted, then
we're okay.  sleep_on() disables IRQs.  If there is only one IRQ handler
that ups a particular sem, then we also aren't in danger of deadlocking.

Anyway, __up_sem() is being used in a bunch of places, and might be used
somewhere in the future that could have an issue with irqsaving.  Like
if process context code was calling __up_sem() *and* there was one IRQ
handler calling __up_sem(), then we could deadlock.

8 years agokthread_yield()
Barret Rhoden [Thu, 25 Oct 2012 19:34:11 +0000 (12:34 -0700)]

Caller is suspended in a kthread, and will get woken up via RKM to the
calling core.  In essence, it pauses the kthread and allows other RKMs
to run.

If the ksched does anything fancy, we could do other things, like send
the kthread to another core.

8 years agoFixes RESET_STACKS
Barret Rhoden [Thu, 25 Oct 2012 19:31:03 +0000 (12:31 -0700)]

Need to not inline __smp_idle(), o/w the set_stack_pointer mucks with
things (specifically, it was mucking with the first word of the previous
page, which was often kthread poison).

8 years agoParent processes track children
Barret Rhoden [Mon, 22 Oct 2012 22:43:48 +0000 (15:43 -0700)]
Parent processes track children

Instead of relying on just the child having the ppid number.  Plus,
there's a little more info in the monitor commands (ps, procinfo), and
trywait was cleaned up a bit.

If the comment about why children don't keep pointers to their parents
doesn't make sense, look over the kref Documentation and think about how
we could ever safely disown a child (like if a parent terminates first).

8 years agoPOSIX signal sending / reception (XCC)
Barret Rhoden [Sat, 20 Oct 2012 00:23:24 +0000 (17:23 -0700)]
POSIX signal sending / reception (XCC)

Adds kernel support for basic POSIX inter-process signals.  We just
multiplex signals through a new Event type.  There's a kernel helper to
send signals, if you want.

Uthread code registers an ev_q for the signals, and right now just has a
dummy handler.  We'll need to hook this in to glibc for support of all
the usual signal-related functions.

Also, grab the new busybox config - it supports kill.

Rebuild your cross compiler/kernel headers and anything that linked
against parlib (like busybox).

8 years agoFixes potential race with SCPs blocking (XCC)
Barret Rhoden [Fri, 19 Oct 2012 23:00:05 +0000 (16:00 -0700)]
Fixes potential race with SCPs blocking (XCC)

If we ever received an event/notif after registering the ev_q and before
yielding, that event would cause us to clear notif_pending.  This would
cause us to sleep permanently in yield, since we already both received
the 'syscall done' event and marked its reception.

If you want to write similar code, the important thing was that we need
notifs disabled before we check the syscall's SC_DONE.

8 years agoRemoves EBADPROC
Barret Rhoden [Thu, 18 Oct 2012 22:22:22 +0000 (15:22 -0700)]

Which is really ESRCH.  No real need to reinstall your kernel headers,
unless you happen to try to compile program that was using that error

8 years agoFixes struct proc initialization
Barret Rhoden [Thu, 18 Oct 2012 22:10:53 +0000 (15:10 -0700)]
Fixes struct proc initialization

We weren't initialized the ksched_data.  Instead of adding that, or
using Ivy, we'll just memset the whole thing to 0, and then selectively
set whatever needs set (sometimes to 0 to be explicit).

8 years agoAdds proc-internals documentation
Barret Rhoden [Tue, 16 Oct 2012 21:38:12 +0000 (14:38 -0700)]
Adds proc-internals documentation

On the recent patches related to proc mgmt KMSGs and related issues.

8 years agoNo longer disables irqs when mucking with pcpui
Barret Rhoden [Mon, 15 Oct 2012 21:16:51 +0000 (14:16 -0700)]
No longer disables irqs when mucking with pcpui

For things like cur_proc, owning_{proc,vcoreid}, and cur_tf, we don't
disable interrupts when mucking with them in proc code.  We used to need
this when proc mgmt KMSGs were immediate.  So long as we continue to not
muck with that state from IRQ handlers or IMMED KMSGs, we're okay.