9 years agoKernel static mappings grow down, APICs remapped
Barret Rhoden [Sat, 11 Jun 2011 00:51:03 +0000 (17:51 -0700)]
Kernel static mappings grow down, APICs remapped

The KERNBASE physical memory mapping still grows up from KERNBASE to the
top of virtual memory.  This top is now KERN_VMAP_TOP, instead of the
old IOAPIC_BASE.  If you arch needs the kernel to never map above a
certain VA, then set this.  RISCV needs it due to its crazy static
kernel aliasing.

RISCV side note: I moved the "max vaddr" stuff (formerly IOAPIC) to the
size dependent code in mmu.h, since I think the old version was wrong
for 32 bit versions.  Feel free to move it back.

All non-KERNBASE mappings will now grow down from KERNBASE, such as VPT,
and the APICs (L and IO).  Any static ones your arch needs should be
defined, and set the value KERN_DYN_TOP at the bottom of the last one.
From this point, all dynamic mappings will occur (in future patches,
when we have dynamic mappings), down to ULIM.

While the LAPIC and IOAPIC don't need to be a part of the kernel
interface (in ros/mmu.h or memlayout.h), the VPT symbol does for now, so until
we figure out how to use the UVPT, I'm leaving it there.

Also, the LAPIC and IOAPIC are now mapped in their new locations, which
are still called LAPIC_BASE nand IOAPIC_BASE.  Previously that name was
overloaded for both VA and PA, and now the PAs have are *_PBASE.

9 years agoExt2: helper function pointers take longs
Barret Rhoden [Wed, 8 Jun 2011 22:20:40 +0000 (15:20 -0700)]
Ext2: helper function pointers take longs

Instead of void*s.  Same deal as with the kernel messages.  Also note
that ext2 uses 32bit ints a lot (like with load_inode()), since it is
part of the disk format.

9 years agoKernel message parameters are now longs
Barret Rhoden [Wed, 8 Jun 2011 21:17:51 +0000 (14:17 -0700)]
Kernel message parameters are now longs

Instead of void*s.  This helps code be 64-bit friendly, and we avoid
casting to and from pointers when we don't care about pointers.

9 years agoUTOP -> UWLIM
Barret Rhoden [Wed, 8 Jun 2011 20:49:41 +0000 (13:49 -0700)]

Clarifies (and fixes) the confusing usage of UTOP as the upper limit to
user-writable VAs.  ULIM is the max accessible, and UWLIM is the max

This touches the kernel headers, but the values haven't changed so you
shouldn't need to rebuild glibc or anything.

9 years agoDefault/static stacks are now PGSIZE
Barret Rhoden [Wed, 8 Jun 2011 20:18:06 +0000 (13:18 -0700)]
Default/static stacks are now PGSIZE

We might up it to two pages in the future, but whatever we do needs to
be kept in sync with kthread stacks, which are one page.

9 years agoRemoved KSTACKTOP
Barret Rhoden [Wed, 8 Jun 2011 19:29:21 +0000 (12:29 -0700)]

This was the virtual mapping of core0's kernel stack (aka, bootstack)
into space below KERNBASE.  We actually haven't even used the virtual
mapping for about 8 months - since kthreadding back in d6177dffd9735.

9 years agoAtomics rewrite (XCC)
Barret Rhoden [Wed, 8 Jun 2011 01:29:10 +0000 (18:29 -0700)]
Atomics rewrite (XCC)

The atomics have been slowly drifting out of control, esp with 64-bit
unfriendliness; this patch ought to fix some things.

1) All atomic ops take an atomic_t*, and if there are values added or
subtracted, they are longs.  The atomic_t helps ensure we only use
atomic ops on atomic variables.

2) Atomic ops on other types have their own functions, denoting the
type, such as atomic_cas_u32().  Careful using these, since you may have
other references to those vars that aren't atomic.

3) BCQs use u32s for their buffer indexes.  If we have programs that are
32 bit on a 64 bit kernel, we would have trouble if we tried using 64
bit values.

4) k/i/atomic.h now is the source of the function prototypes.  They are
extern inlines, which requires -fgnu-89inline (which we've been using),
allowing arches to implement the functions however they'd like, such as
with static inlines or with a regular function (like x86's
spinlock_debug() or riscv's CAS ops).

5) Some users of atomic_swap were cleaned up to represent its status as
an atomic, mostly in userlevel locking code.  Userlevel condition
variables use swap_u32(), which may not be what people want.  That bit
of code is a bit unmaintained at this point.

6) Userspace does not unify its atomics in an inc/atomic.h, since glibc
has its own atomic.h.  There will be a reckoning for userspace at some
point, dealing with the collision of atomic naming with glibc.  It's not
really the kernel's concern.  Also note that I didn't want to force the
-fgnu89-inline on userspace.

7) Rebuild your cross compiler/glibc.  Everything compiles on sparc and
x86.  I haven't been able to try riscv yet.

9 years agoFixes sparc compilation error
Barret Rhoden [Mon, 6 Jun 2011 23:17:32 +0000 (16:17 -0700)]
Fixes sparc compilation error

Sparc doesn't like our new fields in the kernel messages.  We'll 8-byte
align them from now on.  If you change the size of a kernel message, be
sure to update k/a/s/trap.h.

9 years agoKthread stack poisoning
Barret Rhoden [Mon, 6 Jun 2011 21:10:11 +0000 (14:10 -0700)]
Kthread stack poisoning

This has a bunch of asserts to check when sleeping or restarting a
kthread to make sure that we aren't using an active kernel stack.

The option will eventually go away or change when we have kthread
structs at the top of stacks.

For now, this will probably fail on sparc and riscv, so don't turn it on
for them.  Its not a big deal, since this is meant to debug heavy

9 years agoSafer assertions related to __up_sem()
Barret Rhoden [Mon, 6 Jun 2011 20:19:41 +0000 (13:19 -0700)]
Safer assertions related to __up_sem()

When calling __up_sem(), you can ask it to assert that the list is empty
after signalling one.  This is for code that wants a semaphore of only
one item and wants to put in some 'helpful' asserts.  By having __up_sem
do it, we avoid the temptation to check after waking a kthread, but more
importantly we do the check inside the lock.  Doing otherwise might trip
the assert for the wrong reason.

9 years agoCleaned up finishing syscalls
Barret Rhoden [Mon, 6 Jun 2011 19:59:50 +0000 (12:59 -0700)]
Cleaned up finishing syscalls

The name of the old signal_current_sc() was a bit misleading, and wasn't
using the same finishing code as normal syscalls.  While the latter
isn't a big deal, this might avoid issues in the future.  Regardless,
userspace needs to be careful of and not trust events (or polling) for
weird syscalls that don't return normally.

9 years agoFixes race with SC_DONE and event overflow (XCC)
Barret Rhoden [Mon, 6 Jun 2011 19:11:39 +0000 (12:11 -0700)]
Fixes race with SC_DONE and event overflow (XCC)

In VMs, or possibly with poor interrupt timing, the kernel would be
delayed such that the 2LS would deregister and handle all events before
the kernel would send an ev_msg, causing a uthread to be restarted

Rebuild your cross-compiler/glibc.

9 years agoatomic_and()
Barret Rhoden [Mon, 6 Jun 2011 19:10:09 +0000 (12:10 -0700)]

Should work for RISCV - I don't have the compiler to check yet.

9 years agoDon't touch the waiter after waking
Barret Rhoden [Fri, 3 Jun 2011 18:57:54 +0000 (11:57 -0700)]
Don't touch the waiter after waking

If the kthread runs on another core, it'll unwind its stack and
dealloc/clobber the waiter you just woke up.  Like many other places in
the code, once you wake / unlock / unblock something, don't touch it

9 years agoDon't cache pcpui across potential kthread blocks
Barret Rhoden [Fri, 3 Jun 2011 18:55:41 +0000 (11:55 -0700)]
Don't cache pcpui across potential kthread blocks

When you come back up the stack, you could be on a different core if
your kthread migrated, and your pcpui would be wrong.

9 years agoa risc-v single-core process works!!
Andrew Waterman [Sat, 4 Jun 2011 00:38:34 +0000 (17:38 -0700)]
a risc-v single-core process works!!

9 years agouser_mem_check/assert now also check for alignment
Andrew Waterman [Thu, 2 Jun 2011 20:50:36 +0000 (13:50 -0700)]
user_mem_check/assert now also check for alignment

9 years agodecoupled ULIM from KERNBASE. rebuild your xcc.
Andrew Waterman [Wed, 1 Jun 2011 11:24:31 +0000 (04:24 -0700)]
decoupled ULIM from KERNBASE.  rebuild your xcc.

now, each ros/arch/mmu.h defines ULIM individually.

apologies for not being able to test this for x86.  it does compile, at least.

9 years agoadded NOVPT option to disable VPT/UVPT mappings
Andrew Waterman [Wed, 1 Jun 2011 11:21:47 +0000 (04:21 -0700)]
added NOVPT option to disable VPT/UVPT mappings

9 years agofixes towards risc-v user programs running
Andrew Waterman [Wed, 1 Jun 2011 11:20:50 +0000 (04:20 -0700)]
fixes towards risc-v user programs running

9 years agoelf loader now mostly supports 64b elfs
Andrew Waterman [Wed, 1 Jun 2011 11:18:08 +0000 (04:18 -0700)]
elf loader now mostly supports 64b elfs

9 years agoBroken static_assert failed to catch my bug :(
Andrew Waterman [Wed, 1 Jun 2011 08:20:18 +0000 (01:20 -0700)]
Broken static_assert failed to catch my bug :(

9 years agoSynced up RISC-V build
Andrew Waterman [Wed, 1 Jun 2011 02:21:33 +0000 (19:21 -0700)]
Synced up RISC-V build

9 years agonew 64b kernel memory map (not userspace yet)
Andrew Waterman [Wed, 1 Jun 2011 02:12:02 +0000 (19:12 -0700)]
new 64b kernel memory map (not userspace yet)

in short, KERNBASE = 0xFFF8 0000 0000 0000 (the most negative 48b addr),
and KERNSIZE = L1PGSIZE (512 GB).  kernel static symbols are referenced
through the KERN_LOAD_ADDR mapping, which is the upper 2GB, i.e.
KERN_LOAD_ADDR = 0xFFFF FFFF 8000 0000.  since all addresses in this range
are canonicalized signed 32-bit numbers, kernel symbols can be referenced
with 32b sign-extended addresses, reducing code size.

9 years agoKernel message sanity checks
Barret Rhoden [Tue, 31 May 2011 18:08:14 +0000 (11:08 -0700)]
Kernel message sanity checks

Ensures the message went to the proper endpoint.  Now that the slab
allocator was fixed, this shouldn't happen again, but I can imagine
other bugs that would cause it, with crazy results.

Also added a couple other asserts / TODOs.

9 years agoKthread stack freeing is more "accurate"
Barret Rhoden [Tue, 31 May 2011 18:02:30 +0000 (11:02 -0700)]
Kthread stack freeing is more "accurate"

The old version assumed stacktop was page aligned, and PGSIZE above its
actual page.  While this ought to be true on x86, it won't always be
(like if we put the struct kthread at the top of the page) or if we
offset the stacktops per-core (a debugging technique).

9 years agoFixes ancient slab bug
Barret Rhoden [Tue, 31 May 2011 17:38:44 +0000 (10:38 -0700)]
Fixes ancient slab bug

We shouldn't have been locking at all in kmem_cache_grow().  I made it
internal, since no outsiders should be calling it either.  Had we
properly locked, we would have deadlocked and noticed this when it was
written, 2.5 years ago.

Fun fact: I found this in a storm of bugs involving massive kthreading.
It looked like kmsgs (from a slab) were getting misrouted, and multiple
cores were clobbering each others kmsgs (including the kthread*

9 years agoBacktrace reports the last entry
Barret Rhoden [Mon, 30 May 2011 20:32:25 +0000 (13:32 -0700)]
Backtrace reports the last entry

This helps for some odd debugging situations, esp since sometimes the
ebp chain is optimized out and we miss spots (like with proc_restartcore
and sysenter_callwrapper()).

9 years agoFixes some CAS loops
Barret Rhoden [Thu, 19 May 2011 21:09:36 +0000 (14:09 -0700)]
Fixes some CAS loops

The old loops were caching sysc->flags in a register.

For the uthread code, those should have been atomic reads, which forces
a re-read.  I added the cmb()s in case the code changes in the future.
In general, comp_swap technically doesn't need "memory", and any loops
using it ought to provide their own cmb()s.  Still, I put it in CAS just
to avoid future bugs.

9 years agoNMIs and cross-core trapframe inspection
Barret Rhoden [Thu, 19 May 2011 20:50:11 +0000 (13:50 -0700)]
NMIs and cross-core trapframe inspection

x86 can send NMIs, the handler for which prints the trapframe and what
function the EIP is in.  Use it from the monitor with:

ROS(Core 0)> trace coretf OS_COREID

It will work regardless of whether or not IRQs are disabled or whether
or not the core is in the kernel or userspace.

Sparc doesn't have this yet, though the stubs are there.

9 years agoKernel debugging helpers
Barret Rhoden [Thu, 19 May 2011 01:27:21 +0000 (18:27 -0700)]
Kernel debugging helpers

Moved backtrace to arch/kdebug.c, added helpers to get your function's
caller's PC (roughly), and to get the name of a function that holds a
given PC.  Sparc compiles, though doesn't support the two new helpers.

9 years agoHelpful debugging additions
Barret Rhoden [Wed, 18 May 2011 23:14:27 +0000 (16:14 -0700)]
Helpful debugging additions

Just some minor changes to the print output of slab / alarm code.  Also
removed some useless asserts from kthread, which should have gone away
when we put cur_tf in pcpui.

9 years agoMonitor prompt correctly identifies its core
Barret Rhoden [Wed, 18 May 2011 23:08:42 +0000 (16:08 -0700)]
Monitor prompt correctly identifies its core

With multiple monitors in parallel, the monitor would tell you the
prompt, then fight for the lock, and usually lose, so the prompt would
be the *other* core.

9 years agoAvoids nehalem keyboard issues, better monitors
Barret Rhoden [Wed, 18 May 2011 23:03:28 +0000 (16:03 -0700)]
Avoids nehalem keyboard issues, better monitors

My nehalem locks up if I try to read from the keyboard on any core other
than core 0.  This detects the model processor and aborts reading the KB
(assuming you have the Makelocal flag set).  Most people won't need

If you use it and you try to readline/monitor from a non-core0, you'll
need to input via the serial port, since the kernel still expects

9 years agoFixes nasty CAS bug
Barret Rhoden [Tue, 17 May 2011 21:40:57 +0000 (14:40 -0700)]
Fixes nasty CAS bug

This one would only show up if you had enough contention to cause CAS to
fail, at which point eax was clobbered, and if the number you were
working on was > 255, such as when you have 300-500 kthreads.  Goddamn.

9 years agoAlarm fixes
Barret Rhoden [Fri, 13 May 2011 22:07:33 +0000 (15:07 -0700)]
Alarm fixes

Three things:
1) previous versions screwed up if you tried to set an alarm with the
same time as the last item (it can happen legitimately too!).
2) cleaned up set_alarm(), so it's much clearer how it works and handles
the possible cases.  No longer tries to infer the state of the TAILQ by
looking at the start/end times, which was confusing.
3) adds a bunch of assertions to catch weird or uninitialized values.

Note the TSC takes over 200 years to loop (or my basic arithmetic is

9 years agoHandles syscall-event overflow in pthreads
Barret Rhoden [Thu, 12 May 2011 01:29:36 +0000 (18:29 -0700)]
Handles syscall-event overflow in pthreads

Most 2LSs that handle blocking threads and syscalls like pthreads will
need to do something similar.  Actually, they'll need to do something
more advanced!

This code knows how to recover from event overflow, which means that the
event message containing the struct syscall * was lost.

Recovery is a bit expensive, I think, so under heavy amounts of lost
messages, we'll want to do something smarter, like switch to a polling
mechanism, or find a way to use larger BCQs.

9 years agoFixes race-bug in overflow/bit event handling
Barret Rhoden [Wed, 11 May 2011 23:23:07 +0000 (16:23 -0700)]
Fixes race-bug in overflow/bit event handling

Need to check ev_overflows after checking the bit.  The bit handlers run
after checking the bit (which is handled in the FOREACH_SET).

9 years agoMinor fix in user bitmask functions (XCC)
Barret Rhoden [Wed, 11 May 2011 22:42:54 +0000 (15:42 -0700)]
Minor fix in user bitmask functions (XCC)

You'll need to reinstall these headers into your cross compiler paths,
either manually or by recompiling your cross compiler.  It's not a big
deal, unless you try to PRINT_BITMASK, so feel free to hold off.

9 years agoqueue "SAFE" ops for userspace (XCC)
Barret Rhoden [Tue, 10 May 2011 18:22:39 +0000 (11:22 -0700)]
queue "SAFE" ops for userspace (XCC)

This is just a more up-to-date sys/queue.h that has the FOREACH_SAFE
ops, allowing you to remove the item from within the for loop.  The
kernel has been using these for a while now.

Rebuild your cross compiler, or at least put the new queue.h in your
XCC headers.

9 years agoRISC-V SMP boot works
Andrew Waterman [Sat, 28 May 2011 06:33:53 +0000 (23:33 -0700)]
RISC-V SMP boot works

this commit won't compile because i'm not committing a change to the mainline
that changes the memory layout without further consultation

9 years agofixed printd() bugs when DEBUG is defined
Andrew Waterman [Sat, 28 May 2011 06:29:17 +0000 (23:29 -0700)]
fixed printd() bugs when DEBUG is defined

9 years agoRISC-V port mostly links now
Andrew Waterman [Fri, 27 May 2011 09:57:58 +0000 (02:57 -0700)]
RISC-V port mostly links now

9 years agoInitial commit of RISC-V architecture port
Andrew Waterman [Mon, 23 May 2011 09:19:57 +0000 (02:19 -0700)]
Initial commit of RISC-V architecture port

It builds but doesn't link and is missing key functionality, like
env/process/pmap stuff.

9 years ago32b/64b compatibility fixes
Andrew Waterman [Mon, 23 May 2011 09:18:40 +0000 (02:18 -0700)]
32b/64b compatibility fixes

In a few places, types like int or uint32_t were used when the intent
was to use a type as wide as a machine register or a pointer.
I replaced these mostly with uintptr_t.

9 years agoFixes (unused) bug in get_event_type()
Barret Rhoden [Mon, 9 May 2011 20:54:10 +0000 (13:54 -0700)]
Fixes (unused) bug in get_event_type()

No one really uses this function (msr_dumb_while and eth_audio), but
neither of those really know what they are doing / do the right thing.
I don't recomment using get_event_type() anyway, but we'll keep it
around in case we need the helper in the future.

9 years agoSlab allocator locks are now irqsave
Barret Rhoden [Mon, 9 May 2011 20:43:36 +0000 (13:43 -0700)]
Slab allocator locks are now irqsave

Kernel messages call into the slab allocator, which can occur from
both inside and outside interrupt context.

9 years agouva2kva() - Does a page table walk to convert
Barret Rhoden [Mon, 9 May 2011 20:12:52 +0000 (13:12 -0700)]
uva2kva() - Does a page table walk to convert

Useful for debugging.  Also added a brief, unrelated note in blockdev
(no issue there, AFAIK).

9 years agoFixes event BCQ bug
Barret Rhoden [Mon, 9 May 2011 20:10:18 +0000 (13:10 -0700)]
Fixes event BCQ bug

BCQs must have a power-of-two number of elements.  Humorously enough,
this has been fucked up for a long time.  The critical fix is in
k/i/r/event.h.  Everything else is some extra debugging / testing code.

9 years agoFixes nasty kthread bug
Barret Rhoden [Fri, 6 May 2011 01:43:41 +0000 (18:43 -0700)]
Fixes nasty kthread bug

We were freeing the stack we were about to use, which is a bad idea.
Bug showed up as TAILQ corruption (often PFs) in alarm code, and once a
non-empty semaphore in a waiter in sys_block().  The "freed" stack was
being reused for the exact same code path (another sys_block), and
occasionally for other syscalls with a deeper stack (clobbering the LL

9 years agoAlarm debugging tools
Barret Rhoden [Fri, 6 May 2011 01:42:26 +0000 (18:42 -0700)]
Alarm debugging tools

Can see which waiters are running on all cores via the monitor.  I'll
probably add a lot more to this, but it's quite useful already!

9 years agoUser can set how long sys_block() sleeps
Barret Rhoden [Thu, 5 May 2011 18:41:05 +0000 (11:41 -0700)]
User can set how long sys_block() sleeps

9 years agoFixed corner case with alarm rel_time
Barret Rhoden [Thu, 5 May 2011 01:26:43 +0000 (18:26 -0700)]
Fixed corner case with alarm rel_time

With rounding errors when time > now, you could get rel_time == 0, which
shuts off the alarm.

For those curious, the time on hardware to set a 1 usec alarm, sleep on
it, and wake back up is around 3.1 usec, depending on cache hotness.

9 years agoArch independent per-cpu initialization
Barret Rhoden [Wed, 4 May 2011 23:16:07 +0000 (16:16 -0700)]
Arch independent per-cpu initialization

Put the common stuff in k/s/smp.c, and the arch dependent stuff in

9 years agoset_core_timer() now takes a periodic flag
Barret Rhoden [Wed, 4 May 2011 23:03:32 +0000 (16:03 -0700)]
set_core_timer() now takes a periodic flag

So far the only use of set_core_timer() uses a one-shot timer.  The old
periodic style was resulting in a lot of confusing interrupts and
anomalous events, especially in KVM.  Regardless, I want a one-shot

Note that most people should never call set_core_timer().  If you do,
you'll conflict with the alarm code.  Just use the alarm stuff.

9 years agoConverts sys_halt_core() to use alarms
Barret Rhoden [Wed, 4 May 2011 22:50:57 +0000 (15:50 -0700)]
Converts sys_halt_core() to use alarms

Not sure what we want to do long term for core halting.  This will keep
halting the core until the timer is up, servicing interrupts along the
way.  There are a lot of interrupts coming in to core 0 on hardware too.

Note if you want to kfunc sys_halt_core(), your arguments are in hex. =P

9 years agoConverts blockdev and sys_block() to use alarms
Barret Rhoden [Wed, 4 May 2011 00:11:17 +0000 (17:11 -0700)]
Converts blockdev and sys_block() to use alarms

sys_block() uses the kthread-style alarm, and the blockdev fake
interrupt uses the handler-style alarm.  Now, we should be able to have
a bunch of alarms, whether blockdev or sys_block, on all the cores at

9 years agoAlarm infrastructure
Barret Rhoden [Tue, 3 May 2011 22:28:50 +0000 (15:28 -0700)]
Alarm infrastructure

Allows you to block a kthread for a while or to run a handler after a
while.  These alarms are grouped in sorted chains, which are attached to
an interrupt source.  Currently, there are chains for the per-core timer

Check out k/i/alarm.h for a quick howto.

9 years agoPthread lists to track syscalls threads blocked on
Barret Rhoden [Wed, 13 Apr 2011 01:36:40 +0000 (18:36 -0700)]
Pthread lists to track syscalls threads blocked on

Doesn't do much with them yet, will sort out overflow soonish.

9 years agoFixes memory leak with hashtable_iter
Barret Rhoden [Fri, 22 Apr 2011 21:02:20 +0000 (14:02 -0700)]
Fixes memory leak with hashtable_iter

Lots of ughs with this.  Had they not typedef'd, it might have been more
obvious.  The best way would be to have the caller provide the memory
too, so we can use stack vars, but whatever.  3rd party code...

Also changed the remaining two users to use hash_for_each.

9 years agostruct syscall's flags is now an atomic_t (XCC)
Barret Rhoden [Thu, 14 Apr 2011 23:17:24 +0000 (16:17 -0700)]
struct syscall's flags is now an atomic_t (XCC)

Sparc needed this, since their atomic or works weirdly.  Also, it's a
bit safer in general.  Note, you shouldn't try to 'or' in flags in the
third byte, since sparc's atomics will break.

Rebuild your cross compiler.

9 years agoFixes sparc syscall interface (XCC)
Barret Rhoden [Thu, 14 Apr 2011 22:28:45 +0000 (15:28 -0700)]
Fixes sparc syscall interface (XCC)

Sparc wasn't passing the actual syscall*.  This also fixes up the ghetto
numbering (a0 in userspace being a1 in the kernel), as well as trimming
ros_arch_syscall down to the two needed parameters.

You ought to rebuild your sparc cross compiler.

9 years agoMakefile TARGET_ARCH fixes
Barret Rhoden [Thu, 14 Apr 2011 09:30:00 +0000 (02:30 -0700)]
Makefile TARGET_ARCH fixes

TARGET_ARCH is passed from GNUMakefile to recursive makes.  c3po also is
only a user-lib when the TARGET_ARCH is i686.  Once c3po can handle
sparc, then we can change that back.

9 years agoResyncs parlib's sparc's atomics with the kernel's
Barret Rhoden [Thu, 14 Apr 2011 09:25:46 +0000 (02:25 -0700)]
Resyncs parlib's sparc's atomics with the kernel's

Note that while similar, userland atomics in sparc are slightly
different than their kernel counterparts.  One big difference is that
sparc (and x86 too) doesn't not have an atomic_add().  This name
conflicts with glibc, and is part of a larger problem of having two
sources of atomic primitives that might not line up right.
user/parlib/include needs to work with both ROS and glibc (for now), so
this causes problems.

Another difference is with irqsaves (or lack thereof).

Normally, userspace just needs to get the functions it needs, but it was
behind enough that it just received most of the ones from the kernel.

9 years agoGit properly ignores the symlink u/parlib/inc/arch
Barret Rhoden [Thu, 14 Apr 2011 09:23:58 +0000 (02:23 -0700)]
Git properly ignores the symlink u/parlib/inc/arch

Wasn't adjusted back when we moved user/include to user/parlib/include.

9 years agoParlib's rstdio.h -> ros_debug.h
Barret Rhoden [Thu, 14 Apr 2011 09:20:52 +0000 (02:20 -0700)]
Parlib's rstdio.h -> ros_debug.h

parlib.h includes ros_debug.h, so you can still turn on printd or make
ros_debug calls.

9 years agoFixes compilation errors with remote call code
Barret Rhoden [Mon, 11 Apr 2011 20:54:52 +0000 (13:54 -0700)]
Fixes compilation errors with remote call code

Some things since the rebase weren't working, specifically the MCS locks
and parlib code depending on pthread code (albeit just for a printf).

9 years agoFix kref references that are no longer there.
David Zhu [Fri, 1 Apr 2011 11:10:58 +0000 (04:10 -0700)]
Fix kref references that are no longer there.

kref changed to p_kref.

9 years agoMaking tests compile even when arsc is not used.
David Zhu [Fri, 4 Feb 2011 23:31:26 +0000 (15:31 -0800)]
Making tests compile even when arsc is not used.

Converting arsc_server flag to be both user and kernel.

9 years agoMake arsc and local async calls use the same structure.
David Zhu [Wed, 26 Jan 2011 23:35:52 +0000 (15:35 -0800)]
Make arsc and local async calls use the same structure.

Instead of putting the entire call and the parameters in the ring,
we now use a pointer to an external structure that the caller waits

This allows for consistent waiting interface on both remote and
local calls.

9 years agoAdding test case for multproducer async calls.
David Zhu [Mon, 15 Nov 2010 02:23:32 +0000 (18:23 -0800)]
Adding test case for multproducer async calls.

Fixed ring buffer and arsc to support out of order processing.
Eventually this will be converted to use similar mechanisms as local
async calls and simply use the ring buffer as a way of shipping async
call structures around.

9 years agoMore addition to arsc infrastructure.
David Zhu [Thu, 28 Oct 2010 21:34:23 +0000 (14:34 -0700)]
More addition to arsc infrastructure.

Specifically, decoupling arsc call page from procdata.
Create an interface that may be used for proc-to-proc call.
Preparing arsc for multi-threaded calls and reordering of request/response.

9 years agocosmetic change. removing unnecessary elf_info struct.
David Zhu [Fri, 20 Aug 2010 21:13:49 +0000 (14:13 -0700)]
cosmetic change. removing unnecessary elf_info struct.

9 years agoMake clean also cleans userspace
Barret Rhoden [Wed, 30 Mar 2011 01:47:08 +0000 (18:47 -0700)]
Make clean also cleans userspace

It was just cleaning the kernel and tests.

9 years agommap() with addr 0 will start from BRK_END
Barret Rhoden [Sat, 26 Mar 2011 00:22:33 +0000 (17:22 -0700)]
mmap() with addr 0 will start from BRK_END

I might prefer having userspace be the one to adjust the addr to BRK_END
instead of the kernel, but this gets the job done.

9 years agoDisable notifs when changing TLSs
Barret Rhoden [Fri, 25 Mar 2011 21:05:24 +0000 (14:05 -0700)]
Disable notifs when changing TLSs

9 years agoMore careful about memory allocations
Barret Rhoden [Fri, 25 Mar 2011 20:29:40 +0000 (13:29 -0700)]
More careful about memory allocations

Also note we could have been freeing the wrong size of stacks if someone
happened to use the attrs.

9 years agoHash for each helpers
Barret Rhoden [Wed, 23 Mar 2011 20:52:00 +0000 (13:52 -0700)]
Hash for each helpers

In case you want a for each over each value of the hash.  Not a big

9 years agoFixes uthread sysc block logic
Barret Rhoden [Fri, 18 Mar 2011 00:24:27 +0000 (17:24 -0700)]
Fixes uthread sysc block logic

The old version would only screw up if we blocked in uthread_init()
before we entered _M mode.  This way is much clearer, and provides an
approved way to see if you're _M or not.

9 years agoProperly clears cur_sysc when leaving a core
Barret Rhoden [Thu, 17 Mar 2011 23:26:59 +0000 (16:26 -0700)]
Properly clears cur_sysc when leaving a core

This was responsible for the PF when bin_run()ning a non existant
program after running a program on core 0.

9 years agoTest functions for blocking
Barret Rhoden [Thu, 17 Mar 2011 22:06:08 +0000 (15:06 -0700)]
Test functions for blocking

You can use looper.sh to run an app until it fails (or you reboot).
Use it from busybox with: ash looper.sh block_test.

9 years agoFixes bug in pop_ros_tf
Barret Rhoden [Wed, 16 Mar 2011 02:38:39 +0000 (19:38 -0700)]
Fixes bug in pop_ros_tf

Brutal bug, where branches would make the wrong decision and syscall
structs would get clobbered.  EFLAGS wasn't restored, so an unlucky
IPI/notification would result in bad CCs.  Note: subl and addl affect
the flags.

Also, don't use the vcore stack for things like syscall struct storage
after you enable notifs!  Once notifs are enabled, you should not be
touching the vcore stack.

9 years agoFixes mhello to play nice with uthread
Barret Rhoden [Wed, 16 Mar 2011 02:16:09 +0000 (19:16 -0700)]
Fixes mhello to play nice with uthread

Previously, you wouldn't be able to restart thread 0.

9 years agoCatch bugs in sys_block()
Barret Rhoden [Tue, 15 Mar 2011 21:32:14 +0000 (14:32 -0700)]
Catch bugs in sys_block()

Do not call sys_block (or sleep in a blockdev blocking call!) in more
than one place at a time.  This will try to catch multiple uses of the
interrupt handler's void*, though it isn't atomic so it will not catch

9 years agoStop passing uthread to __uthread_yield()
Barret Rhoden [Mon, 14 Mar 2011 21:58:46 +0000 (14:58 -0700)]
Stop passing uthread to __uthread_yield()

No need to, and there's a chance of it fucking around with stacks before
we fully get in vcore context.

9 years agoRemoves vcores_wanted() from 2LS ops
Barret Rhoden [Mon, 14 Mar 2011 18:56:34 +0000 (11:56 -0700)]
Removes vcores_wanted() from 2LS ops

It was only called from thread_runnable, which was right after another
2LS op where they can just request what they want.

9 years agoPthread: stop accessing memory after it was freed
Barret Rhoden [Mon, 14 Mar 2011 18:47:51 +0000 (11:47 -0700)]
Pthread: stop accessing memory after it was freed

9 years agoSupport for blocking and restarting uthreads (XCC)
Barret Rhoden [Mon, 14 Mar 2011 18:41:56 +0000 (11:41 -0700)]
Support for blocking and restarting uthreads (XCC)

Test it out with SYS_block.  Uthreads will call out to the 2LS to block
on syscalls.  Pthread code has an example of what to do (though it
doesn't deal with missed messages/overflow yet).

This also introduces a 'state' variable for uthreads, which is mostly
used for debugging in various places.

There's an odd bug floating around still, noticed most recently in
being in vcore_context in thread_yield.  It isn't obvious, relies on
timing, and is very rare.  If you get it regularly, call me.

Rebuild your cross compiler, or at least reinstall your kernel headers.

9 years agoAtomic or for ints (flag variables)
Barret Rhoden [Mon, 14 Mar 2011 16:34:00 +0000 (09:34 -0700)]
Atomic or for ints (flag variables)

9 years agoFixes user/parlib arch symlink
Barret Rhoden [Mon, 14 Mar 2011 16:31:28 +0000 (09:31 -0700)]
Fixes user/parlib arch symlink

9 years agovcore_idle()
Barret Rhoden [Sat, 12 Mar 2011 02:17:02 +0000 (18:17 -0800)]

When you don't want to give up a vcore, but you don't know what to do.
Can only break out via an IPI/notif/interrupt.

9 years agoFixes _exit and abort() to use exit codes (XCC)
Barret Rhoden [Fri, 11 Mar 2011 01:24:43 +0000 (17:24 -0800)]
Fixes _exit and abort() to use exit codes (XCC)

abort() is a bit ugly, but it works for now.  If you ever see an exit
value of 1337, it is because the kernel directly called proc_destroy().

Rebuild your cross compiler if you want this stuff to work.

9 years agoProactive 0s new vm_region structs
Barret Rhoden [Thu, 10 Mar 2011 02:32:22 +0000 (18:32 -0800)]
Proactive 0s new vm_region structs

This will help catch bugs for now, though if you're using create_vmr(),
be sure to read the comment telling you how to use it!  Caller is
supposed to initialize the extra fields.

9 years agoMinor changes to proc_restartcore()
Barret Rhoden [Tue, 8 Mar 2011 03:01:48 +0000 (19:01 -0800)]
Minor changes to proc_restartcore()

9 years agouthread yield and exit code merged
Barret Rhoden [Tue, 8 Mar 2011 01:25:39 +0000 (17:25 -0800)]
uthread yield and exit code merged

Exit now calls yield with a DYING flag set.  2LSs still have both
callbacks; this just simplifies uthread code a bit.  uthread_yield() is
now the only way for a uthread to pause its state and hop into vcore
context.  Exit does this, just without worrying about its old context.

9 years agoGCC/uthread callbacks on blocking syscalls (XCC)
Barret Rhoden [Tue, 8 Mar 2011 00:04:39 +0000 (16:04 -0800)]
GCC/uthread callbacks on blocking syscalls (XCC)

Doesn't do much yet, just runs a 2LS handler.  The uthread stuff will
change a bit soon, and that handler will run in the bottom half of a
yield-ish path in vcore context.

Rebuild your cross compiler.

9 years agoMCS locks have a "notification-safe" variant
Barret Rhoden [Sat, 5 Mar 2011 01:41:18 +0000 (17:41 -0800)]
MCS locks have a "notification-safe" variant

Any lock that is grabbed from vcore context needs to use
mcs_lock_notifsafe(), which is analagous to using irqsave in the kernel
on its spin_locks.

9 years ago2LS op for how many vcores to request
Barret Rhoden [Sat, 5 Mar 2011 00:14:19 +0000 (16:14 -0800)]
2LS op for how many vcores to request

Called out of uthread_runnable(), for now.  Yielding or whatever is done
by the 2LS sched_entry(), which should never return.

9 years agoMCS locks are smaller and don't rely on vcore_id()
Barret Rhoden [Fri, 4 Mar 2011 23:16:48 +0000 (15:16 -0800)]
MCS locks are smaller and don't rely on vcore_id()

If you had a non-irq_save MCS lock, you would have issues with having
multiple threads lock on the same vcore, or a thread locking and
unlocking on different vcores.

Also, this only uses memory for the callers spinning location (the
qnode) when needed, instead of statically allocating it.  The memory for
these should be per-thread (TLS, stack, whatever).  This also gets rid
of the need for the padding.

9 years agoMakes 'make' make less noise
Barret Rhoden [Fri, 4 Mar 2011 01:56:43 +0000 (17:56 -0800)]
Makes 'make' make less noise