novaboot

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