/* libguestfs - the guestfsd daemon
- * Copyright (C) 2009 Red Hat Inc.
+ * Copyright (C) 2009-2011 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
+#include <signal.h>
#include <inttypes.h>
#include <unistd.h>
#include <errno.h>
sock = _sock;
for (;;) {
- /* Most common errors are leaked memory and leaked file descriptors,
- * so run this between each command:
- */
- if (verbose && 0)
- ignore_value (system ("ls -l /proc/self/fd"));
-
/* Read the length word. */
if (xread (sock, lenbuf, 4) == -1)
exit (EXIT_FAILURE);
xdr_u_int (&xdr, &len);
xdr_destroy (&xdr);
+ if (verbose)
+ fprintf (stderr,
+ "guestfsd: main_loop: new request, len 0x%" PRIx32 "\n",
+ len);
+
if (len > GUESTFS_MESSAGE_MAX) {
fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
len);
end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec;
elapsed_us = end_us - start_us;
- fprintf (stderr, "proc %d (%s) took %d.%02d seconds\n",
+ fprintf (stderr,
+ "guestfsd: main_loop: proc %d (%s) took %d.%02d seconds\n",
proc_nr,
proc_nr >= 0 && proc_nr < GUESTFS_PROC_NR_PROCS
? function_names[proc_nr] : "UNKNOWN PROCEDURE",
xdr_destroy (&xdr);
if (xwrite (sock, lenbuf, 4) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
if (xwrite (sock, buf, len) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
}
xdr_destroy (&xdr);
if (xwrite (sock, lenbuf, 4) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
if (xwrite (sock, buf, len) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
}
for (;;) {
if (verbose)
- fprintf (stderr, "receive_file: reading length word\n");
+ fprintf (stderr, "guestfsd: receive_file: reading length word\n");
/* Read the length word. */
if (xread (sock, lenbuf, 4) == -1)
if (verbose)
fprintf (stderr,
- "receive_file: got chunk: cancel = 0x%x, len = %d, buf = %p\n",
+ "guestfsd: receive_file: got chunk: cancel = 0x%x, len = %d, buf = %p\n",
chunk.cancel, chunk.data.data_len, chunk.data.data_val);
+ if (chunk.cancel != 0 && chunk.cancel != 1) {
+ fprintf (stderr,
+ "guestfsd: receive_file: chunk.cancel != [0|1] ... "
+ "continuing even though we have probably lost synchronization with the library\n");
+ return -1;
+ }
+
if (chunk.cancel) {
if (verbose)
- fprintf (stderr, "receive_file: received cancellation from library\n");
+ fprintf (stderr,
+ "guestfsd: receive_file: received cancellation from library\n");
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
return -2;
}
if (chunk.data.data_len == 0) {
if (verbose)
- fprintf (stderr, "receive_file: end of file, leaving function\n");
+ fprintf (stderr,
+ "guestfsd: receive_file: end of file, leaving function\n");
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
return 0; /* end of file */
}
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
if (r == -1) { /* write error */
if (verbose)
- fprintf (stderr, "receive_file: write error\n");
+ fprintf (stderr, "guestfsd: receive_file: write error\n");
return -1;
}
}
int cancel;
if (len > GUESTFS_MAX_CHUNK_SIZE) {
- fprintf (stderr, "send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
+ fprintf (stderr, "guestfsd: send_file_write: len (%d) > GUESTFS_MAX_CHUNK_SIZE (%d)\n",
len, GUESTFS_MAX_CHUNK_SIZE);
return -1;
}
xdr_destroy (&xdr);
if (flag != GUESTFS_CANCEL_FLAG) {
- fprintf (stderr, "check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
+ fprintf (stderr, "guestfsd: check_for_library_cancellation: read 0x%x from library, expected 0x%x\n",
flag, GUESTFS_CANCEL_FLAG);
return 0;
}
xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {
- fprintf (stderr, "send_chunk: failed to encode chunk\n");
+ fprintf (stderr, "guestfsd: send_chunk: failed to encode chunk\n");
xdr_destroy (&xdr);
return -1;
}
int err = (xwrite (sock, lenbuf, 4) == 0
&& xwrite (sock, buf, len) == 0 ? 0 : -1);
if (err) {
- fprintf (stderr, "send_chunk: write failed\n");
+ fprintf (stderr, "guestfsd: send_chunk: write failed\n");
exit (EXIT_FAILURE);
}
xdr_destroy (&xdr);
if (xwrite (sock, buf, 4) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
if (!xdr_guestfs_progress (&xdr, &message)) {
- fprintf (stderr, "xdr_guestfs_progress: failed to encode message\n");
+ fprintf (stderr, "guestfsd: xdr_guestfs_progress: failed to encode message\n");
xdr_destroy (&xdr);
return;
}
xdr_destroy (&xdr);
if (xwrite (sock, buf, len) == -1) {
- fprintf (stderr, "xwrite failed\n");
+ fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
}
+
+/* "Pulse mode" progress messages. */
+
+#if defined(HAVE_SETITIMER) && defined(HAVE_SIGACTION)
+
+static void async_safe_send_pulse (int sig);
+
+void
+pulse_mode_start (void)
+{
+ struct sigaction act;
+ struct itimerval it;
+
+ memset (&act, 0, sizeof act);
+ act.sa_handler = async_safe_send_pulse;
+ act.sa_flags = SA_RESTART;
+
+ if (sigaction (SIGALRM, &act, NULL) == -1) {
+ perror ("pulse_mode_start: sigaction");
+ return;
+ }
+
+ it.it_value.tv_sec = NOTIFICATION_INITIAL_DELAY / 1000000;
+ it.it_value.tv_usec = NOTIFICATION_INITIAL_DELAY % 1000000;
+ it.it_interval.tv_sec = NOTIFICATION_PERIOD / 1000000;
+ it.it_interval.tv_usec = NOTIFICATION_PERIOD % 1000000;
+
+ if (setitimer (ITIMER_REAL, &it, NULL) == -1)
+ perror ("pulse_mode_start: setitimer");
+}
+
+void
+pulse_mode_end (void)
+{
+ pulse_mode_cancel (); /* Cancel the itimer. */
+
+ notify_progress (1, 1);
+}
+
+void
+pulse_mode_cancel (void)
+{
+ int err = errno; /* Function must preserve errno. */
+ struct itimerval it;
+ struct sigaction act;
+
+ /* Setting it_value to zero cancels the itimer. */
+ it.it_value.tv_sec = 0;
+ it.it_value.tv_usec = 0;
+ it.it_interval.tv_sec = 0;
+ it.it_interval.tv_usec = 0;
+
+ if (setitimer (ITIMER_REAL, &it, NULL) == -1)
+ perror ("pulse_mode_cancel: setitimer");
+
+ memset (&act, 0, sizeof act);
+ act.sa_handler = SIG_DFL;
+
+ if (sigaction (SIGALRM, &act, NULL) == -1)
+ perror ("pulse_mode_cancel: sigaction");
+
+ errno = err;
+}
+
+/* Send a position = 0, total = 1 (pulse mode) message. The tricky
+ * part is we have to do it without invoking any non-async-safe
+ * functions (see signal(7) for a list). Therefore, KISS.
+ */
+static void
+async_safe_send_pulse (int sig)
+{
+ /* XDR is a RFC ... */
+ unsigned char msg[] = {
+ (GUESTFS_PROGRESS_FLAG & 0xff000000) >> 24,
+ (GUESTFS_PROGRESS_FLAG & 0x00ff0000) >> 16,
+ (GUESTFS_PROGRESS_FLAG & 0x0000ff00) >> 8,
+ GUESTFS_PROGRESS_FLAG & 0x000000ff,
+ (proc_nr & 0xff000000) >> 24,
+ (proc_nr & 0x00ff0000) >> 16,
+ (proc_nr & 0x0000ff00) >> 8,
+ proc_nr & 0x000000ff,
+ (serial & 0xff000000) >> 24,
+ (serial & 0x00ff0000) >> 16,
+ (serial & 0x0000ff00) >> 8,
+ serial & 0x000000ff,
+ /* 64 bit position = 0 */ 0, 0, 0, 0, 0, 0, 0, 0,
+ /* 64 bit total = 1 */ 0, 0, 0, 0, 0, 0, 0, 1
+ };
+
+ if (xwrite (sock, msg, sizeof msg) == -1)
+ exit (EXIT_FAILURE);
+}
+
+#else /* !HAVE_SETITIMER || !HAVE_SIGACTION */
+
+void
+pulse_mode_start (void)
+{
+ /* empty */
+}
+
+void
+pulse_mode_end (void)
+{
+ /* empty */
+}
+
+void
+pulse_mode_cancel (void)
+{
+ /* empty */
+}
+
+#endif /* !HAVE_SETITIMER || !HAVE_SIGACTION */
git.annexia.org / libguestfs.git / blobdiff