X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;ds=inline;f=src%2Fguestfs.c;h=73419a64b85d1c210309dbd5498dccb5e770e813;hb=18bf945023071d5d4ec8d96e25142e0ffd066e7c;hp=dec9a1b0da5cb3f2c83b3a70845f52be4ba44a1d;hpb=c5b2282111ead9a0c59db5f40229d20fe0203681;p=libguestfs.git diff --git a/src/guestfs.c b/src/guestfs.c index dec9a1b..73419a6 100644 --- a/src/guestfs.c +++ b/src/guestfs.c @@ -29,7 +29,9 @@ #include #include #include +#include #include + #include #include @@ -632,7 +634,7 @@ int guestfs_launch (guestfs_h *g) { static const char *dir_template = "/tmp/libguestfsXXXXXX"; - int r, i, len, pmore; + int r, i, len, pmore, memsize; int wfd[2], rfd[2]; int tries; const char *kernel_name = "vmlinuz." REPO "." host_cpu; @@ -641,6 +643,7 @@ guestfs_launch (guestfs_h *g) char *kernel = NULL, *initrd = NULL; char unixsock[256]; struct sockaddr_un addr; + struct stat statbuf; /* Configured? */ if (!g->cmdline) { @@ -700,6 +703,40 @@ guestfs_launch (guestfs_h *g) goto cleanup0; } + /* Choose a suitable memory size (in MB). This is more art + * than science, but you can help by doing + * ./configure --enable-debug-command + * and then running: + * debug sh free + * debug mem '' + * and seeing how much free memory is left for particular + * configurations. + * + * It's also helpful to report both the compressed and uncompressed + * size of the initramfs (ls -lh initramfs*.img; du -sh initramfs). + * + * XXX KVM virtio balloon driver? + */ + if (stat (initrd, &statbuf) != -1) { + /* Approximate size of the initramfs after it is decompressed + * in kernel memory. The compression factor is ~2.5-3. + */ + memsize = 3 * statbuf.st_size / 1024 / 1024; + + /* Approximate size used by the kernel. */ + memsize += 10; + + /* Want to give userspace some room, so: */ + memsize += 128; + +#if SIZEOF_LONG == 8 + /* On 64 bit, assume some overhead. */ + memsize += 64; +#endif + } else + memsize = 512; + + /* Make the temporary directory containing the socket. */ if (!g->tmpdir) { g->tmpdir = safe_strdup (g, dir_template); @@ -730,6 +767,7 @@ guestfs_launch (guestfs_h *g) if (r == 0) { /* Child (qemu). */ char vmchannel[256]; char append[256]; + char memsize_str[256]; /* Set up the full command line. Do this in the subprocess so we * don't need to worry about cleaning up. @@ -747,8 +785,10 @@ guestfs_launch (guestfs_h *g) 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 @@ -1452,7 +1492,6 @@ int guestfs__send_sync (guestfs_h *g, int proc_nr, xdrproc_t xdrp, char *args) { - char buffer[GUESTFS_MESSAGE_MAX]; struct guestfs_message_header hdr; XDR xdr; unsigned len; @@ -1465,6 +1504,23 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, 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; @@ -1473,10 +1529,9 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, hdr.serial = serial; hdr.status = GUESTFS_STATUS_OK; - xdrmem_create (&xdr, buffer, sizeof buffer, XDR_ENCODE); if (!xdr_guestfs_message_header (&xdr, &hdr)) { error (g, "xdr_guestfs_message_header failed"); - return -1; + goto cleanup1; } /* Serialize the args. If any, because some message types @@ -1485,24 +1540,23 @@ guestfs__send_sync (guestfs_h *g, int proc_nr, if (xdrp) { if (!(*xdrp) (&xdr, args)) { error (g, "dispatch failed to marshal args"); - return -1; + goto cleanup1; } } + /* Get the actual length of the message, resize the buffer to match + * the actual length, and write the length word at the beginning. + */ len = xdr_getpos (&xdr); xdr_destroy (&xdr); - /* Allocate the outgoing message buffer. */ - g->msg_out = safe_malloc (g, len + 4); - + g->msg_out = safe_realloc (g, g->msg_out, len + 4); g->msg_out_size = len + 4; g->msg_out_pos = 0; xdrmem_create (&xdr, g->msg_out, 4, XDR_ENCODE); xdr_uint32_t (&xdr, &len); - memcpy (g->msg_out + 4, buffer, len); - if (guestfs__switch_to_sending (g) == -1) goto cleanup1; @@ -1613,10 +1667,9 @@ send_file_complete_sync (guestfs_h *g) static int check_for_daemon_cancellation (guestfs_h *g); static int -send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len) +send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t buflen) { - char data[GUESTFS_MAX_CHUNK_SIZE + 48]; - unsigned datalen; + unsigned len; int sent; guestfs_chunk chunk; XDR xdr; @@ -1627,6 +1680,14 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len) 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) @@ -1634,35 +1695,34 @@ send_file_chunk_sync (guestfs_h *g, int cancel, const char *buf, size_t len) return -2; } + /* Allocate the chunk buffer. Don't use the stack to avoid + * excessive stack usage and unnecessary copies. + */ + g->msg_out = safe_malloc (g, GUESTFS_MAX_CHUNK_SIZE + 4 + 48); + xdrmem_create (&xdr, g->msg_out + 4, GUESTFS_MAX_CHUNK_SIZE + 48, XDR_ENCODE); + /* Serialize the chunk. */ chunk.cancel = cancel; - chunk.data.data_len = len; + chunk.data.data_len = buflen; chunk.data.data_val = (char *) buf; - if (g->verbose) - fprintf (stderr, - "library sending chunk cancel = %d, len = %zu, buf = %p\n", - cancel, len, buf); - - xdrmem_create (&xdr, data, sizeof data, XDR_ENCODE); if (!xdr_guestfs_chunk (&xdr, &chunk)) { - error (g, "xdr_guestfs_chunk failed (buf = %p, len = %zu)", buf, len); + error (g, "xdr_guestfs_chunk failed (buf = %p, buflen = %zu)", + buf, buflen); xdr_destroy (&xdr); - return -1; + goto cleanup1; } - datalen = xdr_getpos (&xdr); + len = xdr_getpos (&xdr); xdr_destroy (&xdr); - /* Allocate outgoing message buffer. */ - g->msg_out = safe_malloc (g, datalen + 4); - g->msg_out_size = datalen + 4; + /* 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, &datalen); - - memcpy (g->msg_out + 4, data, datalen); + xdr_uint32_t (&xdr, &len); if (guestfs__switch_to_sending (g) == -1) goto cleanup1;