reorganize file structure to match the upstream requirements

11 files changed, 2505 insertions, 0 deletions

diff --git a/utils/.gitignore b/utils/.gitignore
new file mode 100644
index 0000000..b96f278
--- /dev/null
+++ b/utils/.gitignore
@@ -0,0 +1,3 @@
+setitimer-helper
+squish-pty
+squish-unix
diff --git a/utils/Makefile b/utils/Makefile
new file mode 100644
index 0000000..46a9124
--- /dev/null
+++ b/utils/Makefile
@@ -0,0 +1,11 @@
+all: setitimer-helper squish-pty squish-unix
+
+CC = gcc
+CFLAGS = -Wall -W
+LDFLAGS = -lm
+setitimer-helper: setitimer-helper.o
+squish-pty: squish-pty.o
+squish-unix: squish-unix.o
+
+clean: 
+        rm -f *.o setitimer-helper squish-pty squish-unix
diff --git a/utils/Pintos.pm b/utils/Pintos.pm
new file mode 100644
index 0000000..70df40d
--- /dev/null
+++ b/utils/Pintos.pm
@@ -0,0 +1,491 @@
+# Pintos helper subroutines.
+
+# Number of bytes available for the loader at the beginning of the MBR.
+# Kernel command-line arguments follow the loader.
+our $LOADER_SIZE = 314;
+
+# Partition types.
+my (%role2type) = (KERNEL => 0x20,
+                   FILESYS => 0x21,
+                   SCRATCH => 0x22,
+                   SWAP => 0x23);
+my (%type2role) = reverse %role2type;
+
+# Order of roles within a given disk.
+our (@role_order) = qw (KERNEL FILESYS SCRATCH SWAP);
+
+# Partitions.
+#
+# Valid keys are KERNEL, FILESYS, SCRATCH, SWAP.  Only those
+# partitions which are in use are included.
+#
+# Each value is a reference to a hash.  If the partition's contents
+# are to be obtained from a file (that will be copied into a new
+# virtual disk), then the hash contains:
+#
+# FILE => name of file from which the partition's contents are copied
+#         (perhaps "/dev/zero"),
+# OFFSET => offset in bytes in FILE,
+# BYTES => size in bytes of contents from FILE,
+#
+# If the partition is taken from a virtual disk directly, then it
+# contains the following.  The same keys are also filled in once a
+# file-based partition has been copied into a new virtual disk:
+#
+# DISK => name of virtual disk file,
+# START => sector offset of start of partition within DISK,
+# SECTORS => number of sectors of partition within DISK, which is usually
+#            greater than round_up (BYTES, 512) due to padding.
+our (%parts);
+
+# set_part($opt, $arg)
+#
+# For use as a helper function for Getopt::Long::GetOptions to set
+# disk sources.
+sub set_part {
+    my ($opt, $arg) = @_;
+    my ($role, $source) = $opt =~ /^([a-z]+)(?:-([a-z]+))?/ or die;
+
+    $role = uc $role;
+    $source = 'FILE' if $source eq '';
+
+    die "can't have two sources for \L$role\E partition"
+      if exists $parts{$role};
+
+    do_set_part ($role, $source, $arg);
+}
+
+# do_set_part($role, $source, $arg)
+#
+# Sets partition $role as coming from $source (one of 'file', 'from',
+# or 'size').  $arg is a file name for 'file' or 'from', a size in
+# megabytes for 'size'.
+sub do_set_part {
+    my ($role, $source, $arg) = @_;
+
+    my ($p) = $parts{$role} = {};
+    if ($source eq 'file') {
+        if (read_mbr ($arg)) {
+            print STDERR "warning: $arg looks like a partitioned disk ";
+            print STDERR "(did you want --$role-from=$arg or --disk=$arg?)\n"
+        }
+
+        $p->{FILE} = $arg;
+        $p->{OFFSET} = 0;
+        $p->{BYTES} = -s $arg;
+    } elsif ($source eq 'from') {
+        my (%pt) = read_partition_table ($arg);
+        my ($sp) = $pt{$role};
+        die "$arg: does not contain \L$role\E partition\n" if !defined $sp;
+
+        $p->{FILE} = $arg;
+        $p->{OFFSET} = $sp->{START} * 512;
+        $p->{BYTES} = $sp->{SECTORS} * 512;
+    } elsif ($source eq 'size') {
+        $arg =~ /^\d+(\.\d+)?|\.\d+$/ or die "$arg: not a valid size in MB\n";
+
+        $p->{FILE} = "/dev/zero";
+        $p->{OFFSET} = 0;
+        $p->{BYTES} = ceil ($arg * 1024 * 1024);
+    } else {
+        die;
+    }
+}
+
+# set_geometry('HEADS,SPT')
+# set_geometry('zip')
+#
+# For use as a helper function for Getopt::Long::GetOptions to set
+# disk geometry.
+sub set_geometry {
+    local ($_) = $_[1];
+    if ($_ eq 'zip') {
+        @geometry{'H', 'S'} = (64, 32);
+    } else {
+        @geometry{'H', 'S'} = /^(\d+)[,\s]+(\d+)$/
+          or die "bad syntax for geometry\n";
+        $geometry{H} <= 255 or die "heads limited to 255\n";
+        $geometry{S} <= 63 or die "sectors per track limited to 63\n";
+    }
+}
+
+# set_align('bochs|full|none')
+#
+# For use as a helper function for Getopt::Long::GetOptions to set
+# partition alignment.
+sub set_align {
+    $align = $_[1];
+    die "unknown alignment type \"$align\"\n"
+      if $align ne 'bochs' && $align ne 'full' && $align ne 'none';
+}
+
+# assemble_disk(%args)
+#
+# Creates a virtual disk $args{DISK} containing the partitions
+# described by @args{KERNEL, FILESYS, SCRATCH, SWAP}.
+#
+# Required arguments:
+#   DISK => output disk file name
+#   HANDLE => output file handle (will be closed)
+#
+# Normally at least one of the following is included:
+#   KERNEL, FILESYS, SCRATCH, SWAP => {input:
+#                                      FILE => file to read,
+#                                      OFFSET => byte offset in file,
+#                                      BYTES => byte count from file,
+#
+#                                      output:
+#                                      DISK => output disk file name,
+#                                      START => sector offset in DISK,
+#                                      SECTORS => sector count in DISK},
+#
+# Optional arguments:
+#   ALIGN => 'bochs' (default), 'full', or 'none'
+#   GEOMETRY => {H => heads, S => sectors per track} (default 16, 63)
+#   FORMAT => 'partitioned' (default) or 'raw'
+#   LOADER => $LOADER_SIZE-byte string containing the loader binary
+#   ARGS => ['arg 1', 'arg 2', ...]
+sub assemble_disk {
+    my (%args) = @_;
+
+    my (%geometry) = $args{GEOMETRY} || (H => 16, S => 63);
+
+    my ($align);        # Align partition start, end to cylinder boundary?
+    my ($pad);          # Pad end of disk out to cylinder boundary?
+    if (!defined ($args{ALIGN}) || $args{ALIGN} eq 'bochs') {
+        $align = 0;
+        $pad = 1;
+    } elsif ($args{ALIGN} eq 'full') {
+        $align = 1;
+        $pad = 0;
+    } elsif ($args{ALIGN} eq 'none') {
+        $align = $pad = 0;
+    } else {
+        die;
+    }
+
+    my ($format) = $args{FORMAT} || 'partitioned';
+    die if $format ne 'partitioned' && $format ne 'raw';
+
+    # Check that we have apartitions to copy in.
+    my $part_cnt = grep (defined ($args{$_}), keys %role2type);
+    die "must have exactly one partition for raw output\n"
+      if $format eq 'raw' && $part_cnt != 1;
+
+    # Calculate the disk size.
+    my ($total_sectors) = 0;
+    if ($format eq 'partitioned') {
+        $total_sectors += $align ? $geometry{S} : 1;
+    }
+    for my $role (@role_order) {
+        my ($p) = $args{$role};
+        next if !defined $p;
+
+        die if $p->{DISK};
+
+        my ($bytes) = $p->{BYTES};
+        my ($start) = $total_sectors;
+        my ($end) = $start + div_round_up ($bytes, 512);
+        $end = round_up ($end, cyl_sectors (%geometry)) if $align;
+
+        $p->{DISK} = $args{DISK};
+        $p->{START} = $start;
+        $p->{SECTORS} = $end - $start;
+        $total_sectors = $end;
+    }
+
+    # Write the disk.
+    my ($disk_fn) = $args{DISK};
+    my ($disk) = $args{HANDLE};
+    if ($format eq 'partitioned') {
+        # Pack loader into MBR.
+        my ($loader) = $args{LOADER} || "\xcd\x18";
+        my ($mbr) = pack ("a$LOADER_SIZE", $loader);
+
+        $mbr .= make_kernel_command_line (@{$args{ARGS}});
+
+        # Pack partition table into MBR.
+        $mbr .= make_partition_table (\%geometry, \%args);
+
+        # Add signature to MBR.
+        $mbr .= pack ("v", 0xaa55);
+
+        die if length ($mbr) != 512;
+        write_fully ($disk, $disk_fn, $mbr);
+        write_zeros ($disk, $disk_fn, 512 * ($geometry{S} - 1)) if $align;
+    }
+    for my $role (@role_order) {
+        my ($p) = $args{$role};
+        next if !defined $p;
+
+        my ($source);
+        my ($fn) = $p->{FILE};
+        open ($source, '<', $fn) or die "$fn: open: $!\n";
+        if ($p->{OFFSET}) {
+            sysseek ($source, $p->{OFFSET}, 0) == $p->{OFFSET}
+              or die "$fn: seek: $!\n";
+        }
+        copy_file ($source, $fn, $disk, $disk_fn, $p->{BYTES});
+        close ($source) or die "$fn: close: $!\n";
+
+        write_zeros ($disk, $disk_fn, $p->{SECTORS} * 512 - $p->{BYTES});
+    }
+    if ($pad) {
+        my ($pad_sectors) = round_up ($total_sectors, cyl_sectors (%geometry));
+        write_zeros ($disk, $disk_fn, ($pad_sectors - $total_sectors) * 512);
+    }
+    close ($disk) or die "$disk: close: $!\n";
+}
+
+# make_partition_table({H => heads, S => sectors}, {KERNEL => ..., ...})
+#
+# Creates and returns a partition table for the given partitions and
+# disk geometry.
+sub make_partition_table {
+    my ($geometry, $partitions) = @_;
+    my ($table) = '';
+    for my $role (@role_order) {
+        defined (my $p = $partitions->{$role}) or next;
+
+        my $end = $p->{START} + $p->{SECTORS} - 1;
+        my $bootable = $role eq 'KERNEL';
+
+        $table .= pack ("C", $bootable ? 0x80 : 0);   # Bootable?
+        $table .= pack_chs ($p->{START}, $geometry);  # CHS of partition start
+        $table .= pack ("C", $role2type{$role});      # Partition type
+        $table .= pack_chs($end, $geometry);          # CHS of partition end
+        $table .= pack ("V", $p->{START});            # LBA of partition start
+        $table .= pack ("V", $p->{SECTORS});          # Length in sectors
+        die if length ($table) % 16;
+    }
+    return pack ("a64", $table);
+}
+
+# make_kernel_command_line(@args)
+#
+# Returns the raw bytes to write to an MBR at offset $LOADER_SIZE to
+# set a Pintos kernel command line.
+sub make_kernel_command_line {
+    my (@args) = @_;
+    my ($args) = join ('', map ("$_\0", @args));
+    die "command line exceeds 128 bytes" if length ($args) > 128;
+    return pack ("V a128", scalar (@args), $args);
+}
+
+# copy_file($from_handle, $from_file_name, $to_handle, $to_file_name, $size)
+#
+# Copies $size bytes from $from_handle to $to_handle.
+# $from_file_name and $to_file_name are used in error messages.
+sub copy_file {
+    my ($from_handle, $from_file_name, $to_handle, $to_file_name, $size) = @_;
+
+    while ($size > 0) {
+        my ($chunk_size) = 4096;
+        $chunk_size = $size if $chunk_size > $size;
+        $size -= $chunk_size;
+
+        my ($data) = read_fully ($from_handle, $from_file_name, $chunk_size);
+        write_fully ($to_handle, $to_file_name, $data);
+    }
+}
+
+# read_fully($handle, $file_name, $bytes)
+#
+# Reads exactly $bytes bytes from $handle and returns the data read.
+# $file_name is used in error messages.
+sub read_fully {
+    my ($handle, $file_name, $bytes) = @_;
+    my ($data);
+    my ($read_bytes) = sysread ($handle, $data, $bytes);
+    die "$file_name: read: $!\n" if !defined $read_bytes;
+    die "$file_name: unexpected end of file\n" if $read_bytes != $bytes;
+    return $data;
+}
+
+# write_fully($handle, $file_name, $data)
+#
+# Write $data to $handle.
+# $file_name is used in error messages.
+sub write_fully {
+    my ($handle, $file_name, $data) = @_;
+    my ($written_bytes) = syswrite ($handle, $data);
+    die "$file_name: write: $!\n" if !defined $written_bytes;
+    die "$file_name: short write\n" if $written_bytes != length $data;
+}
+
+sub write_zeros {
+    my ($handle, $file_name, $size) = @_;
+
+    while ($size > 0) {
+        my ($chunk_size) = 4096;
+        $chunk_size = $size if $chunk_size > $size;
+        $size -= $chunk_size;
+
+        write_fully ($handle, $file_name, "\0" x $chunk_size);
+    }
+}
+
+# div_round_up($x,$y)
+#
+# Returns $x / $y, rounded up to the nearest integer.
+# $y must be an integer.
+sub div_round_up {
+    my ($x, $y) = @_;
+    return int ((ceil ($x) + $y - 1) / $y);
+}
+
+# round_up($x, $y)
+#
+# Returns $x rounded up to the nearest multiple of $y.
+# $y must be an integer.
+sub round_up {
+    my ($x, $y) = @_;
+    return div_round_up ($x, $y) * $y;
+}
+
+# cyl_sectors(H => heads, S => sectors)
+#
+# Returns the number of sectors in a cylinder of a disk with the given
+# geometry.
+sub cyl_sectors {
+    my (%geometry) = @_;
+    return $geometry{H} * $geometry{S};
+}
+
+# read_loader($file_name)
+#
+# Reads and returns the first $LOADER_SIZE bytes in $file_name.
+# If $file_name is undefined, tries to find the default loader.
+# Makes sure that the loader is a reasonable size.
+sub read_loader {
+    my ($name) = @_;
+    $name = find_file ("loader.bin") if !defined $name;
+    die "Cannot find loader\n" if !defined $name;
+
+    my ($handle);
+    open ($handle, '<', $name) or die "$name: open: $!\n";
+    -s $handle == $LOADER_SIZE || -s $handle == 512
+      or die "$name: must be exactly $LOADER_SIZE or 512 bytes long\n";
+    $loader = read_fully ($handle, $name, $LOADER_SIZE);
+    close ($handle) or die "$name: close: $!\n";
+    return $loader;
+}
+
+# pack_chs($lba, {H => heads, S => sectors})
+#
+# Converts logical sector $lba to a 3-byte packed geometrical sector
+# in the format used in PC partition tables (see [Partitions]) and
+# returns the geometrical sector as a 3-byte string.
+sub pack_chs {
+    my ($lba, $geometry) = @_;
+    my ($cyl, $head, $sect) = lba_to_chs ($lba, $geometry);
+    return pack ("CCC", $head, $sect | (($cyl >> 2) & 0xc0), $cyl & 0xff);
+}
+
+# lba_to_chs($lba, {H => heads, S => sectors})
+#
+# Returns the geometrical sector corresponding to logical sector $lba
+# given the specified geometry.
+sub lba_to_chs {
+    my ($lba, $geometry) = @_;
+    my ($hpc) = $geometry->{H};
+    my ($spt) = $geometry->{S};
+
+    # Source:
+    # http://en.wikipedia.org/wiki/CHS_conversion
+    use integer;
+    my $cyl = $lba / ($hpc * $spt);
+    my $temp = $lba % ($hpc * $spt);
+    my $head = $temp / $spt;
+    my $sect = $temp % $spt + 1;
+
+    # Source:
+    # http://www.cgsecurity.org/wiki/Intel_Partition_Table
+    if ($cyl <= 1023) {
+        return ($cyl, $head, $sect);
+    } else {
+        return (1023, 254, 63); ## or should this be (1023, $hpc, $spt)?
+    }
+}
+
+# read_mbr($file)
+#
+# Tries to read an MBR from $file.  Returns the 512-byte MBR if
+# successful, otherwise numeric 0.
+sub read_mbr {
+    my ($file) = @_;
+    my ($retval) = 0;
+    open (FILE, '<', $file) or die "$file: open: $!\n";
+    if (-s FILE == 0) {
+        die "$file: file has zero size\n";
+    } elsif (-s FILE >= 512) {
+        my ($mbr);
+        sysread (FILE, $mbr, 512) == 512 or die "$file: read: $!\n";
+        $retval = $mbr if unpack ("v", substr ($mbr, 510)) == 0xaa55;
+    }
+    close (FILE);
+    return $retval;
+}
+
+# interpret_partition_table($mbr, $disk)
+#
+# Parses the partition-table in the specified 512-byte $mbr and
+# returns the partitions.  $disk is used for error messages.
+sub interpret_partition_table {
+    my ($mbr, $disk) = @_;
+    my (%parts);
+    for my $i (0...3) {
+        my ($bootable, $valid, $type, $lba_start, $lba_length)
+          = unpack ("C X V C x3 V V", substr ($mbr, 446 + 16 * $i, 16));
+        next if !$valid;
+
+        (print STDERR "warning: invalid partition entry $i in $disk\n"),
+          next if $bootable != 0 && $bootable != 0x80;
+
+        my ($role) = $type2role{$type};
+        (printf STDERR "warning: non-Pintos partition type 0x%02x in %s\n",
+         $type, $disk),
+          next if !defined $role;
+
+        (print STDERR "warning: duplicate \L$role\E partition in $disk\n"),
+          next if exists $parts{$role};
+
+        $parts{$role} = {START => $lba_start,
+                         SECTORS => $lba_length};
+    }
+    return %parts;
+}
+
+# find_file($base_name)
+#
+# Looks for a file named $base_name in a couple of likely spots.  If
+# found, returns the name; otherwise, returns undef.
+sub find_file {
+    my ($base_name) = @_;
+    -e && return $_ foreach $base_name, "build/$base_name";
+    return undef;
+}
+
+# read_partition_table($file)
+#
+# Reads a partition table from $file and returns the parsed
+# partitions.  Dies if partitions can't be read.
+sub read_partition_table {
+    my ($file) = @_;
+    my ($mbr) = read_mbr ($file);
+    die "$file: not a partitioned disk\n" if !$mbr;
+    return interpret_partition_table ($mbr, $file);
+}
+
+# max(@args)
+#
+# Returns the numerically largest value in @args.
+sub max {
+    my ($max) = $_[0];
+    foreach (@_[1..$#_]) {
+        $max = $_ if $_ > $max;
+    }
+    return $max;
+}
+
+1;
diff --git a/utils/backtrace b/utils/backtrace
new file mode 100755
index 0000000..95e422f
--- /dev/null
+++ b/utils/backtrace
@@ -0,0 +1,106 @@
+#! /usr/bin/perl -w
+
+use strict;
+
+# Check command line.
+if (grep ($_ eq '-h' || $_ eq '--help', @ARGV)) {
+    print <<'EOF';
+backtrace, for converting raw addresses into symbolic backtraces
+usage: backtrace [BINARY]... ADDRESS...
+where BINARY is the binary file or files from which to obtain symbols
+ and ADDRESS is a raw address to convert to a symbol name.
+
+If no BINARY is unspecified, the default is the first of kernel.o or
+build/kernel.o that exists.  If multiple binaries are specified, each
+symbol printed is from the first binary that contains a match.
+
+The ADDRESS list should be taken from the "Call stack:" printed by the
+kernel.  Read "Backtraces" in the "Debugging Tools" chapter of the
+Pintos documentation for more information.
+EOF
+    exit 0;
+}
+die "backtrace: at least one argument required (use --help for help)\n"
+    if @ARGV == 0;
+
+# Drop garbage inserted by kernel.
+@ARGV = grep (!/^(call|stack:?|[-+])$/i, @ARGV);
+s/\.$// foreach @ARGV;
+
+# Find binaries.
+my (@binaries);
+while ($ARGV[0] !~ /^0x/) {
+    my ($bin) = shift @ARGV;
+    die "backtrace: $bin: not found (use --help for help)\n" if ! -e $bin;
+    push (@binaries, $bin);
+}
+if (!@binaries) {
+    my ($bin);
+    if (-e 'kernel.o') {
+        $bin = 'kernel.o';
+    } elsif (-e 'build/kernel.o') {
+        $bin = 'build/kernel.o';
+    } else {
+        die "backtrace: no binary specified and neither \"kernel.o\" nor \"build/kernel.o\" exists (use --help for help)\n";
+    }
+    push (@binaries, $bin);
+}
+
+# Find addr2line.
+my ($a2l) = search_path ("i386-elf-addr2line") || search_path ("addr2line");
+if (!$a2l) {
+    die "backtrace: neither `i386-elf-addr2line' nor `addr2line' in PATH\n";
+}
+sub search_path {
+    my ($target) = @_;
+    for my $dir (split (':', $ENV{PATH})) {
+        my ($file) = "$dir/$target";
+        return $file if -e $file;
+    }
+    return undef;
+}
+
+# Figure out backtrace.
+my (@locs) = map ({ADDR => $_}, @ARGV);
+for my $bin (@binaries) {
+    open (A2L, "$a2l -fe $bin " . join (' ', map ($_->{ADDR}, @locs)) . "|");
+    for (my ($i) = 0; <A2L>; $i++) {
+        my ($function, $line);
+        chomp ($function = $_);
+        chomp ($line = <A2L>);
+        next if defined $locs[$i]{BINARY};
+
+        if ($function ne '??' || $line ne '??:0') {
+            $locs[$i]{FUNCTION} = $function;
+            $locs[$i]{LINE} = $line;
+            $locs[$i]{BINARY} = $bin;
+        }
+    }
+    close (A2L);
+}
+
+# Print backtrace.
+my ($cur_binary);
+for my $loc (@locs) {
+    if (defined ($loc->{BINARY})
+        && @binaries > 1
+        && (!defined ($cur_binary) || $loc->{BINARY} ne $cur_binary)) {
+        $cur_binary = $loc->{BINARY};
+        print "In $cur_binary:\n";
+    }
+
+    my ($addr) = $loc->{ADDR};
+    $addr = sprintf ("0x%08x", hex ($addr)) if $addr =~ /^0x[0-9a-f]+$/i;
+
+    print $addr, ": ";
+    if (defined ($loc->{BINARY})) {
+        my ($function) = $loc->{FUNCTION};
+        my ($line) = $loc->{LINE};
+        $line =~ s/^(\.\.\/)*//;
+        $line = "..." . substr ($line, -25) if length ($line) > 28;
+        print "$function ($line)";
+    } else {
+        print "(unknown)";
+    }
+    print "\n";
+}
diff --git a/utils/pintos b/utils/pintos
new file mode 100755
index 0000000..91f73ad
--- /dev/null
+++ b/utils/pintos
@@ -0,0 +1,955 @@
+#! /usr/bin/perl -w
+
+use strict;
+use POSIX;
+use Fcntl;
+use File::Temp 'tempfile';
+use Getopt::Long qw(:config bundling);
+use Fcntl qw(SEEK_SET SEEK_CUR);
+
+# Read Pintos.pm from the same directory as this program.
+BEGIN { my $self = $0; $self =~ s%/+[^/]*$%%; require "$self/Pintos.pm"; }
+
+# Command-line options.
+our ($start_time) = time ();
+our ($sim);                     # Simulator: bochs, qemu, or player.
+our ($debug) = "none";          # Debugger: none, monitor, or gdb.
+our ($mem) = 4;                 # Physical RAM in MB.
+our ($serial) = 1;              # Use serial port for input and output?
+our ($vga);                     # VGA output: window, terminal, or none.
+our ($jitter);                  # Seed for random timer interrupts, if set.
+our ($realtime);                # Synchronize timer interrupts with real time?
+our ($timeout);                 # Maximum runtime in seconds, if set.
+our ($kill_on_failure);         # Abort quickly on test failure?
+our ($kernel_test);             # Run kernel test instead of user program
+our (@puts);                    # Files to copy into the VM.
+our (@gets);                    # Files to copy out of the VM.
+our ($as_ref);                  # Reference to last addition to @gets or @puts.
+our (@kernel_args);             # Arguments to pass to kernel.
+our (%parts);                   # Partitions.
+our ($make_disk);               # Name of disk to create.
+our ($tmp_disk) = 1;            # Delete $make_disk after run?
+our (@disks);                   # Extra disk images to pass to simulator.
+our ($loader_fn);               # Bootstrap loader.
+our (%geometry);                # IDE disk geometry.
+our ($align);                   # Partition alignment.
+
+parse_command_line ();
+prepare_scratch_disk ();
+find_disks ();
+run_vm ();
+finish_scratch_disk ();
+
+exit 0;
+
+# Parses the command line.
+sub parse_command_line {
+    usage (0) if @ARGV == 0 || (@ARGV == 1 && $ARGV[0] eq '--help');
+
+    @kernel_args = @ARGV;
+    if (grep ($_ eq '--', @kernel_args)) {
+        @ARGV = ();
+        while ((my $arg = shift (@kernel_args)) ne '--') {
+            push (@ARGV, $arg);
+        }
+        GetOptions ("sim=s" => sub { set_sim ($_[1]) },
+                    "bochs" => sub { set_sim ("bochs") },
+                    "qemu" => sub { set_sim ("qemu") },
+                    "player" => sub { set_sim ("player") },
+
+                    "debug=s" => sub { set_debug ($_[1]) },
+                    "no-debug" => sub { set_debug ("none") },
+                    "monitor" => sub { set_debug ("monitor") },
+                    "gdb" => sub { set_debug ("gdb") },
+
+                    "m|memory=i" => \$mem,
+                    "j|jitter=i" => sub { set_jitter ($_[1]) },
+                    "r|realtime" => sub { set_realtime () },
+
+                    "T|timeout=i" => \$timeout,
+                    "k|kill-on-failure" => \$kill_on_failure,
+
+                    "v|no-vga" => sub { set_vga ('none'); },
+                    "s|no-serial" => sub { $serial = 0; },
+                    "t|terminal" => sub { set_vga ('terminal'); },
+                    
+                    "kernel-test"  => sub { set_kernel_test(); },
+                    "p|put-file=s" => sub { add_file (\@puts, $_[1]); },
+                    "g|get-file=s" => sub { add_file (\@gets, $_[1]); },
+                    "a|as=s" => sub { set_as ($_[1]); },
+
+                    "h|help" => sub { usage (0); },
+
+                    "kernel=s" => \&set_part,
+                    "filesys=s" => \&set_part,
+                    "swap=s" => \&set_part,
+
+                    "filesys-size=s" => \&set_part,
+                    "scratch-size=s" => \&set_part,
+                    "swap-size=s" => \&set_part,
+
+                    "kernel-from=s" => \&set_part,
+                    "filesys-from=s" => \&set_part,
+                    "swap-from=s" => \&set_part,
+
+                    "make-disk=s" => sub { $make_disk = $_[1];
+                                           $tmp_disk = 0; },
+                    "disk=s" => sub { set_disk ($_[1]); },
+                    "loader=s" => \$loader_fn,
+
+                    "geometry=s" => \&set_geometry,
+                    "align=s" => \&set_align)
+          or exit 1;
+    }
+
+    $sim = "bochs" if !defined $sim;
+    $debug = "none" if !defined $debug;
+    $vga = exists ($ENV{DISPLAY}) ? "window" : "none" if !defined $vga;
+
+    undef $timeout, print "warning: disabling timeout with --$debug\n"
+      if defined ($timeout) && $debug ne 'none';
+
+    print "warning: enabling serial port for -k or --kill-on-failure\n"
+      if $kill_on_failure && !$serial;
+
+    $align = "bochs",
+      print STDERR "warning: setting --align=bochs for Bochs support\n"
+        if $sim eq 'bochs' && defined ($align) && $align eq 'none';
+}
+
+# usage($exitcode).
+# Prints a usage message and exits with $exitcode.
+sub usage {
+    my ($exitcode) = @_;
+    $exitcode = 1 unless defined $exitcode;
+    print <<'EOF';
+pintos, a utility for running Pintos in a simulator
+Usage: pintos [OPTION...] -- [ARGUMENT...]
+where each OPTION is one of the following options
+  and each ARGUMENT is passed to Pintos kernel verbatim.
+Simulator selection:
+  --bochs                  (default) Use Bochs as simulator
+  --qemu                   Use QEMU as simulator
+  --player                 Use VMware Player as simulator
+Debugger selection:
+  --no-debug               (default) No debugger
+  --monitor                Debug with simulator's monitor
+  --gdb                    Debug with gdb
+Display options: (default is both VGA and serial)
+  -v, --no-vga             No VGA display or keyboard
+  -s, --no-serial          No serial input or output
+  -t, --terminal           Display VGA in terminal (Bochs only)
+Timing options: (Bochs only)
+  -j SEED                  Randomize timer interrupts
+  -r, --realtime           Use realistic, not reproducible, timings
+Testing options:
+  -T, --timeout=N          Kill Pintos after N seconds CPU time or N*load_avg
+                           seconds wall-clock time (whichever comes first)
+  -k, --kill-on-failure    Kill Pintos a few seconds after a kernel or user
+                           panic, test failure, or triple fault
+  --kernel-test            Run kernel test, even though user programs are
+                           enabled.
+Configuration options:
+  -m, --mem=N              Give Pintos N MB physical RAM (default: 4)
+File system commands:
+  -p, --put-file=HOSTFN    Copy HOSTFN into VM, by default under same name
+  -g, --get-file=GUESTFN   Copy GUESTFN out of VM, by default under same name
+  -a, --as=FILENAME        Specifies guest (for -p) or host (for -g) file name
+Partition options: (where PARTITION is one of: kernel filesys scratch swap)
+  --PARTITION=FILE         Use a copy of FILE for the given PARTITION
+  --PARTITION-size=SIZE    Create an empty PARTITION of the given SIZE in MB
+  --PARTITION-from=DISK    Use of a copy of the given PARTITION in DISK
+  (There is no --kernel-size, --scratch, or --scratch-from option.)
+Disk configuration options:
+  --make-disk=DISK         Name the new DISK and don't delete it after the run
+  --disk=DISK              Also use existing DISK (may be used multiple times)
+Advanced disk configuration options:
+  --loader=FILE            Use FILE as bootstrap loader (default: loader.bin)
+  --geometry=H,S           Use H head, S sector geometry (default: 16,63)
+  --geometry=zip           Use 64 head, 32 sector geometry for USB-ZIP boot
+                           (see http://syslinux.zytor.com/usbkey.php)
+  --align=bochs            Pad out disk to cylinder to support Bochs (default)
+  --align=full             Align partition boundaries to cylinder boundary to
+                           let fdisk guess correct geometry and quiet warnings
+  --align=none             Don't align partitions at all, to save space
+Other options:
+  -h, --help               Display this help message.
+EOF
+    exit $exitcode;
+}
+
+# Sets the simulator.
+sub set_sim {
+    my ($new_sim) = @_;
+    die "--$new_sim conflicts with --$sim\n"
+        if defined ($sim) && $sim ne $new_sim;
+    $sim = $new_sim;
+}
+
+# Sets the debugger.
+sub set_debug {
+    my ($new_debug) = @_;
+    die "--$new_debug conflicts with --$debug\n"
+        if $debug ne 'none' && $new_debug ne 'none' && $debug ne $new_debug;
+    $debug = $new_debug;
+}
+
+# Sets VGA output destination.
+sub set_vga {
+    my ($new_vga) = @_;
+    if (defined ($vga) && $vga ne $new_vga) {
+        print "warning: conflicting vga display options\n";
+    }
+    $vga = $new_vga;
+}
+
+# Sets randomized timer interrupts.
+sub set_jitter {
+    my ($new_jitter) = @_;
+    die "--realtime conflicts with --jitter\n" if defined $realtime;
+    die "different --jitter already defined\n"
+        if defined $jitter && $jitter != $new_jitter;
+    $jitter = $new_jitter;
+}
+
+# Sets real-time timer interrupts.
+sub set_realtime {
+    die "--realtime conflicts with --jitter\n" if defined $jitter;
+    $realtime = 1;
+}
+
+# Sets load to run kernel test instead of user program.
+# If user programs are disabled, pintos always runs a kernel test.
+sub set_kernel_test {
+    $kernel_test = 1;
+}
+
+# add_file(\@list, $file)
+#
+# Adds [$file] to @list, which should be @puts or @gets.
+# Sets $as_ref to point to the added element.
+sub add_file {
+    my ($list, $file) = @_;
+    $as_ref = [$file];
+    push (@$list, $as_ref);
+}
+
+# Sets the guest/host name for the previous put/get.
+sub set_as {
+    my ($as) = @_;
+    die "-a (or --as) is only allowed after -p or -g\n" if !defined $as_ref;
+    die "Only one -a (or --as) is allowed after -p or -g\n"
+      if defined $as_ref->[1];
+    $as_ref->[1] = $as;
+}
+
+# Sets $disk as a disk to be included in the VM to run.
+sub set_disk {
+    my ($disk) = @_;
+
+    push (@disks, $disk);
+
+    my (%pt) = read_partition_table ($disk);
+    for my $role (keys %pt) {
+        die "can't have two sources for \L$role\E partition"
+          if exists $parts{$role};
+        $parts{$role}{DISK} = $disk;
+        $parts{$role}{START} = $pt{$role}{START};
+        $parts{$role}{SECTORS} = $pt{$role}{SECTORS};
+    }
+}
+
+# Locates the files used to back each of the virtual disks,
+# and creates temporary disks.
+sub find_disks {
+    # Find kernel, if we don't already have one.
+    if (!exists $parts{KERNEL}) {
+        my $name = find_file ('kernel.bin');
+        die "Cannot find kernel\n" if !defined $name;
+        do_set_part ('KERNEL', 'file', $name);
+    }
+
+    # Try to find file system and swap disks, if we don't already have
+    # partitions.
+    if (!exists $parts{FILESYS}) {
+        my $name = find_file ('filesys.dsk');
+        set_disk ($name) if defined $name;
+    }
+    if (!exists $parts{SWAP}) {
+        my $name = find_file ('swap.dsk');
+        set_disk ($name) if defined $name;
+    }
+
+    # Warn about (potentially) missing partitions.
+    if (my ($project) = `pwd` =~ /\b(threads|userprog|vm|filesys)\b/) {
+        if ((grep ($project eq $_, qw (userprog vm filesys)))
+            && !defined $parts{FILESYS}) {
+            print STDERR "warning: it looks like you're running the $project ";
+            print STDERR "project, but no file system partition is present\n";
+        }
+        if ($project eq 'vm' && !defined $parts{SWAP}) {
+            print STDERR "warning: it looks like you're running the $project ";
+            print STDERR "project, but no swap partition is present\n";
+        }
+    }
+
+    # Open disk handle.
+    my ($handle);
+    if (!defined $make_disk) {
+        ($handle, $make_disk) = tempfile (UNLINK => $tmp_disk,
+                                          SUFFIX => '.dsk');
+    } else {
+        die "$make_disk: already exists\n" if -e $make_disk;
+        open ($handle, '>', $make_disk) or die "$make_disk: create: $!\n";
+    }
+
+    # Prepare the arguments to pass to the Pintos kernel.
+    my (@args);
+    push (@args, '-kernel-test') if $kernel_test;
+    push (@args, shift (@kernel_args))
+      while @kernel_args && $kernel_args[0] =~ /^-/;
+    push (@args, 'extract') if @puts;
+    push (@args, @kernel_args);
+    push (@args, 'append', $_->[0]) foreach @gets;
+
+    # Make disk.
+    my (%disk);
+    our (@role_order);
+    for my $role (@role_order) {
+        my $p = $parts{$role};
+        next if !defined $p;
+        next if exists $p->{DISK};
+        $disk{$role} = $p;
+    }
+    $disk{DISK} = $make_disk;
+    $disk{HANDLE} = $handle;
+    $disk{ALIGN} = $align;
+    $disk{GEOMETRY} = %geometry;
+    $disk{FORMAT} = 'partitioned';
+    $disk{LOADER} = read_loader ($loader_fn);
+    $disk{ARGS} = \@args;
+    assemble_disk (%disk);
+
+    # Put the disk at the front of the list of disks.
+    unshift (@disks, $make_disk);
+    die "can't use more than " . scalar (@disks) . "disks\n" if @disks > 4;
+}
+
+# Prepare the scratch disk for gets and puts.
+sub prepare_scratch_disk {
+    return if !@gets && !@puts;
+
+    my ($p) = $parts{SCRATCH};
+    # Create temporary partition and write the files to put to it,
+    # then write an end-of-archive marker.
+    my ($part_handle, $part_fn) = tempfile (UNLINK => 1, SUFFIX => '.part');
+    put_scratch_file ($_->[0], defined $_->[1] ? $_->[1] : $_->[0],
+                      $part_handle, $part_fn)
+      foreach @puts;
+    write_fully ($part_handle, $part_fn, "\0" x 1024);
+
+    # Make sure the scratch disk is big enough to get big files
+    # and at least as big as any requested size.
+    my ($size) = round_up (max (@gets * 1024 * 1024, $p->{BYTES} || 0), 512);
+    extend_file ($part_handle, $part_fn, $size);
+    close ($part_handle);
+
+    if (exists $p->{DISK}) {
+        # Copy the scratch partition to the disk.
+        die "$p->{DISK}: scratch partition too small\n"
+          if $p->{SECTORS} * 512 < $size;
+
+        my ($disk_handle);
+        open ($part_handle, '<', $part_fn) or die "$part_fn: open: $!\n";
+        open ($disk_handle, '+<', $p->{DISK}) or die "$p->{DISK}: open: $!\n";
+        my ($start) = $p->{START} * 512;
+        sysseek ($disk_handle, $start, SEEK_SET) == $start
+          or die "$p->{DISK}: seek: $!\n";
+        copy_file ($part_handle, $part_fn, $disk_handle, $p->{DISK}, $size);
+        close ($disk_handle) or die "$p->{DISK}: close: $!\n";
+        close ($part_handle) or die "$part_fn: close: $!\n";
+    } else {
+        # Set $part_fn as the source for the scratch partition.
+        do_set_part ('SCRATCH', 'file', $part_fn);
+    }
+}
+
+# Read "get" files from the scratch disk.
+sub finish_scratch_disk {
+    return if !@gets;
+
+    # Open scratch partition.
+    my ($p) = $parts{SCRATCH};
+    my ($part_handle);
+    my ($part_fn) = $p->{DISK};
+    open ($part_handle, '<', $part_fn) or die "$part_fn: open: $!\n";
+    sysseek ($part_handle, $p->{START} * 512, SEEK_SET) == $p->{START} * 512
+      or die "$part_fn: seek: $!\n";
+
+    # Read each file.
+    # If reading fails, delete that file and all subsequent files, but
+    # don't die with an error, because that's a guest error not a host
+    # error.  (If we do exit with an error code, it fouls up the
+    # grading process.)  Instead, just make sure that the host file(s)
+    # we were supposed to retrieve is unlinked.
+    my ($ok) = 1;
+    my ($part_end) = ($p->{START} + $p->{SECTORS}) * 512;
+    foreach my $get (@gets) {
+        my ($name) = defined ($get->[1]) ? $get->[1] : $get->[0];
+        if ($ok) {
+            my ($error) = get_scratch_file ($name, $part_handle, $part_fn);
+            if (!$error && sysseek ($part_handle, 0, SEEK_CUR) > $part_end) {
+                $error = "$part_fn: scratch data overflows partition";
+            }
+            if ($error) {
+                print STDERR "getting $name failed ($error)\n";
+                $ok = 0;
+            }
+        }
+        die "$name: unlink: $!\n" if !$ok && !unlink ($name) && !$!{ENOENT};
+    }
+}
+
+# mk_ustar_field($number, $size)
+#
+# Returns $number in a $size-byte numeric field in the format used by
+# the standard ustar archive header.
+sub mk_ustar_field {
+    my ($number, $size) = @_;
+    my ($len) = $size - 1;
+    my ($out) = sprintf ("%0${len}o", $number) . "\0";
+    die "$number: too large for $size-byte octal ustar field\n"
+      if length ($out) != $size;
+    return $out;
+}
+
+# calc_ustar_chksum($s)
+#
+# Calculates and returns the ustar checksum of 512-byte ustar archive
+# header $s.
+sub calc_ustar_chksum {
+    my ($s) = @_;
+    die if length ($s) != 512;
+    substr ($s, 148, 8, ' ' x 8);
+    return unpack ("%32a*", $s);
+}
+
+# put_scratch_file($src_file_name, $dst_file_name,
+#                  $disk_handle, $disk_file_name).
+#
+# Copies $src_file_name into $disk_handle for extraction as
+# $dst_file_name.  $disk_file_name is used for error messages.
+sub put_scratch_file {
+    my ($src_file_name, $dst_file_name, $disk_handle, $disk_file_name) = @_;
+
+    print "Copying $src_file_name to scratch partition...\n";
+
+    # ustar format supports up to 100 characters for a file name, and
+    # even longer names given some common properties, but our code in
+    # the Pintos kernel only supports at most 99 characters.
+    die "$dst_file_name: name too long (max 99 characters)\n"
+      if length ($dst_file_name) > 99;
+
+    # Compose and write ustar header.
+    stat $src_file_name or die "$src_file_name: stat: $!\n";
+    my ($size) = -s _;
+    my ($header) = (pack ("a100", $dst_file_name)       # name
+                    . mk_ustar_field (0644, 8)          # mode
+                    . mk_ustar_field (0, 8)             # uid
+                    . mk_ustar_field (0, 8)             # gid
+                    . mk_ustar_field ($size, 12)        # size
+                    . mk_ustar_field (1136102400, 12)   # mtime
+                    . (' ' x 8)                         # chksum
+                    . '0'                               # typeflag
+                    . ("\0" x 100)                      # linkname
+                    . "ustar\0"                         # magic
+                    . "00"                              # version
+                    . "root" . ("\0" x 28)              # uname
+                    . "root" . ("\0" x 28)              # gname
+                    . "\0" x 8                          # devmajor
+                    . "\0" x 8                          # devminor
+                    . ("\0" x 155))                     # prefix
+                    . "\0" x 12;                        # pad to 512 bytes
+    substr ($header, 148, 8) = mk_ustar_field (calc_ustar_chksum ($header), 8);
+    write_fully ($disk_handle, $disk_file_name, $header);
+
+    # Copy file data.
+    my ($put_handle);
+    sysopen ($put_handle, $src_file_name, O_RDONLY)
+      or die "$src_file_name: open: $!\n";
+    copy_file ($put_handle, $src_file_name, $disk_handle, $disk_file_name,
+               $size);
+    die "$src_file_name: changed size while being read\n"
+      if $size != -s $put_handle;
+    close ($put_handle);
+
+    # Round up disk data to beginning of next sector.
+    write_fully ($disk_handle, $disk_file_name, "\0" x (512 - $size % 512))
+      if $size % 512;
+}
+
+# get_scratch_file($get_file_name, $disk_handle, $disk_file_name)
+#
+# Copies from $disk_handle to $get_file_name (which is created).
+# $disk_file_name is used for error messages.
+# Returns 1 if successful, 0 on failure.
+sub get_scratch_file {
+    my ($get_file_name, $disk_handle, $disk_file_name) = @_;
+
+    print "Copying $get_file_name out of $disk_file_name...\n";
+
+    # Read ustar header sector.
+    my ($header) = read_fully ($disk_handle, $disk_file_name, 512);
+    return "scratch disk tar archive ends unexpectedly"
+      if $header eq ("\0" x 512);
+
+    # Verify magic numbers.
+    return "corrupt ustar signature" if substr ($header, 257, 6) ne "ustar\0";
+    return "invalid ustar version" if substr ($header, 263, 2) ne '00';
+
+    # Verify checksum.
+    my ($chksum) = oct (unpack ("Z*", substr ($header, 148, 8)));
+    my ($correct_chksum) = calc_ustar_chksum ($header);
+    return "checksum mismatch" if $chksum != $correct_chksum;
+
+    # Get type.
+    my ($typeflag) = substr ($header, 156, 1);
+    return "not a regular file" if $typeflag ne '0' && $typeflag ne "\0";
+
+    # Get size.
+    my ($size) = oct (unpack ("Z*", substr ($header, 124, 12)));
+    return "bad size $size\n" if $size < 0;
+
+    # Copy file data.
+    my ($get_handle);
+    sysopen ($get_handle, $get_file_name, O_WRONLY | O_CREAT, 0666)
+      or die "$get_file_name: create: $!\n";
+    copy_file ($disk_handle, $disk_file_name, $get_handle, $get_file_name,
+               $size);
+    close ($get_handle);
+
+    # Skip forward in disk up to beginning of next sector.
+    read_fully ($disk_handle, $disk_file_name, 512 - $size % 512)
+      if $size % 512;
+
+    return 0;
+}
+
+# Running simulators.
+
+# Runs the selected simulator.
+sub run_vm {
+    if ($sim eq 'bochs') {
+        run_bochs ();
+    } elsif ($sim eq 'qemu') {
+        run_qemu ();
+    } elsif ($sim eq 'player') {
+        run_player ();
+    } else {
+        die "unknown simulator `$sim'\n";
+    }
+}
+
+# Runs Bochs.
+sub run_bochs {
+    # Select Bochs binary based on the chosen debugger.
+    my ($bin) = $debug eq 'monitor' ? 'bochs-dbg' : 'bochs';
+
+    my ($squish_pty);
+    if ($serial) {
+        $squish_pty = find_in_path ("squish-pty");
+        print "warning: can't find squish-pty, so terminal input will fail\n"
+          if !defined $squish_pty;
+    }
+
+    # Write bochsrc.txt configuration file.
+    open (BOCHSRC, ">", "bochsrc.txt") or die "bochsrc.txt: create: $!\n";
+    print BOCHSRC <<EOF;
+romimage: file=\$BXSHARE/BIOS-bochs-latest
+vgaromimage: file=\$BXSHARE/VGABIOS-lgpl-latest
+boot: disk
+cpu: ips=1000000
+megs: $mem
+log: bochsout.txt
+panic: action=fatal
+user_shortcut: keys=ctrlaltdel
+EOF
+    print BOCHSRC "gdbstub: enabled=1\n" if $debug eq 'gdb';
+    print BOCHSRC "clock: sync=", $realtime ? 'realtime' : 'none',
+      ", time0=0\n";
+    print BOCHSRC "ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15\n"
+      if @disks > 2;
+    print_bochs_disk_line ("ata0-master", $disks[0]);
+    print_bochs_disk_line ("ata0-slave", $disks[1]);
+    print_bochs_disk_line ("ata1-master", $disks[2]);
+    print_bochs_disk_line ("ata1-slave", $disks[3]);
+    if ($vga ne 'terminal') {
+        if ($serial) {
+            my $mode = defined ($squish_pty) ? "term" : "file";
+            print BOCHSRC "com1: enabled=1, mode=$mode, dev=/dev/stdout\n";
+        }
+        print BOCHSRC "display_library: nogui\n" if $vga eq 'none';
+    } else {
+        print BOCHSRC "display_library: term\n";
+    }
+    close (BOCHSRC);
+
+    # Compose Bochs command line.
+    my (@cmd) = ($bin, '-q');
+    unshift (@cmd, $squish_pty) if defined $squish_pty;
+    push (@cmd, '-j', $jitter) if defined $jitter;
+
+    # Run Bochs.
+    print join (' ', @cmd), "\n";
+    my ($exit) = xsystem (@cmd);
+    if (WIFEXITED ($exit)) {
+        # Bochs exited normally.
+        # Ignore the exit code; Bochs normally exits with status 1,
+        # which is weird.
+    } elsif (WIFSIGNALED ($exit)) {
+        die "Bochs died with signal ", WTERMSIG ($exit), "\n";
+    } else {
+        die "Bochs died: code $exit\n";
+    }
+}
+
+sub print_bochs_disk_line {
+    my ($device, $disk) = @_;
+    if (defined $disk) {
+        my (%geom) = disk_geometry ($disk);
+        print BOCHSRC "$device: type=disk, path=$disk, mode=flat, ";
+        print BOCHSRC "cylinders=$geom{C}, heads=$geom{H}, spt=$geom{S}, ";
+        print BOCHSRC "translation=none\n";
+    }
+}
+
+# Runs QEMU.
+sub run_qemu {
+    print "warning: qemu doesn't support --terminal\n"
+      if $vga eq 'terminal';
+    print "warning: qemu doesn't support jitter\n"
+      if defined $jitter;
+    my (@cmd) = ('qemu');
+#    push (@cmd, '-no-kqemu');
+    push (@cmd, '-hda', $disks[0]) if defined $disks[0];
+    push (@cmd, '-hdb', $disks[1]) if defined $disks[1];
+    push (@cmd, '-hdc', $disks[2]) if defined $disks[2];
+    push (@cmd, '-hdd', $disks[3]) if defined $disks[3];
+    push (@cmd, '-m', $mem);
+    push (@cmd, '-net', 'none');
+    push (@cmd, '-nographic') if $vga eq 'none';
+    push (@cmd, '-serial', 'stdio') if $serial && $vga ne 'none';
+    push (@cmd, '-S') if $debug eq 'monitor';
+    push (@cmd, '-s', '-S') if $debug eq 'gdb';
+    push (@cmd, '-monitor', 'null') if $vga eq 'none' && $debug eq 'none';
+    run_command (@cmd);
+}
+
+# player_unsup($flag)
+#
+# Prints a message that $flag is unsupported by VMware Player.
+sub player_unsup {
+    my ($flag) = @_;
+    print "warning: no support for $flag with VMware Player\n";
+}
+
+# Runs VMware Player.
+sub run_player {
+    player_unsup ("--$debug") if $debug ne 'none';
+    player_unsup ("--no-vga") if $vga eq 'none';
+    player_unsup ("--terminal") if $vga eq 'terminal';
+    player_unsup ("--jitter") if defined $jitter;
+    player_unsup ("--timeout"), undef $timeout if defined $timeout;
+    player_unsup ("--kill-on-failure"), undef $kill_on_failure
+      if defined $kill_on_failure;
+
+    $mem = round_up ($mem, 4);  # Memory must be multiple of 4 MB.
+
+    open (VMX, ">", "pintos.vmx") or die "pintos.vmx: create: $!\n";
+    chmod 0777 & ~umask, "pintos.vmx";
+    print VMX <<EOF;
+#! /usr/bin/vmware -G
+config.version = 8
+guestOS = "linux"
+memsize = $mem
+floppy0.present = FALSE
+usb.present = FALSE
+sound.present = FALSE
+gui.exitAtPowerOff = TRUE
+gui.exitOnCLIHLT = TRUE
+gui.powerOnAtStartUp = TRUE
+EOF
+
+    print VMX <<EOF if $serial;
+serial0.present = TRUE
+serial0.fileType = "pipe"
+serial0.fileName = "pintos.socket"
+serial0.pipe.endPoint = "client"
+serial0.tryNoRxLoss = "TRUE"
+EOF
+
+    for (my ($i) = 0; $i < 4; $i++) {
+        my ($dsk) = $disks[$i];
+        last if !defined $dsk;
+
+        my ($device) = "ide" . int ($i / 2) . ":" . ($i % 2);
+        my ($pln) = "$device.pln";
+        print VMX <<EOF;
+
+$device.present = TRUE
+$device.deviceType = "plainDisk"
+$device.fileName = "$pln"
+EOF
+
+        open (URANDOM, '<', '/dev/urandom') or die "/dev/urandom: open: $!\n";
+        my ($bytes);
+        sysread (URANDOM, $bytes, 4) == 4 or die "/dev/urandom: read: $!\n";
+        close (URANDOM);
+        my ($cid) = unpack ("L", $bytes);
+
+        my (%geom) = disk_geometry ($dsk);
+        open (PLN, ">", $pln) or die "$pln: create: $!\n";
+        print PLN <<EOF;
+version=1
+CID=$cid
+parentCID=ffffffff
+createType="monolithicFlat"
+
+RW $geom{CAPACITY} FLAT "$dsk" 0
+
+# The Disk Data Base
+#DDB
+
+ddb.adapterType = "ide"
+ddb.virtualHWVersion = "4"
+ddb.toolsVersion = "2"
+ddb.geometry.cylinders = "$geom{C}"
+ddb.geometry.heads = "$geom{H}"
+ddb.geometry.sectors = "$geom{S}"
+EOF
+        close (PLN);
+    }
+    close (VMX);
+
+    my ($squish_unix);
+    if ($serial) {
+        $squish_unix = find_in_path ("squish-unix");
+        print "warning: can't find squish-unix, so terminal input ",
+          "and output will fail\n" if !defined $squish_unix;
+    }
+
+    my ($vmx) = getcwd () . "/pintos.vmx";
+    my (@cmd) = ("vmplayer", $vmx);
+    unshift (@cmd, $squish_unix, "pintos.socket") if $squish_unix;
+    print join (' ', @cmd), "\n";
+    xsystem (@cmd);
+}
+
+# Disk utilities.
+
+sub extend_file {
+    my ($handle, $file_name, $size) = @_;
+    if (-s ($handle) < $size) {
+        sysseek ($handle, $size - 1, 0) == $size - 1
+          or die "$file_name: seek: $!\n";
+        syswrite ($handle, "\0") == 1
+          or die "$file_name: write: $!\n";
+    }
+}
+
+# disk_geometry($file)
+#
+# Examines $file and returns a valid IDE disk geometry for it, as a
+# hash.
+sub disk_geometry {
+    my ($file) = @_;
+    my ($size) = -s $file;
+    die "$file: stat: $!\n" if !defined $size;
+    die "$file: size $size not a multiple of 512 bytes\n" if $size % 512;
+    my ($cyl_size) = 512 * 16 * 63;
+    my ($cylinders) = ceil ($size / $cyl_size);
+
+    return (CAPACITY => $size / 512,
+            C => $cylinders,
+            H => 16,
+            S => 63);
+}
+
+# Subprocess utilities.
+
+# run_command(@args)
+#
+# Runs xsystem(@args).
+# Also prints the command it's running and checks that it succeeded.
+sub run_command {
+    print join (' ', @_), "\n";
+    die "command failed\n" if xsystem (@_);
+}
+
+# xsystem(@args)
+#
+# Creates a subprocess via exec(@args) and waits for it to complete.
+# Relays common signals to the subprocess.
+# If $timeout is set then the subprocess will be killed after that long.
+sub xsystem {
+    # QEMU turns off local echo and does not restore it if killed by a signal.
+    # We compensate by restoring it ourselves.
+    my $cleanup = sub {};
+    if (isatty (0)) {
+        my $termios = POSIX::Termios->new;
+        $termios->getattr (0);
+        $cleanup = sub { $termios->setattr (0, &POSIX::TCSANOW); }
+    }
+
+    # Create pipe for filtering output.
+    pipe (my $in, my $out) or die "pipe: $!\n" if $kill_on_failure;
+
+    my ($pid) = fork;
+    if (!defined ($pid)) {
+        # Fork failed.
+        die "fork: $!\n";
+    } elsif (!$pid) {
+        # Running in child process.
+        dup2 (fileno ($out), STDOUT_FILENO) or die "dup2: $!\n"
+          if $kill_on_failure;
+        exec_setitimer (@_);
+    } else {
+        # Running in parent process.
+        close $out if $kill_on_failure;
+
+        my ($cause);
+        local $SIG{ALRM} = sub { timeout ($pid, $cause, $cleanup); };
+        local $SIG{INT} = sub { relay_signal ($pid, "INT", $cleanup); };
+        local $SIG{TERM} = sub { relay_signal ($pid, "TERM", $cleanup); };
+        alarm ($timeout * get_load_average () + 1) if defined ($timeout);
+
+        if ($kill_on_failure) {
+            # Filter output.
+            my ($buf) = "";
+            my ($boots) = 0;
+            local ($|) = 1;
+            for (;;) {
+                if (waitpid ($pid, WNOHANG) != 0) {
+                    # Subprocess died.  Pass through any remaining data.
+                    print $buf while sysread ($in, $buf, 4096) > 0;
+                    last;
+                }
+
+                # Read and print out pipe data.
+                my ($len) = length ($buf);
+                waitpid ($pid, 0), last
+                  if sysread ($in, $buf, 4096, $len) <= 0;
+                print substr ($buf, $len);
+
+                # Remove full lines from $buf and scan them for keywords.
+                while ((my $idx = index ($buf, "\n")) >= 0) {
+                    local $_ = substr ($buf, 0, $idx + 1, '');
+                    next if defined ($cause);
+                    if (/(Kernel PANIC|User process ABORT)/ ) {
+                        $cause = "\L$1\E";
+                        alarm (5);
+                    } elsif (/Pintos booting/ && ++$boots > 1) {
+                        $cause = "triple fault";
+                        alarm (5);
+                    } elsif (/FAILED/) {
+                        $cause = "test failure";
+                        alarm (5);
+                    }
+                }
+            }
+        } else {
+            waitpid ($pid, 0);
+        }
+        alarm (0);
+        &$cleanup ();
+
+        if (WIFSIGNALED ($?) && WTERMSIG ($?) == SIGVTALRM ()) {
+            seek (STDOUT, 0, 2);
+            print "\nTIMEOUT after $timeout seconds of host CPU time\n";
+            exit 0;
+        }
+
+        return $?;
+    }
+}
+
+# relay_signal($pid, $signal, &$cleanup)
+#
+# Relays $signal to $pid and then reinvokes it for us with the default
+# handler.  Also cleans up temporary files and invokes $cleanup.
+sub relay_signal {
+    my ($pid, $signal, $cleanup) = @_;
+    kill $signal, $pid;
+    eval { File::Temp::cleanup() };     # Not defined in old File::Temp.
+    &$cleanup ();
+    $SIG{$signal} = 'DEFAULT';
+    kill $signal, getpid ();
+}
+
+# timeout($pid, $cause, &$cleanup)
+#
+# Interrupts $pid and dies with a timeout error message,
+# after invoking $cleanup.
+sub timeout {
+    my ($pid, $cause, $cleanup) = @_;
+    kill "INT", $pid;
+    waitpid ($pid, 0);
+    &$cleanup ();
+    seek (STDOUT, 0, 2);
+    if (!defined ($cause)) {
+        my ($load_avg) = `uptime` =~ /(load average:.*)$/i;
+        print "\nTIMEOUT after ", time () - $start_time,
+          " seconds of wall-clock time";
+        print  " - $load_avg" if defined $load_avg;
+        print "\n";
+    } else {
+        print "Simulation terminated due to $cause.\n";
+    }
+    exit 0;
+}
+
+# Returns the system load average over the last minute.
+# If the load average is less than 1.0 or cannot be determined, returns 1.0.
+sub get_load_average {
+    my ($avg) = `uptime` =~ /load average:\s*([^,]+),/;
+    return $avg >= 1.0 ? $avg : 1.0;
+}
+
+# Calls setitimer to set a timeout, then execs what was passed to us.
+sub exec_setitimer {
+    if (defined $timeout) {
+        if ($ ge 5.8.0) {
+            eval "
+              use Time::HiRes qw(setitimer ITIMER_VIRTUAL);
+              setitimer (ITIMER_VIRTUAL, $timeout, 0);
+            ";
+        } else {
+            { exec ("setitimer-helper", $timeout, @_); };
+            exit 1 if !$!{ENOENT};
+            print STDERR "warning: setitimer-helper is not installed, so ",
+              "CPU time limit will not be enforced\n";
+        }
+    }
+    exec (@_);
+    exit (1);
+}
+
+sub SIGVTALRM {
+    use Config;
+    my $i = 0;
+    foreach my $name (split(' ', $Config{sig_name})) {
+        return $i if $name eq 'VTALRM';
+        $i++;
+    }
+    return 0;
+}
+
+# find_in_path ($program)
+#
+# Searches for $program in $ENV{PATH}.
+# Returns $program if found, otherwise undef.
+sub find_in_path {
+    my ($program) = @_;
+    -x "$_/$program" and return $program foreach split (':', $ENV{PATH});
+    return;
+}
diff --git a/utils/pintos-gdb b/utils/pintos-gdb
new file mode 100755
index 0000000..9c9555b
--- /dev/null
+++ b/utils/pintos-gdb
@@ -0,0 +1,21 @@
+#! /bin/sh
+
+# Path to GDB macros file.  Customize for your site.
+PINTOS_SRC="$(dirname $(dirname $(which pintos-gdb)))"
+GDBMACROS="${PINTOS_SRC}/misc/gdb-macros"
+
+# Choose correct GDB.
+if command -v i386-elf-gdb >/dev/null 2>&1; then
+        GDB=i386-elf-gdb
+else
+        GDB=gdb
+fi
+
+# Run GDB.
+if test -f "$GDBMACROS"; then
+        exec $GDB -x "$GDBMACROS" "$@"
+else
+        echo "*** $GDBMACROS does not exist ***"
+        echo "*** Pintos GDB macros will not be available ***"
+        exec $GDB "$@"
+fi
diff --git a/utils/pintos-mkdisk b/utils/pintos-mkdisk
new file mode 100755
index 0000000..87b1563
--- /dev/null
+++ b/utils/pintos-mkdisk
@@ -0,0 +1,134 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+use POSIX;
+use Getopt::Long qw(:config bundling);
+use Fcntl 'SEEK_SET';
+
+# Read Pintos.pm from the same directory as this program.
+BEGIN { my $self = $0; $self =~ s%/+[^/]*$%%; require "$self/Pintos.pm"; }
+
+our ($disk_fn);                 # Output disk file name.
+our (%parts);                   # Partitions.
+our ($format);                  # "partitioned" (default) or "raw"
+our (%geometry);                # IDE disk geometry.
+our ($align);                   # Align partitions on cylinders?
+our ($loader_fn);               # File name of loader.
+our ($include_loader);          # Include loader?
+our (@kernel_args);             # Kernel arguments.
+
+if (grep ($_ eq '--', @ARGV)) {
+    @kernel_args = @ARGV;
+    @ARGV = ();
+    while ((my $arg = shift (@kernel_args)) ne '--') {
+        push (@ARGV, $arg);
+    }
+}
+
+GetOptions ("h|help" => sub { usage (0); },
+
+            "kernel=s" => \&set_part,
+            "filesys=s" => \&set_part,
+            "scratch=s" => \&set_part,
+            "swap=s" => \&set_part,
+
+            "filesys-size=s" => \&set_part,
+            "scratch-size=s" => \&set_part,
+            "swap-size=s" => \&set_part,
+
+            "kernel-from=s" => \&set_part,
+            "filesys-from=s" => \&set_part,
+            "scratch-from=s" => \&set_part,
+            "swap-from=s" => \&set_part,
+
+            "format=s" => \$format,
+            "loader:s" => \&set_loader,
+            "no-loader" => \&set_no_loader,
+            "geometry=s" => \&set_geometry,
+            "align=s" => \&set_align)
+  or exit 1;
+usage (1) if @ARGV != 1;
+
+$disk_fn = $ARGV[0];
+die "$disk_fn: already exists\n" if -e $disk_fn;
+
+# Sets the loader to copy to the MBR.
+sub set_loader {
+    die "can't specify both --loader and --no-loader\n"
+      if defined ($include_loader) && !$include_loader;
+    $include_loader = 1;
+    $loader_fn = $_[1] if $_[1] ne '';
+}
+
+# Disables copying a loader to the MBR.
+sub set_no_loader {
+    die "can't specify both --loader and --no-loader\n"
+      if defined ($include_loader) && $include_loader;
+    $include_loader = 0;
+}
+
+# Figure out whether to include a loader.
+$include_loader = exists ($parts{KERNEL}) && $format eq 'partitioned'
+  if !defined ($include_loader);
+die "can't write loader to raw disk\n" if $include_loader && $format eq 'raw';
+die "can't write command-line arguments without --loader or --kernel\n"
+  if @kernel_args && !$include_loader;
+print STDERR "warning: --loader only makes sense without --kernel "
+  . "if this disk will be used to load a kernel from another disk\n"
+  if $include_loader && !exists ($parts{KERNEL});
+
+# Open disk.
+my ($disk_handle);
+open ($disk_handle, '>', $disk_fn) or die "$disk_fn: create: $!\n";
+
+# Read loader.
+my ($loader);
+$loader = read_loader ($loader_fn) if $include_loader;
+
+# Write disk.
+my (%disk) = %parts;
+$disk{DISK} = $disk_fn;
+$disk{HANDLE} = $disk_handle;
+$disk{ALIGN} = $align;
+$disk{GEOMETRY} = %geometry;
+$disk{FORMAT} = $format;
+$disk{LOADER} = $loader;
+$disk{ARGS} = \@kernel_args;
+assemble_disk (%disk);
+
+# Done.
+exit 0;
+
+sub usage {
+    print <<'EOF';
+pintos-mkdisk, a utility for creating Pintos virtual disks
+Usage: pintos-mkdisk [OPTIONS] DISK [-- ARGUMENT...]
+where DISK is the virtual disk to create,
+      each ARGUMENT is inserted into the command line written to DISK,
+  and each OPTION is one of the following options.
+Partition options: (where PARTITION is one of: kernel filesys scratch swap)
+  --PARTITION=FILE         Use a copy of FILE for the given PARTITION
+  --PARTITION-size=SIZE    Create an empty PARTITION of the given SIZE in MB
+  --PARTITION-from=DISK    Use of a copy of the given PARTITION in DISK
+  (There is no --kernel-size option.)
+Output disk options:
+  --format=partitioned     Write partition table to output (default)
+  --format=raw             Do not write partition table to output
+  (Pintos can only use partitioned disks.)
+Partitioned format output options:
+  --loader[=FILE]          Get bootstrap loader from FILE (default: loader.bin
+                           if --kernel option is specified, empty otherwise)
+  --no-loader              Do not include a bootstrap loader
+  --geometry=H,S           Use H head, S sector geometry (default: 16, 63)
+  --geometry=zip           Use 64 head, 32 sector geometry for USB-ZIP boot
+                           per http://syslinux.zytor.com/usbkey.php
+  --align=bochs            Round size to cylinder for Bochs support (default)
+  --align=full             Align partition boundaries to cylinder boundary to
+                           let fdisk guess correct geometry and quiet warnings
+  --align=none             Don't align partitions at all, to save space
+Other options:
+  -h, --help               Display this help message.
+EOF
+    exit ($_[0]);
+}
diff --git a/utils/pintos-set-cmdline b/utils/pintos-set-cmdline
new file mode 100644
index 0000000..8c8f702
--- /dev/null
+++ b/utils/pintos-set-cmdline
@@ -0,0 +1,42 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Fcntl 'SEEK_SET';
+
+# Read Pintos.pm from the same directory as this program.
+BEGIN { my $self = $0; $self =~ s%/+[^/]*$%%; require "$self/Pintos.pm"; }
+
+# Get command-line arguments.
+usage (0) if @ARGV == 1 && $ARGV[0] eq '--help';
+usage (1) if @ARGV < 2 || $ARGV[1] ne '--';
+my ($disk, undef, @kernel_args) = @ARGV;
+
+# Open disk.
+my ($handle);
+open ($handle, '+<', $disk) or die "$disk: open: $!\n";
+
+# Check that it's a partitioned disk with a Pintos loader.
+my ($buffer) = read_fully ($handle, $disk, 512);
+unpack ("x510 v", $buffer) == 0xaa55 or die "$disk: not a partitioned disk\n";
+$buffer =~ /Pintos/ or die "$disk: does not contain Pintos loader\n";
+
+# Write the command line.
+our ($LOADER_SIZE);
+sysseek ($handle, $LOADER_SIZE, SEEK_SET) == $LOADER_SIZE
+  or die "$disk: seek: $!\n";
+write_fully ($handle, $disk, make_kernel_command_line (@kernel_args));
+
+# Close disk.
+close ($handle) or die "$disk: close: $!\n";
+
+exit 0;
+
+sub usage {
+    print <<'EOF';
+pintos-set-cmdline, a utility for changing the command line in Pintos disks
+Usage: pintos-set-cmdline DISK -- [ARGUMENT...]
+where DISK is a bootable disk containing a Pintos loader
+  and each ARGUMENT is inserted into the command line written to DISK.
+EOF
+    exit ($_[0]);
+}
diff --git a/utils/setitimer-helper.c b/utils/setitimer-helper.c
new file mode 100644
index 0000000..772d736
--- /dev/null
+++ b/utils/setitimer-helper.c
@@ -0,0 +1,49 @@
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  const char *program_name = argv[0];
+  double timeout;
+
+  if (argc < 3)
+    {
+      fprintf (stderr,
+               "setitimer-helper: runs a program with a virtual CPU limit\n"
+               "usage: %s TIMEOUT PROGRAM [ARG...]\n"
+               "  where TIMEOUT is the virtual CPU limit, in seconds,\n"
+               "    and remaining arguments specify the program to run\n"
+               "    and its argument.\n",
+               program_name);
+      return EXIT_FAILURE;
+    }
+
+  timeout = strtod (argv[1], NULL);
+  if (timeout >= 0.0 && timeout < LONG_MAX)
+    {
+      struct itimerval it;
+
+      it.it_interval.tv_sec = 0;
+      it.it_interval.tv_usec = 0;
+      it.it_value.tv_sec = timeout;
+      it.it_value.tv_usec = (timeout - floor (timeout)) * 1000000;
+      if (setitimer (ITIMER_VIRTUAL, &it, NULL) < 0)
+        fprintf (stderr, "%s: setitimer: %s\n",
+                 program_name, strerror (errno));
+    }
+  else
+    fprintf (stderr, "%s: invalid timeout value \"%s\"\n",
+             program_name, argv[1]);
+  
+  execvp (argv[2], &argv[2]);
+  fprintf (stderr, "%s: couldn't exec \"%s\": %s\n",
+           program_name, argv[2], strerror (errno));
+  return EXIT_FAILURE;
+}
diff --git a/utils/squish-pty.c b/utils/squish-pty.c
new file mode 100644
index 0000000..c8375a5
--- /dev/null
+++ b/utils/squish-pty.c
@@ -0,0 +1,355 @@
+#define _GNU_SOURCE 1
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stropts.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <termios.h>
+#include <unistd.h>
+
+static void
+fail_io (const char *msg, ...)
+     __attribute__ ((noreturn))
+     __attribute__ ((format (printf, 1, 2)));
+
+/* Prints MSG, formatting as with printf(),
+   plus an error message based on errno,
+   and exits. */
+static void
+fail_io (const char *msg, ...)
+{
+  va_list args;
+
+  va_start (args, msg);
+  vfprintf (stderr, msg, args);
+  va_end (args);
+
+  if (errno != 0)
+    fprintf (stderr, ": %s", strerror (errno));
+  putc ('\n', stderr);
+  exit (EXIT_FAILURE);
+}
+
+/* If FD is a terminal, configures it for noncanonical input mode
+   with VMIN and VTIME set as indicated.
+   If FD is not a terminal, has no effect. */
+static void
+make_noncanon (int fd, int vmin, int vtime)
+{
+  if (isatty (fd)) 
+    {
+      struct termios termios;
+      if (tcgetattr (fd, &termios) < 0)
+        fail_io ("tcgetattr");
+      termios.c_lflag &= ~(ICANON | ECHO);
+      termios.c_cc[VMIN] = vmin;
+      termios.c_cc[VTIME] = vtime;
+      if (tcsetattr (fd, TCSANOW, &termios) < 0)
+        fail_io ("tcsetattr");
+    }
+}
+
+/* Make FD non-blocking if NONBLOCKING is true,
+   or blocking if NONBLOCKING is false. */
+static void
+make_nonblocking (int fd, bool nonblocking) 
+{
+  int flags = fcntl (fd, F_GETFL);
+  if (flags < 0)
+    fail_io ("fcntl");
+  if (nonblocking)
+    flags |= O_NONBLOCK;
+  else
+    flags &= ~O_NONBLOCK;
+  if (fcntl (fd, F_SETFL, flags) < 0)
+    fail_io ("fcntl");
+}
+
+/* Handle a read or write on *FD, which is the pty if FD_IS_PTY
+   is true, that returned end-of-file or error indication RETVAL.
+   The system call is named CALL, for use in error messages.
+   Returns true if processing may continue, false if we're all
+   done. */
+static bool
+handle_error (ssize_t retval, int *fd, bool fd_is_pty, const char *call)
+{
+  if (fd_is_pty)
+    {
+      if (retval < 0)
+        {
+          if (errno == EIO)
+            {
+              /* Slave side of pty has been closed. */
+              return false;
+            }
+          else
+            fail_io (call); 
+        }
+      else
+        return true;
+    }
+  else 
+    {
+      if (retval == 0)
+        {
+          close (*fd);
+          *fd = -1;
+          return true;
+        }
+      else
+        fail_io (call);
+    }
+}
+
+/* Copies data from stdin to PTY and from PTY to stdout until no
+   more data can be read or written. */
+static void
+relay (int pty, int dead_child_fd) 
+{
+  struct pipe 
+    {
+      int in, out;
+      char buf[BUFSIZ];
+      size_t size, ofs;
+      bool active;
+    };
+  struct pipe pipes[2];
+
+  /* Make PTY, stdin, and stdout non-blocking. */
+  make_nonblocking (pty, true);
+  make_nonblocking (STDIN_FILENO, true);
+  make_nonblocking (STDOUT_FILENO, true);
+
+  /* Configure noncanonical mode on PTY and stdin to avoid
+     waiting for end-of-line.  We want to minimize context
+     switching on PTY (for efficiency) and minimize latency on
+     stdin to avoid a laggy user experience. */
+  make_noncanon (pty, 16, 1);
+  make_noncanon (STDIN_FILENO, 1, 0);
+
+  memset (pipes, 0, sizeof pipes);
+  pipes[0].in = STDIN_FILENO;
+  pipes[0].out = pty;
+  pipes[1].in = pty;
+  pipes[1].out = STDOUT_FILENO;
+  
+  while (pipes[0].in != -1 || pipes[1].in != -1)
+    {
+      fd_set read_fds, write_fds;
+      int retval;
+      int i;
+
+      FD_ZERO (&read_fds);
+      FD_ZERO (&write_fds);
+      for (i = 0; i < 2; i++)
+        {
+          struct pipe *p = &pipes[i];
+
+          /* Don't do anything with the stdin->pty pipe until we
+             have some data for the pty->stdout pipe.  If we get
+             too eager, Bochs will throw away our input. */
+          if (i == 0 && !pipes[1].active)
+            continue;
+          
+          if (p->in != -1 && p->size + p->ofs < sizeof p->buf)
+            FD_SET (p->in, &read_fds);
+          if (p->out != -1 && p->size > 0)
+            FD_SET (p->out, &write_fds); 
+        }
+      FD_SET (dead_child_fd, &read_fds);
+
+      do 
+        {
+          retval = select (FD_SETSIZE, &read_fds, &write_fds, NULL, NULL); 
+        }
+      while (retval < 0 && errno == EINTR);
+      if (retval < 0) 
+        fail_io ("select");
+
+      if (FD_ISSET (dead_child_fd, &read_fds))
+        {
+          /* Child died.  Do final relaying. */
+          struct pipe *p = &pipes[1];
+          if (p->out == -1)
+            return;
+          make_nonblocking (STDOUT_FILENO, false);
+          for (;;) 
+            {
+              ssize_t n;
+                  
+              /* Write buffer. */
+              while (p->size > 0) 
+                {
+                  n = write (p->out, p->buf + p->ofs, p->size);
+                  if (n < 0)
+                    fail_io ("write");
+                  else if (n == 0)
+                    fail_io ("zero-length write");
+                  p->ofs += n;
+                  p->size -= n;
+                }
+              p->ofs = 0;
+
+              p->size = n = read (p->in, p->buf, sizeof p->buf);
+              if (n <= 0)
+                return;
+            }
+        }
+
+      for (i = 0; i < 2; i++) 
+        {
+          struct pipe *p = &pipes[i];
+          if (p->in != -1 && FD_ISSET (p->in, &read_fds))
+            {
+              ssize_t n = read (p->in, p->buf + p->ofs + p->size,
+                                sizeof p->buf - p->ofs - p->size);
+              if (n > 0) 
+                {
+                  p->active = true;
+                  p->size += n;
+                  if (p->size == BUFSIZ && p->ofs != 0)
+                    {
+                      memmove (p->buf, p->buf + p->ofs, p->size);
+                      p->ofs = 0;
+                    }
+                }
+              else if (!handle_error (n, &p->in, p->in == pty, "read"))
+                return;
+            }
+          if (p->out != -1 && FD_ISSET (p->out, &write_fds)) 
+            {
+              ssize_t n = write (p->out, p->buf + p->ofs, p->size);
+              if (n > 0) 
+                {
+                  p->ofs += n;
+                  p->size -= n;
+                  if (p->size == 0)
+                    p->ofs = 0;
+                }
+              else if (!handle_error (n, &p->out, p->out == pty, "write"))
+                return;
+            }
+        }
+    }
+}
+
+static int dead_child_fd;
+
+static void
+sigchld_handler (int signo __attribute__ ((unused))) 
+{
+  if (write (dead_child_fd, "", 1) < 0)
+    _exit (1);
+}
+
+int
+main (int argc __attribute__ ((unused)), char *argv[])
+{
+  int master, slave;
+  char *name;
+  pid_t pid;
+  struct sigaction sa;
+  int pipe_fds[2];
+  struct itimerval zero_itimerval, old_itimerval;
+
+  if (argc < 2) 
+    {
+      fprintf (stderr,
+               "usage: squish-pty COMMAND [ARG]...\n"
+               "Squishes both stdin and stdout into a single pseudoterminal,\n"
+               "which is passed as stdout to run the specified COMMAND.\n");
+      return EXIT_FAILURE;
+    }
+
+  /* Open master side of pty and get ready to open slave. */
+  master = open ("/dev/ptmx", O_RDWR | O_NOCTTY);
+  if (master < 0)
+    fail_io ("open \"/dev/ptmx\"");
+  if (grantpt (master) < 0)
+    fail_io ("grantpt");
+  if (unlockpt (master) < 0)
+    fail_io ("unlockpt");
+
+  /* Open slave side of pty. */
+  name = ptsname (master);
+  if (name == NULL)
+    fail_io ("ptsname");
+  slave = open (name, O_RDWR);
+  if (slave < 0)
+    fail_io ("open \"%s\"", name);
+
+  /* System V implementations need STREAMS configuration for the
+     slave. */
+  if (isastream (slave))
+    {
+      if (ioctl (slave, I_PUSH, "ptem") < 0
+          || ioctl (slave, I_PUSH, "ldterm") < 0)
+        fail_io ("ioctl");
+    }
+
+  /* Arrange to get notified when a child dies, by writing a byte
+     to a pipe fd.  We really want to use pselect() and
+     sigprocmask(), but Solaris 2.7 doesn't have it. */
+  if (pipe (pipe_fds) < 0)
+    fail_io ("pipe");
+  dead_child_fd = pipe_fds[1];
+
+  memset (&sa, 0, sizeof sa);
+  sa.sa_handler = sigchld_handler;
+  sigemptyset (&sa.sa_mask);
+  sa.sa_flags = SA_RESTART;
+  if (sigaction (SIGCHLD, &sa, NULL) < 0)
+    fail_io ("sigaction");
+
+  /* Save the virtual interval timer, which might have been set
+     by the process that ran us.  It really should be applied to
+     our child process. */
+  memset (&zero_itimerval, 0, sizeof zero_itimerval);
+  if (setitimer (ITIMER_VIRTUAL, &zero_itimerval, &old_itimerval) < 0)
+    fail_io ("setitimer");
+  
+  pid = fork ();
+  if (pid < 0)
+    fail_io ("fork");
+  else if (pid != 0) 
+    {
+      /* Running in parent process. */
+      int status;
+      close (slave);
+      relay (master, pipe_fds[0]);
+
+      /* If the subprocess has died, die in the same fashion.
+         In particular, dying from SIGVTALRM tells the pintos
+         script that we ran out of CPU time. */
+      if (waitpid (pid, &status, WNOHANG) > 0)
+        {
+          if (WIFEXITED (status))
+            return WEXITSTATUS (status);
+          else if (WIFSIGNALED (status))
+            raise (WTERMSIG (status));
+        }
+      return 0; 
+    }
+  else 
+    {
+      /* Running in child process. */
+      if (setitimer (ITIMER_VIRTUAL, &old_itimerval, NULL) < 0)
+        fail_io ("setitimer");
+      if (dup2 (slave, STDOUT_FILENO) < 0)
+        fail_io ("dup2");
+      if (close (pipe_fds[0]) < 0 || close (pipe_fds[1]) < 0
+          || close (slave) < 0 || close (master) < 0)
+        fail_io ("close");
+      execvp (argv[1], argv + 1);
+      fail_io ("exec");
+    }
+}
diff --git a/utils/squish-unix.c b/utils/squish-unix.c
new file mode 100644
index 0000000..805205b
--- /dev/null
+++ b/utils/squish-unix.c
@@ -0,0 +1,338 @@
+#define _GNU_SOURCE 1
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stropts.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <termios.h>
+#include <unistd.h>
+
+static void
+fail_io (const char *msg, ...)
+     __attribute__ ((noreturn))
+     __attribute__ ((format (printf, 1, 2)));
+
+/* Prints MSG, formatting as with printf(),
+   plus an error message based on errno,
+   and exits. */
+static void
+fail_io (const char *msg, ...)
+{
+  va_list args;
+
+  va_start (args, msg);
+  vfprintf (stderr, msg, args);
+  va_end (args);
+
+  if (errno != 0)
+    fprintf (stderr, ": %s", strerror (errno));
+  putc ('\n', stderr);
+  exit (EXIT_FAILURE);
+}
+
+/* If FD is a terminal, configures it for noncanonical input mode
+   with VMIN and VTIME set as indicated.
+   If FD is not a terminal, has no effect. */
+static void
+make_noncanon (int fd, int vmin, int vtime)
+{
+  if (isatty (fd)) 
+    {
+      struct termios termios;
+      if (tcgetattr (fd, &termios) < 0)
+        fail_io ("tcgetattr");
+      termios.c_lflag &= ~(ICANON | ECHO);
+      termios.c_cc[VMIN] = vmin;
+      termios.c_cc[VTIME] = vtime;
+      if (tcsetattr (fd, TCSANOW, &termios) < 0)
+        fail_io ("tcsetattr");
+    }
+}
+
+/* Make FD non-blocking if NONBLOCKING is true,
+   or blocking if NONBLOCKING is false. */
+static void
+make_nonblocking (int fd, bool nonblocking) 
+{
+  int flags = fcntl (fd, F_GETFL);
+  if (flags < 0)
+    fail_io ("fcntl");
+  if (nonblocking)
+    flags |= O_NONBLOCK;
+  else
+    flags &= ~O_NONBLOCK;
+  if (fcntl (fd, F_SETFL, flags) < 0)
+    fail_io ("fcntl");
+}
+
+/* Handle a read or write on *FD, which is the socket if
+   FD_IS_SOCK is true, that returned end-of-file or error
+   indication RETVAL.  The system call is named CALL, for use in
+   error messages.  Returns true if processing may continue,
+   false if we're all done. */
+static bool
+handle_error (ssize_t retval, int *fd, bool fd_is_sock, const char *call)
+{
+  if (retval == 0)
+    {
+      if (fd_is_sock)
+        return false;
+      else
+        {
+          *fd = -1;
+          return true;
+        }
+    }
+  else
+    fail_io (call); 
+}
+
+/* Copies data from stdin to SOCK and from SOCK to stdout until no
+   more data can be read or written. */
+static void
+relay (int sock) 
+{
+  struct pipe 
+    {
+      int in, out;
+      char buf[BUFSIZ];
+      size_t size, ofs;
+      bool active;
+    };
+  struct pipe pipes[2];
+
+  /* In case stdin is a file, go back to the beginning.
+     This allows replaying the input on reset. */
+  lseek (STDIN_FILENO, 0, SEEK_SET);
+
+  /* Make SOCK, stdin, and stdout non-blocking. */
+  make_nonblocking (sock, true);
+  make_nonblocking (STDIN_FILENO, true);
+  make_nonblocking (STDOUT_FILENO, true);
+
+  /* Configure noncanonical mode on stdin to avoid waiting for
+     end-of-line. */
+  make_noncanon (STDIN_FILENO, 1, 0);
+
+  memset (pipes, 0, sizeof pipes);
+  pipes[0].in = STDIN_FILENO;
+  pipes[0].out = sock;
+  pipes[1].in = sock;
+  pipes[1].out = STDOUT_FILENO;
+  
+  while (pipes[0].in != -1 || pipes[1].in != -1
+         || (pipes[1].size && pipes[1].out != -1))
+    {
+      fd_set read_fds, write_fds;
+      sigset_t empty_set;
+      int retval;
+      int i;
+
+      FD_ZERO (&read_fds);
+      FD_ZERO (&write_fds);
+      for (i = 0; i < 2; i++)
+        {
+          struct pipe *p = &pipes[i];
+
+          /* Don't do anything with the stdin->sock pipe until we
+             have some data for the sock->stdout pipe.  If we get
+             too eager, vmplayer will throw away our input. */
+          if (i == 0 && !pipes[1].active)
+            continue;
+          
+          if (p->in != -1 && p->size + p->ofs < sizeof p->buf)
+            FD_SET (p->in, &read_fds);
+          if (p->out != -1 && p->size > 0)
+            FD_SET (p->out, &write_fds); 
+        }
+      sigemptyset (&empty_set);
+      retval = pselect (FD_SETSIZE, &read_fds, &write_fds, NULL, NULL,
+                        &empty_set);
+      if (retval < 0) 
+        {
+          if (errno == EINTR)
+            {
+              /* Child died.  Do final relaying. */
+              struct pipe *p = &pipes[1];
+              if (p->out == -1)
+                exit (0);
+              make_nonblocking (STDOUT_FILENO, false);
+              for (;;) 
+                {
+                  ssize_t n;
+                  
+                  /* Write buffer. */
+                  while (p->size > 0) 
+                    {
+                      n = write (p->out, p->buf + p->ofs, p->size);
+                      if (n < 0)
+                        fail_io ("write");
+                      else if (n == 0)
+                        fail_io ("zero-length write");
+                      p->ofs += n;
+                      p->size -= n;
+                    }
+                  p->ofs = 0;
+
+                  p->size = n = read (p->in, p->buf, sizeof p->buf);
+                  if (n <= 0)
+                    exit (0);
+                }
+            }
+          fail_io ("select"); 
+        }
+
+      for (i = 0; i < 2; i++) 
+        {
+          struct pipe *p = &pipes[i];
+          if (p->in != -1 && FD_ISSET (p->in, &read_fds))
+            {
+              ssize_t n = read (p->in, p->buf + p->ofs + p->size,
+                                sizeof p->buf - p->ofs - p->size);
+              if (n > 0) 
+                {
+                  p->active = true;
+                  p->size += n;
+                  if (p->size == BUFSIZ && p->ofs != 0)
+                    {
+                      memmove (p->buf, p->buf + p->ofs, p->size);
+                      p->ofs = 0;
+                    }
+                }
+              else if (!handle_error (n, &p->in, p->in == sock, "read"))
+                return;
+            }
+          if (p->out != -1 && FD_ISSET (p->out, &write_fds)) 
+            {
+              ssize_t n = write (p->out, p->buf + p->ofs, p->size);
+              if (n > 0) 
+                {
+                  p->ofs += n;
+                  p->size -= n;
+                  if (p->size == 0)
+                    p->ofs = 0;
+                }
+              else if (!handle_error (n, &p->out, p->out == sock, "write"))
+                return;
+            }
+        }
+    }
+}
+
+static void
+sigchld_handler (int signo __attribute__ ((unused))) 
+{
+  /* Nothing to do. */
+}
+
+int
+main (int argc __attribute__ ((unused)), char *argv[])
+{
+  pid_t pid;
+  struct itimerval zero_itimerval;
+  struct sockaddr_un sun;
+  sigset_t sigchld_set;
+  int sock;
+  
+  if (argc < 3) 
+    {
+      fprintf (stderr,
+               "usage: squish-unix SOCKET COMMAND [ARG]...\n"
+               "Squishes both stdin and stdout into a single Unix domain\n"
+               "socket named SOCKET, and runs COMMAND as a subprocess.\n");
+      return EXIT_FAILURE;
+    }
+
+  /* Create socket. */
+  sock = socket (PF_LOCAL, SOCK_STREAM, 0);
+  if (sock < 0)
+    fail_io ("socket");
+
+  /* Configure socket. */
+  sun.sun_family = AF_LOCAL;
+  strncpy (sun.sun_path, argv[1], sizeof sun.sun_path);
+  sun.sun_path[sizeof sun.sun_path - 1] = '\0';
+  if (unlink (sun.sun_path) < 0 && errno != ENOENT)
+    fail_io ("unlink");
+  if (bind (sock, (struct sockaddr *) &sun,
+            (offsetof (struct sockaddr_un, sun_path)
+             + strlen (sun.sun_path) + 1)) < 0)
+    fail_io ("bind");
+
+  /* Listen on socket. */
+  if (listen (sock, 1) < 0)
+    fail_io ("listen");
+
+  /* Block SIGCHLD and set up a handler for it. */
+  sigemptyset (&sigchld_set);
+  sigaddset (&sigchld_set, SIGCHLD);
+  if (sigprocmask (SIG_BLOCK, &sigchld_set, NULL) < 0)
+    fail_io ("sigprocmask");
+  if (signal (SIGCHLD, sigchld_handler) == SIG_ERR)
+    fail_io ("signal");
+
+  /* Save the virtual interval timer, which might have been set
+     by the process that ran us.  It really should be applied to
+     our child process. */
+  memset (&zero_itimerval, 0, sizeof zero_itimerval);
+  if (setitimer (ITIMER_VIRTUAL, &zero_itimerval, NULL) < 0)
+    fail_io ("setitimer");
+  
+  pid = fork ();
+  if (pid < 0)
+    fail_io ("fork");
+  else if (pid != 0) 
+    {
+      /* Running in parent process. */
+      make_nonblocking (sock, true);
+      for (;;) 
+        {
+          fd_set read_fds;
+          sigset_t empty_set;
+          int retval;
+          int conn;
+
+          /* Wait for connection. */
+          FD_ZERO (&read_fds);
+          FD_SET (sock, &read_fds);
+          sigemptyset (&empty_set);
+          retval = pselect (sock + 1, &read_fds, NULL, NULL, NULL, &empty_set);
+          if (retval < 0) 
+            {
+              if (errno == EINTR)
+                break;
+              fail_io ("select"); 
+            }
+
+          /* Accept connection. */
+          conn = accept (sock, NULL, NULL);
+          if (conn < 0)
+            fail_io ("accept");
+
+          /* Relay connection. */
+          relay (conn);
+          close (conn);
+        }
+      return 0; 
+    }
+  else 
+    {
+      /* Running in child process. */
+      if (close (sock) < 0)
+        fail_io ("close");
+      execvp (argv[2], argv + 2);
+      fail_io ("exec");
+    }
+}