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