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 Simple examples of using C<novaboot>:
1380
1381 =over 3
1382
1383 =item 1.
1384
1385 Running an OS in Qemu can be accomplished by giving the B<--qemu> option.
1386 Thus running
1387
1388  novaboot --qemu myos
1389
1390 (or C<./myos --qemu> as described above) will run Qemu and make it
1391 boot the configuration specified in the F<myos> script.
1392
1393 =item 2.
1394
1395 Create a bootloader configuration file (currently supported
1396 bootloaders are GRUB, GRUB2, ISOLINUX, Pulsar, and U-Boot) and copy it
1397 with all other files needed for booting to a remote boot server. Then
1398 use a TCP/IP-controlled relay/serial-to-TCP converter to reset the
1399 target and receive its serial output.
1400
1401  ./myos --grub2 --server=192.168.1.1:/tftp --iprelay=192.168.1.2
1402
1403 Alternatively, you can put these switches to the configuration file
1404 and run:
1405
1406  ./myos --target mytarget
1407
1408 =item 3.
1409
1410 Specifying all the options needed by novaboot to successfully control
1411 the target, either on command line or in configuration files, can be
1412 difficult for users. Novaboot supports configuring the target
1413 centrally via L<novaboot-shell(1)> on a server. With such a
1414 configuration, users only need to use the B<--ssh> option to specify
1415 where to boot their OS:
1416
1417  ./myos --ssh myboard@example.com
1418
1419 Typically, the server is the computer connected to and controlling the
1420 target board and running the TFTP server.
1421
1422 =item 4.
1423
1424 Run DHCP and TFTP server on developer's machine to boot the target
1425 from it.
1426
1427  ./myos --dhcp-tftp
1428
1429 This usage is useful when no network infrastructure is in place, and
1430 the target is connected directly to developer's box.
1431
1432 =item 5.
1433
1434 Create bootable ISO image.
1435
1436  novaboot --iso -- script1 script2
1437
1438 The created ISO image will have ISOLINUX bootloader installed on it,
1439 and the boot menu will allow selecting between I<script1> and
1440 I<script2> configurations.
1441
1442 =back
1443
1444 =head1 PHASES AND OPTIONS
1445
1446 Novaboot performs its work in several phases. Command like options
1447 described bellow influence the execution of each phase or allow their
1448 skipping. The list of phases (in the execution order) is as follows.
1449
1450 =over
1451
1452 =item 1. L<Configuration reading|/Configuration reading phase>
1453
1454 =item 2. L<Command line processing|/Command line processing phase>
1455
1456 =item 3. L<Script preprocessing|/Script preprocessing phase>
1457
1458 =item 4. L<File generation|/File generation phase>
1459
1460 =item 5. L<Target connection|/Target connection check>
1461
1462 =item 6. L<File deployment|/File deployment phase>
1463
1464 =item 7. L<Target power-on and reset|/Target power-on and reset phase>
1465
1466 =item 8. L<Interaction with the bootloader|/Interaction with the bootloader on the target>
1467
1468 =item 9. L<Target interaction|/Target interaction phase>
1469
1470 =back
1471
1472 Each phase is described in the following sections together with the
1473 command line options that control it.
1474
1475 =head2 Configuration reading phase
1476
1477 After starting, novaboot reads zero or more configuration files. We
1478 describe their content in section L</"CONFIGURATION FILES">. By default, the
1479 configuration is read from multiple locations. First from the system
1480 configuration directory (F</etc/novaboot.d/>), second from the user
1481 configuration file (F<~/.config/novaboot>) and third from F<.novaboot>
1482 files along the path to the current directory. Alternatively, a single
1483 configuration file specified with the B<-c> switch or with the
1484 C<NOVABOOT_CONFIG> environment variable is read. The latter read files
1485 override settings from the former ones.
1486
1487 The system configuration directory is determined by the content of
1488 NOVABOOT_CONFIG_DIR environment variable and defaults to
1489 F</etc/novaboot.d>. Files in this directory with names consisting
1490 solely of English letters, numbers, dashes '-' and underscores '_'
1491 (note that dot '.' is not included) are read in alphabetical order.
1492
1493 Then, the user configuration file is read from
1494 F<$XDG_CONFIG_HOME/novaboot>. If C<$XDG_CONFIG_HOME> environment
1495 variable is not set F<~/.config/novaboot> is read instead.
1496
1497 Finally, novaboot searches for files named F<.novaboot> starting from the
1498 directory of the novaboot script (or working directory, see bellow)
1499 and continuing upwards up to the root directory. The found
1500 configuration files are then read in the opposite order (i.e. from the
1501 root directory downwards). This ordering allows having, for example, a project
1502 specific configuration in F<~/project/.novaboot>.
1503
1504 Note the difference between F<~/.config/novaboot> and F<~/.novaboot>.
1505 The former one is always read, whereas the latter only when novaboot
1506 script or working directory is under the C<$HOME> directory.
1507
1508 In certain cases, the location of the novaboot script cannot be
1509 determined in this early phase. This situation happens either when the script is
1510 read from the standard input or when novaboot is invoked explicitly as
1511 in the example L</"4."> above. In this case, the current working
1512 directory is used as a starting point for configuration file search
1513 instead of the novaboot script directory.
1514
1515 =over 8
1516
1517 =item -c, --config=I<filename>
1518
1519 Use the specified configuration file instead of the default one(s).
1520
1521 =back
1522
1523 =head2 Command line processing phase
1524
1525 =over 8
1526
1527 =item --dump-config
1528
1529 Dump the current configuration to stdout end exit. Useful as an
1530 initial template for a configuration file.
1531
1532 =item -h, --help
1533
1534 Print short (B<-h>) or long (B<--help>) help.
1535
1536 =item -t, --target=I<target>
1537
1538 This option serves as a user configurable shortcut for other novaboot
1539 options. The effect of this option is the same as specifying the
1540 options stored in the C<%targets> configuration variable under key
1541 I<target>. See also L</"CONFIGURATION FILES">.
1542
1543 When this option is not given, novaboot tries to determine the target
1544 to use from either B<NOVABOOT_TARGET> environment variable or
1545 B<$default_target> configuration file variable.
1546
1547 =item --ssh=I<user@hostname>
1548
1549 Configures novaboot to control the target via C<novaboot-shell>
1550 running remotely via SSH.
1551
1552 Using this option is the same as specifying B<--remote-cmd>,
1553 B<--remote-expect>, B<--server> B<--rsync-flags>, B<--prefix> and
1554 B<--reset-cmd> manually in a way compatible with C<novaboot-shell>.
1555 The server can be configured to provide other, safe bootloader-related
1556 options, to the client. When this happens, novaboot prints them to
1557 stdout.
1558
1559 Currently, this in an initial experimental implementation. We plan to
1560 change/extend this feature soon!
1561
1562 =back
1563
1564 =head2 Script preprocessing phase
1565
1566 This phase allows modifying the parsed novaboot script before it is
1567 used in the later phases.
1568
1569 =over 8
1570
1571 =item -a, --append=I<parameters>
1572
1573 Append a string to the first C<load> line in the novaboot script. This option
1574 can be used to append parameters to the kernel's or root task's
1575 command line. This option can appear multiple times.
1576
1577 =item -b, --bender
1578
1579 Use L<Bender|https://github.com/TUD-OS/morbo/blob/master/standalone/bender.c>
1580 chainloader. Bender scans the PCI bus for PCI serial ports and stores
1581 the information about them in the BIOS data area for use by the
1582 kernel.
1583
1584 =item --chainloader=I<chainloader>
1585
1586 Specifies a chainloader that is loaded before the kernel and other
1587 files specified in the novaboot script. E.g. 'bin/boot/bender
1588 promisc'.
1589
1590 =item --dump
1591
1592 Print the modules to boot and their parameters, after this phase
1593 finishes. Then exit. This is useful for seeing the effect of other
1594 options in this section.
1595
1596 =item -k, --kernel=F<file>
1597
1598 Replace the first word on the first C<load> line in the novaboot
1599 script with F<file>.
1600
1601 =item --scriptmod=I<Perl expression>
1602
1603 When novaboot reads the script, I<Perl expression> is executed for every
1604 line (in $_ variable). For example, C<novaboot
1605 --scriptmod=s/sigma0/omega6/g> replaces every occurrence of I<sigma0>
1606 in the script with I<omega6>.
1607
1608 When this option is present, it overrides I<$script_modifier> variable
1609 from the configuration file, which has the same effect. If this option
1610 is given multiple times all expressions are evaluated in the command
1611 line order.
1612
1613 =back
1614
1615 =head2 File generation phase
1616
1617 In this phase, files needed for booting are generated in a so-called
1618 I<build directory> (see L</--build-dir>). In most cases configuration
1619 for a bootloader is generated automatically by novaboot. It is also
1620 possible to generate other files using I<heredoc> or I<"<"> syntax in
1621 novaboot scripts. Finally, novaboot can generate binaries in this phases by
1622 running C<scons> or C<make>.
1623
1624 =over 8
1625
1626 =item --build-dir=I<directory>
1627
1628 Overrides the default build directory location.
1629
1630 The default build directory location is determined as follows: If the
1631 configuration file defines the C<$builddir> variable, its value is
1632 used. Otherwise, it is the directory that contains the first processed
1633 novaboot script.
1634
1635 See also L</BUILDDIR> variable.
1636
1637 =item -g, --grub[=I<filename>]
1638
1639 Generates grub bootloader menu file. If the I<filename> is not
1640 specified, F<menu.lst> is used. The I<filename> is relative to the
1641 build directory (see B<--build-dir>).
1642
1643 =item --grub-preamble=I<prefix>
1644
1645 Specifies the I<preamble> that is at the beginning of the generated
1646 GRUB or GRUB2 config files. This is useful for specifying GRUB's
1647 timeout.
1648
1649 =item --prefix=I<prefix>
1650
1651 Specifies I<prefix> (e.g. F</srv/tftp>) that is put in front of every
1652 filename in generated bootloader configuration files (or in U-Boot
1653 commands).
1654
1655 If the I<prefix> contains string $NAME, it will be replaced with the
1656 name of the novaboot script (see also B<--name>).
1657
1658 If the I<prefix> contains string $BUILDDIR, it will be replaced with
1659 the build directory (see also B<--build-dir>).
1660
1661 =item --grub-prefix
1662
1663 Alias for B<--prefix>.
1664
1665 =item --grub2[=I<filename>]
1666
1667 Generate GRUB2 menu entry in I<filename>. If I<filename> is not
1668 specified F<grub.cfg> is used. The content of the menu entry can be
1669 customized with B<--grub-preamble>, B<--grub2-prolog> or
1670 B<--grub_prefix> options.
1671
1672 To use the generated menu entry on your development
1673 machine that uses GRUB2, append the following snippet to
1674 F</etc/grub.d/40_custom> file and regenerate your grub configuration,
1675 i.e. run update-grub on Debian/Ubuntu.
1676
1677   if [ -f /path/to/nul/build/grub.cfg ]; then
1678     source /path/to/nul/build/grub.cfg
1679   fi
1680
1681 =item --grub2-prolog=I<prolog>
1682
1683 Specifies the text that novaboot puts at the beginning of the GRUB2 menu entry.
1684
1685 =item -m, --make[=make command]
1686
1687 Runs C<make> to build files that are not generated by novaboot itself.
1688
1689 =item --name=I<string>
1690
1691 Use the name I<string> instead of the name of the novaboot script.
1692 This name is used for things like a title of grub menu or for the
1693 server directory where the boot files are copied to.
1694
1695 =item --no-file-gen
1696
1697 Do not run external commands to generate files (i.e. "<" syntax and
1698 C<run> keyword). This switch does not influence the generation of files
1699 specified with "<<WORD" syntax.
1700
1701 =item -p, --pulsar[=mac]
1702
1703 Generates pulsar bootloader configuration file named F<config-I<mac>>
1704 The I<mac> string is typically a MAC address and defaults to
1705 I<novaboot>.
1706
1707 =item --scons[=scons command]
1708
1709 Runs C<scons> to build files that are not generated by novaboot
1710 itself.
1711
1712 =item --strip-rom
1713
1714 Strip I<rom://> prefix from command lines and generated config files.
1715 The I<rom://> prefix is used by NUL. For NRE, it has to be stripped.
1716
1717 =item --gen-only
1718
1719 Exit novaboot after file generation phase.
1720
1721 =back
1722
1723 =head2 Target connection check
1724
1725 In this phase novaboot connects to target's serial port (if it has
1726 one). If another novaboot user/instance occupies the target, novaboot
1727 exits here with an error message.
1728
1729 =over 8
1730
1731 =item --amt=I<"[user[:password]@]host[:port]>
1732
1733 Use Intel AMT technology to control the target machine. WS management
1734 is used to powercycle it and Serial-Over-Lan (SOL) for input/output.
1735 The hostname or (IP address) is given by the I<host> parameter. If the
1736 I<password> is not specified, environment variable AMT_PASSWORD is
1737 used. The I<port> specifies a TCP port for SOL. If not specified, the
1738 default is 16992. The default I<user> is admin.
1739
1740 =item --iprelay=I<addr[:port]>
1741
1742 Use TCP/IP relay and serial port to access the target's serial port
1743 and powercycle it. The I<addr> parameter specifies the IP address of
1744 the relay. If I<port> is not specified, it defaults to 23.
1745
1746 Note: This option is supposed to work with HWG-ER02a IP relays.
1747
1748 =item --iprelay-cmd=I<command>
1749
1750 Similar to B<--iprelay> but uses I<command> to talk to the iprelay
1751 rather than direct network connection.
1752
1753 =item -s, --serial[=device]
1754
1755 Target's serial line is connected to host's serial line (device). The
1756 default value for device is F</dev/ttyUSB0>.
1757
1758 The value of this option is exported in NB_NOVABOOT environment
1759 variable to all subprocesses run by C<novaboot>.
1760
1761 =item --stty=I<settings>
1762
1763 Specifies settings passed to C<stty> invoked on the serial line
1764 specified with B<--serial> option. If this option is not given,
1765 C<stty> is called with C<raw -crtscts -onlcr 115200> settings.
1766
1767 =item --remote-cmd=I<cmd>
1768
1769 Command that mediates connection to the target's serial line. For
1770 example C<ssh server 'cu -l /dev/ttyS0'>.
1771
1772 =item --remote-expect=I<string>
1773
1774 Wait for reception of I<string> after establishing the remote
1775 connection. This option is needed when novaboot should wait for
1776 confirmation before deploying files to the target, e.g. to not
1777 overwrite other user's files when they are using the target.
1778
1779 =item --remote-expect-silent=I<string>
1780
1781 The same as B<--remote-expect> except that the remote output is not
1782 echoed to stdout while waiting for the I<string>. Everything after the
1783 matched string is printed to stdout, so you may want to include line
1784 end characters in the I<string> as well.
1785
1786 =item --remote-expect-timeout=I<seconds>
1787
1788 Timeout in seconds for B<--remote-expect> or
1789 B<--remote-expect-seconds>. When negative, waits forever. The default
1790 is -1 seconds.
1791
1792 =back
1793
1794 =head2 File deployment phase
1795
1796 In some setups, it is necessary to copy the files needed for booting
1797 to a particular location, e.g. to a TFTP boot server or to the
1798 F</boot> partition.
1799
1800 =over 8
1801
1802 =item -d, --dhcp-tftp
1803
1804 Turns your workstation into a DHCP and TFTP server so that the OS can
1805 be booted via PXE BIOS (or similar mechanism) on the test machine
1806 directly connected by a plain Ethernet cable to your workstation.
1807
1808 The DHCP and TFTP servers require root privileges and C<novaboot>
1809 uses C<sudo> command to obtain those. You can put the following to
1810 I</etc/sudoers> to allow running the necessary commands without asking
1811 for a password.
1812
1813  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
1814  your_login ALL=NOPASSWD: NOVABOOT
1815
1816 =item --tftp
1817
1818 Starts a TFTP server on your workstation. This is similar to
1819 B<--dhcp-tftp> except that DHCP server is not started.
1820
1821 The TFTP server requires root privileges and C<novaboot> uses C<sudo>
1822 command to obtain those. You can put the following to I</etc/sudoers>
1823 to allow running the necessary commands without asking for a password.
1824
1825  Cmnd_Alias NOVABOOT =  /usr/sbin/in.tftpd --listen --secure -v -v -v --pidfile tftpd.pid *, /usr/bin/pkill --pidfile=tftpd.pid
1826  your_login ALL=NOPASSWD: NOVABOOT
1827
1828 =item --tftp-port=I<port>
1829
1830 Port to run the TFTP server on. Implies B<--tftp>.
1831
1832 =item --netif=I<network interface>
1833
1834 Network interface used to deploy files to the target. The default value is
1835 I<eth0>. This option influences the configuration of the DHCP server started
1836 by B<--dhcp-tftp> and the value that B<$NB_MYIP> get replaced with during
1837 U-Boot conversation.
1838
1839 =item --iso[=filename]
1840
1841 Generates the ISO image that boots NOVA system via GRUB. If no filename
1842 is given, the image is stored under I<NAME>.iso, where I<NAME> is the name
1843 of the novaboot script (see also B<--name>).
1844
1845 =item --server[=[[user@]server:]path]
1846
1847 Copy all files needed for booting to another location. The files will
1848 be copied (by B<rsync> tool) to the directory I<path>. If the I<path>
1849 contains string $NAME, it will be replaced with the name of the
1850 novaboot script (see also B<--name>).
1851
1852 =item --rsync-flags=I<flags>
1853
1854 Specifies I<flags> to append to F<rsync> command line when
1855 copying files as a result of I<--server> option.
1856
1857 =item --concat
1858
1859 If B<--server> is used and its value ends with $NAME, then after
1860 copying the files, a new bootloader configuration file (e.g. menu.lst)
1861 is created at I<path-wo-name>, i.e. the path specified by B<--server>
1862 with $NAME part removed. The content of the file is created by
1863 concatenating all files of the same name from all subdirectories of
1864 I<path-wo-name> found on the "server".
1865
1866 =item --ider
1867
1868 Use Intel AMT technology for IDE redirection. This allows the target
1869 machine to boot from novaboot created ISO image. Implies B<--iso>.
1870
1871 The experimental C<amtider> utility needed by this option can be
1872 obtained from https://github.com/wentasah/amtterm.
1873
1874 =back
1875
1876 =head2 Target power-on and reset phase
1877
1878 At this point, the target is reset (or switched on/off). There are
1879 several ways how this can be accomplished. Resetting a physical target
1880 can currently be accomplished by the following options: B<--amt>,
1881 B<--iprelay>, B<--reset-cmd> and B<--reset-send>.
1882
1883 =over 8
1884
1885 =item --on, --off
1886
1887 Switch on/off the target machine and exit. The script (if any) is
1888 completely ignored. Currently, it works only with the following
1889 options: B<--iprelay>, B<--amt>, B<--ssh>.
1890
1891 =item -Q, --qemu[=I<qemu-binary>]
1892
1893 Boot the configuration in qemu. Optionally, the name of qemu binary
1894 can be specified as a parameter.
1895
1896 =item --qemu-append=I<flags>
1897
1898 Append I<flags> to the default qemu flags (QEMU_FLAGS variable or
1899 C<-cpu coreduo -smp 2>).
1900
1901 =item -q, --qemu-flags=I<flags>
1902
1903 Replace the default qemu flags (QEMU_FLAGS variable or C<-cpu coreduo
1904 -smp 2>) with I<flags> specified here.
1905
1906 =item --reset-cmd=I<cmd>
1907
1908 Runs command I<cmd> to reset the target.
1909
1910 =item --reset-send=I<string>
1911
1912 Reset the target by sending the given I<string> to the remote serial
1913 line. "\n" sequences are replaced with the newline character.
1914
1915 =item --no-reset, --reset
1916
1917 Disable/enable resetting of the target.
1918
1919 =back
1920
1921 =head2 Interaction with the bootloader on the target
1922
1923 =over 8
1924
1925 =item --uboot[=I<prompt>]
1926
1927 Interact with U-Boot bootloader to boot the thing described in the
1928 novaboot script. I<prompt> specifies the U-Boot's prompt (default is
1929 "=> ", other common prompts are "U-Boot> " or "U-Boot# ").
1930
1931 =item --no-uboot
1932
1933 Disable U-Boot interaction previously enabled with B<--uboot>.
1934
1935 =item --uboot-init
1936
1937 Command(s) to send the U-Boot bootloader before loading the images and
1938 booting them. This option can be given multiple times. After sending
1939 commands from each option novaboot waits for U-Boot I<prompt>.
1940
1941 If the command contains string I<$NB_MYIP> then this string is
1942 replaced by IPv4 address of eth0 interface (see also B<--netif>).
1943 Similarly, I<$NB_PREFIX> is replaced with prefix given by B<--prefix>.
1944
1945 See also C<uboot> keyword in L</"NOVABOOT SCRIPT SYNTAX">).
1946
1947 =item --uboot-addr I<name>=I<address>
1948
1949 Load address of U-Boot's C<tftpboot> command for loading I<name>,
1950 where name is one of I<kernel>, I<ramdisk> or I<fdt> (flattened device
1951 tree).
1952
1953 The default addresses are ${I<name>_addr_r}, i.e. U-Boot environment
1954 variables used by convention for this purpose.
1955
1956 =item --uboot-cmd=I<command>
1957
1958 Specifies U-Boot command used to execute the OS. If the command
1959 contains strings C<$kernel_addr>, C<$ramdisk_addr>, C<$fdt_addr>,
1960 these are replaced with the addresses configured with B<--uboot-addr>.
1961
1962 The default value is
1963
1964     bootm $kernel_addr $ramdisk_addr $fdt_addr
1965
1966 or the C<UBOOT_CMD> variable if defined in the novaboot script.
1967
1968 =back
1969
1970 =head2 Target interaction phase
1971
1972 In this phase, target's serial output is redirected to stdout and if
1973 stdin is a TTY, it is redirected to the target's serial input allowing
1974 interactive work with the target.
1975
1976 =over 8
1977
1978 =item --exiton=I<string>
1979
1980 When the I<string> is sent by the target, novaboot exits. This option can
1981 be specified multiple times, in which case novaboot exits whenever
1982 either of the specified strings is sent.
1983
1984 If the I<string> is C<-re>, then the next B<--exiton>'s I<string> is
1985 treated as a regular expression. For example:
1986
1987     --exiton -re --exiton 'error:.*failed'
1988
1989 =item --exiton-re=I<regex>
1990
1991 The same as --exiton -re --exiton I<regex>.
1992
1993 =item --exiton-timeout=I<seconds>
1994
1995 By default B<--exiton> waits for the string match forever. When this
1996 option is specified, "exiton" timeouts after the specifies the number of
1997 seconds and novaboot returns non-zero exit code.
1998
1999 =item -i, --interactive
2000
2001 Setup things for the interactive use of the target. Your terminal will
2002 be switched to raw mode. In raw mode, your local terminal does not
2003 process input in any way (no echoing of entered characters, no
2004 interpretation of special characters). This, among others, means that
2005 Ctrl-C is passed to the target and does not interrupt novaboot. To
2006 exit from novaboot interactive mode type "~~.".
2007
2008 =item --no-interaction, --interaction
2009
2010 Skip resp. force target interaction phase. When skipped, novaboot exits
2011 immediately after the boot is initiated.
2012
2013 =item --expect=I<string>
2014
2015 When the I<string> is received from the target, send the string specified
2016 with the subsequent B<--send*> option to the target.
2017
2018 =item --expect-re=I<regex>
2019
2020 When target's output matches regular expression I<regex>, send the
2021 string specified with the subsequent B<--send*> option to the target.
2022
2023 =item --expect-raw=I<perl-code>
2024
2025 Provides direct control over Perl's Expect module.
2026
2027 =item --send=I<string>
2028
2029 Send I<string> to the target after the previously specified
2030 B<--expect*> was matched in the target's output. The I<string> may
2031 contain escape sequences such as "\n".
2032
2033 Note that I<string> is actually interpreted by Perl, so it can contain
2034 much more that escape sequences. This behavior may change in the
2035 future.
2036
2037 Example: C<--expect='login: ' --send='root\n'>
2038
2039 =item --sendcont=I<string>
2040
2041 Similar to B<--send> but continue expecting more input.
2042
2043 Example: C<--expect='Continue?' --sendcont='yes\n'>
2044
2045 =item --final-eol, --no-final-eol
2046
2047 By default, B<novaboot> always prints an end-of-line character at the
2048 end of its execution in order to ensure that the output of programs
2049 started after novaboot appears at the beginning of the line. When this
2050 is not desired B<--no-final-eol> option can be used to override this
2051 behavior.
2052
2053 =back
2054
2055 =head1 NOVABOOT SCRIPT SYNTAX
2056
2057 The syntax tries to mimic POSIX shell syntax. The syntax is defined
2058 by the following rules.
2059
2060 Lines starting with "#" and empty lines are ignored.
2061
2062 Lines that end with "\" are concatenated with the following line after
2063 removal of the final "\" and leading whitespace of the following line.
2064
2065 Lines of the form I<VARIABLE=...> (i.e. matching '^[A-Z_]+=' regular
2066 expression) assign values to internal variables. See L</VARIABLES>
2067 section.
2068
2069 Otherwise, the first word on the line defines the meaning of the line.
2070 The following keywords are supported:
2071
2072 =over 4
2073
2074 =item C<load>
2075
2076 These lines represent modules to boot. The
2077 word after C<load> is a file name (relative to the build directory
2078 (see B<--build-dir>) of the module to load and the remaining words are
2079 passed to it as the command line parameters.
2080
2081 When the C<load> line ends with "<<WORD" then the subsequent lines
2082 until the line containing solely WORD are copied literally to the file
2083 named on that line. This is similar to shell's heredoc feature.
2084
2085 When the C<load> line ends with "< CMD" then command CMD is executed
2086 with F</bin/sh> and its standard output is stored in the file named on
2087 that line. The SRCDIR variable in CMD's environment is set to the
2088 absolute path of the directory containing the interpreted novaboot
2089 script.
2090
2091 =item C<copy>
2092
2093 These lines are similar to C<load> lines. The
2094 file mentioned there is copied to the same place as in the case of C<load>
2095 (e.g. tftp server), but the file is not used in the bootloader
2096 configuration. Such a file can be used by the target for other
2097 purposes than booting, e.g. at OS runtime or for firmware update.
2098
2099 =item C<chld>
2100
2101 Chainload another bootloader. Instead of loading multiboot modules
2102 identified with C<load> keyword, run another bootloader. This is
2103 currently supported only by pulsar and can be used to load e.g. Grub
2104 as in the example below:
2105
2106  chld boot/grub/i386-pc/core.0
2107
2108
2109 =item C<run>
2110
2111 Lines starting with C<run> keyword contain shell commands that are run
2112 during file generation phase. This is the same as the "< CMD" syntax
2113 for C<load> keyboard except that the command's output is not
2114 redirected to a file. The ordering of commands is the same as they
2115 appear in the novaboot script.
2116
2117 =item C<uboot>
2118
2119 These lines represent U-Boot commands that are sent to the target if
2120 B<--uboot> option is given. Having a U-Boot line in the novaboot
2121 script is the same as giving B<--uboot-init> option to novaboot. The
2122 following syntax variants are supported:
2123
2124
2125   uboot[:<timeout>] <string> [> <file>]
2126   uboot[:<timeout>] < <shell> [> <file>]
2127
2128 C<string> is the literal U-Boot command.
2129
2130 The C<uboot> keyword can be suffixed with timeout specification. The
2131 syntax is C<uboot:Ns>, where C<N> is the whole number of seconds. If
2132 the U-Boot command prompt does not appear before the timeout, novaboot
2133 fails. The default timeout is 10 seconds.
2134
2135 In the second variant with the C<<> character the shell code is
2136 executed and its standard output is sent to U-Boot. Example:
2137
2138   uboot < printf "mmc write \$loadaddr 1 %x" $(($(/usr/bin/stat -c%s rootfs.ext4) / 512))
2139
2140 When C<E<gt> file> part is present, the output of the U-Boot command
2141 is written into the given file.
2142
2143 =back
2144
2145 Example (Linux):
2146
2147   #!/usr/bin/env novaboot
2148   load bzImage console=ttyS0,115200
2149   run  make -C buildroot
2150   load rootfs.cpio < gen_cpio buildroot/images/rootfs.cpio "myapp->/etc/init.d/S99myapp"
2151
2152 Example (NOVA User Land - NUL):
2153
2154   #!/usr/bin/env novaboot
2155   WVDESC=Example program
2156   load bin/apps/sigma0.nul S0_DEFAULT script_start:1,1 \
2157                            verbose hostkeyb:0,0x60,1,12,2
2158   load bin/apps/hello.nul
2159   load hello.nulconfig <<EOF
2160   sigma0::mem:16 name::/s0/log name::/s0/timer name::/s0/fs/rom ||
2161   rom://bin/apps/hello.nul
2162   EOF
2163
2164 This example will load three modules: F<sigma0.nul>, F<hello.nul> and
2165 F<hello.nulconfig>. sigma0 receives some command line parameters and
2166 F<hello.nulconfig> file is generated on the fly from the lines between
2167 C<<<EOF> and C<EOF>.
2168
2169 Example (Zynq system update via U-Boot):
2170
2171   #!/usr/bin/env novaboot
2172
2173   uboot dhcp
2174
2175   # Write kernel to FAT filesystem on the 1st SD card partition
2176   run mkimage -f uboot-image.its image.ub
2177   copy image.ub
2178   uboot:60s tftpboot ${loadaddr} $NB_PREFIX/image.ub
2179   uboot fatwrite mmc 0:1 ${loadaddr} image.ub $filesize
2180   uboot set bootargs console=ttyPS0,115200 root=/dev/mmcblk0p2
2181
2182   # Write root FS image to the 2nd SD card partition
2183   copy rootfs/images/rootfs.ext4
2184   uboot:60s tftpboot ${loadaddr} $NB_PREFIX/rootfs/images/rootfs.ext4
2185   uboot mmc part > mmc-part.txt
2186   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))
2187
2188   UBOOT_CMD=boot
2189
2190
2191 =head2 VARIABLES
2192
2193 The following variables are interpreted in the novaboot script:
2194
2195 =over 8
2196
2197 =item BUILDDIR
2198
2199 Novaboot chdir()s to this directory before file generation phase. The
2200 directory name specified here is relative to the build directory
2201 specified by other means (see L</--build-dir>).
2202
2203 =item EXITON
2204
2205 Assigning this variable has the same effect as specifying L</--exiton>
2206 option.
2207
2208 =item INTERACTION
2209
2210 Setting this variable to zero is the same as giving
2211 L</--no-interaction>, specifying to one corresponds to
2212 L</--interaction>.
2213
2214 =item HYPERVISOR_PARAMS
2215
2216 Parameters passed to the hypervisor. The default value is "serial", unless
2217 overridden in the configuration file.
2218
2219 =item KERNEL
2220
2221 The kernel to use instead of the hypervisor specified in the
2222 configuration file with the C<$hypervisor> variable. The value should
2223 contain the name of the kernel image as well as its command line
2224 parameters. If this variable is defined and non-empty, the variable
2225 HYPERVISOR_PARAMS is not used.
2226
2227 =item NO_BOOT
2228
2229 If this variable is 1, the system is not booted. This is currently
2230 only implemented for U-Boot bootloader where it is useful for
2231 interacting with the bootloader without booting the system - e.g. for
2232 flashing.
2233
2234 =item QEMU
2235
2236 Use a specific qemu binary (can be overridden with B<-Q>) and flags
2237 when booting this script under qemu. If QEMU_FLAGS variable is also
2238 specified flags specified in QEMU variable are replaced by those in
2239 QEMU_FLAGS.
2240
2241 =item QEMU_FLAGS
2242
2243 Use specific qemu flags (can be overridden with B<-q>).
2244
2245 =item UBOOT_CMD
2246
2247 See L</--uboot-cmd>.
2248
2249 =item WVDESC
2250
2251 Description of the WvTest-compliant program.
2252
2253 =item WVTEST_TIMEOUT
2254
2255 The timeout in seconds for WvTest harness. If no complete line appears
2256 in the test output within the time specified here, the test fails. It
2257 is necessary to specify this for long running tests that produce no
2258 intermediate output.
2259
2260 =back
2261
2262 =head1 CONFIGURATION FILES
2263
2264 Novaboot can read its configuration from one or more files. By
2265 default, novaboot looks for files in F</etc/novaboot.d>, file
2266 F<~/.config/novaboot> and files named F<.novaboot> as described in
2267 L</Configuration reading phase>. Alternatively, configuration file
2268 location can be specified with the B<-c> switch or with the
2269 NOVABOOT_CONFIG environment variable. The configuration file has Perl
2270 syntax (i.e. it is better to put C<1;> as the last line) and should set
2271 values of certain Perl variables. The current configuration can be
2272 dumped with the B<--dump-config> switch. Some configuration variables
2273 can be overridden by environment variables (see below) or by command
2274 line switches.
2275
2276 Supported configuration variables include:
2277
2278 =over 8
2279
2280 =item $builddir
2281
2282 Build directory location relative to the location of the configuration
2283 file.
2284
2285 =item $default_target
2286
2287 Default target (see below) to use when no target is explicitly
2288 specified with the B<--target> command line option or
2289 B<NOVABOOT_TARGET> environment variable.
2290
2291 =item %targets
2292
2293 Hash of target definitions to be used with the B<--target> option. The
2294 key is the identifier of the target, the value is the string with
2295 command line options. For instance, if the configuration file contains:
2296
2297  $targets{'mybox'} = '--server=boot:/tftproot --serial=/dev/ttyUSB0 --grub',
2298
2299 then the following two commands are equivalent:
2300
2301  ./myos --server=boot:/tftproot --serial=/dev/ttyUSB0 --grub
2302  ./myos -t mybox
2303
2304 =back
2305
2306 =head1 ENVIRONMENT VARIABLES
2307
2308 Some options can be specified not only via config file or command line
2309 but also through environment variables. Environment variables override
2310 the values from the configuration file and command line parameters
2311 override the environment variables.
2312
2313 =over 8
2314
2315 =item NOVABOOT_CONFIG
2316
2317 Name of the novaboot configuration file to use instead of the default
2318 one(s).
2319
2320 =item NOVABOOT_CONFIG_DIR
2321
2322 Name of the novaboot configuration directory. When not specified
2323 F</etc/novaboot.d> is used.
2324
2325 =item NOVABOOT_TARGET
2326
2327 Name of the novaboot target to use. This overrides the value of
2328 B<$default_target> from the configuration file and can be overridden
2329 with the B<--target> command line option.
2330
2331 =item NOVABOOT_BENDER
2332
2333 Defining this variable has the same effect as using B<--bender>
2334 option.
2335
2336 =back
2337
2338 =head1 AUTHORS
2339
2340 Michal Sojka <sojka@os.inf.tu-dresden.de>
2341
2342 Latest novaboot version can be found at
2343 L<https://github.com/wentasah/novaboot>.
2344
2345 =cut
2346
2347 # LocalWords:  novaboot Novaboot NOVABOOT TFTP PXE DHCP filename stty
2348 # LocalWords:  chainloader stdout Qemu qemu preprocessing ISOLINUX bootable
2349 # LocalWords:  config subprocesses sudo sudoers tftp dhcp IDE stdin
2350 # LocalWords:  subdirectories TTY whitespace heredoc POSIX WvTest