#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
#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);
/* 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;
};
}
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) {
}
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) {
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;
+ }
}
- /* cache=off improves reliability in the event of a host crash. */
- snprintf (buf, len, "file=%s,cache=off,if=%s", filename, DRIVE_IF);
-
return guestfs_config (g, "-drive", buf);
}
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]);
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;
}
/* 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)
if (buf) {
*buf = safe_realloc (g, *buf, len + ctx.chunks[i].data.data_len);
- memcpy (*buf+len, ctx.chunks[i].data.data_val,
+ memcpy (((char *)*buf)+len, ctx.chunks[i].data.data_val,
ctx.chunks[i].data.data_len);
}
len += ctx.chunks[i].data.data_len;
}
static int
+__attribute__((noreturn))
select_add_timeout (guestfs_main_loop *mlv, guestfs_h *g, int interval,
guestfs_handle_timeout_cb cb, void *data)
{
}
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;