# Command-line options.
our ($start_time) = time ();
-our ($sim); # Simulator: bochs, qemu, or gsx.
+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?
GetOptions ("sim=s" => sub { set_sim (@_) },
"bochs" => sub { set_sim ("bochs") },
"qemu" => sub { set_sim ("qemu") },
- "gsx" => sub { set_sim ("gsx") },
+ "player" => sub { set_sim ("player") },
"debug=s" => sub { set_debug (@_) },
"no-debug" => sub { set_debug ("none") },
Simulator selection:
--bochs (default) Use Bochs as simulator
--qemu Use qemu as simulator
- --gsx Use VMware GSX Server 3.x as simulator
+ --player Use VMware Player as simulator
Debugger selection:
--no-debug (default) No debugger
--monitor Debug with simulator's monitor
run_bochs ();
} elsif ($sim eq 'qemu') {
run_qemu ();
- } elsif ($sim eq 'gsx') {
- run_gsx ();
+ } elsif ($sim eq 'player') {
+ run_player ();
} else {
die "unknown simulator `$sim'\n";
}
my ($squish_pty);
if ($serial) {
- for my $dir (split (':', $ENV{PATH})) {
- $squish_pty = "$dir/squish-pty", last if -x "$dir/squish-pty";
- }
+ $squish_pty = find_in_path ("squish-pty");
print "warning: can't find squish-pty, so terminal input will fail\n"
if !defined $squish_pty;
}
run_command (@cmd);
}
-# gsx_unsup($flag)
+# player_unsup($flag)
#
-# Prints a message that $flag is unsupported by GSX Server.
-sub gsx_unsup {
+# Prints a message that $flag is unsupported by VMware Player.
+sub player_unsup {
my ($flag) = @_;
- print "warning: no support for $flag with VMware GSX Server\n";
+ print "warning: no support for $flag with VMware Player\n";
}
-# Runs VMware GSX Server.
-sub run_gsx {
- gsx_unsup ("--$debug") if $debug ne 'none';
- gsx_unsup ("--no-vga") if $vga eq 'none';
- gsx_unsup ("--terminal") if $vga eq 'terminal';
- gsx_unsup ("--jitter") if defined $jitter;
- gsx_unsup ("--kill-on-failure") if defined $kill_on_failure;
+# 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;
- unlink ("pintos.out");
+ # Memory size must be multiple of 4.
+ $mem = int (($mem + 3) / 4) * 4;
open (VMX, ">", "pintos.vmx") or die "pintos.vmx: create: $!\n";
chmod 0777 & ~umask, "pintos.vmx";
print VMX <<EOF;
#! /usr/bin/vmware -G
-config.version = 6
+config.version = 8
guestOS = "linux"
-floppy0.present = FALSE
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 = "file"
-serial0.fileName = "pintos.out"
+serial0.fileType = "pipe"
+serial0.fileName = "pintos.socket"
+serial0.pipe.endPoint = "client"
+serial0.tryNoRxLoss = "TRUE"
EOF
for (my ($i) = 0; $i < 4; $i++) {
my ($dsk) = $disk->{FILE_NAME};
next if !defined $dsk;
- my ($pln) = $dsk;
- $pln =~ s/\.dsk//;
- $pln .= ".pln";
-
my ($device) = "ide" . int ($i / 2) . ":" . ($i % 2);
+ my ($pln) = "$device.pln";
print VMX <<EOF;
$device.present = TRUE
$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 ($disk);
open (PLN, ">", $pln) or die "$pln: create: $!\n";
print PLN <<EOF;
-DRIVETYPE ide
-#vm|VERSION 2
-#vm|TOOLSVERSION 2
-CYLINDERS $geom{C}
-HEADS $geom{H}
-SECTORS $geom{S}
-#vm|CAPACITY $geom{CAPACITY}
-ACCESS "$dsk" 0 $geom{CAPACITY}
+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";
- system ("vmware-cmd -s register $vmx >&/dev/null");
- system ("vmware-cmd $vmx stop hard >&/dev/null");
- system ("vmware -l -G -x -q $vmx");
- system ("vmware-cmd $vmx stop hard >&/dev/null");
- system ("vmware-cmd -s unregister $vmx >&/dev/null");
+ my (@cmd) = ("vmplayer", $vmx);
+ unshift (@cmd, $squish_unix, "pintos.socket") if $squish_unix;
+ print join (' ', @cmd), "\n";
+ xsystem (@cmd);
}
\f
# Disk utilities.
}
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;
+}
--- /dev/null
+#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");
+ }
+}
projects / pintos-anon / commitdiff