akaros.git
5 years agorendez_wakeup() has a return value
Barret Rhoden [Mon, 14 Oct 2013 22:31:14 +0000 (15:31 -0700)]
rendez_wakeup() has a return value

A bool, telling the caller if anything was woken up.  The original plan9
wakeup() returned a proc*, for instance.  The uses I've seen of it (2)
are okay with a bool.

5 years agoRenames schedule()
Barret Rhoden [Sat, 12 Oct 2013 16:13:16 +0000 (09:13 -0700)]
Renames schedule()

To avoid any future bugs like fb7e2a51 (from the old 9ns branch).  Our
schedule() is different than regular OSs, for better or worse.

5 years agoFixes bug in pipe
Barret Rhoden [Thu, 10 Oct 2013 22:14:48 +0000 (15:14 -0700)]
Fixes bug in pipe

Thought we had this one sorted out before.  If we have a sleeping
reader/writer, when we close an end, we need to wake everyone so they can
decide if they should still be sleeping.

5 years agoSemaphore debugging
Barret Rhoden [Wed, 9 Oct 2013 19:21:39 +0000 (12:21 -0700)]
Semaphore debugging

Turn it on with CONFIG_SEMAPHORE_DEBUG.  The most useful way to use it
is via kfunc print_all_sem_info.

5 years agoArch specific PC/IP and FP/BP helpers
Barret Rhoden [Wed, 9 Oct 2013 19:12:04 +0000 (12:12 -0700)]
Arch specific PC/IP and FP/BP helpers

Ultimately, we'll settle on read_pc and read_fp.

5 years agoMoves socket semaphore stuff
Barret Rhoden [Wed, 9 Oct 2013 03:50:09 +0000 (20:50 -0700)]
Moves socket semaphore stuff

If we end up using the sockets, we should integrate the fd->whatever
lookup differently.

5 years agoSemaphore try methods
Barret Rhoden [Tue, 8 Oct 2013 20:23:27 +0000 (13:23 -0700)]
Semaphore try methods

FYI: the irqsave sem_*downs aren't called from IRQ context; they are
used when the ups might be called from IRQ context.

5 years agoFixes spin_trylock()
Barret Rhoden [Tue, 8 Oct 2013 17:23:07 +0000 (10:23 -0700)]
Fixes spin_trylock()

Was returning TRUE on failure, instead of on success.

5 years agoRendezvous: plan9 style sync with CVs
Barret Rhoden [Tue, 8 Oct 2013 00:56:40 +0000 (17:56 -0700)]
Rendezvous: plan9 style sync with CVs

Rendezvous encapsulates a common CV pattern, albeit one where the
locking is grabbed internally.  If you need the lock grabbed externally
to protect some invariant, then you can probably just use CVs directly.

To reiterate: the rendez locks internally, and when we run the func
pointer to check cond, we hold the lock.  But that lock isn't meant to
protect against concurrent changes to the state - it protects the rv
(rendez variable, btw).

The timeout code is a bit trickier.  You can either use rendez as an
example, or use it directly.  If the locking style of rendez is
insufficient and you need a timer, we can consider exposing the rendez
lock, similar to cv_lock().  Assuming your timer code is fairly
identical.  We'll see.

The test handles a few basic cases, but nothing with actual IRQs.

5 years agoAlarms can be unset
Barret Rhoden [Mon, 7 Oct 2013 23:42:52 +0000 (16:42 -0700)]
Alarms can be unset

The old code assumed the alarms hadn't fired yet, and if you tried to
unset one that had fired, it'd be a mess.

5 years agoAlarm pcpu tchains can be adjusted cross-core
Barret Rhoden [Mon, 7 Oct 2013 23:39:55 +0000 (16:39 -0700)]
Alarm pcpu tchains can be adjusted cross-core

The trick is to detect we're on the other core, and trigger the
interrupt remotely.  The alarm code can handle spurious interrupts, so
there's no problem.

5 years agoKernel alarm tchains use locks
Barret Rhoden [Mon, 7 Oct 2013 23:03:22 +0000 (16:03 -0700)]
Kernel alarm tchains use locks

Previously, we left this to the tchain source to determine if it needed
locking or not.  The pcpu tchains were able to get by with IRQ
disabling.  This won't work if we want to be able to reasonably disable
an alarm, since we might want to disable from another core.

5 years agoadd %r format
Ronald G. Minnich [Sat, 5 Oct 2013 17:27:28 +0000 (10:27 -0700)]
add %r format

Either barret or kevin will kill me for this one.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoFixes bugs with larger kstack allocation
Barret Rhoden [Sat, 5 Oct 2013 00:09:54 +0000 (17:09 -0700)]
Fixes bugs with larger kstack allocation

Was asking for a 0-order alloc in kthread, and the smp boot code wasn't
looking at the bottom of the stack (it was looking at the bottom of the
first page on the receiving end).

5 years agoHelper to spawn kernel tasks (ktasks)
Barret Rhoden [Fri, 4 Oct 2013 17:40:39 +0000 (10:40 -0700)]
Helper to spawn kernel tasks (ktasks)

These are just kernel messages that might block.  Some subsystems launch
them, and they are meant to run for the life of the system.  We added a
name for debugging.

Also, since it's not clear how to schedule KMSGs or ktasks, we just send
them to the calling core, like with all KMSGs...

5 years agoKthreads launched from KMSGs are tracked as ktasks
Barret Rhoden [Thu, 3 Oct 2013 23:44:57 +0000 (16:44 -0700)]
Kthreads launched from KMSGs are tracked as ktasks

The kernel tasks don't have a particular address space, and won't store a
reference to whatever process happens to be running.  Previously, things like
loopbackread() would save a reference to whatever process happened to be
running there, which would keep that process from fully DYING.

Any routine kernel message will have is_ktask set.  If they block, the kthread
code will know to handle these differently.  This means that syscall context
shouldn't somehow try to execute as an RKM.  As a reminder, when you first
launch an RKM, it is in early_rkm_ctx.  So put another way, no syscall work or
other work on behalf of a process that can block should execute in
early_rkm_ctx().  Anyway, this all is subject to change, if I need to.
Comments inline will track the latest.

5 years agoKthreads track cur_sysc and cur_errbuf
Barret Rhoden [Thu, 3 Oct 2013 02:33:38 +0000 (19:33 -0700)]
Kthreads track cur_sysc and cur_errbuf

Instead of having them sit in pcpui, then copying them to the kthread,
we just put them directly in the kthread.  This matches their intent.
Using pcpui was more of a hack back when we didn't have kthreads at all
times.

Note that set_errno() can be called before we have a kthread set up,
hence the need to check for its existence.

5 years agoKthreads track running kernel contexts
Barret Rhoden [Thu, 3 Oct 2013 01:34:23 +0000 (18:34 -0700)]
Kthreads track running kernel contexts

Previously, we would only create a kthread on-demand to hold a kernel
context when it wants to block.  Now, we always have a kthread tracking
the running context.

5 years agoKernel stack get/put interface
Barret Rhoden [Wed, 2 Oct 2013 21:52:43 +0000 (14:52 -0700)]
Kernel stack get/put interface

Also cleans up the poison/canary, and if you need to, you should be able
to get larger stacks (change the KSTKSHIFT).

5 years agoSafer apipe_read_locked()
Barret Rhoden [Tue, 1 Oct 2013 23:37:13 +0000 (16:37 -0700)]
Safer apipe_read_locked()

In case readers who lock externally don't check for emptiness before
reading.

5 years agoReader-writer queue locks
Barret Rhoden [Thu, 26 Sep 2013 18:20:36 +0000 (11:20 -0700)]
Reader-writer queue locks

These will be the qlocks in 9ns/inferno.

5 years agospin_trylock()
Barret Rhoden [Tue, 24 Sep 2013 23:11:23 +0000 (16:11 -0700)]
spin_trylock()

When lock checking, it won't check for IRQs when trylocking.

5 years agoSpinlock debugging improvements
Barret Rhoden [Tue, 24 Sep 2013 22:17:04 +0000 (15:17 -0700)]
Spinlock debugging improvements

Can blacklist locks from collection, and the output also says where the lock
was last grabbed.

Also, catches any attempt to unlock a lock that is already unlocked.

5 years agoChecks for running off the stack
Barret Rhoden [Tue, 24 Sep 2013 21:06:02 +0000 (14:06 -0700)]
Checks for running off the stack

Printing takes up a shitload of stack, esp when deep in a call stack (FS, net,
etc).  This will try to catch stack clobbers caused by calls to print that
cause print to run off the stack.

5 years agoPoor-mans ftrace with spatch
Barret Rhoden [Wed, 18 Sep 2013 18:40:43 +0000 (11:40 -0700)]
Poor-mans ftrace with spatch

Will add a printk to the entry and exit of every function you spatch.
Doesn't work with multicore, so only use it on core 0.

5 years agoFixes apipe_read_cond()
Barret Rhoden [Tue, 17 Sep 2013 21:01:14 +0000 (14:01 -0700)]
Fixes apipe_read_cond()

Uses a priority_reader CV, so that we can have only one reader at a
time.  In the process, I separated the reader and writer CVs too.  Since
we have multiple CVs sharing a lock, it's clearer to use a standalone
lock.  Maybe I'll switch over to the POSIX CV style in the future...

Note: this was cherry-picked and had some minor issues.  I blame any bugs on
that.

5 years agoCan associate multiple CVs with spinlocks
Barret Rhoden [Tue, 17 Sep 2013 19:18:14 +0000 (12:18 -0700)]
Can associate multiple CVs with spinlocks

You can associate a CV with any spinlock.  This is so you can easily
have multiple conditions protected by the same lock.  Calling cv_lock()
on any of them grabs the common spinlock.

5 years agoRFC: support pipe reads based on a condition.
Ronald G. Minnich [Tue, 17 Sep 2013 06:17:26 +0000 (23:17 -0700)]
RFC: support pipe reads based on a condition.

This is a proposal for pipe reading conditioned on a function. It is often
necessary to read lock a pipe and read data from it until some condition is met.
It is essential that we keep the lock for our own uses until we are done, to ensure
integral copyout of possibly fragmented RPC and other requests. Note this
was not an issue with the Plan 9 'il' protocol, became an issue with IP V4,
and will not be an issue with IP V6. But we have to support v4, even though
we're supposed to be beyond all that now. Legacy sucks.

The apipe_read_cond is called with a function, f, and an arg. Each time the
pipe is non-empty, f is called with the pipe and arg as parameters. F returns
0 until some condition is met, in which case it returns > 0, or until failure,
in which case it returns < 0. f may read data from the pipe by calling
apipe_read_locked.

If this design meets with approval (ha!) then I can create a qio function that
uses these semantics. But, I expect the Akaros guys will do something
better :-)

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoMake the errstr a more reasonable size. (XCC)
Ronald G. Minnich [Sun, 15 Sep 2013 21:15:19 +0000 (14:15 -0700)]
Make the errstr a more reasonable size. (XCC)

Note from brho: rebuild your cross compiler and userspace.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoMake set_errstr take a printf-like format
Ronald G. Minnich [Sun, 15 Sep 2013 21:08:34 +0000 (14:08 -0700)]
Make set_errstr take a printf-like format

One of the things I really disliked about Plan 9 was that we
could return an errstr, and we only ever returned 52 errors
even though errstr was called in over 112 places. It gets
even more confusing if a program or library transforms the args:
what did the args look like precisely? Hard to say.

So on Plan 9 we get errors no more informative than errno. That's a very
low bar, to say the least.

This change allows for more useful error messages. We include an
example -- not a great one, but hey, it already cleared something
up for me.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoKthread poison checker
Barret Rhoden [Sat, 14 Sep 2013 20:36:49 +0000 (13:36 -0700)]
Kthread poison checker

Drop this wherever you want to see if you have already clobbered your
current stack's canary.  It'll printk your message and panic.  If you
call this while you are still off your stack, you'll get a Bad Stacktop
panic.

5 years agox86: Fixes 64 bit VPT mapping
Barret Rhoden [Sat, 14 Sep 2013 18:06:04 +0000 (11:06 -0700)]
x86: Fixes 64 bit VPT mapping

You can't have global entries on certain interior PML PTEs.  For
instance, in the 4K walk (which we're doing for VPT/VPD), PML4 and PML3
both need the global bit to be 0.

5 years agoBusybox doesn't use internal echo
Barret Rhoden [Fri, 13 Sep 2013 17:34:36 +0000 (10:34 -0700)]
Busybox doesn't use internal echo

The builtin echo breaks up its write in a way that messes with 9ns
control files.

Copy out the bb config and rebuild busybox.  Be sure to set up a symlink
for echo.

5 years agoBusybox perror knows about errstr
Barret Rhoden [Fri, 13 Sep 2013 02:07:16 +0000 (19:07 -0700)]
Busybox perror knows about errstr

Busybox rolls their own perror.  I made an ugly patch that hacks in errstr.
Feel free to more elegantly add ", errstr" to their 'msg'.

If you're interested in using it, you'll get better error messages from the 9ns
code.  For example:

/ $ cat sdfsd
cat: can't open 'sdfsd': No such file or directory
/ $ cat /9/sdfsf
cat: can't open '/9/sdfsf': No such file or directory, file does not exist
/ $ cat '#p/1/args'
cat: read error: Unspecified, ken has left the building

You'll need to manually patch busybox for this.

5 years agoSet errno when only errstr was called
Barret Rhoden [Fri, 13 Sep 2013 01:51:18 +0000 (18:51 -0700)]
Set errno when only errstr was called

Some error paths set errstr, but not errno.  Glibc will ignore errstr if there
isn't an errno too, so we need something.

Ultimately, we should be setting both errno and errstr (given a glibc-world
with errno).  Til then, we'll set a generic errno.

This won't harm the current glibc, which 0's sysc.errstr before calling, but
that isn't actually part of the ABI.  So with this hack, it is possible to set
errno when there wasn't actually an error.  Luckily, userspace shouldn't look
at errno unless it was told too (via a bad retval), in which case, we probably
wanted errno set anyway.  Still, be careful.

5 years agoCommon helper defines (XCC)
Barret Rhoden [Thu, 16 Jan 2014 01:41:43 +0000 (17:41 -0800)]
Common helper defines (XCC)

Dropping these in the kernel header for now, though they aren't used in part of
the kernel interface.

5 years agostrtoul()
Barret Rhoden [Thu, 16 Jan 2014 01:34:01 +0000 (17:34 -0800)]
strtoul()

Ron's old version, based off strtol().

5 years agoudelay_sched()
Barret Rhoden [Thu, 16 Jan 2014 01:25:35 +0000 (17:25 -0800)]
udelay_sched()

Sleeps a kthread for 'usec' microseconds.

5 years agoAdds per cpu errbuf pointers
Barret Rhoden [Sat, 24 Aug 2013 00:51:31 +0000 (17:51 -0700)]
Adds per cpu errbuf pointers

So we don't need to track perrbuf throughout all of the waserror-using code.

I'm tracking it as a void*, since the errbuf stuff isn't even in this branch
yet.

5 years agoProvides current_errstr()
Barret Rhoden [Sat, 24 Aug 2013 00:06:14 +0000 (17:06 -0700)]
Provides current_errstr()

Instead of using the per-proc current->errstr, now use the per-syscall errstr.

6 years agoThe monitor doesn't cache coreid
Barret Rhoden [Thu, 12 Sep 2013 00:41:02 +0000 (17:41 -0700)]
The monitor doesn't cache coreid

Certain commands, when run from the monitor, can cause the monitor to
migrate unexpectedly.  We no longer cache the coreid, and we force a
re-read, so that we don't report the old coreid after a migration.

6 years agoUpdates .gitignore
Barret Rhoden [Wed, 11 Sep 2013 21:30:57 +0000 (14:30 -0700)]
Updates .gitignore

I was sick of seeing the occasional .swo with vi.

6 years agoFixes bug in sys_pipe()
Barret Rhoden [Fri, 6 Sep 2013 02:18:41 +0000 (19:18 -0700)]
Fixes bug in sys_pipe()

Under some circumstances, a writer could block and then never wake up.

6 years agoAtomic pipes
Barret Rhoden [Fri, 6 Sep 2013 02:10:38 +0000 (19:10 -0700)]
Atomic pipes

Similar to pipe, but for in-kernel transfer and synchronization.  You
can't use them from IRQ context.  See apipe.h for info.

6 years agoAdds round-down to the nearest power of 2
Barret Rhoden [Fri, 6 Sep 2013 01:36:47 +0000 (18:36 -0700)]
Adds round-down to the nearest power of 2

Can also use the Xen macros, if you're interested (__RD32).

6 years agoRenames the console lock
Barret Rhoden [Wed, 4 Sep 2013 22:48:26 +0000 (15:48 -0700)]
Renames the console lock

Interestingly enough, this wasn't the first spinlock ever (hence the poor
name).  The first actual usages were for the output_lock (very similar to the
console lock).  I don't count the smp_boot assembly stuff as a legit use of the
venerable spinlock.

6 years agoAdds a pcpu tracer for spinlocks
Barret Rhoden [Wed, 4 Sep 2013 22:36:19 +0000 (15:36 -0700)]
Adds a pcpu tracer for spinlocks

Compile with SPINLOCK_DEBUG and TRACE_LOCKS, then access the info from the
monitor with 'trace pcpui'.

This is very spammy, and it'll clobber any other info in the trace, so be
careful using it.  It will also attempt to find the location of the lock, based
on the symtab.  This only works for locks above KLA (o/w, the lock is dynamic).

When building with TRACE_LOCKS, we also disable any of the fancier checks for
the console and printf locks, so that they don't clobber our results.
Otherwise, as you printed lines, you'd be adding to the trace.

6 years agoSpinlock checking is disabled by default
Barret Rhoden [Wed, 4 Sep 2013 22:33:41 +0000 (15:33 -0700)]
Spinlock checking is disabled by default

Reversing depth_disabled to checking_enabled.  Now, the extra debugging won't
get turned on til we're ready for it.

6 years agox86: Better emergency codes for core 0
Barret Rhoden [Fri, 30 Aug 2013 18:02:05 +0000 (11:02 -0700)]
x86: Better emergency codes for core 0

Shift-G still works, though I suggest weaning yourself of that.  Ctrl-G
does the same thing (enters the monitor when the core is able to).  This
is the preferred way to enter the monitor.

Ctrl-Q also enters the monitor, but does so directly from IRQ context.
This can be dangerous, but is better than nothing.

Ctrl-B dumps a backtrace and trapframe of the core.  You could do this
manually after a Ctrl-Q, too.

The core that runs the backtrace or monitor is whatever core received
the IRQ.  This is almost always core 0.  Debugging remote cores can be
done from the monitor on core 0.

These codes require interrupts to be enabled.  I don't have a way to
send nmis to core 0 yet, other than from the monitor on another core.

6 years agoPipe open/release should depend on mode not flags
Kevin Klues [Wed, 28 Aug 2013 22:02:14 +0000 (15:02 -0700)]
Pipe open/release should depend on mode not flags

6 years agoprintnum() is no longer recursive
Barret Rhoden [Wed, 28 Aug 2013 16:02:43 +0000 (09:02 -0700)]
printnum() is no longer recursive

When printing a full 64 bit pointer in hex (16 'digit's), printnum()
consumed over 1KB of stack, which can run off the end of the kernel
stack.  We use about 80B per frame.

I'm not concerned about the repeated divisions; the actual output is far
more expensive than that, last I checked.

6 years agoInitialize num pipe readerw/writers to 0
Kevin Klues [Thu, 22 Aug 2013 00:37:07 +0000 (17:37 -0700)]
Initialize num pipe readerw/writers to 0

6 years agoFixes error handling in do_pipe()
Barret Rhoden [Tue, 20 Aug 2013 19:43:44 +0000 (12:43 -0700)]
Fixes error handling in do_pipe()

Was leaking memory if we failed to create files for each end of the pipe.

6 years agoVFS: get_dentry() sets errno
Barret Rhoden [Tue, 20 Aug 2013 19:32:28 +0000 (12:32 -0700)]
VFS: get_dentry() sets errno

Keeping it in line with similar functions.  Also catches some places where we
weren't checking the return value of get_dentry().  Not sure how failure for
init_sb() or do_lookup() should work.

6 years agoPipes (XCC)
Barret Rhoden [Mon, 19 Aug 2013 22:07:33 +0000 (15:07 -0700)]
Pipes (XCC)

Basic pipe functionality, using the old VFS.  Should be able to handle
multiple readers and writers, though I haven't tested that yet.

These pipes aren't rooted in the VFS yet, though we could extend them to
handle named pipes reasonably easily.

Rebuild your toolchain and any program that would use pipe (busybox).

6 years agoVFS dummy ops
Barret Rhoden [Fri, 16 Aug 2013 23:40:17 +0000 (16:40 -0700)]
VFS dummy ops

To catch bugs when we calling ops on inodes/dentries unexpectedly.

6 years agoFixes up lindent
Barret Rhoden [Mon, 19 Aug 2013 22:29:44 +0000 (15:29 -0700)]
Fixes up lindent

indent still messes up sometimes.  In some cases (like with weird printk
formatting), it can be fixed and won't cause the problem again.  In
others, like in sys_buster right after the #defines, it'll insist on
formatting in a weird manner.

Anyway, this is better than not formatting the code at all.

6 years agoLindent script for Akaros
Ronald G. Minnich [Mon, 19 Aug 2013 20:51:11 +0000 (13:51 -0700)]
Lindent script for Akaros

Some minor changes -- ts and i set to 8.
Should we dump the line length? Do we really care
about 80 columns? I know I don't.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
6 years agoROUNDDOWN can handle uint64_t on 32 bit (XCC)
Barret Rhoden [Thu, 15 Aug 2013 23:44:34 +0000 (16:44 -0700)]
ROUNDDOWN can handle uint64_t on 32 bit (XCC)

ROUNDDOWN was casting to a uintptr_t, which would truncate a uint64_t on
32 bit builds.  (Came up in mboot parsing, when pages above
0x0000000100000000 would get treated as if offset from 0).

Since the compiler complains about the int->pointer->int casting, even
in code that should never be called (based on the sizeof() in
ROUNDDOWN), we had to make ROUNDDOWN (and ROUNDUP) only work on
uintptr_t.  Ideally, we'll fix that in the future (C11 features,
perhaps).

You should reinstall your kernel headers to get the new changes for
userspace, though it's not a huge deal.

6 years agoMultiboot memory detection fixes
Barret Rhoden [Thu, 15 Aug 2013 00:17:39 +0000 (17:17 -0700)]
Multiboot memory detection fixes

A few things:
- Multiboot's regions don't cover all of physical memory; it has holes.  We now
  init the pages[] array (for x86) to mark all pages as busy, and explicitly
  mark the free pages.
- The previous version of this worked a little, since the unmarked, non-free
  pages weren't on any free page lists.  However, the contiguous memory
  allocator (which is really lousy btw) looks directly at refcnts, bypassing
  the lists.
- One problem is that there is a big chunk of unusable memory around 0xfec00000
  (IOAPIC and friends).  This was working okay with multiboot's memory
  mappings, but not with qemu's "here's a lot of memory" approach.  In lieu of
  doing full-fledged memory detection/probing, I'm just ignoring physical
  memory from [0xc0000000, 0xffffffff].  This only applies to qemu, when
  launched with the -kernel flag.
- 32 bit had some other issues when giving out memory near the 4GB mark, as
  well as having other issues with 64 bit addresses (note some of the changes
  from %p to 0x%016llx).
- The bug with giving out pages that were mapped to IO/BIOS/x86 magic regions
  in high memory showed up as clobbered bookkeeping in small slab pages in
  kmem_cache_grow() (stored at the end of the pages improperly allocated).
  Good times!

6 years agoSlightly more consistent VC count interfaces
Barret Rhoden [Sat, 10 Aug 2013 00:21:10 +0000 (17:21 -0700)]
Slightly more consistent VC count interfaces

The main concern was the size of size_t vs uint32_t.  We're still sloppy
about uint32_t vs int.

The kernel header still has max_vcores as a size_t.  I'll change that
next time I muck around in that part of the headers (I don't want to
force more toolchain rebuilds).

6 years agoThread0 can call pthread_exit()
Barret Rhoden [Fri, 9 Aug 2013 23:41:11 +0000 (16:41 -0700)]
Thread0 can call pthread_exit()

Needed to not free thread0's TLS (it was never malloc'd), and needed to
trigger exit() when the last pthread (including thread0) exits.

6 years agoUpdated GETTING_STARTED
Barret Rhoden [Thu, 8 Aug 2013 21:35:04 +0000 (14:35 -0700)]
Updated GETTING_STARTED

With info about how to run without a VM image file, straight outta qemu.

6 years agoThe monitor's trace coretf can query all cores
Barret Rhoden [Thu, 8 Aug 2013 20:37:17 +0000 (13:37 -0700)]
The monitor's trace coretf can query all cores

You can pass -1 for the COREID, and we'll NMI all cores, instead of just one.

Due to this, the NMI handler doesn't print the trapframe by default.  To get
the trapframe, toggle the trace's verbosity to 'on' with "trace verbose".

6 years agox86: option to disable the keyboard
Barret Rhoden [Thu, 8 Aug 2013 20:18:28 +0000 (13:18 -0700)]
x86: option to disable the keyboard

To avoid some SMM overheads on machines with USB keyboards.

Without this, simply sitting in the kernel monitor on core 0 has a massive
performance hit on some benchmarks (10-15x for fluidanimate).

Note that sitting in the monitor still has an effect on performance, for now,
even with the KB disabled.

6 years agox86 can handle missing multiboot mmaps
Barret Rhoden [Thu, 8 Aug 2013 20:02:00 +0000 (13:02 -0700)]
x86 can handle missing multiboot mmaps

If you run qemu with -kernel akaros-kernel, instead of with a hard disk image
(like mnt/hdd.img), qemu won't fake all of the multiboot memory maps.  x86 was
using this info to figure out what memory was free.  We now handle the case
where we only get a maximum memory amount from multiboot.

Incidentally, the memory reported by multiboot from the BIOS usually is
insufficient if you have more than 4GB of RAM, at least in my experience.  This
is why I was parsing the mmap regions, where multiboot details memory about
4GB.  Qemu with -kernel, which doesn't tell us the mmaps, does tell us all of
physical memory via the BIOS methods (mboot_detect_memory()).

With this change, you can run very large kernel images in qemu.  Qemu takes
forever to load large images (> 100MB) when it tries to load from a disk image.
You can load a 300MB+ kernel directly via -kernel in about a minute.

6 years agoFixes KFS multi-paths
Barret Rhoden [Thu, 8 Aug 2013 19:49:21 +0000 (12:49 -0700)]
Fixes KFS multi-paths

You can have multiple KFS paths in your .config (space separated).  KFS will be
built from the union of the contents of all of those directories.

A couple notes:
- if you have multiple directories named the same, they both appear, and with
  the same name.  For instance, you can have two /bins.  When you ls /bin,
  you'll get the contents of both bins.  It's a little weird, but not in a way
  that stops you from merging different KFS paths.  (for now).
- KFS might not like symlinks to directories outside of the KFS path.  Not
  sure.  If you put a symlink in kern/kfs from go -> ../../../go, KFS code
  doesn't like it.  If you really want this behavior, let me know.  O/w, just
  use multiple KFS paths.

6 years agoForgot the risvc Kbuild in last commit
Kevin Klues [Thu, 8 Aug 2013 04:35:54 +0000 (21:35 -0700)]
Forgot the risvc Kbuild in last commit

6 years agoAdded setjmp/longjmp support to the kernel
Kevin Klues [Thu, 8 Aug 2013 04:23:27 +0000 (21:23 -0700)]
Added setjmp/longjmp support to the kernel

Full implementations for 32/64 bit x86.
Stubs in place for riscv with TODOs.
Test and example usage in kern/src/testing.c

6 years agoContext-saving functions are attrib'd return_twice
Barret Rhoden [Mon, 5 Aug 2013 23:22:44 +0000 (16:22 -0700)]
Context-saving functions are attrib'd return_twice

The compiler should warn us if it was unable to generate the code that doesn't
rely on registers across the function call.

The places we used it didn't do much on the return, so this probably wasn't a
problem.  Still, it may be in the future, and this beats inspecting the
assembly.

One thing that isn't clear is whether or not returns_twice causes the compiler
to mark all registers as dead, or just the caller-saved registers.  Probably
the former.

The motivation for this is a stack clobber problem, where the compiler may save
the caller-saved registers (before calling save_user_ctx()) by pushing them on
the stack.  If this happens, when save_ returns the first time, it'll restore
the registers properly, but then could clobber that space so that the second
time it returns, the values it pops are garbage.  Hopefully the compiler will
avoid saving registers in this manner, or otherwise do anything that could be
harmed by returning twice.

6 years agoFixes bug in KFS new inode creation
Barret Rhoden [Sun, 4 Aug 2013 19:22:50 +0000 (12:22 -0700)]
Fixes bug in KFS new inode creation

Wasn't properly initializing the size field.  This would only matter
when creating new files in KFS, and would only trigger if the memory we
alloc'd wasn't already zeroed.

Something like      $ echo "" >> tmpfile    was enough to cause it, once
the bits lined up right.

The previous commit's backtrace was rather useful in determining this
(without it, all we know is there was a KPF in memcpy).

6 years agoArbitrary kernel context backtracing
Barret Rhoden [Sun, 4 Aug 2013 18:57:48 +0000 (11:57 -0700)]
Arbitrary kernel context backtracing

We can backtrace any context compiled with frame pointers, given the
program counter and frame pointer.

The existing monitor command 'backtrace' will still backtrace the
calling context, when given no arguments.  Additionally, it will
backtrace any frame, given the PC and FP.

Kernel page faults on x86 will backtrace the faulting context.  Riscv
still needs an implementation of backtrace_frame().

backtrace_frame() will sort of work for userspace too, though the kernel
won't know the names of functions, and you need to compile all of
userspace with -fno-omit-frame-pointer (which we don't do by default).

6 years agoUserspace handling of errstr and errno (XCC)
Barret Rhoden [Sun, 4 Aug 2013 02:48:46 +0000 (19:48 -0700)]
Userspace handling of errstr and errno (XCC)

Since not all uthreads have TLS, errno and the new errstr need to be
decoupled from the TLS.

When we're a uthread, we'll use storage in the uthread struct for errno
and errstr.  Otherwise, we'll default to the TLS locations (for vcores).
ld.so will continue to use its own area.  Very early in start.c, before
we call out to uthread code, we'd also use the TLS location.

perror() will print out the errstr, if there is one like so:

"your-message: errno-translated-to-text, errstr"

Rebuild your cross compiler.

6 years agoKernel support for set_errstr()
Barret Rhoden [Sun, 4 Aug 2013 01:34:37 +0000 (18:34 -0700)]
Kernel support for set_errstr()

6 years ago__ros_syscall -> __ros_syscall_noerrno (XCC)
Barret Rhoden [Sun, 4 Aug 2013 01:14:37 +0000 (18:14 -0700)]
__ros_syscall -> __ros_syscall_noerrno (XCC)

The *errno_loc parameter was never used by anyone, and this func was
left over from when __ros_syscall_errno() called __ros_syscall() under
the hood.

Since everyone who calls this wants no errno, I just removed it.

Rebuild your cross compiler.  (Copy over the changed files, or just make
clean first).

6 years agox86_64: removes unnecessary syscall (XCC)
Barret Rhoden [Sun, 4 Aug 2013 01:02:34 +0000 (18:02 -0700)]
x86_64: removes unnecessary syscall (XCC)

It was leftover from 32 bit code.

Copy over the changed file and rebuild your cross compiler.

6 years agoAdd an errstr to the syscall struct
Ronald G. Minnich [Fri, 2 Aug 2013 22:07:53 +0000 (15:07 -0700)]
Add an errstr to the syscall struct

Not supported in kernel or userland yet but this will allow us to
get more extensive error info to users as needed.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
6 years agoSmall optimization to inline ros_syscall_sync
Kevin Klues [Fri, 2 Aug 2013 20:55:56 +0000 (13:55 -0700)]
Small optimization to inline ros_syscall_sync

When calling from other libc functions in the same file, just inline it.
Only exposed version of the call is not inlined now.

6 years agoMalloc changes for future plan 9 namespace support
Ronald G. Minnich [Fri, 2 Aug 2013 17:19:41 +0000 (10:19 -0700)]
Malloc changes for future plan 9 namespace support

Add a kzmalloc which zeros the allocated area.

Add a flag, to be done later, which indicates that blocking, instead
of panicing, is ok when memory is not available.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
6 years agox86: fixes initialization errors in page_alloc
Barret Rhoden [Thu, 1 Aug 2013 23:32:07 +0000 (16:32 -0700)]
x86: fixes initialization errors in page_alloc

If the kernel's end symbol was page aligned, pa64_is_in_kernel() would
inaccurately report that address as being in the kernel.  That page actually
can be free.  check_range() was catching this.  Luckily, the error was in the
safe direction; we were marking a free page as busy.

The ROUNDDOWN fix is similar.  Check the comment for details; we're mostly
ignoring the issue for now.

6 years agoPreemption recovery doesn't change TLSs
Barret Rhoden [Thu, 1 Aug 2013 22:59:19 +0000 (15:59 -0700)]
Preemption recovery doesn't change TLSs

Instead of changing TLSs to get at current_uthread, we figure out the linear
address of the remote vcore's current_uthread and access it directly (from
within our usual TLS).

Aside from removing two potentially expensive TLS changes, this also simplifies
and clarifies the code.

6 years agoVcore TLS desc in procdata (XCC)
Barret Rhoden [Wed, 31 Jul 2013 18:47:14 +0000 (11:47 -0700)]
Vcore TLS desc in procdata (XCC)

Userspace now tells the kernel what TLS descriptor to use for each vcore.  The
main reason is that when making a new context, the kernel would zero the TLS
base, and then userspace would quickly set it to the vcore's TLS.  On amd64,
this incurs an extra syscall (for now), and on i686, it's an extra 70ns for the
lousy-LDT mangling.  This change allows the kernel to quickly set the TLS base
(and optionally not change it if it is already correct).

Note that only amd64 uses this option in the kernel; riscv and i686 still
handle this in userspace, but also expose their tlsdesc to the kernel.

The other benefit to this is debugging - it's often helpful for me to have
access to this from the kernel.

As a historic note, this isn't the first arch-dependent tidbit in procdata.
The transition_stack (vcore's stack) was added to procdata since sparc couldn't
handle not having a stack (x86 was just loading %sp in assembly before _start).

6 years agox86: catches buggy rdtscp
Barret Rhoden [Wed, 31 Jul 2013 00:20:30 +0000 (17:20 -0700)]
x86: catches buggy rdtscp

Not sure if this is a "bug in qemu" or something I'm doing wrong.  But rdtscp
should drop the value of MSR_TSC_AUX in ecx.  If this fails, it busts our
FAST_COREID.  If this happens to you in a VM, just change your CONFIG.

If it happens on hardware, let me know.

6 years agoRemoves unnecessary TLS var from vcore.c
Barret Rhoden [Tue, 30 Jul 2013 02:27:28 +0000 (19:27 -0700)]
Removes unnecessary TLS var from vcore.c

Not sure why that was in TLS.  If I had a good reason, then I should
have left a note...

6 years agoUthreads do not require TLS
Barret Rhoden [Tue, 30 Jul 2013 02:11:03 +0000 (19:11 -0700)]
Uthreads do not require TLS

By default, individual uthreads will not have their own TLS; they will piggyback
off of their vcore's TLS.  The uthread library can handle individual
uthreads having TLS.

Note that thread0 (from glibc) will have TLS, no matter what.   FYI,
thread0's TLS gets used at exit, and needs to be the same as when the
program started (C++ programs, fluidanimate at least).

2LSs choose whether or not their specific uthreads have TLS.  To be
somewhat compatible, pthreads will have them by default.  If you're app
doesn't need TLS, call pthread_need_tls(FALSE), preferably before call
pthread_create().

For reference, this lowers the latency of the context switch (via the
untuned pthread_test 100 100000 1) from ~360ns -> 194ns.  That includes
3 mcs locks in the 2LS, which we could minimize.

6 years agoAdd basic timeout functionality to pthread futexes
Kevin Klues [Tue, 30 Jul 2013 03:28:56 +0000 (20:28 -0700)]
Add basic timeout functionality to pthread futexes

In the current implementation we simply launch a helper pthread that
calls sys_block(1000) in a tight loop.  It wakes up every millisecond
and checks if there are any futexes whose timeouts have expired and it
wakes them up. If there are no futexes waiting on a timer, we park the
pthread and wait until another futex is waited on that has timeout.

6 years agoUpdate futex code to faster method for blocking
Kevin Klues [Tue, 30 Jul 2013 00:18:12 +0000 (17:18 -0700)]
Update futex code to faster method for blocking

This method has proven to be significantly faster when using the 2LS
futex code in the context of lithe.  I ported it over from the futex
code I wrote for lithe as the 2LS.

6 years agoExpose akaros_syscall_sync through libc (XCC)
Kevin Klues [Sun, 28 Jul 2013 23:59:38 +0000 (16:59 -0700)]
Expose akaros_syscall_sync through libc (XCC)

This function takes a syscall struct as a parameter and performs a
single synchyronous syscall using that struct.  If the syscall is not
complete upon exiting the kernel the currently running thread will be
handed off to the 2LS and blocked there.

6 years agoFixes assembly input clobbers (XCC)
Barret Rhoden [Sat, 27 Jul 2013 05:21:57 +0000 (22:21 -0700)]
Fixes assembly input clobbers (XCC)

You can't list an input as a clobber, so to actually clobber it, you
need to use it as an output.  So we use a dummy variable, and hopefully
the compiler does the right thing.

Note we can't (or at least shouldn't) output to the same input variable
(using "+D"(a0), for instance).  We aren't actually outputting a valid
value for any variable; it's usually gibberish or 0, and we don't want
the compiler to *not* save and restore any input args that it may need in
the future.

Also note that these issues are just with the software contexts, where I
was trying to use the asm clobbers to mimic the amd64 calling
convention, so none of the HW TFs were affected.

Reinstall your cross compiler.

6 years agoAdds a KMSG tracer
Barret Rhoden [Sat, 27 Jul 2013 00:14:35 +0000 (17:14 -0700)]
Adds a KMSG tracer

This traces all kernel messages and MCP proc_yields (which affect the
local context much like a KMSG).  It's a non-overwrite, so you'll need
to reset the ring to get up-to-date results.

Default is off.

6 years agoAdds a pcpui trace buffer for generic events
Barret Rhoden [Sat, 27 Jul 2013 00:09:51 +0000 (17:09 -0700)]
Adds a pcpui trace buffer for generic events

Users pick the next available type and provide a handler.  You can run
all the handlers or reset the trace ring from the kernel monitor (e.g.
trace pcpui, trace pcpui-reset).

All users should use the same access method (racy, no overwrite).  If
some subsystem uses overwrite, they'll end up starving the
non-overwriters.

6 years agoAdds a tracing facility for in-kernel events
Barret Rhoden [Sat, 27 Jul 2013 00:05:59 +0000 (17:05 -0700)]
Adds a tracing facility for in-kernel events

Useful for debugging.  Check out k/i/trace.h for info and how to use it.

6 years agoCleans up restartcore/smp_idle, fixes corner case
Barret Rhoden [Thu, 25 Jul 2013 18:37:02 +0000 (11:37 -0700)]
Cleans up restartcore/smp_idle, fixes corner case

It was possible to have a proc's address space hang around on a core, if that
core was idle, then received a __startcore, followed quickly by __death, and
then was never used again.

This cleans up this situation (abandon_core() aggressively if there is no
owner), and cleans up proc_restartcore() and smp_idle() a little.

6 years agox86: smp_boot no longer uses smp_call_*
Barret Rhoden [Sat, 20 Jul 2013 01:05:17 +0000 (18:05 -0700)]
x86: smp_boot no longer uses smp_call_*

Instead, we have a dedicated IRQ vector that does nothing but return.
This is enough to break the non-core0s out of their hlt.

Other than it being nice to not need the ancient smp_callsi_ (which
might go away), this is needed if you run with FAST_COREID.  Before,
smp_call_ would trigger a full irq_handler(), which increments pcpui
irq_depth, before core_id() is ready.  The other option would be to use
a core_id_early() call in irq_handler(), which I dislike.

Also, don't repurpose the POKE_HANDLER() without thinking about how it
might interact with abort_halt().

6 years agox86: fast core_id() option
Barret Rhoden [Thu, 18 Jul 2013 23:42:11 +0000 (16:42 -0700)]
x86: fast core_id() option

Implements core_id() with rdtscp.  VM support for rdtscp can be a bit
spotty.  If you want to run with this, try it once without, and see if
the kernel detects support for rdtscp (in the bootup output).  If so,
you're good to go.

6 years agox86: fixes backtrace bug
Barret Rhoden [Thu, 18 Jul 2013 22:38:26 +0000 (15:38 -0700)]
x86: fixes backtrace bug

Was using func_name after freeing.

6 years agox86: fixes early core_id() calls
Barret Rhoden [Wed, 17 Jul 2013 21:21:28 +0000 (14:21 -0700)]
x86: fixes early core_id() calls

Ever since we set up minimal paging in assembly, we were unable to access the
LAPIC (and therefore coreid) until the LAPIC was mapped in during vm_init().
This prevented the newer panic and warn from working, and totally killed
spinlock debugging.

Previously, we had a full "virtual" KERNBASE mapping (in 32 bit) with
segmentation.  I think those attempted accesses of the unmapped LAPIC were just
silentely returning 0, which is the 'right' answer at that stage of bootup.
Either way, now that paging is on, unmapped LAPIC accesses would page fault and
trigger a reboot since the IDT isn't set up yet either.

Any callers of core_id() that can happen before vm_init() need to use
core_id_early().  I'm not overly concerned about code reachable via the
monitor, since if you got there, it's by a panic and we should already be
working on that problem.  If this is too much of a burden, we can just put the
bool check in core_id(), and take that potential cache miss on every call.

6 years agox86: fixes read_tsc_serialized()
Barret Rhoden [Wed, 17 Jul 2013 22:16:09 +0000 (15:16 -0700)]
x86: fixes read_tsc_serialized()

The compiler was reordering operations (stores, in one case) past the
serialization.

6 years agox86_64: support for machines with only 2MB pages
Barret Rhoden [Fri, 19 Jul 2013 23:43:13 +0000 (16:43 -0700)]
x86_64: support for machines with only 2MB pages

Some machines (future AMD ones? and definitely some VMs) don't support 1
GB jumbo pages.

This adds in support for using 2MB jumbos for the boot mappings.

This adds an extra 2MB or so of extra memory in the data segment for the
pml2s, regardless of whether or not your machine needs them.  I might
add a CONFIG for that at some point.

6 years agox86_64: boot up error messages
Barret Rhoden [Fri, 19 Jul 2013 16:35:31 +0000 (09:35 -0700)]
x86_64: boot up error messages

If the machine can't support long mode (unlikely) or 1 GB pages (more
likely, esp for VMs), we print an error message and halt.  If we need
more error checking, we can add it in easily.

The errors will be printed to the CGA and COM1.