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 IP address of $netif";
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
1103         my ($matched_pattern_position, $error,
1104             $successfully_matching_string,
1105             $before_match, $after_match) =
1106                 $exp->expect($timeout, $uboot_prompt);
1107         die "No U-Boot prompt: $error" if $error;
1108         #print "\n>>>>$before_match<<<<\n";
1109     }
1110
1111     # Load files if there are some load lines in the script
1112     if (scalar(@$modules) > 0  && !$variables->{NO_BOOT}) {
1113         my ($kbin, $kcmd) = split(' ', shift(@$modules), 2);
1114         my $dtb;
1115         @$modules = map { if (/\.dtb$/) { $dtb=$_; (); } else { $_ } } @$modules;
1116         my $initrd = shift @$modules;
1117
1118         if (defined $kbin) {
1119             die "No '--uboot-addr kernel' given" unless $uboot_addr{kernel};
1120             $exp->send("tftpboot $uboot_addr{kernel} $prefix$kbin\n");
1121             $exp->expect(10,
1122                          [qr/##/, sub { exp_continue; }],
1123                          $uboot_prompt) || die "Kernel load timeout";
1124         }
1125         if (defined $dtb) {
1126             die "No '--uboot-addr fdt' given" unless $uboot_addr{fdt};
1127             $exp->send("tftpboot $uboot_addr{fdt} $prefix$dtb\n");
1128             $exp->expect(10,
1129                          [qr/##/, sub { exp_continue; }],
1130                          $uboot_prompt) || die "Device tree load timeout";
1131         }
1132         if (defined $initrd) {
1133             die "No '--uboot-addr ramdisk' given" unless $uboot_addr{ramdisk};
1134             $exp->send("tftpboot $uboot_addr{ramdisk} $prefix$initrd\n");
1135             $exp->expect(10,
1136                          [qr/##/, sub { exp_continue; }],
1137                          $uboot_prompt) || die "Initrd load timeout";
1138         } else {
1139             $uboot_addr{ramdisk} = '-';
1140         }
1141
1142         $kcmd //= '';
1143         $exp->send("setenv bootargs $kcmd\n");
1144         $exp->expect(5, $uboot_prompt)  || die "U-Boot prompt timeout";
1145
1146     }
1147     $uboot_cmd //= $variables->{UBOOT_CMD} // 'bootm $kernel_addr $ramdisk_addr $fdt_addr';
1148     if (!$variables->{NO_BOOT} && $uboot_cmd ne '') {
1149         $uboot_cmd =~ s/\$kernel_addr/$uboot_addr{kernel}/g;
1150         $uboot_cmd =~ s/\$ramdisk_addr/$uboot_addr{ramdisk}/g;
1151         $uboot_cmd =~ s/\$fdt_addr/$uboot_addr{fdt}/g;
1152
1153         $exp->send($uboot_cmd . "\n");
1154         $exp->expect(5, "\n")  || die "U-Boot command timeout";
1155     }
1156 }
1157
1158 ### Serial line interaction
1159 if ($interaction && defined $exp) {
1160     # Serial line of the target is available
1161     my $interrupt = 'Ctrl-C';
1162     if ($interactive && !@exiton) {
1163         $interrupt = '"~~."';
1164     }
1165     print STDERR "novaboot: Serial line interaction (press $interrupt to interrupt)...\n";
1166     $exp->log_stdout(1);
1167     if (@exiton) {
1168         $exp->expect($exiton_timeout, @expect_raw, @exiton) || die("exiton timeout");
1169     } else {
1170         my @inputs = ($exp);
1171         my $infile = new IO::File;
1172         $infile->IO::File::fdopen(*STDIN,'r');
1173         my $in_object = Expect->exp_init($infile);
1174         $in_object->set_group($exp);
1175
1176         if ($interactive) {
1177             $in_object->set_seq('~~\.', sub { print STDERR "novaboot: Escape sequence detected\r\n"; undef; });
1178             $in_object->manual_stty(0);   # Use raw terminal mode
1179         } else {
1180             $in_object->manual_stty(1);   # Do not modify terminal settings
1181         }
1182         push(@inputs, $in_object);
1183         #use Data::Dumper;
1184         #print Dumper(\@expect_raw);
1185         $exp->expect(undef, @expect_raw) if @expect_raw;
1186         Expect::interconnect(@inputs) unless defined($exp->exitstatus);
1187     }
1188 }
1189
1190 ## Kill dhcpc or tftpd
1191 if (defined $dhcp_tftp || defined $tftp) {
1192     die("novaboot: This should kill servers on background\n");
1193 }
1194
1195 # Always finish novaboot output with newline
1196 print "\n" if $final_eol;
1197
1198 ## Documentation
1199
1200 =encoding utf8
1201 =head1 NAME
1202
1203 novaboot - Boots a locally compiled operating system on a remote
1204 target or in qemu
1205
1206 =head1 SYNOPSIS
1207
1208 B<novaboot> --help
1209
1210 B<novaboot> [option]... [--] script...
1211
1212 B<./script> [option]...
1213
1214 =head1 DESCRIPTION
1215
1216 Novaboot makes booting of a locally compiled operating system (OS)
1217 (e.g. NOVA or Linux) on remote targets as simple as running a program
1218 locally. It automates things like copying OS images to a TFTP server,
1219 generation of bootloader configuration files, resetting of target
1220 hardware or redirection of target's serial line to stdin/out. Novaboot
1221 is highly configurable and makes it easy to boot a single image on
1222 different targets or different images on a single target.
1223
1224 Novaboot operation is controlled by configuration files, command line
1225 options and by a so called novaboot script, which can be thought as a
1226 generalization of bootloader configuration files (see L</"NOVABOOT
1227 SCRIPT SYNTAX">). Typical way of using novaboot is to make the
1228 novaboot script executable and set its first line to I<#!/usr/bin/env
1229 novaboot>. Then, booting a particular OS configuration becomes the
1230 same as executing a local program – the novaboot script.
1231
1232 Novaboot uses configuration files to, among other things, define
1233 command line options needed for different targets. Users typically use
1234 only the B<-t>/B<--target> command line option to select the target.
1235 Internally, this option expands to the pre-configured options.
1236 Configuration files are searched at multiple places, which allows to
1237 have per-system, per-user or per-project configurations. Configuration
1238 file syntax is described in section L</"CONFIGURATION FILES">.
1239
1240 Simple examples of using C<novaboot>:
1241
1242 =over 3
1243
1244 =item 1.
1245
1246 Run an OS in Qemu. This can be specified with the B<--qemu> option.
1247 Thus running
1248
1249  novaboot --qemu myos
1250
1251 (or C<./myos --qemu> as described above) will run Qemu and make it
1252 boot the configuration specified in the F<myos> script.
1253
1254 =item 2.
1255
1256 Create a bootloader configuration file (currently supported
1257 bootloaders are GRUB, GRUB2, ISOLINUX, Pulsar and U-Boot) and copy it
1258 with all other files needed for booting to a remote boot server. Then
1259 use a TCP/IP-controlled relay/serial-to-TCP converter to reset the
1260 target and receive its serial output.
1261
1262  ./myos --grub2 --server=192.168.1.1:/tftp --iprelay=192.168.1.2
1263
1264 Alternatively, you can put these switches to the configuration file
1265 and run:
1266
1267  ./myos --target mytarget
1268
1269 =item 3.
1270
1271 Run DHCP and TFTP server on developer's machine to boot the target
1272 from it.
1273
1274  ./myos --dhcp-tftp
1275
1276 This is useful when no network infrastructure is in place and
1277 the target is connected directly to developer's box.
1278
1279 =item 4.
1280
1281 Create bootable ISO image.
1282
1283  novaboot --iso -- script1 script2
1284
1285 The created ISO image will have ISOLINUX bootloader installed on it
1286 and the boot menu will allow selecting between I<script1> and
1287 I<script2> configurations.
1288
1289 =back
1290
1291 =head1 PHASES AND OPTIONS
1292
1293 Novaboot performs its work in several phases. Each phase can be
1294 influenced by several command line options, certain phases can be
1295 skipped. The list of phases (in the execution order) is as follows.
1296
1297 =over
1298
1299 =item 1. L<Configuration reading|/Configuration reading phase>
1300
1301 =item 2. L<Command line processing|/Command line processing phase>
1302
1303 =item 3. L<Script preprocessing|/Script preprocessing phase>
1304
1305 =item 4. L<File generation|/File generation phase>
1306
1307 =item 5. L<Target connection|/Target connection check>
1308
1309 =item 6. L<File deployment|/File deployment phase>
1310
1311 =item 7. L<Target power-on and reset|/Target power-on and reset phase>
1312
1313 =item 8. L<Interaction with the bootloader|/Interaction with the bootloader on the target>
1314
1315 =item 9. L<Target interaction|/Target interaction phase>
1316
1317 =back
1318
1319 Each phase is described in the following sections together with the
1320 command line options that control it.
1321
1322 =head2 Configuration reading phase
1323
1324 After starting, novaboot reads configuration files. Their content is
1325 described in section L</"CONFIGURATION FILES">. By default,
1326 configuration is read from multiple locations. First from the system
1327 configuration directory (F</etc/novaboot.d/>), second from the user
1328 configuration file (F<~/.config/novaboot>) and third from F<.novaboot>
1329 files along the path to the current directory. Alternatively, a single
1330 configuration file specified with the B<-c> switch or with the
1331 C<NOVABOOT_CONFIG> environment variable is read. The latter read files
1332 override settings from the former ones.
1333
1334 The system configuration directory is determined by the content of
1335 NOVABOOT_CONFIG_DIR environment variable and defaults to
1336 F</etc/novaboot.d>. Files in this directory with names consisting
1337 solely of English letters, numbers, dashes '-' and underscores '_'
1338 (note that dot '.' is not included) are read in alphabetical order.
1339
1340 Then, the user configuration file is read from
1341 F<$XDG_CONFIG_HOME/novaboot>. If C<$XDG_CONFIG_HOME> environemnt
1342 variable is not set F<~/.config/novaboot> is read instead.
1343
1344 Finally, novaboot searches for files named F<.novaboot> starting from the
1345 directory of the novaboot script (or working directory, see bellow)
1346 and continuing upwards up to the root directory. The found
1347 configuration files are then read in the opposite order (i.e. from the
1348 root directory downwards). This allows to have, for example, a project
1349 specific configuration in F<~/project/.novaboot>.
1350
1351 Note the difference between F<~/.config/novaboot> and F<~/.novaboot>.
1352 The former one is read always, whereas the latter only when novaboot
1353 script or working directory is under the C<$HOME> directory.
1354
1355 In certain cases, the location of the novaboot script cannot be
1356 determined in this early phase. This happens either when the script is
1357 read from the standard input or when novaboot is invoked explicitly as
1358 in the example L</"4."> above. In this case the current working
1359 directory is used as a starting point for configuration file search
1360 instead of the novaboot script directory.
1361
1362 =over 8
1363
1364 =item -c, --config=I<filename>
1365
1366 Use the specified configuration file instead of the default one(s).
1367
1368 =back
1369
1370 =head2 Command line processing phase
1371
1372 =over 8
1373
1374 =item --dump-config
1375
1376 Dump the current configuration to stdout end exit. Useful as an
1377 initial template for a configuration file.
1378
1379 =item -h, --help
1380
1381 Print short (B<-h>) or long (B<--help>) help.
1382
1383 =item -t, --target=I<target>
1384
1385 This option serves as a user configurable shortcut for other novaboot
1386 options. The effect of this option is the same as specifying the
1387 options stored in the C<%targets> configuration variable under key
1388 I<target>. See also L</"CONFIGURATION FILES">.
1389
1390 When this option is not given, novaboot tries to determine the target
1391 to use from either B<NOVABOOT_TARGET> environment variable or from
1392 B<$default_target> configuration file variable.
1393
1394 =back
1395
1396 =head2 Script preprocessing phase
1397
1398 This phases allows to modify the parsed novaboot script before it is
1399 used in the later phases.
1400
1401 =over 8
1402
1403 =item -a, --append=I<parameters>
1404
1405 Append a string to the first C<load> line in the novaboot script. This
1406 can be used to append parameters to the kernel's or root task's
1407 command line. This option can appear multiple times.
1408
1409 =item -b, --bender
1410
1411 Use L<bender|https://github.com/TUD-OS/morbo/blob/master/standalone/bender.c>
1412 chainloader. Bender scans the PCI bus for PCI serial ports and stores
1413 the information about them in the BIOS data area for use by the
1414 kernel.
1415
1416 =item --chainloader=I<chainloader>
1417
1418 Specifies a chainloader that is loaded before the kernel and other
1419 files specified in the novaboot script. E.g. 'bin/boot/bender
1420 promisc'.
1421
1422 =item --dump
1423
1424 Print the modules to boot and their parameters after this phase
1425 finishes. Then exit. This is useful for seeing the effect of other
1426 options in this section.
1427
1428 =item -k, --kernel=F<file>
1429
1430 Replace the first word on the first C<load> line in the novaboot
1431 script with F<file>.
1432
1433 =item --scriptmod=I<perl expression>
1434
1435 When novaboot script is read, I<perl expression> is executed for every
1436 line (in $_ variable). For example, C<novaboot
1437 --scriptmod=s/sigma0/omega6/g> replaces every occurrence of I<sigma0>
1438 in the script with I<omega6>.
1439
1440 When this option is present, it overrides I<$script_modifier> variable
1441 from the configuration file, which has the same effect. If this option
1442 is given multiple times all expressions are evaluated in the command
1443 line order.
1444
1445 =back
1446
1447 =head2 File generation phase
1448
1449 In this phase, files needed for booting are generated in a so called
1450 I<build directory> (see L</--build-dir>). In most cases configuration
1451 for a bootloader is generated automatically by novaboot. It is also
1452 possible to generate other files using I<heredoc> or I<"<"> syntax in
1453 novaboot scripts. Finally, binaries can be generated in this phases by
1454 running C<scons> or C<make>.
1455
1456 =over 8
1457
1458 =item --build-dir=I<directory>
1459
1460 Overrides the default build directory location.
1461
1462 The default build directory location is determined as follows: If the
1463 configuration file defines the C<$builddir> variable, its value is
1464 used. Otherwise, it is the directory that contains the first processed
1465 novaboot script.
1466
1467 See also L</BUILDDIR> variable.
1468
1469 =item -g, --grub[=I<filename>]
1470
1471 Generates grub bootloader menu file. If the I<filename> is not
1472 specified, F<menu.lst> is used. The I<filename> is relative to the
1473 build directory (see B<--build-dir>).
1474
1475 =item --grub-preamble=I<prefix>
1476
1477 Specifies the I<preable> that is at the beginning of the generated
1478 GRUB or GRUB2 config files. This is useful for specifying GRUB's
1479 timeout.
1480
1481 =item --prefix=I<prefix>
1482
1483 Specifies I<prefix> (e.g. F</srv/tftp>) that is put in front of every
1484 file name in generated bootloader configuration files (or in U-Boot
1485 commands).
1486
1487 If the I<prefix> contains string $NAME, it will be replaced with the
1488 name of the novaboot script (see also B<--name>).
1489
1490 If the I<prefix> contains string $BUILDDIR, it will be replaced with
1491 the build directory (see also B<--build-dir>).
1492
1493 =item --grub-prefix
1494
1495 Alias for B<--prefix>.
1496
1497 =item --grub2[=I<filename>]
1498
1499 Generate GRUB2 menu entry in I<filename>. If I<filename> is not
1500 specified F<grub.cfg> is used. The content of the menu entry can be
1501 customized with B<--grub-preamble>, B<--grub2-prolog> or
1502 B<--grub_prefix> options.
1503
1504 In order to use the the generated menu entry on your development
1505 machine that uses GRUB2, append the following snippet to
1506 F</etc/grub.d/40_custom> file and regenerate your grub configuration,
1507 i.e. run update-grub on Debian/Ubuntu.
1508
1509   if [ -f /path/to/nul/build/grub.cfg ]; then
1510     source /path/to/nul/build/grub.cfg
1511   fi
1512
1513 =item --grub2-prolog=I<prolog>
1514
1515 Specifies text that is put at the beginning of the GRUB2 menu entry.
1516
1517 =item -m, --make[=make command]
1518
1519 Runs C<make> to build files that are not generated by novaboot itself.
1520
1521 =item --name=I<string>
1522
1523 Use the name I<string> instead of the name of the novaboot script.
1524 This name is used for things like a title of grub menu or for the
1525 server directory where the boot files are copied to.
1526
1527 =item --no-file-gen
1528
1529 Do not run external commands to generate files (i.e. "<" syntax and
1530 C<run> keyword). This switch does not influence generation of files
1531 specified with "<<WORD" syntax.
1532
1533 =item -p, --pulsar[=mac]
1534
1535 Generates pulsar bootloader configuration file named F<config-I<mac>>
1536 The I<mac> string is typically a MAC address and defaults to
1537 I<novaboot>.
1538
1539 =item --scons[=scons command]
1540
1541 Runs C<scons> to build files that are not generated by novaboot
1542 itself.
1543
1544 =item --strip-rom
1545
1546 Strip I<rom://> prefix from command lines and generated config files.
1547 The I<rom://> prefix is used by NUL. For NRE, it has to be stripped.
1548
1549 =item --gen-only
1550
1551 Exit novaboot after file generation phase.
1552
1553 =back
1554
1555 =head2 Target connection check
1556
1557 If supported by the target, the connection to it is made and it is
1558 checked whether the target is not occupied by another novaboot
1559 user/instance.
1560
1561 =over 8
1562
1563 =item --amt=I<"[user[:password]@]host[:port]>
1564
1565 Use Intel AMT technology to control the target machine. WS management
1566 is used to powercycle it and Serial-Over-Lan (SOL) for input/output.
1567 The hostname or (IP address) is given by the I<host> parameter. If
1568 I<password> is not specified, environment variable AMT_PASSWORD is
1569 used. The I<port> specifies a TCP port for SOL. If not specified, the
1570 default is 16992. Default I<user> is admin.
1571
1572 =item --iprelay=I<addr[:port]>
1573
1574 Use TCP/IP relay and serial port to access the target's serial port
1575 and powercycle it. The IP address of the relay is given by I<addr>
1576 parameter. If I<port> is not specified, it default to 23.
1577
1578 Note: This option is supposed to work with HWG-ER02a IP relays.
1579
1580 =item -s, --serial[=device]
1581
1582 Target's serial line is connected to host's serial line (device). The
1583 default value for device is F</dev/ttyUSB0>.
1584
1585 The value of this option is exported in NB_NOVABOOT environment
1586 variable to all subprocesses run by C<novaboot>.
1587
1588 =item --stty=I<settings>
1589
1590 Specifies settings passed to C<stty> invoked on the serial line
1591 specified with B<--serial> option. If this option is not given,
1592 C<stty> is called with C<raw -crtscts -onlcr 115200> settings.
1593
1594 =item --remote-cmd=I<cmd>
1595
1596 Command that mediates connection to the target's serial line. For
1597 example C<ssh server 'cu -l /dev/ttyS0'>.
1598
1599 =item --remote-expect=I<string>
1600
1601 Wait for reception of I<string> after establishing the remote
1602 connection.
1603
1604 =item --remote-expect-silent=I<string>
1605
1606 The same as B<--remote-expect> except that the remote output is not
1607 echoed to stdout while waiting for the I<string>. Everything after the
1608 matched string is printed to stdout, so you may want to include line
1609 end characters in the I<string> as well.
1610
1611 =back
1612
1613 =head2 File deployment phase
1614
1615 In some setups, it is necessary to copy the files needed for booting
1616 to a particular location, e.g. to a TFTP boot server or to the
1617 F</boot> partition.
1618
1619 =over 8
1620
1621 =item -d, --dhcp-tftp
1622
1623 Turns your workstation into a DHCP and TFTP server so that the OS can
1624 be booted via PXE BIOS (or similar mechanism) on the test machine
1625 directly connected by a plain Ethernet cable to your workstation.
1626
1627 The DHCP and TFTP servers requires root privileges and C<novaboot>
1628 uses C<sudo> command to obtain those. You can put the following to
1629 I</etc/sudoers> to allow running the necessary commands without asking
1630 for password.
1631
1632  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
1633  your_login ALL=NOPASSWD: NOVABOOT
1634
1635 =item --tftp
1636
1637 Starts a TFTP server on your workstation. This is similar to
1638 B<--dhcp-tftp> except that DHCP server is not started.
1639
1640 The TFTP server require root privileges and C<novaboot> uses C<sudo>
1641 command to obtain those. You can put the following to I</etc/sudoers>
1642 to allow running the necessary commands without asking for password.
1643
1644  Cmnd_Alias NOVABOOT =  /usr/sbin/in.tftpd --listen --secure -v -v -v --pidfile tftpd.pid *, /usr/bin/pkill --pidfile=tftpd.pid
1645  your_login ALL=NOPASSWD: NOVABOOT
1646
1647 =item --tftp-port=I<port>
1648
1649 Port to run the TFTP server on. Implies B<--tftp>.
1650
1651 =item --netif=I<network interface>
1652
1653 Network interface used to deploy files to the target. Default value is
1654 I<eth0>. This influences the configuration of the DHCP server started
1655 by B<--dhcp-tftp> and the value that B<$NB_MYIP> get replaced with in
1656 U-Boot conversation.
1657
1658 =item --iso[=filename]
1659
1660 Generates the ISO image that boots NOVA system via GRUB. If no filename
1661 is given, the image is stored under I<NAME>.iso, where I<NAME> is the name
1662 of the novaboot script (see also B<--name>).
1663
1664 =item --server[=[[user@]server:]path]
1665
1666 Copy all files needed for booting to another location. The files will
1667 be copied (by B<rsync> tool) to the directory I<path>. If the I<path>
1668 contains string $NAME, it will be replaced with the name of the
1669 novaboot script (see also B<--name>).
1670
1671 =item --rsync-flags=I<flags>
1672
1673 Specifies which I<flags> are appended to F<rsync> command line when
1674 copying files as a result of I<--server> option.
1675
1676 =item --concat
1677
1678 If B<--server> is used and its value ends with $NAME, then after
1679 copying the files, a new bootloader configuration file (e.g. menu.lst)
1680 is created at I<path-wo-name>, i.e. the path specified by B<--server>
1681 with $NAME part removed. The content of the file is created by
1682 concatenating all files of the same name from all subdirectories of
1683 I<path-wo-name> found on the "server".
1684
1685 =item --ider
1686
1687 Use Intel AMT technology for IDE redirection. This allows the target
1688 machine to boot from novaboot created ISO image. Implies B<--iso>.
1689
1690 The experimental C<amtider> utility needed by this option can be
1691 obtained from https://github.com/wentasah/amtterm.
1692
1693 =back
1694
1695 =head2 Target power-on and reset phase
1696
1697 At this point, the target is reset (or switched on/off). There is
1698 several ways how this can be accomplished. Resetting a physical target
1699 can currently be accomplished by the following options: B<--amt>,
1700 B<--iprelay>, B<--reset-cmd> and B<--reset-send>.
1701
1702 =over 8
1703
1704 =item --on, --off
1705
1706 Switch on/off the target machine and exit. The script (if any) is
1707 completely ignored. Currently it works only with B<--iprelay> or
1708 B<--amt>.
1709
1710 =item -Q, --qemu[=I<qemu-binary>]
1711
1712 Boot the configuration in qemu. Optionally, the name of qemu binary
1713 can be specified as a parameter.
1714
1715 =item --qemu-append=I<flags>
1716
1717 Append I<flags> to the default qemu flags (QEMU_FLAGS variable or
1718 C<-cpu coreduo -smp 2>).
1719
1720 =item -q, --qemu-flags=I<flags>
1721
1722 Replace the default qemu flags (QEMU_FLAGS variable or C<-cpu coreduo
1723 -smp 2>) with I<flags> specified here.
1724
1725 =item --reset-cmd=I<cmd>
1726
1727 Command that resets the target.
1728
1729 =item --reset-send=I<string>
1730
1731 Reset the target by sending the given I<string> to the remote serial
1732 line. "\n" sequences are replaced with newline character.
1733
1734 =item --no-reset, --reset
1735
1736 Disable/enable resetting of the target.
1737
1738 =back
1739
1740 =head2 Interaction with the bootloader on the target
1741
1742 =over 8
1743
1744 =item --uboot[=I<prompt>]
1745
1746 Interact with U-Boot bootloader to boot the thing described in the
1747 novaboot script. I<prompt> specifies the U-Boot's prompt (default is
1748 "=> ", other common prompts are "U-Boot> " or "U-Boot# ").
1749 Implementation of this option is currently tied to a particular board
1750 that we use. It may be subject to changes in the future!
1751
1752 =item --no-uboot
1753
1754 Disable U-Boot interaction previously enabled with B<--uboot>.
1755
1756 =item --uboot-init
1757
1758 Command(s) to send the U-Boot bootloader before loading the images and
1759 booting them. This option can be given multiple times. After sending
1760 commands from each option novaboot waits for U-Boot I<prompt>.
1761
1762 If the command contains string I<$NB_MYIP> then this string is
1763 replaced by IPv4 address of eth0 interface (see also B<--netif>).
1764 Similarly I<$NB_PREFIX> is replaced with prefix given by B<--prefix>.
1765
1766 See also C<uboot> keyword in L</"NOVABOOT SCRIPT SYNTAX">).
1767
1768 =item --uboot-addr I<name>=I<address>
1769
1770 Load address of U-Boot's C<tftpboot> command for loading I<name>,
1771 where name is one of I<kernel>, I<ramdisk> or I<fdt> (flattened device
1772 tree).
1773
1774 The default addresses are ${I<name>_addr_r}, i.e. U-Boot environment
1775 variables used by convention for this purpose.
1776
1777 =item --uboot-cmd=I<command>
1778
1779 Specifies U-Boot command used to execute the OS. If the command
1780 contains strings C<$kernel_addr>, C<$ramdisk_addr>, C<$fdt_addr>,
1781 these are replaced with the addresses configured with B<--uboot-addr>.
1782
1783 The default value is
1784
1785     bootm $kernel_addr $ramdisk_addr $fdt_addr
1786
1787 or the C<UBOOT_CMD> variable if defined in the novaboot script.
1788
1789 =back
1790
1791 =head2 Target interaction phase
1792
1793 In this phase, target's serial output is redirected to stdout and if
1794 stdin is a TTY, it is redirected to the target's serial input allowing
1795 interactive work with the target.
1796
1797 =over 8
1798
1799 =item --exiton=I<string>
1800
1801 When I<string> is sent by the target, novaboot exits. This option can
1802 be specified multiple times, in which case novaboot exits whenever
1803 either of the specified strings is sent.
1804
1805 If I<string> is C<-re>, then the next B<--exiton>'s I<string> is
1806 treated as regular expression. For example:
1807
1808     --exiton -re --exiton 'error:.*failed'
1809
1810 =item --exiton-re=I<regex>
1811
1812 The same as --exiton -re --exiton I<regex>.
1813
1814 =item --exiton-timeout=I<seconds>
1815
1816 By default B<--exiton> waits for the string match forever. When this
1817 option is specified, "exiton" timeouts after the specifies number of
1818 seconds and novaboot returns non-zero exit code.
1819
1820 =item -i, --interactive
1821
1822 Setup things for interactive use of target. Your terminal will be
1823 switched to raw mode. In raw mode, your system does not process input
1824 in any way (no echoing of entered characters, no interpretation
1825 special characters). This, among others, means that Ctrl-C is passed
1826 to the target and does no longer interrupt novaboot. Use "~~."
1827 sequence to exit novaboot.
1828
1829 =item --no-interaction, --interaction
1830
1831 Skip resp. force target interaction phase. When skipped, novaboot exits
1832 immediately when boot is initiated.
1833
1834 =item --expect=I<string>
1835
1836 When I<string> is received from the target, send the string specified
1837 with the subsequent B<--send*> option to the target.
1838
1839 =item --expect-re=I<regex>
1840
1841 When target's output matches regular expression I<regex>, send the
1842 string specified with the subsequent B<--send*> option to the target.
1843
1844 =item --expect-raw=I<perl-code>
1845
1846 Provides direct control over Perl's Expect module.
1847
1848 =item --send=I<string>
1849
1850 Send I<string> to the target after the previously specified
1851 B<--expect*> was matched in the target's output. The I<string> may
1852 contain escape sequences such as "\n".
1853
1854 Note that I<string> is actually interpreted by Perl, so it can contain
1855 much more that escape sequences. This behavior may change in the
1856 future.
1857
1858 Example: C<--expect='login: ' --send='root\n'>
1859
1860 =item --sendcont=I<string>
1861
1862 Similar to B<--send> but continue expecting more input.
1863
1864 Example: C<--expect='Continue?' --sendcont='yes\n'>
1865
1866 =item --final-eol, --no-final-eol
1867
1868 By default, B<novaboot> always prints an end-of-line character at the
1869 end of its execution in order to ensure that the output of programs
1870 started after novaboot appears at the beginning of the line. When this
1871 is not desired B<--no-final-eol> option can be used to override this
1872 behavior.
1873
1874 =back
1875
1876 =head1 NOVABOOT SCRIPT SYNTAX
1877
1878 The syntax tries to mimic POSIX shell syntax. The syntax is defined
1879 with the following rules.
1880
1881 Lines starting with "#" and empty lines are ignored.
1882
1883 Lines that end with "\" are concatenated with the following line after
1884 removal of the final "\" and leading whitespace of the following line.
1885
1886 Lines of the form I<VARIABLE=...> (i.e. matching '^[A-Z_]+=' regular
1887 expression) assign values to internal variables. See L</VARIABLES>
1888 section.
1889
1890 Lines starting with C<load> keyword represent modules to boot. The
1891 word after C<load> is a file name (relative to the build directory
1892 (see B<--build-dir>) of the module to load and the remaining words are
1893 passed to it as the command line parameters.
1894
1895 When the C<load> line ends with "<<WORD" then the subsequent lines
1896 until the line containing solely WORD are copied literally to the file
1897 named on that line. This is similar to shell's heredoc feature.
1898
1899 When the C<load> line ends with "< CMD" then command CMD is executed
1900 with F</bin/sh> and its standard output is stored in the file named on
1901 that line. The SRCDIR variable in CMD's environment is set to the
1902 absolute path of the directory containing the interpreted novaboot
1903 script.
1904
1905 Lines starting with C<run> keyword contain shell commands that are run
1906 during file generation phase. This is the same as the "< CMD" syntax
1907 for C<load> keyboard except that the command's output is not
1908 redirected to a file. The ordering of commands is the same as they
1909 appear in the novaboot script.
1910
1911 Lines starting with C<uboot> represent U-Boot commands that are sent
1912 to the target if B<--uboot> option is given. Having a U-Boot line in
1913 the novaboot script is the same as passing an equivalent
1914 B<--uboot-init> option to novaboot. The C<uboot> keyword can be
1915 suffixed with timeout specification. The syntax is C<uboot:Ns>, where
1916 C<N> is the whole number of seconds. If the U-Boot command prompt does
1917 not appear before the timeout, novaboot fails. The default timeout is
1918 10 seconds.
1919
1920 Example (Linux):
1921
1922   #!/usr/bin/env novaboot
1923   load bzImage console=ttyS0,115200
1924   run  make -C buildroot
1925   load rootfs.cpio < gen_cpio buildroot/images/rootfs.cpio "myapp->/etc/init.d/S99myapp"
1926
1927 Example (NOVA User Land - NUL):
1928
1929   #!/usr/bin/env novaboot
1930   WVDESC=Example program
1931   load bin/apps/sigma0.nul S0_DEFAULT script_start:1,1 \
1932                            verbose hostkeyb:0,0x60,1,12,2
1933   load bin/apps/hello.nul
1934   load hello.nulconfig <<EOF
1935   sigma0::mem:16 name::/s0/log name::/s0/timer name::/s0/fs/rom ||
1936   rom://bin/apps/hello.nul
1937   EOF
1938
1939 This example will load three modules: F<sigma0.nul>, F<hello.nul> and
1940 F<hello.nulconfig>. sigma0 receives some command line parameters and
1941 F<hello.nulconfig> file is generated on the fly from the lines between
1942 C<<<EOF> and C<EOF>.
1943
1944 =head2 VARIABLES
1945
1946 The following variables are interpreted in the novaboot script:
1947
1948 =over 8
1949
1950 =item BUILDDIR
1951
1952 Novaboot chdir()s to this directory before file generation phase. The
1953 directory name specified here is relative to the build directory
1954 specified by other means (see L</--build-dir>).
1955
1956 =item EXITON
1957
1958 Assigning this variable has the same effect as specifying L</--exiton>
1959 option.
1960
1961 =item HYPERVISOR_PARAMS
1962
1963 Parameters passed to hypervisor. The default value is "serial", unless
1964 overridden in configuration file.
1965
1966 =item KERNEL
1967
1968 The kernel to use instead of the hypervisor specified in the
1969 configuration file with the C<$hypervisor> variable. The value should
1970 contain the name of the kernel image as well as its command line
1971 parameters. If this variable is defined and non-empty, the variable
1972 HYPERVISOR_PARAMS is not used.
1973
1974 =item NO_BOOT
1975
1976 If this variable is 1, the system is not booted. This is currently
1977 only implemented for U-Boot bootloader where it is useful for
1978 interacting with the bootloader without booting the system - e.g. for
1979 flashing.
1980
1981 =item QEMU
1982
1983 Use a specific qemu binary (can be overridden with B<-Q>) and flags
1984 when booting this script under qemu. If QEMU_FLAGS variable is also
1985 specified flags specified in QEMU variable are replaced by those in
1986 QEMU_FLAGS.
1987
1988 =item QEMU_FLAGS
1989
1990 Use specific qemu flags (can be overridden with B<-q>).
1991
1992 =item UBOOT_CMD
1993
1994 See L</--uboot-cmd>.
1995
1996 =item WVDESC
1997
1998 Description of the WvTest-compliant program.
1999
2000 =item WVTEST_TIMEOUT
2001
2002 The timeout in seconds for WvTest harness. If no complete line appears
2003 in the test output within the time specified here, the test fails. It
2004 is necessary to specify this for long running tests that produce no
2005 intermediate output.
2006
2007 =back
2008
2009 =head1 CONFIGURATION FILES
2010
2011 Novaboot can read its configuration from one or more files. By
2012 default, novaboot looks for files in F</etc/novaboot.d>, file
2013 F<~/.config/novaboot> and files named F<.novaboot> as described in
2014 L</Configuration reading phase>. Alternatively, configuration file
2015 location can be specified with the B<-c> switch or with the
2016 NOVABOOT_CONFIG environment variable. The configuration file has Perl
2017 syntax (i.e. it is better to put C<1;> as the last line) and should set
2018 values of certain Perl variables. The current configuration can be
2019 dumped with the B<--dump-config> switch. Some configuration variables
2020 can be overridden by environment variables (see below) or by command
2021 line switches.
2022
2023 Supported configuration variables include:
2024
2025 =over 8
2026
2027 =item $builddir
2028
2029 Build directory location relative to the location of the configuration
2030 file.
2031
2032 =item $default_target
2033
2034 Default target (see below) to use when no target is explicitly
2035 specified with the B<--target> command line option or
2036 B<NOVABOOT_TARGET> environment variable.
2037
2038 =item %targets
2039
2040 Hash of target definitions to be used with the B<--target> option. The
2041 key is the identifier of the target, the value is the string with
2042 command line options. For instance, if the configuration file contains:
2043
2044  $targets{'mybox'} = '--server=boot:/tftproot --serial=/dev/ttyUSB0 --grub',
2045
2046 then the following two commands are equivalent:
2047
2048  ./myos --server=boot:/tftproot --serial=/dev/ttyUSB0 --grub
2049  ./myos -t mybox
2050
2051 =back
2052
2053 =head1 ENVIRONMENT VARIABLES
2054
2055 Some options can be specified not only via config file or command line
2056 but also through environment variables. Environment variables override
2057 the values from configuration file and command line parameters
2058 override the environment variables.
2059
2060 =over 8
2061
2062 =item NOVABOOT_CONFIG
2063
2064 Name of the novaboot configuration file to use instead of the default
2065 one(s).
2066
2067 =item NOVABOOT_CONFIG_DIR
2068
2069 Name of the novaboot configuration directory. When not specified
2070 F</etc/novaboot.d> is used.
2071
2072 =item NOVABOOT_TARGET
2073
2074 Name of the novaboot target to use. This overrides the value of
2075 B<$default_target> from the configuration file and can be overriden
2076 with the B<--target> command line option.
2077
2078 =item NOVABOOT_BENDER
2079
2080 Defining this variable has the same effect as using B<--bender>
2081 option.
2082
2083 =back
2084
2085 =head1 AUTHORS
2086
2087 Michal Sojka <sojka@os.inf.tu-dresden.de>
2088
2089 Latest novaboot version can be found at
2090 L<https://github.com/wentasah/novaboot>.
2091
2092 =cut
2093
2094 # LocalWords:  novaboot Novaboot NOVABOOT TFTP PXE DHCP filename stty
2095 # LocalWords:  chainloader stdout Qemu qemu preprocessing ISOLINUX bootable
2096 # LocalWords:  config subprocesses sudo sudoers tftp dhcp IDE stdin
2097 # LocalWords:  subdirectories TTY whitespace heredoc POSIX WvTest