7 years agoMCS-PDR locks take a *qnode
Barret Rhoden [Wed, 8 May 2013 00:11:48 +0000 (17:11 -0700)]
MCS-PDR locks take a *qnode

Futex code can use either spinpdr or mcspdr, up to them.  For the
semaphore code, it was a simpler change to just change the lock style.

7 years agoMCS-PDR locks cache vcoreids
Barret Rhoden [Tue, 7 May 2013 22:25:33 +0000 (15:25 -0700)]
MCS-PDR locks cache vcoreids

We read-in the vcoreid of whoever we may need to spin on before
signalling.  This both cuts down on cache contention (less re-reading of
the pred's qnode to get the vcoreid) and gets rid of the restriction of
having qnode memory be safely accessed, even after unlocking.  Both
changes help with performance.

7 years agoSpeeds up regular MCS locks
Barret Rhoden [Tue, 7 May 2013 18:28:43 +0000 (11:28 -0700)]
Speeds up regular MCS locks

Even when the qnode is allocated on the stack (perhaps especially then),
CL aligning it reduces cache-line contention (false sharing of the CL
with the main thread using its stack).

Also this exposes some lower-level MCS locking functions.

7 years agoprov pokes the ksched after a successful provision
Barret Rhoden [Mon, 6 May 2013 01:49:23 +0000 (18:49 -0700)]
prov pokes the ksched after a successful provision

The ksched will eventually notice, and since provisioning is rare, it
shouldn't matter either way.  However, this is useful for test programs.

This also cleans up the retval work a little.

7 years agosys_poke_ksched() on behalf of other processes
Barret Rhoden [Mon, 6 May 2013 01:42:47 +0000 (18:42 -0700)]
sys_poke_ksched() on behalf of other processes

So something like 'prov' can kick the ksched to make it notice the
changes faster.  It's not a huge deal, since provisions are a
fine-grained choice, but it also doesn't hurt.  And it helps with some
testing code.

No need to rebuild the cross compiler, but you do need to rebuild any
MCP app and all of parlib.

7 years agoRemoves any restrictions on process control
Barret Rhoden [Sun, 5 May 2013 22:59:51 +0000 (15:59 -0700)]
Removes any restrictions on process control

Until we have a real solution, the half-assed "direct parent only" (or
self) control test doesn't really do much.

7 years agoAllow the killing of WAITING processes
Barret Rhoden [Sun, 5 May 2013 22:51:55 +0000 (15:51 -0700)]
Allow the killing of WAITING processes

Children are not inherited or killed or anything.  They get a parent ==
0, which is like processes launched from the monitor.

7 years agoAllow WAITING->RUNNING_S transition
Barret Rhoden [Sun, 5 May 2013 21:25:43 +0000 (14:25 -0700)]
Allow WAITING->RUNNING_S transition

Used by the proc_yield SCP path.  In this case, we're not involving the
ksched in the fake wakeup process.  Also note that the MCP yield code
doesn't need this, since it doesn't synchronize based on the process's
state (it uses the vcore's state).

7 years agoFixes race in SCP yielding (again) (XCC)
Barret Rhoden [Sun, 5 May 2013 20:45:40 +0000 (13:45 -0700)]
Fixes race in SCP yielding (again) (XCC)

979bce86 had the right idea, just the wrong code.  Took a while to
actually have this happen (usleep 1 wasn't sufficient, even in a loop.
Had to have a few other things going on).

7 years agoDefines ACCESS_ONCE(x) macro (XCC)
Barret Rhoden [Sat, 4 May 2013 06:41:57 +0000 (23:41 -0700)]
Defines ACCESS_ONCE(x) macro (XCC)

This forces a one-time read of the value x.   I've been meaning to do
this for a while - we have a lot of synchronization code that assumes
that data is only loaded once, at a specific point in time.  Eventually
I'll go through older code and start using this.

Check out http://lwn.net/Articles/508991/ for more info.

This will also help with code that wants to force a read-in (say, from
global state to thread state) for performance reasons.

Keep in mind that we continue to need memory barriers, like the wmb(),
wrmb(), etc, since this has nothing to do with the processor's ordering
of operations, and also has nothing to do with writing values.

This is fairly similar to a cmb(), in that both tell the compiler that
memory values may have changed.  One slight difference is that a cmb()
(and rmb/wmb on x86) involves an asm volatile, which should prevent the
compiler from reordering the accesses (I think!).  AFAIK, the compiler
could reorder:

local_x = ACCESS_ONCE(x);
local_y = ACCESS_ONCE(y);

and if it is important to actually read x before y, then you want to do:

local_x = ACCESS_ONCE(x);
rmb(); /* on x86, this is just an asm volatile("" ::: "memory") */
local_y = ACCESS_ONCE(y);

The rmb() orders the x and y reads, and the ACCESS_ONCE prevents the
compiler from trying to read in x in the future when using local_x.

Finally, note that any use of an rwmb() (where we want to enforce the
read happens before the write) will probably want to use an ACCESS_ONCE,
unless we are okay with reading the value again after the write.

Reinstall your kernel header.

7 years agoAdds helper program for reading max_vcores
Barret Rhoden [Sat, 4 May 2013 05:51:35 +0000 (22:51 -0700)]
Adds helper program for reading max_vcores

This is used by shell scripts to get max_vcores.  We don't have pipes
working yet, so the answer is passed via the return value.  You can do
something like:

pthread_test $MAXVC 9999999999999999 $MAXVC &

to launch pthread test so that it will run forever and want all of the
cores available.

7 years agoChanges formatting on prov and pthread_test
Barret Rhoden [Sat, 4 May 2013 05:50:42 +0000 (22:50 -0700)]
Changes formatting on prov and pthread_test

7 years agoRemoves redundant event handler, exposes others
Barret Rhoden [Fri, 3 May 2013 23:46:40 +0000 (16:46 -0700)]
Removes redundant event handler, exposes others

The old handler wasn't being used - was overwritten by uthread code.
The main difference is that the uthread handler knows how to deal with
the CAN_RCV_MSG flag.

This also exposes the uthread's preemption/indir handlers, so that
applications can wrap the handlers with their own handlers.

7 years agoChecks addr + len after adjusting addr in mmap()
Barret Rhoden [Fri, 3 May 2013 23:09:23 +0000 (16:09 -0700)]
Checks addr + len after adjusting addr in mmap()

When setting addr to BRK_END for anonymous mappings, we could have an
addr + len that passes UMAPTOP.

7 years agoFixes bug with ksched running while an SCP dies
Barret Rhoden [Wed, 1 May 2013 00:36:52 +0000 (17:36 -0700)]
Fixes bug with ksched running while an SCP dies

The local SCP could be dying (via an exit(), for example), but before
the __death KMSG is sent, and IRQ triggers the ksched tick KMSG, which
will happen before __death.

Notice we can't send a __ksched_tick message, since that would rearm the
(probably) already armed alarm, using the same awaiter.  This would
result in a few problems, one of which was runaway __ksched_tick kmsgs
that exhaust the system's memory...

This is a little clunky, in that the ksched needs to deal with this.  An
alternative would be to make launching an SCP (proc_run_s()) operate
with RKMs, or make SCP death *not* use RKMs.

7 years agoAdds helper program to sleep / block
Barret Rhoden [Tue, 30 Apr 2013 22:25:19 +0000 (15:25 -0700)]
Adds helper program to sleep / block

$ usleep MICROSEC

7 years agoFixes race with vcore_yield()
Barret Rhoden [Mon, 29 Apr 2013 22:22:58 +0000 (15:22 -0700)]
Fixes race with vcore_yield()

In some scenarios, the kernel would think we wanted <= 0 cores
(negatives triggered the > max_vcores() check), if we were yielding
repeatedly while messages arrived.

7 years agoFixes x86 FPU initialization
Barret Rhoden [Fri, 26 Apr 2013 18:54:15 +0000 (11:54 -0700)]
Fixes x86 FPU initialization

Need to clear the FPU header state before saving the default copy.  My
guess is the PXE agent / bootloader used FP and left us with a full,
dirty FP stack.  Though perhaps the CPU just decided to start like that.
Either way, that bad state was bleeding through to the SCPs / thread0s,
which increase the likelihood of errors in apps (CFL errors in
fluidanimate, which can also cause page faults).

7 years agoAllows XCC building with newer texinfo (XCC)
Barret Rhoden [Wed, 24 Apr 2013 23:09:51 +0000 (16:09 -0700)]
Allows XCC building with newer texinfo (XCC)

binutils and stage2 of gcc are building some documentation that has a
few bugs:

We just disable the building, using the method described in

If you've been purposefully using old versions of texinfo, please
upgrade and test this out.  Works on my gentoo box.  You'll need to rm
the builddirs and hidden configure files in tools/compilers/gcc-glibc/.

7 years agoCleans up run_uthread helpers
Barret Rhoden [Wed, 24 Apr 2013 21:49:06 +0000 (14:49 -0700)]
Cleans up run_uthread helpers

Running a current uthread is different enough from running a new uthread
to have separate functions, esp with all of the asserts.  And less

Note I stopped double-checking events - that's a huge pain.

7 years agoFixes saving FP state when copying out uthreads
Barret Rhoden [Wed, 24 Apr 2013 02:11:41 +0000 (19:11 -0700)]
Fixes saving FP state when copying out uthreads

We weren't saving the state from the FPU when we copyout/paused uthreads
on the local/calling core.

7 years agoFixes x86 SW context FP restore
Barret Rhoden [Wed, 24 Apr 2013 01:49:35 +0000 (18:49 -0700)]
Fixes x86 SW context FP restore

The FPU stack could have registers in it, either due to old FP loads, or
due to MMX usage (which marks the entire stack as full).  The ABI
expects an empty stack.  Conveniently enough emms clears it, even though
8.1.7 doesn't mention it.

7 years agox86 FP exception/error parsing
Barret Rhoden [Tue, 23 Apr 2013 23:52:15 +0000 (16:52 -0700)]
x86 FP exception/error parsing

We don't handle any FP errors in software, but we will tell you why we
killed your program!  (These errors are more likely due to system
software not restoring your FPU state properly).

7 years agoKills processes when MAP_POPULATE fails
Barret Rhoden [Mon, 22 Apr 2013 22:03:15 +0000 (15:03 -0700)]
Kills processes when MAP_POPULATE fails

Still have some issues with running out of memory: proc_destroy()
consumes memory (sending kernel messages, possibly blocking in the FS
when closing files), busybox doesn't wait on the dying process right
away, and the rest of the system is still running.

7 years agox86 userspace uses software contexts (XCC)
Barret Rhoden [Sat, 20 Apr 2013 22:12:24 +0000 (15:12 -0700)]
x86 userspace uses software contexts (XCC)

These are for all software-controlled threading/yielding
(uthread_yield()), but not for syscall/sysenter yet.

Reinstall kernel headers / rebuild parlib and applications.

7 years agoAdds syscall for help entering VC context (XCC)
Barret Rhoden [Mon, 22 Apr 2013 19:11:15 +0000 (12:11 -0700)]
Adds syscall for help entering VC context (XCC)

We had been using sys_self_notify for this, but I actually want
something that doesn't require a specific vcoreid and just acts on the
calling pcore.

There are a couple cases with the old style where we could send
(harmless) notifs to the wrong core.  If the uthread were interrupted
and migrated right after it decided to self_notify, when it was repopped
in the future, it would notify its old vcore.

The other nice thing about this is that we don't need to worry about the
storage space for the syscall, simplifying our pop code a bit.  I didn't
bother removing the local_sysc from the restart_helper.  Not worth the
hassle, and I'll do it on the next rewrite of the HW TF stuff.

Reinstall kernel headers, rebuild parlib + apps.

7 years agox86: detect FS/GS MSRs
Barret Rhoden [Mon, 22 Apr 2013 18:30:27 +0000 (11:30 -0700)]
x86: detect FS/GS MSRs

On some machines (like the Nehalem), there are MSRs for the kernel to
access FS and GS base.  Not to be confused with the even newer support
for userspace access to those MSRs via {RD,WR}{FS,GS}BASE instructions.

7 years agox86: initialize XMM registers along with x87
Barret Rhoden [Fri, 19 Apr 2013 18:30:27 +0000 (11:30 -0700)]
x86: initialize XMM registers along with x87

In the future (or in RISCV), someone might have an init_fp_state() that
is super-efficient.  If it turns out that manually zeroing the XMM
registers is faster, then we can change the code.  I haven't
microbenchmarked the new way or compared it to 0'ing the 15 XMM
registers + loading the MXCSR yet.

7 years agoFixes assert typo
Barret Rhoden [Wed, 24 Apr 2013 22:18:17 +0000 (15:18 -0700)]
Fixes assert typo

7 years agoImprove RISC-V cpu_relax
Andrew Waterman [Tue, 23 Apr 2013 12:20:54 +0000 (05:20 -0700)]
Improve RISC-V cpu_relax

Before, it executed a tight loop, which isn't energy efficient.  Now,
it divides 0 by 0 and "uses" the result, which, on our in-order
microarchitectures, results in a long-latency stall that doesn't burn too
much energy.

7 years agoImplement backtrace for RISC-V
Andrew Waterman [Tue, 23 Apr 2013 12:20:11 +0000 (05:20 -0700)]
Implement backtrace for RISC-V

We now have a working frame pointer when -fno-omit-frame-pointer is given.

7 years agoMove read/write_fsr so they're visible to userland
Andrew Waterman [Tue, 23 Apr 2013 12:17:38 +0000 (05:17 -0700)]
Move read/write_fsr so they're visible to userland

7 years agoFormatting/renaming some RISC-V stuff
Andrew Waterman [Tue, 23 Apr 2013 11:37:34 +0000 (04:37 -0700)]
Formatting/renaming some RISC-V stuff

7 years agoAlways keep floating point enabled on RISC-V
Andrew Waterman [Tue, 23 Apr 2013 11:24:24 +0000 (04:24 -0700)]
Always keep floating point enabled on RISC-V

7 years agoUpdate save_kernel_tf_asm to use new calling conv.
Andrew Waterman [Tue, 23 Apr 2013 11:22:28 +0000 (04:22 -0700)]
Update save_kernel_tf_asm to use new calling conv.

7 years agoImplement save/restore_fp_state for RISC-V
Andrew Waterman [Tue, 23 Apr 2013 10:58:02 +0000 (03:58 -0700)]
Implement save/restore_fp_state for RISC-V

7 years agoSuppress warning and fix assert in proc_pop_ctx
Andrew Waterman [Tue, 23 Apr 2013 10:03:03 +0000 (03:03 -0700)]
Suppress warning and fix assert in proc_pop_ctx

7 years agoBypass GOT/PLT for __ros_syscall within libc
Andrew Waterman [Tue, 23 Apr 2013 06:35:18 +0000 (23:35 -0700)]
Bypass GOT/PLT for __ros_syscall within libc

Bypassing the global offset table removes one level of indirection in the
syscall path.  On RISC-V, a call via the GOT is three instructions, including
a load, whereas a direct call is a single instruction with no data memory
access.  The situation in x86 is analogous, though it's the PLT and
instruction cache that are bypassed, rather than the GOT and data cache.
(FWIW, the difference is due to self-modifying code being cheap on x86.)

In general, libc_hidden_proto/libc_hidden_def have this effect, but they
should only be used when interposition isn't necessary (e.g. you can't use
LD_PRELOAD to override function definitions if the PLT is bypassed).

7 years agoReimplement writev to not access errno on success
Andrew Waterman [Mon, 22 Apr 2013 22:24:56 +0000 (15:24 -0700)]
Reimplement writev to not access errno on success

Like the previous commit, this helps when debugging ld.so, since TLS may
not yet be initialized.

7 years agoDon't write/obtain errno unless sysc.err is set
Andrew Waterman [Mon, 22 Apr 2013 22:20:14 +0000 (15:20 -0700)]
Don't write/obtain errno unless sysc.err is set

This is mostly a performance optimization, but it also allows syscalls
to be executed before TLS is set up.  This helps when debugging ld.so.

7 years agoSupport new risc-v calling convention
Andrew Waterman [Mon, 22 Apr 2013 22:05:08 +0000 (15:05 -0700)]
Support new risc-v calling convention

7 years agofill-kfs strips only debug info from libc.so/ld.so
Andrew Waterman [Mon, 22 Apr 2013 22:01:40 +0000 (15:01 -0700)]
fill-kfs strips only debug info from libc.so/ld.so

7 years agoFixes bug with pop_ros_ctx (x86)
Barret Rhoden [Fri, 19 Apr 2013 01:51:37 +0000 (18:51 -0700)]
Fixes bug with pop_ros_ctx (x86)

Again, much like 2612bab3, removing the memset in 0a19848d0 caused
another bug, where we were no longer sending in EV_NONE and a null
message.  Having a gibberish message led to sending very high event
numbers, which was basically a quasi-random function pointer.

Good times!

7 years agoUthreads handle FP save and restore
Barret Rhoden [Thu, 18 Apr 2013 22:50:08 +0000 (15:50 -0700)]
Uthreads handle FP save and restore

RISCV / SPARC, please take a look at your code (TODO).  I didn't just
inline it, in case you want to put the code in C files in your subdirs.

7 years agoUthreads need to be aligned when allocated
Barret Rhoden [Thu, 18 Apr 2013 22:45:24 +0000 (15:45 -0700)]
Uthreads need to be aligned when allocated

All threading libraries need to force alignment with posix_memalign,
since the ancillary state requires greater than 8 byte alignment.

7 years agoRemoves env_push/pop of FPU state
Barret Rhoden [Wed, 17 Apr 2013 23:13:36 +0000 (16:13 -0700)]
Removes env_push/pop of FPU state

RISC and SPARC: please check out your fp_state functions (like save,
restore, init).

7 years agoKernel properly handles floating point (XCC)
Barret Rhoden [Wed, 17 Apr 2013 23:07:44 +0000 (16:07 -0700)]
Kernel properly handles floating point (XCC)

The kernel saves and restores floating point rather aggressively.  There
are a couple corner cases where we can avoid saving state, such as when
a uthread makes a syscall and gets preempted before the call returns.

The use of the TS flag is actually quite problematic.  We'd need to
reflect it to userspace via VCPD, and it would end up acting as a taint
if uthreads migrate between vcores.  Keep in mind that userspace can't
reset TS on its own, and any attempt to save callee-saved FP state (like
on a user-level context switch) will result in a trap, forcing the FPU
to be turned on.

Rebuild parlib and all applications.

7 years agoUthread arch-dependent code uses user_contexts
Barret Rhoden [Mon, 15 Apr 2013 21:28:26 +0000 (14:28 -0700)]
Uthread arch-dependent code uses user_contexts

Still use HW contexts in all architectures, but each arch can make the
change to SW contexts (for uthreads and syscalls) at their leisure.

7 years agoProcdata uses user_contexts (XCC)
Barret Rhoden [Sat, 13 Apr 2013 02:59:45 +0000 (19:59 -0700)]
Procdata uses user_contexts (XCC)

This changes the kernel interface from struct trapframes to struct
user_contexts.  I also found some ancient documentation, though I'm sure
a lot more of it is out of date (esp regarding preemption).

Userspace libraries (and ancient ghetto test programs...) use the new
kernel interface, though the user-level arch-dependent functions still
operate on HW TFs (instead of contexts).

Also, c3po looks like it might not work; not sure what its deal is/was.

7 years agoRenames struct trapframe -> hw_trapframe (XCC)
Barret Rhoden [Sat, 13 Apr 2013 01:26:08 +0000 (18:26 -0700)]
Renames struct trapframe -> hw_trapframe (XCC)

VCPD still uses the HW TFs, instead of contexts.

7 years agoKernel arch-dependent functions use user_contexts
Barret Rhoden [Sat, 13 Apr 2013 00:57:52 +0000 (17:57 -0700)]
Kernel arch-dependent functions use user_contexts

It's up to each arch to determine how they will use the HW and SW TFs in
the user_context, including callee-saved FP state.

Just to help with bugs, I put some asserts in each arch's pop_ctx.

7 years agoKernel uses user_contexts, instead of TFs
Barret Rhoden [Fri, 12 Apr 2013 23:50:33 +0000 (16:50 -0700)]
Kernel uses user_contexts, instead of TFs

Pcpui changed to use user_contexts.  Changes set_current_tf to ctx
variants.  Proc and other arch-independent code are all converted.

The kernel headers (and therefore userspace) still use TFs, and
arch-dependent code (like init_tf and pop_tf) still use TFs.

7 years agoChanges hardware trapframe calls to use new struct
Barret Rhoden [Fri, 12 Apr 2013 00:44:50 +0000 (17:44 -0700)]
Changes hardware trapframe calls to use new struct

All places where we used a struct trapframe and that was a HW trapframe
(compared to a SW trapframe or user_context) now use the new struct

I considered removing the TF from the monitor calls, since I don't see
much use in it.  Monitor functions that want to use it can't assume it
is there (only ever called from breakpoint).  Maybe we'll find a
debugging use for it.

7 years agoKernel messages no longer take *tf
Barret Rhoden [Thu, 11 Apr 2013 22:14:10 +0000 (15:14 -0700)]
Kernel messages no longer take *tf

I've been considering getting rid of this for a while - it is mostly an
artifact of old-school KMSGs that operated on running TFs, which was
from back before we were tracking the user-tf via pcpui->cur_tf.  Those
old messages wanted to operate on the user context, not whatever
hardware TF happened to be running at the time the KMSG executes.

7 years agoUses kernel_ctx instead of TF for kthreading
Barret Rhoden [Thu, 11 Apr 2013 16:56:43 +0000 (09:56 -0700)]
Uses kernel_ctx instead of TF for kthreading

We're trying to be more explicit about what sort of trapframe we're
using at any given time.

This also gives us a layer of code indirection (it should compile the
same for now) that may be helpful later.

7 years agoSwitches kernel trap.h #include order
Barret Rhoden [Thu, 11 Apr 2013 16:33:35 +0000 (09:33 -0700)]
Switches kernel trap.h #include order

All places (other than asm) should include trap.h, not arch/trap.h, such
that the main kernel include is the 'gateway' header to all trap
functionality, just like ros/trapframe.h, atomic.h, etc.

I can see pros and cons of doing it this way vs the older way (arch
first), but I'm leaning towards arch-second unless someone has a really
good reason not to (even knowing that we'll have to be careful where we
 #include the arch file, like in atomic.h).

7 years agoDefines new struct user_context (XCC)
Barret Rhoden [Thu, 11 Apr 2013 01:32:03 +0000 (18:32 -0700)]
Defines new struct user_context (XCC)

Changes some #includes to get everyone calling ros/trapframe.h instead
of ros/arch/trapframe.h.

7 years agoPerf debug test
Barret Rhoden [Thu, 4 Apr 2013 23:10:46 +0000 (16:10 -0700)]
Perf debug test

Based on one of fluidanimate's stages.  Runs a little faster on Linux
for some reason.  If the perf of an MCP is significantly worse than an
SCP, then check for SpeedStep / Turbomode.

7 years agoPthread barrier work
Barret Rhoden [Mon, 1 Apr 2013 20:48:07 +0000 (13:48 -0700)]
Pthread barrier work

Pthreads will block on a barrier now, instead of spinning and yielding
(pthread_yield() would keep them on the runqueue).

Not clear yet what is the best spin/block strategy.  !threads_active is
safe, but not always optimal.

7 years agoAdds an OS-agnostic header for TSC readings
Barret Rhoden [Fri, 29 Mar 2013 21:49:51 +0000 (14:49 -0700)]
Adds an OS-agnostic header for TSC readings

Linux programs can #include tsc-compat.h to get similar calls to Akaros
library calls for reading the tsc and gettings its frequency.

If someone feels inclined, they can write an overhead detector for
Linux, being mindful of IRQs and the ksched.

7 years agoNotes on cross-linking applications
Barret Rhoden [Thu, 28 Mar 2013 23:43:48 +0000 (16:43 -0700)]
Notes on cross-linking applications

Check out the txt file for info on linking files compiled for another
OS (Akaros / Linux).

7 years agoMake 'make fill-kfs' more minimalist
Andrew Waterman [Wed, 27 Mar 2013 23:43:07 +0000 (16:43 -0700)]
Make 'make fill-kfs' more minimalist

7 years agoFix spurious panics on RISC-V keystrokes
Andrew Waterman [Wed, 27 Mar 2013 23:42:25 +0000 (16:42 -0700)]
Fix spurious panics on RISC-V keystrokes

7 years agoFix alignment in UCQ headers (XCC)
Barret Rhoden [Wed, 27 Mar 2013 23:14:15 +0000 (16:14 -0700)]
Fix alignment in UCQ headers (XCC)

The char[] wasn't aligned nicely for the spinlock.

Reinstall your kernel headers and rebuild userspace/tests.

7 years agoForce userclean before installing libs in (XCC)
Kevin Klues [Wed, 27 Mar 2013 22:20:03 +0000 (15:20 -0700)]
Force userclean before installing libs in (XCC)

7 years agoRemove dependency on go loanguage for ros-gcc
Kevin Klues [Wed, 27 Mar 2013 21:44:52 +0000 (14:44 -0700)]
Remove dependency on go loanguage for ros-gcc

7 years agoImplement atomic_add_not_zero using LR/SC directly
Andrew Waterman [Wed, 27 Mar 2013 10:22:30 +0000 (03:22 -0700)]
Implement atomic_add_not_zero using LR/SC directly

It takes fewer instructions than the CAS loop and should be less

7 years agoRemove ROS_MEM_ALIGN, etc. macros
Andrew Waterman [Wed, 27 Mar 2013 10:21:30 +0000 (03:21 -0700)]
Remove ROS_MEM_ALIGN, etc. macros

Manually rounding up sizeof(struct pbuf) to the pointer size is unnecessary
because the struct contains pointers.  Also, some targets have pointer more
stringent alignment requirements than 4.

7 years agoDon't build riscv-ros-gccgo (for now)
Andrew Waterman [Wed, 27 Mar 2013 10:04:05 +0000 (03:04 -0700)]
Don't build riscv-ros-gccgo (for now)

7 years agoIsolate x86-specific code in recently-added tests
Andrew Waterman [Wed, 27 Mar 2013 10:02:56 +0000 (03:02 -0700)]
Isolate x86-specific code in recently-added tests

7 years agoAdd RISC-V CAS via load-reserved/store conditional
Andrew Waterman [Wed, 27 Mar 2013 09:59:49 +0000 (02:59 -0700)]
Add RISC-V CAS via load-reserved/store conditional

7 years agoe1000: fix resetting bug
Barret Rhoden [Tue, 26 Mar 2013 22:44:15 +0000 (15:44 -0700)]
e1000: fix resetting bug

Need to replace our buggy e1000 with a real one.

7 years agoPthread cond_broadcast amortizes 2LS runnable ops
Barret Rhoden [Tue, 26 Mar 2013 04:21:25 +0000 (21:21 -0700)]
Pthread cond_broadcast amortizes 2LS runnable ops

Saves quite a bit on broadcast-heavy applications, especially if the
queue lock is heavily contended.

7 years ago2LSs don't always call uthread_runnable
Barret Rhoden [Tue, 26 Mar 2013 03:49:04 +0000 (20:49 -0700)]
2LSs don't always call uthread_runnable

More like, they are allowed to call their own sched op, instead of
always calling out to the uthread code.  The uthread wrapper is just
meant for external code that doesn't know the name of the sched op.
This will help with batch wakeup functions.

7 years agoe1000: better device detection
Barret Rhoden [Sat, 23 Mar 2013 21:48:38 +0000 (14:48 -0700)]
e1000: better device detection

Can now detect c89's two e1000 cards.  But we still can only config one
of them...

7 years agoRemoves extraneous x86 net files
Barret Rhoden [Sun, 24 Mar 2013 00:26:17 +0000 (17:26 -0700)]
Removes extraneous x86 net files

Looks like these were accidentally created in 32d657d, but aren't
actually in use.

7 years agoMove nic_common.h and nic_common.c to mainline
Andrew Waterman [Sat, 23 Mar 2013 23:50:53 +0000 (16:50 -0700)]
Move nic_common.h and nic_common.c to mainline

Happily, there was nothing x86-specific about them!

7 years agoUse ssize_t for recv etc. return type
Andrew Waterman [Sat, 23 Mar 2013 23:41:33 +0000 (16:41 -0700)]
Use ssize_t for recv etc. return type

Just another 32b/64b compatibility issue

7 years agoRemove __INT64_C etc. macros, as GCC provides them
Andrew Waterman [Sat, 23 Mar 2013 23:40:18 +0000 (16:40 -0700)]
Remove __INT64_C etc. macros, as GCC provides them

7 years agohandle RISC-V keyboard interrupts properly
Andrew Waterman [Sat, 23 Mar 2013 23:39:25 +0000 (16:39 -0700)]
handle RISC-V keyboard interrupts properly

Rather than piggybacking on the IPI handler, that is.

7 years agoSimplify RISC-V page_alloc_init
Andrew Waterman [Sat, 23 Mar 2013 23:20:35 +0000 (16:20 -0700)]
Simplify RISC-V page_alloc_init

7 years agoUpdate command for invoking RISC-V ISA simulator
Andrew Waterman [Sat, 23 Mar 2013 23:18:54 +0000 (16:18 -0700)]
Update command for invoking RISC-V ISA simulator

7 years agoUpdate RISC-V XCC toolchain
Andrew Waterman [Sat, 23 Mar 2013 23:16:14 +0000 (16:16 -0700)]
Update RISC-V XCC toolchain

I folded the gcc 4.6 patch to support compilation under gcc 4.7 into the
RISC-V patches.

7 years agoTests now build with -lm
Barret Rhoden [Sat, 23 Mar 2013 02:53:41 +0000 (19:53 -0700)]
Tests now build with -lm

Used in some upcoming tests, and doesn't hurt the existing ones.

7 years agoPthread condition variables redone
Barret Rhoden [Sat, 23 Mar 2013 02:51:40 +0000 (19:51 -0700)]
Pthread condition variables redone

Now they block in the 2LS, instead of spinning like on an HPC barrier.
The test is basically the same as the one in the kernel, maybe a bit
better (definitely clearer, due to yields and join calls).

7 years agoDon't populate / fault in prot == 0 pages
Barret Rhoden [Sat, 23 Mar 2013 02:36:09 +0000 (19:36 -0700)]
Don't populate / fault in prot == 0 pages

We get the warning on line 551 a lot, from glibc/malloc.  It's probably
because we're always MAP_POPULATING, regardless of what is asked for.
Note that you shouldn't try to populate a prot == 0.

Now that the warning might mean something, we'll actually look at it.

7 years agoMerge origin/netpush (networking code) (XCC)
Barret Rhoden [Fri, 22 Mar 2013 00:04:19 +0000 (17:04 -0700)]
Merge origin/netpush (networking code) (XCC)

Had some compilation issues (missing mbuf.h, etc), but compiles now.

Other than basic conflicts, this also was using the old semaphore style,
as well as having a few other issues in semaphore usage, so please check
that out.

Rebuild your cross compiler.  There are a bunch of new files in the -ros
folder, so either copy them over, or just make clean.  Here are the new
glibc files:



7 years agoMore simple fixes.
David Zhu [Thu, 4 Oct 2012 01:02:51 +0000 (18:02 -0700)]
More simple fixes.
Last time the cross compilation did not complete from scratch.

7 years agoPadding in MCS-PDR qnodes (XCC)
Barret Rhoden [Wed, 20 Mar 2013 23:29:32 +0000 (16:29 -0700)]
Padding in MCS-PDR qnodes (XCC)

Check the comment about weird padding issues.  Either way, we want some
padding.  Too much wasn't right either, for some reason.

Reinstall kernel headers.

7 years agoKernel uses ARCH_CL_SIZE (XCC)
Barret Rhoden [Wed, 20 Mar 2013 23:28:56 +0000 (16:28 -0700)]
Kernel uses ARCH_CL_SIZE (XCC)

Instead of the older HW_CACHE_ALIGN or whatever.

Reinstall kernel headers.

7 years agofix up for sys_listen
David Zhu [Sun, 30 Sep 2012 21:10:50 +0000 (14:10 -0700)]
fix up for sys_listen

7 years agoaccept function and wake up logic
David Zhu [Sun, 30 Sep 2012 17:35:58 +0000 (10:35 -0700)]
accept function and wake up logic

7 years agoRemoves the MCS-PDR lock holder optimization (XCC)
Barret Rhoden [Wed, 20 Mar 2013 22:17:50 +0000 (15:17 -0700)]
Removes the MCS-PDR lock holder optimization (XCC)

Was an optimization for making preemption recovery fast, but was making
the locking common case slow.

Reinstall your kernel headers if you want (it'll still build okay).

7 years agoMCS PDR locks use memalign
Barret Rhoden [Wed, 20 Mar 2013 22:15:10 +0000 (15:15 -0700)]
MCS PDR locks use memalign

To ensure we get the right alignment, and not only the right size, for
the malloc'd qnodes.

7 years agoBasic socket stubs and functionalities.
David Zhu [Fri, 14 Sep 2012 00:03:19 +0000 (17:03 -0700)]
Basic socket stubs and functionalities.

Putting the socket interface in place, and some initial implementation of sockets
for tcp.

7 years agoinitial tcp commit!
David Zhu [Sun, 13 May 2012 21:40:32 +0000 (14:40 -0700)]
initial tcp commit!

Things that may break, IP options, out of sequence packet handling, etc.

7 years agox86: tsc cycles test
Barret Rhoden [Tue, 19 Mar 2013 18:39:23 +0000 (11:39 -0700)]
x86: tsc cycles test

Simple benchmark to determine if TSC ticks are equivalent to cycles,
given that the CPU frequency doesn't vary.

7 years agox86: handle overflow when setting the lapic timer
Barret Rhoden [Tue, 19 Mar 2013 01:40:27 +0000 (18:40 -0700)]
x86: handle overflow when setting the lapic timer

Note that if you have a long-running alarm and a short periodic alarm
that goes off frequently, the long-runner will continue to be reset
every time the periodic runs off.  For a brief moment, the long-runner
will be the next up, which will cause an overflow calculation, til the
periodic resets itself (depending on the nature of the periodic reset.
The ksched does the reset outside of the handler, for instance).

7 years agox86: changes LAPIC timer divisor to 32
Barret Rhoden [Tue, 19 Mar 2013 00:25:44 +0000 (17:25 -0700)]
x86: changes LAPIC timer divisor to 32

Seems like a reasonable choice.  128 wasn't working on c89, since the
bus was so slow (100MHz) that we couldn't express 1 usec.  We could
allow some runtime setting/resetting, but 32 should be fine for anything
we need.

7 years agoPXELINUX booting configs
Barret Rhoden [Sat, 16 Mar 2013 05:53:09 +0000 (22:53 -0700)]
PXELINUX booting configs

Feel free to use my PXE make target (for those of your with access).