X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Flaunch.c;h=7b3372c2bc85d43d596ff351eaf62cb15c9ace25;hp=7cd5a561d078115ba75b4a7e4bcd09388380b19b;hb=3814680423984b3c46c2f99e944c2a71862bde9f;hpb=41f25ab3df5f306ac717fa7a6efd58328d30c1ae diff --git a/src/launch.c b/src/launch.c index 7cd5a56..7b3372c 100644 --- a/src/launch.c +++ b/src/launch.c @@ -1,5 +1,5 @@ /* libguestfs - * Copyright (C) 2009-2010 Red Hat Inc. + * Copyright (C) 2009-2011 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 @@ -34,6 +34,7 @@ #include #include #include +#include #include #include @@ -62,20 +63,52 @@ #include #include "c-ctype.h" -#include "glthread/lock.h" #include "ignore-value.h" +#include "glthread/lock.h" #include "guestfs.h" #include "guestfs-internal.h" #include "guestfs-internal-actions.h" #include "guestfs_protocol.h" -static int check_peer_euid (guestfs_h *g, int sock, uid_t *rtn); +static int launch_appliance (guestfs_h *g); +static int64_t timeval_diff (const struct timeval *x, const struct timeval *y); +static void print_qemu_command_line (guestfs_h *g, char **argv); +static int connect_unix_socket (guestfs_h *g, const char *sock); static int qemu_supports (guestfs_h *g, const char *option); +static char *qemu_drive_param (guestfs_h *g, const struct drive *drv); + +#if 0 +static int qemu_supports_re (guestfs_h *g, const pcre *option_regex); + +static void compile_regexps (void) __attribute__((constructor)); +static void free_regexps (void) __attribute__((destructor)); -/* Add a string to the current command line. */ static void -incr_cmdline_size (guestfs_h *g) +compile_regexps (void) +{ + const char *err; + int offset; + +#define COMPILE(re,pattern,options) \ + do { \ + re = pcre_compile ((pattern), (options), &err, &offset, NULL); \ + if (re == NULL) { \ + ignore_value (write (2, err, strlen (err))); \ + abort (); \ + } \ + } while (0) +} + +static void +free_regexps (void) +{ +} +#endif + +/* Functions to add a string to the current command line. */ +static void +alloc_cmdline (guestfs_h *g) { if (g->cmdline == NULL) { /* g->cmdline[0] is reserved for argv[0], set in guestfs_launch. */ @@ -83,7 +116,12 @@ incr_cmdline_size (guestfs_h *g) g->cmdline = safe_malloc (g, sizeof (char *)); g->cmdline[0] = NULL; } +} +static void +incr_cmdline_size (guestfs_h *g) +{ + alloc_cmdline (g); g->cmdline_size++; g->cmdline = safe_realloc (g, g->cmdline, sizeof (char *) * g->cmdline_size); } @@ -102,6 +140,61 @@ add_cmdline (guestfs_h *g, const char *str) return 0; } +struct drive ** +guestfs___checkpoint_drives (guestfs_h *g) +{ + struct drive **i = &g->drives; + while (*i != NULL) i = &((*i)->next); + return i; +} + +void +guestfs___rollback_drives (guestfs_h *g, struct drive **i) +{ + guestfs___free_drives(i); +} + +/* Internal command to return the command line. */ +char ** +guestfs__debug_cmdline (guestfs_h *g) +{ + size_t i; + char **r; + + alloc_cmdline (g); + + r = safe_malloc (g, sizeof (char *) * (g->cmdline_size + 1)); + r[0] = safe_strdup (g, g->qemu); /* g->cmdline[0] is always NULL */ + + for (i = 1; i < g->cmdline_size; ++i) + r[i] = safe_strdup (g, g->cmdline[i]); + + r[g->cmdline_size] = NULL; + + return r; /* caller frees */ +} + +/* Internal command to return the list of drives. */ +char ** +guestfs__debug_drives (guestfs_h *g) +{ + size_t i, count; + char **ret; + struct drive *drv; + + for (count = 0, drv = g->drives; drv; count++, drv = drv->next) + ; + + ret = safe_malloc (g, sizeof (char *) * (count + 1)); + + for (i = 0, drv = g->drives; drv; i++, drv = drv->next) + ret[i] = qemu_drive_param (g, drv); + + ret[count] = NULL; + + return ret; /* caller frees */ +} + int guestfs__config (guestfs_h *g, const char *qemu_param, const char *qemu_value) @@ -134,78 +227,177 @@ guestfs__config (guestfs_h *g, return 0; } -int -guestfs__add_drive_with_if (guestfs_h *g, const char *filename, - const char *drive_if) +/* 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. + * + * NB: This function is only called on the !readonly path. We must + * try to open with O_RDWR to test that the file is readable and + * writable here. + */ +static int +test_cache_off (guestfs_h *g, const char *filename) { - size_t len = strlen (filename) + 64; - char buf[len]; - - if (strchr (filename, ',') != NULL) { - error (g, _("filename cannot contain ',' (comma) character")); - return -1; + int fd = open (filename, O_RDWR|O_DIRECT); + if (fd >= 0) { + close (fd); + 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); + fd = open (filename, O_RDWR); if (fd >= 0) { close (fd); - snprintf (buf, len, "file=%s,cache=off,if=%s", filename, drive_if); - } else { - fd = open (filename, O_RDONLY); - if (fd >= 0) { - close (fd); - snprintf (buf, len, "file=%s,if=%s", filename, drive_if); - } else { - perrorf (g, "%s", filename); - return -1; - } + return 0; } - return guestfs__config (g, "-drive", buf); + perrorf (g, "%s", filename); + return -1; +} + +/* Check string parameter matches ^[-_[:alnum:]]+$ (in C locale). */ +static int +valid_format_iface (const char *str) +{ + size_t len = strlen (str); + + if (len == 0) + return 0; + + while (len > 0) { + char c = *str++; + len--; + if (c != '-' && c != '_' && !c_isalnum (c)) + return 0; + } + return 1; } int -guestfs__add_drive_ro_with_if (guestfs_h *g, const char *filename, - const char *drive_if) +guestfs__add_drive_opts (guestfs_h *g, const char *filename, + const struct guestfs_add_drive_opts_argv *optargs) { + int readonly; + char *format; + char *iface; + char *name; + int use_cache_off; + if (strchr (filename, ',') != NULL) { error (g, _("filename cannot contain ',' (comma) character")); return -1; } - if (access (filename, F_OK) == -1) { - perrorf (g, "%s", filename); + readonly = optargs->bitmask & GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK + ? optargs->readonly : 0; + format = optargs->bitmask & GUESTFS_ADD_DRIVE_OPTS_FORMAT_BITMASK + ? safe_strdup (g, optargs->format) : NULL; + iface = optargs->bitmask & GUESTFS_ADD_DRIVE_OPTS_IFACE_BITMASK + ? safe_strdup (g, optargs->iface) : safe_strdup (g, DRIVE_IF); + name = optargs->bitmask & GUESTFS_ADD_DRIVE_OPTS_NAME_BITMASK + ? safe_strdup (g, optargs->name) : NULL; + + if (format && !valid_format_iface (format)) { + error (g, _("%s parameter is empty or contains disallowed characters"), + "format"); + free (format); + free (iface); + free (name); + return -1; + } + if (!valid_format_iface (iface)) { + error (g, _("%s parameter is empty or contains disallowed characters"), + "iface"); + free (format); + free (iface); + free (name); return -1; } - size_t len = strlen (filename) + 64; - char buf[len]; + /* For writable files, see if we can use cache=off. This also + * checks for the existence of the file. For readonly we have + * to do the check explicitly. + */ + use_cache_off = readonly ? 0 : test_cache_off (g, filename); + if (use_cache_off == -1) { + free (format); + free (iface); + free (name); + return -1; + } + + if (readonly) { + if (access (filename, R_OK) == -1) { + perrorf (g, "%s", filename); + free (format); + free (iface); + free (name); + return -1; + } + } + + struct drive **i = &(g->drives); + while (*i != NULL) i = &((*i)->next); - snprintf (buf, len, "file=%s,snapshot=on,if=%s", filename, drive_if); + *i = safe_malloc (g, sizeof (struct drive)); + (*i)->next = NULL; + (*i)->path = safe_strdup (g, filename); + (*i)->readonly = readonly; + (*i)->format = format; + (*i)->iface = iface; + (*i)->name = name; + (*i)->use_cache_off = use_cache_off; - return guestfs__config (g, "-drive", buf); + return 0; } int guestfs__add_drive (guestfs_h *g, const char *filename) { - return guestfs__add_drive_with_if (g, filename, DRIVE_IF); + struct guestfs_add_drive_opts_argv optargs = { + .bitmask = 0, + }; + + return guestfs__add_drive_opts (g, filename, &optargs); } int guestfs__add_drive_ro (guestfs_h *g, const char *filename) { - return guestfs__add_drive_ro_with_if (g, filename, DRIVE_IF); + struct guestfs_add_drive_opts_argv optargs = { + .bitmask = GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK, + .readonly = 1, + }; + + return guestfs__add_drive_opts (g, filename, &optargs); +} + +int +guestfs__add_drive_with_if (guestfs_h *g, const char *filename, + const char *iface) +{ + struct guestfs_add_drive_opts_argv optargs = { + .bitmask = GUESTFS_ADD_DRIVE_OPTS_IFACE_BITMASK, + .iface = iface, + }; + + return guestfs__add_drive_opts (g, filename, &optargs); +} + +int +guestfs__add_drive_ro_with_if (guestfs_h *g, const char *filename, + const char *iface) +{ + struct guestfs_add_drive_opts_argv optargs = { + .bitmask = GUESTFS_ADD_DRIVE_OPTS_IFACE_BITMASK + | GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK, + .iface = iface, + .readonly = 1, + }; + + return guestfs__add_drive_opts (g, filename, &optargs); } int @@ -224,242 +416,116 @@ guestfs__add_cdrom (guestfs_h *g, const char *filename) return guestfs__config (g, "-cdrom", filename); } -/* Returns true iff file is contained in dir. */ -static int -dir_contains_file (const char *dir, const char *file) -{ - int dirlen = strlen (dir); - int filelen = strlen (file); - int len = dirlen+filelen+2; - char path[len]; - - snprintf (path, len, "%s/%s", dir, file); - return access (path, F_OK) == 0; -} - -/* Returns true iff every listed file is contained in 'dir'. */ -static int -dir_contains_files (const char *dir, ...) -{ - va_list args; - const char *file; - - va_start (args, dir); - while ((file = va_arg (args, const char *)) != NULL) { - if (!dir_contains_file (dir, file)) { - va_end (args); - return 0; - } - } - va_end (args); - return 1; -} - -static void print_timestamped_message (guestfs_h *g, const char *fs, ...); -static int build_supermin_appliance (guestfs_h *g, const char *path, char **kernel, char **initrd); static int is_openable (guestfs_h *g, const char *path, int flags); -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"; int guestfs__launch (guestfs_h *g) { - const char *tmpdir; - char dir_template[PATH_MAX]; - int r, pmore; - size_t len; - int wfd[2], rfd[2]; - int tries; - char *path, *pelem, *pend; - char *kernel = NULL, *initrd = NULL; - int null_vmchannel_sock; - char unixsock[256]; - struct sockaddr_un addr; - /* Configured? */ - if (!g->cmdline) { - error (g, _("you must call guestfs_add_drive before guestfs_launch")); - return -1; - } - if (g->state != CONFIG) { error (g, _("the libguestfs handle has already been launched")); return -1; } - /* Start the clock ... */ - gettimeofday (&g->launch_t, NULL); + TRACE0 (launch_start); /* Make the temporary directory. */ -#ifdef P_tmpdir - tmpdir = P_tmpdir; -#else - tmpdir = "/tmp"; -#endif - - tmpdir = getenv ("TMPDIR") ? : tmpdir; - snprintf (dir_template, sizeof dir_template, "%s/libguestfsXXXXXX", tmpdir); - if (!g->tmpdir) { + TMP_TEMPLATE_ON_STACK (dir_template); g->tmpdir = safe_strdup (g, dir_template); if (mkdtemp (g->tmpdir) == NULL) { perrorf (g, _("%s: cannot create temporary directory"), dir_template); - goto cleanup0; + return -1; } } - /* Allow anyone to read the temporary directory. There are no - * secrets in the kernel or initrd files. The socket in this + /* Allow anyone to read the temporary directory. The socket in this * directory won't be readable but anyone can see it exists if they * want. (RHBZ#610880). */ if (chmod (g->tmpdir, 0755) == -1) - fprintf (stderr, "chmod: %s: %m (ignored)\n", g->tmpdir); + warning (g, "chmod: %s: %m (ignored)", g->tmpdir); - /* First search g->path for the supermin appliance, and try to - * synthesize a kernel and initrd from that. If it fails, we - * try the path search again looking for a backup ordinary - * appliance. - */ - pelem = path = safe_strdup (g, g->path); - do { - pend = strchrnul (pelem, ':'); - pmore = *pend == ':'; - *pend = '\0'; - len = pend - pelem; - - /* Empty element of "." means cwd. */ - if (len == 0 || (len == 1 && *pelem == '.')) { - if (g->verbose) - fprintf (stderr, - "looking for supermin appliance in current directory\n"); - if (dir_contains_files (".", - "supermin.d", "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); - - if (dir_contains_files (pelem, - "supermin.d", "kmod.whitelist", NULL)) { - if (build_supermin_appliance (g, pelem, &kernel, &initrd) == -1) - return -1; - break; - } - } - - pelem = pend + 1; - } while (pmore); - - free (path); - - if (kernel == NULL || initrd == NULL) { - /* Search g->path for the kernel and initrd. */ - pelem = path = safe_strdup (g, g->path); - do { - pend = strchrnul (pelem, ':'); - pmore = *pend == ':'; - *pend = '\0'; - len = pend - pelem; - - /* Empty element or "." means cwd. */ - if (len == 0 || (len == 1 && *pelem == '.')) { - if (g->verbose) - fprintf (stderr, - "looking for appliance in current directory\n"); - if (dir_contains_files (".", kernel_name, initrd_name, NULL)) { - kernel = safe_strdup (g, kernel_name); - initrd = safe_strdup (g, initrd_name); - break; - } - } - /* Look at /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; - } - } + /* Launch the appliance or attach to an existing daemon. */ + switch (g->attach_method) { + case ATTACH_METHOD_APPLIANCE: + return launch_appliance (g); - pelem = pend + 1; - } while (pmore); + case ATTACH_METHOD_UNIX: + return connect_unix_socket (g, g->attach_method_arg); - free (path); + default: + abort (); } +} - 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; +static int +launch_appliance (guestfs_h *g) +{ + int r; + int wfd[2], rfd[2]; + char guestfsd_sock[256]; + struct sockaddr_un addr; + + /* At present you must add drives before starting the appliance. In + * future when we enable hotplugging you won't need to do this. + */ + if (!g->drives) { + error (g, _("you must call guestfs_add_drive before guestfs_launch")); + return -1; } + /* Start the clock ... */ + gettimeofday (&g->launch_t, NULL); + guestfs___launch_send_progress (g, 0); + + TRACE0 (launch_build_appliance_start); + + /* Locate and/or build the appliance. */ + char *kernel = NULL, *initrd = NULL, *appliance = NULL; + if (guestfs___build_appliance (g, &kernel, &initrd, &appliance) == -1) + return -1; + + TRACE0 (launch_build_appliance_end); + + guestfs___launch_send_progress (g, 3); + if (g->verbose) - print_timestamped_message (g, "begin testing qemu features"); + guestfs___print_timestamped_message (g, "begin testing qemu features"); /* Get qemu help text and version. */ if (qemu_supports (g, NULL) == -1) goto cleanup0; - /* Choose which vmchannel implementation to use. */ - if (CAN_CHECK_PEER_EUID && qemu_supports (g, "-net user")) { - /* The "null vmchannel" implementation. Requires SLIRP (user mode - * networking in qemu) but no other vmchannel support. The daemon - * will connect back to a random port number on localhost. - */ - struct sockaddr_in addr; - socklen_t addrlen = sizeof addr; + /* Using virtio-serial, we need to create a local Unix domain socket + * for qemu to connect to. + */ + snprintf (guestfsd_sock, sizeof guestfsd_sock, "%s/guestfsd.sock", g->tmpdir); + unlink (guestfsd_sock); - g->sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); - if (g->sock == -1) { - perrorf (g, "socket"); - goto cleanup0; - } - addr.sin_family = AF_INET; - addr.sin_port = htons (0); - addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK); - if (bind (g->sock, (struct sockaddr *) &addr, addrlen) == -1) { - perrorf (g, "bind"); - goto cleanup0; - } + g->sock = socket (AF_UNIX, SOCK_STREAM, 0); + if (g->sock == -1) { + perrorf (g, "socket"); + goto cleanup0; + } - if (listen (g->sock, 256) == -1) { - perrorf (g, "listen"); - goto cleanup0; - } + if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) { + perrorf (g, "fcntl"); + goto cleanup0; + } - if (getsockname (g->sock, (struct sockaddr *) &addr, &addrlen) == -1) { - perrorf (g, "getsockname"); - goto cleanup0; - } + addr.sun_family = AF_UNIX; + strncpy (addr.sun_path, guestfsd_sock, UNIX_PATH_MAX); + addr.sun_path[UNIX_PATH_MAX-1] = '\0'; - if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) { - perrorf (g, "fcntl"); - goto cleanup0; - } + if (bind (g->sock, &addr, sizeof addr) == -1) { + perrorf (g, "bind"); + goto cleanup0; + } - null_vmchannel_sock = ntohs (addr.sin_port); - if (g->verbose) - fprintf (stderr, "null_vmchannel_sock = %d\n", null_vmchannel_sock); - } else { - /* Using some vmchannel impl. We need to create a local Unix - * domain socket for qemu to use. - */ - snprintf (unixsock, sizeof unixsock, "%s/sock", g->tmpdir); - unlink (unixsock); - null_vmchannel_sock = 0; + if (listen (g->sock, 1) == -1) { + perrorf (g, "listen"); + goto cleanup0; } if (!g->direct) { @@ -470,7 +536,7 @@ guestfs__launch (guestfs_h *g) } if (g->verbose) - print_timestamped_message (g, "finished testing qemu features"); + guestfs___print_timestamped_message (g, "finished testing qemu features"); r = fork (); if (r == -1) { @@ -486,28 +552,70 @@ guestfs__launch (guestfs_h *g) if (r == 0) { /* Child (qemu). */ char buf[256]; - const char *vmchannel = NULL; /* Set up the full command line. Do this in the subprocess so we * don't need to worry about cleaning up. */ + + /* Set g->cmdline[0] to the name of the qemu process. However + * it is possible that no g->cmdline has been allocated yet so + * we must do that first. + */ + alloc_cmdline (g); g->cmdline[0] = g->qemu; - /* qemu sometimes needs this option to enable hardware - * virtualization, but some versions of 'qemu-kvm' will use KVM - * regardless (even where this option appears in the help text). - * It is rumoured that there are versions of qemu where supplying - * this option when hardware virtualization is not available will - * cause qemu to fail, so we we have to check at least that - * /dev/kvm is openable. That's not reliable, since /dev/kvm - * might be openable by qemu but not by us (think: SELinux) in - * which case the user would not get hardware virtualization, - * although at least shouldn't fail. A giant clusterfuck with the - * qemu command line, again. + /* Add drives */ + struct drive *drv = g->drives; + while (drv != NULL) { + /* Construct the final -drive parameter. */ + char *buf = qemu_drive_param (g, drv); + + add_cmdline (g, "-drive"); + add_cmdline (g, buf); + free (buf); + + drv = drv->next; + } + + if (qemu_supports (g, "-nodefconfig")) + add_cmdline (g, "-nodefconfig"); + + /* The qemu -machine option (added 2010-12) is a bit more sane + * since it falls back through various different acceleration + * modes, so try that first (thanks Markus Armbruster). */ - if (qemu_supports (g, "-enable-kvm") && - is_openable (g, "/dev/kvm", O_RDWR)) - add_cmdline (g, "-enable-kvm"); + if (qemu_supports (g, "-machine")) { + add_cmdline (g, "-machine"); +#if QEMU_MACHINE_TYPE_IS_BROKEN + /* Workaround for qemu 0.15: We have to add the '[type=]pc' + * since there is no default. This is not a permanent solution + * because this only works on PC-like hardware. Other platforms + * like ppc would need a different machine type. + * + * This bug is fixed in qemu commit 2645c6dcaf6ea2a51a, and was + * not a problem in qemu < 0.15. + */ + add_cmdline (g, "pc,accel=kvm:tcg"); +#else + add_cmdline (g, "accel=kvm:tcg"); +#endif + } else { + /* qemu sometimes needs this option to enable hardware + * virtualization, but some versions of 'qemu-kvm' will use KVM + * regardless (even where this option appears in the help text). + * It is rumoured that there are versions of qemu where supplying + * this option when hardware virtualization is not available will + * cause qemu to fail, so we we have to check at least that + * /dev/kvm is openable. That's not reliable, since /dev/kvm + * might be openable by qemu but not by us (think: SELinux) in + * which case the user would not get hardware virtualization, + * although at least shouldn't fail. A giant clusterfuck with the + * qemu command line, again. + */ + if (qemu_supports (g, "-enable-kvm") && + is_openable (g, "/dev/kvm", O_RDWR)) + add_cmdline (g, "-enable-kvm"); + } /* Newer versions of qemu (from around 2009/12) changed the * behaviour of monitors so that an implicit '-monitor stdio' is @@ -521,8 +629,12 @@ guestfs__launch (guestfs_h *g) add_cmdline (g, "-nodefaults"); add_cmdline (g, "-nographic"); - add_cmdline (g, "-serial"); - add_cmdline (g, "stdio"); + + if (g->smp > 1) { + snprintf (buf, sizeof buf, "%d", g->smp); + add_cmdline (g, "-smp"); + add_cmdline (g, buf); + } snprintf (buf, sizeof buf, "%d", g->memsize); add_cmdline (g, "-m"); @@ -538,71 +650,44 @@ guestfs__launch (guestfs_h *g) if (qemu_supports (g, "-rtc-td-hack")) add_cmdline (g, "-rtc-td-hack"); - /* If qemu has SLIRP (user mode network) enabled then we can get - * away with "no vmchannel", where we just connect back to a random - * host port. - */ - if (null_vmchannel_sock) { - add_cmdline (g, "-net"); - add_cmdline (g, "user,vlan=0,net=" NETWORK); - - snprintf (buf, sizeof buf, - "guestfs_vmchannel=tcp:" ROUTER ":%d", - null_vmchannel_sock); - vmchannel = strdup (buf); - } + /* Create the virtio serial bus. */ + add_cmdline (g, "-device"); + add_cmdline (g, "virtio-serial"); - /* New-style -net user,guestfwd=... syntax for guestfwd. See: - * - * http://git.savannah.gnu.org/cgit/qemu.git/commit/?id=c92ef6a22d3c71538fcc48fb61ad353f7ba03b62 - * - * The original suggested format doesn't work, see: - * - * http://lists.gnu.org/archive/html/qemu-devel/2009-07/msg01654.html - * - * However Gerd Hoffman privately suggested to me using -chardev - * instead, which does work. - */ - else if (qemu_supports (g, "-chardev") && qemu_supports (g, "guestfwd")) { - snprintf (buf, sizeof buf, - "socket,id=guestfsvmc,path=%s,server,nowait", unixsock); - - add_cmdline (g, "-chardev"); - add_cmdline (g, buf); - - snprintf (buf, sizeof buf, - "user,vlan=0,net=" NETWORK "," - "guestfwd=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT - "-chardev:guestfsvmc"); - - add_cmdline (g, "-net"); - add_cmdline (g, buf); - - vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT; - } - - /* Not guestfwd. HOPEFULLY this qemu uses the older -net channel - * syntax, or if not then we'll get a quick failure. +#if 0 + /* Use virtio-console (a variant form of virtio-serial) for the + * guest's serial console. */ - else { - snprintf (buf, sizeof buf, - "channel," GUESTFWD_PORT ":unix:%s,server,nowait", unixsock); - - add_cmdline (g, "-net"); - add_cmdline (g, buf); - add_cmdline (g, "-net"); - add_cmdline (g, "user,vlan=0,net=" NETWORK); + add_cmdline (g, "-chardev"); + add_cmdline (g, "stdio,id=console"); + add_cmdline (g, "-device"); + add_cmdline (g, "virtconsole,chardev=console,name=org.libguestfs.console.0"); +#else + /* When the above works ... until then: */ + add_cmdline (g, "-serial"); + add_cmdline (g, "stdio"); +#endif - vmchannel = "guestfs_vmchannel=tcp:" GUESTFWD_ADDR ":" GUESTFWD_PORT; + /* Set up virtio-serial for the communications channel. */ + add_cmdline (g, "-chardev"); + snprintf (buf, sizeof buf, "socket,path=%s,id=channel0", guestfsd_sock); + add_cmdline (g, buf); + add_cmdline (g, "-device"); + add_cmdline (g, "virtserialport,chardev=channel0,name=org.libguestfs.channel.0"); + + /* Enable user networking. */ + if (g->enable_network) { + add_cmdline (g, "-netdev"); + add_cmdline (g, "user,id=usernet,net=169.254.0.0/16"); + add_cmdline (g, "-device"); + add_cmdline (g, NET_IF ",netdev=usernet"); } - add_cmdline (g, "-net"); - add_cmdline (g, "nic,model=" NET_IF ",vlan=0"); #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 */ \ + "no_timer_check " /* fix for RHBZ#502058 */ \ "acpi=off " /* we don't need ACPI, turn it off */ \ "printk.time=1 " /* display timestamp before kernel messages */ \ "cgroup_disable=memory " /* saves us about 5 MB of RAM */ @@ -611,42 +696,64 @@ guestfs__launch (guestfs_h *g) snprintf (buf, sizeof buf, LINUX_CMDLINE "%s " /* (selinux) */ - "%s " /* (vmchannel) */ "%s " /* (verbose) */ "TERM=%s " /* (TERM environment variable) */ "%s", /* (append) */ g->selinux ? "selinux=1 enforcing=0" : "selinux=0", - vmchannel ? vmchannel : "", g->verbose ? "guestfs_verbose=1" : "", getenv ("TERM") ? : "linux", g->append ? g->append : ""); add_cmdline (g, "-kernel"); - add_cmdline (g, (char *) kernel); + add_cmdline (g, kernel); add_cmdline (g, "-initrd"); - add_cmdline (g, (char *) initrd); + add_cmdline (g, initrd); add_cmdline (g, "-append"); add_cmdline (g, buf); + /* Add the ext2 appliance drive (last of all). */ + if (appliance) { + const char *cachemode = ""; + if (qemu_supports (g, "cache=")) { + if (qemu_supports (g, "unsafe")) + cachemode = ",cache=unsafe"; + else if (qemu_supports (g, "writeback")) + cachemode = ",cache=writeback"; + } + + char buf2[PATH_MAX + 64]; + add_cmdline (g, "-drive"); + snprintf (buf2, sizeof buf2, "file=%s,snapshot=on,if=" DRIVE_IF "%s", + appliance, cachemode); + add_cmdline (g, buf2); + } + /* Finish off the command line. */ incr_cmdline_size (g); g->cmdline[g->cmdline_size-1] = NULL; - if (g->verbose) - print_cmdline (g); - if (!g->direct) { - /* Set up stdin, stdout. */ + /* Set up stdin, stdout, stderr. */ close (0); close (1); close (wfd[1]); close (rfd[0]); + /* Stdin. */ if (dup (wfd[0]) == -1) { dup_failed: perror ("dup failed"); _exit (EXIT_FAILURE); } + /* Stdout. */ + if (dup (rfd[1]) == -1) + goto dup_failed; + + /* Particularly since qemu 0.15, qemu spews all sorts of debug + * information on stderr. It is useful to both capture this and + * not confuse casual users, so send stderr to the pipe as well. + */ + close (2); if (dup (rfd[1]) == -1) goto dup_failed; @@ -654,15 +761,18 @@ guestfs__launch (guestfs_h *g) close (rfd[1]); } -#if 0 - /* Set up a new process group, so we can signal this process - * and all subprocesses (eg. if qemu is really a shell script). - */ - setpgid (0, 0); -#endif + /* Dump the command line (after setting up stderr above). */ + if (g->verbose) + print_qemu_command_line (g, g->cmdline); + + /* Put qemu in a new process group. */ + if (g->pgroup) + setpgid (0, 0); setenv ("LC_ALL", "C", 1); + TRACE0 (launch_run_qemu); + execv (g->qemu, g->cmdline); /* Run qemu. */ perror (g->qemu); _exit (EXIT_FAILURE); @@ -675,6 +785,8 @@ guestfs__launch (guestfs_h *g) kernel = NULL; free (initrd); initrd = NULL; + free (appliance); + appliance = NULL; /* Fork the recovery process off which will kill qemu if the parent * process fails to do so (eg. if the parent segfaults). @@ -686,8 +798,16 @@ guestfs__launch (guestfs_h *g) pid_t qemu_pid = g->pid; pid_t parent_pid = getppid (); + /* It would be nice to be able to put this in the same process + * group as qemu (ie. setpgid (0, qemu_pid)). However this is + * not possible because we don't have any guarantee here that + * the qemu process has started yet. + */ + if (g->pgroup) + setpgid (0, 0); + /* 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 + * http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/misc/ps_status.c;hb=HEAD */ /* Loop around waiting for one or both of the other processes to @@ -740,93 +860,33 @@ guestfs__launch (guestfs_h *g) } } - if (null_vmchannel_sock) { - int sock = -1; - uid_t uid; - - /* Null vmchannel implementation: We listen on g->sock for a - * connection. The connection could come from any local process - * so we must check it comes from the appliance (or at least - * from our UID) for security reasons. - */ - while (sock == -1) { - sock = guestfs__accept_from_daemon (g); - if (sock == -1) - goto cleanup1; - - if (check_peer_euid (g, sock, &uid) == -1) - goto cleanup1; - if (uid != geteuid ()) { - fprintf (stderr, - "libguestfs: warning: unexpected connection from UID %d to port %d\n", - uid, null_vmchannel_sock); - close (sock); - sock = -1; - continue; - } - } - - if (fcntl (sock, F_SETFL, O_NONBLOCK) == -1) { - perrorf (g, "fcntl"); - goto cleanup1; - } + g->state = LAUNCHING; - close (g->sock); - g->sock = sock; - } else { - /* Other vmchannel. Open the Unix socket. - * - * The vmchannel implementation that got merged with qemu sucks in - * a number of ways. Both ends do connect(2), which means that no - * one knows what, if anything, is connected to the other end, or - * if it becomes disconnected. Even worse, we have to wait some - * indeterminate time for qemu to create the socket and connect to - * it (which happens very early in qemu's start-up), so any code - * that uses vmchannel is inherently racy. Hence this silly loop. - */ - g->sock = socket (AF_UNIX, SOCK_STREAM, 0); - if (g->sock == -1) { - perrorf (g, "socket"); - goto cleanup1; - } + /* Wait for qemu to start and to connect back to us via + * virtio-serial and send the GUESTFS_LAUNCH_FLAG message. + */ + r = guestfs___accept_from_daemon (g); + if (r == -1) + goto cleanup1; - if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) { - perrorf (g, "fcntl"); - goto cleanup1; - } + /* NB: We reach here just because qemu has opened the socket. It + * does not mean the daemon is up until we read the + * GUESTFS_LAUNCH_FLAG below. Failures in qemu startup can still + * happen even if we reach here, even early failures like not being + * able to open a drive. + */ - addr.sun_family = AF_UNIX; - strncpy (addr.sun_path, unixsock, UNIX_PATH_MAX); - addr.sun_path[UNIX_PATH_MAX-1] = '\0'; - - tries = 100; - /* Always sleep at least once to give qemu a small chance to start up. */ - usleep (10000); - while (tries > 0) { - r = connect (g->sock, (struct sockaddr *) &addr, sizeof addr); - if ((r == -1 && errno == EINPROGRESS) || r == 0) - goto connected; - - if (errno != ENOENT) - perrorf (g, "connect"); - tries--; - usleep (100000); - } + close (g->sock); /* Close the listening socket. */ + g->sock = r; /* This is the accepted data socket. */ - error (g, _("failed to connect to vmchannel socket")); + if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) { + perrorf (g, "fcntl"); goto cleanup1; - - connected: ; } - g->state = LAUNCHING; - - /* Wait for qemu to start and to connect back to us via vmchannel and - * send the GUESTFS_LAUNCH_FLAG message. - */ uint32_t size; void *buf = NULL; - r = guestfs__recv_from_daemon (g, &size, &buf); + r = guestfs___recv_from_daemon (g, &size, &buf); free (buf); if (r == -1) return -1; @@ -837,7 +897,7 @@ guestfs__launch (guestfs_h *g) } if (g->verbose) - print_timestamped_message (g, "appliance is up"); + guestfs___print_timestamped_message (g, "appliance is up"); /* This is possible in some really strange situations, such as * guestfsd starts up OK but then qemu immediately exits. Check for @@ -849,6 +909,10 @@ guestfs__launch (guestfs_h *g) goto cleanup1; } + TRACE0 (launch_end); + + guestfs___launch_send_progress (g, 12); + return 0; cleanup1: @@ -858,7 +922,7 @@ guestfs__launch (guestfs_h *g) } if (g->pid > 0) kill (g->pid, 9); if (g->recoverypid > 0) kill (g->recoverypid, 9); - waitpid (g->pid, NULL, 0); + if (g->pid > 0) waitpid (g->pid, NULL, 0); if (g->recoverypid > 0) waitpid (g->recoverypid, NULL, 0); g->fd[0] = -1; g->fd[1] = -1; @@ -874,88 +938,148 @@ guestfs__launch (guestfs_h *g) g->state = CONFIG; free (kernel); free (initrd); + free (appliance); return -1; } -/* This function is used to print the qemu command line before it gets - * executed, when in verbose mode. +/* Alternate attach method: instead of launching the appliance, + * connect to an existing unix socket. */ -static void -print_cmdline (guestfs_h *g) +static int +connect_unix_socket (guestfs_h *g, const char *sockpath) { - int i = 0; - int needs_quote; + int r; + struct sockaddr_un addr; - while (g->cmdline[i]) { - if (g->cmdline[i][0] == '-') /* -option starts a new line */ - fprintf (stderr, " \\\n "); + /* Start the clock ... */ + gettimeofday (&g->launch_t, NULL); - if (i > 0) fputc (' ', stderr); + /* Set these to nothing so we don't try to kill random processes or + * read from random file descriptors. + */ + g->pid = 0; + g->recoverypid = 0; + g->fd[0] = -1; + g->fd[1] = -1; - /* Does it need shell quoting? This only deals with simple cases. */ - needs_quote = strcspn (g->cmdline[i], " ") != strlen (g->cmdline[i]); + if (g->verbose) + guestfs___print_timestamped_message (g, "connecting to %s", sockpath); - if (needs_quote) fputc ('\'', stderr); - fprintf (stderr, "%s", g->cmdline[i]); - if (needs_quote) fputc ('\'', stderr); - i++; + g->sock = socket (AF_UNIX, SOCK_STREAM, 0); + if (g->sock == -1) { + perrorf (g, "socket"); + return -1; } - fputc ('\n', stderr); -} + addr.sun_family = AF_UNIX; + strncpy (addr.sun_path, sockpath, UNIX_PATH_MAX); + addr.sun_path[UNIX_PATH_MAX-1] = '\0'; -/* This function does the hard work of building the supermin appliance - * on the fly. 'path' is the directory containing the control files. - * 'kernel' and 'initrd' are where we will return the names of the - * kernel and initrd (only initrd is built). The work is done by - * an external script. We just tell it where to put the result. - */ -static int -build_supermin_appliance (guestfs_h *g, const char *path, - char **kernel, char **initrd) -{ - char cmd[4096]; - int r, len; + g->state = LAUNCHING; - if (g->verbose) - print_timestamped_message (g, "begin building supermin appliance"); + if (connect (g->sock, &addr, sizeof addr) == -1) { + perrorf (g, "bind"); + goto cleanup; + } - len = strlen (g->tmpdir); - *kernel = safe_malloc (g, len + 8); - snprintf (*kernel, len+8, "%s/kernel", g->tmpdir); - *initrd = safe_malloc (g, len + 8); - snprintf (*initrd, len+8, "%s/initrd", g->tmpdir); + if (fcntl (g->sock, F_SETFL, O_NONBLOCK) == -1) { + perrorf (g, "fcntl"); + goto cleanup; + } - /* Set a sensible umask in the subprocess, so kernel and initrd - * output files are world-readable (RHBZ#610880). - */ - snprintf (cmd, sizeof cmd, - "umask 0002; " - "febootstrap-supermin-helper%s " - "-k '%s/kmod.whitelist' " - "'%s/supermin.d' " - host_cpu " " - "%s %s", - g->verbose ? " --verbose" : "", - path, - path, - *kernel, *initrd); - if (g->verbose) - print_timestamped_message (g, "%s", cmd); - - r = system (cmd); - if (r == -1 || WEXITSTATUS(r) != 0) { - error (g, _("external command failed: %s"), cmd); - free (*kernel); - free (*initrd); - *kernel = *initrd = NULL; - return -1; + uint32_t size; + void *buf = NULL; + r = guestfs___recv_from_daemon (g, &size, &buf); + free (buf); + + if (r == -1) return -1; + + if (size != GUESTFS_LAUNCH_FLAG) { + error (g, _("guestfs_launch failed, unexpected initial message from guestfsd")); + goto cleanup; } if (g->verbose) - print_timestamped_message (g, "finished building supermin appliance"); + guestfs___print_timestamped_message (g, "connected"); + + if (g->state != READY) { + error (g, _("contacted guestfsd, but state != READY")); + goto cleanup; + } return 0; + + cleanup: + close (g->sock); + return -1; +} + +/* launch (of the ordinary appliance) generates approximate progress + * messages. Currently these are defined as follows: + * + * 0 / 12: launch clock starts + * 3 / 12: appliance created + * 6 / 12: detected that guest kernel started + * 9 / 12: detected that /init script is running + * 12 / 12: launch completed successfully + * + * Notes: + * (1) This is not a documented ABI and the behaviour may be changed + * or removed in future. + * (2) Messages are only sent if more than 5 seconds has elapsed + * since the launch clock started. + * (3) There is a gross hack in proto.c to make this work. + */ +void +guestfs___launch_send_progress (guestfs_h *g, int perdozen) +{ + struct timeval tv; + + gettimeofday (&tv, NULL); + if (timeval_diff (&g->launch_t, &tv) >= 5000) { + guestfs_progress progress_message = + { .proc = 0, .serial = 0, .position = perdozen, .total = 12 }; + + guestfs___progress_message_callback (g, &progress_message); + } +} + +/* Return the location of the tmpdir (eg. "/tmp") and allow users + * to override it at runtime using $TMPDIR. + * http://www.pathname.com/fhs/pub/fhs-2.3.html#TMPTEMPORARYFILES + */ +const char * +guestfs_tmpdir (void) +{ + const char *tmpdir; + +#ifdef P_tmpdir + tmpdir = P_tmpdir; +#else + tmpdir = "/tmp"; +#endif + + const char *t = getenv ("TMPDIR"); + if (t) tmpdir = t; + + return tmpdir; +} + +/* Return the location of the persistent tmpdir (eg. "/var/tmp") and + * allow users to override it at runtime using $TMPDIR. + * http://www.pathname.com/fhs/pub/fhs-2.3.html#VARTMPTEMPORARYFILESPRESERVEDBETWEE + */ +const char * +guestfs___persistent_tmpdir (void) +{ + const char *tmpdir; + + tmpdir = "/var/tmp"; + + const char *t = getenv ("TMPDIR"); + if (t) tmpdir = t; + + return tmpdir; } /* Compute Y - X and return the result in milliseconds. @@ -972,8 +1096,11 @@ timeval_diff (const struct timeval *x, const struct timeval *y) return msec; } -static void -print_timestamped_message (guestfs_h *g, const char *fs, ...) +/* Note that since this calls 'debug' it should only be called + * from the parent process. + */ +void +guestfs___print_timestamped_message (guestfs_h *g, const char *fs, ...) { va_list args; char *msg; @@ -988,12 +1115,42 @@ print_timestamped_message (guestfs_h *g, const char *fs, ...) gettimeofday (&tv, NULL); - fprintf (stderr, "[%05" PRIi64 "ms] %s\n", - timeval_diff (&g->launch_t, &tv), msg); + debug (g, "[%05" PRIi64 "ms] %s", timeval_diff (&g->launch_t, &tv), msg); free (msg); } +/* This is called from the forked subprocess just before qemu runs, so + * it can just print the message straight to stderr, where it will be + * picked up and funnelled through the usual appliance event API. + */ +static void +print_qemu_command_line (guestfs_h *g, char **argv) +{ + int i = 0; + int needs_quote; + + struct timeval tv; + gettimeofday (&tv, NULL); + fprintf (stderr, "[%05" PRIi64 "ms] ", timeval_diff (&g->launch_t, &tv)); + + while (argv[i]) { + if (argv[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 (argv[i], " ") != strlen (argv[i]); + + if (needs_quote) fputc ('\'', stderr); + fprintf (stderr, "%s", argv[i]); + if (needs_quote) fputc ('\'', stderr); + i++; + } +} + +static int test_qemu_cmd (guestfs_h *g, const char *cmd, char **ret); static int read_all (guestfs_h *g, FILE *fp, char **ret); /* Test qemu binary (or wrapper) runs, and do 'qemu -help' and @@ -1006,38 +1163,49 @@ test_qemu (guestfs_h *g) char cmd[1024]; FILE *fp; + free (g->qemu_help); + g->qemu_help = NULL; + free (g->qemu_version); + g->qemu_version = NULL; + snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -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); + if (test_qemu_cmd (g, cmd, &g->qemu_help) == -1) { + error (g, _("command failed: %s\n\nIf qemu is located on a non-standard path, try setting the LIBGUESTFS_QEMU\nenvironment variable. There may also be errors printed above."), + cmd); return -1; } - if (read_all (g, fp, &g->qemu_help) == -1) - goto error; + snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -version 2>/dev/null", + g->qemu); - if (pclose (fp) == -1) - goto error; + /* Intentionally ignore errors from qemu -version. */ + ignore_value (test_qemu_cmd (g, cmd, &g->qemu_version)); - snprintf (cmd, sizeof cmd, "LC_ALL=C '%s' -nographic -version 2>/dev/null", - g->qemu); + return 0; +} + +static int +test_qemu_cmd (guestfs_h *g, const char *cmd, char **ret) +{ + FILE *fp; fp = popen (cmd, "r"); - if (fp) { - /* Intentionally ignore errors. */ - read_all (g, fp, &g->qemu_version); + if (fp == NULL) + return -1; + + if (read_all (g, fp, ret) == -1) { pclose (fp); + return -1; } + if (pclose (fp) != 0) + return -1; + return 0; } @@ -1089,102 +1257,55 @@ qemu_supports (guestfs_h *g, const char *option) return strstr (g->qemu_help, option) != NULL; } +#if 0 +/* As above but using a regex instead of a fixed string. */ +static int +qemu_supports_re (guestfs_h *g, const pcre *option_regex) +{ + if (!g->qemu_help) { + if (test_qemu (g) == -1) + return -1; + } + + return match (g, g->qemu_help, option_regex); +} +#endif + /* Check if a file can be opened. */ static int is_openable (guestfs_h *g, const char *path, int flags) { int fd = open (path, flags); if (fd == -1) { - if (g->verbose) - perror (path); + debug (g, "is_openable: %s: %m", path); return 0; } close (fd); return 1; } -/* Check the peer effective UID for a TCP socket. Ideally we'd like - * SO_PEERCRED for a loopback TCP socket. This isn't possible on - * Linux (but it is on Solaris!) so we read /proc/net/tcp instead. - */ -static int -check_peer_euid (guestfs_h *g, int sock, uid_t *rtn) +static char * +qemu_drive_param (guestfs_h *g, const struct drive *drv) { -#if CAN_CHECK_PEER_EUID - struct sockaddr_in peer; - socklen_t addrlen = sizeof peer; - - if (getpeername (sock, (struct sockaddr *) &peer, &addrlen) == -1) { - perrorf (g, "getpeername"); - return -1; - } - - if (peer.sin_family != AF_INET || - ntohl (peer.sin_addr.s_addr) != INADDR_LOOPBACK) { - error (g, "check_peer_euid: unexpected connection from non-IPv4, non-loopback peer (family = %d, addr = %s)", - peer.sin_family, inet_ntoa (peer.sin_addr)); - return -1; - } - - struct sockaddr_in our; - addrlen = sizeof our; - if (getsockname (sock, (struct sockaddr *) &our, &addrlen) == -1) { - perrorf (g, "getsockname"); - return -1; - } + size_t len = 64; + char *r; - FILE *fp = fopen ("/proc/net/tcp", "r"); - if (fp == NULL) { - perrorf (g, "/proc/net/tcp"); - return -1; - } + len += strlen (drv->path); + len += strlen (drv->iface); + if (drv->format) + len += strlen (drv->format); - char line[256]; - if (fgets (line, sizeof line, fp) == NULL) { /* Drop first line. */ - error (g, "unexpected end of file in /proc/net/tcp"); - fclose (fp); - return -1; - } + r = safe_malloc (g, len); - while (fgets (line, sizeof line, fp) != NULL) { - unsigned line_our_addr, line_our_port, line_peer_addr, line_peer_port; - int dummy0, dummy1, dummy2, dummy3, dummy4, dummy5, dummy6; - int line_uid; - - if (sscanf (line, "%d:%08X:%04X %08X:%04X %02X %08X:%08X %02X:%08X %08X %d", - &dummy0, - &line_our_addr, &line_our_port, - &line_peer_addr, &line_peer_port, - &dummy1, &dummy2, &dummy3, &dummy4, &dummy5, &dummy6, - &line_uid) == 12) { - /* Note about /proc/net/tcp: local_address and rem_address are - * always in network byte order. However the port part is - * always in host byte order. - * - * The sockname and peername that we got above are in network - * byte order. So we have to byte swap the port but not the - * address part. - */ - if (line_our_addr == our.sin_addr.s_addr && - line_our_port == ntohs (our.sin_port) && - line_peer_addr == peer.sin_addr.s_addr && - line_peer_port == ntohs (peer.sin_port)) { - *rtn = line_uid; - fclose (fp); - return 0; - } - } - } + snprintf (r, len, "file=%s%s%s%s%s,if=%s", + drv->path, + drv->readonly ? ",snapshot=on" : "", + drv->use_cache_off ? ",cache=off" : "", + drv->format ? ",format=" : "", + drv->format ? drv->format : "", + drv->iface); - error (g, "check_peer_euid: no matching TCP connection found in /proc/net/tcp"); - fclose (fp); - return -1; -#else /* !CAN_CHECK_PEER_EUID */ - /* This function exists but should never be called in this - * configuration. - */ - abort (); -#endif /* !CAN_CHECK_PEER_EUID */ + return r; /* caller frees */ } /* You had to call this function after launch in versions <= 1.0.70, @@ -1209,8 +1330,7 @@ guestfs__kill_subprocess (guestfs_h *g) return -1; } - if (g->verbose) - fprintf (stderr, "sending SIGTERM to process %d\n", g->pid); + debug (g, "sending SIGTERM to process %d", g->pid); if (g->pid > 0) kill (g->pid, SIGTERM); if (g->recoverypid > 0) kill (g->recoverypid, 9);