[Qemu-devel] [PATCH 1/2] guest agent: add guest-file-open-pipe

[Michael Roth <mdroth@linux.vnet.ibm.com>]

Creates a FIFO pair that can be used with existing file read/write
interfaces to communicate with processes spawned via the forthcoming
guest-file-exec interface.

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>
---
 qapi-schema-guest.json     |   24 ++++++-
 qga/guest-agent-commands.c |  179 +++++++++++++++++++++++++++++++++++++------
 2 files changed, 177 insertions(+), 26 deletions(-)

diff --git a/qapi-schema-guest.json b/qapi-schema-guest.json
index fde5971..4c9f063 100644
--- a/qapi-schema-guest.json
+++ b/qapi-schema-guest.json
@@ -80,18 +80,40 @@
   'returns': 'int' }
 
 ##
+# @guest-file-open-pipe
+#
+# Open a pipe to in the guest to associated with a qga-spawned processes
+# for communication.
+#
+# Returns: Guest file handle on success, as per guest-file-open. This
+# handle is useable with the same interfaces as a handle returned by
+# guest-file-open.
+#
+# Since: 1.0.50
+##
+{ 'command': 'guest-file-open-pipe',
+  'returns': 'int' }
+
+##
 # @guest-file-close:
 #
 # Close an open file in the guest
 #
 # @handle: filehandle returned by guest-file-open
+# @pipe-end: #optional GuestFilePipeEnd value ("rw"/"w"/"r") to specify
+# which end of the pipe to close. Please note that closing the write
+# side of a pipe will block until the read side is closed. If you've
+# passed the read-side of the pipe to a qga-spawned process, make sure
+# the process as exited before attempting to close the write side.
 #
 # Returns: Nothing on success.
 #
 # Since: 0.15.0
 ##
+{ 'enum': 'GuestFilePipeEnd',
+  'data': [ 'r', 'w', 'rw' ] }
 { 'command': 'guest-file-close',
-  'data': { 'handle': 'int' } }
+  'data': { 'handle': 'int', '*pipe-end': 'GuestFilePipeEnd' } }
 
 ##
 # @guest-file-read:
diff --git a/qga/guest-agent-commands.c b/qga/guest-agent-commands.c
index 6da9904..ae77ee4 100644
--- a/qga/guest-agent-commands.c
+++ b/qga/guest-agent-commands.c
@@ -44,6 +44,34 @@ static void slog(const char *fmt, ...)
     va_end(ap);
 }
 
+static void toggle_flags(int fd, long flags, bool set, Error **err)
+{
+    int ret, old_flags;
+
+    old_flags = fcntl(fd, F_GETFL);
+    if (old_flags == -1) {
+        error_set(err, QERR_QGA_COMMAND_FAILED,
+                  "failed to fetch filehandle flags");
+        return;
+    }
+    ret = fcntl(fd, F_SETFL, set ? old_flags | flags : old_flags & ~flags);
+    if (ret == -1) {
+        error_set(err, QERR_QGA_COMMAND_FAILED,
+                  "failed to set filehandle flags");
+        return;
+    }
+}
+
+static void ftoggle_flags(FILE *fh, long flags, bool set, Error **err)
+{
+    int fd;
+    if (!fh || (fd = fileno(fh)) == -1) {
+        error_set(err, QERR_QGA_COMMAND_FAILED, "invalid filehandle");
+        return;
+    }
+    toggle_flags(fd, flags, set, err);
+}
+
 int64_t qmp_guest_sync(int64_t id, Error **errp)
 {
     return id;
@@ -102,7 +130,14 @@ void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
 
 typedef struct GuestFileHandle {
     uint64_t id;
-    FILE *fh;
+    bool is_pipe;
+    union {
+        FILE *fh;
+        struct {
+            FILE *in;
+            FILE *out;
+        } pipe;
+    } stream;
     QTAILQ_ENTRY(GuestFileHandle) next;
 } GuestFileHandle;
 
@@ -110,14 +145,31 @@ static struct {
     QTAILQ_HEAD(, GuestFileHandle) filehandles;
 } guest_file_state;
 
-static void guest_file_handle_add(FILE *fh)
+static uint64_t guest_file_handle_add(FILE *fh)
 {
     GuestFileHandle *gfh;
 
     gfh = g_malloc0(sizeof(GuestFileHandle));
     gfh->id = fileno(fh);
-    gfh->fh = fh;
+    gfh->is_pipe = false;
+    gfh->stream.fh = fh;
+
+    QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
+    return gfh->id;
+}
+
+static uint64_t guest_file_handle_add_pipe(FILE *in, FILE *out)
+{
+    GuestFileHandle *gfh;
+
+    gfh = g_malloc0(sizeof(GuestFileHandle));
+    gfh->id = fileno(in);
+    gfh->is_pipe = true;
+    gfh->stream.pipe.in = in;
+    gfh->stream.pipe.out = out;
+
     QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
+    return gfh->id;
 }
 
 static GuestFileHandle *guest_file_handle_find(int64_t id)
@@ -137,7 +189,6 @@ static GuestFileHandle *guest_file_handle_find(int64_t id)
 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
 {
     FILE *fh;
-    int fd;
     int64_t ret = -1;
 
     if (!has_mode) {
@@ -153,39 +204,112 @@ int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, E
     /* set fd non-blocking to avoid common use cases (like reading from a
      * named pipe) from hanging the agent
      */
-    fd = fileno(fh);
-    ret = fcntl(fd, F_GETFL);
-    ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
-    if (ret == -1) {
-        error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed");
+    ftoggle_flags(fh, O_NONBLOCK, true, err);
+    if (error_is_set(err)) {
         fclose(fh);
         return -1;
     }
 
-    guest_file_handle_add(fh);
-    slog("guest-file-open, handle: %d", fd);
-    return fd;
+    ret = guest_file_handle_add(fh);
+    slog("guest-file-open, handle: %ld", ret);
+    return ret;
 }
 
-void qmp_guest_file_close(int64_t handle, Error **err)
+int64_t qmp_guest_file_open_pipe(Error **err)
+{
+    FILE *fh[2];
+    int fd[2], i;
+    int64_t ret = -1;
+
+    slog("guest-file-open-pipe called");
+
+    ret = pipe(fd);
+    if (ret == -1) {
+        error_set(err, QERR_QGA_COMMAND_FAILED, "pipe() failed");
+        return -1;
+    }
+    for (i = 0; i < 2; i++) {
+        toggle_flags(fd[i], O_NONBLOCK, true, err);
+        if (error_is_set(err)) {
+            close(fd[i]);
+            return -1;
+        }
+    }
+
+    fh[0] = fdopen(fd[0], "r");
+    if (!fh[0]) {
+        error_set(err, QERR_OPEN_FILE_FAILED, "pipe (read-side)");
+        return -1;
+    }
+    fh[1] = fdopen(fd[1], "w");
+    if (!fh[1]) {
+        fclose(fh[0]);
+        error_set(err, QERR_OPEN_FILE_FAILED, "pipe (write-side)");
+        return -1;
+    }
+    ret = guest_file_handle_add_pipe(fh[1], fh[0]);
+    slog("guest-file-open-pipe, handle: %ld", ret);
+    return ret;
+}
+
+void qmp_guest_file_close(int64_t handle, bool has_pipe_end,
+                          GuestFilePipeEnd pipe_end, Error **err)
 {
     GuestFileHandle *gfh = guest_file_handle_find(handle);
     int ret;
+    bool remove = false;
 
-    slog("guest-file-close called, handle: %ld", handle);
+    slog("guest-file-close called, handle: %ld, pipe: %d, pipe_end: %d", handle,
+         has_pipe_end, pipe_end);
     if (!gfh) {
         error_set(err, QERR_FD_NOT_FOUND, "handle");
         return;
     }
 
-    ret = fclose(gfh->fh);
-    if (ret == -1) {
-        error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed");
-        return;
+    if (gfh->is_pipe) {
+        if (!has_pipe_end) {
+            pipe_end = GUEST_FILE_PIPE_END_RW;
+        }
+        if ((pipe_end == GUEST_FILE_PIPE_END_RW ||
+             pipe_end == GUEST_FILE_PIPE_END_R) &&
+            gfh->stream.pipe.out) {
+            g_debug("closing pipe (read-side)...");
+            ret = fclose(gfh->stream.pipe.out);
+            g_debug("done closing pipe.");
+            if (ret == -1) {
+                error_set(err, QERR_INVALID_PARAMETER, "pipe (read-side)");
+                goto out_err;
+            }
+            gfh->stream.pipe.out = NULL;
+        }
+        if ((pipe_end == GUEST_FILE_PIPE_END_RW ||
+             pipe_end == GUEST_FILE_PIPE_END_W) &&
+            gfh->stream.pipe.in) {
+            g_debug("closing pipe (write-side)...");
+            ret = fclose(gfh->stream.pipe.in);
+            g_debug("done closing pipe.");
+            if (ret == -1) {
+                error_set(err, QERR_INVALID_PARAMETER, "pipe (write-side)");
+                goto out_err;
+            }
+            gfh->stream.pipe.in = NULL;
+        }
+        remove = !gfh->stream.pipe.in && !gfh->stream.pipe.out;
+    } else {
+        ret = fclose(gfh->stream.fh);
+        if (ret == -1) {
+            error_set(err, QERR_INVALID_PARAMETER, "filehandle");
+            goto out_err;
+        }
+        gfh->stream.fh = NULL;
+        remove = true;
     }
 
-    QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
-    g_free(gfh);
+out_err:
+    if (remove) {
+        QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
+        g_free(gfh);
+    }
 }
 
 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
@@ -209,10 +333,10 @@ struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
         return NULL;
     }
 
-    fh = gfh->fh;
+    fh = gfh->is_pipe ? gfh->stream.pipe.out : gfh->stream.fh;
     buf = g_malloc0(count+1);
     read_count = fread(buf, 1, count, fh);
-    if (ferror(fh)) {
+    if (0 && read_count == 0 && !feof(fh) && ferror(fh)) {
         slog("guest-file-read failed, handle: %ld", handle);
         error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed");
     } else {
@@ -245,7 +369,7 @@ GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
         return NULL;
     }
 
-    fh = gfh->fh;
+    fh = gfh->is_pipe ? gfh->stream.pipe.in : gfh->stream.fh;
     buf = g_base64_decode(buf_b64, &buf_len);
 
     if (!has_count) {
@@ -284,7 +408,12 @@ struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
         return NULL;
     }
 
-    fh = gfh->fh;
+    if (gfh->is_pipe) {
+        error_set(err, QERR_QGA_COMMAND_FAILED, "cannot seek on a pipe");
+        return NULL;
+    }
+
+    fh = gfh->stream.fh;
     ret = fseek(fh, offset, whence);
     if (ret == -1) {
         error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
@@ -309,7 +438,7 @@ void qmp_guest_file_flush(int64_t handle, Error **err)
         return;
     }
 
-    fh = gfh->fh;
+    fh = gfh->is_pipe ? gfh->stream.pipe.in : gfh->stream.fh;
     ret = fflush(fh);
     if (ret == EOF) {
         error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
-- 
1.7.4.1