akaros.git
5 years agoAdd spin_lock_irqsave transformation for ilock
Ronald G. Minnich [Thu, 16 Jan 2014 22:05:58 +0000 (14:05 -0800)]
Add spin_lock_irqsave transformation for ilock

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agonullmedium compiles, with warnings.
Ronald G. Minnich [Thu, 16 Jan 2014 22:03:40 +0000 (14:03 -0800)]
nullmedium compiles, with warnings.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoadd in the inferno stack.
Ronald G. Minnich [Thu, 16 Jan 2014 19:51:24 +0000 (11:51 -0800)]
add in the inferno stack.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoRemove all the old proto stack.
Ronald G. Minnich [Thu, 16 Jan 2014 19:45:14 +0000 (11:45 -0800)]
Remove all the old proto stack.

5 years agoAdd the inferno networking code, minus il
Ronald G. Minnich [Thu, 16 Jan 2014 19:31:39 +0000 (11:31 -0800)]
Add the inferno networking code, minus il

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoRip out the old network stack. It's in the way.
Ronald G. Minnich [Thu, 16 Jan 2014 19:27:37 +0000 (11:27 -0800)]
Rip out the old network stack. It's in the way.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoerror.c from inferno
Ronald G. Minnich [Thu, 16 Jan 2014 18:29:16 +0000 (10:29 -0800)]
error.c from inferno

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoInterim commit, compiles. We need to bring in support code now.
Ronald G. Minnich [Thu, 16 Jan 2014 16:31:12 +0000 (08:31 -0800)]
Interim commit, compiles. We need to bring in support code now.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoFirst Inferno imports
Ronald G. Minnich [Thu, 16 Jan 2014 01:30:23 +0000 (17:30 -0800)]
First Inferno imports

This is first pass and we're including the Inferno files as-is
so we can retain some ideas about what we change.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoBring forward the modern shiny scripts.
Ronald G. Minnich [Thu, 16 Jan 2014 01:21:36 +0000 (17:21 -0800)]
Bring forward the modern shiny scripts.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoLatest and greatest ifconfig/root scripts
Barret Rhoden [Thu, 16 Jan 2014 21:19:23 +0000 (13:19 -0800)]
Latest and greatest ifconfig/root scripts

Don't want to lose the config settings and whatnot.

5 years agoqlock wrappers
Barret Rhoden [Thu, 16 Jan 2014 21:13:35 +0000 (13:13 -0800)]
qlock wrappers

qlocks are binary semaphores.  For now, they are just wrappers around
our sems.

qlocks must be initialized.  plan9 will probably just set it to 0, and
then will hang the first time it tries to lock.

I didn't bother porting over the ilocks.  Should just spatch and
initialize those.

5 years agokmalloc_align()
Barret Rhoden [Tue, 10 Dec 2013 02:30:30 +0000 (18:30 -0800)]
kmalloc_align()

Can be freed with kfree().  Same goes for kzmalloc_align().  Alignment
must be a multiple of sizeof long.

Did some basic tests on 32 and 64 bit.  32 bit complains at compile time
(ROUNDUP).  Feel free to fix that, if someone has a nice way.  Or make
the compiler smarter to not complain about casts in branches it'll never
take.

5 years agoClarifies minor PIT comments
Barret Rhoden [Mon, 9 Dec 2013 17:55:01 +0000 (09:55 -0800)]
Clarifies minor PIT comments

We only ever use PIT timer 1, which has 0, 1, and 2 counters.  Some of
the comments made it harder to verify that.

5 years agoMask PIT timer IRQ by default
Barret Rhoden [Mon, 9 Dec 2013 03:43:44 +0000 (19:43 -0800)]
Mask PIT timer IRQ by default

Needed for Ron's machine.

5 years agolore file.
Ronald G. Minnich [Mon, 9 Dec 2013 02:49:52 +0000 (18:49 -0800)]
lore file.

Stuff we must never forget.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoDirty hack for serial I/O on Ron's AMD
Barret Rhoden [Sun, 8 Dec 2013 23:29:08 +0000 (15:29 -0800)]
Dirty hack for serial I/O on Ron's AMD

Hopefully this will go away very soon.  We're not getting serial IRQs,
so we poll whenever another IRQ (timer) goes off.

5 years agoFix race with x86 boot
Barret Rhoden [Sun, 8 Dec 2013 22:35:45 +0000 (14:35 -0800)]
Fix race with x86 boot

It's possible that some IRQ could break the AP cores out of their halt
before core 0 set up things for the final core init.

5 years agoAdd a line of info to the Go docs
Ronald G. Minnich [Sun, 8 Dec 2013 20:49:00 +0000 (12:49 -0800)]
Add a line of info to the Go docs

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoFixes AMD cpuinfo MSR problem
Barret Rhoden [Sat, 7 Dec 2013 00:08:20 +0000 (16:08 -0800)]
Fixes AMD cpuinfo MSR problem

Broader problem: some MSRs are Intel specific, some aren't.  We call all
of them IA32_.  This patch only access two known-bad MSRs if we think we
are Intel.  The MISC_ENABLE was crashing AMD boxes.  FEATURE_CONTROL
hasn't crashed anything yet, but I don't see it in the AMD manual.

5 years agoCleans up tests/
Barret Rhoden [Fri, 6 Dec 2013 22:20:09 +0000 (14:20 -0800)]
Cleans up tests/

We're making a lot of old tests that we don't need, and they all
bloat the size of the initramfs.  This cuts it from 48MB to 26MB or so,
for me.  Glibc still takes up 13MB.

Part of the reason each test is large (200KB+) is that they all
statically link parlib.

All of the tests still live in an old/ directory.  Feel free to add more
tests, in general.  Anything we'll regularly use can be in the main
tests/ directory.  I'm just tired of building (and copying across the
network) huge kernel images.

You might need to make userclean.

You'll also want to clean out binaries from kern/kfs/bin, since those
won't get automatically cleaned.  To do this, I mv'd busybox out of KFS
temporarily, then did:

$ find kern/kfs/bin -type f -exec rm '{}' \+

(or something similar) to remove the binaries, but not the symlinks for
busybox.  Then I mv'd busybox back.

5 years agoMakefile can detect changes in alternate KFS dirs
Barret Rhoden [Tue, 3 Dec 2013 07:55:07 +0000 (23:55 -0800)]
Makefile can detect changes in alternate KFS dirs

If we don't have kfs-paths as the source of kern_initramfs_files, make
probably won't notice the change to files in any directory other than
FIRST_KFS_PATH, and thus it won't rebuild KFS with the updated files.

This change can detect missing directories too, though you'll need to
run make a couple times if you recently had a bad KFS paths list, due to
how we don't process the .config right away.

5 years agoHack for qemu's missed LAPIC timers
Barret Rhoden [Tue, 3 Dec 2013 06:50:33 +0000 (22:50 -0800)]
Hack for qemu's missed LAPIC timers

If your system hangs and needs keyboard input (or network packets) to
wake up, try turning on LOUSY_APIC_TIMER, and report your results to the
mailing list.  We've seen this on qemu with KVM disabled.

Here's part of the email with details from debugging this:

------------------------------
> still, the question is whether or not __trigger was sitting there as
> an RKM while we halted the core, or if the timer IRQ didn't fire
> until we hit the KB.  i'll poke around a bit - i should be able to
> check the RKM queue from qemu.

turns out that we don't have any pending RKMs when everything is
halted (looked at the memory from qemu), which means the timer interrupt
isn't going off (since it should enqueue an RKM).  then once we hit a
key (like CTRL-Q), the timer interrupt does fire before the KB/serial
IRQ; we see the RKM __trigger_tchain queued (via the monitor/kfunc).

so it looks like the timer IRQ should fire, but doesn't.  and then when
we fire some other IRQ, like serial/KB, the timer IRQ does fire.  i
haven't been able to inspect the LAPIC from qemu - that's not the sort
of thing they'd emulate in physical memory for the monitor, i guess.

anyway, perhaps qemu with-no-kvm doesn't like something about our local
apic timer IRQs?  since qemu doesn't report an always running APIC, it's
possible for the timer to stop in deep C states or speedstep
transitions (SDM 3a 10.5.4).  though even when we -enable-kvm, qemu
also reports no "always running APIC."  maybe qemu is getting confused
and turning something off, or i screwed up some initialization?  Or
perhaps qemu doesn't like our use of "hlt", and has some race of it's
own where halt and alarms happen concurrently.

whenever we do break it out (via KB, for instance), we actually get two
IRQs delivered (handle_irq() runs twice from the moment i hit ctrl-q
til we get into the monitor (which happens directly from ctrl-q's IRQ
handler)).  so probably the first IRQ is the LAPIC timer, and the second
is the keyboard.

incidentally, any IRQ, not just a keyboard/serial IRQ, is enough to
break qemu out of its funk.  so instead of holding down the space bar
with a power supply, you can keep trying to telnet to localhost:5555.
=)

5 years agoFix the top level makefile
Ronald G. Minnich [Wed, 27 Nov 2013 17:41:23 +0000 (09:41 -0800)]
Fix the top level makefile

If your .config included more than on kfs path, and any of those
paths did not exist, empty directories were created. Fix that.

Fix the logic up a bit on creating the image such that
you have some idea that a directory in your paths does
not exist.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoFixes ktask aborting
Barret Rhoden [Tue, 26 Nov 2013 19:50:21 +0000 (11:50 -0800)]
Fixes ktask aborting

For some reason, my original testing machine didn't catch this.  proc can be
non-zero, but still gibberish, causing a PF.

5 years agoKernel alarms pass the alarm ID
Barret Rhoden [Tue, 26 Nov 2013 02:06:20 +0000 (18:06 -0800)]
Kernel alarms pass the alarm ID

So userspace can tell which of it's #A alarms is firing.  With this (and
with multiple event handlers per event), we could have multiple alarm
handlers register and run dynamically.  Alternatively, we could switch
based on the ID, if there was one common handler (can do that
statically).

Note that the existing alarm examples can receive multiple events for
the same alarm.  It's up to userspace to handle that (it's easy, and we
do it).  This is a consequence of using SPAM_PUBLIC.  If your alarm
can't handle that, use an INDIR/FALLBACK.  This is part of the reason
why I didn't make a helper to set up all the alarm stuff - people will
want to customize, especially in the realm of the ev_q.  (The other
issue is whether or not CLOEXEC is used.  And there may be other issues
I haven't thought of).

Multiple ev_qs can be registered for different alarms; it's just hard to
share the event handler for them all, hence this patch.  I'll deal with
this more if we ever get someone who wants to use multiple kernel alarms
with different handlers.

5 years agoDestroying procs will abort their syscalls
Barret Rhoden [Tue, 26 Nov 2013 00:58:36 +0000 (16:58 -0800)]
Destroying procs will abort their syscalls

Will only abort the abortable syscalls, not ones blocked on qlocks or
anything other than a rendez_sleep().

5 years agoFix for concurrent syscall aborters
Barret Rhoden [Mon, 25 Nov 2013 23:45:30 +0000 (15:45 -0800)]
Fix for concurrent syscall aborters

And adds some explanation about the issues of aborting syscalls.
Massive amounts of notes paid off; they reminded me of the
multiple-aborter case.

5 years agoNotes on using Go.
Ronald G. Minnich [Fri, 22 Nov 2013 22:35:12 +0000 (14:35 -0800)]
Notes on using Go.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoAlarm to abort syscalls, should be used in ping
Barret Rhoden [Fri, 22 Nov 2013 18:39:08 +0000 (10:39 -0800)]
Alarm to abort syscalls, should be used in ping

Will need to reorganize a lot of userspace's libraries.  Stuff like
nsec2tsc() doesn't need to be in a benchmarking library.  Same goes for
the alarm stuff; benchutil is more of a "everything I can't put in
parlib that we want by default."

5 years agoFixes tchain corruption
Barret Rhoden [Fri, 22 Nov 2013 01:55:34 +0000 (17:55 -0800)]
Fixes tchain corruption

If you have multiple unsets of the same waiter, you would corrupt the
list.  I actually had this happen, though I'm not sure how.  The ksched
alarm was getting accidentally ripped off this list, causing all
processes to hang.  My hunch is that ping was setting and cancelling
alarms frequently, and perhaps userspace submitted concurrent requests
to unset its main alarm.

5 years agoFixes bug with cross-core kernel alarms
Barret Rhoden [Fri, 22 Nov 2013 01:05:09 +0000 (17:05 -0800)]
Fixes bug with cross-core kernel alarms

Bad pointer arithmetic.

5 years agoSYS_abort_syscall (XCC)
Barret Rhoden [Fri, 22 Nov 2013 00:14:26 +0000 (16:14 -0800)]
SYS_abort_syscall (XCC)

Userspace can request the cancellation of a syscall.  If that sysc is
blocked on a rendez, such as when listening on a network chan, it will
return via error().  If not, nothing will happen.

Reinstall your kernel headers.

5 years agoPlan9 style waserror() handling
Barret Rhoden [Thu, 16 Jan 2014 20:49:01 +0000 (12:49 -0800)]
Plan9 style waserror() handling

Adapted from the latest version we built for the old 9ns branch.

You'll need to #include err.h to use this.  Since it includes some other
files of its own, I didn't want to put it in common.h.

5 years agoUserspace alarm service
Barret Rhoden [Wed, 20 Nov 2013 19:35:25 +0000 (11:35 -0800)]
Userspace alarm service

Built off #A, this provides a basic alarm handler service similar to the
kernel's.  The main differences are that there are no semaphores and
only one tchain (interrupt source).

Instead of having to set up a full #A alarm for every little handler,
you can use the user alarm service, which will multiplex them in
userspace off a single kernel alarm.

5 years agoAdds devalarm (#A)
Barret Rhoden [Wed, 20 Nov 2013 00:02:27 +0000 (16:02 -0800)]
Adds devalarm (#A)

It is an alarm service for processes.  Check out the top of
k/d/d/alarm.c and the test for more details.

Commented out right now, since we don't have a 9ns stack.

5 years agoDon't print spurious interrupts
Ronald G. Minnich [Wed, 20 Nov 2013 17:59:01 +0000 (09:59 -0800)]
Don't print spurious interrupts

They happen way more than we thought and we don't care.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoShort doc on using go9p so people don't have to search so much
Ronald G. Minnich [Wed, 20 Nov 2013 17:57:20 +0000 (09:57 -0800)]
Short doc on using go9p so people don't have to search so much

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoFixes PF in sys_exec()
Barret Rhoden [Wed, 20 Nov 2013 02:49:20 +0000 (18:49 -0800)]
Fixes PF in sys_exec()

This could happen if load_elf() tries to set_errno().  This could happen
if we failed to load the requested interpreter (ei.interp).

5 years agoHack for mon_bin_run()
Barret Rhoden [Tue, 19 Nov 2013 21:50:16 +0000 (13:50 -0800)]
Hack for mon_bin_run()

This only matters when you run bin_run (or bb) while another process is
current on the core.  Say you lock up a process and want to get another
shell, prior to this the new shell would inherit certain things from the
active process, due to assumptions in the create paths about the
relationship between the parent and current.

5 years agoFix up of file open flags (XCC)
Barret Rhoden [Tue, 19 Nov 2013 21:21:19 +0000 (13:21 -0800)]
Fix up of file open flags (XCC)

Plan9 and glibc differed in their open flags, as well as semantics on
things like CREATE.  Note there is no OCREAT in plan9, so we've got more
of a mashup of flags and syscalls.

I tried to get the intent of openmode() correct: reduce to the access
mode type, with EXEC => RDONLY, and ignore all the other flags.

devsrv's open was aborting for TRUNC, though I don't see why.  These
fake devices should be ignoring it anyways; everything is one big write
from the beginning, for all writes.

Reinstall your kernel headers, if you want access to the flags from
userspace.

5 years agoStub sleep in glibc (XCC)
Barret Rhoden [Tue, 19 Nov 2013 00:25:08 +0000 (16:25 -0800)]
Stub sleep in glibc (XCC)

Some plan9 programs are calling sleep, and that links to some old
half-built POSIX sleep in glibc that ends up just busy waiting.

We don't support the regular sleep() directly; specifically, we don't
inrerupt sleep on signal delivery.  2LSs could build this if they want,
though signals are sent to processes, not to threads.  In that sense,
sleep is a bit wrong for what we want to do.

If you want to just put a uthread to sleep for a certain amount of time,
you can call uthread_sleep().  Its dumb and just uses the debugging
sys_block to wait in the kernel (we could do it in userspace, for
instance, with an alarm system).

Anyway, I mostly wanted to see stub warnings when compiling something
that calls sleep(), since that is a sign that the program will have
issues with signal handling / porting.

You need to copy over the sleep file into glibc-2.14.1/ and rebuild, or
do a make clean and rebuild your cross compiler.

5 years agoAdds read-only umem helper
Barret Rhoden [Mon, 18 Nov 2013 23:32:58 +0000 (15:32 -0800)]
Adds read-only umem helper

5 years agoSafety checks in send_event()
Barret Rhoden [Mon, 18 Nov 2013 23:31:02 +0000 (15:31 -0800)]
Safety checks in send_event()

Catch future IRQ calls of send_event().  Also, send_event() might be
able to handle PROC_DYING, but just in case, we abort.  Once again,
we're using "the immutable state of DYING" here (no worry of races once
your DYING when you hold a ref).

5 years agoKernel alarm handling moved to RKM context
Barret Rhoden [Mon, 18 Nov 2013 23:07:32 +0000 (15:07 -0800)]
Kernel alarm handling moved to RKM context

Instead of running handlers from IRQ context, we shift them to RKM
context.  Alternatively, we could only do this for the awaiter handlers
(and not the semaphores), but it's probably not a big deal.

The reason for this so that we can easily send_event from an alarm
handler.  Right now, you can't send_event from IRQ context since it
might trigger a proc wakeup (grab the proclock, scheduler callbacks,
etc), all of which are not irqsave.

While I could change all of those, I'd rather cut down on the amount of
things in IRQ context (both for interrupt latency as well as for code
safety - RKMs can block, etc, though a block will delay all alarms under
the current code).  Keep in mind that send_event() can also trigger an
mmap call.  If we ever want blockable alarms, we can easily put that in
(IRQ handler wakes sems, executes handlers marked "IRQOK", and launched
an RKM otherwise).

5 years agoFixes reset_alarm_abs()
Barret Rhoden [Fri, 15 Nov 2013 04:59:55 +0000 (20:59 -0800)]
Fixes reset_alarm_abs()

It couldn't handle an alarm that had never been set, since has_fired was
initially 0.  Renaming has_fired clarifies its use, fixes the init
problem, and makes the code clearer.

5 years agoKmalloc canary debugging
Barret Rhoden [Sat, 16 Nov 2013 21:51:59 +0000 (13:51 -0800)]
Kmalloc canary debugging

This was originally used to fix a kmalloc bug in mntwalk.

The issue that pops up with any 9ns code doing its own walks was messing
up with the wq size:

- wq = kzmalloc(sizeof(struct walkqid) +
-       (nname - 1) * sizeof(struct qid), 0);
+ wq = kzmalloc(sizeof(struct walkqid) + (nname) * sizeof(struct qid),
+   KMALLOC_WAIT);

It seems that any plan9 walk is going to have the problem.  We had a
similar issue with devwalk, and it looked the same.  (Canary clobber in
namec for e.elems, and the clobber was due to a previous (in memory, not
in time) kmalloc).

5 years agoBe a little more verbose when kfree fails.
Ronald G. Minnich [Sat, 16 Nov 2013 21:55:30 +0000 (13:55 -0800)]
Be a little more verbose when kfree fails.

Print out what the canary was and what it was expected to be.
Then, hexdump 128 bytes before and after the passed in
address.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoAdd a hexdump function
Ronald G. Minnich [Sat, 16 Nov 2013 21:48:49 +0000 (13:48 -0800)]
Add a hexdump function

Very handy when things go wrong.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
5 years agoSwitches kernel stack size to 8KB
Barret Rhoden [Fri, 15 Nov 2013 08:05:24 +0000 (00:05 -0800)]
Switches kernel stack size to 8KB

Not a fan, and I'd like to undo this once we cut down on our excessive
stack use.  But we need this for sanity now.

5 years agox86 serial input converts \r to \n
Barret Rhoden [Fri, 15 Nov 2013 00:57:31 +0000 (16:57 -0800)]
x86 serial input converts \r to \n

This is probably part of an ongoing disconnect at the console level
between the kernel and userspace.

The serial port reads a \r for a newline (at least in qemu and in
minicom a while back).  Userspace in general can't handle that.  csquery
couldn't, and busybox also has issues (try rm on
/9/bin/somefile-that-exists, you'll hang on the "really remove this?"
query).

5 years agoAdds reset_alarm_abs()
Barret Rhoden [Wed, 13 Nov 2013 02:10:36 +0000 (18:10 -0800)]
Adds reset_alarm_abs()

Alarm resets will allow a caller to update the time at which the alarm
will fire.  This way, you can increase the time of an alarm, while
keeping the system armed.  It is equivalent to unset_alarm; set_alarm;,
except that there is only one resetting of the tchain interrupt.

There is no guarantee that the alarm hasn't already fired.  If it has,
it will get reinserted into the tchain.

This isn't super-necessary for the kernel, since resetting the IRQ is
pretty easy.  But userspace will have alarm code that is highly similar
(and will use k/s/alarm.c as a base) and resetting the IRQ takes a
syscall from userspace.

If we need _rel and _inc, we can add those easily.

5 years agoAdds test program to fetch a web page
Barret Rhoden [Wed, 6 Nov 2013 03:36:44 +0000 (19:36 -0800)]
Adds test program to fetch a web page

Timeouts don't work properly, so if you try to connect to a non-existent
host/port, you'll probably hang forever.

5 years agoFixes VFS open bug
Barret Rhoden [Tue, 5 Nov 2013 23:28:54 +0000 (15:28 -0800)]
Fixes VFS open bug

Need to store the flags, apparently.

5 years agoUnset errno when VFS fails
Barret Rhoden [Tue, 5 Nov 2013 23:06:35 +0000 (15:06 -0800)]
Unset errno when VFS fails

When the VFS fails an open or similar call, it sets errno.  When 9ns
succeeds, errno is still set.

While this is acceptable use of errno (should only check it if you know
the call failed, in a call-specific manner), Go has trouble with this
(at least our Go).  I'm fine with dealing with this in-kernel, though I
don't promise to not touch errno in the case of success.

Note this commit is applied with no 9ns stuff in place (like in open and
stat).

5 years agoAdds some busybox editors
Barret Rhoden [Tue, 5 Nov 2013 01:51:46 +0000 (17:51 -0800)]
Adds some busybox editors

ed seems to work, not that I know it very well.  sed works too (at least
a basic sed 's/foo/bar/g' does).

vi doesn't work (screen control is all messed up).  Haven't tried awk.

You'll need to copy this config file to your busybox directory as
.config, then remake.  And of course copy the binary to KFS.

To save you all the hassle, I put symlinks in KFS for all the busybox
commands I use.

Here's some reading:
http://linux.about.com/library/cmd/blcmdl1_ed.htm
http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ed.html
http://cm.bell-labs.com/cm/cs/who/dmr/qed.html

5 years agoHalf-assed file truncation
Barret Rhoden [Tue, 5 Nov 2013 01:50:43 +0000 (17:50 -0800)]
Half-assed file truncation

Need to do something with the page cache, but hopefully we won't mess
with it at all.

5 years agoVFS helpers for getting/putting FDs
Barret Rhoden [Mon, 4 Nov 2013 16:53:57 +0000 (08:53 -0800)]
VFS helpers for getting/putting FDs

So that 9ns can use FD numbers from VFS space, and we don't need to
convert between the two.

This may have some issues, since the 9ns hacked fd lookup isn't
implemented yet.

5 years agoProperly close files when destroying procs
Barret Rhoden [Fri, 1 Nov 2013 20:54:54 +0000 (13:54 -0700)]
Properly close files when destroying procs

I'm not 100% happy with this, but we're locking anyways, so we might as
well use it to prevent concurrent additions/modifications when we're
destroying the process.

This prevents us from sharing fgrps, which I'm okay with.

There are lots of races involved, check the comments for details.

I left in the notes about where to deal with plan9/inferno chans.

5 years agoAllow multiple handlers per IRQ
Barret Rhoden [Wed, 30 Oct 2013 22:02:18 +0000 (15:02 -0700)]
Allow multiple handlers per IRQ

We don't allow unregistering yet - requires RCU-like sync with the read
side.

5 years agoPADDR helpers for lower and upper 32 bits
Barret Rhoden [Tue, 29 Oct 2013 23:50:15 +0000 (16:50 -0700)]
PADDR helpers for lower and upper 32 bits

We usually need to tell devices 64 bit PADDRs in two separate 32 bit
chunks.  Also, I added some catches for the RTL driver.  Without this
check, we could have the NIC writing on the wrong pages (when the true
PADDR > 4 GB).

5 years agoDynamic virtual memory mapping helpers
Barret Rhoden [Tue, 29 Oct 2013 15:11:36 +0000 (08:11 -0700)]
Dynamic virtual memory mapping helpers

We'll see, but most users probably just want the mapping to happen, and
don't care about splitting up the getting the segment and doing the
mapping.

5 years agoPCI cleanup
Barret Rhoden [Mon, 28 Oct 2013 22:54:15 +0000 (15:54 -0700)]
PCI cleanup

Includes helper functions for reading/writing 16/8 bit registers in the config
space and the ensuing cleanup.

Also includes better detection of multifunction devices; we only scan
for them if we know we have a multifunction, instead of scanning all the
time.  We also were missing out on the header type frequently, since we
didn't mask 0x7c.

5 years agox86: helper for PCI bus mastering
Barret Rhoden [Mon, 28 Oct 2013 00:16:10 +0000 (17:16 -0700)]
x86: helper for PCI bus mastering

Probably every PCI device that needs to DMA will need to set this.

5 years agox86: locking when messing with the PIC
Barret Rhoden [Fri, 25 Oct 2013 21:43:13 +0000 (14:43 -0700)]
x86: locking when messing with the PIC

This is ultra-paranoia.  In general, we only mess with the PIC from
core 0.  That's the only core we route PIC IRQs to.  But there's a
chance we have an MCP that triggers something like a mask or unmask of
the PIC, which could happen concurrently with an IRQ.  I don't know if
we have anything that can do that yet, but better safe than sorry.

As far as the extra perf overheads go, ideally we wouldn't even be using
the PIC, but we'd have the same set of issues with the IOAPIC, and will
need locking in those cases too.

5 years agox86: sends the EOI later in the IRQ path
Barret Rhoden [Fri, 25 Oct 2013 21:18:52 +0000 (14:18 -0700)]
x86: sends the EOI later in the IRQ path

I've gone back and forth on this.  Check out 1b50da7e for reference.

Right now, we're taking more spurious IRQs, probably due to sending EOI
early.  It's not necessary for ipi_is_pending() to send early either,
and I don't see other OSs doing it.

5 years agoFix spurious IRQ check
Barret Rhoden [Fri, 25 Oct 2013 19:29:04 +0000 (12:29 -0700)]
Fix spurious IRQ check

5 years agoNIC drivers use register_dev_irq()
Barret Rhoden [Wed, 23 Oct 2013 05:22:40 +0000 (22:22 -0700)]
NIC drivers use register_dev_irq()

In plan9, this would go in devether.

5 years agoHelper for registering device IRQs
Barret Rhoden [Wed, 23 Oct 2013 05:19:58 +0000 (22:19 -0700)]
Helper for registering device IRQs

This puts all the dirty hacks into one place, without drivers needing to
know about the particulars of IRQ routing, which interrupt handler table
to use, etc.

5 years agoPCI cleanup and better BAR handling
Barret Rhoden [Wed, 23 Oct 2013 04:42:22 +0000 (21:42 -0700)]
PCI cleanup and better BAR handling

Not perfect, but it gets some of the muck out of the drivers.

5 years agoSome tweaks to print_func_entry()
Barret Rhoden [Mon, 21 Oct 2013 01:31:15 +0000 (18:31 -0700)]
Some tweaks to print_func_entry()

We need the tab resetting, since for every kproc that doesn't return, we
tab in at least once.

Turning it off easily is also useful, without spatching over and over.

The Core printf helps a little with concurrency slightly, though
kthreads end up running on core 0, so you'll still need to manually edit
the trace.

5 years agoFixes set_alarm() for alarm handlers
Barret Rhoden [Sun, 20 Oct 2013 17:05:48 +0000 (10:05 -0700)]
Fixes set_alarm() for alarm handlers

set_alarm() grabs the tchain lock.  In alarm handlers, currently the
lock is already held while executing the handlers.

Instead, use __set_alarm() when the tchain lock is already held.

5 years agoMore defensive atoi()
Barret Rhoden [Sun, 20 Oct 2013 17:01:28 +0000 (10:01 -0700)]
More defensive atoi()

Needed this to catch a bug in the old plan9 code, where atoi was used
instead of strtol.

Here's the old notes from that bug:

We were setting the netfile's type to 0, which means we would never
detect/match any incoming packets.  This includes broadcast packets
that we sent ourselves (such as an arp, telling us that we are
10.0.2.15).

The root issue is atoi vs strtol.  atoi is supposed to be for base
10, though NxM uses atoi for netifwrite.  Perhaps their strtol
allows a base prefix to override the base parameter.

5 years agoMoves genbuf into kthreads
Barret Rhoden [Tue, 15 Oct 2013 22:34:01 +0000 (15:34 -0700)]
Moves genbuf into kthreads

So we can have independent syscalls from the same process in the
kernel...

We should consider finding a better way to do the genbuf.  Though I
guess it's not as bad as the waserror()/poperror() stuff on performance.

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.