+ /* First search g->path for the supermin appliance, and try to
+ * synthesize a kernel and initrd from that. If it fails, we
+ * try the path search again looking for a backup ordinary
+ * appliance.
+ */
+ pelem = path = safe_strdup (g, g->path);
+ do {
+ pend = strchrnul (pelem, ':');
+ pmore = *pend == ':';
+ *pend = '\0';
+ len = pend - pelem;
+
+ /* Empty element of "." means cwd. */
+ if (len == 0 || (len == 1 && *pelem == '.')) {
+ if (g->verbose)
+ fprintf (stderr,
+ "looking for supermin appliance in current directory\n");
+ if (dir_contains_files (".",
+ supermin_name, supermin_hostfiles_name,
+ "kmod.whitelist", NULL)) {
+ if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1)
+ return -1;
+ break;
+ }
+ }
+ /* Look at <path>/supermin* etc. */
+ else {
+ if (g->verbose)
+ fprintf (stderr, "looking for supermin appliance in %s\n", pelem);
+
+ if (dir_contains_files (pelem,
+ supermin_name, supermin_hostfiles_name,
+ "kmod.whitelist", NULL)) {
+ if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1)
+ return -1;
+ break;
+ }
+ }
+
+ pelem = pend + 1;
+ } while (pmore);
+
+ free (path);
+
+ if (kernel == NULL || initrd == NULL) {
+ /* Search g->path for the kernel and initrd. */
+ pelem = path = safe_strdup (g, g->path);
+ do {
+ pend = strchrnul (pelem, ':');
+ pmore = *pend == ':';
+ *pend = '\0';
+ len = pend - pelem;
+
+ /* Empty element or "." means cwd. */
+ if (len == 0 || (len == 1 && *pelem == '.')) {
+ if (g->verbose)
+ fprintf (stderr,
+ "looking for appliance in current directory\n");
+ if (dir_contains_files (".", kernel_name, initrd_name, NULL)) {
+ kernel = safe_strdup (g, kernel_name);
+ initrd = safe_strdup (g, initrd_name);
+ break;
+ }
+ }
+ /* Look at <path>/kernel etc. */
+ else {
+ if (g->verbose)
+ fprintf (stderr, "looking for appliance in %s\n", pelem);
+
+ if (dir_contains_files (pelem, kernel_name, initrd_name, NULL)) {
+ kernel = safe_malloc (g, len + strlen (kernel_name) + 2);
+ initrd = safe_malloc (g, len + strlen (initrd_name) + 2);
+ sprintf (kernel, "%s/%s", pelem, kernel_name);
+ sprintf (initrd, "%s/%s", pelem, initrd_name);
+ break;
+ }
+ }
+
+ pelem = pend + 1;
+ } while (pmore);
+
+ free (path);
+ }
+
+ if (kernel == NULL || initrd == NULL) {
+ error (g, _("cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)"),
+ kernel_name, initrd_name, g->path);
+ goto cleanup0;
+ }
+
+ /* Get qemu help text and version. */
+ if (test_qemu (g) == -1)
+ goto cleanup0;
+
+ /* Make the vmchannel socket. */
+ snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir);
+ unlink (unixsock);
+
+ if (pipe (wfd) == -1 || pipe (rfd) == -1) {
+ perrorf (g, "pipe");
+ goto cleanup0;
+ }
+
+ r = fork ();
+ if (r == -1) {
+ perrorf (g, "fork");
+ close (wfd[0]);
+ close (wfd[1]);
+ close (rfd[0]);
+ close (rfd[1]);
+ goto cleanup0;
+ }
+
+ if (r == 0) { /* Child (qemu). */
+ char vmchannel[256];
+ char append[256];
+ char memsize_str[256];
+
+ /* Set up the full command line. Do this in the subprocess so we
+ * don't need to worry about cleaning up.
+ */
+ g->cmdline[0] = g->qemu;
+
+#define LINUX_CMDLINE \
+ "panic=1 " /* force kernel to panic if daemon exits */ \
+ "console=ttyS0 " /* serial console */ \
+ "udevtimeout=300 " /* good for very slow systems (RHBZ#480319) */ \
+ "noapic " /* workaround for RHBZ#502058 - ok if not SMP */ \
+ "acpi=off " /* we don't need ACPI, turn it off */ \
+ "cgroup_disable=memory " /* saves us about 5 MB of RAM */
+
+ /* Linux kernel command line. */
+ snprintf (append, sizeof append,
+ LINUX_CMDLINE
+ "guestfs=%s:%d "
+ "%s" /* (selinux) */
+ "%s" /* (verbose) */
+ "%s", /* (append) */
+ VMCHANNEL_ADDR, VMCHANNEL_PORT,
+ g->selinux ? "selinux=1 enforcing=0 " : "selinux=0 ",
+ g->verbose ? "guestfs_verbose=1 " : " ",
+ g->append ? g->append : "");
+
+ snprintf (memsize_str, sizeof memsize_str, "%d", g->memsize);
+
+ add_cmdline (g, "-m");
+ add_cmdline (g, memsize_str);
+ add_cmdline (g, "-no-reboot"); /* Force exit instead of reboot on panic */
+ add_cmdline (g, "-kernel");
+ add_cmdline (g, (char *) kernel);
+ add_cmdline (g, "-initrd");
+ add_cmdline (g, (char *) initrd);
+ add_cmdline (g, "-append");
+ add_cmdline (g, append);
+ add_cmdline (g, "-nographic");
+ add_cmdline (g, "-serial");
+ add_cmdline (g, "stdio");
+
+#if 0
+ /* Doesn't work. See:
+ * http://lists.gnu.org/archive/html/qemu-devel/2009-07/threads.html
+ * Subject "guestfwd option doesn't allow supplementary ,server,nowait"
+ */
+ if (qemu_supports (g, "guestfwd")) {
+ /* New-style -net user,guestfwd=... syntax for vmchannel. See:
+ * http://git.savannah.gnu.org/cgit/qemu.git/commit/?id=c92ef6a22d3c71538fcc48fb61ad353f7ba03b62
+ */
+ snprintf (vmchannel, sizeof vmchannel,
+ "user,vlan=0,net=10.0.2.0/8,guestfwd=tcp:%s:%d-unix:%s,server,nowait",
+ VMCHANNEL_ADDR, VMCHANNEL_PORT, unixsock);
+
+ add_cmdline (g, "-net");
+ add_cmdline (g, vmchannel);
+ } else {
+#endif
+ /* Not guestfwd. HOPEFULLY this qemu uses the older -net channel
+ * syntax, or if not then we'll get a quick failure.
+ */
+ snprintf (vmchannel, sizeof vmchannel,
+ "channel,%d:unix:%s,server,nowait",
+ VMCHANNEL_PORT, unixsock);
+
+ add_cmdline (g, "-net");
+ add_cmdline (g, vmchannel);
+ add_cmdline (g, "-net");
+ add_cmdline (g, "user,vlan=0,net=10.0.2.0/8");
+#if 0
+ }
+#endif
+ add_cmdline (g, "-net");
+ add_cmdline (g, "nic,model=" NET_IF ",vlan=0");
+
+ /* These options recommended by KVM developers to improve reliability. */
+ if (qemu_supports (g, "-no-hpet"))
+ add_cmdline (g, "-no-hpet");
+
+ if (qemu_supports (g, "-rtc-td-hack"))
+ add_cmdline (g, "-rtc-td-hack");
+
+ /* Finish off the command line. */
+ incr_cmdline_size (g);
+ g->cmdline[g->cmdline_size-1] = NULL;
+
+ if (g->verbose)
+ print_cmdline (g);
+
+ /* Set up stdin, stdout. */
+ close (0);
+ close (1);
+ close (wfd[1]);
+ close (rfd[0]);
+
+ if (dup (wfd[0]) == -1) {
+ dup_failed:
+ perror ("dup failed");
+ _exit (1);
+ }
+ if (dup (rfd[1]) == -1)
+ goto dup_failed;
+
+ close (wfd[0]);
+ close (rfd[1]);
+
+#if 0
+ /* Set up a new process group, so we can signal this process
+ * and all subprocesses (eg. if qemu is really a shell script).
+ */
+ setpgid (0, 0);
+#endif
+
+ execv (g->qemu, g->cmdline); /* Run qemu. */
+ perror (g->qemu);
+ _exit (1);
+ }
+
+ /* Parent (library). */
+ g->pid = r;
+
+ free (kernel);
+ kernel = NULL;
+ free (initrd);
+ initrd = NULL;
+
+ /* Fork the recovery process off which will kill qemu if the parent
+ * process fails to do so (eg. if the parent segfaults).
+ */
+ r = fork ();
+ if (r == 0) {
+ pid_t qemu_pid = g->pid;
+ pid_t parent_pid = getppid ();
+
+ /* Writing to argv is hideously complicated and error prone. See:
+ * http://anoncvs.postgresql.org/cvsweb.cgi/pgsql/src/backend/utils/misc/ps_status.c?rev=1.33.2.1;content-type=text%2Fplain
+ */
+
+ /* Loop around waiting for one or both of the other processes to
+ * disappear. It's fair to say this is very hairy. The PIDs that
+ * we are looking at might be reused by another process. We are
+ * effectively polling. Is the cure worse than the disease?
+ */
+ for (;;) {
+ if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */
+ _exit (0);
+ if (kill (parent_pid, 0) == -1) {
+ /* Parent's gone away, qemu still around, so kill qemu. */
+ kill (qemu_pid, 9);
+ _exit (0);
+ }
+ sleep (2);
+ }
+ }
+
+ /* Don't worry, if the fork failed, this will be -1. The recovery
+ * process isn't essential.
+ */
+ g->recoverypid = r;
+
+ /* Start the clock ... */
+ time (&g->start_t);
+
+ /* Close the other ends of the pipe. */
+ close (wfd[0]);
+ close (rfd[1]);
+
+ if (fcntl (wfd[1], F_SETFL, O_NONBLOCK) == -1 ||
+ fcntl (rfd[0], F_SETFL, O_NONBLOCK) == -1) {
+ perrorf (g, "fcntl");
+ goto cleanup1;
+ }
+
+ g->fd[0] = wfd[1]; /* stdin of child */
+ g->fd[1] = rfd[0]; /* stdout of child */
+
+ /* Open the Unix socket. The vmchannel implementation that got
+ * merged with qemu sucks in a number of ways. Both ends do
+ * connect(2), which means that no one knows what, if anything, is
+ * connected to the other end, or if it becomes disconnected. Even
+ * worse, we have to wait some indeterminate time for qemu to create
+ * the socket and connect to it (which happens very early in qemu's
+ * start-up), so any code that uses vmchannel is inherently racy.
+ * Hence this silly loop.
+ */
+ g->sock = socket (AF_UNIX, SOCK_STREAM, 0);
+ if (g->sock == -1) {
+ perrorf (g, "socket");
+ goto cleanup1;
+ }
+
+ if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) {
+ perrorf (g, "fcntl");
+ goto cleanup2;
+ }
+
+ addr.sun_family = AF_UNIX;
+ strncpy (addr.sun_path, unixsock, UNIX_PATH_MAX);
+ addr.sun_path[UNIX_PATH_MAX-1] = '\0';
+
+ tries = 100;
+ /* Always sleep at least once to give qemu a small chance to start up. */
+ usleep (10000);
+ while (tries > 0) {
+ r = connect (g->sock, (struct sockaddr *) &addr, sizeof addr);
+ if ((r == -1 && errno == EINPROGRESS) || r == 0)
+ goto connected;
+
+ if (errno != ENOENT)
+ perrorf (g, "connect");
+ tries--;
+ usleep (100000);
+ }
+
+ error (g, _("failed to connect to vmchannel socket"));
+ goto cleanup2;
+
+ connected:
+ /* Watch the file descriptors. */
+ free (g->msg_in);
+ g->msg_in = NULL;
+ g->msg_in_size = g->msg_in_allocated = 0;
+
+ free (g->msg_out);
+ g->msg_out = NULL;
+ g->msg_out_size = 0;
+ g->msg_out_pos = 0;
+
+ g->stdout_watch =
+ g->main_loop->add_handle (g->main_loop, g, g->fd[1],
+ GUESTFS_HANDLE_READABLE,
+ stdout_event, NULL);
+ if (g->stdout_watch == -1) {
+ error (g, _("could not watch qemu stdout"));
+ goto cleanup3;
+ }
+
+ if (guestfs__switch_to_receiving (g) == -1)
+ goto cleanup3;
+
+ g->state = LAUNCHING;
+ return 0;
+
+ cleanup3:
+ if (g->stdout_watch >= 0)
+ g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch);
+ if (g->sock_watch >= 0)
+ g->main_loop->remove_handle (g->main_loop, g, g->sock_watch);
+
+ cleanup2:
+ close (g->sock);
+
+ cleanup1:
+ close (wfd[1]);
+ close (rfd[0]);
+ kill (g->pid, 9);
+ if (g->recoverypid > 0) kill (g->recoverypid, 9);
+ waitpid (g->pid, NULL, 0);
+ if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
+ g->fd[0] = -1;
+ g->fd[1] = -1;
+ g->sock = -1;
+ g->pid = 0;
+ g->recoverypid = 0;
+ g->start_t = 0;
+ g->stdout_watch = -1;
+ g->sock_watch = -1;
+
+ cleanup0:
+ free (kernel);
+ free (initrd);
+ return -1;
+}
+
+/* This function is used to print the qemu command line before it gets
+ * executed, when in verbose mode.
+ */
+static void
+print_cmdline (guestfs_h *g)
+{
+ int i = 0;
+ int needs_quote;
+
+ while (g->cmdline[i]) {
+ if (g->cmdline[i][0] == '-') /* -option starts a new line */
+ fprintf (stderr, " \\\n ");
+
+ if (i > 0) fputc (' ', stderr);
+
+ /* Does it need shell quoting? This only deals with simple cases. */
+ needs_quote = strcspn (g->cmdline[i], " ") != strlen (g->cmdline[i]);
+
+ if (needs_quote) fputc ('\'', stderr);
+ fprintf (stderr, "%s", g->cmdline[i]);
+ if (needs_quote) fputc ('\'', stderr);
+ i++;
+ }
+
+ fputc ('\n', stderr);
+}
+
+/* This function does the hard work of building the supermin appliance
+ * on the fly. 'path' is the directory containing the control files.
+ * 'kernel' and 'initrd' are where we will return the names of the
+ * kernel and initrd (only initrd is built). The work is done by
+ * an external script. We just tell it where to put the result.
+ */
+static int
+build_supermin_appliance (guestfs_h *g, const char *path,
+ char **kernel, char **initrd)
+{
+ char cmd[4096];
+ int r, len;
+
+ len = strlen (g->tmpdir);
+ *kernel = safe_malloc (g, len + 8);
+ snprintf (*kernel, len+8, "%s/kernel", g->tmpdir);
+ *initrd = safe_malloc (g, len + 8);
+ snprintf (*initrd, len+8, "%s/initrd", g->tmpdir);
+
+ snprintf (cmd, sizeof cmd,
+ "PATH='%s':$PATH "
+ "libguestfs-supermin-helper '%s' %s %s",
+ path,
+ path, *kernel, *initrd);
+
+ r = system (cmd);
+ if (r == -1 || WEXITSTATUS(r) != 0) {
+ error (g, _("external command failed: %s"), cmd);
+ free (*kernel);
+ free (*initrd);
+ *kernel = *initrd = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+static int read_all (guestfs_h *g, FILE *fp, char **ret);
+
+/* Test qemu binary (or wrapper) runs, and do 'qemu -help' and
+ * 'qemu -version' so we know what options this qemu supports and
+ * the version.
+ */
+static int
+test_qemu (guestfs_h *g)
+{
+ char cmd[1024];
+ FILE *fp;
+
+ free (g->qemu_help);
+ free (g->qemu_version);
+ g->qemu_help = NULL;
+ g->qemu_version = NULL;
+
+ snprintf (cmd, sizeof cmd, "'%s' -help", g->qemu);
+
+ fp = popen (cmd, "r");
+ /* qemu -help should always work (qemu -version OTOH wasn't
+ * supported by qemu 0.9). If this command doesn't work then it
+ * probably indicates that the qemu binary is missing.
+ */
+ if (!fp) {
+ /* XXX This error is never printed, even if the qemu binary
+ * doesn't exist. Why?
+ */
+ error:
+ perrorf (g, _("%s: command failed: If qemu is located on a non-standard path, try setting the LIBGUESTFS_QEMU environment variable."), cmd);
+ return -1;
+ }
+
+ if (read_all (g, fp, &g->qemu_help) == -1)
+ goto error;
+
+ if (pclose (fp) == -1)
+ goto error;
+
+ snprintf (cmd, sizeof cmd, "'%s' -version 2>/dev/null", g->qemu);
+
+ fp = popen (cmd, "r");
+ if (fp) {
+ /* Intentionally ignore errors. */
+ read_all (g, fp, &g->qemu_version);
+ pclose (fp);
+ }
+
+ return 0;
+}
+
+static int
+read_all (guestfs_h *g, FILE *fp, char **ret)
+{
+ int r, n = 0;
+ char *p;
+
+ again:
+ if (feof (fp)) {
+ *ret = safe_realloc (g, *ret, n + 1);
+ (*ret)[n] = '\0';
+ return n;
+ }
+
+ *ret = safe_realloc (g, *ret, n + BUFSIZ);
+ p = &(*ret)[n];
+ r = fread (p, 1, BUFSIZ, fp);
+ if (ferror (fp)) {
+ perrorf (g, "read");
+ return -1;
+ }
+ n += r;
+ goto again;
+}
+
+/* Test if option is supported by qemu command line (just by grepping
+ * the help text).
+ */
+static int
+qemu_supports (guestfs_h *g, const char *option)
+{
+ return g->qemu_help && strstr (g->qemu_help, option) != NULL;
+}
+
+static void
+finish_wait_ready (guestfs_h *g, void *vp)
+{
+ if (g->verbose)
+ fprintf (stderr, "finish_wait_ready called, %p, vp = %p\n", g, vp);
+
+ *((int *)vp) = 1;
+ g->main_loop->main_loop_quit (g->main_loop, g);
+}
+
+int
+guestfs__wait_ready (guestfs_h *g)
+{
+ int finished = 0, r;
+
+ if (g->state == READY) return 0;
+
+ if (g->state == BUSY) {
+ error (g, _("qemu has finished launching already"));
+ return -1;
+ }
+
+ if (g->state != LAUNCHING) {
+ error (g, _("qemu has not been launched yet"));
+ return -1;
+ }
+
+ g->launch_done_cb = finish_wait_ready;
+ g->launch_done_cb_data = &finished;
+ r = g->main_loop->main_loop_run (g->main_loop, g);
+ g->launch_done_cb = NULL;
+ g->launch_done_cb_data = NULL;
+
+ if (r == -1) return -1;
+
+ if (finished != 1) {
+ error (g, _("guestfs_wait_ready failed, see earlier error messages"));
+ return -1;
+ }
+
+ /* This is possible in some really strange situations, such as
+ * guestfsd starts up OK but then qemu immediately exits. Check for
+ * it because the caller is probably expecting to be able to send
+ * commands after this function returns.
+ */
+ if (g->state != READY) {
+ error (g, _("qemu launched and contacted daemon, but state != READY"));
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+guestfs__kill_subprocess (guestfs_h *g)
+{
+ if (g->state == CONFIG) {
+ error (g, _("no subprocess to kill"));
+ return -1;
+ }
+
+ if (g->verbose)
+ fprintf (stderr, "sending SIGTERM to process %d\n", g->pid);
+
+ kill (g->pid, SIGTERM);
+ if (g->recoverypid > 0) kill (g->recoverypid, 9);
+
+ return 0;
+}
+
+/* Access current state. */
+int
+guestfs__is_config (guestfs_h *g)
+{
+ return g->state == CONFIG;
+}
+
+int
+guestfs__is_launching (guestfs_h *g)
+{
+ return g->state == LAUNCHING;
+}
+
+int
+guestfs__is_ready (guestfs_h *g)
+{
+ return g->state == READY;
+}
+
+int
+guestfs__is_busy (guestfs_h *g)
+{
+ return g->state == BUSY;
+}
+
+int
+guestfs__get_state (guestfs_h *g)
+{
+ return g->state;
+}
+
+int
+guestfs__set_ready (guestfs_h *g)
+{
+ if (g->state != BUSY) {
+ error (g, _("guestfs_set_ready: called when in state %d != BUSY"),
+ g->state);
+ return -1;
+ }
+ g->state = READY;
+ return 0;
+}
+
+int
+guestfs__set_busy (guestfs_h *g)
+{
+ if (g->state != READY) {
+ error (g, _("guestfs_set_busy: called when in state %d != READY"),
+ g->state);
+ return -1;
+ }
+ g->state = BUSY;
+ return 0;
+}
+
+int
+guestfs__end_busy (guestfs_h *g)
+{
+ switch (g->state)
+ {
+ case BUSY:
+ g->state = READY;
+ break;
+ case CONFIG:
+ case READY:
+ break;
+
+ case LAUNCHING:
+ case NO_HANDLE:
+ default:
+ error (g, _("guestfs_end_busy: called when in state %d"), g->state);
+ return -1;
+ }
+ return 0;
+}
+
+/* We don't know if stdout_event or sock_read_event will be the
+ * first to receive EOF if the qemu process dies. This function
+ * has the common cleanup code for both.
+ */
+static void
+child_cleanup (guestfs_h *g)
+{
+ if (g->verbose)
+ fprintf (stderr, "stdout_event: %p: child process died\n", g);
+ /*kill (g->pid, SIGTERM);*/
+ if (g->recoverypid > 0) kill (g->recoverypid, 9);
+ waitpid (g->pid, NULL, 0);
+ if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0);
+ if (g->stdout_watch >= 0)
+ g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch);
+ if (g->sock_watch >= 0)
+ g->main_loop->remove_handle (g->main_loop, g, g->sock_watch);
+ close (g->fd[0]);
+ close (g->fd[1]);
+ close (g->sock);
+ g->fd[0] = -1;
+ g->fd[1] = -1;
+ g->sock = -1;
+ g->pid = 0;
+ g->recoverypid = 0;
+ g->start_t = 0;
+ g->stdout_watch = -1;
+ g->sock_watch = -1;
+ g->state = CONFIG;
+ if (g->subprocess_quit_cb)
+ g->subprocess_quit_cb (g, g->subprocess_quit_cb_data);
+}
+
+/* This function is called whenever qemu prints something on stdout.
+ * Qemu's stdout is also connected to the guest's serial console, so
+ * we see kernel messages here too.