X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=05fb113b864648a7530d37d46652cb879b6d2d64;hp=cad2cadb73b187c294796aea665f1e025cd8d0a2;hb=ae5be84decf1a40e1de22176c747e110b77829a2;hpb=749708a7ec8930c34605ec58c18fefe0ed8e7981 diff --git a/src/guestfs.c b/src/guestfs.c index cad2cad..05fb113 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -29,7 +29,9 @@ #include #include #include +#include #include + #include #include @@ -56,13 +58,6 @@ #include "guestfs.h" #include "guestfs_protocol.h" -void guestfs_error (guestfs_h *g, const char *fs, ...); -void guestfs_perrorf (guestfs_h *g, const char *fs, ...); -void *guestfs_safe_malloc (guestfs_h *g, size_t nbytes); -void *guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes); -char *guestfs_safe_strdup (guestfs_h *g, const char *str); -void *guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size); - #define error guestfs_error #define perrorf guestfs_perrorf #define safe_malloc guestfs_safe_malloc @@ -148,7 +143,8 @@ struct guestfs_h int fd[2]; /* Stdin/stdout of qemu. */ int sock; /* Daemon communications socket. */ - int pid; /* Qemu PID. */ + pid_t pid; /* Qemu PID. */ + pid_t recoverypid; /* Recovery process PID. */ time_t start_t; /* The time when we started qemu. */ int stdout_watch; /* Watches qemu stdout for log messages. */ @@ -163,6 +159,7 @@ struct guestfs_h int autosync; const char *path; + const char *qemu; char *last_error; @@ -224,7 +221,9 @@ guestfs_create (void) str = getenv ("LIBGUESTFS_PATH"); g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH; - /* XXX We should probably make QEMU configurable as well. */ + + str = getenv ("LIBGUESTFS_QEMU"); + g->qemu = str != NULL ? str : QEMU; g->main_loop = guestfs_get_default_main_loop (); @@ -423,10 +422,26 @@ xwrite (int fd, const void *buf, size_t len) while (len > 0) { r = write (fd, buf, len); - if (r == -1) { - perror ("write"); + if (r == -1) return -1; - } + + buf += r; + len -= r; + } + + return 0; +} + +static int +xread (int fd, void *buf, size_t len) +{ + int r; + + while (len > 0) { + r = read (fd, buf, len); + if (r == -1) + return -1; + buf += r; len -= r; } @@ -502,6 +517,22 @@ guestfs_get_path (guestfs_h *g) return g->path; } +int +guestfs_set_qemu (guestfs_h *g, const char *qemu) +{ + if (qemu == NULL) + g->qemu = QEMU; + else + g->qemu = qemu; + return 0; +} + +const char * +guestfs_get_qemu (guestfs_h *g) +{ + return g->qemu; +} + /* Add a string to the current command line. */ static void incr_cmdline_size (guestfs_h *g) @@ -604,7 +635,7 @@ int guestfs_launch (guestfs_h *g) { static const char *dir_template = "/tmp/libguestfsXXXXXX"; - int r, i, len, pmore; + int r, i, len, pmore, memsize; int wfd[2], rfd[2]; int tries; const char *kernel_name = "vmlinuz." REPO "." host_cpu; @@ -613,6 +644,7 @@ guestfs_launch (guestfs_h *g) char *kernel = NULL, *initrd = NULL; char unixsock[256]; struct sockaddr_un addr; + struct stat statbuf; /* Configured? */ if (!g->cmdline) { @@ -672,6 +704,40 @@ guestfs_launch (guestfs_h *g) 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? + */ + 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; + + /* Make the temporary directory containing the socket. */ if (!g->tmpdir) { g->tmpdir = safe_strdup (g, dir_template); @@ -702,11 +768,12 @@ guestfs_launch (guestfs_h *g) 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] = (char *) QEMU; + g->cmdline[0] = (char *) g->qemu; /* Construct the -net channel parameter for qemu. */ snprintf (vmchannel, sizeof vmchannel, @@ -715,11 +782,17 @@ guestfs_launch (guestfs_h *g) /* Linux kernel command line. */ snprintf (append, sizeof append, - "console=ttyS0 guestfs=%s:%d", VMCHANNEL_ADDR, VMCHANNEL_PORT); + "console=ttyS0 guestfs=%s:%d%s", + VMCHANNEL_ADDR, VMCHANNEL_PORT, + g->verbose ? " guestfs_verbose=1" : ""); + + snprintf (memsize_str, sizeof memsize_str, "%d", memsize); add_cmdline (g, "-m"); - add_cmdline (g, "384"); /* XXX Choose best size. */ + add_cmdline (g, memsize_str); +#if 0 add_cmdline (g, "-no-kqemu"); /* Avoids a warning. */ +#endif add_cmdline (g, "-kernel"); add_cmdline (g, (char *) kernel); add_cmdline (g, "-initrd"); @@ -734,12 +807,12 @@ guestfs_launch (guestfs_h *g) add_cmdline (g, "-net"); add_cmdline (g, "user,vlan=0"); add_cmdline (g, "-net"); - add_cmdline (g, "nic,vlan=0"); + add_cmdline (g, "nic,model=rtl8139,vlan=0"); incr_cmdline_size (g); g->cmdline[g->cmdline_size-1] = NULL; if (g->verbose) { - fprintf (stderr, "%s", QEMU); + fprintf (stderr, "%s", g->qemu); for (i = 0; g->cmdline[i]; ++i) fprintf (stderr, " %s", g->cmdline[i]); fprintf (stderr, "\n"); @@ -762,14 +835,48 @@ guestfs_launch (guestfs_h *g) setpgid (0, 0); #endif - execv (QEMU, g->cmdline); /* Run qemu. */ - perror (QEMU); + execv (g->qemu, g->cmdline); /* Run qemu. */ + perror (g->qemu); _exit (1); } /* Parent (library). */ g->pid = r; + /* 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); @@ -866,11 +973,14 @@ guestfs_launch (guestfs_h *g) 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; @@ -946,6 +1056,7 @@ guestfs_kill_subprocess (guestfs_h *g) fprintf (stderr, "sending SIGTERM to process %d\n", g->pid); kill (g->pid, SIGTERM); + if (g->recoverypid > 0) kill (g->recoverypid, 9); return 0; } @@ -981,6 +1092,28 @@ 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; +} + /* Structure-freeing functions. These rely on the fact that the * structure format is identical to the XDR format. See note in * generator.ml. @@ -1041,7 +1174,9 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, 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) @@ -1053,6 +1188,7 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, 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; @@ -1119,6 +1255,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, g->msg_in_size += n; /* Have we got enough of a message to be able to process it yet? */ + again: if (g->msg_in_size < 4) return; xdrmem_create (&xdr, g->msg_in, g->msg_in_size, XDR_DECODE); @@ -1131,7 +1268,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, * starts up it sends a "magic" value (longer than any possible * message). Check for this. */ - if (len == 0xf5f55ff5) { + if (len == GUESTFS_LAUNCH_FLAG) { if (g->state != LAUNCHING) error (g, "received magic signature from guestfsd, but in state %d", g->state); @@ -1147,7 +1284,19 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, goto cleanup; } - /* If this happens, it's pretty bad and we've probably lost synchronization.*/ + /* This can happen if a cancellation happens right at the end + * of us sending a FileIn parameter to the daemon. Discard. The + * daemon should send us an error message next. + */ + if (len == GUESTFS_CANCEL_FLAG) { + g->msg_in_size -= 4; + memmove (g->msg_in, g->msg_in+4, g->msg_in_size); + goto again; + } + + /* If this happens, it's pretty bad and we've probably lost + * synchronization. + */ if (len > GUESTFS_MESSAGE_MAX) { error (g, "message length (%u) > maximum possible size (%d)", len, GUESTFS_MESSAGE_MAX); @@ -1156,14 +1305,6 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, if (g->msg_in_size-4 < len) return; /* Need more of this message. */ - /* This should not happen, and if it does it probably means we've - * lost all hope of synchronization. - */ - if (g->msg_in_size-4 > len) { - error (g, "len = %d, but msg_in_size-4 = %d", len, g->msg_in_size-4); - goto cleanup; - } - /* Got the full message, begin processing it. */ if (g->verbose) { int i, j; @@ -1191,10 +1332,13 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, error (g, "state %d != BUSY", g->state); /* Push the message up to the higher layer. */ - g->state = READY; if (g->reply_cb) g->reply_cb (g, g->reply_cb_data, &xdr); + g->msg_in_size -= len + 4; + memmove (g->msg_in, g->msg_in+len+4, g->msg_in_size); + if (g->msg_in_size > 0) goto again; + cleanup: /* Free the message buffer if it's grown excessively large. */ if (g->msg_in_allocated > 65536) { @@ -1253,7 +1397,7 @@ sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, return; if (g->verbose) - fprintf (stderr, "sock_write_event: done writing, switching back to reading events\n"); + fprintf (stderr, "sock_write_event: done writing, calling send_cb\n"); free (g->msg_out); g->msg_out = NULL; @@ -1390,7 +1534,6 @@ int guestfs__send_sync (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) { - char buffer[GUESTFS_MESSAGE_MAX]; struct guestfs_message_header hdr; XDR xdr; unsigned len; @@ -1398,11 +1541,28 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, int sent; guestfs_main_loop *ml = guestfs_get_main_loop (g); - if (g->state != READY) { - error (g, "dispatch: state %d != READY", g->state); + if (g->state != BUSY) { + error (g, "guestfs__send_sync: state %d != BUSY", g->state); return -1; } + /* This is probably an internal error. Or perhaps we should just + * free the buffer anyway? + */ + if (g->msg_out != NULL) { + error (g, "guestfs__send_sync: msg_out should be NULL"); + return -1; + } + + /* We have to allocate this message buffer on the heap because + * it is quite large (although will be mostly unused). We + * can't allocate it on the stack because in some environments + * we have quite limited stack space available, notably when + * running in the JVM. + */ + g->msg_out = safe_malloc (g, GUESTFS_MESSAGE_MAX + 4); + xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MESSAGE_MAX, XDR_ENCODE); + /* Serialize the header. */ hdr.prog = GUESTFS_PROGRAM; hdr.vers = GUESTFS_PROTOCOL_VERSION; @@ -1411,10 +1571,9 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, hdr.serial = serial; hdr.status = GUESTFS_STATUS_OK; - xdrmem_create (&xdr, buffer, sizeof buffer, XDR_ENCODE); if (!xdr_guestfs_message_header (&xdr, &hdr)) { error (g, "xdr_guestfs_message_header failed"); - return -1; + goto cleanup1; } /* Serialize the args. If any, because some message types @@ -1423,27 +1582,22 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, if (xdrp) { if (!(*xdrp) (&xdr, args)) { error (g, "dispatch failed to marshal args"); - return -1; + goto cleanup1; } } + /* Get the actual length of the message, resize the buffer to match + * the actual length, and write the length word at the beginning. + */ len = xdr_getpos (&xdr); xdr_destroy (&xdr); - /* Allocate the outgoing message buffer. */ - g->msg_out = safe_malloc (g, len + 4); - + g->msg_out = safe_realloc (g, g->msg_out, len + 4); g->msg_out_size = len + 4; g->msg_out_pos = 0; - g->state = BUSY; xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); - if (!xdr_uint32_t (&xdr, &len)) { - error (g, "xdr_uint32_t failed in dispatch"); - goto cleanup1; - } - - memcpy (g->msg_out + 4, buffer, len); + xdr_uint32_t (&xdr, &len); if (guestfs__switch_to_sending (g) == -1) goto cleanup1; @@ -1463,7 +1617,6 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, free (g->msg_out); g->msg_out = NULL; g->msg_out_size = 0; - g->state = READY; return -1; } @@ -1473,12 +1626,17 @@ static int send_file_data_sync (guestfs_h *g, const char *buf, size_t len); static int send_file_cancellation_sync (guestfs_h *g); static int send_file_complete_sync (guestfs_h *g); -/* Synchronously send a file. */ +/* Synchronously send a file. + * Returns: + * 0 OK + * -1 error + * -2 daemon cancelled (we must read the error message) + */ int guestfs__send_file_sync (guestfs_h *g, const char *filename) { char buf[GUESTFS_MAX_CHUNK_SIZE]; - int fd, r; + int fd, r, err; fd = open (filename, O_RDONLY); if (fd == -1) { @@ -1492,11 +1650,15 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename) /* Send file in chunked encoding. */ while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) { - if (send_file_data_sync (g, buf, r) == -1) - return -1; + err = send_file_data_sync (g, buf, r); + if (err < 0) { + if (err == -2) /* daemon sent cancellation */ + send_file_cancellation_sync (g); + return err; + } } - if (cancel) { + if (cancel) { /* cancel from either end */ send_file_cancellation_sync (g); return -1; } @@ -1530,8 +1692,7 @@ send_file_data_sync (guestfs_h *g, const char *buf, size_t len) static int send_file_cancellation_sync (guestfs_h *g) { - char buf[1]; - return send_file_chunk_sync (g, 1, buf, 0); + return send_file_chunk_sync (g, 1, NULL, 0); } /* Send a file complete chunk. */ @@ -1545,42 +1706,66 @@ send_file_complete_sync (guestfs_h *g) /* Send a chunk, cancellation or end of file, synchronously (ie. wait * for it to go). */ +static int check_for_daemon_cancellation (guestfs_h *g); + static int -send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len) +send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen) { - void *data; - unsigned datalen; + unsigned len; int sent; guestfs_chunk chunk; XDR xdr; guestfs_main_loop *ml = guestfs_get_main_loop (g); if (g->state != BUSY) { - error (g, "send_file_chunk: state %d != READY", g->state); + error (g, "send_file_chunk_sync: state %d != READY", g->state); return -1; } + /* This is probably an internal error. Or perhaps we should just + * free the buffer anyway? + */ + if (g->msg_out != NULL) { + error (g, "guestfs__send_sync: msg_out should be NULL"); + return -1; + } + + /* Did the daemon send a cancellation message? */ + if (check_for_daemon_cancellation (g)) { + if (g->verbose) + fprintf (stderr, "got daemon cancellation\n"); + return -2; + } + + /* Allocate the chunk buffer. Don't use the stack to avoid + * excessive stack usage and unnecessary copies. + */ + g->msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48); + xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); + /* Serialize the chunk. */ chunk.cancel = cancel; - chunk.data.data_len = len; + chunk.data.data_len = buflen; chunk.data.data_val = (char *) buf; - data = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 48); - xdrmem_create (&xdr, data, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); - if (xdr_guestfs_chunk (&xdr, &chunk)) { - error (g, "xdr_guestfs_chunk failed"); - free (data); - return -1; + if (!xdr_guestfs_chunk (&xdr, &chunk)) { + error (g, "xdr_guestfs_chunk failed (buf = %p, buflen = %zu)", + buf, buflen); + xdr_destroy (&xdr); + goto cleanup1; } - datalen = xdr_getpos (&xdr); + len = xdr_getpos (&xdr); xdr_destroy (&xdr); - data = safe_realloc (g, data, datalen); - g->msg_out = data; - g->msg_out_size = datalen; + /* Reduce the size of the outgoing message buffer to the real length. */ + g->msg_out = safe_realloc (g, g->msg_out, len + 4); + g->msg_out_size = len + 4; g->msg_out_pos = 0; + xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); + xdr_uint32_t (&xdr, &len); + if (guestfs__switch_to_sending (g) == -1) goto cleanup1; @@ -1599,14 +1784,57 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len) free (g->msg_out); g->msg_out = NULL; g->msg_out_size = 0; - g->state = READY; return -1; } -/* Synchronously receive a file. - * XXX No way to cancel file receives. We would need to send an - * error to the daemon and have it see this and stop sending. +/* At this point we are sending FileIn file(s) to the guest, and not + * expecting to read anything, so if we do read anything, it must be + * a cancellation message. This checks for this case without blocking. */ +static int +check_for_daemon_cancellation (guestfs_h *g) +{ + fd_set rset; + struct timeval tv; + int r; + char buf[4]; + uint32_t flag; + XDR xdr; + + FD_ZERO (&rset); + FD_SET (g->sock, &rset); + tv.tv_sec = 0; + tv.tv_usec = 0; + r = select (g->sock+1, &rset, NULL, NULL, &tv); + if (r == -1) { + perrorf (g, "select"); + return 0; + } + if (r == 0) + return 0; + + /* Read the message from the daemon. */ + r = xread (g->sock, buf, sizeof buf); + if (r == -1) { + perrorf (g, "read"); + return 0; + } + + xdrmem_create (&xdr, buf, sizeof buf, XDR_DECODE); + xdr_uint32_t (&xdr, &flag); + xdr_destroy (&xdr); + + if (flag != GUESTFS_CANCEL_FLAG) { + error (g, "check_for_daemon_cancellation: read 0x%x from daemon, expected 0x%x\n", + flag, GUESTFS_CANCEL_FLAG); + return 0; + } + + return 1; +} + +/* Synchronously receive a file. */ + static int receive_file_data_sync (guestfs_h *g, void **buf); int @@ -1615,17 +1843,18 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) void *buf; int fd, r; - fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY); + fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, 0666); if (fd == -1) { perrorf (g, "open: %s", filename); - return -1; + goto cancel; } /* Receive the file in chunked encoding. */ while ((r = receive_file_data_sync (g, &buf)) > 0) { if (xwrite (fd, buf, r) == -1) { + perrorf (g, "%s: write", filename); free (buf); - return -1; + goto cancel; } free (buf); } @@ -1641,6 +1870,28 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) } return 0; + + cancel: ; + /* Send cancellation message to daemon, then wait until it + * cancels (just throwing away data). + */ + XDR xdr; + char fbuf[4]; + uint32_t flag = GUESTFS_CANCEL_FLAG; + + xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE); + xdr_uint32_t (&xdr, &flag); + xdr_destroy (&xdr); + + if (xwrite (g->sock, fbuf, sizeof fbuf) == -1) { + perrorf (g, "write to daemon socket"); + return -1; + } + + while ((r = receive_file_data_sync (g, &buf)) > 0) + free (buf); /* just discard it */ + + return -1; } struct receive_file_ctx { @@ -1657,6 +1908,8 @@ receive_file_cb (guestfs_h *g, void *data, XDR *xdr) ml->main_loop_quit (ml, g); + memset (&chunk, 0, sizeof chunk); + if (!xdr_guestfs_chunk (xdr, &chunk)) { error (g, "failed to parse file chunk"); ctx->code = -1; @@ -1689,6 +1942,10 @@ receive_file_data_sync (guestfs_h *g, void **buf) guestfs_set_reply_callback (g, receive_file_cb, &ctx); (void) ml->main_loop_run (ml, g); guestfs_set_reply_callback (g, NULL, NULL); + + if (g->verbose) + fprintf (stderr, "receive_file_data_sync: code %d\n", ctx.code); + switch (ctx.code) { case 0: /* end of file */ return 0; @@ -1872,10 +2129,9 @@ select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g) { struct select_main_loop *ml = (struct select_main_loop *) mlv; - if (!ml->is_running) { - error (g, "cannot quit, we are not running in a main loop"); - return -1; - } + /* Note that legitimately ml->is_running can be zero when + * this function is called. + */ ml->is_running = 0; return 0;