novaboot

   1 #!/usr/bin/env perl
   2
   3 # This program is free software: you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation, either version 2 of the License, or
   6 # (at your option) any later version.
   7
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 ## Initialization
  17
  18 use strict;
  19 use warnings;
  20 use warnings (exists $ENV{NOVABOOT_TEST} ? (FATAL => 'all') : ());
  21 use Getopt::Long qw(GetOptionsFromString GetOptionsFromArray);
  22 use Pod::Usage;
  23 use File::Basename;
  24 use File::Spec;
  25 use IO::Handle;
  26 use Time::HiRes("usleep");
  27 use Socket;
  28 use FileHandle;
  29 use IPC::Open2;
  30 use POSIX qw(:errno_h sysconf);
  31 use Cwd qw(getcwd abs_path);
  32 use Expect;
  33
  34 # always flush
  35 $| = 1;
  36
  37 my $invocation_dir = $ENV{PWD} || getcwd();
  38
  39 # We prefer using PWD, to use nicer paths names with symbolic links.
  40 # However, when executed from 'make -C dir', PWD may contain the make
  41 # invocation path, not the real invocation path with dir at the end.
  42 # We fix that here.
  43 if (abs_path($ENV{PWD}) ne abs_path(getcwd())) {
  44     $invocation_dir = getcwd();
  45 }
  46
  47 ## Configuration file handling
  48
  49 # Default configuration
  50 $CFG::hypervisor = "";
  51 $CFG::hypervisor_params = "serial";
  52 $CFG::genisoimage = "genisoimage";
  53 $CFG::qemu = 'qemu-system-i386 -cpu coreduo -smp 2';
  54 $CFG::default_target = '';
  55 $CFG::netif = 'eth0';
  56 %CFG::targets = (
  57     'qemu' => '--qemu',
  58     "tud" => '--server=erwin.inf.tu-dresden.de:~sojka/boot/novaboot --rsync-flags="--chmod=Dg+s,ug+w,o-w,+rX --rsync-path=\"umask 002 && rsync\"" --grub --grub-prefix=(nd)/tftpboot/sojka/novaboot --grub-preamble="timeout 0" --concat --iprelay=141.76.48.80:2324 --scriptmod=s/\\\\bhostserial\\\\b/hostserialpci/g',
  59     "novabox" => '--ssh=novabox@rtime.felk.cvut.cz',
  60     "localhost" => '--scriptmod=s/console=tty[A-Z0-9,]+// --server=/boot/novaboot/$NAME --grub2 --grub-prefix=/boot/novaboot/$NAME --grub2-prolog="  set root=\'(hd0,msdos1)\'"',
  61     "ryu" =>  '--uboot --uboot-init="mw f0000b00 \${psc_cfg}; sleep 1" --uboot-addr kernel=800000 --uboot-addr ramdisk=b00000 --uboot-addr fdt=7f0000',
  62     "ryuglab" => '--target ryu --ssh=ryu@pc-sojkam.felk.cvut.cz',
  63     "ryulocal" => '--target ryu --dhcp-tftp --serial --reset-cmd="if which dtrrts; then dtrrts $NB_SERIAL 0 1; sleep 0.1; dtrrts $NB_SERIAL 1 1; fi"',
  64     );
  65
  66 {
  67     my %const;
  68     $const{linux}->{_SC_NPROCESSORS_CONF} = 83;
  69     my $nproc = sysconf($const{$^O}->{_SC_NPROCESSORS_CONF});
  70
  71     $CFG::scons = "scons -j$nproc";
  72     $CFG::make = "make -j$nproc";
  73 }
  74
  75 my $builddir;
  76
  77 sub read_config($) {
  78     my ($cfg) = @_;
  79     {
  80         package CFG; # Put config data into a separate namespace
  81
  82         my $rc = do($cfg);
  83
  84         # Check for errors
  85         if ($@) {
  86             die("ERROR: Failure compiling '$cfg' - $@");
  87         } elsif (! defined($rc)) {
  88             die("ERROR: Failure reading '$cfg' - $!");
  89         } elsif (! $rc) {
  90             die("ERROR: Failure processing '$cfg'");
  91         }
  92     }
  93     $builddir = File::Spec->rel2abs($CFG::builddir, dirname($cfg)) if defined $CFG::builddir;
  94     print STDERR "novaboot: Read $cfg\n";
  95 }
  96
  97 my @cfgs;
  98 {
  99     # We don't use $0 here, because it points to the novaboot itself and
 100     # not to the novaboot script. The problem with this approach is that
 101     # when a script is run as "novaboot <options> <script>" then $ARGV[0]
 102     # contains the first option. Hence the -f check.
 103     my $dir = File::Spec->rel2abs($ARGV[0] && -f $ARGV[0] ? dirname($ARGV[0]) : '', $invocation_dir);
 104     while ((-d $dir || -l $dir ) && $dir ne "/") {
 105         push @cfgs, "$dir/.novaboot" if -r "$dir/.novaboot";
 106         my @dirs = File::Spec->splitdir($dir);
 107         $dir = File::Spec->catdir(@dirs[0..$#dirs-1]);
 108     }
 109     @cfgs = reverse @cfgs;
 110
 111     my $xdg_config_home = $ENV{'XDG_CONFIG_HOME'} || $ENV{'HOME'}.'/.config';
 112     unshift(@cfgs, "$xdg_config_home/novaboot") if -r "$xdg_config_home/novaboot";
 113
 114     $dir = $ENV{'NOVABOOT_CONFIG_DIR'} || '/etc/novaboot.d';
 115     if (opendir(my $dh, $dir)) {
 116         my @etccfg = map { "$dir/$_" } grep { /^[-_a-zA-Z0-9]+$/ && -f "$dir/$_" } readdir($dh);
 117         closedir $dh;
 118         @etccfg = sort(@etccfg);
 119         @cfgs = ( @etccfg, @cfgs );
 120     }
 121 }
 122 my $cfg = $ENV{'NOVABOOT_CONFIG'};
 123 Getopt::Long::Configure(qw/no_ignore_case pass_through/);
 124 GetOptions ("config|c=s" => \$cfg);
 125 read_config($_) foreach $cfg or @cfgs;
 126
 127 ## Command line handling
 128
 129 my $explicit_target = $ENV{'NOVABOOT_TARGET'};
 130 GetOptions ("target|t=s" => \$explicit_target);
 131
 132 # Variables for command line options
 133 my ($amt, @append, $bender, @chainloaders, $concat, $config_name_opt, $dhcp_tftp, $dump_opt, $dump_config, @exiton, $exiton_timeout, @expect_raw, $final_eol, $gen_only, $grub_config, $grub_prefix, $grub_preamble, $grub2_prolog, $grub2_config, $help, $ider, $interaction, $iprelay, $iprelay_cmd, $iso_image, $interactive, $kernel_opt, $make, $man, $netif, $no_file_gen, $off_opt, $on_opt, $pulsar, $pulsar_root, $qemu, $qemu_append, $qemu_flags_cmd, @remote_cmd, $remote_expect, $remote_expect_silent, $remote_expect_timeout, $reset, @reset_cmd, $reset_send, $rom_prefix, $rsync_flags, @scriptmod, $scons, $serial, $server, $stty, $tftp, $tftp_port, $uboot, %uboot_addr, $uboot_cmd, @uboot_init, $uboot_stop_key);
 134
 135 my ($target_reset, $target_power_on, $target_power_off);
 136
 137 # Default values of certain command line options
 138 %uboot_addr = (
 139     'kernel'  => '${kernel_addr_r}',
 140     'ramdisk' => '${ramdisk_addr_r}',
 141     'fdt'     => '${fdt_addr_r}',
 142     );
 143 $rsync_flags = '';
 144 $rom_prefix = 'rom://';
 145 $stty = 'raw -crtscts -onlcr -echo 115200';
 146 $reset = 1;                     # Reset target by default
 147 $interaction = 1;               # Perform target interaction by default
 148 $final_eol = 1;
 149 $netif = $CFG::netif;
 150 $remote_expect_timeout = -1;
 151
 152 my @expect_seen = ();
 153 sub handle_expect
 154 {
 155     my ($n, $v) = @_;
 156     push(@expect_seen, '-re') if $n eq "expect-re";
 157     push(@expect_seen, $v);
 158 }
 159
 160 sub handle_send
 161 {
 162     my ($n, $v) = @_;
 163     unless (@expect_seen) { die("No --expect before --send"); }
 164     my $ret = ($n eq "sendcont") ? exp_continue : 0;
 165     unshift(@expect_raw, sub { shift->send(eval("\"$v\"")); $ret; });
 166     unshift(@expect_raw, @expect_seen);
 167     @expect_seen = ();
 168 }
 169
 170 # Options which can be safely specified on the server (via --ssh),
 171 # i.e. which cannot cause unwanted local code execution etc.
 172 my %opt_spec_safe = (
 173     "grub|g:s"       => \$grub_config,
 174     "grub-preamble=s"=> \$grub_preamble,
 175     "grub2-prolog=s" => \$grub2_prolog,
 176     "grub2:s"        => \$grub2_config,
 177     "prefix|grub-prefix=s" => \$grub_prefix,
 178     "pulsar-root=s"  => \$pulsar_root,
 179     "pulsar|p:s"     => \$pulsar,
 180     "remote-expect=s"=> \$remote_expect,
 181     "remote-expect-silent=s"=> sub { $remote_expect=$_[1]; $remote_expect_silent=1; },
 182     "remote-expect-timeout=i"=> \$remote_expect_timeout,
 183     "uboot-addr=s"   => \%uboot_addr,
 184     "uboot-cmd=s"    => \$uboot_cmd,
 185     "uboot-stop-key=s" => \$uboot_stop_key,
 186     "uboot-init=s"   => sub { push @uboot_init, { command => $_[1] }; },
 187     "uboot:s"        => \$uboot,
 188     );
 189
 190 my %opt_spec = (
 191     %opt_spec_safe,
 192     "amt=s"          => \$amt,
 193     "append|a=s"     => \@append,
 194     "bender|b"       => \$bender,
 195     "build-dir=s"    => sub { my ($n, $v) = @_; $builddir = File::Spec->rel2abs($v); },
 196     "concat"         => \$concat,
 197     "chainloader=s"  => \@chainloaders,
 198     "dhcp-tftp|d"    => \$dhcp_tftp,
 199     "dump"           => \$dump_opt,
 200     "dump-config"    => \$dump_config,
 201     "exiton=s"       => \@exiton,
 202     "exiton-timeout=i"=> \$exiton_timeout,
 203     "exiton-re=s"    => sub { my ($n, $v) = @_; push(@exiton, '-re', $v); },
 204     "expect=s"       => \&handle_expect,
 205     "expect-re=s"    => \&handle_expect,
 206     "expect-raw=s"   => sub { my ($n, $v) = @_; unshift(@expect_raw, eval($v)); },
 207     "final-eol!"     => \$final_eol,
 208     "gen-only"       => \$gen_only,
 209     "ider"           => \$ider,
 210     "interaction!"   => \$interaction,
 211     "iprelay=s"      => \$iprelay,
 212     "iprelay-cmd=s"  => \$iprelay_cmd,
 213     "iso:s"          => \$iso_image,
 214     "kernel|k=s"     => \$kernel_opt,
 215     "interactive|i"  => \$interactive,
 216     "name=s"         => \$config_name_opt,
 217     "make|m:s"       => \$make,
 218     "netif=s"        => \$netif,
 219     "no-file-gen"    => \$no_file_gen,
 220     "off"            => \$off_opt,
 221     "on"             => \$on_opt,
 222     "qemu|Q:s"       => \$qemu,
 223     "qemu-append=s"  => \$qemu_append,
 224     "qemu-flags|q=s" => \$qemu_flags_cmd,
 225     "remote-cmd=s"   => sub { @remote_cmd = ($_[1]); },
 226     "reset!"         => \$reset,
 227     "reset-cmd=s"    => sub { @reset_cmd = ($_[1]); },
 228     "reset-send=s"   => \$reset_send,
 229     "rsync-flags=s"  => \$rsync_flags,
 230     "scons:s"        => \$scons,
 231     "scriptmod=s"    => \@scriptmod,
 232     "send=s"         => \&handle_send,
 233     "sendcont=s"     => \&handle_send,
 234     "serial|s:s"     => \$serial,
 235     "server:s"       => \$server,
 236     "ssh:s"          => \&handle_novaboot_server,
 237     "strip-rom"      => sub { $rom_prefix = ''; },
 238     "stty=s"         => \$stty,
 239     "tftp"           => \$tftp,
 240     "tftp-port=i"    => \$tftp_port,
 241     "no-uboot"       => sub { undef $uboot; },
 242     "h"              => \$help,
 243     "help"           => \$man,
 244     );
 245
 246 sub handle_novaboot_server
 247 {
 248     my ($n, $val) = @_;
 249     my $xdg_runtime_dir = $ENV{XDG_RUNTIME_DIR} || '/var/run';
 250     my $ssh_ctl_path = "${xdg_runtime_dir}/novaboot$$";
 251
 252     @remote_cmd = ('ssh', '-tt', '-M', '-S', $ssh_ctl_path, $val, 'console');
 253     $remote_expect = "novaboot-shell: Connected";
 254     $server = "$val:";
 255     $rsync_flags = "--rsh='ssh -S \'${ssh_ctl_path}\''";
 256     ($grub_prefix = $val) =~ s|(.*)@.*|\/$1\/| if index($val, '@') != -1;
 257     @reset_cmd = ('ssh', '-tt', '-S', $ssh_ctl_path, $val, 'reset');
 258
 259     $target_power_off = sub { system_verbose('ssh', '-tt', '-S', $ssh_ctl_path, $val, 'off'); };
 260     $target_power_on  = sub { system_verbose('ssh', '-tt', '-S', $ssh_ctl_path, $val, 'on'); };
 261
 262     my $cmd = "ssh '${val}' get-config";
 263     print STDERR "novaboot: Running: $cmd\n";
 264     my @target_config = qx($cmd  < /dev/null);
 265     if ($?) { die("Cannot get target configuration from the server"); }
 266     printf "novaboot: Received configuration from the server:%s\n", (!@target_config) ? " empty" : "";
 267     foreach (@target_config) { chomp; print "  $_\n"; }
 268
 269     my $p = Getopt::Long::Parser->new;
 270     $p->configure(qw/no_ignore_case no_pass_through/);
 271     $p->getoptionsfromarray(\@target_config, %opt_spec_safe) or die("Error processing configuration from the server");
 272
 273     if (scalar @target_config) { die "Unsuported configuration received from the server: ".join(", ", @target_config); }
 274 }
 275
 276 # First process target options
 277 {
 278     my $t = defined($explicit_target) ? $explicit_target : $CFG::default_target;
 279     my @target_expanded;
 280     Getopt::Long::Configure(qw/no_ignore_case pass_through/);
 281     while ($t) {
 282         exists $CFG::targets{$t} or die("Unknown target '$t' (valid targets are: ".join(", ", sort keys(%CFG::targets)).")");
 283
 284         undef $explicit_target;
 285         my ($ret, $remaining_args) = GetOptionsFromString ($CFG::targets{$t}, ("target|t=s" => \$explicit_target));
 286         if (!$ret) { die "Error parsing target $t option"; }
 287         push(@target_expanded, @$remaining_args);
 288         $t = $explicit_target;
 289     }
 290
 291     my @args = (@target_expanded, @ARGV);
 292     print STDERR "novaboot: Effective options: @args\n";
 293
 294     Getopt::Long::Configure(qw/no_ignore_case no_pass_through/);
 295     GetOptionsFromArray(\@target_expanded, %opt_spec) or die ("Error in target definition");
 296 }
 297
 298 # Then process other command line options - some of them may override
 299 # what was specified by the target
 300 GetOptions %opt_spec or die("Error in command line arguments");
 301 pod2usage(1) if $help;
 302 pod2usage(-exitstatus => 0, -verbose => 2) if $man;
 303
 304 ### Dump sanitized configuration (if requested)
 305
 306 if ($dump_config) {
 307     use Data::Dumper;
 308     $Data::Dumper::Indent=1;
 309     print "# This file is in perl syntax.\n";
 310     foreach my $key(sort(keys(%CFG::))) { # See "Symbol Tables" in perlmod(1)
 311         if (defined ${$CFG::{$key}}) { print Data::Dumper->Dump([${$CFG::{$key}}], ["*$key"]); }
 312         if (        @{$CFG::{$key}}) { print Data::Dumper->Dump([\@{$CFG::{$key}}], ["*$key"]); }
 313         if (        %{$CFG::{$key}}) { print Data::Dumper->Dump([\%{$CFG::{$key}}], ["*$key"]); }
 314     }
 315     print "1;\n";
 316     exit;
 317 }
 318
 319 ### Sanitize configuration
 320
 321 if ($interactive && !-t STDIN) {
 322     die("novaboot: Interactive mode not supported when not on terminal");
 323 }
 324
 325 if (defined $config_name_opt && scalar(@ARGV) > 1) { die "You cannot use --name with multiple scripts"; }
 326
 327 if ($ider) {
 328     $iso_image //= ''; # IDE-R needs an ISO image
 329     if (!defined $amt) { die "Error: --ider requires --amt"; }
 330 }
 331
 332 {
 333     my %input_opts = ('--iprelay'    => \$iprelay,
 334                       '--iprelay-cmd'=> \$iprelay_cmd,
 335                       '--serial'     => \$serial,
 336                       '--remote-cmd' => (@remote_cmd ? \$remote_cmd[0] : undef),
 337                       '--amt'        => \$amt);
 338     my @opts = grep(defined(${$input_opts{$_}}) , keys %input_opts);
 339
 340     die("novaboot: More than one target connection option: ".join(', ', @opts)) if scalar @opts > 1;
 341 }
 342
 343 # Default options
 344 if (defined $serial) {
 345     $serial ||= "/dev/ttyUSB0";
 346     $ENV{NB_SERIAL} = $serial;
 347 }
 348 if (defined $grub_config) { $grub_config ||= "menu.lst"; }
 349 if (defined $grub2_config) { $grub2_config ||= "grub.cfg"; }
 350
 351 ## Parse the novaboot script(s)
 352 my @scripts;
 353 my $file;
 354 my $EOF;
 355 my $last_fn = '';
 356 my ($modules, $variables, $generated, $copy, $chainload, $continuation) = ([], {}, [], []);
 357 my $skip_reading = defined($on_opt) || defined($off_opt);
 358 while (!$skip_reading && ($_ = <>)) {
 359     if ($ARGV ne $last_fn) { # New script
 360         die "Missing EOF in $last_fn" if $file;
 361         die "Unfinished line in $last_fn" if $continuation;
 362         $last_fn = $ARGV;
 363         push @scripts, { 'filename' => $ARGV,
 364                          'modules' => $modules = [],
 365                          'variables' => $variables = {},
 366                          'generated' => $generated = [],
 367                          'copy' => $copy = [],
 368                          'chainload' => $chainload = [],
 369         };
 370
 371     }
 372     chomp();
 373     next if /^#/ || /^\s*$/;    # Skip comments and empty lines
 374
 375     $_ =~ s/^[[:space:]]*// if ($continuation);
 376
 377     if (/\\$/) {                # Line continuation
 378         $continuation .= substr($_, 0, length($_)-1);
 379         next;
 380     }
 381
 382     if ($continuation) {        # Last continuation line
 383         $_ = $continuation . $_;
 384         $continuation = '';
 385     }
 386
 387     foreach my $mod(@scriptmod) { eval $mod; }
 388
 389     if ($file && $_ eq $EOF) {  # Heredoc end
 390         undef $file;
 391         next;
 392     }
 393     if ($file) {                # Heredoc content
 394         push @{$file}, "$_\n";
 395         next;
 396     }
 397     if (/^([A-Z_]+)=(.*)$/) {   # Internal variable
 398         $$variables{$1} = $2;
 399         push(@exiton, $2) if ($1 eq "EXITON");
 400         $interaction = $2 if ($1 eq "INTERACTION");
 401         next;
 402     }
 403     sub process_load_copy($) {
 404         die("novaboot: '$last_fn' line $.: Missing file name\n") unless /^[^ <]+/;
 405         if (/^([^ ]*)(.*?)[[:space:]]*<<([^ ]*)$/) { # Heredoc start
 406             $file = [];
 407             push @$generated, {filename => $1, content => $file};
 408             $EOF = $3;
 409             return "$1$2";
 410         }
 411         if (/^([^ ]*)(.*?)[[:space:]]*< ?(.*)$/) { # Command substitution
 412             push @$generated, {filename => $1, command => $3};
 413             return "$1$2";
 414         }
 415         return $_;
 416     }
 417     if (s/^load *//) {          # Load line
 418         push @$modules, process_load_copy($_);
 419         next;
 420     }
 421     if (s/^copy *//) {          # Copy line
 422         push @$copy, process_load_copy($_);
 423         next;
 424     }
 425     if (s/^chld *//) {          # Chainload line
 426         push @$chainload, process_load_copy($_);
 427         next;
 428     }
 429     if (/^run (.*)/) {          # run line
 430         push @$generated, {command => $1};
 431         next;
 432     }
 433     if (/^uboot(?::([0-9]+)s)? +(< *)?(.*)/) {  # uboot line
 434         # TODO: If U-Boot supports some interactive menu, it might
 435         # make sense to store uboot lines per novaboot script.
 436         my ($timeout, $redir, $string, $dest) = ($1, $2, $3);
 437         if ($string =~ /(.*) *> *(.*)/) {
 438             $string = $1;
 439             $dest = $2;
 440         }
 441         push @uboot_init, { command => $redir ? "" : $string,
 442                             system =>  $redir ? $string : "",
 443                             timeout => $timeout,
 444                             dest => $dest,
 445         };
 446         next;
 447     }
 448
 449     die("novaboot: Cannot parse script '$last_fn' line $.. Didn't you forget 'load' keyword?\n");
 450 }
 451 # use Data::Dumper;
 452 # print Dumper(\@scripts);
 453
 454 foreach my $script (@scripts) {
 455     $modules = $$script{modules};
 456     @$modules[0] =~ s/^[^ ]*/$kernel_opt/ if $kernel_opt;
 457     @$modules[0] .= ' ' . join(' ', @append) if @append;
 458
 459     my $kernel;
 460     if (exists $variables->{KERNEL}) {
 461         $kernel = $variables->{KERNEL};
 462     } else {
 463         if ($CFG::hypervisor) {
 464             $kernel = $CFG::hypervisor . " ";
 465             if (exists $variables->{HYPERVISOR_PARAMS}) {
 466                 $kernel .= $variables->{HYPERVISOR_PARAMS};
 467             } else {
 468                 $kernel .= $CFG::hypervisor_params;
 469             }
 470         }
 471     }
 472     @$modules = ($kernel, @$modules) if $kernel;
 473     @$modules = (@chainloaders, @$modules);
 474     @$modules = ("bin/boot/bender", @$modules) if ($bender || defined $ENV{'NOVABOOT_BENDER'});
 475 }
 476
 477 if ($dump_opt) {
 478     foreach my $script (@scripts) {
 479         print join("\n", @{$$script{modules}})."\n";
 480     }
 481     exit(0);
 482 }
 483
 484 ## Helper functions
 485
 486 sub generate_configs($$$) {
 487     my ($base, $generated, $filename) = @_;
 488     if ($base) { $base = "$base/"; };
 489     foreach my $g(@$generated) {
 490       if (exists $$g{content}) {
 491         my $config = $$g{content};
 492         my $fn = $$g{filename};
 493         open(my $f, '>', $fn) || die("$fn: $!");
 494         map { s|\brom://([^ ]*)|$rom_prefix$base$1|g; print $f "$_"; } @{$config};
 495         close($f);
 496         print STDERR "novaboot: Created $fn\n";
 497       } elsif (exists $$g{command} && ! $no_file_gen) {
 498         $ENV{SRCDIR} = dirname(File::Spec->rel2abs( $filename, $invocation_dir ));
 499         if (exists $$g{filename}) {
 500             system_verbose("( $$g{command} ) > $$g{filename}");
 501         } else {
 502             system_verbose($$g{command});
 503         }
 504       }
 505     }
 506 }
 507
 508 sub generate_grub_config($$$$;$)
 509 {
 510     my ($filename, $title, $base, $modules_ref, $preamble) = @_;
 511     if ($base) { $base = "$base/"; };
 512     open(my $fg, '>', $filename) or die "$filename: $!";
 513     print $fg "$preamble\n" if $preamble;
 514     print $fg "title $title\n" if $title;
 515     #print $fg "root $base\n"; # root doesn't really work for (nd)
 516     my $first = 1;
 517     foreach (@$modules_ref) {
 518         if ($first) {
 519             $first = 0;
 520             my ($kbin, $kcmd) = split(' ', $_, 2);
 521             $kcmd = '' if !defined $kcmd;
 522             print $fg "kernel ${base}$kbin $kcmd\n";
 523         } else {
 524             s|\brom://([^ ]*)|$rom_prefix$base$1|g; # Translate rom:// files - needed for vdisk parameter of sigma0
 525             print $fg "module $base$_\n";
 526         }
 527     }
 528     close($fg);
 529     print("novaboot: Created $builddir/$filename\n");
 530     return $filename;
 531 }
 532
 533 sub generate_syslinux_config($$$$)
 534 {
 535     my ($filename, $title, $base, $modules_ref) = @_;
 536     if ($base && $base !~ /\/$/) { $base = "$base/"; };
 537     open(my $fg, '>', $filename) or die "$filename: $!";
 538     print $fg "LABEL $title\n";
 539     #TODO print $fg "MENU LABEL $human_readable_title\n";
 540
 541     my ($kbin, $kcmd) = split(' ', @$modules_ref[0], 2);
 542
 543     if (system("file $kbin|grep 'Linux kernel'") == 0) {
 544         my $initrd = @$modules_ref[1];
 545         die('To many "load" lines for Linux kernel') if (scalar @$modules_ref > 2);
 546         print $fg "LINUX $base$kbin\n";
 547         print $fg "APPEND $kcmd\n";
 548         print $fg "INITRD $base$initrd\n";
 549     } else {
 550         print $fg "KERNEL mboot.c32\n";
 551         my @append;
 552         foreach (@$modules_ref) {
 553             s|\brom://([^ ]*)|$rom_prefix$base$1|g; # Translate rom:// files - needed for vdisk parameter of sigma0
 554             push @append, "$base$_";
 555             print $fg "APPEND ".join(' --- ', @append)."\n";
 556         }
 557     }
 558     #TODO print $fg "TEXT HELP\n";
 559     #TODO print $fg "some help here\n";
 560     #TODO print $fg "ENDTEXT\n";
 561     close($fg);
 562     print("novaboot: Created $builddir/$filename\n");
 563     return $filename;
 564 }
 565
 566 sub generate_grub2_config($$$$;$$)
 567 {
 568     my ($filename, $title, $base, $modules_ref, $preamble, $prolog) = @_;
 569     if ($base && substr($base,-1,1) ne '/') { $base = "$base/"; };
 570     open(my $fg, '>', $filename) or die "$filename: $!";
 571     print $fg "$preamble\n" if $preamble;
 572     $title ||= 'novaboot';
 573     print $fg "menuentry $title {\n";
 574     print $fg "$prolog\n" if $prolog;
 575     my $first = 1;
 576     foreach (@$modules_ref) {
 577         if ($first) {
 578             $first = 0;
 579             my ($kbin, $kcmd) = split(' ', $_, 2);
 580             $kcmd = '' if !defined $kcmd;
 581             print $fg "  multiboot ${base}$kbin $kcmd\n";
 582         } else {
 583             my @args = split;
 584             # GRUB2 doesn't pass filename in multiboot info so we have to duplicate it here
 585             $_ = join(' ', ($args[0], @args));
 586             s|\brom://|$rom_prefix|g; # We do not need to translate path for GRUB2
 587             print $fg "  module $base$_\n";
 588         }
 589     }
 590     print $fg "}\n";
 591     close($fg);
 592     print("novaboot: Created $builddir/$filename\n");
 593     return $filename;
 594 }
 595
 596 sub generate_pulsar_config($$$)
 597 {
 598     my ($filename, $modules_ref, $chainload_ref) = @_;
 599     open(my $fg, '>', $filename) or die "$filename: $!";
 600     print $fg "root $pulsar_root\n" if defined $pulsar_root;
 601     if (scalar(@$chainload_ref) > 0) {
 602         print $fg "chld $$chainload_ref[0]\n";
 603     } else {
 604         my $first = 1;
 605         my ($kbin, $kcmd);
 606         foreach (@$modules_ref) {
 607             if ($first) {
 608                 $first = 0;
 609                 ($kbin, $kcmd) = split(' ', $_, 2);
 610                 $kcmd = '' if !defined $kcmd;
 611             } else {
 612                 my @args = split;
 613                 s|\brom://|$rom_prefix|g;
 614                 print $fg "load $_\n";
 615             }
 616         }
 617         # Put kernel as last - this is needed for booting Linux and has no influence on non-Linux OSes
 618         print $fg "exec $kbin $kcmd\n";
 619     }
 620     close($fg);
 621     print("novaboot: Created $builddir/$filename\n");
 622     return $filename;
 623 }
 624
 625 sub shell_cmd_string(@)
 626 {
 627     if (scalar(@_) == 1) {
 628         return $_[0];
 629     } else {
 630         return join(' ', map((/^[-_=a-zA-Z0-9\/\.\+]+$/ ? "$_" : "'$_'"), @_));
 631     }
 632 }
 633
 634 sub exec_verbose(@)
 635 {
 636     print STDERR "novaboot: Running: ".shell_cmd_string(@_)."\n";
 637     exec(@_);
 638     exit(1); # should not be reached
 639 }
 640
 641 sub system_verbose
 642 {
 643     print STDERR "novaboot: Running: ".shell_cmd_string(@_)."\n";
 644     my $ret = system(@_);
 645     if ($ret & 0x007f) { die("Command terminated by a signal"); }
 646     if ($ret & 0xff00) {die("Command exit with non-zero exit code"); }
 647     if ($ret) { die("Command failure $ret"); }
 648 }
 649
 650 sub trim($) {
 651     my ($str) = @_;
 652     $str =~ s/^\s+|\s+$//g;
 653     return $str
 654 }
 655
 656 ## WvTest headline
 657
 658 if (exists $variables->{WVDESC}) {
 659     print STDERR "Testing \"$variables->{WVDESC}\" in $last_fn:\n";
 660 } elsif ($last_fn =~ /\.wv$/) {
 661     print STDERR "Testing \"all\" in $last_fn:\n";
 662 }
 663
 664 ## Connect to the target and check whether it is not occupied
 665
 666 # We have to do this before file generation phase, because file
 667 # generation is intermixed with file deployment phase and we want to
 668 # check whether the target is not used by somebody else before
 669 # deploying files. Otherwise, we may rewrite other user's files on a
 670 # boot server.
 671
 672 my $exp; # Expect object to communicate with the target over serial line
 673
 674 sub kill_exp_on_signal() {
 675     # Sometimes, under unclear circumstances (e.g. when running under
 676     # both Jenkins and Robotframework), novaboot does not terminate
 677     # console command when killed. The console is then blocked by the
 678     # stale process forever. Theoretically, this should not happen,
 679     # because when novaboot is killed, console command's controlling
 680     # terminal sends SIGHUP to the console command and the command
 681     # should terminate. It seems that at least SSH sometimes ignores
 682     # HUP and does not terminate. The code below seems to work around
 683     # that problem by killing the process immediately with SIGTERM,
 684     # which is not ignored.
 685
 686     sub kill_console { kill TERM => $exp->pid if $exp->pid; die "Terminated by SIG$_[0]"; };
 687
 688     # For our Jenkins/Robotframework use case, it was sufficient to
 689     # handle the TERM signal, but to be on the safe side, we also
 690     # catch other signals.
 691     $SIG{TERM} = \&kill_console;
 692     $SIG{HUP} = \&kill_console;
 693     $SIG{INT} = \&kill_console;
 694     $SIG{QUIT} = \&kill_console;
 695 }
 696
 697
 698 my ($amt_user, $amt_password, $amt_host, $amt_port);
 699
 700 if (defined $iprelay || defined $iprelay_cmd) {
 701     if (defined $iprelay) {
 702         my $IPRELAY;
 703         $iprelay =~ /([.0-9]+)(:([0-9]+))?/;
 704         my $addr = $1;
 705         my $port = $3 || 23;
 706         my $paddr   = sockaddr_in($port, inet_aton($addr));
 707         my $proto   = getprotobyname('tcp');
 708         socket($IPRELAY, PF_INET, SOCK_STREAM, $proto)  || die "socket: $!";
 709         print STDERR "novaboot: Connecting to IP relay... ";
 710         connect($IPRELAY, $paddr)    || die "connect: $!";
 711         print STDERR "done\n";
 712         $exp = Expect->init(\*$IPRELAY);
 713         $exp->log_stdout(1);
 714     }
 715     if (defined $iprelay_cmd) {
 716         print STDERR "novaboot: Running: $iprelay_cmd\n";
 717         $exp = new Expect;
 718         $exp->raw_pty(1);
 719         $exp->spawn($iprelay_cmd);
 720         kill_exp_on_signal();
 721     }
 722
 723     while (1) {
 724         print $exp "\xFF\xF6";  # AYT
 725         my $connected = $exp->expect(20, # Timeout in seconds
 726                                      '<iprelayd: connected>',
 727                                      '-re', '<WEB51 HW[^>]*>')
 728             || die "iprelay connection: " . ($! || "timeout");
 729         last if $connected;
 730     }
 731
 732     sub relaycmd($$) {
 733         my ($relay, $onoff) = @_;
 734         die unless ($relay == 1 || $relay == 2);
 735
 736         my $cmd = ($relay == 1 ? 0x5 : 0x6) | ($onoff ? 0x20 : 0x10);
 737         return "\xFF\xFA\x2C\x32".chr($cmd)."\xFF\xF0";
 738     }
 739
 740     sub relayconf($$) {
 741         my ($relay, $onoff) = @_;
 742         die unless ($relay == 1 || $relay == 2);
 743         my $cmd = ($relay == 1 ? 0xdf : 0xbf) | ($onoff ? 0x00 : 0xff);
 744         return "\xFF\xFA\x2C\x97".chr($cmd)."\xFF\xF0";
 745     }
 746
 747     sub relay($$;$) {
 748         my ($relay, $onoff, $can_giveup) = @_;
 749         my $confirmation = '';
 750         $exp->log_stdout(0);
 751         print $exp relaycmd($relay, $onoff);
 752         my $confirmed = $exp->expect(20, # Timeout in seconds
 753                                      relayconf($relay, $onoff))
 754             || die "iprelay command: " . ($! || "timeout");
 755         if (!$confirmed) {
 756             if ($can_giveup) {
 757                 print("Relay confirmation timeout - ignoring\n");
 758             } else {
 759                 die "Relay confirmation timeout";
 760             }
 761         }
 762         $exp->log_stdout(1);
 763     }
 764
 765     $target_reset = sub {
 766         relay(2, 1, 1); # Reset the machine
 767         usleep(100000);
 768         relay(2, 0);
 769     };
 770
 771     $target_power_off = sub {
 772         relay(1, 1);            # Press power button
 773         usleep(6000000);        # Long press to switch off
 774         relay(1, 0);
 775     };
 776
 777     $target_power_on = sub {
 778         relay(1, 1);            # Press power button
 779         usleep(100000);         # Short press
 780         relay(1, 0);
 781     };
 782 }
 783 elsif ($serial) {
 784     my $CONN;
 785     system_verbose("stty -F $serial $stty");
 786     open($CONN, "+<", $serial) || die "open $serial: $!";
 787     $exp = Expect->init(\*$CONN);
 788 }
 789 elsif (@remote_cmd) {
 790     print STDERR "novaboot: Running: ".shell_cmd_string(@remote_cmd)."\n";
 791     $exp = Expect->spawn(@remote_cmd);
 792     kill_exp_on_signal();
 793 }
 794 elsif (defined $amt) {
 795     require LWP::UserAgent;
 796     require LWP::Authen::Digest;
 797
 798     sub genXML {
 799         my ($host, $username, $password, $schema, $className, $pstate) = @_;
 800         #AMT numbers for PowerStateChange (MNI => bluescreen on windows;-)
 801         my %pstates = ("on"        => 2,
 802                        "standby"   => 4,
 803                        "hibernate" => 7,
 804                        "off"       => 8,
 805                        "reset"     => 10,
 806                        "MNI"       => 11);
 807         return <<END;
 808                 <s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:w="http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd">
 809                 <s:Header><a:To>http://$host:16992/wsman</a:To>
 810                 <w:ResourceURI s:mustUnderstand="true">$schema</w:ResourceURI>
 811                 <a:ReplyTo><a:Address s:mustUnderstand="true">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address></a:ReplyTo>
 812                 <a:Action s:mustUnderstand="true">$schema$className</a:Action>
 813                 <w:MaxEnvelopeSize s:mustUnderstand="true">153600</w:MaxEnvelopeSize>
 814                 <a:MessageID>uuid:709072C9-609C-4B43-B301-075004043C7C</a:MessageID>
 815                 <w:Locale xml:lang="en-US" s:mustUnderstand="false" />
 816                 <w:OperationTimeout>PT60.000S</w:OperationTimeout>
 817                 <w:SelectorSet><w:Selector Name="Name">Intel(r) AMT Power Management Service</w:Selector></w:SelectorSet>
 818                 </s:Header><s:Body>
 819                 <p:RequestPowerStateChange_INPUT xmlns:p="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PowerManagementService">
 820                 <p:PowerState>$pstates{$pstate}</p:PowerState>
 821                 <p:ManagedElement><a:Address>http://$host:16992/wsman</a:Address>
 822                 <a:ReferenceParameters><w:ResourceURI>http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem</w:ResourceURI>
 823                 <w:SelectorSet><w:Selector Name="Name">ManagedSystem</w:Selector></w:SelectorSet>
 824                 </a:ReferenceParameters></p:ManagedElement>
 825                 </p:RequestPowerStateChange_INPUT>
 826                 </s:Body></s:Envelope>
 827 END
 828     }
 829
 830     sub sendPOST {
 831         my ($host, $username, $password, $content) = @_;
 832
 833         my $ua = LWP::UserAgent->new();
 834         $ua->agent("novaboot");
 835
 836         my $req = HTTP::Request->new(POST => "http://$host:16992/wsman");
 837         my $res = $ua->request($req);
 838         die ("Unexpected AMT response: " . $res->status_line) unless $res->code == 401;
 839
 840         my ($realm) = $res->header("WWW-Authenticate") =~ /Digest realm="(.*?)"/;
 841         $ua->credentials("$host:16992", $realm, $username => $password);
 842
 843         # Create a request
 844         $req = HTTP::Request->new(POST => "http://$host:16992/wsman");
 845         $req->content_type('application/x-www-form-urlencoded');
 846         $req->content($content);
 847         $res = $ua->request($req);
 848         die ("AMT power change request failed: " . $res->status_line) unless $res->is_success;
 849         $res->content() =~ /<g:ReturnValue>(\d+)<\/g:ReturnValue>/;
 850         return $1;
 851     }
 852
 853     sub powerChange  {
 854         my ($host, $username, $password, $pstate)=@_;
 855         my $schema="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PowerManagementService";
 856         my $className="/RequestPowerStateChange";
 857         my $content = genXML($host, $username, $password ,$schema, $className, $pstate);
 858         return sendPOST($host, $username, $password, $content);
 859     }
 860
 861     ($amt_user,$amt_password,$amt_host,$amt_port) = ($amt =~ /(?:(.*?)(?::(.*))?@)?([^:]*)(?::([0-9]*))?/);;
 862     $amt_user ||= "admin";
 863     $amt_password ||= $ENV{'AMT_PASSWORD'} || die "AMT password not specified";
 864     $amt_host || die "AMT host not specified";
 865     $amt_port ||= 16994;
 866
 867
 868     $target_power_off = sub {
 869         $exp->close();
 870         my $result = powerChange($amt_host,$amt_user,$amt_password, "off");
 871         die "AMT power off failed (ReturnValue $result)" if $result != 0;
 872     };
 873
 874     $target_power_on = sub {
 875         my $result = powerChange($amt_host,$amt_user,$amt_password, "on");
 876         die "AMT power on failed (ReturnValue $result)" if $result != 0;
 877     };
 878
 879     $target_reset = sub {
 880         my $result = powerChange($amt_host,$amt_user,$amt_password, "reset");
 881         if ($result != 0) {
 882             print STDERR "Warning: Cannot reset $amt_host, trying power on. ";
 883             $result = powerChange($amt_host,$amt_user,$amt_password, "on");
 884         }
 885         die "AMT reset failed (ReturnValue $result)" if $result != 0;
 886     };
 887
 888     my $cmd = "amtterm -u $amt_user -p $amt_password $amt_host $amt_port";
 889     print STDERR "novaboot: Running: $cmd\n" =~ s/\Q$amt_password\E/???/r;
 890     $exp = Expect->spawn($cmd);
 891     $exp->expect(10, "RUN_SOL") || die "Expect for 'RUN_SOL': " . ($! || "timeout");
 892 }
 893
 894
 895 if ($remote_expect) {
 896     $exp || die("No serial line connection");
 897     my $log = $exp->log_stdout;
 898     if (defined $remote_expect_silent) {
 899         $exp->log_stdout(0);
 900     }
 901     $exp->expect($remote_expect_timeout >= 0 ? $remote_expect_timeout : undef,
 902                  $remote_expect) || die "Expect for '$remote_expect':" . ($! || "timeout");;
 903     if (defined $remote_expect_silent) {
 904         $exp->log_stdout($log);
 905         print $exp->after() if $log;
 906     }
 907 }
 908
 909 if (@reset_cmd) {
 910     $target_reset = sub {
 911         system_verbose(@reset_cmd);
 912     };
 913 }
 914
 915 if (defined $reset_send) {
 916     $target_reset = sub {
 917         $reset_send =~ s/\\n/\n/g;
 918         $exp->send($reset_send);
 919     };
 920 }
 921
 922 if (defined $on_opt && defined $target_power_on) {
 923     &$target_power_on();
 924     exit;
 925 }
 926 if (defined $off_opt && defined $target_power_off) {
 927     print STDERR "novaboot: Switching the target off...\n";
 928     &$target_power_off();
 929     exit;
 930 }
 931
 932 $builddir ||= dirname(File::Spec->rel2abs( ${$scripts[0]}{filename})) if scalar @scripts;
 933 if (defined $builddir) {
 934     chdir($builddir) or die "Can't change directory to $builddir: $!";
 935     print STDERR "novaboot: Entering directory `$builddir'\n";
 936 } else {
 937     $builddir = $invocation_dir;
 938 }
 939
 940 ## File generation phase
 941 my (%files_iso, $menu_iso, $filename);
 942 my $config_name = '';
 943 my $prefix = '';
 944
 945 foreach my $script (@scripts) {
 946     $filename = $$script{filename};
 947     $modules = $$script{modules};
 948     $generated = $$script{generated};
 949     $variables = $$script{variables};
 950
 951     ($config_name = $filename) =~ s#.*/##;
 952     $config_name = $config_name_opt if (defined $config_name_opt);
 953
 954     if (exists $variables->{BUILDDIR}) {
 955         $builddir = File::Spec->rel2abs($variables->{BUILDDIR});
 956         chdir($builddir) or die "Can't change directory to $builddir: $!";
 957         print STDERR "novaboot: Entering directory `$builddir'\n";
 958     }
 959
 960     if ($grub_prefix) {
 961         $prefix = $grub_prefix;
 962         $prefix =~ s/\$NAME/$config_name/;
 963         $prefix =~ s/\$BUILDDIR/$builddir/;
 964     }
 965     # TODO: use $grub_prefix as first parameter if some switch is given
 966     generate_configs('', $generated, $filename);
 967
 968 ### Generate bootloader configuration files
 969     my @bootloader_configs;
 970     push @bootloader_configs, generate_grub_config($grub_config, $config_name, $prefix, $modules, $grub_preamble) if (defined $grub_config);
 971     push @bootloader_configs, generate_grub2_config($grub2_config, $config_name, $prefix, $modules, $grub_preamble, $grub2_prolog) if (defined $grub2_config);
 972     push @bootloader_configs, generate_pulsar_config('config-'.($pulsar||'novaboot'), $modules, $chainload) if (defined $pulsar);
 973
 974 ### Run scons or make
 975     {
 976         my @all;
 977         push @all, @$modules;
 978         push @all, @$copy;
 979         push @all, @$chainload;
 980         my @files = map({ ($file) = m/([^ ]*)/; $file; } @all);
 981
 982         # Filter-out generated files
 983         my @to_build = grep({ my $file = $_; !scalar(grep($file eq ($$_{filename} || ''), @$generated)) } @files);
 984
 985         system_verbose($scons || $CFG::scons." ".join(" ", @to_build)) if (defined $scons);
 986         system_verbose($make  || $CFG::make ." ".join(" ", @to_build)) if (defined $make);
 987     }
 988
 989 ### Copy files (using rsync)
 990     if (defined $server && !defined($gen_only)) {
 991         (my $real_server = $server) =~ s/\$NAME/$config_name/;
 992
 993         my ($hostname, $path) = split(":", $real_server, 2);
 994         if (! defined $path) {
 995             $path = $hostname;
 996             $hostname = "";
 997         }
 998         my $files = join(" ", map({ ($file) = m/([^ ]*)/; $file; } ( @$modules, @bootloader_configs, @$copy)));
 999         map({ my $file = (split)[0]; die "Not a file: $file: $!" if ! -e $file || -d $file; } @$modules);
1000         my $istty = -t STDOUT && ($ENV{'TERM'} || 'dumb') ne 'dumb';
1001         my $progress = $istty ? "--progress" : "";
1002         if ($files) {
1003             system_verbose("rsync $progress -RLp $rsync_flags $files $real_server");
1004             if ($server =~ m|/\$NAME$| && $concat) {
1005                 my $cmd = join("; ", map { "( cd $path/.. && cat */$_ > $_ )" } @bootloader_configs);
1006                 system_verbose($hostname ? "ssh $hostname '$cmd'" : $cmd);
1007             }
1008         }
1009     }
1010
1011 ### Prepare ISO image generation
1012     if (defined $iso_image) {
1013         generate_configs("(cd)", $generated, $filename);
1014         my $menu;
1015         generate_syslinux_config(\$menu, $config_name, "/", $modules);
1016         $menu_iso .= "$menu\n";
1017         map { ($file,undef) = split; $files_iso{$file} = 1; } @$modules;
1018     }
1019 }
1020
1021 ## Generate ISO image
1022 if (defined $iso_image) {
1023     system_verbose("mkdir -p isolinux");
1024
1025     my @files;
1026     if (-f '/usr/lib/ISOLINUX/isolinux.bin') {
1027         # Newer ISOLINUX version
1028         @files = qw(/usr/lib/ISOLINUX/isolinux.bin /usr/lib/syslinux/modules/bios/mboot.c32 /usr/lib/syslinux/modules/bios/libcom32.c32 /usr/lib/syslinux/modules/bios/menu.c32 /usr/lib/syslinux/modules/bios/ldlinux.c32);
1029     } else {
1030         # Older ISOLINUX version
1031         @files = qw(/usr/lib/syslinux/isolinux.bin /usr/lib/syslinux/mboot.c32 /usr/lib/syslinux/menu.c32);
1032     }
1033     system_verbose("cp @files isolinux");
1034     open(my $fh, ">isolinux/isolinux.cfg");
1035     if ($#scripts) {
1036         print $fh "TIMEOUT 50\n";
1037         print $fh "DEFAULT menu\n";
1038     } else {
1039         print $fh "DEFAULT $config_name\n";
1040     }
1041     print $fh "$menu_iso";
1042     close($fh);
1043
1044     my $files = join(" ", map("$_=$_", (keys(%files_iso), 'isolinux/isolinux.cfg', map(s|.*/|isolinux/|r, @files))));
1045     $iso_image ||= "$config_name.iso";
1046
1047     # Note: We use -U flag below to "Allow 'untranslated' filenames,
1048     # completely violating the ISO9660 standards". Without this
1049     # option, isolinux is not able to read files names for example
1050     # bzImage-3.0.
1051     system_verbose("$CFG::genisoimage -R -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -hide-rr-moved -U -o $iso_image -graft-points $files");
1052     print("ISO image created: $builddir/$iso_image\n");
1053 }
1054
1055 exit(0) if defined $gen_only;
1056
1057 ## Boot the system using various methods and send serial output to stdout
1058
1059 if (scalar(@scripts) > 1 && ( defined $dhcp_tftp || defined $serial || defined $iprelay)) {
1060     die "You cannot do this with multiple scripts simultaneously";
1061 }
1062
1063 if ($variables->{WVTEST_TIMEOUT}) {
1064     print STDERR "wvtest: timeout ", $variables->{WVTEST_TIMEOUT}, "\n";
1065 }
1066
1067 ### Start in Qemu
1068
1069 if (defined $qemu) {
1070     # Qemu
1071     $qemu ||= $variables->{QEMU} || $CFG::qemu;
1072     my @qemu_flags = split(" ", $qemu);
1073     $qemu = shift(@qemu_flags);
1074
1075     @qemu_flags = split(/ +/, trim($variables->{QEMU_FLAGS})) if exists $variables->{QEMU_FLAGS};
1076     @qemu_flags = split(/ +/, trim($qemu_flags_cmd)) if $qemu_flags_cmd;
1077     push(@qemu_flags, split(/ +/, trim($qemu_append || '')));
1078
1079     if (defined $iso_image) {
1080         # Boot NOVA with grub (and test the iso image)
1081         push(@qemu_flags, ('-cdrom', $iso_image));
1082     } else {
1083         # Boot NOVA without GRUB
1084
1085         # Non-patched qemu doesn't like commas, but NUL can live with pluses instead of commans
1086         foreach (@$modules) {s/,/+/g;}
1087         generate_configs("", $generated, $filename);
1088
1089         if (scalar @$modules) {
1090             my ($kbin, $kcmd) = split(' ', shift(@$modules), 2);
1091             $kcmd = '' if !defined $kcmd;
1092             my $dtb;
1093             @$modules = map { if (/\.dtb$/) { $dtb=$_; (); } else { $_ } } @$modules;
1094             my $initrd = join ",", @$modules;
1095
1096             push(@qemu_flags, ('-kernel', $kbin, '-append', $kcmd));
1097             push(@qemu_flags, ('-initrd', $initrd)) if $initrd;
1098             push(@qemu_flags, ('-dtb', $dtb)) if $dtb;
1099         }
1100     }
1101     if (!grep /^-serial$/, @qemu_flags) {
1102         push(@qemu_flags,  qw(-serial stdio)); # Redirect serial output (for collecting test restuls)
1103     }
1104     unshift(@qemu_flags, ('-name', $config_name));
1105     print STDERR "novaboot: Running: ".shell_cmd_string($qemu, @qemu_flags)."\n";
1106     $exp = Expect->spawn(($qemu, @qemu_flags)) || die("exec() failed: $!");
1107 }
1108
1109 ### Local DHCPD and TFTPD
1110
1111 my ($dhcpd_pid, $tftpd_pid);
1112
1113 $tftp=1 if $tftp_port;
1114
1115 if (defined $dhcp_tftp)
1116 {
1117     generate_configs("(nd)", $generated, $filename);
1118     system_verbose('mkdir -p tftpboot');
1119     generate_grub_config("tftpboot/os-menu.lst", $config_name, "(nd)", \@$modules, "timeout 0");
1120     open(my $fh, '>', 'dhcpd.conf');
1121     my $mac = `cat /sys/class/net/$netif/address`;
1122     chomp $mac;
1123     print $fh "subnet 10.23.23.0 netmask 255.255.255.0 {
1124                       range 10.23.23.10 10.23.23.100;
1125                       filename \"bin/boot/grub/pxegrub.pxe\";
1126                       next-server 10.23.23.1;
1127 }
1128 host server {
1129         hardware ethernet $mac;
1130         fixed-address 10.23.23.1;
1131 }";
1132     close($fh);
1133     system_verbose("sudo ip a add 10.23.23.1/24 dev $netif;
1134             sudo ip l set dev $netif up;
1135             sudo touch dhcpd.leases");
1136
1137     # We run servers by forking ourselves, because the servers end up
1138     # in our process group and get killed by signals sent to the
1139     # process group (e.g. Ctrl-C on terminal).
1140     $dhcpd_pid = fork();
1141     exec_verbose("sudo dhcpd -d -cf dhcpd.conf -lf dhcpd.leases -pf dhcpd.pid") if ($dhcpd_pid == 0);
1142 }
1143
1144 if (defined $dhcp_tftp || defined $tftp) {
1145     $tftp_port ||= 69;
1146     # Unfortunately, tftpd requires root privileges even with
1147     # non-privileged (>1023) port due to initgroups().
1148     system_verbose("sudo in.tftpd --listen --secure -v -v -v --pidfile tftpd.pid  --address :$tftp_port $builddir");
1149
1150     # Kill server when we die
1151     $SIG{__DIE__} = sub { system_verbose('sudo pkill --pidfile=dhcpd.pid') if (defined $dhcp_tftp);
1152                           system_verbose('sudo pkill --pidfile=tftpd.pid'); };
1153
1154     # We have to kill tftpd explicitely, because it is not in our process group
1155     $SIG{INT} = sub { system_verbose('sudo pkill --pidfile=tftpd.pid'); exit(0); };
1156 }
1157
1158 ### AMT IDE-R
1159 if (defined $ider) {
1160     my $ider_cmd= "amtider -c $iso_image -u $amt_user -p $amt_password $amt_host $amt_port"  ;
1161     print STDERR "novaboot: Running: $ider_cmd\n" =~ s/\Q$amt_password\E/???/r;
1162     my $ider_pid = fork();
1163     if ($ider_pid == 0) {
1164         exec($ider_cmd);
1165         die "IDE redirection failed";
1166     }
1167     # FIXME: This collides with --tftp option. Hopefully, nobody needs
1168     # to use both simultaneously.
1169     $SIG{__DIE__} = sub { system_verbose('kill $ider_pid'); };
1170 }
1171
1172 ### Reset target (IP relay, AMT, ...)
1173
1174 if (defined $target_reset && $reset) {
1175     print STDERR "novaboot: Resetting the test box... ";
1176     &$target_reset();
1177     print STDERR "done\n";
1178     if (defined $exp) {
1179         # We don't want to output anything printed by the target
1180         # before reset so we clear the buffers now. This is, however,
1181         # not ideal because we may loose some data that were sent
1182         # after the reset. If this is a problem, one should reset and
1183         # connect to serial line in atomic manner. For example, if
1184         # supported by hardware, use --remote-cmd 'sterm -d ...' and
1185         # do not use separate --reset-cmd.
1186         my $log = $exp->log_stdout;
1187         $exp->log_stdout(0);
1188         $exp->expect(0); # Read data from target
1189         $exp->clear_accum();    # Clear the read data
1190         $exp->log_stdout($log);
1191     }
1192 }
1193
1194 ### U-boot conversation
1195 if (defined $uboot) {
1196     my $uboot_prompt = $uboot || '=> ';
1197     print STDERR "novaboot: Waiting for U-Boot prompt...\n";
1198     $exp || die("No serial line connection");
1199     $exp->log_stdout(1);
1200     #$exp->exp_internal(1);
1201     $exp->expect(20,
1202                  [qr/Hit any key to stop autoboot:/, sub {
1203                      $exp->send($uboot_stop_key // "\n");
1204                      exp_continue; }],
1205                  $uboot_prompt) || die "No U-Boot prompt deteceted";
1206     foreach my $cmdspec (@uboot_init) {
1207         my ($cmd, $timeout);
1208         die "Internal error - please report a bug" unless ref($cmdspec) eq "HASH";
1209
1210         if ($cmdspec->{system}) {
1211             $cmd = `$cmdspec->{system}`;
1212         } else {
1213             $cmd = $cmdspec->{command};
1214         }
1215         $timeout = $cmdspec->{timeout} // 10;
1216
1217         if ($cmd =~ /\$NB_MYIP/) {
1218             my $ip = (grep /inet /, `ip addr show $netif`)[0] || die "Problem determining IP address of $netif";
1219             $ip =~ s/\s*inet ([0-9.]*).*/$1/;
1220             $cmd =~ s/\$NB_MYIP/$ip/g;
1221         }
1222         if ($cmd =~ /\$NB_PREFIX/) {
1223             my $p = $prefix;
1224             $p =~ s|/*$||;
1225             $cmd =~ s/\$NB_PREFIX/$p/g;
1226         }
1227         chomp($cmd);
1228         $exp->send("$cmd\n");
1229
1230         my ($matched_pattern_position, $error,
1231             $successfully_matching_string,
1232             $before_match, $after_match) =
1233                 $exp->expect($timeout, $uboot_prompt);
1234         die "No U-Boot prompt: $error" if $error;
1235
1236         if ($cmdspec->{dest}) {
1237             open(my $fh, ">", $cmdspec->{dest}) or die "Cannot open '$cmdspec->{dest}': $!";
1238             print $fh $before_match;
1239             close($fh);
1240         }
1241     }
1242
1243     # Load files if there are some load lines in the script
1244     if (scalar(@$modules) > 0  && !$variables->{NO_BOOT}) {
1245         my ($kbin, $kcmd) = split(' ', shift(@$modules), 2);
1246         my $dtb;
1247         @$modules = map { if (/\.dtb$/) { $dtb=$_; (); } else { $_ } } @$modules;
1248         my $initrd = shift @$modules;
1249
1250         if (defined $kbin && $kbin ne '/dev/null') {
1251             die "No '--uboot-addr kernel' given" unless $uboot_addr{kernel};
1252             $exp->send("tftpboot $uboot_addr{kernel} $prefix$kbin\n");
1253             $exp->expect(15,
1254                          [qr/##/, sub { exp_continue; }],
1255                          $uboot_prompt) || die "Kernel load: " . ($! || "timeout");
1256         }
1257         if (defined $dtb) {
1258             die "No '--uboot-addr fdt' given" unless $uboot_addr{fdt};
1259             $exp->send("tftpboot $uboot_addr{fdt} $prefix$dtb\n");
1260             $exp->expect(15,
1261                          [qr/##/, sub { exp_continue; }],
1262                          $uboot_prompt) || die "Device tree load: " . ($! || "timeout");
1263         } else  {
1264             $uboot_addr{fdt} = '';
1265         }
1266         if (defined $initrd) {
1267             die "No '--uboot-addr ramdisk' given" unless $uboot_addr{ramdisk};
1268             $exp->send("tftpboot $uboot_addr{ramdisk} $prefix$initrd\n");
1269             $exp->expect(15,
1270                          [qr/##/, sub { exp_continue; }],
1271                          $uboot_prompt) || die "Initrd load: " . ($! || "timeout");
1272         } else {
1273             $uboot_addr{ramdisk} = '-';
1274         }
1275
1276         $kcmd //= '';
1277         $exp->send("setenv bootargs $kcmd\n");
1278         $exp->expect(5, $uboot_prompt)  || die "U-Boot prompt: " . ($! || "timeout");
1279
1280     }
1281     $uboot_cmd //= $variables->{UBOOT_CMD} // 'bootm $kernel_addr $ramdisk_addr $fdt_addr';
1282     if (!$variables->{NO_BOOT} && $uboot_cmd ne '') {
1283         $uboot_cmd =~ s/\$kernel_addr/$uboot_addr{kernel}/g;
1284         $uboot_cmd =~ s/\$ramdisk_addr/$uboot_addr{ramdisk}/g;
1285         $uboot_cmd =~ s/\$fdt_addr/$uboot_addr{fdt}/g;
1286
1287         $exp->send($uboot_cmd . "\n");
1288         $exp->expect(5, "\n")  || die "U-Boot command: " . ($! || "timeout");
1289     }
1290 }
1291
1292 ### Serial line interaction
1293 if ($interaction && defined $exp) {
1294     # Serial line of the target is available
1295     my $interrupt = 'Ctrl-C';
1296     if ($interactive && !@exiton) {
1297         $interrupt = '"~~."';
1298     }
1299     print STDERR "novaboot: Serial line interaction (press $interrupt to interrupt)...\n";
1300     $exp->log_stdout(1);
1301     if (@exiton) {
1302         $exp->expect($exiton_timeout, @expect_raw, @exiton) || die("exiton: " . ($! || "timeout"));
1303     } else {
1304         my @inputs = ($exp);
1305         my $infile = new IO::File;
1306         $infile->IO::File::fdopen(*STDIN,'r');
1307         my $in_object = Expect->exp_init($infile);
1308         $in_object->set_group($exp);
1309
1310         if ($interactive) {
1311             $in_object->set_seq('~~\.', sub { print STDERR "novaboot: Escape sequence detected\r\n"; undef; });
1312             $in_object->manual_stty(0);   # Use raw terminal mode
1313         } else {
1314             $in_object->manual_stty(1);   # Do not modify terminal settings
1315         }
1316         push(@inputs, $in_object);
1317         #use Data::Dumper;
1318         #print Dumper(\@expect_raw);
1319         $exp->expect(undef, @expect_raw) if @expect_raw;
1320
1321         $^W = 0; # Suppress Expect warning: handle id(3) is not a tty. Not changing mode at /usr/share/perl5/Expect.pm line 393, <> line 8.
1322         Expect::interconnect(@inputs) unless defined($exp->exitstatus);
1323         $^W = 1;
1324     }
1325 }
1326
1327 # When exp-spawned command ignores SIGHUP, Expect waits 5 seconds
1328 # before killing it. We kill it by SIGTERM immediately.
1329 kill TERM => $exp->pid if defined $exp && $exp->pid;
1330
1331 ## Kill dhcpc or tftpd
1332 if (defined $dhcp_tftp || defined $tftp) {
1333     die("novaboot: This should kill servers on background\n");
1334 }
1335
1336 # Always finish novaboot output with newline
1337 print "\n" if $final_eol;
1338
1339 ## Documentation
1340
1341 =encoding utf8
1342
1343 =head1 NAME
1344
1345 novaboot - Boots a locally compiled operating system on a remote
1346 target or in qemu
1347
1348 =head1 SYNOPSIS
1349
1350 B<novaboot> --help
1351
1352 B<novaboot> [option]... [--] script...
1353
1354 B<./script> [option]...
1355
1356 =head1 DESCRIPTION
1357
1358 Novaboot makes booting of a locally compiled operating system (OS)
1359 (e.g. NOVA or Linux) on remote targets as simple as running a program
1360 locally. It automates things like copying OS images to a TFTP server,
1361 generation of bootloader configuration files, resetting of target
1362 hardware or redirection of target's serial line to stdin/out. Novaboot
1363 is highly configurable and makes it easy to boot a single image on
1364 different targets or different images on a single target.
1365
1366 Novaboot operation is controlled by configuration files, command line
1367 options and by a so-called novaboot script, which can be thought as a
1368 generalization of bootloader configuration files (see L</"NOVABOOT
1369 SCRIPT SYNTAX">). The typical way of using novaboot is to make the
1370 novaboot script executable and set its first line to I<#!/usr/bin/env
1371 novaboot>. Then, booting a particular OS configuration becomes the
1372 same as executing a local program – the novaboot script.
1373
1374 Novaboot uses configuration files to, among other things, define
1375 command line options needed for different targets. Users typically use
1376 only the B<-t>/B<--target> command line option to select the target.
1377 Internally, this option expands to the pre-configured options.
1378 Novaboot searches configuration files at multiple places, which allows
1379 having per-system, per-user or per-project configurations.
1380 Configuration file syntax is described in section L</"CONFIGURATION
1381 FILES">.
1382
1383 Novaboot newcomers may be confused by a large number of configuration
1384 options. Understanding all these options is not always needed,
1385 depending on the used setup. The L<figure from the doc directory
1386 |https://github.com/wentasah/novaboot/blob/master/doc/typical-setups.svg>
1387 shows different setups that vary in how much effort is needed
1388 configure novaboot for them. The setups are:
1389
1390 =over 3
1391
1392 =item A: Laptop and target device only
1393
1394 This requires to configure everything on the laptop side, including a
1395 serial line connection (L</--serial>, L</--remote-cmd>, ...), power
1396 on/off/reset commands (L</--reset-cmd>, ...), TFTP server
1397 (L</--server>, L</--prefix>...), device IP addresses, etc.
1398
1399 =item B: Laptop, target device and external TFTP server
1400
1401 Like the previous setup, but the TFTP (and maybe DHCP) configuration
1402 is handled by a server. Novaboot users need to understand where to
1403 copy their files to the TFTP server (L</--server>) and which IP
1404 addresses their target will get, but do not need to configure the
1405 servers themselves.
1406
1407 =item C: Novaboot server running novaboot-shell
1408
1409 With this setup, the configuration is done on the server. Users only
1410 need to know the SSH account (L</--ssh>) used to communicate between
1411 novaboot and novaboot server. The server is implemented as a
1412 restricted shell (L<novaboot-shell(1)>) on the server. No need to give
1413 full shell access to novaboot users on the server.
1414
1415 =back
1416
1417 =head2 Simple examples of using C<novaboot>:
1418
1419 To boot Linux (files F<bzImage> and F<rootfs.cpio> in current
1420 directory), create F<mylinux> file with this content:
1421
1422     #!/usr/bin/env novaboot
1423     load bzImage console=ttyS0,115200
1424     load rootfs.cpio
1425
1426 =over 3
1427
1428 =item 1.
1429
1430 Booting an OS in Qemu can be accomplished by giving the B<--qemu> option.
1431 Thus running
1432
1433  novaboot --qemu mylinux
1434
1435 (or C<./mylinux --qemu> as described above) will run Qemu and make it
1436 boot the configuration specified in the F<mylinux> script. How is qemu
1437 started can be configured in various ways (see below).
1438
1439 =item 2.
1440
1441 Create a bootloader configuration file (currently supported
1442 bootloaders are GRUB, GRUB2, ISOLINUX, Pulsar, and U-Boot) and copy it
1443 with all other files needed for booting to a remote TFTP server. Then
1444 use a TCP/IP-controlled relay/serial-to-TCP converter to reset the
1445 target and receive its serial output.
1446
1447  ./mylinux --grub2 --server=192.168.1.1:/tftp --iprelay=192.168.1.2
1448
1449 Alternatively, you can put these switches to the configuration file
1450 and run:
1451
1452  ./mylinux --target mytarget
1453
1454 =item 3.
1455
1456 Specifying all the options needed by novaboot to successfully control
1457 the target, either on command line or in configuration files, can be
1458 difficult for users. Novaboot supports configuring the target
1459 centrally via L<novaboot-shell(1)> on a server. With such a
1460 configuration, users only need to use the B<--ssh> option to specify
1461 where to boot their OS:
1462
1463  ./mylinux --ssh myboard@example.com
1464
1465 Typically, the server is the computer connected to and controlling the
1466 target board and running the TFTP server.
1467
1468 =item 4.
1469
1470 Run DHCP and TFTP server on developer's machine to boot the target
1471 from it.
1472
1473  ./mylinux --dhcp-tftp
1474
1475 This usage is useful when no network infrastructure is in place, and
1476 the target is connected directly to developer's box.
1477
1478 =item 5.
1479
1480 Create bootable ISO image.
1481
1482  novaboot --iso -- script1 script2
1483
1484 The created ISO image will have ISOLINUX bootloader installed on it,
1485 and the boot menu will allow selecting between I<script1> and
1486 I<script2> configurations.
1487
1488 =back
1489
1490 =head1 OPTIONS AND PHASES
1491
1492 Novaboot performs its work in several phases. Command line options
1493 described bellow influence the execution of each phase or allow their
1494 skipping. The list of phases (in the execution order) is as follows.
1495
1496 =over
1497
1498 =item 1. L<Configuration reading|/Configuration reading phase>
1499
1500 =item 2. L<Command line processing|/Command line processing phase>
1501
1502 =item 3. L<Script preprocessing|/Script preprocessing phase>
1503
1504 =item 4. L<File generation|/File generation phase>
1505
1506 =item 5. L<Target connection|/Target connection check>
1507
1508 =item 6. L<File deployment|/File deployment phase>
1509
1510 =item 7. L<Target power-on and reset|/Target power-on and reset phase>
1511
1512 =item 8. L<Interaction with the bootloader|/Interaction with the bootloader on the target>
1513
1514 =item 9. L<Target interaction|/Target interaction phase>
1515
1516 =back
1517
1518 Each phase is described in the following sections together with the
1519 command line options that control it.
1520
1521 =head2 Configuration reading phase
1522
1523 After starting, novaboot reads zero or more configuration files. We
1524 describe their content in section L</"CONFIGURATION FILES">. By default, the
1525 configuration is read from multiple locations. First from the system
1526 configuration directory (F</etc/novaboot.d/>), second from the user
1527 configuration file (F<~/.config/novaboot>) and third from F<.novaboot>
1528 files along the path to the current directory. Alternatively, a single
1529 configuration file specified with the B<-c> switch or with the
1530 C<NOVABOOT_CONFIG> environment variable is read. The latter read files
1531 override settings from the former ones.
1532
1533 The system configuration directory is determined by the content of
1534 NOVABOOT_CONFIG_DIR environment variable and defaults to
1535 F</etc/novaboot.d>. Files in this directory with names consisting
1536 solely of English letters, numbers, dashes '-' and underscores '_'
1537 (note that dot '.' is not included) are read in alphabetical order.
1538
1539 Then, the user configuration file is read from
1540 F<$XDG_CONFIG_HOME/novaboot>. If C<$XDG_CONFIG_HOME> environment
1541 variable is not set F<~/.config/novaboot> is read instead.
1542
1543 Finally, novaboot searches for files named F<.novaboot> starting from the
1544 directory of the novaboot script (or working directory, see bellow)
1545 and continuing upwards up to the root directory. The found
1546 configuration files are then read in the opposite order (i.e. from the
1547 root directory downwards). This ordering allows having, for example, a project
1548 specific configuration in F<~/project/.novaboot>.
1549
1550 Note the difference between F<~/.config/novaboot> and F<~/.novaboot>.
1551 The former one is always read, whereas the latter only when novaboot
1552 script or working directory is under the C<$HOME> directory.
1553
1554 In certain cases, the location of the novaboot script cannot be
1555 determined in this early phase. This situation happens either when the script is
1556 read from the standard input or when novaboot is invoked explicitly as
1557 in the example L</"4."> above. In this case, the current working
1558 directory is used as a starting point for configuration file search
1559 instead of the novaboot script directory.
1560
1561 =over 8
1562
1563 =item -c, --config=I<filename>
1564
1565 Use the specified configuration file instead of the default one(s).
1566
1567 =back
1568
1569 =head2 Command line processing phase
1570
1571 =over 8
1572
1573 =item --dump-config
1574
1575 Dump the current configuration to stdout end exit. Useful as an
1576 initial template for a configuration file.
1577
1578 =item -h, --help
1579
1580 Print short (B<-h>) or long (B<--help>) help.
1581
1582 =item -t, --target=I<target>
1583
1584 This option serves as a user configurable shortcut for other novaboot
1585 options. The effect of this option is the same as specifying the
1586 options stored in the C<%targets> configuration variable under key
1587 I<target>. See also L</"CONFIGURATION FILES">.
1588
1589 When this option is not given, novaboot tries to determine the target
1590 to use from either B<NOVABOOT_TARGET> environment variable or
1591 B<$default_target> configuration file variable.
1592
1593 =item --ssh=I<user@hostname>
1594
1595 Configures novaboot to control the target via C<novaboot-shell>
1596 running remotely via SSH.
1597
1598 Using this option is the same as specifying B<--remote-cmd>,
1599 B<--remote-expect>, B<--server> B<--rsync-flags>, B<--prefix> and
1600 B<--reset-cmd> manually in a way compatible with C<novaboot-shell>.
1601 The server can be configured to provide other, safe bootloader-related
1602 options, to the client. When this happens, novaboot prints them to
1603 stdout.
1604
1605 Currently, this in an initial experimental implementation. We plan to
1606 change/extend this feature soon!
1607
1608 =back
1609
1610 =head2 Script preprocessing phase
1611
1612 This phase allows modifying the parsed novaboot script before it is
1613 used in the later phases.
1614
1615 =over 8
1616
1617 =item -a, --append=I<parameters>
1618
1619 Append a string to the first C<load> line in the novaboot script. This option
1620 can be used to append parameters to the kernel's or root task's
1621 command line. This option can appear multiple times.
1622
1623 =item -b, --bender
1624
1625 Use L<Bender|https://github.com/TUD-OS/morbo/blob/master/standalone/bender.c>
1626 chainloader. Bender scans the PCI bus for PCI serial ports and stores
1627 the information about them in the BIOS data area for use by the
1628 kernel.
1629
1630 =item --chainloader=I<chainloader>
1631
1632 Specifies a chainloader that is loaded before the kernel and other
1633 files specified in the novaboot script. E.g. 'bin/boot/bender
1634 promisc'.
1635
1636 =item --dump
1637
1638 Print the modules to boot and their parameters, after this phase
1639 finishes. Then exit. This is useful for seeing the effect of other
1640 options in this section.
1641
1642 =item -k, --kernel=F<file>
1643
1644 Replace the first word on the first C<load> line in the novaboot
1645 script with F<file>.
1646
1647 =item --scriptmod=I<Perl expression>
1648
1649 When novaboot reads the script, I<Perl expression> is executed for every
1650 line (in $_ variable). For example, C<novaboot
1651 --scriptmod=s/sigma0/omega6/g> replaces every occurrence of I<sigma0>
1652 in the script with I<omega6>.
1653
1654 When this option is present, it overrides I<$script_modifier> variable
1655 from the configuration file, which has the same effect. If this option
1656 is given multiple times all expressions are evaluated in the command
1657 line order.
1658
1659 =back
1660
1661 =head2 File generation phase
1662
1663 In this phase, files needed for booting are generated in a so-called
1664 I<build directory> (see L</--build-dir>). In most cases configuration
1665 for a bootloader is generated automatically by novaboot. It is also
1666 possible to generate other files using I<heredoc> or I<"<"> syntax in
1667 novaboot scripts. Finally, novaboot can generate binaries in this phases by
1668 running C<scons> or C<make>.
1669
1670 =over 8
1671
1672 =item --build-dir=I<directory>
1673
1674 Overrides the default build directory location.
1675
1676 The default build directory location is determined as follows: If the
1677 configuration file defines the C<$builddir> variable, its value is
1678 used. Otherwise, it is the directory that contains the first processed
1679 novaboot script.
1680
1681 See also L</BUILDDIR> variable.
1682
1683 =item -g, --grub[=I<filename>]
1684
1685 Generates grub bootloader menu file. If the I<filename> is not
1686 specified, F<menu.lst> is used. The I<filename> is relative to the
1687 build directory (see B<--build-dir>).
1688
1689 =item --grub-preamble=I<prefix>
1690
1691 Specifies the I<preamble> that is at the beginning of the generated
1692 GRUB or GRUB2 config files. This is useful for specifying GRUB's
1693 timeout.
1694
1695 =item --prefix=I<prefix>
1696
1697 Specifies I<prefix> (e.g. F</srv/tftp>) that is put in front of every
1698 filename in generated bootloader configuration files (or in U-Boot
1699 commands).
1700
1701 If the I<prefix> contains string $NAME, it will be replaced with the
1702 name of the novaboot script (see also B<--name>).
1703
1704 If the I<prefix> contains string $BUILDDIR, it will be replaced with
1705 the build directory (see also B<--build-dir>).
1706
1707 =item --grub-prefix
1708
1709 Alias for B<--prefix>.
1710
1711 =item --grub2[=I<filename>]
1712
1713 Generate GRUB2 menu entry in I<filename>. If I<filename> is not
1714 specified F<grub.cfg> is used. The content of the menu entry can be
1715 customized with B<--grub-preamble>, B<--grub2-prolog> or
1716 B<--grub_prefix> options.
1717
1718 To use the generated menu entry on your development
1719 machine that uses GRUB2, append the following snippet to
1720 F</etc/grub.d/40_custom> file and regenerate your grub configuration,
1721 i.e. run update-grub on Debian/Ubuntu.
1722
1723   if [ -f /path/to/nul/build/grub.cfg ]; then
1724     source /path/to/nul/build/grub.cfg
1725   fi
1726
1727 =item --grub2-prolog=I<prolog>
1728
1729 Specifies the text that novaboot puts at the beginning of the GRUB2 menu entry.
1730
1731 =item -m, --make[=make command]
1732
1733 Runs C<make> to build files that are not generated by novaboot itself.
1734
1735 =item --name=I<string>
1736
1737 Use the name I<string> instead of the name of the novaboot script.
1738 This name is used for things like a title of grub menu or for the
1739 server directory where the boot files are copied to.
1740
1741 =item --no-file-gen
1742
1743 Do not run external commands to generate files (i.e. "<" syntax and
1744 C<run> keyword). This switch does not influence the generation of files
1745 specified with "<<WORD" syntax.
1746
1747 =item -p, --pulsar[=mac]
1748
1749 Generates pulsar bootloader configuration file named F<config-I<mac>>
1750 The I<mac> string is typically a MAC address and defaults to
1751 I<novaboot>.
1752
1753 =item --scons[=scons command]
1754
1755 Runs C<scons> to build files that are not generated by novaboot
1756 itself.
1757
1758 =item --strip-rom
1759
1760 Strip I<rom://> prefix from command lines and generated config files.
1761 The I<rom://> prefix is used by NUL. For NRE, it has to be stripped.
1762
1763 =item --gen-only
1764
1765 Exit novaboot after file generation phase.
1766
1767 =back
1768
1769 =head2 Target connection check
1770
1771 In this phase novaboot connects to target's serial port (if it has
1772 one). If another novaboot user/instance occupies the target, novaboot
1773 exits here with an error message.
1774
1775 =over 8
1776
1777 =item --amt=I<"[user[:password]@]host[:port]>
1778
1779 Use Intel AMT technology to control the target machine. WS management
1780 is used to powercycle it and Serial-Over-Lan (SOL) for input/output.
1781 The hostname or (IP address) is given by the I<host> parameter. If the
1782 I<password> is not specified, environment variable AMT_PASSWORD is
1783 used. The I<port> specifies a TCP port for SOL. If not specified, the
1784 default is 16992. The default I<user> is admin.
1785
1786 =item --iprelay=I<addr[:port]>
1787
1788 Use TCP/IP relay and serial port to access the target's serial port
1789 and powercycle it. The I<addr> parameter specifies the IP address of
1790 the relay. If I<port> is not specified, it defaults to 23.
1791
1792 Note: This option is supposed to work with HWG-ER02a IP relays.
1793
1794 =item --iprelay-cmd=I<command>
1795
1796 Similar to B<--iprelay> but uses I<command> to talk to the iprelay
1797 rather than direct network connection.
1798
1799 =item -s, --serial[=device]
1800
1801 Target's serial line is connected to host's serial line (device). The
1802 default value for device is F</dev/ttyUSB0>.
1803
1804 The value of this option is exported in NB_NOVABOOT environment
1805 variable to all subprocesses run by C<novaboot>.
1806
1807 =item --stty=I<settings>
1808
1809 Specifies settings passed to C<stty> invoked on the serial line
1810 specified with B<--serial> option. If this option is not given,
1811 C<stty> is called with C<raw -crtscts -onlcr 115200> settings.
1812
1813 =item --remote-cmd=I<cmd>
1814
1815 Command that mediates connection to the target's serial line. For
1816 example C<ssh server 'cu -l /dev/ttyS0'>.
1817
1818 =item --remote-expect=I<string>
1819
1820 Wait for reception of I<string> after establishing the remote serial
1821 line connection. Novaboot assumes that after establishing the serial
1822 line connection, the user running novaboot has exclusive access to the
1823 target. If establishing of the serial line connection happens
1824 asynchronously (e.g. running a command remotely via SSH), we need this
1825 option to wait until the exclusive access is confirmed by the remote
1826 side.
1827
1828 Depending on target configuration, this option can solve two practical
1829 problems: 1) Overwriting of files deployed by another user currently
1830 using the target. 2) Resetting the target board before serial line
1831 connection is established and thus missing bootloader interaction.
1832
1833 Example of usage with the L<sterm
1834 tool|https://rtime.felk.cvut.cz/gitweb/sojka/sterm.git>:
1835
1836   --remote-cmd='ssh -tt example.com sterm -v /dev/ttyUSB0' --remote-expect='sterm: Connected'
1837
1838 =item --remote-expect-silent=I<string>
1839
1840 The same as B<--remote-expect> except that the remote output is not
1841 echoed to stdout while waiting for the I<string>. Everything after the
1842 matched string is printed to stdout, so you may want to include line
1843 end characters in the I<string> as well.
1844
1845 =item --remote-expect-timeout=I<seconds>
1846
1847 Timeout in seconds for B<--remote-expect> or
1848 B<--remote-expect-seconds>. When negative, waits forever. The default
1849 is -1 seconds.
1850
1851 =back
1852
1853 =head2 File deployment phase
1854
1855 In some setups, it is necessary to copy the files needed for booting
1856 to a particular location, e.g. to a TFTP boot server or to the
1857 F</boot> partition.
1858
1859 =over 8
1860
1861 =item -d, --dhcp-tftp
1862
1863 Turns your workstation into a DHCP and TFTP server so that the OS can
1864 be booted via PXE BIOS (or similar mechanism) on the test machine
1865 directly connected by a plain Ethernet cable to your workstation.
1866
1867 The DHCP and TFTP servers require root privileges and C<novaboot>
1868 uses C<sudo> command to obtain those. You can put the following to
1869 I</etc/sudoers> to allow running the necessary commands without asking
1870 for a password.
1871
1872  Cmnd_Alias NOVABOOT = /bin/ip a add 10.23.23.1/24 dev eth0, /bin/ip l set dev eth0 up, /usr/sbin/dhcpd -d -cf dhcpd.conf -lf dhcpd.leases -pf dhcpd.pid, /usr/sbin/in.tftpd --listen --secure -v -v -v --pidfile tftpd.pid *, /usr/bin/touch dhcpd.leases, /usr/bin/pkill --pidfile=dhcpd.pid, /usr/bin/pkill --pidfile=tftpd.pid
1873  your_login ALL=NOPASSWD: NOVABOOT
1874
1875 =item --tftp
1876
1877 Starts a TFTP server on your workstation. This is similar to
1878 B<--dhcp-tftp> except that DHCP server is not started.
1879
1880 The TFTP server requires root privileges and C<novaboot> uses C<sudo>
1881 command to obtain those. You can put the following to I</etc/sudoers>
1882 to allow running the necessary commands without asking for a password.
1883
1884  Cmnd_Alias NOVABOOT =  /usr/sbin/in.tftpd --listen --secure -v -v -v --pidfile tftpd.pid *, /usr/bin/pkill --pidfile=tftpd.pid
1885  your_login ALL=NOPASSWD: NOVABOOT
1886
1887 =item --tftp-port=I<port>
1888
1889 Port to run the TFTP server on. Implies B<--tftp>.
1890
1891 =item --netif=I<network interface>
1892
1893 Network interface used to deploy files to the target. This option
1894 influences the configuration of the DHCP server started by
1895 B<--dhcp-tftp> and the value that B<$NB_MYIP> get replaced with during
1896 U-Boot conversation. The default value is C<$netif> variable from
1897 configuration files, which defaults to I<eth0>.
1898
1899 =item --iso[=filename]
1900
1901 Generates the ISO image that boots NOVA system via GRUB. If no filename
1902 is given, the image is stored under I<NAME>.iso, where I<NAME> is the name
1903 of the novaboot script (see also B<--name>).
1904
1905 =item --server[=[[user@]server:]path]
1906
1907 Copy all files needed for booting to another location. The files will
1908 be copied (by B<rsync> tool) to the directory I<path>. If the I<path>
1909 contains string $NAME, it will be replaced with the name of the
1910 novaboot script (see also B<--name>).
1911
1912 =item --rsync-flags=I<flags>
1913
1914 Specifies I<flags> to append to F<rsync> command line when
1915 copying files as a result of I<--server> option.
1916
1917 =item --concat
1918
1919 If B<--server> is used and its value ends with $NAME, then after
1920 copying the files, a new bootloader configuration file (e.g. menu.lst)
1921 is created at I<path-wo-name>, i.e. the path specified by B<--server>
1922 with $NAME part removed. The content of the file is created by
1923 concatenating all files of the same name from all subdirectories of
1924 I<path-wo-name> found on the "server".
1925
1926 =item --ider
1927
1928 Use Intel AMT technology for IDE redirection. This allows the target
1929 machine to boot from novaboot created ISO image. Implies B<--iso>.
1930
1931 The experimental C<amtider> utility needed by this option can be
1932 obtained from https://github.com/wentasah/amtterm.
1933
1934 =back
1935
1936 =head2 Target power-on and reset phase
1937
1938 At this point, the target is reset (or switched on/off). There are
1939 several ways how this can be accomplished. Resetting a physical target
1940 can currently be accomplished by the following options: B<--amt>,
1941 B<--iprelay>, B<--reset-cmd> and B<--reset-send>.
1942
1943 =over 8
1944
1945 =item --on, --off
1946
1947 Switch on/off the target machine and exit. The script (if any) is
1948 completely ignored. Currently, it works only with the following
1949 options: B<--iprelay>, B<--amt>, B<--ssh>.
1950
1951 =item -Q, --qemu[=I<qemu-binary>]
1952
1953 Boot the configuration in qemu. Optionally, the name of qemu binary
1954 can be specified as a parameter.
1955
1956 =item --qemu-append=I<flags>
1957
1958 Append I<flags> to the default qemu flags (QEMU_FLAGS variable or
1959 C<-cpu coreduo -smp 2>).
1960
1961 =item -q, --qemu-flags=I<flags>
1962
1963 Replace the default qemu flags (QEMU_FLAGS variable or C<-cpu coreduo
1964 -smp 2>) with I<flags> specified here.
1965
1966 =item --reset-cmd=I<cmd>
1967
1968 Runs command I<cmd> to reset the target.
1969
1970 =item --reset-send=I<string>
1971
1972 Reset the target by sending the given I<string> to the remote serial
1973 line. "\n" sequences are replaced with the newline character.
1974
1975 =item --no-reset, --reset
1976
1977 Disable/enable resetting of the target.
1978
1979 =back
1980
1981 =head2 Interaction with the bootloader on the target
1982
1983 =over 8
1984
1985 =item --uboot[=I<prompt>]
1986
1987 Interact with U-Boot bootloader to boot the thing described in the
1988 novaboot script. I<prompt> specifies the U-Boot's prompt (default is
1989 "=> ", other common prompts are "U-Boot> " or "U-Boot# ").
1990
1991 =item --no-uboot
1992
1993 Disable U-Boot interaction previously enabled with B<--uboot>.
1994
1995 =item --uboot-stop-key=I<key>
1996
1997 Character, which is sent as a response to U-Boot's "Hit any key to
1998 stop autoboot" message. The default value is newline, but some devices
1999 (e.g. TP-Link TD-W8970) require a specific key to be pressed.
2000
2001 =item --uboot-init
2002
2003 Command(s) to send the U-Boot bootloader before loading the images and
2004 booting them. This option can be given multiple times. After sending
2005 commands from each option novaboot waits for U-Boot I<prompt>.
2006
2007 If the command contains string I<$NB_MYIP> then this string is
2008 replaced by IPv4 address of eth0 interface (see also B<--netif>).
2009 Similarly, I<$NB_PREFIX> is replaced with prefix given by B<--prefix>.
2010
2011 See also C<uboot> keyword in L</"NOVABOOT SCRIPT SYNTAX">).
2012
2013 =item --uboot-addr I<name>=I<address>
2014
2015 Load address of U-Boot's C<tftpboot> command for loading I<name>,
2016 where name is one of I<kernel>, I<ramdisk> or I<fdt> (flattened device
2017 tree).
2018
2019 The default addresses are ${I<name>_addr_r}, i.e. U-Boot environment
2020 variables used by convention for this purpose.
2021
2022 =item --uboot-cmd=I<command>
2023
2024 Specifies U-Boot command used to execute the OS. If the command
2025 contains strings C<$kernel_addr>, C<$ramdisk_addr>, C<$fdt_addr>,
2026 these are replaced with the addresses configured with B<--uboot-addr>.
2027
2028 The default value is
2029
2030     bootm $kernel_addr $ramdisk_addr $fdt_addr
2031
2032 or the C<UBOOT_CMD> variable if defined in the novaboot script.
2033
2034 =back
2035
2036 =head2 Target interaction phase
2037
2038 In this phase, target's serial output is redirected to stdout and if
2039 stdin is a TTY, it is redirected to the target's serial input allowing
2040 interactive work with the target.
2041
2042 =over 8
2043
2044 =item --exiton=I<string>
2045
2046 When the I<string> is sent by the target, novaboot exits. This option can
2047 be specified multiple times, in which case novaboot exits whenever
2048 either of the specified strings is sent.
2049
2050 If the I<string> is C<-re>, then the next B<--exiton>'s I<string> is
2051 treated as a regular expression. For example:
2052
2053     --exiton -re --exiton 'error:.*failed'
2054
2055 =item --exiton-re=I<regex>
2056
2057 The same as --exiton -re --exiton I<regex>.
2058
2059 =item --exiton-timeout=I<seconds>
2060
2061 By default B<--exiton> waits for the string match forever. When this
2062 option is specified, "exiton" timeouts after the specified number of
2063 seconds and novaboot returns non-zero exit code.
2064
2065 =item -i, --interactive
2066
2067 Setup things for the interactive use of the target. Your terminal will
2068 be switched to raw mode. In raw mode, your local terminal does not
2069 process input in any way (no echoing of entered characters, no
2070 interpretation of special characters). This, among others, means that
2071 Ctrl-C is passed to the target and does not interrupt novaboot. To
2072 exit from novaboot interactive mode type "~~.".
2073
2074 =item --no-interaction, --interaction
2075
2076 Skip resp. force target interaction phase. When skipped, novaboot exits
2077 immediately after the boot is initiated.
2078
2079 =item --expect=I<string>
2080
2081 When the I<string> is received from the target, send the string specified
2082 with the subsequent B<--send*> option to the target.
2083
2084 =item --expect-re=I<regex>
2085
2086 When target's output matches regular expression I<regex>, send the
2087 string specified with the subsequent B<--send*> option to the target.
2088
2089 =item --expect-raw=I<perl-code>
2090
2091 Provides direct control over Perl's Expect module.
2092
2093 =item --send=I<string>
2094
2095 Send I<string> to the target after the previously specified
2096 B<--expect*> was matched in the target's output. The I<string> may
2097 contain escape sequences such as "\n".
2098
2099 Note that I<string> is actually interpreted by Perl, so it can contain
2100 much more that escape sequences. This behavior may change in the
2101 future.
2102
2103 Example: C<--expect='login: ' --send='root\n'>
2104
2105 =item --sendcont=I<string>
2106
2107 Similar to B<--send> but continue expecting more input.
2108
2109 Example: C<--expect='Continue?' --sendcont='yes\n'>
2110
2111 =item --final-eol, --no-final-eol
2112
2113 By default, B<novaboot> always prints an end-of-line character at the
2114 end of its execution in order to ensure that the output of programs
2115 started after novaboot appears at the beginning of the line. When this
2116 is not desired B<--no-final-eol> option can be used to override this
2117 behavior.
2118
2119 =back
2120
2121 =head1 NOVABOOT SCRIPT SYNTAX
2122
2123 The syntax tries to mimic POSIX shell syntax. The syntax is defined
2124 by the following rules.
2125
2126 Lines starting with "#" and empty lines are ignored.
2127
2128 Lines that end with "\" are concatenated with the following line after
2129 removal of the final "\" and leading whitespace of the following line.
2130
2131 Lines of the form I<VARIABLE=...> (i.e. matching '^[A-Z_]+=' regular
2132 expression) assign values to internal variables. See L</VARIABLES>
2133 section.
2134
2135 Otherwise, the first word on the line defines the meaning of the line.
2136 The following keywords are supported:
2137
2138 =over 4
2139
2140 =item C<load>
2141
2142 These lines represent modules to boot. The
2143 word after C<load> is a file name (relative to the build directory
2144 (see B<--build-dir>) of the module to load and the remaining words are
2145 passed to it as the command line parameters.
2146
2147 When booting Linux, the first C<load> line usually refers to the
2148 kernel image and its command line parameters (unless you use some
2149 special pre-loader). Other C<load> lines may refer to an initramfs
2150 image and/or a device tree blob. Their order is not important, as the
2151 device tree is recognized as the file name ending with C<.dtb>.
2152
2153 When the C<load> line ends with "<<WORD" then the subsequent lines
2154 until the line containing solely WORD are copied literally to the file
2155 named on that line. This is similar to the heredoc feature of UNIX
2156 shells.
2157
2158 When the C<load> line ends with "< CMD" then command CMD is executed
2159 with F</bin/sh> and its standard output is stored in the file named on
2160 that line. The SRCDIR variable in CMD's environment is set to the
2161 absolute path of the directory containing the interpreted novaboot
2162 script.
2163
2164 =item C<copy>
2165
2166 These lines are similar to C<load> lines. The
2167 file mentioned there is copied to the same place as in the case of C<load>
2168 (e.g. tftp server), but the file is not used in the bootloader
2169 configuration. Such a file can be used by the target for other
2170 purposes than booting, e.g. at OS runtime or for firmware update.
2171
2172 =item C<chld>
2173
2174 Chainload another bootloader. Instead of loading multiboot modules
2175 identified with C<load> keyword, run another bootloader. This is
2176 currently supported only by pulsar and can be used to load e.g. Grub
2177 as in the example below:
2178
2179  chld boot/grub/i386-pc/core.0
2180
2181
2182 =item C<run>
2183
2184 Lines starting with C<run> keyword contain shell commands that are run
2185 during file generation phase. This is the same as the "< CMD" syntax
2186 for C<load> keyboard except that the command's output is not
2187 redirected to a file. The ordering of commands is the same as they
2188 appear in the novaboot script.
2189
2190 =item C<uboot>
2191
2192 These lines represent U-Boot commands that are sent to the target if
2193 B<--uboot> option is given. Having a U-Boot line in the novaboot
2194 script is the same as giving B<--uboot-init> option to novaboot. The
2195 following syntax variants are supported:
2196
2197
2198   uboot[:<timeout>] <string> [> <file>]
2199   uboot[:<timeout>] < <shell> [> <file>]
2200
2201 C<string> is the literal U-Boot command.
2202
2203 The C<uboot> keyword can be suffixed with timeout specification. The
2204 syntax is C<uboot:Ns>, where C<N> is the whole number of seconds. If
2205 the U-Boot command prompt does not appear before the timeout, novaboot
2206 fails. The default timeout is 10 seconds.
2207
2208 In the second variant with the C<<> character the shell code is
2209 executed and its standard output is sent to U-Boot. Example:
2210
2211   uboot < printf "mmc write \$loadaddr 1 %x" $(($(/usr/bin/stat -c%s rootfs.ext4) / 512))
2212
2213 When C<E<gt> file> part is present, the output of the U-Boot command
2214 is written into the given file.
2215
2216 =back
2217
2218 Example (Linux):
2219
2220   #!/usr/bin/env novaboot
2221   load bzImage console=ttyS0,115200
2222   run  make -C buildroot
2223   load rootfs.cpio < gen_cpio buildroot/images/rootfs.cpio "myapp->/etc/init.d/S99myapp"
2224
2225 Example (NOVA User Land - NUL):
2226
2227   #!/usr/bin/env novaboot
2228   WVDESC=Example program
2229   load bin/apps/sigma0.nul S0_DEFAULT script_start:1,1 \
2230                            verbose hostkeyb:0,0x60,1,12,2
2231   load bin/apps/hello.nul
2232   load hello.nulconfig <<EOF
2233   sigma0::mem:16 name::/s0/log name::/s0/timer name::/s0/fs/rom ||
2234   rom://bin/apps/hello.nul
2235   EOF
2236
2237 This example will load three modules: F<sigma0.nul>, F<hello.nul> and
2238 F<hello.nulconfig>. sigma0 receives some command line parameters and
2239 F<hello.nulconfig> file is generated on the fly from the lines between
2240 C<<<EOF> and C<EOF>.
2241
2242 Example (Zynq system update via U-Boot):
2243
2244   #!/usr/bin/env novaboot
2245
2246   uboot dhcp
2247
2248   # Write kernel to FAT filesystem on the 1st SD card partition
2249   run mkimage -f uboot-image.its image.ub
2250   copy image.ub
2251   uboot:60s tftpboot ${loadaddr} $NB_PREFIX/image.ub
2252   uboot fatwrite mmc 0:1 ${loadaddr} image.ub $filesize
2253   uboot set bootargs console=ttyPS0,115200 root=/dev/mmcblk0p2
2254
2255   # Write root FS image to the 2nd SD card partition
2256   copy rootfs/images/rootfs.ext4
2257   uboot:60s tftpboot ${loadaddr} $NB_PREFIX/rootfs/images/rootfs.ext4
2258   uboot mmc part > mmc-part.txt
2259   uboot < printf "mmc write \$loadaddr %x %x" $(awk '{ if ($1 == "2") { print $2 }}' mmc-part.txt) $(($(/usr/bin/stat -L --printf=%s rootfs/images/rootfs.ext4) / 512))
2260
2261   UBOOT_CMD=boot
2262
2263
2264 =head2 VARIABLES
2265
2266 The following variables are interpreted in the novaboot script:
2267
2268 =over 8
2269
2270 =item BUILDDIR
2271
2272 Novaboot chdir()s to this directory before file generation phase. The
2273 directory name specified here is relative to the build directory
2274 specified by other means (see L</--build-dir>).
2275
2276 =item EXITON
2277
2278 Assigning this variable has the same effect as specifying L</--exiton>
2279 option.
2280
2281 =item INTERACTION
2282
2283 Setting this variable to zero is the same as giving
2284 L</--no-interaction>, specifying to one corresponds to
2285 L</--interaction>.
2286
2287 =item HYPERVISOR_PARAMS
2288
2289 Parameters passed to the hypervisor. The default value is "serial", unless
2290 overridden in the configuration file.
2291
2292 =item KERNEL
2293
2294 The kernel to use instead of the hypervisor specified in the
2295 configuration file with the C<$hypervisor> variable. The value should
2296 contain the name of the kernel image as well as its command line
2297 parameters. If this variable is defined and non-empty, the variable
2298 HYPERVISOR_PARAMS is not used.
2299
2300 =item NO_BOOT
2301
2302 If this variable is 1, the system is not booted. This is currently
2303 only implemented for U-Boot bootloader where it is useful for
2304 interacting with the bootloader without booting the system - e.g. for
2305 flashing.
2306
2307 =item QEMU
2308
2309 Use a specific qemu binary (can be overridden with B<-Q>) and flags
2310 when booting this script under qemu. If QEMU_FLAGS variable is also
2311 specified flags specified in QEMU variable are replaced by those in
2312 QEMU_FLAGS.
2313
2314 =item QEMU_FLAGS
2315
2316 Use specific qemu flags (can be overridden with B<-q>).
2317
2318 =item UBOOT_CMD
2319
2320 See L</--uboot-cmd>.
2321
2322 =item WVDESC
2323
2324 Description of the WvTest-compliant program.
2325
2326 =item WVTEST_TIMEOUT
2327
2328 The timeout in seconds for WvTest harness. If no complete line appears
2329 in the test output within the time specified here, the test fails. It
2330 is necessary to specify this for long running tests that produce no
2331 intermediate output.
2332
2333 =back
2334
2335 =head1 CONFIGURATION FILES
2336
2337 Novaboot can read its configuration from one or more files. By
2338 default, novaboot looks for files in F</etc/novaboot.d>, file
2339 F<~/.config/novaboot> and files named F<.novaboot> as described in
2340 L</Configuration reading phase>. Alternatively, configuration file
2341 location can be specified with the B<-c> switch or with the
2342 NOVABOOT_CONFIG environment variable. The configuration file has Perl
2343 syntax (i.e. it is better to put C<1;> as the last line) and should set
2344 values of certain Perl variables. The current configuration can be
2345 dumped with the B<--dump-config> switch. Some configuration variables
2346 can be overridden by environment variables (see below) or by command
2347 line switches.
2348
2349 Supported configuration variables include:
2350
2351 =over 8
2352
2353 =item $builddir
2354
2355 Build directory location relative to the location of the configuration
2356 file.
2357
2358 =item $default_target
2359
2360 Default target (see below) to use when no target is explicitly
2361 specified with the B<--target> command line option or
2362 B<NOVABOOT_TARGET> environment variable.
2363
2364 =item $netif
2365
2366 Default value for the B<--netif> option. If not specified, it defaults
2367 to I<eth0>.
2368
2369 =item %targets
2370
2371 Hash of target definitions to be used with the B<--target> option. The
2372 key is the identifier of the target, the value is the string with
2373 command line options. For instance, if the configuration file contains:
2374
2375  $targets{'mybox'} = '--server=boot:/tftproot --serial=/dev/ttyUSB0 --grub',
2376
2377 then the following two commands are equivalent:
2378
2379  ./myos --server=boot:/tftproot --serial=/dev/ttyUSB0 --grub
2380  ./myos -t mybox
2381
2382 =back
2383
2384 =head1 ENVIRONMENT VARIABLES
2385
2386 Some options can be specified not only via config file or command line
2387 but also through environment variables. Environment variables override
2388 the values from the configuration file and command line parameters
2389 override the environment variables.
2390
2391 =over 8
2392
2393 =item NOVABOOT_CONFIG
2394
2395 Name of the novaboot configuration file to use instead of the default
2396 one(s).
2397
2398 =item NOVABOOT_CONFIG_DIR
2399
2400 Name of the novaboot configuration directory. When not specified
2401 F</etc/novaboot.d> is used.
2402
2403 =item NOVABOOT_TARGET
2404
2405 Name of the novaboot target to use. This overrides the value of
2406 B<$default_target> from the configuration file and can be overridden
2407 with the B<--target> command line option.
2408
2409 =item NOVABOOT_BENDER
2410
2411 Defining this variable has the same effect as using B<--bender>
2412 option.
2413
2414 =back
2415
2416 =head1 AUTHORS
2417
2418 Michal Sojka <sojka@os.inf.tu-dresden.de>
2419
2420 Latest novaboot version can be found at
2421 L<https://github.com/wentasah/novaboot>.
2422
2423 =cut
2424
2425 # LocalWords:  novaboot Novaboot NOVABOOT TFTP PXE DHCP filename stty
2426 # LocalWords:  chainloader stdout Qemu qemu preprocessing ISOLINUX bootable
2427 # LocalWords:  config subprocesses sudo sudoers tftp dhcp IDE stdin
2428 # LocalWords:  subdirectories TTY whitespace heredoc POSIX WvTest