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