X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fguestfs.c;h=04bd4e88f9fa7cbb480ccfe7b9364e191f92f853;hp=0b5625378eedffc701cf1c5d6a0c846d13afa30d;hb=5da810b96072c0fd71d78713025a2e104295d0ff;hpb=6cb84b6e94f424afb9e25b392148fe679d4c7d51 diff --git a/src/guestfs.c b/src/guestfs.c index 0b56253..04bd4e8 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -1,5 +1,5 @@ /* libguestfs - * Copyright (C) 2009 Red Hat Inc. + * Copyright (C) 2009 Red Hat Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -58,14 +59,15 @@ #include "guestfs.h" #include "guestfs_protocol.h" +#include "ignore-value.h" #ifdef HAVE_GETTEXT #include "gettext.h" #define _(str) dgettext(PACKAGE, (str)) -#define N_(str) dgettext(PACKAGE, (str)) +//#define N_(str) dgettext(PACKAGE, (str)) #else #define _(str) str -#define N_(str) str +//#define N_(str) str #endif #define error guestfs_error @@ -73,7 +75,7 @@ #define safe_malloc guestfs_safe_malloc #define safe_realloc guestfs_safe_realloc #define safe_strdup guestfs_safe_strdup -#define safe_memdup guestfs_safe_memdup +//#define safe_memdup guestfs_safe_memdup static void default_error_cb (guestfs_h *g, void *data, const char *msg); static void stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, int watch, int fd, int events); @@ -162,6 +164,8 @@ struct guestfs_h char *tmpdir; /* Temporary directory containing socket. */ + char *qemu_help, *qemu_version; /* Output of qemu -help, qemu -version. */ + char **cmdline; /* Qemu command line. */ int cmdline_size; @@ -172,6 +176,10 @@ struct guestfs_h char *qemu; /* Qemu binary. */ char *append; /* Append to kernel command line. */ + int memsize; /* Size of RAM (megabytes). */ + + int selinux; /* selinux enabled? */ + char *last_error; /* Callbacks. */ @@ -194,9 +202,9 @@ struct guestfs_h /* Messages sent and received from the daemon. */ char *msg_in; - int msg_in_size, msg_in_allocated; + unsigned int msg_in_size, msg_in_allocated; char *msg_out; - int msg_out_size, msg_out_pos; + unsigned int msg_out_size, msg_out_pos; int msg_next_serial; }; @@ -244,6 +252,22 @@ guestfs_create (void) if (!g->append) goto error; } + /* 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. Thus we can safely choose a + * large, generous amount of memory, and it'll just get swapped + * on smaller systems. + */ + str = getenv ("LIBGUESTFS_MEMSIZE"); + if (str) { + if (sscanf (str, "%d", &g->memsize) != 1 || g->memsize <= 256) { + fprintf (stderr, "libguestfs: non-numeric or too small value for LIBGUESTFS_MEMSIZE\n"); + goto error; + } + } else + g->memsize = 500; + g->main_loop = guestfs_get_default_main_loop (); /* Start with large serial numbers so they are easy to spot @@ -306,6 +330,25 @@ guestfs_close (guestfs_h *g) if (g->state != CONFIG) guestfs_kill_subprocess (g); + /* Close any sockets and deregister any handlers. */ + 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); + g->stdout_watch = -1; + g->sock_watch = -1; + + if (g->fd[0] >= 0) + close (g->fd[0]); + if (g->fd[1] >= 0) + close (g->fd[1]); + if (g->sock >= 0) + close (g->sock); + g->fd[0] = -1; + g->fd[1] = -1; + g->sock = -1; + + /* Remove tmpfiles. */ if (g->tmpdir) { snprintf (filename, sizeof filename, "%s/sock", g->tmpdir); unlink (filename); @@ -346,6 +389,8 @@ guestfs_close (guestfs_h *g) free (g->path); free (g->qemu); free (g->append); + free (g->qemu_help); + free (g->qemu_version); free (g); } @@ -382,9 +427,11 @@ guestfs_error (guestfs_h *g, const char *fs, ...) char *msg; va_start (args, fs); - vasprintf (&msg, fs, args); + int err = vasprintf (&msg, fs, args); va_end (args); + if (err < 0) return; + if (g->error_cb) g->error_cb (g, g->error_cb_data, msg); set_last_error (g, msg); @@ -396,19 +443,21 @@ guestfs_perrorf (guestfs_h *g, const char *fs, ...) { va_list args; char *msg; - int err = errno; + int errnum = errno; va_start (args, fs); - vasprintf (&msg, fs, args); + int err = vasprintf (&msg, fs, args); va_end (args); + if (err < 0) return; + #ifndef _GNU_SOURCE char buf[256]; - strerror_r (err, buf, sizeof buf); + strerror_r (errnum, buf, sizeof buf); #else char _buf[256]; char *buf; - buf = strerror_r (err, _buf, sizeof _buf); + buf = strerror_r (errnum, _buf, sizeof _buf); #endif msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1); @@ -429,6 +478,42 @@ guestfs_safe_malloc (guestfs_h *g, size_t nbytes) return ptr; } +/* Return 1 if an array of N objects, each of size S, cannot exist due + to size arithmetic overflow. S must be positive and N must be + nonnegative. This is a macro, not an inline function, so that it + works correctly even when SIZE_MAX < N. + + By gnulib convention, SIZE_MAX represents overflow in size + calculations, so the conservative dividend to use here is + SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value. + However, malloc (SIZE_MAX) fails on all known hosts where + sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for + exactly-SIZE_MAX allocations on such hosts; this avoids a test and + branch when S is known to be 1. */ +# define xalloc_oversized(n, s) \ + ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) + +/* Technically we should add an autoconf test for this, testing for the desired + functionality, like what's done in gnulib, but for now, this is fine. */ +#define HAVE_GNU_CALLOC (__GLIBC__ >= 2) + +/* Allocate zeroed memory for N elements of S bytes, with error + checking. S must be nonzero. */ +void * +guestfs_safe_calloc (guestfs_h *g, size_t n, size_t s) +{ + /* From gnulib's calloc function in xmalloc.c. */ + void *p; + /* Test for overflow, since some calloc implementations don't have + proper overflow checks. But omit overflow and size-zero tests if + HAVE_GNU_CALLOC, since GNU calloc catches overflow and never + returns NULL if successful. */ + if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s)) + || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0))) + g->abort_cb (); + return p; +} + void * guestfs_safe_realloc (guestfs_h *g, void *ptr, int nbytes) { @@ -455,8 +540,9 @@ guestfs_safe_memdup (guestfs_h *g, void *ptr, size_t size) } static int -xwrite (int fd, const void *buf, size_t len) +xwrite (int fd, const void *v_buf, size_t len) { + const char *buf = v_buf; int r; while (len > 0) { @@ -472,15 +558,16 @@ xwrite (int fd, const void *buf, size_t len) } static int -xread (int fd, void *buf, size_t len) +xread (int fd, void *v_buf, size_t len) { + char *buf = v_buf; int r; while (len > 0) { r = read (fd, buf, len); if (r == -1) { if (errno == EINTR || errno == EAGAIN) - continue; + continue; return -1; } @@ -593,6 +680,56 @@ guestfs_get_append (guestfs_h *g) return g->append; } +int +guestfs_set_memsize (guestfs_h *g, int memsize) +{ + g->memsize = memsize; + return 0; +} + +int +guestfs_get_memsize (guestfs_h *g) +{ + return g->memsize; +} + +int +guestfs_set_selinux (guestfs_h *g, int selinux) +{ + g->selinux = selinux; + return 0; +} + +int +guestfs_get_selinux (guestfs_h *g) +{ + return g->selinux; +} + +int +guestfs_get_pid (guestfs_h *g) +{ + if (g->pid > 0) + return g->pid; + else { + error (g, "get_pid: no qemu subprocess"); + return -1; + } +} + +struct guestfs_version * +guestfs_version (guestfs_h *g) +{ + struct guestfs_version *r; + + r = safe_malloc (g, sizeof *r); + r->major = PACKAGE_VERSION_MAJOR; + r->minor = PACKAGE_VERSION_MINOR; + r->release = PACKAGE_VERSION_RELEASE; + r->extra = safe_strdup (g, PACKAGE_VERSION_EXTRA); + return r; +} + /* Add a string to the current command line. */ static void incr_cmdline_size (guestfs_h *g) @@ -624,7 +761,7 @@ add_cmdline (guestfs_h *g, const char *str) int guestfs_config (guestfs_h *g, - const char *qemu_param, const char *qemu_value) + const char *qemu_param, const char *qemu_value) { if (qemu_param[0] != '-') { error (g, _("guestfs_config: parameter must begin with '-' character")); @@ -638,7 +775,6 @@ guestfs_config (guestfs_h *g, strcmp (qemu_param, "-initrd") == 0 || strcmp (qemu_param, "-nographic") == 0 || strcmp (qemu_param, "-serial") == 0 || - strcmp (qemu_param, "-vnc") == 0 || strcmp (qemu_param, "-full-screen") == 0 || strcmp (qemu_param, "-std-vga") == 0 || strcmp (qemu_param, "-vnc") == 0) { @@ -666,13 +802,31 @@ guestfs_add_drive (guestfs_h *g, const char *filename) return -1; } - if (access (filename, F_OK) == -1) { - perrorf (g, "%s", filename); - return -1; + /* cache=off improves reliability in the event of a host crash. + * + * However this option causes qemu to try to open the file with + * O_DIRECT. This fails on some filesystem types (notably tmpfs). + * So we check if we can open the file with or without O_DIRECT, + * and use cache=off (or not) accordingly. + * + * This test also checks for the presence of the file, which + * is a documented semantic of this interface. + */ + int fd = open (filename, O_RDONLY|O_DIRECT); + if (fd >= 0) { + close (fd); + snprintf (buf, len, "file=%s,cache=off,if=" DRIVE_IF, filename); + } else { + fd = open (filename, O_RDONLY); + if (fd >= 0) { + close (fd); + snprintf (buf, len, "file=%s,if=" DRIVE_IF, filename); + } else { + perrorf (g, "%s", filename); + return -1; + } } - snprintf (buf, len, "file=%s", filename); - return guestfs_config (g, "-drive", buf); } @@ -692,7 +846,7 @@ guestfs_add_drive_ro (guestfs_h *g, const char *filename) return -1; } - snprintf (buf, len, "file=%s,snapshot=on", filename); + snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, DRIVE_IF); return guestfs_config (g, "-drive", buf); } @@ -745,6 +899,9 @@ dir_contains_files (const char *dir, ...) } static int build_supermin_appliance (guestfs_h *g, const char *path, char **kernel, char **initrd); +static int test_qemu (guestfs_h *g); +static int qemu_supports (guestfs_h *g, const char *option); +static void print_cmdline (guestfs_h *g); static const char *kernel_name = "vmlinuz." REPO "." host_cpu; static const char *initrd_name = "initramfs." REPO "." host_cpu ".img"; @@ -756,8 +913,9 @@ static const char *supermin_hostfiles_name = int guestfs_launch (guestfs_h *g) { - static const char *dir_template = "/tmp/libguestfsXXXXXX"; - int r, i, pmore, memsize; + const char *tmpdir; + char dir_template[PATH_MAX]; + int r, pmore; size_t len; int wfd[2], rfd[2]; int tries; @@ -766,6 +924,15 @@ guestfs_launch (guestfs_h *g) char unixsock[256]; struct sockaddr_un addr; +#ifdef P_tmpdir + tmpdir = P_tmpdir; +#else + tmpdir = "/tmp"; +#endif + + tmpdir = getenv ("TMPDIR") ? : tmpdir; + snprintf (dir_template, sizeof dir_template, "%s/libguestfsXXXXXX", tmpdir); + /* Configured? */ if (!g->cmdline) { error (g, _("you must call guestfs_add_drive before guestfs_launch")); @@ -801,27 +968,27 @@ guestfs_launch (guestfs_h *g) /* Empty element of "." means cwd. */ if (len == 0 || (len == 1 && *pelem == '.')) { if (g->verbose) - fprintf (stderr, - "looking for supermin appliance in current directory\n"); + 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; + supermin_name, supermin_hostfiles_name, + "kmod.whitelist", NULL)) { + if (build_supermin_appliance (g, ".", &kernel, &initrd) == -1) + return -1; + break; } } /* Look at /supermin* etc. */ else { if (g->verbose) - fprintf (stderr, "looking for supermin appliance in %s\n", pelem); + 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; + supermin_name, supermin_hostfiles_name, + "kmod.whitelist", NULL)) { + if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1) + return -1; + break; } } @@ -841,27 +1008,27 @@ guestfs_launch (guestfs_h *g) /* 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; - } + 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 /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; - } + 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; @@ -872,18 +1039,13 @@ guestfs_launch (guestfs_h *g) if (kernel == NULL || initrd == NULL) { error (g, _("cannot find %s or %s on LIBGUESTFS_PATH (current path = %s)"), - kernel_name, initrd_name, g->path); + kernel_name, initrd_name, g->path); goto cleanup0; } - /* 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. - */ - memsize = 384; + /* 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); @@ -914,25 +1076,30 @@ guestfs_launch (guestfs_h *g) */ g->cmdline[0] = g->qemu; - /* Construct the -net channel parameter for qemu. */ - snprintf (vmchannel, sizeof vmchannel, - "channel,%d:unix:%s,server,nowait", - VMCHANNEL_PORT, unixsock); +#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, - "panic=1 console=ttyS0 guestfs=%s:%d%s%s%s", - VMCHANNEL_ADDR, VMCHANNEL_PORT, - g->verbose ? " guestfs_verbose=1" : "", - g->append ? " " : "", g->append ? g->append : ""); - - snprintf (memsize_str, sizeof memsize_str, "%d", memsize); + 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); -#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); @@ -943,29 +1110,69 @@ guestfs_launch (guestfs_h *g) 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, vmchannel); - add_cmdline (g, "-net"); - add_cmdline (g, "user,vlan=0"); - add_cmdline (g, "-net"); - add_cmdline (g, "nic,model=virtio,vlan=0"); + 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) { - fprintf (stderr, "%s", g->qemu); - for (i = 0; g->cmdline[i]; ++i) - fprintf (stderr, " %s", g->cmdline[i]); - fprintf (stderr, "\n"); - } + if (g->verbose) + print_cmdline (g); /* Set up stdin, stdout. */ close (0); close (1); close (wfd[1]); close (rfd[0]); - dup (wfd[0]); - dup (rfd[1]); + + 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]); @@ -1008,11 +1215,11 @@ guestfs_launch (guestfs_h *g) */ for (;;) { if (kill (qemu_pid, 0) == -1) /* qemu's gone away, we aren't needed */ - _exit (0); + _exit (0); if (kill (parent_pid, 0) == -1) { - /* Parent's gone away, qemu still around, so kill qemu. */ - kill (qemu_pid, 9); - _exit (0); + /* Parent's gone away, qemu still around, so kill qemu. */ + kill (qemu_pid, 9); + _exit (0); } sleep (2); } @@ -1093,8 +1300,8 @@ guestfs_launch (guestfs_h *g) g->stdout_watch = g->main_loop->add_handle (g->main_loop, g, g->fd[1], - GUESTFS_HANDLE_READABLE, - stdout_event, NULL); + GUESTFS_HANDLE_READABLE, + stdout_event, NULL); if (g->stdout_watch == -1) { error (g, _("could not watch qemu stdout")); goto cleanup3; @@ -1137,6 +1344,33 @@ guestfs_launch (guestfs_h *g) 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 @@ -1145,7 +1379,7 @@ guestfs_launch (guestfs_h *g) */ static int build_supermin_appliance (guestfs_h *g, const char *path, - char **kernel, char **initrd) + char **kernel, char **initrd) { char cmd[4096]; int r, len; @@ -1157,10 +1391,10 @@ build_supermin_appliance (guestfs_h *g, const char *path, 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); + "PATH='%s':$PATH " + "libguestfs-supermin-helper '%s' %s %s", + path, + path, *kernel, *initrd); r = system (cmd); if (r == -1 || WEXITSTATUS(r) != 0) { @@ -1174,6 +1408,90 @@ build_supermin_appliance (guestfs_h *g, const char *path, 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) { @@ -1280,7 +1598,7 @@ guestfs_set_ready (guestfs_h *g) { if (g->state != BUSY) { error (g, _("guestfs_set_ready: called when in state %d != BUSY"), - g->state); + g->state); return -1; } g->state = READY; @@ -1292,7 +1610,7 @@ guestfs_set_busy (guestfs_h *g) { if (g->state != READY) { error (g, _("guestfs_set_busy: called when in state %d != READY"), - g->state); + g->state); return -1; } g->state = BUSY; @@ -1310,45 +1628,16 @@ guestfs_end_busy (guestfs_h *g) 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; } -/* 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); -} - /* 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. @@ -1388,7 +1677,7 @@ child_cleanup (guestfs_h *g) */ static void stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) + int watch, int fd, int events) { char buf[4096]; int n; @@ -1396,8 +1685,8 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, #if 0 if (g->verbose) fprintf (stderr, - "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); + "stdout_event: %p g->state = %d, fd = %d, events = 0x%x\n", + g, g->state, fd, events); #endif if (g->fd[1] != fd) { @@ -1420,7 +1709,7 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, /* In verbose mode, copy all log messages to stderr. */ if (g->verbose) - write (2, buf, n); + ignore_value (write (STDERR_FILENO, buf, n)); /* It's an actual log message, send it upwards if anyone is listening. */ if (g->log_message_cb) @@ -1432,7 +1721,7 @@ stdout_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, */ static void sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) + int watch, int fd, int events) { XDR xdr; u_int32_t len; @@ -1440,8 +1729,8 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, if (g->verbose) fprintf (stderr, - "sock_read_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); + "sock_read_event: %p g->state = %d, fd = %d, events = 0x%x\n", + g, g->state, fd, events); if (g->sock != fd) { error (g, _("sock_read_event: internal error: %d != %d"), g->sock, fd); @@ -1453,7 +1742,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, g->msg_in = safe_realloc (g, g->msg_in, g->msg_in_allocated); } n = read (g->sock, g->msg_in + g->msg_in_size, - g->msg_in_allocated - g->msg_in_size); + g->msg_in_allocated - g->msg_in_size); if (n == 0) { /* Disconnected. */ child_cleanup (g); @@ -1485,14 +1774,14 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, if (len == GUESTFS_LAUNCH_FLAG) { if (g->state != LAUNCHING) error (g, _("received magic signature from guestfsd, but in state %d"), - g->state); + g->state); else if (g->msg_in_size != 4) error (g, _("received magic signature from guestfsd, but msg size is %d"), - g->msg_in_size); + g->msg_in_size); else { g->state = READY; if (g->launch_done_cb) - g->launch_done_cb (g, g->launch_done_cb_data); + g->launch_done_cb (g, g->launch_done_cb_data); } goto cleanup; @@ -1513,7 +1802,7 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, */ if (len > GUESTFS_MESSAGE_MAX) { error (g, _("message length (%u) > maximum possible size (%d)"), - len, GUESTFS_MESSAGE_MAX); + len, GUESTFS_MESSAGE_MAX); goto cleanup; } @@ -1527,17 +1816,17 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, 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]); + printf ("%02x ", (unsigned char) g->msg_in[j]); for (; j < i+16; ++j) - printf (" "); + 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 ("."); + if (isprint (g->msg_in[j])) + printf ("%c", g->msg_in[j]); + else + printf ("."); for (; j < i+16; ++j) - printf (" "); + printf (" "); printf ("|\n"); } } @@ -1575,14 +1864,14 @@ sock_read_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, */ static void sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, - int watch, int fd, int events) + int watch, int fd, int events) { - int n; + int n, err; if (g->verbose) fprintf (stderr, - "sock_write_event: %p g->state = %d, fd = %d, events = 0x%x\n", - g, g->state, fd, events); + "sock_write_event: %p g->state = %d, fd = %d, events = 0x%x\n", + g, g->state, fd, events); if (g->sock != fd) { error (g, _("sock_write_event: internal error: %d != %d"), g->sock, fd); @@ -1596,13 +1885,16 @@ sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, if (g->verbose) fprintf (stderr, "sock_write_event: writing %d bytes ...\n", - g->msg_out_size - g->msg_out_pos); + g->msg_out_size - g->msg_out_pos); n = write (g->sock, g->msg_out + g->msg_out_pos, - g->msg_out_size - g->msg_out_pos); + g->msg_out_size - g->msg_out_pos); if (n == -1) { - if (errno != EAGAIN) + err = errno; + if (err != EAGAIN) perrorf (g, "write"); + if (err == EPIPE) /* Disconnected from guest (RHBZ#508713). */ + child_cleanup (g); return; } @@ -1629,7 +1921,7 @@ sock_write_event (struct guestfs_main_loop *ml, guestfs_h *g, void *data, void guestfs_set_send_callback (guestfs_h *g, - guestfs_send_cb cb, void *opaque) + guestfs_send_cb cb, void *opaque) { g->send_cb = cb; g->send_cb_data = opaque; @@ -1637,7 +1929,7 @@ guestfs_set_send_callback (guestfs_h *g, void guestfs_set_reply_callback (guestfs_h *g, - guestfs_reply_cb cb, void *opaque) + guestfs_reply_cb cb, void *opaque) { g->reply_cb = cb; g->reply_cb_data = opaque; @@ -1645,7 +1937,7 @@ guestfs_set_reply_callback (guestfs_h *g, void guestfs_set_log_message_callback (guestfs_h *g, - guestfs_log_message_cb cb, void *opaque) + guestfs_log_message_cb cb, void *opaque) { g->log_message_cb = cb; g->log_message_cb_data = opaque; @@ -1653,7 +1945,7 @@ guestfs_set_log_message_callback (guestfs_h *g, void guestfs_set_subprocess_quit_callback (guestfs_h *g, - guestfs_subprocess_quit_cb cb, void *opaque) + guestfs_subprocess_quit_cb cb, void *opaque) { g->subprocess_quit_cb = cb; g->subprocess_quit_cb_data = opaque; @@ -1661,7 +1953,7 @@ guestfs_set_subprocess_quit_callback (guestfs_h *g, void guestfs_set_launch_done_callback (guestfs_h *g, - guestfs_launch_done_cb cb, void *opaque) + guestfs_launch_done_cb cb, void *opaque) { g->launch_done_cb = cb; g->launch_done_cb_data = opaque; @@ -1702,8 +1994,8 @@ guestfs__switch_to_sending (guestfs_h *g) g->sock_watch = g->main_loop->add_handle (g->main_loop, g, g->sock, - GUESTFS_HANDLE_WRITABLE, - sock_write_event, NULL); + GUESTFS_HANDLE_WRITABLE, + sock_write_event, NULL); if (g->sock_watch == -1) { error (g, _("add_handle failed")); return -1; @@ -1725,8 +2017,8 @@ guestfs__switch_to_receiving (guestfs_h *g) g->sock_watch = g->main_loop->add_handle (g->main_loop, g, g->sock, - GUESTFS_HANDLE_READABLE, - sock_read_event, NULL); + GUESTFS_HANDLE_READABLE, + sock_read_event, NULL); if (g->sock_watch == -1) { error (g, _("add_handle failed")); return -1; @@ -1751,7 +2043,7 @@ send_cb (guestfs_h *g, void *data) int guestfs__send_sync (guestfs_h *g, int proc_nr, - xdrproc_t xdrp, char *args) + xdrproc_t xdrp, char *args) { struct guestfs_message_header hdr; XDR xdr; @@ -1876,7 +2168,7 @@ guestfs__send_file_sync (guestfs_h *g, const char *filename) err = send_file_data_sync (g, buf, r); if (err < 0) { if (err == -2) /* daemon sent cancellation */ - send_file_cancellation_sync (g); + send_file_cancellation_sync (g); return err; } } @@ -1973,7 +2265,7 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen) if (!xdr_guestfs_chunk (&xdr, &chunk)) { error (g, _("xdr_guestfs_chunk failed (buf = %p, buflen = %zu)"), - buf, buflen); + buf, buflen); xdr_destroy (&xdr); goto cleanup1; } @@ -2049,7 +2341,7 @@ check_for_daemon_cancellation (guestfs_h *g) if (flag != GUESTFS_CANCEL_FLAG) { error (g, _("check_for_daemon_cancellation: read 0x%x from daemon, expected 0x%x\n"), - flag, GUESTFS_CANCEL_FLAG); + flag, GUESTFS_CANCEL_FLAG); return 0; } @@ -2105,6 +2397,10 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) char fbuf[4]; uint32_t flag = GUESTFS_CANCEL_FLAG; + if (g->verbose) + fprintf (stderr, "%s: waiting for daemon to acknowledge cancellation\n", + __func__); + xdrmem_create (&xdr, fbuf, sizeof fbuf, XDR_ENCODE); xdr_uint32_t (&xdr, &flag); xdr_destroy (&xdr); @@ -2126,8 +2422,8 @@ guestfs__receive_file_sync (guestfs_h *g, const char *filename) */ struct receive_file_ctx { int count; /* 0 if receive_file_cb not called, or - * else count number of chunks. - */ + * else count number of chunks. + */ guestfs_chunk *chunks; /* Array of chunks. */ }; @@ -2166,7 +2462,7 @@ receive_file_cb (guestfs_h *g, void *data, XDR *xdr) /* Copy the chunk to the list. */ ctx->chunks = safe_realloc (g, ctx->chunks, - sizeof (guestfs_chunk) * (ctx->count+1)); + sizeof (guestfs_chunk) * (ctx->count+1)); ctx->chunks[ctx->count] = chunk; ctx->count++; } @@ -2223,8 +2519,8 @@ receive_file_data_sync (guestfs_h *g, void **buf, size_t *len_r) if (buf) { *buf = safe_realloc (g, *buf, len + ctx.chunks[i].data.data_len); - memcpy (*buf+len, ctx.chunks[i].data.data_val, - ctx.chunks[i].data.data_len); + memcpy (((char *)*buf)+len, ctx.chunks[i].data.data_val, + ctx.chunks[i].data.data_len); } len += ctx.chunks[i].data.data_len; } @@ -2238,7 +2534,7 @@ receive_file_data_sync (guestfs_h *g, void **buf, size_t *len_r) static int select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events, - guestfs_handle_event_cb cb, void *data) + guestfs_handle_event_cb cb, void *data) { struct select_main_loop *ml = (struct select_main_loop *) mlv; @@ -2248,9 +2544,9 @@ select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events, } if ((events & ~(GUESTFS_HANDLE_READABLE | - GUESTFS_HANDLE_WRITABLE | - GUESTFS_HANDLE_HANGUP | - GUESTFS_HANDLE_ERROR)) != 0) { + GUESTFS_HANDLE_WRITABLE | + GUESTFS_HANDLE_HANGUP | + GUESTFS_HANDLE_ERROR)) != 0) { error (g, _("set of events (0x%x) contains unknown events"), events); return -1; } @@ -2283,7 +2579,7 @@ select_add_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd, int events, 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)); + sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); } ml->handle_cb_data[fd].cb = cb; ml->handle_cb_data[fd].g = g; @@ -2320,7 +2616,7 @@ select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int 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)); + sizeof (struct select_handle_cb_data) * (ml->max_fd+1)); } ml->nr_fds--; @@ -2329,8 +2625,9 @@ select_remove_handle (guestfs_main_loop *mlv, guestfs_h *g, int fd) } static int +__attribute__((noreturn)) select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval, - guestfs_handle_timeout_cb cb, void *data) + guestfs_handle_timeout_cb cb, void *data) { //struct select_main_loop *ml = (struct select_main_loop *) mlv; @@ -2338,6 +2635,7 @@ select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval, } static int +__attribute__((noreturn)) select_remove_timeout (guestfs_main_loop *mlv, guestfs_h *g, int timer) { //struct select_main_loop *ml = (struct select_main_loop *) mlv; @@ -2373,7 +2671,7 @@ select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g) r = select (ml->max_fd+1, &rset2, &wset2, &xset2, NULL); if (r == -1) { if (errno == EINTR || errno == EAGAIN) - continue; + continue; perrorf (g, "select"); ml->is_running = 0; return -1; @@ -2382,17 +2680,17 @@ select_main_loop_run (guestfs_main_loop *mlv, guestfs_h *g) for (fd = 0; r > 0 && fd <= ml->max_fd; ++fd) { events = 0; if (FD_ISSET (fd, &rset2)) - events |= GUESTFS_HANDLE_READABLE; + events |= GUESTFS_HANDLE_READABLE; if (FD_ISSET (fd, &wset2)) - events |= GUESTFS_HANDLE_WRITABLE; + events |= GUESTFS_HANDLE_WRITABLE; if (FD_ISSET (fd, &xset2)) - events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP; + events |= GUESTFS_HANDLE_ERROR | GUESTFS_HANDLE_HANGUP; if (events) { - r--; - 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); + r--; + 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); } } }