mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-22 15:02:25 +00:00
954 lines
27 KiB
Plaintext
954 lines
27 KiB
Plaintext
#
|
|
# Integration of Depot Autopilot into a Run-tool-based test infrastructure
|
|
#
|
|
# For a detailed documentation of the user interface and the features of this
|
|
# Run script please see _repos/gems/src/app/depot_autopilot/README_.
|
|
#
|
|
|
|
|
|
##############################################################
|
|
## Local copies of run tool procedures with small adaptions ##
|
|
## ##
|
|
## FIXME: Adapt original and remove local copies ##
|
|
##############################################################
|
|
|
|
proc autopilot_wait_for_output { wait_for_re timeout_value running_spawn_id } {
|
|
global output
|
|
global run_genode_failed
|
|
|
|
if {$wait_for_re == "forever"} {
|
|
set timeout -1
|
|
interact {
|
|
\003 {
|
|
send_user "Expect: 'interact' received 'strg+c' and was cancelled\n";
|
|
exit
|
|
}
|
|
-i $running_spawn_id
|
|
}
|
|
} else {
|
|
set timeout $timeout_value
|
|
}
|
|
|
|
set platform_msg [run_boot_string]
|
|
if {$platform_msg eq ""} {
|
|
set platform_msg "undefined platform command startup string sequence"
|
|
}
|
|
|
|
expect {
|
|
-i $running_spawn_id $platform_msg { puts stderr "Error: platform rebooted unexpectedly"; exit -4 }
|
|
-i $running_spawn_id -re $wait_for_re { }
|
|
|
|
# sel4
|
|
-i $running_spawn_id -re {Error: ~Cnode - not implemented.*?\n} {
|
|
puts stderr "Error: Core presumably went out of resources";
|
|
set run_genode_failed 1
|
|
return
|
|
}
|
|
# pistachio kernel fault
|
|
-i $running_spawn_id -re {--- "KD# Exception caught" ---.*?\n} {
|
|
puts stderr "Error: Kernel fault";
|
|
set run_genode_failed 1
|
|
return
|
|
}
|
|
# sel4 unknown fault caught by core
|
|
-i $running_spawn_id -re {Error: unexpected exception during fault.*?stopped.*?\n} {
|
|
puts stderr "Error: Unknown fault";
|
|
set run_genode_failed 1
|
|
return
|
|
}
|
|
# can happen, for instance, on socat TCP-timeout
|
|
eof {
|
|
puts stderr "Error: Spawned process died unexpectedly";
|
|
set run_genode_failed 1
|
|
return
|
|
}
|
|
timeout {
|
|
puts stderr "Error: Test execution timed out";
|
|
set run_genode_failed 1
|
|
return
|
|
}
|
|
}
|
|
append output $expect_out(buffer)
|
|
}
|
|
|
|
proc autopilot_create_tar_from_depot_binaries { archive_path args } {
|
|
|
|
# filter out api and src archives from requested depot content
|
|
set content {}
|
|
foreach subdir [_collect_from_depot $args] {
|
|
if {[regexp [_depot_archive_versioned_path_pattern] $subdir dummy user type]} {
|
|
if {$type == "src"} continue;
|
|
if {$type == "api"} continue;
|
|
}
|
|
lappend content $subdir
|
|
}
|
|
|
|
check_for_missing_depot_archives
|
|
|
|
eval "exec tar cf $archive_path -T /dev/null -C [depot_dir] [lsort -unique $content]"
|
|
}
|
|
|
|
proc autopilot_run_genode_until {{wait_for_re forever} {timeout_value 0} {running_spawn_id -1}} {
|
|
#
|
|
# If a running_spawn_id is specified, wait for the expected output
|
|
#
|
|
if {$running_spawn_id != -1} {
|
|
autopilot_wait_for_output $wait_for_re $timeout_value $running_spawn_id
|
|
return;
|
|
}
|
|
|
|
set retry 3
|
|
while { $retry != 0 } {
|
|
|
|
if {![run_power_cycle]} {
|
|
puts "Power cycle step failed, retry."
|
|
sleep 3
|
|
incr retry -1;
|
|
continue
|
|
}
|
|
|
|
if {![run_load]} {
|
|
puts "Load step failed, retry."
|
|
|
|
# kill the spawned load process if there is one
|
|
if {[load_spawn_id] != -1} {
|
|
kill_spawned [load_spawn_id]
|
|
}
|
|
|
|
incr retry -1;
|
|
continue;
|
|
}
|
|
|
|
if {![run_log $wait_for_re $timeout_value]} {
|
|
puts "Log step failed, retry."
|
|
incr retry -1;
|
|
continue;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
puts stderr "Boot process failed 3 times in series. I give up!";
|
|
exit -1;
|
|
}
|
|
|
|
|
|
########################
|
|
## Utility procedures ##
|
|
########################
|
|
|
|
|
|
|
|
#
|
|
# Whether the run script is used interactively
|
|
#
|
|
proc interactive {} {
|
|
return [expr ![get_cmd_switch --autopilot]]
|
|
}
|
|
|
|
|
|
#
|
|
# Get value of an environment variable
|
|
#
|
|
proc get_env_var { var_name default_value } {
|
|
if {[info exists ::env($var_name)]} {
|
|
return $::env($var_name)
|
|
}
|
|
return $default_value
|
|
}
|
|
|
|
#
|
|
# Check if archives are available without doing anything with them
|
|
#
|
|
proc check_archives_available { args } {
|
|
|
|
# filter out api and src archives from requested depot content
|
|
set content {}
|
|
foreach subdir [_collect_from_depot $args] {
|
|
if {[regexp [_depot_archive_versioned_path_pattern] $subdir dummy user type]} {
|
|
if {$type == "src"} continue;
|
|
if {$type == "api"} continue;
|
|
}
|
|
lappend content $subdir
|
|
}
|
|
|
|
check_for_missing_depot_archives
|
|
}
|
|
|
|
#
|
|
# Return routes for boot modules that shall overlay the test-depot content
|
|
#
|
|
proc single_test_module_routes { } {
|
|
|
|
global test_modules
|
|
set result ""
|
|
foreach module $test_modules {
|
|
append result {
|
|
<service name="ROM" label_last="} $module {"> <parent/> </service>}
|
|
}
|
|
return $result
|
|
}
|
|
|
|
#
|
|
# Return autopilot start-nodes for the test packages that shall be run
|
|
#
|
|
proc test_pkgs_start_nodes { } {
|
|
|
|
global test_pkgs
|
|
|
|
set result ""
|
|
foreach test_pkg $test_pkgs {
|
|
if {[skip_test $test_pkg]} {
|
|
append result {
|
|
<start name="} $test_pkg {" skip="true"/>}
|
|
} else {
|
|
append result {
|
|
<start name="} $test_pkg {" pkg="} [depot_user] {/pkg/} $test_pkg {/} [_current_depot_archive_version pkg $test_pkg] {"/>}
|
|
}
|
|
}
|
|
return $result
|
|
}
|
|
|
|
|
|
#
|
|
# Prepare to call run_genode_until (again, with a changed setup)
|
|
#
|
|
proc prepare_to_run_genode { } {
|
|
|
|
global output
|
|
global qemu_args
|
|
global previous_results
|
|
global previous_time_ms
|
|
global previous_succeeded
|
|
global previous_failed
|
|
global previous_skipped
|
|
global test_pkgs
|
|
global test_srcs
|
|
global test_builds
|
|
global test_modules
|
|
global test_repeat
|
|
global last_test_pkg
|
|
global run_genode_failed
|
|
global serial_id
|
|
global timeout
|
|
global initial_qemu_args
|
|
|
|
# reset the QEMU arguments to the value when the run script was entered
|
|
set qemu_args $initial_qemu_args
|
|
|
|
# compose list of the package archives to add to the depot archive
|
|
set depot_tar_pkg_archives ""
|
|
foreach test_pkg $test_pkgs {
|
|
if {![skip_test $test_pkg]} {
|
|
append depot_tar_pkg_archives " [depot_user]/pkg/$test_pkg "
|
|
}
|
|
}
|
|
|
|
# compose list of the source archives to add to the depot archive
|
|
set depot_tar_src_archives ""
|
|
foreach test_src $test_srcs {
|
|
if {![skip_test $test_src]} {
|
|
append depot_tar_src_archives " [depot_user]/src/$test_src "
|
|
}
|
|
}
|
|
|
|
# compose list of the archives to import to the boot directory
|
|
set import_archives ""
|
|
append import_archives {
|
|
} [depot_user] {/src/} [base_src] {
|
|
} [depot_user] {/src/report_rom
|
|
} [depot_user] {/src/fs_rom
|
|
} [depot_user] {/src/vfs
|
|
} [depot_user] {/src/loader
|
|
} [depot_user] {/src/init
|
|
} [depot_user] {/src/depot_query
|
|
}
|
|
if {![skip_test test-lx_block]} {
|
|
append import_archives [depot_user] {/raw/test-lx_block }
|
|
}
|
|
|
|
# check existance of all required archives at once
|
|
set all_archives [concat $depot_tar_pkg_archives \
|
|
$depot_tar_src_archives \
|
|
$import_archives]
|
|
if {[interactive]} {
|
|
check_archives_available {*}$all_archives
|
|
} else {
|
|
check_archives_available {*}$import_archives
|
|
}
|
|
|
|
# create the depot archive in the boot directory
|
|
create_boot_directory
|
|
autopilot_create_tar_from_depot_binaries [run_dir]/genode/depot.tar \
|
|
{*}$depot_tar_pkg_archives
|
|
set depot_tar_wo_src_size [file size [run_dir]/genode/depot.tar]
|
|
append_src_and_api_depot_packages_to_tar [run_dir]/genode/depot.tar \
|
|
{*}$depot_tar_src_archives
|
|
set depot_tar_size [file size [run_dir]/genode/depot.tar]
|
|
puts "Depot archive has a size of $depot_tar_size bytes \
|
|
($depot_tar_wo_src_size bytes without sources)"
|
|
|
|
#
|
|
# Install the root-init config
|
|
#
|
|
append config {
|
|
<config prio_levels="2">
|
|
<parent-provides>
|
|
<service name="ROM"/>
|
|
<service name="IRQ"/>
|
|
<service name="IO_PORT"/>
|
|
<service name="IO_MEM"/>
|
|
<service name="PD"/>
|
|
<service name="RM"/>
|
|
<service name="CPU"/>
|
|
<service name="LOG"/>
|
|
<service name="TRACE"/>
|
|
</parent-provides>
|
|
|
|
<default-route>
|
|
<any-service> <parent/> <any-child/> </any-service>
|
|
</default-route>
|
|
<default caps="100"/>
|
|
|
|
<start name="timer" priority="0">
|
|
<resource name="RAM" quantum="1M"/>
|
|
<provides> <service name="Timer"/> </provides>
|
|
</start>
|
|
|
|
<start name="report_rom" priority="-1">
|
|
<binary name="report_rom"/>
|
|
<resource name="RAM" quantum="2M"/>
|
|
<provides> <service name="Report"/> <service name="ROM"/> </provides>
|
|
<config verbose="no">
|
|
<policy label="depot_autopilot -> blueprint" report="depot_query -> blueprint"/>
|
|
<policy label="depot_query -> query" report="depot_autopilot -> query"/>
|
|
<policy label="dynamic -> config" report="depot_autopilot -> init.config"/>
|
|
</config>
|
|
</start>
|
|
|
|
<start name="vfs" priority="-1">
|
|
<resource name="RAM" quantum="16M"/>
|
|
<provides> <service name="File_system"/> </provides>
|
|
<config>
|
|
<vfs>
|
|
<dir name="depot"> <tar name="depot.tar"/> </dir>
|
|
<dir name="gcov_data"> <ram/> </dir>
|
|
</vfs>
|
|
<policy label="depot_query -> depot" root="/depot" />
|
|
<policy label="fs_rom -> " root="/depot" />
|
|
<policy label="dynamic -> gcov -> gcov -> depot" root="/depot" />
|
|
<policy label_suffix=" -> gcov_data" root="/gcov_data" writeable="yes" />
|
|
</config>
|
|
</start>
|
|
|
|
<start name="fs_rom" priority="-1" caps="300">
|
|
<resource name="RAM" quantum="32M"/>
|
|
<provides> <service name="ROM"/> </provides>
|
|
</start>
|
|
|
|
<start name="depot_query" priority="-1">
|
|
<resource name="RAM" quantum="2M"/>
|
|
<config query="rom">
|
|
<vfs> <dir name="depot"> <fs label="depot"/> </dir> </vfs>
|
|
</config>
|
|
<route>
|
|
<service name="ROM" label="query"> <child name="report_rom"/> </service>
|
|
<any-service> <parent/> <any-child/> </any-service>
|
|
</route>
|
|
</start>
|
|
|
|
<start name="depot_autopilot" priority="-1">
|
|
<resource name="RAM" quantum="8M"/>
|
|
<provides> <service name="LOG"/> </provides>
|
|
<config repeat="} $test_repeat {" arch="} [depot_spec] {" children_label_prefix="dynamic -> ">
|
|
<static>
|
|
<parent-provides>
|
|
<service name="ROM"/>
|
|
<service name="CPU"/>
|
|
<service name="PD"/>
|
|
<service name="LOG"/>
|
|
<service name="RM"/>
|
|
<service name="Timer"/>
|
|
<service name="TRACE"/>
|
|
<service name="File_system"/>
|
|
</parent-provides>
|
|
</static>
|
|
<common_routes>
|
|
|
|
} [single_test_module_routes] {
|
|
|
|
<service name="ROM" label_last="ld.lib.so"> <parent/> </service>
|
|
<service name="ROM" label_last="init"> <parent/> </service>
|
|
<service name="CPU"> <parent/> </service>
|
|
<service name="PD"> <parent/> </service>
|
|
<service name="LOG"> <parent/> </service>
|
|
<service name="Timer"> <parent/> </service>
|
|
<service name="RM"> <parent/> </service>
|
|
<service name="TRACE"> <parent/> </service>
|
|
<service name="File_system" label="gcov -> depot"> <parent/> </service>
|
|
<service name="File_system" label_suffix="gcov_data"> <parent/> </service>
|
|
</common_routes>
|
|
|
|
<previous-results time_sec="} [expr ($previous_time_ms + 999) / 1000] {"
|
|
succeeded="} $previous_succeeded {"
|
|
skipped="} $previous_skipped {"
|
|
failed="} $previous_failed {">} [string map {\" .} $previous_results] {</previous-results>
|
|
|
|
} [test_pkgs_start_nodes] {
|
|
|
|
</config>
|
|
<route>
|
|
<service name="PD" unscoped_label="depot_autopilot"> <parent/> </service>
|
|
<service name="CPU" unscoped_label="depot_autopilot"> <parent/> </service>
|
|
<service name="LOG" unscoped_label="depot_autopilot"> <parent/> </service>
|
|
<service name="ROM" unscoped_label="depot_autopilot"> <parent/> </service>
|
|
<service name="ROM" unscoped_label="ld.lib.so"> <parent/> </service>
|
|
<service name="ROM" label="blueprint"> <child name="report_rom"/> </service>
|
|
<service name="Report" label="query"> <child name="report_rom"/> </service>
|
|
<service name="Report" label="init.config"> <child name="report_rom"/> </service>
|
|
<service name="Timer" label=""> <child name="timer"/> </service>
|
|
</route>
|
|
</start>
|
|
|
|
<start name="dynamic" caps="8000" priority="-1">
|
|
<resource name="RAM" quantum="286M"/>
|
|
<binary name="init"/>
|
|
<route>
|
|
|
|
} [single_test_module_routes] {
|
|
|
|
<service name="ROM" label_last="ld.lib.so"> <parent/> </service>
|
|
<service name="ROM" label_last="init"> <parent/> </service>
|
|
<service name="ROM" label="config"> <child name="report_rom"/> </service>
|
|
<service name="ROM"> <child name="fs_rom"/> </service>
|
|
<service name="LOG" unscoped_label="dynamic"> <parent/> </service>
|
|
<service name="LOG"> <child name="depot_autopilot"/> </service>
|
|
<service name="Timer"> <child name="timer"/> </service>
|
|
<any-service> <parent/> <any-child/> </any-service>
|
|
</route>
|
|
</start>
|
|
|
|
</config>}
|
|
install_config $config
|
|
|
|
|
|
#
|
|
# Create the rest of the boot modules
|
|
#
|
|
|
|
set build_components { app/depot_autopilot }
|
|
append build_components $test_builds
|
|
build $build_components
|
|
|
|
import_from_depot {*}$import_archives
|
|
|
|
|
|
#
|
|
# Build boot image from boot modules
|
|
#
|
|
|
|
set boot_modules [build_artifacts]
|
|
append boot_modules $test_modules
|
|
build_boot_image $boot_modules
|
|
|
|
set last_test_pkg ""
|
|
set run_genode_failed 0
|
|
set serial_id -1
|
|
set timeout 40
|
|
|
|
append qemu_args " -nographic "
|
|
}
|
|
|
|
|
|
#
|
|
# Initialize variables that accumulate test results for possible reboots
|
|
#
|
|
proc init_previous_results {} {
|
|
global previous_results_on_exit
|
|
global previous_results
|
|
global previous_time_ms
|
|
global previous_succeeded
|
|
global previous_failed
|
|
global previous_skipped
|
|
|
|
set previous_results_on_exit 1
|
|
set previous_results ""
|
|
set previous_time_ms 0
|
|
set previous_succeeded 0
|
|
set previous_failed 0
|
|
set previous_skipped 0
|
|
}
|
|
|
|
|
|
#
|
|
# Whether a test shall be skipped or not
|
|
#
|
|
proc skip_test { test } {
|
|
global skip_test
|
|
if {![info exists skip_test($test)]} {
|
|
return 0
|
|
}
|
|
return $skip_test($test)
|
|
}
|
|
|
|
|
|
#
|
|
# Whether all given archives and the archives they depend on are available
|
|
#
|
|
proc archives_available { archives } {
|
|
|
|
global _missing_depot_archives
|
|
set buf $_missing_depot_archives
|
|
set _missing_depot_archives ""
|
|
_collect_from_depot $archives
|
|
set result [expr [llength $_missing_depot_archives] == 0]
|
|
set _missing_depot_archives $buf
|
|
return $result
|
|
}
|
|
|
|
|
|
#
|
|
# Initialize variables that can be configured via the user interface
|
|
#
|
|
proc init_test_setting {} {
|
|
|
|
global test_pkgs
|
|
global test_srcs
|
|
global test_builds
|
|
global test_modules
|
|
global test_repeat
|
|
global default_test_pkgs
|
|
global default_test_srcs
|
|
|
|
#
|
|
# Initialize the lists of test package-archives, source-archives,
|
|
# build-targets, and boot-modules to be considered by the run script
|
|
#
|
|
set test_pkgs [get_env_var TEST_PKGS "default"]
|
|
set test_srcs [get_env_var TEST_SRCS "default"]
|
|
set test_builds [get_env_var TEST_BUILDS ""]
|
|
set test_modules [get_env_var TEST_MODULES ""]
|
|
set test_repeat [get_env_var TEST_REPEAT "false"]
|
|
|
|
set nr_of_tests_to_run 0
|
|
|
|
# initialize list of test package archives
|
|
if {$test_pkgs == "default"} {
|
|
set test_pkgs $default_test_pkgs
|
|
}
|
|
foreach test_pkg $test_pkgs {
|
|
if {[skip_test $test_pkg]} {
|
|
continue
|
|
}
|
|
incr nr_of_tests_to_run
|
|
if {[interactive]} {
|
|
continue
|
|
}
|
|
if {[archives_available [depot_user]/pkg/$test_pkg]} {
|
|
continue
|
|
}
|
|
set test_pkgs [lsearch -all -inline -not -exact \
|
|
$test_pkgs $test_pkg]
|
|
|
|
puts stderr "Warning: remove test package of \"$test_pkg\" because of\
|
|
missing archives"
|
|
}
|
|
# initialize list of test source archives
|
|
if {$test_srcs == "default"} {
|
|
set test_srcs $default_test_srcs
|
|
}
|
|
foreach test_src $test_srcs {
|
|
if {[skip_test $test_src]} {
|
|
continue
|
|
}
|
|
if {[interactive]} {
|
|
continue
|
|
}
|
|
if {[archives_available [depot_user]/src/$test_src]} {
|
|
continue
|
|
}
|
|
set test_srcs [lsearch -all -inline -not -exact \
|
|
$test_srcs $test_src]
|
|
|
|
puts stderr "Warning: remove test source of \"$test_src\" because of\
|
|
missing archives"
|
|
}
|
|
puts "Number of tests to run: $nr_of_tests_to_run"
|
|
}
|
|
|
|
|
|
#
|
|
# Overwrite exit procedure to ensure to always print a results overview
|
|
#
|
|
rename exit run_tool_exit
|
|
proc exit {{status 0}} {
|
|
|
|
global previous_results_on_exit
|
|
global previous_results
|
|
global previous_time_ms
|
|
global previous_succeeded
|
|
global previous_failed
|
|
global previous_skipped
|
|
|
|
if {![info exists previous_results_on_exit] || \
|
|
![info exists previous_results] || \
|
|
![info exists previous_time_ms] || \
|
|
![info exists previous_succeeded] || \
|
|
![info exists previous_failed] || \
|
|
![info exists previous_skipped]} \
|
|
{
|
|
init_previous_results
|
|
}
|
|
if {$previous_results_on_exit != 0} {
|
|
set previous_time_sec [expr $previous_time_ms / 1000]
|
|
set previous_time_sec_frac [expr $previous_time_ms - $previous_time_sec * 1000]
|
|
set previous_results_list [split $previous_results "\n"]
|
|
puts ""
|
|
puts "Failed to let Depot Autopilot finish!"
|
|
puts "Result overview simulated by run script:"
|
|
puts ""
|
|
puts "\[init -> depot_autopilot] --- Finished after $previous_time_sec.$previous_time_sec_frac sec ---"
|
|
puts "\[init -> depot_autopilot] "
|
|
foreach previous_result $previous_results_list {
|
|
puts "\[init -> depot_autopilot] $previous_result"
|
|
}
|
|
puts "\[init -> depot_autopilot] "
|
|
puts "\[init -> depot_autopilot] succeeded: $previous_succeeded failed: $previous_failed skipped: $previous_skipped"
|
|
puts "\[init -> depot_autopilot] "
|
|
}
|
|
run_tool_exit $status
|
|
}
|
|
|
|
|
|
##################
|
|
## Main routine ##
|
|
##################
|
|
|
|
#
|
|
# Check platform support
|
|
#
|
|
if {[expr ![have_spec x86] && \
|
|
![have_spec arm_v6] && \
|
|
![have_spec arm_v7a] && \
|
|
![have_spec arm_v8a] && \
|
|
![have_spec riscv]]} \
|
|
{
|
|
puts "\n Run script is not supported on this platform. \n";
|
|
exit 0
|
|
}
|
|
|
|
#
|
|
# Default list of test package-archives
|
|
#
|
|
# Was obtained by issuing:
|
|
#
|
|
# ! cd <GENODE_DIR>/repos
|
|
# ! find . -type d -wholename *recipes/pkg/test-* -printf '%f\n' | sort
|
|
#
|
|
set default_test_pkgs {
|
|
test-spark
|
|
test-spark_exception
|
|
test-spark_secondary_stack
|
|
test-black_hole
|
|
test-clipboard
|
|
test-depot_query_index
|
|
test-ds_ownership
|
|
test-dynamic_config
|
|
test-dynamic_config_loader
|
|
test-entrypoint
|
|
test-expat
|
|
test-fault_detection
|
|
test-file_vault_config_report
|
|
test-file_vault_config_report_no_entropy
|
|
test-fs_packet
|
|
test-fs_report
|
|
test-fs_rom_update
|
|
test-fs_rom_update_fs
|
|
test-fs_rom_update_ram
|
|
test-fs_tool
|
|
test-init
|
|
test-init_loop
|
|
test-ldso
|
|
test-libc
|
|
test-libc_connect_lwip
|
|
test-libc_connect_lxip
|
|
test-libc_connect_vfs_server_lwip
|
|
test-libc_connect_vfs_server_lxip
|
|
test-libc_counter
|
|
test-libc_execve
|
|
test-libc_fifo_pipe
|
|
test-libc_fork
|
|
test-libc_getenv
|
|
test-libc_pipe
|
|
test-libc_vfs
|
|
test-libc_vfs_audit
|
|
test-libc_vfs_block
|
|
test-libc_vfs_counter
|
|
test-libc_vfs_fs
|
|
test-libc_vfs_fs_chained
|
|
test-libc_vfs_ram
|
|
test-log
|
|
test-lx_block
|
|
test-mmio
|
|
test-new_delete
|
|
test-nic_loopback
|
|
test-part_block_gpt
|
|
test-part_block_mbr
|
|
test-pipe_read_ready
|
|
test-pthread
|
|
test-ram_fs_chunk
|
|
test-read_only_rom
|
|
test-reconstructible
|
|
test-registry
|
|
test-report_rom
|
|
test-resource_request
|
|
test-resource_yield
|
|
test-rm_fault
|
|
test-rm_fault_no_nox
|
|
test-rm_nested
|
|
test-rm_stress
|
|
test-rom_filter
|
|
test-sandbox
|
|
test-sanitizer
|
|
test-sequence
|
|
test-signal
|
|
test-slab
|
|
test-stack_smash
|
|
test-stdcxx
|
|
test-synced_interface
|
|
test-tcp_bulk_lwip
|
|
test-tcp_bulk_lxip
|
|
test-terminal_crosslink
|
|
test-timer
|
|
test-tls
|
|
test-token
|
|
test-trace
|
|
test-trace_buffer
|
|
test-trace_logger
|
|
test-utf8
|
|
test-vfs_block
|
|
test-vfs_stress_fs
|
|
test-vfs_stress_ram
|
|
test-weak_ptr
|
|
test-xml_generator
|
|
test-xml_node
|
|
gcov
|
|
}
|
|
|
|
#
|
|
# Default list of test source-archives
|
|
#
|
|
set default_test_srcs {
|
|
test-xml_generator
|
|
}
|
|
|
|
#
|
|
# Whether the platform supports non-executable dataspaces
|
|
#
|
|
proc non_executable_supported { } {
|
|
if {[have_spec hw] && [have_spec x86_64]} { return true }
|
|
if {[have_spec hw] && [have_spec arm]} { return true }
|
|
if {[have_spec nova] && [have_spec x86_64]} { return true }
|
|
if {[have_spec foc] && [have_spec x86_64]} { return true }
|
|
if {[have_spec foc] && [have_spec arm]} { return true }
|
|
if {[have_spec sel4] && [have_spec arm]} { return true }
|
|
return false
|
|
}
|
|
|
|
proc skip_test_if { condition test } {
|
|
|
|
global skip_test
|
|
if {$condition} {
|
|
set skip_test($test) true
|
|
}
|
|
}
|
|
|
|
#
|
|
# Whether to skip a test - if undefined for a test, the test is not skipped
|
|
#
|
|
|
|
#
|
|
# pbxa9 and zynq_qemu don't support jitterentropy
|
|
#
|
|
skip_test_if [expr ([have_board pbxa9] || [have_board zynq_qemu])] test-file_vault_config_report
|
|
skip_test_if [expr !([have_board pbxa9] || [have_board zynq_qemu])] test-file_vault_config_report_no_entropy
|
|
|
|
# rpi has a quite limited amount of RAM
|
|
skip_test_if [have_board rpi] test-file_vault_config_report
|
|
skip_test_if [have_board rpi] test-file_vault_config_report_no_entropy
|
|
|
|
set skip_test(test-fault_detection) [expr [have_spec pistachio] || [have_spec fiasco]]
|
|
set skip_test(test-fs_packet) [expr ![interactive] && [have_include "power_on/qemu"]]
|
|
set skip_test(test-libc) [expr [have_spec sel4] || [have_board rpi] || [have_board imx53_qsb_tz]]
|
|
set skip_test(test-lx_block) [expr ![have_board linux]]
|
|
set skip_test(test-rm_fault) [expr [have_board linux] || ![non_executable_supported]]
|
|
set skip_test(test-rm_fault_no_nox) [expr [have_board linux] || ![skip_test test-rm_fault]]
|
|
set skip_test(test-rm_nested) [expr [have_board linux] || [have_spec pistachio]]
|
|
set skip_test(test-slab) [expr ![interactive] && [have_include "power_on/qemu"]]
|
|
set skip_test(test-spark_exception) [expr [have_spec arm]]
|
|
set skip_test(test-tcp_bulk_lwip) [expr ![have_spec x86] && ![have_include "power_on/qemu"]]
|
|
set skip_test(test-tcp_bulk_lxip) [expr ![have_spec x86] && ![have_include "power_on/qemu"]]
|
|
|
|
if {[have_spec foc]} {
|
|
set skip_test(test-entrypoint) [have_board pbxa9]
|
|
set skip_test(test-libc) [have_board pbxa9]
|
|
set skip_test(test-tcp_bulk_lxip) [have_board pbxa9]
|
|
# foc on pbxa9 caps RAM at 256 MiB - skip tests with excessive RAM demand
|
|
skip_test_if [have_board pbxa9] test-file_vault_config_report
|
|
skip_test_if [have_board pbxa9] test-file_vault_config_report_no_entropy
|
|
}
|
|
if {[have_spec riscv]} {
|
|
set skip_test(gcov) true
|
|
set skip_test(test-libc_connect_lxip) true
|
|
set skip_test(test-libc_connect_vfs_server_lxip) true
|
|
set skip_test(test-rm_fault_no_nox) true
|
|
set skip_test(test-spark) true
|
|
set skip_test(test-spark_exception) true
|
|
set skip_test(test-spark_secondary_stack) true
|
|
set skip_test(test-tcp_bulk_lxip) true
|
|
set skip_test(test-trace_logger) true
|
|
set skip_test(test-xml_generator) true
|
|
set skip_test(test-file_vault_config_report) true
|
|
}
|
|
|
|
#
|
|
# FIXME
|
|
#
|
|
# When doing the libc_getenv test on autopilot+foc+x86 and one of the
|
|
# subsequent tests crashes the system so it gets rebooted by the run script,
|
|
# the system doesn't come up again. It gets stuck after core initialization.
|
|
#
|
|
set skip_test(test-libc_getenv) [expr ![interactive] && [have_spec foc] && [have_spec x86]]
|
|
|
|
# remember initial qemu args in case we have to re-boot later
|
|
set initial_qemu_args ""
|
|
if {[info exists qemu_args]} {
|
|
set initial_qemu_args $qemu_args
|
|
}
|
|
|
|
# initialize global variables
|
|
init_test_setting
|
|
init_previous_results
|
|
|
|
#
|
|
# Some platforms have a problem with executing all tests in a single boot.
|
|
# Thus, we have to re-boot them periodically.
|
|
#
|
|
set max_nr_of_tests_per_boot 0
|
|
if {[have_spec sel4]} {
|
|
set max_nr_of_tests_per_boot 20
|
|
}
|
|
|
|
# generic preparation for each system boot
|
|
prepare_to_run_genode
|
|
|
|
while {1} {
|
|
|
|
# check whether the system is already running
|
|
if {$serial_id == -1} {
|
|
|
|
# boot the system and wait for the depot autopilot to come up
|
|
autopilot_run_genode_until {depot_autopilot\] --- .*?\n} $timeout
|
|
set serial_id [output_spawn_id]
|
|
set nr_of_tests_this_boot 0
|
|
|
|
# if the system didn't even boot, exit (prints previous results)
|
|
if {$run_genode_failed} {
|
|
exit -1
|
|
}
|
|
} else {
|
|
|
|
# wait for the next step of the depot autopilot
|
|
set init_time_ms [clock clicks -millisec]
|
|
autopilot_run_genode_until {depot_autopilot\] --- .*?\n} $timeout $serial_id
|
|
set previous_time_ms [expr $previous_time_ms + [expr ([clock clicks -millisec] - $init_time_ms)] ]
|
|
set serial_id [output_spawn_id]
|
|
|
|
# remove last test from list and check if we have to reboot the system
|
|
set test_pkgs [lsearch -all -inline -not -exact $test_pkgs $last_test_pkg]
|
|
if {$run_genode_failed} {
|
|
|
|
# shut-down running system
|
|
kill_spawned $serial_id
|
|
run_power_off
|
|
|
|
# remember result of last test
|
|
if {$previous_results != ""} {
|
|
append previous_results \012
|
|
}
|
|
append previous_results { } [format {%-31s %-6s %7s} $last_test_pkg "failed " "$timeout.000"] { reboot}
|
|
incr previous_failed
|
|
|
|
# prepare system re-boot
|
|
prepare_to_run_genode
|
|
continue
|
|
}
|
|
}
|
|
# if the autopilot finished all tests, evaluate its return value
|
|
if {[regexp {depot_autopilot\] --- Finished} $output]} {
|
|
set output ""
|
|
run_genode_until {child "depot_autopilot" exited with exit value.*?\n} 10 $serial_id
|
|
set previous_results_on_exit 0
|
|
grep_output {^\[init\] }
|
|
compare_output_to {[init] child "depot_autopilot" exited with exit value 0}
|
|
exit 0
|
|
}
|
|
# if the autopilot started a new test, set a new timeout
|
|
if {[regexp {depot_autopilot\] --- Run} $output]} {
|
|
|
|
# if we ran and finished another test beforehand, parse its result
|
|
if {$last_test_pkg != ""} {
|
|
|
|
# remember result of last test in case the system must be restartet
|
|
set last_test_result ""
|
|
regexp {depot_autopilot\] ( [^\033]+)} $output ignored last_test_result
|
|
regsub -all {<} $last_test_result {\<} last_test_result
|
|
|
|
set failed_off [string first " failed" $last_test_result]
|
|
set skipped_off [string first " skipped" $last_test_result]
|
|
set ok_off [string first " ok" $last_test_result]
|
|
|
|
if {$failed_off > 0 && ($skipped_off < 0 || $failed_off < $skipped_off) && ($ok_off < 0 || $failed_off < $ok_off)} {
|
|
incr previous_failed
|
|
} elseif {$skipped_off > 0 && ($ok_off < 0 || $skipped_off < $ok_off)} {
|
|
incr previous_skipped
|
|
} elseif {$ok_off > 0} {
|
|
incr previous_succeeded
|
|
} else {
|
|
puts "Error: malformed test result"
|
|
puts $last_test_result
|
|
exit -1
|
|
}
|
|
if {$previous_results != ""} {
|
|
append previous_results \012
|
|
}
|
|
append previous_results $last_test_result
|
|
incr nr_of_tests_this_boot
|
|
}
|
|
# if the Autopilot is currently repeating, reset repeat-influenced variables
|
|
if {[llength $test_pkgs] == 0} {
|
|
init_test_setting
|
|
init_previous_results
|
|
}
|
|
# determine timeout for the next timeout
|
|
set min_timeout 30
|
|
regexp {depot_autopilot\] --- Run "(.*?)" \(max ([0-9]*?) } $output] ignore last_test_pkg min_timeout
|
|
set timeout [expr $min_timeout + 30]
|
|
|
|
# re-boot if the maximum number of tests per boot is set and reached
|
|
if { [expr $max_nr_of_tests_per_boot && \
|
|
$nr_of_tests_this_boot >= $max_nr_of_tests_per_boot] } \
|
|
{
|
|
# shut-down running system
|
|
puts "Re-booting to meet maximum number of tests per boot for this platform"
|
|
kill_spawned $serial_id
|
|
run_power_off
|
|
|
|
# prepare system re-boot
|
|
prepare_to_run_genode
|
|
continue
|
|
}
|
|
set output ""
|
|
}
|
|
}
|