akaros.git
5 years agoIfconfig uses the MAC for machine identification
Ronald G. Minnich [Tue, 7 Oct 2014 21:26:06 +0000 (21:26 +0000)]
Ifconfig uses the MAC for machine identification

Keys on MAC address.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
Git-fu-d-by: brho
5 years agoAdds script to build bootable USB drives
Barret Rhoden [Tue, 7 Oct 2014 21:00:08 +0000 (14:00 -0700)]
Adds script to build bootable USB drives

Requires extlinux.  See the script for more info.

5 years agoFixes kernel state tracking for 32 bit x86
Barret Rhoden [Tue, 7 Oct 2014 20:57:00 +0000 (13:57 -0700)]
Fixes kernel state tracking for 32 bit x86

In case we ever use that again.

5 years agoIncreases the maximum number of FDs
Barret Rhoden [Tue, 7 Oct 2014 02:29:33 +0000 (19:29 -0700)]
Increases the maximum number of FDs

I didn't bother syncing this with glibc.  We can, if its an issue.  I'd rather
just not use the struct fd_set in userspace.  It's a huge pain in the ass on
Linux.

5 years agoFixes deadlock on growing the FD set
Barret Rhoden [Tue, 7 Oct 2014 02:01:27 +0000 (19:01 -0700)]
Fixes deadlock on growing the FD set

If we tried to grow beyond the max number of FDs, we'd set n == max and
kmalloc, memset, and memmove without making progress.  The loops would retry.

5 years agoAvoids deadlock in pip
Barret Rhoden [Tue, 7 Oct 2014 01:50:28 +0000 (18:50 -0700)]
Avoids deadlock in pip

If another core has the files lock and is stuck, we'll deadlock the kernel
spinning on the lock.

5 years agoFixes FD set freeing
Barret Rhoden [Mon, 6 Oct 2014 21:21:58 +0000 (14:21 -0700)]
Fixes FD set freeing

If a process is DYING and the number of FDs was greater than the default, we
would free the blobs, but keep pointers to the blobs.  Later, a pip would try
to read those and would be looking at re-alloced, garbage memory.

5 years agoks: monitor command for mucking with the ksched
Barret Rhoden [Mon, 6 Oct 2014 21:20:26 +0000 (14:20 -0700)]
ks: monitor command for mucking with the ksched

The only new functionality is the "sort" command, which will sort the idle core
list from 1..n.  "nc" is a hook to avoid calling kfunc next_core, which is a
minor pain.

5 years agoHelpful program, added by popular request
Barret Rhoden [Thu, 2 Oct 2014 01:49:38 +0000 (18:49 -0700)]
Helpful program, added by popular request

If you want to make your own, use jp2a, cut and paste into vi, and add
the printf(" and \n"); from block mode.

5 years agoPorts lock_test to Linux
Barret Rhoden [Thu, 2 Oct 2014 01:43:47 +0000 (18:43 -0700)]
Ports lock_test to Linux

Build from your AKAROS_ROOT directory with:

$ gcc -O2 -std=gnu99 -fno-stack-protector -g tests/lock_test.c \
  -lpthread -lm -o linux_lock_test

Linux only has the spin and mcs/mcscas available, so the others are
stubs.  It will attempt to pin the worker threads to physical cores
0..n.  If you do your own tasksetting after the program is running, you
can override that.  That might be useful if you want to fake preemption.

The ugliest thing is #including the lock source code in a .h file.
Doing it with measure.c is only slightly less nastry.  Maybe we can get
some linux make targets or something, and put this compat stuff in one
place.

5 years agoUser spinlock speedups
Barret Rhoden [Thu, 2 Oct 2014 01:41:08 +0000 (18:41 -0700)]
User spinlock speedups

Test, then test-and-set avoids everyone writing EBUSY to the cacheline
when it is already locked.  This cuts down on cache line contention.

5 years agoVarious userspace Linux compat hacks
Barret Rhoden [Thu, 2 Oct 2014 00:47:27 +0000 (17:47 -0700)]
Various userspace Linux compat hacks

I'd like to build some of the tests for Linux without a lot of fuss.  We
can do it for pthread_test already.  Lock_test is next.

There are a variety of hacks for compatability all over the place: the
TSC stuff, a OS-independent parts of benchutil (measure.c), and more
coming soon.  If we're going to make microbenchmarks that mostly work on
both, then we should consolidate these hacks a bit.

5 years agolock_test: output results to a file
Barret Rhoden [Wed, 1 Oct 2014 20:45:59 +0000 (13:45 -0700)]
lock_test: output results to a file

Also tracks the number of loops performed.  Once one thread finishes,
the test is done.  On a VM with a small number of loops, some threads
won't perform any loops - in which case you're not really contending for
the lock.

5 years agoigbe: removes the receive buffer pool
Barret Rhoden [Tue, 30 Sep 2014 19:49:24 +0000 (12:49 -0700)]
igbe: removes the receive buffer pool

5 years ago82536: removes receive buffer pools
Barret Rhoden [Tue, 30 Sep 2014 19:24:40 +0000 (12:24 -0700)]
82536: removes receive buffer pools

There weren't enough receive buffers.  If we get a large burst of traffic, all
of the NICs RBs could be pushed into the network stack (TCP conv rqs).  Then
we're unable to receive new packets.  If the app (kweb) doesn't read, we never
receive packets.  Kweb would have all of its threads blocked on a write, and
that write was unable to receive an ACK.

Instead of just increasing the number, or even growing the pool, I just opted
to remove the pools completely.  If we need/want NIC pools in the future, we
can add them back (preferably with a helper subsystem, so not all NICs reinvent
the wheel).

5 years agoSyscall debugging touchups
Barret Rhoden [Tue, 30 Sep 2014 18:51:36 +0000 (11:51 -0700)]
Syscall debugging touchups

Syscall string saving was saving old strings, and the output of arguments was
imited to 32 bits.

5 years agomon_kpfret(): return from a kernel page fault
Barret Rhoden [Tue, 30 Sep 2014 18:41:16 +0000 (11:41 -0700)]
mon_kpfret(): return from a kernel page fault

In the off chance the kernel faults and you want to try to recover, pass kpfret
the HW tf pointer.  It'll try to smp_idle, abandoning the kernel context.  This
means that any locks that were held are still locked, so you might deadlock.

This can't handle a nested fault (like if you fault while trying to run
kpfret).

5 years ago82536: catch null blocks from qbread
Barret Rhoden [Mon, 29 Sep 2014 04:35:18 +0000 (21:35 -0700)]
82536: catch null blocks from qbread

This shouldn't happen, since we don't tear down interfaces or anything
like that.

5 years agoFixes #K open
Barret Rhoden [Mon, 29 Sep 2014 04:27:42 +0000 (21:27 -0700)]
Fixes #K open

You need to process omode with openmode() before doing an equality check
with OREAD/O_RDONLY (which == 0, btw...).

This was breaking the ability to bind #K or bind -b.  bind -a worked.
Similarly, ls \#K failed, but cat \#K worked.  The ls-cat check is the
usual way to detect this stuff (it's come up before).

5 years agoCleaned up some printking
Barret Rhoden [Mon, 29 Sep 2014 04:06:46 +0000 (21:06 -0700)]
Cleaned up some printking

The ifconfig is a bit tricky.  Somewhere we set errno in the kernel,
probably during the various bind internal calls.  It's probably fine,
but my BB echo hacks thinks it is an error.

The kprof extra printk isn't needed since echo now prints errors.

5 years agoBusybox echo prints error messages
Barret Rhoden [Mon, 29 Sep 2014 03:52:04 +0000 (20:52 -0700)]
Busybox echo prints error messages

It was ignoring any errors, depending on which version of echo_main was
being built.  It's a minor pain to detect errors too, due to how glibc
implements fputs, I think.  Clearing and checking errno suffices.

Now, when you echo garbage > /some/9ns/ctlfile, you'll hear about what
went wrong.

If we start building with writev, or whatever, then we may need another
patch.

You'll need to patch busybox, etc.

5 years agompstat - accounts for time in CPU states
Barret Rhoden [Mon, 29 Sep 2014 01:32:53 +0000 (18:32 -0700)]
mpstat - accounts for time in CPU states

For the pretty version, cat \#K/mpstat.

If you want to read the data with a program, you probably want
mpstat-raw.  All the lines are fixed size, so you should be able to seek
to a particular offset for a particular CPU.

You can reset the values by echoing reset into either mpstat or
mpstat-raw.

Since the CG cores might be sitting idle, they won't update their state
unless they get an IPI.  By default, when you execute mpstat, it'll send
this IPI.  You can turn that off in the ctl message, which is probably
only useful if there is a program that is polling mpstat-raw.

I haven't implemented the for disabling the rdtsc yet.  I'll do that if
it turns out that there is a noticeable overhead, or maybe if it helps
with debugging.

5 years agoRISC-V broadcast IPI
Barret Rhoden [Mon, 29 Sep 2014 01:30:53 +0000 (18:30 -0700)]
RISC-V broadcast IPI

Needs a look, etc.  The RISC-V port needs a bit of work.

5 years agoCPU state tracking
Barret Rhoden [Mon, 29 Sep 2014 00:31:34 +0000 (17:31 -0700)]
CPU state tracking

Whenever the CPU transitions between states, we account for the amount
of time spent in the previous state in pcpui.  This will be useful for
accounting.  The downside is that we have a few more rdtsc calls, each
of which costs about 30 TSC ticks/cycles (Core i7-950, I think).

For example, given a process in userspace (state == USER), we take an
interrupt (change to IRQ), then after hard IRQ context, we go into the
kernel (change to KERN), and then eventually pop back to userspace
(change to USER).  Three rdtsc calls.  For a syscall, the transitions
are just USER->KERN, then KERN->USER.

In the future, we can add helpers to disable the rdtsc part, if it turns
into a pain.  I'll look into it more when I speed up syscalls.

5 years agox86: handling unregistered IRQs
Barret Rhoden [Sun, 28 Sep 2014 23:37:00 +0000 (16:37 -0700)]
x86: handling unregistered IRQs

If we receive an IRQ for a vector with no handler, then we don't know
how to send an EOI.  Before this commit, if you sent an I_TESTING, we
would just do nothing.  Since we don't send an EOI, we'd never receive
another interrupt.

In general, we probably shouldn't be receiving interrupts that we don't
have handlers registered for, but who knows.  For testing, at least, I
can imagine receiving more IRQs.

Note the bit about POKE too - those are racy and since poke doesn't go
through the main IRQ handling, it won't deal with the halt race
(abort_halt()).

5 years agocs.c: install format specifier for %F
Ronald G. Minnich [Thu, 25 Sep 2014 03:06:29 +0000 (03:06 +0000)]
cs.c: install format specifier for %F

This makes the debug output usable:
CS:Twalk tag 1d fid 21 newfid 24 nwname 1 0:cs CS:Rwalk tag 1d nwqid 1d 0:(0000000000000001x 2d )  22CS:Job done
CS:Topen tag 1d fid 24d mode 2CS:Ropen tag 1d qid (0000000000000001x 2d ) iounit 0d  24CS:Job done
CS:Twrite tag 1d fid 24 offset 0 count 17d 'tcp!localhost!ssh'CS:write tcp!localhost!sshCS:Rwrite tag 1d count 17d 11CS:Job done
CS:Tread tag 1d fid 24 offset 0 count 127dCS:Rread tag 1d count 27d '/net/tcp/clone 127.0.0.1!22' 38CS:Job done
CS:Tread tag 1d fid 24 offset 27 count 127dCS:Rread tag 1d count 0d <no data> 11CS:Job done
CS:Tclunk tag 1d fid 24dCS:Rclunk tag 1d 7CS:Job done

This shows where we could make things better: an addition to the protocol, namely, Treadfile, would reduce this overhead
from 6 packets to 1.

And if we could make that a top-level system call, well ...

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoFixes kprof kproftab usage
Barret Rhoden [Tue, 23 Sep 2014 23:28:50 +0000 (16:28 -0700)]
Fixes kprof kproftab usage

Cleaning up the vomit.

5 years agoMake tracing easier by allowing us to start via /proc/pid/ctl
Ronald G. Minnich [Tue, 23 Sep 2014 23:25:27 +0000 (23:25 +0000)]
Make tracing easier by allowing us to start via /proc/pid/ctl

echo trace > /proc/pid/ctl

starts tracing.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoRemove NIX bits from the Proc ctl command.
Ronald G. Minnich [Tue, 23 Sep 2014 22:55:52 +0000 (22:55 +0000)]
Remove NIX bits from the Proc ctl command.

There's no chance we'll need this.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoFixes errno value for opens without O_CREATE
Barret Rhoden [Tue, 23 Sep 2014 21:46:35 +0000 (14:46 -0700)]
Fixes errno value for opens without O_CREATE

Return the error value of the path lookup, which could be due to a missing
directory, too many loops, etc.

5 years agoRemove return that ended up with a memory leak in cs.c
Ronald G. Minnich [Tue, 23 Sep 2014 20:19:41 +0000 (20:19 +0000)]
Remove return that ended up with a memory leak in cs.c

I was hoping we'd have replaced it by now ...

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoBe a bit more informative when we panic trying to pull up.
Ronald G. Minnich [Tue, 23 Sep 2014 19:53:16 +0000 (19:53 +0000)]
Be a bit more informative when we panic trying to pull up.

The former message was utterly useless.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoFixes netlog
Barret Rhoden [Tue, 23 Sep 2014 17:53:35 +0000 (10:53 -0700)]
Fixes netlog

snprintf -> vsnprintf.

Also cleaned up some usages of netlog().

To use netlog:

$ echo set tcp > /net/log

'tcp', or any of the Log strings in Netlogflag flags[].

$ cat /net/log &

There needs to be some process with /net/log open for the logger to produce the
log entries.  Alternatively, you can dump the log to a file.

5 years agoClear all networking block flags in NIC frees
Barret Rhoden [Fri, 19 Sep 2014 00:11:49 +0000 (17:11 -0700)]
Clear all networking block flags in NIC frees

These two NICs use their own free method.  They clear the old checksum
flags, but not the TSO flag.  While the NICs don't use those flags yet,
there could be a potential taint issue where that flag gets carried
around the stack by accident.  Better to clear the flags aggressively.

5 years agoFixes ICMP block reuse (checksumming)
Barret Rhoden [Thu, 18 Sep 2014 23:52:45 +0000 (16:52 -0700)]
Fixes ICMP block reuse (checksumming)

c89 was unable to respond to pings.

It would attempt to respond, but the packet would get corrupted on the
way out, such that the "45" at the start of the IP header would be 00.

The root cause was that ICMP reuses the inbound block for the echo
reply, and the block flags were being reinterpreted.  It was not
clearing the block checksum flags.  c89's NIC was setting the IP and PKT
checksum flags on inbound packets, since the NIC already did those
checksums.  Theses flags were reinterpreted on the reply path to say
those checksums needed to be done again (in the checksum finalize).
But the checksum_start flag was set to 0xe, for whatever reason, which
clobbered the IP header.

Part of the issue is that the checksum flags are used both coming in and
going back out.  The only outbound flag used is Btcpck, but the
existence of the inbound flag was enough to trigger the outbound
finalize logic.

5 years agoFixes arp sends
Barret Rhoden [Thu, 18 Sep 2014 22:20:47 +0000 (15:20 -0700)]
Fixes arp sends

The first time we'd send an arp, the arp would wait til it was a second
old (and maybe with other sendarps pushing it), instead of sending
immediately.  "ctime" ~= last sent time, though it's not always like
that (o/w I'd change the name).  Maybe it is "change time".

5 years agoFixes gross stack consumers
Barret Rhoden [Thu, 18 Sep 2014 01:41:25 +0000 (18:41 -0700)]
Fixes gross stack consumers

Whenever we call etherbind(), we run off the bottom of a 4KB stack.  Sometimes
the canary catches it, if a clobber happened to trigger it.  Other times, it
seems fine.  And yet others, the machine locks up.  The major stack consumers
were the dials/calls and their huge strings.

If this breaks your ifconfig, let me know.

You should be able to run without LARGE_KSTACKS now.

5 years ago82536: fixes ktask names
Barret Rhoden [Thu, 18 Sep 2014 01:05:01 +0000 (18:05 -0700)]
82536: fixes ktask names

All of the ktasks (l, r, and t) were using the same char *name, so they all
were named whatever the last ktask was.  In this case, the tproc.

This somewhat perpetuates the "ktask does not make a copy" crap.  Though I just
don't want to put another string blob in the kthread struct right now.

5 years agoPrintx commands (off by default)
Barret Rhoden [Thu, 18 Sep 2014 00:39:01 +0000 (17:39 -0700)]
Printx commands (off by default)

A common tool I use is to printk, or now even trace_printk, to debug something.
But you don't always want the printing on, due to massive amounts of printing
under certain circumstances.

Invariably, I'd make a throw-away function that I would kfunc to toggle the
printing on and off.  I already do something similar with the poor-mans
ftrace/spatch.

"printx" is the term for this debugging style printing, and it can be turned on
and off.  There is a monitor command (px) that toggles it.  And just for fun
(and profit) there's a Kprof file to control it too (kprintx).

$ echo on > /prof/kprintx (once #K is attached).

The 'x' comes from "xme", which is the name of the one-off kfunc function I
usually use for debugging.

The default value is off.  The poor-mans ftrace uses printx_on as well, so if
you want the tracing on, you'll need to turn it on manually.  This is a change,
but a good one.

5 years ago82563: faster booting
Barret Rhoden [Thu, 18 Sep 2014 00:25:07 +0000 (17:25 -0700)]
82563: faster booting

I don't know if we need to wait 10 seconds for the reset.  It adds about 40 sec
to c89's boot time.

5 years agoCrank up the READSTR buffer a bit
Barret Rhoden [Thu, 18 Sep 2014 00:23:09 +0000 (17:23 -0700)]
Crank up the READSTR buffer a bit

READSTR is the size of a buffer used by some devices when asked to snprintf a
bunch of its details.  ether->ifstats was a big user.

The old size wasn't enough for some drivers (82563), so results from catting
the ifstats would be truncated.

5 years ago82563: fixes TX overrun/replenish bug
Barret Rhoden [Wed, 17 Sep 2014 23:11:16 +0000 (16:11 -0700)]
82563: fixes TX overrun/replenish bug

When replenish was called without being allowed to sleep, it could bail out of
its loop early and fail to update the RDT (both ctlr and HW).  If it bails out
after having replenished some buffers, the RDT no longer matches where block
pointers should/should not be.

For reference, RDT points to an empty buffer (bp = 0).  RDH points to the first
full one.  Replenish will fill up to one slot prior to RDH, so that the queue
is full when there is one empty spot at RDH - 1.

5 years agoVFS: only lookup once
Barret Rhoden [Wed, 17 Sep 2014 23:06:19 +0000 (16:06 -0700)]
VFS: only lookup once

Path lookups were looking up twice on failure, optimisticly assuming we'd want
to O_CREAT(E) too.

This isn't a huge deal.  It was more of a problem when our path lookups were
buggy and took 20usec.  Then the extra lookup was expensive.

5 years agoVFS: use a proper hash function
Barret Rhoden [Wed, 17 Sep 2014 22:58:39 +0000 (15:58 -0700)]
VFS: use a proper hash function

Every dentry was getting 0xcafebabe for its hash value.  That put them all in
the same bucket in the dentry cache.  That made dcache lookups cost
O(nr_files_in_vfs), which was making opens (or any path lookup) take a long
time once we put the Go tree in KFS.  This even affected 9ns lookups, since
those check the VFS before trying 9ns.

5 years agoVFS: superblock init can handle d_ops
Barret Rhoden [Wed, 17 Sep 2014 22:55:52 +0000 (15:55 -0700)]
VFS: superblock init can handle d_ops

Passing 0 for the parent won't work if we actually want to use dentry ops for
the qstr building (d_hash).

5 years agoprint_func helpers cleanup
Barret Rhoden [Wed, 17 Sep 2014 19:55:52 +0000 (12:55 -0700)]
print_func helpers cleanup

The trace_printk doesn't work well with the existing helpers for the poor-mans
ftrace, but this change makes it a little easier to use.

If you want to use trace_printk, change the main print line to trace_, remove
the trailing \n, and comment out __print_hdr.

5 years agotrace_printk()
Barret Rhoden [Wed, 17 Sep 2014 17:53:52 +0000 (10:53 -0700)]
trace_printk()

trace_printk() will drop lines of formatted text into the trace buffer,
up to a limited size.

A couple things to note.
- The trace buffer prints syscalls as the complete, not when they start.
  If you have some trace prints from a syscalls execution, they will
  show up before the syscall entry
- If you have a trace print, it will always kmalloc and build the trace.
  We don't have controls (yet) for globally disabling any prints.  I
  didn't bother coupling it to the "trace" monitor commands, opting to
  wait to control it via #K.  Might not even be necessary, since these
  are for debugging.
- If kprof is not attached, the traces aren't saved (or accessible).
- I'd like it if we could use all traces as extra_data blobs, so we just
  pass the pointer to a block in the queue, instead of copying
  everything.  Not a big deal though.

5 years agosnprintf() return value changes
Barret Rhoden [Wed, 17 Sep 2014 07:28:32 +0000 (00:28 -0700)]
snprintf() return value changes

It's helpful for snprintf() to return 0, instead of an error code, when
it does no work.  A common pattern is something like:

len = 0;
len += snprintf(buf + len, bufsz - len, "whatever");
len += snprintf(buf + len, bufsz - len, "overflowed buf");
len += snprintf(buf + len, bufsz - len, "used to error");
len += snprintf(buf + len, bufsz - len, "and more text");

Once bufsz - len == 0, such as after the "overflow" print, future
snprintfs now return 0, and are basically nops.  Previously, the
snprintfs that error out would return a negative value, actually setting
length back slightly, allowing "and more text" to clobber a bit.

Additionally, the usual snprintf returns how many characters we
processed, regardless of whether or not we wrote them.  This is
unsuitable for marking progress through a buffer.  Now, we return how
many characters we wrote.

The current semantics: snprintf forces a null termination of the string,
but does not count that in the return value (similar to strlen()).  The
return value is the number of characters written.  If a buf has n bytes,
n-1 is the max return value, with the nth byte being set to 0.

This is a little different than normal snprintf, but is more useful for
our series-of-snprintfs pattern.  If we change it back, we'll need to be
careful of the signs of bufsz and len to make sure we don't pass in
large unsigned values and accidentally trigger a huge printf.

5 years agoRemove ifconfig from root script
Kevin Klues [Wed, 17 Sep 2014 18:05:56 +0000 (11:05 -0700)]
Remove ifconfig from root script

This was moslty in there for me, and I don't want it there anymore.

5 years agoCleans up devip state functions
Barret Rhoden [Wed, 7 May 2014 23:25:05 +0000 (16:25 -0700)]
Cleans up devip state functions

The protocols (tcp, udp, ipifc, etc) have state functions that print out
state info about a conversation.  There are a few things wrong.
- The main thing is that the size of the print buffers can change from
  one syscall to another.  When cat reads it, it reads twice so that it
  can detect EOF.  If the filesize changed, it could get more info the
  next time.
- TCP was printing %lu instead of %u for u32s.  This was popping up as
  as very large numbers due to seeing gibberish on the stack thinking it
  was a 64 bit int.  This also changed the size of the state buffer
  frequently.
- The devices were not uniformly doing the \n or not.

5 years agogrow_fd() sets errno/errstr
Barret Rhoden [Thu, 11 Sep 2014 19:41:44 +0000 (12:41 -0700)]
grow_fd() sets errno/errstr

Note the use of error(current_errstr()).  grow_fd() already set errstr,
but we still wanted to do the error longjmp.  Using current_errstr()
should maintain the previous errstr.  It's a format print, again, from
current_errstr into current_errstr again.

Since this commit messed with one of the Ebadf's, I knocked out the
other too.  The long term goal is to not use any of the hardcoded
errstrs (preferring errno for that).  This's one more hardcoded errstr
string removed, with 67 to go!

5 years agogrowfd() grows enough for the desired fd
Barret Rhoden [Wed, 10 Sep 2014 21:54:15 +0000 (14:54 -0700)]
growfd() grows enough for the desired fd

Removing the hacky while loop, too.

This was bugging out if we asked for an FD > nfd + delta.  The
allocation wasn't big enough, and we'd fail.  9ns opens would fail if
there were too many VFS opens between 9ns opens (the VFS and 9ns share
an FD pool).

5 years agoTraces syscalls with nsec precision
Barret Rhoden [Wed, 10 Sep 2014 03:58:43 +0000 (20:58 -0700)]
Traces syscalls with nsec precision

And also formats the trace for a terminal, with the 'data' contents
appearing on the next line.

Here's a trace of reading the letter 'h' from the console (with one
extra wrap due to the width of this commit message):

----------------------
[     37.776775555]-[     37.776776330] Syscall  13 (  proc_yield):(0x0,
0x0, 0x0, 0x0, 0x0, 0x0) ret: 0x0 proc: 2 core: 0 vcore: 0 data:
[     37.776770403]-[     37.981424392] Syscall 100 (        read):(0x0,
0xffbfdf51, 0x1, 0x0, 0x0, 0x0) ret: 0x1 proc: 2 core: 0 vcore: 0 data:
                                                                   h
----------------------

Note the 'h' on its own after the read command, lined up after the :
after the syscall name.

If there is an empty line in the trace, that is because there was a
trace data length, but printdump didn't print anything.  I noticed this
when the input was a carriage return.

More importantly, notice the timestamps.  The read started first, but
the yield finished first.  First to finish is the first into the trace
queue.

5 years agoFixes SCP wakeup latency
Barret Rhoden [Wed, 10 Sep 2014 03:38:17 +0000 (20:38 -0700)]
Fixes SCP wakeup latency

When an SCP syscall completes on a CG core, which ultimately wakes up
the process, the SCP was not running until the next ksched timer tick.

This scenario could happen if an SCP blocks on a read on a pipe that
gets written to by an MCP.  The pipe write wakes the reader, and since
the kthread code is primitive, it just finishes the bottom half of the
syscall on the MCPs core (a CG core).  Core 0 could have been halted the
entire time, and had no reason to wake up.  It may have called
cpu_bored() a long time ago and has not woken up yet.

Btw, note that syscalls in the trace are written in the order of
*completion*, not submission.  This is more clear from the TSC
timestamp, but the pretty output only has msec granularity.

5 years agoDisables the HPET
Barret Rhoden [Tue, 9 Sep 2014 21:26:09 +0000 (14:26 -0700)]
Disables the HPET

If the system has an HPET, ACPI will tell us.  In lieu of properly setting it
up, I just make sure it is disabled.

Long range plan is for a #T timer device or something, which would use the HPET
if available.

The HPET is pretty straightforward btw, just not a priority.

5 years agoCleans up vmap()
Barret Rhoden [Tue, 9 Sep 2014 20:55:52 +0000 (13:55 -0700)]
Cleans up vmap()

Uses KADDR directly, without the physaddr sanity check.  If you run with
less than 1 GB RAM, the check will fail.  I'll probably remove that
check eventually.

5 years agoMoves 9ns endian helpers
Barret Rhoden [Tue, 9 Sep 2014 20:23:27 +0000 (13:23 -0700)]
Moves 9ns endian helpers

Keep them in a single spot.

5 years agox86: initializes the LPC
Barret Rhoden [Tue, 2 Sep 2014 18:48:58 +0000 (11:48 -0700)]
x86: initializes the LPC

If your machine has an LPC, part of the PCH or maybe the southbridge, then this
will do very basic initialization.  It'll just disable one of the timers that
triggers SMIs on one of my machines.

5 years agox86: disables USB legacy stack
Barret Rhoden [Tue, 2 Sep 2014 18:47:59 +0000 (11:47 -0700)]
x86: disables USB legacy stack

Only for EHCI and UHCI.  You'll get a warning on OHCI.

5 years agoChanges default init script to just run bash
Barret Rhoden [Tue, 2 Sep 2014 17:43:54 +0000 (10:43 -0700)]
Changes default init script to just run bash

You need to make menuconfig to use this option.

5 years agoAdd the trex ethermedium.
Ronald G. Minnich [Wed, 10 Sep 2014 02:44:55 +0000 (02:44 +0000)]
Add the trex ethermedium.

The intent is that for bleeding edge devices, we want our own medium
to hack on as we please. Anticipating some weird usage, I've added
the trexconfig script, which you can hack as you wish.

If you want to change basic functions in the medium, copy them and convert
them. I'm still not sure we don't want trexmedium.c but for now we decided not
to create a new file.

Test:
comment out the ethermedium struct (i.e. leave only the trexmedium available)
boot, run trexconfig, note network works.

uncomment out ethermedium, boot, run /trexconfig, it all works.
reboot, run ifconfig, it all still works.

I decided to skip the branch because this change is pretty harmless.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoSyscall tracing formatting touchups
Barret Rhoden [Wed, 3 Sep 2014 05:06:36 +0000 (22:06 -0700)]
Syscall tracing formatting touchups

The main thing is that we print the real time (since boot) in seconds,
instead of TSC ticks.

As a reminder to anyone using c89, the TSC only resets on a cold boot.
Perhaps that has something to do with its service processor locking up
every so often!  (we'll see if it is every 49 days)

5 years agoSyscall tracing handles dropped traces
Barret Rhoden [Wed, 3 Sep 2014 00:20:48 +0000 (17:20 -0700)]
Syscall tracing handles dropped traces

If a trace is getting dropped, we'll output the trace instead.

This should rarely happen (OOM), unless we change the queue code.

5 years agoWe can now trace various system calls
Ronald G. Minnich [Fri, 29 Aug 2014 19:51:15 +0000 (19:51 +0000)]
We can now trace various system calls

And see return values, and see file open names and read/write data

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
Git-fu'd by brho

5 years agoMove to a queue-based system call tracing
Ronald G. Minnich [Tue, 2 Sep 2014 18:09:29 +0000 (18:09 +0000)]
Move to a queue-based system call tracing

Now, we allocate a trace record in the system call and, when we exit, write it
to a queue for the kptrace qid.

Read reads from the queue.

Records are text, delimited by a newline.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
Git-fu'd by brho

5 years agoprintdump(), used for tracing
Ronald G. Minnich [Fri, 29 Aug 2014 06:36:05 +0000 (06:36 +0000)]
printdump(), used for tracing

Git-fu'd by brho.

5 years agochdir and fchdir need to return a 'long'
Kevin Klues [Wed, 27 Aug 2014 03:19:28 +0000 (20:19 -0700)]
chdir and fchdir need to return a 'long'

I made them return an intreg_t because other syscalls use this type
(which is a little weird), but no matter what we use, we need to make
sure the value returned is sign extended properly to the size of a long.

This is necessary because Go has a generic syscall wrapper that examines
the return value and checks to see if it is "-1" before allocating a new
AkaError struct and returning errno and errrstr up the stack. On amd64,
when a syscall just returns an 'int', the upper bits are 0'd out and we
interpret the value as 2^32, not -1 (which indicates a success). We also
cannot simply donwcast the return value to 32 bits before doing the
comparison because some system calls (e.g. mmap) can have valid values
that have all lower 32 bits set to 1.

This isn't a problem for glibc because it doesn't have a generic wrapper
around all syscall. It can down cast the return value to the proper type
in the libc wrapper before doing the check of whether or not to return
an error.

5 years agoFixes chdir retval
Barret Rhoden [Wed, 27 Aug 2014 01:22:21 +0000 (18:22 -0700)]
Fixes chdir retval

Was returning -errno on errors, instead of -1.  Also, this cleans up the
discrepancy betweren how do_chdir() and do_fchdir() handle errno and return
values.

5 years agoRemoves old documentation
Barret Rhoden [Tue, 26 Aug 2014 23:42:24 +0000 (16:42 -0700)]
Removes old documentation

More up-to-date stuff at:
https://github.com/klueska/go-akaros/blob/master/misc/akaros/README

5 years agoFaulting pthread signal handlers abort
Barret Rhoden [Tue, 26 Aug 2014 23:32:01 +0000 (16:32 -0700)]
Faulting pthread signal handlers abort

If the handler faults and tries to signal itself, we print the debug info and
abort the process.

Note the sighandler or the process in general can mask or override certain
handlers (like the PF handler) to not do anything.  In which case, the thread
will restart and refault, forever.  That's the process's fault.

5 years agosys_chdir() / fchdir() take a pid (XCC)
Barret Rhoden [Tue, 26 Aug 2014 22:02:33 +0000 (15:02 -0700)]
sys_chdir() / fchdir() take a pid (XCC)

This is so parents (or any process that controls another) can change the
working directory (PWD, DOT, etc) of another process, including itself.

This does slow down chdir a little, due to the sync on pid lookup and decref,
but scalable chdir() isn't a big deal at this point.

Copy over chdir.c and fchdir.c and rebuild glibc.  Or just make clean it.

5 years agoFixes sys_dup_fds_to
Barret Rhoden [Tue, 26 Aug 2014 21:58:01 +0000 (14:58 -0700)]
Fixes sys_dup_fds_to

Had a gaping hole where we didn't make sure that p controls the target (even
though proc_controls() is mostly a noop now).

Also fixes up the error reporting (set_errno and -1, instead of returning
-error).

5 years agoHelper for syscalls getting pid2proc
Barret Rhoden [Tue, 26 Aug 2014 21:56:29 +0000 (14:56 -0700)]
Helper for syscalls getting pid2proc

Given a pid, I often want to get a proc only if p controls it.  Some uses for
pid2proc, like in wait and poke, want to do their own thing.

5 years agoRevert "Add support for the childfdmap for Go"
Kevin Klues [Tue, 26 Aug 2014 20:01:39 +0000 (13:01 -0700)]
Revert "Add support for the childfdmap for Go"

This reverts commit 1f6c9b6de45e868d0dffd3415825273dac459695.

5 years agoAdd support for the childfdmap for Go
Ronald G. Minnich [Mon, 25 Aug 2014 17:51:20 +0000 (17:51 +0000)]
Add support for the childfdmap for Go

Sorry for this mess, but I'm hoping someone can fix the include mess.
We need a gerrit or something where we can post draft patches.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoVFS O_APPEND
Barret Rhoden [Sun, 24 Aug 2014 17:39:57 +0000 (10:39 -0700)]
VFS O_APPEND

Might actually be race-free!

5 years ago__pthread_handle_pending_posix_signals() changes
Kevin Klues [Sat, 23 Aug 2014 21:00:16 +0000 (14:00 -0700)]
__pthread_handle_pending_posix_signals() changes

Don't call run_uthread() directly iniside
__pthread_handle_pending_posix_signals().  Actually don't even call this
function 'handle_pending_posix_signals' at all.  Instead call it
'prep_for_pending_posix_signal', and just prep the pthread so it will be
restarted inside its signal handler context next time it is run.
It's semantically identical to what we had before, but it's a better
abstraction since (in the future) we may wish to do something between
this prep and actually restarting the thread.

The previous implementation also forced us to always restore the signal
handler context from pthread->uthread.u_ctx (even if the pthread's
saved context was currently sitting in the vcpd uthread_ctx slot).
This implementation now updates the pthread's current context in place,
allowing it to be restarted the same way whether there were pending
posix signals or not.

5 years agoPosix signals in uthread context not vcore context
Kevin Klues [Fri, 22 Aug 2014 18:12:45 +0000 (11:12 -0700)]
Posix signals in uthread context not vcore context

This patch set makes is so that posix signals are run from uthread
context instead of vcore context when triggered from the pthread
library.

Whenever a pthread has a signal pending and it is about to be restarted,
a temprary signal context and stack is swapped in to run the signal
handlers for those pending signals, and the pthread is restored into
that context.  When the signal handlers have compelted, the original
context and stack are restored, and the pthread is rsumed.

A new 'sigdata' struct has been introduced to encapsulate the data
structures necessary to handle all this swapping back and forth.  These
'sigdata' structs are served as part of the parlib signal library, and
reused across different pthreads whenever they have a signal handler to
run. The rest of the changes live entirely in the pthread library,
though we may be able to move parts of it out to parlib once we
generalize it a bit more.

5 years agoAdd implementation of wait-free unordered list.
Kevin Klues [Fri, 22 Aug 2014 18:02:58 +0000 (11:02 -0700)]
Add implementation of wait-free unordered list.

The list is ever-increasing in size, in that once space is created to
accomodate an item in the list, that space is never freed until the
entire list is destroyed. Items are inserted in the list such that
ordering on removal is not guaranteed.

This structure is useful in situations when you want to maintain a
small pool of objects that are shared amongst a larger set of
objects, but only get used for a short period of time (e.g. futext
element structs, sigdata structs, etc.).

5 years agoVFS truncate
Barret Rhoden [Thu, 21 Aug 2014 17:53:44 +0000 (10:53 -0700)]
VFS truncate

Also flushes the PM on O_TRUNC and touches up some sync on the file
size, since it just needed a spinlock.  Too bad the VFS was built before
we had semaphores, though it probably still would be rather racy.

Note that KFS won't write pages back, so any modifications to a file
won't exist outside of the page cache.  This isn't particularly related
to truncates extending a file, since the same thing happens with
write().

5 years agoVFS rename
Barret Rhoden [Wed, 20 Aug 2014 18:22:31 +0000 (11:22 -0700)]
VFS rename

Works, but it's ridiculously racy, as is most all of the VFS.  If you
have renames concurrent with other renames or much of anything, you
could bust the dentry tree or who knows what else.

The VFS (and anything that does a similar task, like a 9ns device) needs
a serious overhaul for both concurrency protection and scalability.

I also don't bother checking if new_path contains old_path.  A check
would help, but we're still in "serious redesign" territory.  Check out
my comments for more info.

That being said, you can mv files and directories around with busybox.

I didn't use testrename much, mv worked quite well.  But I'll leave it
around for now for debugging with 9ns (which needs work).  Also, glibc's
rename work, and there is no need for a separate rename() for the test
program.  Calling the syscall directly means you had an old glibc
(either not compiled right, or not loaded in KFS).

5 years agox86: avoids bad frame pointers in backtrace
Barret Rhoden [Wed, 20 Aug 2014 02:06:56 +0000 (19:06 -0700)]
x86: avoids bad frame pointers in backtrace

Backtrace will stop backtracing if it hits a non-canonical, non-kernel address.
It'll still record the PC, so we can see some evidence of the corruption.

Thanks to Drew for pointing this out and providing a fix.

5 years agoFixes some 32 bit usages of NOW
Barret Rhoden [Tue, 19 Aug 2014 22:53:34 +0000 (15:53 -0700)]
Fixes some 32 bit usages of NOW

I looked for any place storing NOW in a 32 bit int, but I might have missed a
few or otherwise broke things.

5 years agoSYS_dup_fds_to (XCC)
Barret Rhoden [Tue, 19 Aug 2014 22:14:16 +0000 (15:14 -0700)]
SYS_dup_fds_to (XCC)

Finishes Ron's sys_mapchildfds.

Reinstall your kernel headers.

5 years agoFixes insert_file()
Barret Rhoden [Tue, 19 Aug 2014 22:13:11 +0000 (15:13 -0700)]
Fixes insert_file()

__claim_fd() returns a status, not a value.

5 years agoFixes buggy assert in __claim_fd()
Barret Rhoden [Tue, 19 Aug 2014 17:42:15 +0000 (10:42 -0700)]
Fixes buggy assert in __claim_fd()

Was checking FD 0, instead of the FD we claimed.

5 years agoAllow a parent to set up a child's fd's via a new system call
Ronald G. Minnich [Tue, 19 Aug 2014 17:15:29 +0000 (17:15 +0000)]
Allow a parent to set up a child's fd's via a new system call

Needed for Go. The parent sets up an array of
childfdmap
structs, with parent and childfds, then calls system call 65536,
which we might want to consider naming ;-)

Not working.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoKFS allows seeks beyond the file size
Barret Rhoden [Thu, 14 Aug 2014 16:46:25 +0000 (09:46 -0700)]
KFS allows seeks beyond the file size

It looks like the VFS writes, page cache, and KFS readpage() can all handle the
offset being higher than the file size, and it should create a hole.

5 years agoNo longer require LD_LIBRARY_PATH to be set (XCC)
Kevin Klues [Thu, 14 Aug 2014 03:51:50 +0000 (20:51 -0700)]
No longer require LD_LIBRARY_PATH to be set (XCC)

Previously we had to have LD_LIBRARY_PATH =/lib set in the environment
for all binaries to be able to find their shared libraries.  This was
because we had the wrong set of default paths specified in our ld.so
dynamic loader library.  This patch fixes that.

I had to manually set the variable "default-rpath" in
glibc-2.14.1/Makeconfig to make this work.  By default this value is set
to the lib path in our cross compiler (i.e.
x86_64-ros-gcc/x86_64-ros/lib/).  This default path is sufficient if you
only ever use the resulting ld.so file on the host machine.  The problem
is, we manually copy this file over to run natively on akaros, and at
this point, the default-rpath that got set is bogus.  There's really no
way around it, but to manually set it because of the weird way we are
moving this library around.

Anyway, we no longer have to have an LD_LIBRARY_PATH set for every
executable, ld.so knows to look in /lib by default.

5 years agoTypo in variable name.
Kevin Klues [Thu, 14 Aug 2014 01:16:38 +0000 (18:16 -0700)]
Typo in variable name.

I tested before pushing, so I'm not sure why it compiled and ran for me,
but this was clearly a typo and should have been oflag from the
beginning.

5 years agoAdd more restrictive oflag checks to sys_open
Kevin Klues [Thu, 14 Aug 2014 00:56:22 +0000 (17:56 -0700)]
Add more restrictive oflag checks to sys_open

Also make sure and error out with EISDIR if the named file is a
directory and oflag includes O_WRONLY or O_RDWR. This has only been
added to the vfs.

5 years agofchdir() (XCC)
Barret Rhoden [Wed, 13 Aug 2014 20:26:29 +0000 (13:26 -0700)]
fchdir() (XCC)

Implements sys_fchdir, and touches up the raciness on pwd.  The 9ns side does a
better job, IIRC, of dealing with races on lookups (any of which can start at
pwd (DOT)).  Right now, a VFS lookup from pwd concurrent with a chdir could
fail to grab a ref.

Rebuild glibc.

5 years agoRevert "Add /etc/ld.so.conf so the dynamic loader has a path even if LD_LIBRARY_PATH...
Ronald G. Minnich [Tue, 12 Aug 2014 23:55:03 +0000 (23:55 +0000)]
Revert "Add /etc/ld.so.conf so the dynamic loader has a path even if LD_LIBRARY_PATH is not set"

This reverts commit dca513882cec49ae570605f3eace49fc63dfc357.

Because that did not do it either. We have to fix ld-linux

5 years agoAdd /etc/ld.so.conf so the dynamic loader has a path even if LD_LIBRARY_PATH is not set
Ronald G. Minnich [Tue, 12 Aug 2014 23:50:09 +0000 (23:50 +0000)]
Add /etc/ld.so.conf so the dynamic loader has a path even if LD_LIBRARY_PATH is not set

In Akaros, if LD_LIBRARY_PATH is not set, then no .so's will be found. This breaks
a Go test which resets the environment.

Or if you
unset LD_LIBRARY_PATH
you can never run another dynamically linked command.

So put /lib into /etc/ld.so.conf; this gets us past one part of the
os/exec benchmark.

This is ugly but workable. It's disappointing to bring this kind of ugliness into
Akaros but so it goes.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoRevert "CS multi-threaded and locking."
Ronald G. Minnich [Mon, 11 Aug 2014 22:45:43 +0000 (22:45 +0000)]
Revert "CS multi-threaded and locking."

This reverts commit 9f77d75980ef4ab3a7e5bf516c383c916beed877.

THis borked it big time.

5 years agoMake etherread4() safe for LRO.
Andrew Gallatin [Mon, 11 Aug 2014 14:30:19 +0000 (07:30 -0700)]
Make etherread4() safe for LRO.

This patch allows etherread4() read up to 128K, rather than just an MTU
size.  This is required because qbread() is used to read, and
the semantics of qbread() are to give you one block of at most len bytes.
If a block is > len (which will be the case for LRO, when len == MTU), then
it will split the block.   When the block is split  when feeding packets from
dev/ether to ethermedium, you wind up looking in the middle of the
payload for headers, and it is a total mess.  Ideally, there would
be some sort of qbreadall() that would not take a length argument
that would just return the next block on the queue (eg, a blocking
qget()).

128K was chosen because it is roughly 2x the size of the largest
imaginable MTU and/or LRO packet size (due to both IPv4 and
IPv6 being limited to roughly 64K + headers per packet).

Discussed with: Barret Rhoden, Ronald Minnich

Signed-off-by: Andrew Gallatin <gallatin@google.com>
5 years agoprintfmt: print cur_errbuf as part of %e
Ronald G. Minnich [Sat, 9 Aug 2014 03:27:57 +0000 (03:27 +0000)]
printfmt: print cur_errbuf as part of %e

Of course, now we should start initializing first element to 0 when we
do a system call, I guess, as it's printing garbage sometimes.

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
5 years agoqio.c: don't just warn when we have problems, panic.
Ronald G. Minnich [Sat, 9 Aug 2014 03:25:33 +0000 (03:25 +0000)]
qio.c: don't just warn when we have problems, panic.

You're going to hate me for this one. But I'm seeing real problems
from the extra stuff that I think is breaking some Go tests.

I think we need to fix it, not just warn, so I've made it a panic for
now.

I'm willing to be convinced this is a mistake, but it just seems very bad
otherwise.

In one case, packblock, I just return the bp if there is extra data, which
should at least preserve correctness.

I am hoping this forces us to get this right. It seems really hokey
as is. But maybe I'm just wrong.

5 years agoFixes TCP drops due to ARP timeouts
Barret Rhoden [Wed, 6 Aug 2014 02:00:32 +0000 (19:00 -0700)]
Fixes TCP drops due to ARP timeouts

The root of the problem is that arpents were using u32s to store the
msec since boot.  Machines that run for over 50 days will wrap around.

Since NOW was a u64, the arpent ctimes were getting set to weird
numbers, and ultimately the arpents all appeared to be stale.

Stale arps get their blocklists pruned to one block (which is a
questionable bit of code).  These blocks were TCP packets.

So if a machine was running for more than 50 days, and if multiple TCP
packets were sent to the same arpent quickly, one of them could be
dropped, which throws off the entire TCP stream.

c89 happens to be a machine with a TSC that doesn't reset when
soft-rebooting (via our reboot()), so it acted like a machine that had
been up for about 3 months.

Arguably, we could have NOW (and the others, like seconds() and
milliseconds()) be cast to a u32, so that at least both NOW and ctime
are the same width, but that seems really shoddy.

5 years agoCS multi-threaded and locking.
David Zhu [Tue, 29 Jul 2014 05:12:42 +0000 (22:12 -0700)]
CS multi-threaded and locking.

Note this is a basic version. Locking is not optimal and uses large
locks over large areas. Fine grained locking should improve the
performance of the CS server significantly. Holding off further
optimization if we are going to write it in GO.