}
/* release mutex (XXX) */
+ free (g->msg_in);
+ free (g->msg_out);
free (g->last_error);
free (g);
}
char *kernel = NULL, *initrd = NULL;
char unixsock[256];
struct sockaddr_un addr;
- struct stat statbuf;
/* Configured? */
if (!g->cmdline) {
goto cleanup0;
}
- /* Choose a suitable memory size (in MB). This is more art
- * than science, but you can help by doing
- * ./configure --enable-debug-command
- * and then running:
- * debug sh free
- * debug mem ''
- * and seeing how much free memory is left for particular
- * configurations.
- *
- * It's also helpful to report both the compressed and uncompressed
- * size of the initramfs (ls -lh initramfs*.img; du -sh initramfs).
- *
- * XXX KVM virtio balloon driver?
+ /* Choose a suitable memory size. Previously we tried to choose
+ * a minimal memory size, but this isn't really necessary since
+ * recent QEMU and KVM don't do anything nasty like locking
+ * memory into core any more. This we can safely choose a
+ * large, generous amount of memory, and it'll just get swapped
+ * on smaller systems.
*/
- if (stat (initrd, &statbuf) != -1) {
- /* Approximate size of the initramfs after it is decompressed
- * in kernel memory. The compression factor is ~2.5-3.
- */
- memsize = 3 * statbuf.st_size / 1024 / 1024;
-
- /* Approximate size used by the kernel. */
- memsize += 10;
-
- /* Want to give userspace some room, so: */
- memsize += 128;
-
-#if SIZEOF_LONG == 8
- /* On 64 bit, assume some overhead. */
- memsize += 64;
-#endif
- } else
- memsize = 512;
-
+ memsize = 384;
/* Make the temporary directory containing the socket. */
if (!g->tmpdir) {
/* Linux kernel command line. */
snprintf (append, sizeof append,
- "console=ttyS0 guestfs=%s:%d%s",
+ "panic=1 console=ttyS0 guestfs=%s:%d%s",
VMCHANNEL_ADDR, VMCHANNEL_PORT,
g->verbose ? " guestfs_verbose=1" : "");
#if 0
add_cmdline (g, "-no-kqemu"); /* Avoids a warning. */
#endif
+ 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");
/* 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).
*/
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:
+ error (g, "guestfs_end_busy: called when in state %d", g->state);
+ return -1;
+ }
+ return 0;
+}
+
/* Structure-freeing functions. These rely on the fact that the
* structure format is identical to the XDR format. See note in
* generator.ml.
free (x);
}
+/* 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.
n = read (fd, buf, sizeof buf);
if (n == 0) {
/* Hopefully this indicates the qemu child process has died. */
- 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);
+ child_cleanup (g);
return;
}
}
n = read (g->sock, g->msg_in + g->msg_in_size,
g->msg_in_allocated - g->msg_in_size);
- if (n == 0)
- /* Disconnected? Ignore it because stdout_watch will get called
- * and will do the cleanup.
- */
+ if (n == 0) {
+ /* Disconnected. */
+ child_cleanup (g);
return;
+ }
if (n == -1) {
if (errno != EINTR && errno != EAGAIN)