diff options
Diffstat (limited to 'libdde-linux26/mk/ptest')
| -rwxr-xr-x | libdde-linux26/mk/ptest | 444 |
1 files changed, 444 insertions, 0 deletions
diff --git a/libdde-linux26/mk/ptest b/libdde-linux26/mk/ptest new file mode 100755 index 00000000..e85d53b6 --- /dev/null +++ b/libdde-linux26/mk/ptest @@ -0,0 +1,444 @@ +#! /usr/bin/perl -W +# +# Run package tests using Fiasco-UX +# +# +# Adam Lackorzynski <adam@os.inf.tu-dresden.de> +# Ronald Aigner <ra3@os.inf.tu-dresden.de> +# +# This script is derived from the autocheck script which can be found in +# kernel/fiasco/tools. It has been slightly modified to suit the demands of +# the package tests. +# + +# make it pass for now +#exit 0; + +use strict; +use Getopt::Long; + +my $FIASCOUX; +my $FIASCOUX_PARAM; +my $L4DIR; +my $OBJ_BASE; +my $OBJDIR = 'OBJ-x86_586-l4v2'; +my $EXPECTED_OUT = 'expected.txt'; +my $TMP_OUT = 'tmp_out.txt'; +my $PKGNAME; +my $COMPARE_CMD = 'diff -u $EXPECTED_OUT $TMP_OUT'; + +my $ALARM_TIMEOUT = 60; # in seconds + +my %templs = ( + roottask => '%s/pkg/roottask/server/src/%s/roottask', + sigma0 => '%s/pkg/sigma0/server/src/%s/sigma0', +); + +my $Verbose = 0; +my $Quiet = 0; +my $Generate = 0; +my $Memory = 32; +my $Plainrun = 0; +my $No_fb = 0; +my $Use_Symbols = 0; +my $Use_Lines = 0; + +my %progs; +my %results; +my %output; +my @Baseservers; +my $Client; +my $Server; +my $Fiasco_Dir; + +# filehandle for fiasco output +my $Input; +my $Output; + +my $Exit_code = 0; +my $pid = 0; + +my $FILTER_LEVEL_FIASCO = 0; +my $FILTER_LEVEL_ROOTTASK = 1; +my $FILTER_LEVEL_USER = 2; +my $Filter_state = $FILTER_LEVEL_FIASCO; +my $Filter_level = $FILTER_LEVEL_USER; + +sub usage() { + print <<EOU; +$0 [options] -c <client> -s <server> + + --l4dir, -l path Path to an L4 directory + --fiascoux, -f file Path to the Fiasco-UX binary + --fiascoux_param, -p params Parameters for Fiasco-UX + --memory, -m megabyte Number of Megabytes used by Fiasco. (default: 32) + --objdir, -O objdir Object dir, currently: $OBJDIR + --verbose, -v Be verbose (e.g. show output of L4 apps) + --quiet, -q Tell nothing, just set the exit code + --generate Generate the output file instead of comparing to it + --server, -s file The server to be tested + --client, -c file The file to run as test-application + --base, -b file Additional base servers required by the application + Can be a comma seperated list. (Only specify the + binary names!) (default: log, names, dm_phys) + --timeout, -t timeout Time in seconds to wait before shooting down a + runaway fiasco. (default: 60) + --expectfail Expect failure. Return 0 on failure, 1 on success. + + Environment variables: + L4DIR Path to an L4 directory + OBJ_BASE Path to build directory + FIASCOUX Path to the Fiasco-UX binary + EXPECTED_OUT Filename of the file containing the expected output + TMP_OUT Filename of the tempfile containing Fiasco's output + COMPARE_CMD Command to compare output and expected output + + Notes: + Environment variables override options! +EOU +} + +## +# Check if L4DIR looks like an L4 directory +sub check_for_l4dir() { + unless (-d "$L4DIR/pkg/l4sys/include" || + -d "$L4DIR/../kernel/fiasco/src/kern/ux") { + die "$L4DIR doesn't look like an L4 directory!"; + } +} + +## +# Just check if the supplied binary in $FIASCOUX is really +# a Fiasco UX version. Native versions will just segfault. +sub check_for_fiasco_ux() { + + unless ((-x $FIASCOUX && -f $FIASCOUX) || + (-l $FIASCOUX && -x readlink $FIASCOUX && -f readlink $FIASCOUX)) { + die "$FIASCOUX: Does not exist or isn't an executable file"; + } + + system("$FIASCOUX -h >/dev/null 2>&1"); + die "$FIASCOUX doesn't seem to be a UX version." if $?; + + $FIASCOUX =~ /(.*)\/([^\/]*)$/; + $Fiasco_Dir = $1; +} + +# check for user app in binary path of L4 +sub check_user_app($) +{ + my $app_with_args = shift; + + # extract arch and api from OBJ-dir + $OBJDIR =~ /OBJ-([^-]*)-(.*)/; + my $arch = $1; + my $api = $2; + + my @check = split(/\s+/, $app_with_args); + my $app = shift @check; + + my $p = sprintf "%s/bin/%s/%s/%s", $OBJ_BASE, $arch, $api, $app; + die "There's no $p!" unless -f $p; + + return $p.'\\ '.join('\\ ', @check) if @check; + $p; +} + +## +# Check for userland (roottask, sigma0, ...) +sub check_for_userland() { + foreach my $t (keys %templs) { + my $p = sprintf $templs{$t}, $OBJ_BASE, $OBJDIR; + die "There's no $p!" unless -f $p; + $progs{$t} = $p; + } + + # check for base-servers + my @servers = @Baseservers; + @Baseservers = {}; + if (scalar(@servers) eq 0) { + @servers = ( "log", "names", "dm_phys" ); + } + + # iterate over servers and test if they exist in the bin dir + foreach my $s (@servers) { + push @Baseservers, check_user_app($s); + } + + # test client and server + push @Baseservers, check_user_app($Client) if defined($Client); + push @Baseservers, check_user_app($Server); +} + +## +# Does the comparison of the output +sub run_diff { + print STDERR "Running compare command \"$COMPARE_CMD\".\n" if $Verbose; + open(TMP, "$COMPARE_CMD |") or die "Cannot run diff: $!"; + my @diff = <TMP>; + close TMP; + + # reset console in interactive mode + system "if tty -s; then stty echo icrnl icanon; fi"; + + # check if there are differences between expected and generated output + if (@diff == 0) { + print STDERR "Output of test in $PKGNAME ok.\n"; + return $Exit_code; + } + + print STDERR "Test in $PKGNAME generated unexpected output:\n"; + @diff = splice @diff, 1000 if @diff > 1000; + print STDERR @diff, "\n"; + return 1 - $Exit_code; +} + +## +# Called if second alarm signal received +# +# Now all the output of Fiasco-UX should be through and we can savely kill +# Fiasco-UX. We then check the generated output and terminate ourselves. +sub got_sig_alarm_second { + print STDERR "Timeout for flushing Fiasco-UX output\n" if $Verbose; + print STDERR "Sending SIGKILL to $pid and diff output\n" if $Verbose; + + kill KILL => $pid; + alarm 0; + + # some sanity checks + if ( $Filter_state < $FILTER_LEVEL_USER ) { + print $Output "\n"; + print $Output "User tasks did not start. Maybe overlapping modules?\n"; + print $Output "Run \"" . fiascoux_cmdline() . "\" manually to check.\n"; + } + close $Output; + + # in generate mode, simply return + if ($Generate) { + system "stty echo"; + exit 0; + } + + exit run_diff(); +} + +## +# Called if first alarm signal received +# +# To flush Fiasco Output we send it a SIGINT (^C). Then we set up a second +# timeout and return, so the filter can process the output which we forced to +# be flushed. +sub got_sig_alarm_first { + print STDERR "Timeout for Fiasco-UX hit!\n" if $Verbose; + print STDERR "Sending SIGINT to $pid\n" if $Verbose; + + kill INT => $pid; + $SIG{ALRM} = \&got_sig_alarm_second; + alarm 2; # time to flush output + + # return to keep on filtering the output of Fiasco +} + +## +# Runs the timer and kills fiasco if runaway +# +# - sets the signal handler +# - initializes the timeout +sub set_alarm { + $SIG{ALRM} = \&got_sig_alarm_first; + alarm $ALARM_TIMEOUT; + print STDERR "Set alarm to $ALARM_TIMEOUT seconds\n" if $Verbose; +} + +## +# Build the fiasco command line +# +# Adds the binaries with the appropriate parameters. +sub fiascoux_cmdline() { + (my $p = $FIASCOUX) =~ s/\/[^\/]+$//; + my $cmdline = "$FIASCOUX"; + $cmdline .= " $FIASCOUX_PARAM" if defined $FIASCOUX_PARAM; + $cmdline .= " -symbols $Fiasco_Dir/Symbols" if $Use_Symbols; + $cmdline .= " -lines $Fiasco_Dir/Lines" if $Use_Lines; + $cmdline .= " -m $Memory"; + $cmdline .= " -R $progs{roottask}"; # -quiet"; + $cmdline .= "\"" if $Use_Symbols || $Use_Lines; + $cmdline .= " -symbols" if $Use_Symbols; + $cmdline .= " -lines" if $Use_Lines; + $cmdline .= "\"" if $Use_Symbols || $Use_Lines; + $cmdline .= " -S $progs{sigma0}"; # --quiet"; + # when we change this to not cd into Fiasco dir, then + # prepend $p to $irq0 + $cmdline .= " -I ".$p."/irq0"; + if ($No_fb eq 1) { + $cmdline .= " -F /bin/true"; + } else { + $cmdline .= " -F ".$p."/con_ux"; + } + # add -l to base-servers, which already contains client and server + for my $s (@Baseservers) { + if (ref($s) ne "HASH") { # just checking for Hashes that smuggled in + $cmdline .= " -l ".$s; + } + } + $cmdline; +} + +## +# filters the output of fiasco +# +# We want to see everything once roottask are finished loading. +# Therefore, we need some state machine to skip everything before and while +# roottask is running. +sub filter_fiasco_out +{ + $_ = shift; + + # filter escape sequences + s/[[:cntrl:]]\[(\d;)?\d{0,2}m//g; + s/
//g; + s/[[:cntrl:]]\[K//g; + s/[[:cntrl:]]\[\d+;\d+[Hfr]//g; + + # check if we have to change state + if (/^Roottask: Loading \d+ modules\./ && + $Filter_state eq $FILTER_LEVEL_FIASCO) { + $Filter_state = $FILTER_LEVEL_ROOTTASK; + print STDERR "Changed state to Roottask-Output\n" if $Verbose; + } + if ( /^$/ && $Filter_state eq $FILTER_LEVEL_ROOTTASK) { + $Filter_state = $FILTER_LEVEL_USER; + print STDERR "Changed state to Userland-Output\n" if $Verbose; + } + + # skip everything before and from roottask + return undef if $Filter_state < $Filter_level; + + # if we are not supposed to filter anything, then return the line + return $_ if $Filter_level eq $FILTER_LEVEL_FIASCO; + + # filter empty lines + return undef if /^$/; + + # filter JDB warning and prompt + return undef if /^Terminal probably too small, should be at least/; + return undef if /^\([a-f0-9]\.\d\d\) jdb:/; + return undef if /^--.*ESP:.*EIP:.*/; + + # filter memory dump + return undef if /^([a-f0-9]){8}:/; + + $_; +} + +## +# call_test +sub run_fiasco { + my $cmdline = fiascoux_cmdline(); + print "Calling: $cmdline\n" if $Verbose; + + $pid = open($Input, "$cmdline|"); + die "Can't start Fiasco: $!" unless defined $pid; + print "Run Fiasco-UX in $pid\n" if $Verbose; + + # if in generate mode, we redirect output to EXPECTED_OUT + # otherwise we redirect stdout to the TMP_OUT file + my $filename = $Generate ? $EXPECTED_OUT : $TMP_OUT; + open($Output, ">$filename") || die "Cannot open output file $filename"; + my $oldfh = select($Output); $| = 1; select($oldfh); + print STDERR "Opened $filename, now setting timer\n" if $Verbose; + + # the parent sets up the timer (it will eventually call the run_diff sub) + set_alarm(); + + my $o; + while (<$Input>) { + # we have to strip some lines + $o = filter_fiasco_out($_); + next unless defined $o; + print $Output $o; + } + print STDERR "Fiasco terminated.\n" if $Verbose; + close $Input; + close $Output; + # when we drop out of this loop fiasco terminated + alarm 0; + + # in generate mode, simply return + exit 0 if $Generate; + + exit run_diff(); +} + +## +# Plain run of Fiasco UX +# +# Not timer, no filter, simply run UX +sub run_plain_fiasco { + my $cmdline = fiascoux_cmdline(); + print "Running UX: \"$cmdline\"\n"; + exec($cmdline) or die "Can't start Fiasco: $!"; + exit 1; +} + + +# ------------------------------------------------------------- + +unless (GetOptions("help|h", sub { usage(); exit(0); }, + "l4dir|l=s", \$L4DIR, + "builddir=s", \$OBJ_BASE, + "fiascoux|f=s", \$FIASCOUX, + "fiascoux_param|p=s", \$FIASCOUX_PARAM, + "memory|m=s", \$Memory, + "objdir|O=s", \$OBJDIR, + "verbose|v!", \$Verbose, + "quiet|q!", \$Quiet, + "generate!", \$Generate, + "expectfail!", \$Exit_code, + "client|c=s", \$Client, + "server|s=s", \$Server, + "base|b=s", \@Baseservers, + "timeout|t=s", \$ALARM_TIMEOUT, + "plainrun!", \$Plainrun, + "filterlevel=i", \$Filter_level, + "nofb!", \$No_fb, + "symbols!", \$Use_Symbols, + "lines!", \$Use_Lines, + )) { + usage(); + exit(1); +} + +@Baseservers = split(/,/,join(',',@Baseservers)); + +$L4DIR = $ENV{L4DIR} || die "Need an L4DIR set!" unless $L4DIR; +$OBJ_BASE = $ENV{OBJ_BASE} || die "Need an builddir (OBJ_BASE) set!" unless $OBJ_BASE; +$FIASCOUX = $ENV{FIASCOUX} || die "Need a Fiasco-UX path!" unless $FIASCOUX; +if ($ENV{EXPECTED_OUT}) { $EXPECTED_OUT = $ENV{EXPECTED_OUT}; } +die "Need filename of expected output!" unless $EXPECTED_OUT; +if ($ENV{TMP_OUT}) { $TMP_OUT = $ENV{TMP_OUT}; } +die "No valid temporary file set!" unless $TMP_OUT; +$PKGNAME = $ENV{PKGNAME} || $Server + || die "No package-name set!" unless $PKGNAME; +if ($ENV{COMPARE_CMD}) { $COMPARE_CMD = $ENV{COMPARE_CMD}; } +die "No compare command set!" unless $COMPARE_CMD; + +check_for_l4dir(); +check_for_fiasco_ux(); +check_for_userland(); + +## +# The package test script: +# This script forks off Fiasco and sets up a timeout. When the timeout +# strikes, it sends a SIGINT to Fiasco to force a flush of the output buffer. +# Then it sends a SIGKILL to terminate Fiasco. +print "Main called by $$.\n" if $Verbose; + +# if plainrun, start run_plain_fiasco (it never returns) +run_plain_fiasco() if $Plainrun; + +# this function forks off fiasco +run_fiasco(); + +# when we reach this point, something terribly went wrong +die "Oops, error in script!\n"; |