novaboot

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