novaboot

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