X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=05fb113b864648a7530d37d46652cb879b6d2d64;hp=d3594d3b3e8dc454936e42f02f7880ee868f8aeb;hb=ae5be84decf1a40e1de22176c747e110b77829a2;hpb=9c5ea364505f9f2553a20e93b78a61e3953eacf8 diff --git a/src/guestfs.c b/src/guestfs.c index d3594d3..05fb113 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -19,7 +19,7 @@ #include #define _BSD_SOURCE /* for mkdtemp, usleep */ -#define _GNU_SOURCE /* for vasprintf, GNU strerror_r */ +#define _GNU_SOURCE /* for vasprintf, GNU strerror_r, strchrnul */ #include #include @@ -29,7 +29,9 @@ #include #include #include +#include #include + #include #include @@ -56,51 +58,93 @@ #include "guestfs.h" #include "guestfs_protocol.h" -static void error (guestfs_h *g, const char *fs, ...); -static void perrorf (guestfs_h *g, const char *fs, ...); -static void *safe_malloc (guestfs_h *g, int nbytes); -static void *safe_realloc (guestfs_h *g, void *ptr, int nbytes); -static char *safe_strdup (guestfs_h *g, const char *str); +#define error guestfs_error +#define perrorf guestfs_perrorf +#define safe_malloc guestfs_safe_malloc +#define safe_realloc guestfs_safe_realloc +#define safe_strdup guestfs_safe_strdup +#define safe_memdup guestfs_safe_memdup static void default_error_cb (guestfs_h *g, void *data, const char *msg); -static void stdout_event (void *data, int watch, int fd, int events); -static void sock_read_event (void *data, int watch, int fd, int events); -static void sock_write_event (void *data, int watch, int fd, int events); +static void stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); +static void sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); +static void sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); -static int select_add_handle (guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data); -static int select_remove_handle (guestfs_h *g, int watch); -static int select_add_timeout (guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data); -static int select_remove_timeout (guestfs_h *g, int timer); -static void select_main_loop_run (guestfs_h *g); -static void select_main_loop_quit (guestfs_h *g); +static void close_handles (void); -#define UNIX_PATH_MAX 108 +static int select_add_handle (guestfs_main_loop *ml, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data); +static int select_remove_handle (guestfs_main_loop *ml, guestfs_h *g, int watch); +static int select_add_timeout (guestfs_main_loop *ml, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data); +static int select_remove_timeout (guestfs_main_loop *ml, guestfs_h *g, int timer); +static int select_main_loop_run (guestfs_main_loop *ml, guestfs_h *g); +static int select_main_loop_quit (guestfs_main_loop *ml, guestfs_h *g); -/* Also in guestfsd.c */ -#define VMCHANNEL_PORT 6666 -#define VMCHANNEL_ADDR "10.0.2.4" +/* Default select-based main loop. */ +struct select_handle_cb_data { + guestfs_handle_event_cb cb; + guestfs_h *g; + void *data; +}; + +struct select_main_loop { + /* NB. These fields must be the same as in struct guestfs_main_loop: */ + guestfs_add_handle_cb add_handle; + guestfs_remove_handle_cb remove_handle; + guestfs_add_timeout_cb add_timeout; + guestfs_remove_timeout_cb remove_timeout; + guestfs_main_loop_run_cb main_loop_run; + guestfs_main_loop_quit_cb main_loop_quit; + + /* Additional private data: */ + int is_running; + + fd_set rset; + fd_set wset; + fd_set xset; + + int max_fd; + int nr_fds; + struct select_handle_cb_data *handle_cb_data; +}; -/* Current main loop. */ -static guestfs_main_loop main_loop = { +/* Default main loop. */ +static struct select_main_loop default_main_loop = { .add_handle = select_add_handle, .remove_handle = select_remove_handle, .add_timeout = select_add_timeout, .remove_timeout = select_remove_timeout, .main_loop_run = select_main_loop_run, .main_loop_quit = select_main_loop_quit, + + /* XXX hopefully .rset, .wset, .xset are initialized to the empty + * set by the normal action of everything being initialized to zero. + */ + .is_running = 0, + .max_fd = -1, + .nr_fds = 0, + .handle_cb_data = NULL, }; +#define UNIX_PATH_MAX 108 + +/* Also in guestfsd.c */ +#define VMCHANNEL_PORT 6666 +#define VMCHANNEL_ADDR "10.0.2.4" + /* GuestFS handle and connection. */ enum state { CONFIG, LAUNCHING, READY, BUSY, NO_HANDLE }; struct guestfs_h { + struct guestfs_h *next; /* Linked list of open handles. */ + /* State: see the state machine diagram in the man page guestfs(3). */ enum state state; 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. */ @@ -112,11 +156,19 @@ struct guestfs_h int cmdline_size; int verbose; + int autosync; + + const char *path; + const char *qemu; + + char *last_error; /* Callbacks. */ guestfs_abort_cb abort_cb; guestfs_error_handler_cb error_cb; void * error_cb_data; + guestfs_send_cb send_cb; + void * send_cb_data; guestfs_reply_cb reply_cb; void * reply_cb_data; guestfs_log_message_cb log_message_cb; @@ -126,14 +178,8 @@ struct guestfs_h guestfs_launch_done_cb launch_done_cb; void * launch_done_cb_data; - /* These callbacks are called before reply_cb and launch_done_cb, - * and are used to implement the high-level API without needing to - * interfere with callbacks that the user might have set. - */ - guestfs_reply_cb reply_cb_internal; - void * reply_cb_internal_data; - guestfs_launch_done_cb launch_done_cb_internal; - void * launch_done_cb_internal_data; + /* Main loop used by this handle. */ + guestfs_main_loop *main_loop; /* Messages sent and received from the daemon. */ char *msg_in; @@ -144,6 +190,9 @@ struct guestfs_h int msg_next_serial; }; +static guestfs_h *handles = NULL; +static int atexit_handler_set = 0; + guestfs_h * guestfs_create (void) { @@ -170,11 +219,34 @@ guestfs_create (void) str = getenv ("LIBGUESTFS_DEBUG"); g->verbose = str != NULL && strcmp (str, "1") == 0; + str = getenv ("LIBGUESTFS_PATH"); + g->path = str != NULL ? str : GUESTFS_DEFAULT_PATH; + + str = getenv ("LIBGUESTFS_QEMU"); + g->qemu = str != NULL ? str : QEMU; + + g->main_loop = guestfs_get_default_main_loop (); + /* Start with large serial numbers so they are easy to spot * inside the protocol. */ g->msg_next_serial = 0x00123400; + /* Link the handles onto a global list. This is the one area + * where the library needs to be made thread-safe. (XXX) + */ + /* acquire mutex (XXX) */ + g->next = handles; + handles = g; + if (!atexit_handler_set) { + atexit (close_handles); + atexit_handler_set = 1; + } + /* release mutex (XXX) */ + + if (g->verbose) + fprintf (stderr, "new guestfs handle %p\n", g); + return g; } @@ -183,6 +255,7 @@ guestfs_close (guestfs_h *g) { int i; char filename[256]; + guestfs_h *gg; if (g->state == NO_HANDLE) { /* Not safe to call 'error' here, so ... */ @@ -190,6 +263,13 @@ guestfs_close (guestfs_h *g) return; } + if (g->verbose) + fprintf (stderr, "closing guestfs handle %p (state %d)\n", g, g->state); + + /* Try to sync if autosync flag is set. */ + if (g->autosync && g->state == READY) + guestfs_sync (g); + /* Remove any handlers that might be called back before we kill the * subprocess. */ @@ -216,41 +296,69 @@ guestfs_close (guestfs_h *g) /* Mark the handle as dead before freeing it. */ g->state = NO_HANDLE; + /* acquire mutex (XXX) */ + if (handles == g) + handles = g->next; + else { + for (gg = handles; gg->next != g; gg = gg->next) + ; + gg->next = g->next; + } + /* release mutex (XXX) */ + + free (g->last_error); free (g); } +/* Close all open handles (called from atexit(3)). */ +static void +close_handles (void) +{ + while (handles) guestfs_close (handles); +} + +const char * +guestfs_last_error (guestfs_h *g) +{ + return g->last_error; +} + +static void +set_last_error (guestfs_h *g, const char *msg) +{ + free (g->last_error); + g->last_error = strdup (msg); +} + static void default_error_cb (guestfs_h *g, void *data, const char *msg) { fprintf (stderr, "libguestfs: error: %s\n", msg); } -static void -error (guestfs_h *g, const char *fs, ...) +void +guestfs_error (guestfs_h *g, const char *fs, ...) { va_list args; char *msg; - if (!g->error_cb) return; - va_start (args, fs); vasprintf (&msg, fs, args); va_end (args); - g->error_cb (g, g->error_cb_data, msg); + if (g->error_cb) g->error_cb (g, g->error_cb_data, msg); + set_last_error (g, msg); free (msg); } -static void -perrorf (guestfs_h *g, const char *fs, ...) +void +guestfs_perrorf (guestfs_h *g, const char *fs, ...) { va_list args; char *msg; int err = errno; - if (!g->error_cb) return; - va_start (args, fs); vasprintf (&msg, fs, args); va_end (args); @@ -268,35 +376,79 @@ perrorf (guestfs_h *g, const char *fs, ...) strcat (msg, ": "); strcat (msg, buf); - g->error_cb (g, g->error_cb_data, msg); + if (g->error_cb) g->error_cb (g, g->error_cb_data, msg); + set_last_error (g, msg); free (msg); } -static void * -safe_malloc (guestfs_h *g, int nbytes) +void * +guestfs_safe_malloc (guestfs_h *g, size_t nbytes) { void *ptr = malloc (nbytes); if (!ptr) g->abort_cb (); return ptr; } -static void * -safe_realloc (guestfs_h *g, void *ptr, int nbytes) +void * +guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes) { void *p = realloc (ptr, nbytes); if (!p) g->abort_cb (); return p; } -static char * -safe_strdup (guestfs_h *g, const char *str) +char * +guestfs_safe_strdup (guestfs_h *g, const char *str) { char *s = strdup (str); if (!s) g->abort_cb (); return s; } +void * +guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size) +{ + void *p = malloc (size); + if (!p) g->abort_cb (); + memcpy (p, ptr, size); + return p; +} + +static int +xwrite (int fd, const void *buf, size_t len) +{ + int r; + + while (len > 0) { + r = write (fd, buf, len); + 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; + } + + return 0; +} + void guestfs_set_out_of_memory_handler (guestfs_h *g, guestfs_abort_cb cb) { @@ -323,10 +475,11 @@ guestfs_get_error_handler (guestfs_h *g, void **data_rtn) return g->error_cb; } -void +int guestfs_set_verbose (guestfs_h *g, int v) { - g->verbose = v; + g->verbose = !!v; + return 0; } int @@ -335,6 +488,51 @@ guestfs_get_verbose (guestfs_h *g) return g->verbose; } +int +guestfs_set_autosync (guestfs_h *g, int a) +{ + g->autosync = !!a; + return 0; +} + +int +guestfs_get_autosync (guestfs_h *g) +{ + return g->autosync; +} + +int +guestfs_set_path (guestfs_h *g, const char *path) +{ + if (path == NULL) + g->path = GUESTFS_DEFAULT_PATH; + else + g->path = path; + return 0; +} + +const char * +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) @@ -407,6 +605,11 @@ guestfs_add_drive (guestfs_h *g, const char *filename) return -1; } + if (access (filename, F_OK) == -1) { + perrorf (g, "%s", filename); + return -1; + } + snprintf (buf, len, "file=%s", filename); return guestfs_config (g, "-drive", buf); @@ -420,6 +623,11 @@ guestfs_add_cdrom (guestfs_h *g, const char *filename) return -1; } + if (access (filename, F_OK) == -1) { + perrorf (g, "%s", filename); + return -1; + } + return guestfs_config (g, "-cdrom", filename); } @@ -427,18 +635,16 @@ int guestfs_launch (guestfs_h *g) { static const char *dir_template = "/tmp/libguestfsXXXXXX"; - int r, i; + int r, i, len, pmore, memsize; int wfd[2], rfd[2]; int tries; - /*const char *qemu = QEMU;*/ /* XXX */ - const char *qemu = "/usr/bin/qemu-system-x86_64"; - const char *kernel = "vmlinuz.fedora-10.x86_64"; - const char *initrd = "initramfs.fedora-10.x86_64.img"; + const char *kernel_name = "vmlinuz." REPO "." host_cpu; + const char *initrd_name = "initramfs." REPO "." host_cpu ".img"; + char *path, *pelem, *pend; + char *kernel = NULL, *initrd = NULL; char unixsock[256]; struct sockaddr_un addr; - - /* XXX Choose which qemu to run. */ - /* XXX Choose initrd, etc. */ + struct stat statbuf; /* Configured? */ if (!g->cmdline) { @@ -451,12 +657,93 @@ guestfs_launch (guestfs_h *g) return -1; } + /* 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 kernel and initrd in current directory\n"); + if (access (kernel_name, F_OK) == 0 && access (initrd_name, F_OK) == 0) { + kernel = safe_strdup (g, kernel_name); + initrd = safe_strdup (g, initrd_name); + break; + } + } + /* Look at /kernel etc. */ + else { + 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); + + if (g->verbose) + fprintf (stderr, "looking for %s and %s\n", kernel, initrd); + + if (access (kernel, F_OK) == 0 && access (initrd, F_OK) == 0) + break; + free (kernel); + free (initrd); + kernel = initrd = NULL; + } + + 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; + } + + /* 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); if (mkdtemp (g->tmpdir) == NULL) { perrorf (g, "%s: cannot create temporary directory", dir_template); - return -1; + goto cleanup0; } } @@ -465,7 +752,7 @@ guestfs_launch (guestfs_h *g) if (pipe (wfd) == -1 || pipe (rfd) == -1) { perrorf (g, "pipe"); - return -1; + goto cleanup0; } r = fork (); @@ -475,17 +762,18 @@ guestfs_launch (guestfs_h *g) close (wfd[1]); close (rfd[0]); close (rfd[1]); - return -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] = (char *) qemu; + g->cmdline[0] = (char *) g->qemu; /* Construct the -net channel parameter for qemu. */ snprintf (vmchannel, sizeof vmchannel, @@ -494,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"); @@ -513,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"); @@ -531,6 +825,8 @@ guestfs_launch (guestfs_h *g) close (rfd[0]); dup (wfd[0]); dup (rfd[1]); + close (wfd[0]); + close (rfd[1]); #if 0 /* Set up a new process group, so we can signal this process @@ -539,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); @@ -616,31 +946,25 @@ guestfs_launch (guestfs_h *g) g->msg_out_pos = 0; g->stdout_watch = - main_loop.add_handle (g, g->fd[1], - GUESTFS_HANDLE_READABLE, - stdout_event, g); + 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; } - g->sock_watch = - main_loop.add_handle (g, g->sock, - GUESTFS_HANDLE_READABLE, - sock_read_event, g); - if (g->sock_watch == -1) { - error (g, "could not watch daemon communications socket"); + if (guestfs__switch_to_receiving (g) == -1) goto cleanup3; - } g->state = LAUNCHING; return 0; cleanup3: if (g->stdout_watch >= 0) - main_loop.remove_handle (g, g->stdout_watch); + g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch); if (g->sock_watch >= 0) - main_loop.remove_handle (g, g->sock_watch); + g->main_loop->remove_handle (g->main_loop, g, g->sock_watch); cleanup2: close (g->sock); @@ -649,28 +973,38 @@ 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; + + cleanup0: + free (kernel); + free (initrd); return -1; } 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; - main_loop.main_loop_quit (g); + g->main_loop->main_loop_quit (g->main_loop, g); } int guestfs_wait_ready (guestfs_h *g) { - int r = 0; + int finished = 0, r; if (g->state == READY) return 0; @@ -684,13 +1018,15 @@ guestfs_wait_ready (guestfs_h *g) return -1; } - g->launch_done_cb_internal = finish_wait_ready; - g->launch_done_cb_internal_data = &r; - main_loop.main_loop_run (g); - g->launch_done_cb_internal = NULL; - g->launch_done_cb_internal_data = NULL; + 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) { + if (r == -1) return -1; + + if (finished != 1) { error (g, "guestfs_wait_ready failed, see earlier error messages"); return -1; } @@ -717,21 +1053,106 @@ guestfs_kill_subprocess (guestfs_h *g) } if (g->verbose) - fprintf (stderr, "sending SIGTERM to process group %d\n", g->pid); + 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; +} + +/* Structure-freeing functions. These rely on the fact that the + * structure format is identical to the XDR format. See note in + * generator.ml. + */ +void +guestfs_free_int_bool (struct guestfs_int_bool *x) +{ + free (x); +} + +void +guestfs_free_lvm_pv_list (struct guestfs_lvm_pv_list *x) +{ + xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_pv_list, (char *) x); + free (x); +} + +void +guestfs_free_lvm_vg_list (struct guestfs_lvm_vg_list *x) +{ + xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_vg_list, (char *) x); + free (x); +} + +void +guestfs_free_lvm_lv_list (struct guestfs_lvm_lv_list *x) +{ + xdr_free ((xdrproc_t) xdr_guestfs_lvm_int_lv_list, (char *) x); + free (x); +} + /* 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. */ static void -stdout_event (void *data, int watch, int fd, int events) +stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, + int watch, int fd, int events) { - guestfs_h *g = (guestfs_h *) data; char buf[4096]; int n; @@ -753,11 +1174,13 @@ stdout_event (void *data, int watch, int fd, int events) 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) - main_loop.remove_handle (g, g->stdout_watch); + g->main_loop->remove_handle (g->main_loop, g, g->stdout_watch); if (g->sock_watch >= 0) - main_loop.remove_handle (g, g->sock_watch); + g->main_loop->remove_handle (g->main_loop, g, g->sock_watch); close (g->fd[0]); close (g->fd[1]); close (g->sock); @@ -765,6 +1188,7 @@ stdout_event (void *data, int watch, int fd, int events) 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; @@ -793,9 +1217,9 @@ stdout_event (void *data, int watch, int fd, int events) * guestfsd (daemon inside the guest) communication socket. */ static void -sock_read_event (void *data, int watch, int fd, int events) +sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, + int watch, int fd, int events) { - guestfs_h *g = (guestfs_h *) data; XDR xdr; unsigned len; int n; @@ -831,6 +1255,7 @@ sock_read_event (void *data, int watch, int fd, int events) 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); @@ -843,7 +1268,7 @@ sock_read_event (void *data, int watch, int fd, int events) * 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); @@ -852,8 +1277,6 @@ sock_read_event (void *data, int watch, int fd, int events) g->msg_in_size); else { g->state = READY; - if (g->launch_done_cb_internal) - g->launch_done_cb_internal (g, g->launch_done_cb_internal_data); if (g->launch_done_cb) g->launch_done_cb (g, g->launch_done_cb_data); } @@ -861,7 +1284,19 @@ sock_read_event (void *data, int watch, int fd, int events) 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); @@ -870,27 +1305,39 @@ sock_read_event (void *data, int watch, int fd, int events) 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; + + for (i = 0; i < g->msg_in_size; i += 16) { + printf ("%04x: ", i); + for (j = i; j < MIN (i+16, g->msg_in_size); ++j) + printf ("%02x ", (unsigned char) g->msg_in[j]); + for (; j < i+16; ++j) + printf (" "); + printf ("|"); + for (j = i; j < MIN (i+16, g->msg_in_size); ++j) + if (isprint (g->msg_in[j])) + printf ("%c", g->msg_in[j]); + else + printf ("."); + for (; j < i+16; ++j) + printf (" "); + printf ("|\n"); + } } /* Not in the expected state. */ if (g->state != BUSY) error (g, "state %d != BUSY", g->state); - /* Push the message up to the higher layer. Note that unlike - * launch_done_cb / launch_done_cb_internal, we only call at - * most one of the callback functions here. - */ - g->state = READY; - if (g->reply_cb_internal) - g->reply_cb_internal (g, g->reply_cb_internal_data, &xdr); - else if (g->reply_cb) - g->reply_cb (g, g->reply_cb, &xdr); + /* Push the message up to the higher layer. */ + 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. */ @@ -908,9 +1355,9 @@ sock_read_event (void *data, int watch, int fd, int events) * guestfsd (daemon inside the guest) communication socket. */ static void -sock_write_event (void *data, int watch, int fd, int events) +sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, + int watch, int fd, int events) { - guestfs_h *g = (guestfs_h *) data; int n; if (g->verbose) @@ -950,43 +1397,172 @@ sock_write_event (void *data, int watch, int fd, int events) 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; g->msg_out_pos = g->msg_out_size = 0; - if (main_loop.remove_handle (g, g->sock_watch) == -1) { - error (g, "remove_handle failed in sock_write_event"); - return; + /* Done writing, call the higher layer. */ + if (g->send_cb) + g->send_cb (g, g->send_cb_data); +} + +void +guestfs_set_send_callback (guestfs_h *g, + guestfs_send_cb cb, void *opaque) +{ + g->send_cb = cb; + g->send_cb_data = opaque; +} + +void +guestfs_set_reply_callback (guestfs_h *g, + guestfs_reply_cb cb, void *opaque) +{ + g->reply_cb = cb; + g->reply_cb_data = opaque; +} + +void +guestfs_set_log_message_callback (guestfs_h *g, + guestfs_log_message_cb cb, void *opaque) +{ + g->log_message_cb = cb; + g->log_message_cb_data = opaque; +} + +void +guestfs_set_subprocess_quit_callback (guestfs_h *g, + guestfs_subprocess_quit_cb cb, void *opaque) +{ + g->subprocess_quit_cb = cb; + g->subprocess_quit_cb_data = opaque; +} + +void +guestfs_set_launch_done_callback (guestfs_h *g, + guestfs_launch_done_cb cb, void *opaque) +{ + g->launch_done_cb = cb; + g->launch_done_cb_data = opaque; +} + +/* Access to the handle's main loop and the default main loop. */ +void +guestfs_set_main_loop (guestfs_h *g, guestfs_main_loop *main_loop) +{ + g->main_loop = main_loop; +} + +guestfs_main_loop * +guestfs_get_main_loop (guestfs_h *g) +{ + return g->main_loop; +} + +guestfs_main_loop * +guestfs_get_default_main_loop (void) +{ + return (guestfs_main_loop *) &default_main_loop; +} + +/* Change the daemon socket handler so that we are now writing. + * This sets the handle to sock_write_event. + */ +int +guestfs__switch_to_sending (guestfs_h *g) +{ + if (g->sock_watch >= 0) { + if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { + error (g, "remove_handle failed"); + g->sock_watch = -1; + return -1; + } } + g->sock_watch = - main_loop.add_handle (g, g->sock, - GUESTFS_HANDLE_READABLE, - sock_read_event, g); + g->main_loop->add_handle (g->main_loop, g, g->sock, + GUESTFS_HANDLE_WRITABLE, + sock_write_event, NULL); if (g->sock_watch == -1) { - error (g, "add_handle failed in sock_write_event"); - return; + error (g, "add_handle failed"); + return -1; + } + + return 0; +} + +int +guestfs__switch_to_receiving (guestfs_h *g) +{ + if (g->sock_watch >= 0) { + if (g->main_loop->remove_handle (g->main_loop, g, g->sock_watch) == -1) { + error (g, "remove_handle failed"); + g->sock_watch = -1; + return -1; + } } + + g->sock_watch = + g->main_loop->add_handle (g->main_loop, g, g->sock, + GUESTFS_HANDLE_READABLE, + sock_read_event, NULL); + if (g->sock_watch == -1) { + error (g, "add_handle failed"); + return -1; + } + + return 0; } -/* Dispatch a call to the remote daemon. This function just queues - * the call in msg_out, to be sent when we next enter the main loop. - * Returns -1 for error, or the message serial number. +/* Dispatch a call (len + header + args) to the remote daemon, + * synchronously (ie. using the guest's main loop to wait until + * it has been sent). Returns -1 for error, or the serial + * number of the message. */ -static int -dispatch (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) +static void +send_cb (guestfs_h *g, void *data) +{ + guestfs_main_loop *ml = guestfs_get_main_loop (g); + + *((int *)data) = 1; + ml->main_loop_quit (ml, g); +} + +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; int serial = g->msg_next_serial++; + 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; @@ -995,10 +1571,9 @@ dispatch (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) 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 @@ -1007,89 +1582,390 @@ dispatch (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) 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"); + xdr_uint32_t (&xdr, &len); + + if (guestfs__switch_to_sending (g) == -1) + goto cleanup1; + + sent = 0; + guestfs_set_send_callback (g, send_cb, &sent); + if (ml->main_loop_run (ml, g) == -1) goto cleanup1; + if (sent != 1) { + error (g, "send failed, see earlier error messages"); + goto cleanup1; + } + + return serial; + + cleanup1: + free (g->msg_out); + g->msg_out = NULL; + g->msg_out_size = 0; + return -1; +} + +static int cancel = 0; /* XXX Implement file cancellation. */ +static int send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len); +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. + * 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, err; + + fd = open (filename, O_RDONLY); + if (fd == -1) { + perrorf (g, "open: %s", filename); + send_file_cancellation_sync (g); + /* Daemon sees cancellation and won't reply, so caller can + * just return here. + */ + return -1; } - memcpy (g->msg_out + 4, buffer, len); + /* Send file in chunked encoding. */ + while (!cancel && (r = read (fd, buf, sizeof buf)) > 0) { + 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) { /* cancel from either end */ + send_file_cancellation_sync (g); + return -1; + } + + if (r == -1) { + perrorf (g, "read: %s", filename); + send_file_cancellation_sync (g); + return -1; + } + + /* End of file, but before we send that, we need to close + * the file and check for errors. + */ + if (close (fd) == -1) { + perrorf (g, "close: %s", filename); + send_file_cancellation_sync (g); + return -1; + } + + return send_file_complete_sync (g); +} + +/* Send a chunk of file data. */ +static int +send_file_data_sync (guestfs_h *g, const char *buf, size_t len) +{ + return send_file_chunk_sync (g, 0, buf, len); +} + +/* Send a cancellation message. */ +static int +send_file_cancellation_sync (guestfs_h *g) +{ + return send_file_chunk_sync (g, 1, NULL, 0); +} + +/* Send a file complete chunk. */ +static int +send_file_complete_sync (guestfs_h *g) +{ + char buf[1]; + return send_file_chunk_sync (g, 0, buf, 0); +} + +/* 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 buflen) +{ + unsigned len; + int sent; + guestfs_chunk chunk; + XDR xdr; + guestfs_main_loop *ml = guestfs_get_main_loop (g); - /* Change the handle to sock_write_event. */ - if (main_loop.remove_handle (g, g->sock_watch) == -1) { - error (g, "remove_handle failed in dispatch"); + if (g->state != BUSY) { + 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 = buflen; + chunk.data.data_val = (char *) buf; + + if (!xdr_guestfs_chunk (&xdr, &chunk)) { + error (g, "xdr_guestfs_chunk failed (buf = %p, buflen = %zu)", + buf, buflen); + xdr_destroy (&xdr); goto cleanup1; } - g->sock_watch = - main_loop.add_handle (g, g->sock, - GUESTFS_HANDLE_WRITABLE, - sock_write_event, g); - if (g->sock_watch == -1) { - error (g, "add_handle failed in dispatch"); + + len = xdr_getpos (&xdr); + xdr_destroy (&xdr); + + /* 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; + + sent = 0; + guestfs_set_send_callback (g, send_cb, &sent); + if (ml->main_loop_run (ml, g) == -1) + goto cleanup1; + if (sent != 1) { + error (g, "send file chunk failed, see earlier error messages"); goto cleanup1; } - return serial; + return 0; cleanup1: free (g->msg_out); g->msg_out = NULL; g->msg_out_size = 0; - g->state = READY; return -1; } -/* The high-level actions are autogenerated by generator.ml. Include - * them here. +/* 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. */ -#include "guestfs-actions.c" +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; -/* This is the default main loop implementation, using select(2). */ + 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; -struct handle_cb_data { - guestfs_handle_event_cb cb; - void *data; -}; + /* 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 +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, 0666); + if (fd == -1) { + perrorf (g, "open: %s", filename); + 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); + goto cancel; + } + free (buf); + } + + if (r == -1) { + error (g, "%s: error in chunked encoding", filename); + return -1; + } + + if (close (fd) == -1) { + perrorf (g, "close: %s", filename); + return -1; + } + + 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 */ -static fd_set rset; -static fd_set wset; -static fd_set xset; -static int select_init_done = 0; -static int max_fd = -1; -static int nr_fds = 0; -static struct handle_cb_data *handle_cb_data = NULL; + return -1; +} + +struct receive_file_ctx { + int code; + void **buf; +}; static void -select_init (void) +receive_file_cb (guestfs_h *g, void *data, XDR *xdr) { - if (!select_init_done) { - FD_ZERO (&rset); - FD_ZERO (&wset); - FD_ZERO (&xset); + guestfs_main_loop *ml = guestfs_get_main_loop (g); + struct receive_file_ctx *ctx = (struct receive_file_ctx *) data; + guestfs_chunk chunk; - select_init_done = 1; + 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; + return; } + if (chunk.cancel) { + error (g, "file receive cancelled by daemon"); + ctx->code = -2; + return; + } + if (chunk.data.data_len == 0) { /* end of transfer */ + ctx->code = 0; + return; + } + + ctx->code = chunk.data.data_len; + *ctx->buf = chunk.data.data_val; /* caller frees */ } +/* Receive a chunk of file data. */ static int -select_add_handle (guestfs_h *g, int fd, int events, +receive_file_data_sync (guestfs_h *g, void **buf) +{ + struct receive_file_ctx ctx; + guestfs_main_loop *ml = guestfs_get_main_loop (g); + + ctx.code = -3; + ctx.buf = 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; + case -1: case -2: + return -1; + case -3: + error (g, "failed to call receive_file_cb"); + return -1; + default: /* received n bytes of data */ + return ctx.code; + } +} + +/* This is the default main loop implementation, using select(2). */ + +static int +select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events, guestfs_handle_event_cb cb, void *data) { - select_init (); + struct select_main_loop *ml = (struct select_main_loop *) mlv; if (fd < 0 || fd >= FD_SETSIZE) { error (g, "fd %d is out of range", fd); @@ -1109,7 +1985,9 @@ select_add_handle (guestfs_h *g, int fd, int events, return -1; } - if (FD_ISSET (fd, &rset) || FD_ISSET (fd, &wset) || FD_ISSET (fd, &xset)) { + if (FD_ISSET (fd, &ml->rset) || + FD_ISSET (fd, &ml->wset) || + FD_ISSET (fd, &ml->xset)) { error (g, "fd %d is already registered", fd); return -1; } @@ -1120,102 +1998,111 @@ select_add_handle (guestfs_h *g, int fd, int events, } if ((events & GUESTFS_HANDLE_READABLE)) - FD_SET (fd, &rset); + FD_SET (fd, &ml->rset); if ((events & GUESTFS_HANDLE_WRITABLE)) - FD_SET (fd, &wset); + FD_SET (fd, &ml->wset); if ((events & GUESTFS_HANDLE_HANGUP) || (events & GUESTFS_HANDLE_ERROR)) - FD_SET (fd, &xset); + FD_SET (fd, &ml->xset); - if (fd > max_fd) { - max_fd = fd; - handle_cb_data = safe_realloc (g, handle_cb_data, - sizeof (struct handle_cb_data) * (max_fd+1)); + if (fd > ml->max_fd) { + ml->max_fd = fd; + ml->handle_cb_data = + safe_realloc (g, ml->handle_cb_data, + sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); } - handle_cb_data[fd].cb = cb; - handle_cb_data[fd].data = data; + ml->handle_cb_data[fd].cb = cb; + ml->handle_cb_data[fd].g = g; + ml->handle_cb_data[fd].data = data; - nr_fds++; + ml->nr_fds++; /* Any integer >= 0 can be the handle, and this is as good as any ... */ return fd; } static int -select_remove_handle (guestfs_h *g, int fd) +select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd) { - select_init (); + struct select_main_loop *ml = (struct select_main_loop *) mlv; if (fd < 0 || fd >= FD_SETSIZE) { error (g, "fd %d is out of range", fd); return -1; } - if (!FD_ISSET (fd, &rset) && !FD_ISSET (fd, &wset) && !FD_ISSET (fd, &xset)) { + if (!FD_ISSET (fd, &ml->rset) && + !FD_ISSET (fd, &ml->wset) && + !FD_ISSET (fd, &ml->xset)) { error (g, "fd %d was not registered", fd); return -1; } - FD_CLR (fd, &rset); - FD_CLR (fd, &wset); - FD_CLR (fd, &xset); + FD_CLR (fd, &ml->rset); + FD_CLR (fd, &ml->wset); + FD_CLR (fd, &ml->xset); - if (fd == max_fd) { - max_fd--; - handle_cb_data = safe_realloc (g, handle_cb_data, - sizeof (struct handle_cb_data) * (max_fd+1)); + if (fd == ml->max_fd) { + ml->max_fd--; + ml->handle_cb_data = + safe_realloc (g, ml->handle_cb_data, + sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); } - nr_fds--; + ml->nr_fds--; return 0; } static int -select_add_timeout (guestfs_h *g, int interval, +select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval, guestfs_handle_timeout_cb cb, void *data) { - select_init (); + //struct select_main_loop *ml = (struct select_main_loop *) mlv; abort (); /* XXX not implemented yet */ } static int -select_remove_timeout (guestfs_h *g, int timer) +select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer) { - select_init (); + //struct select_main_loop *ml = (struct select_main_loop *) mlv; abort (); /* XXX not implemented yet */ } -/* Note that main loops can be nested. */ -static int level = 0; - -static void -select_main_loop_run (guestfs_h *g) +/* The 'g' parameter is just used for error reporting. Events + * for multiple handles can be dispatched by running the main + * loop. + */ +static int +select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g) { - int old_level, fd, r, events; + struct select_main_loop *ml = (struct select_main_loop *) mlv; + int fd, r, events; fd_set rset2, wset2, xset2; - select_init (); + if (ml->is_running) { + error (g, "select_main_loop_run: this cannot be called recursively"); + return -1; + } - old_level = level++; - while (level > old_level) { - if (nr_fds == 0) { - level = old_level; + ml->is_running = 1; + + while (ml->is_running) { + if (ml->nr_fds == 0) break; - } - rset2 = rset; - wset2 = wset; - xset2 = xset; - r = select (max_fd+1, &rset2, &wset2, &xset2, NULL); + rset2 = ml->rset; + wset2 = ml->wset; + xset2 = ml->xset; + r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL); if (r == -1) { perrorf (g, "select"); - level = old_level; - break; + ml->is_running = 0; + return -1; } - for (fd = 0; r > 0 && fd <= max_fd; ++fd) { + for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) { events = 0; if (FD_ISSET (fd, &rset2)) events |= GUESTFS_HANDLE_READABLE; @@ -1225,22 +2112,27 @@ select_main_loop_run (guestfs_h *g) events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP; if (events) { r--; - handle_cb_data[fd].cb (handle_cb_data[fd].data, - fd, fd, events); + ml->handle_cb_data[fd].cb ((guestfs_main_loop *) ml, + ml->handle_cb_data[fd].g, + ml->handle_cb_data[fd].data, + fd, fd, events); } } } + + ml->is_running = 0; + return 0; } -static void -select_main_loop_quit (guestfs_h *g) +static int +select_main_loop_quit (guestfs_main_loop *mlv, guestfs_h *g) { - select_init (); + struct select_main_loop *ml = (struct select_main_loop *) mlv; - if (level == 0) { - error (g, "cannot quit, we are not in a main loop"); - return; - } + /* Note that legitimately ml->is_running can be zero when + * this function is called. + */ - level--; + ml->is_running = 0; + return 0; }