From patchwork Thu May 21 05:49:25 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Denis V. Lunev" X-Patchwork-Id: 474798 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id E6211140187 for ; Thu, 21 May 2015 15:48:58 +1000 (AEST) Received: from localhost ([::1]:55062 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YvJLl-0006YJ-2g for incoming@patchwork.ozlabs.org; Thu, 21 May 2015 01:48:57 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:51809) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YvJL9-0005S0-Sa for qemu-devel@nongnu.org; Thu, 21 May 2015 01:48:21 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YvJL8-0001KL-BU for qemu-devel@nongnu.org; Thu, 21 May 2015 01:48:19 -0400 Received: from mailhub.sw.ru ([195.214.232.25]:46201 helo=relay.sw.ru) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YvJL7-0001Jz-Pz for qemu-devel@nongnu.org; Thu, 21 May 2015 01:48:18 -0400 Received: from hades.sw.ru ([10.30.8.132]) by relay.sw.ru (8.13.4/8.13.4) with ESMTP id t4L5m6nj003297; Thu, 21 May 2015 08:48:12 +0300 (MSK) From: "Denis V. Lunev" To: Date: Thu, 21 May 2015 08:49:25 +0300 Message-Id: <1432187369-28020-3-git-send-email-den@openvz.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1432187369-28020-1-git-send-email-den@openvz.org> References: <1432187369-28020-1-git-send-email-den@openvz.org> X-detected-operating-system: by eggs.gnu.org: OpenBSD 3.x X-Received-From: 195.214.232.25 Cc: Roman Kagan , Olga Krishtal , Michael Roth , qemu-devel@nongnu.org, "Denis V. Lunev" Subject: [Qemu-devel] [PATCH 2/6] qga: implement guest-pipe-open command X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org From: Olga Krishtal The command creates 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: Olga Krishtal Signed-off-by: Denis V. Lunev CC: Roman Kagan CC: Eric Blake CC: Michael Roth --- qga/commands-posix.c | 96 +++++++++++++++++++++++++++++++++++++++++++++++++--- qga/commands-win32.c | 8 ++++- qga/qapi-schema.json | 44 ++++++++++++++++++++++++ 3 files changed, 143 insertions(+), 5 deletions(-) diff --git a/qga/commands-posix.c b/qga/commands-posix.c index d0f371b..a616996 100644 --- a/qga/commands-posix.c +++ b/qga/commands-posix.c @@ -212,6 +212,7 @@ void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp) typedef struct GuestFileHandle { uint64_t id; FILE *fh; + int pipe_other_end_fd; /* if set, it's a pipe fd of the other end. */ QTAILQ_ENTRY(GuestFileHandle) next; } GuestFileHandle; @@ -219,7 +220,8 @@ static struct { QTAILQ_HEAD(, GuestFileHandle) filehandles; } guest_file_state; -static int64_t guest_file_handle_add(FILE *fh, Error **errp) +static int64_t guest_file_handle_add(FILE *fh, int pipe_other_end_fd, + Error **errp) { GuestFileHandle *gfh; int64_t handle; @@ -232,6 +234,7 @@ static int64_t guest_file_handle_add(FILE *fh, Error **errp) gfh = g_malloc0(sizeof(GuestFileHandle)); gfh->id = handle; gfh->fh = fh; + gfh->pipe_other_end_fd = pipe_other_end_fd; QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); return handle; @@ -399,7 +402,7 @@ int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, */ qemu_set_nonblock(fileno(fh)); - handle = guest_file_handle_add(fh, errp); + handle = guest_file_handle_add(fh, -1, errp); if (handle < 0) { fclose(fh); return -1; @@ -409,6 +412,85 @@ int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, return handle; } +GuestPipeInfoList *qmp_guest_pipe_open(GuestPipeMode mode, Error **errp) +{ + FILE *f = NULL; + int fd[2], this_end, other_end; + int64_t handle; + GuestPipeInfoList *pipe_list; + GuestPipeInfo *pipe_inf; + const char *op_flag; + + slog("guest-pipe-open called"); + + if (mode > 2) { + error_set(errp, ERROR_CLASS_GENERIC_ERROR, + "Only \"r\" or \"w\" are the valid modes to open a pipe"); + return NULL; + } + + if (pipe(fd) != 0) { + error_set_errno(errp, errno, QERR_QGA_COMMAND_FAILED, "pipe() failed"); + return NULL; + } + + this_end = (mode == GUEST_PIPE_MODE_WRITE); + other_end = !this_end; + + qemu_set_nonblock(fd[this_end]); + + qemu_set_cloexec(fd[this_end]); + qemu_set_cloexec(fd[other_end]); + + if (mode == GUEST_PIPE_MODE_READ) { + op_flag = "r"; + } else { + op_flag = "w"; + } + f = fdopen(fd[this_end], op_flag); + if (f == NULL) { + error_set_errno(errp, errno, QERR_QGA_COMMAND_FAILED, + "fdopen() failed to open pipe handle"); + goto fail; + } + + handle = guest_file_handle_add(f, fd[other_end], errp); + if (handle == -1) { + goto fail; + } + + slog("guest-pipe-open: handle: %" PRId64, handle); + + pipe_inf = g_malloc0(sizeof(*pipe_inf)); + pipe_inf->fd = handle; + pipe_list = g_malloc0(sizeof(*pipe_list)); + pipe_list->value = pipe_inf; + pipe_list->next = NULL; + return pipe_list; + +fail: + if (f != NULL) { + fclose(f); + } else { + close(fd[this_end]); + } + close(fd[other_end]); + return NULL; +} + +static int guest_pipe_close_other_end(GuestFileHandle *gfh) +{ + if (gfh->pipe_other_end_fd != -1) { + if (close(gfh->pipe_other_end_fd) != 0) { + return 1; + } + + gfh->pipe_other_end_fd = -1; + } + + return 0; +} + void qmp_guest_file_close(int64_t handle, Error **errp) { GuestFileHandle *gfh = guest_file_handle_find(handle, errp); @@ -419,6 +501,11 @@ void qmp_guest_file_close(int64_t handle, Error **errp) return; } + if (guest_pipe_close_other_end(gfh) != 0) { + error_setg_errno(errp, errno, "failed to close pipe handle"); + return; + } + ret = fclose(gfh->fh); if (ret == EOF) { error_setg_errno(errp, errno, "failed to close handle"); @@ -2395,7 +2482,7 @@ GList *ga_command_blacklist_init(GList *blacklist) "guest-suspend-hybrid", "guest-network-get-interfaces", "guest-get-vcpus", "guest-set-vcpus", "guest-get-memory-blocks", "guest-set-memory-blocks", - "guest-get-memory-block-size", NULL}; + "guest-get-memory-block-size", "guest-pipe-open", NULL}; char **p = (char **)list; while (*p) { @@ -2409,7 +2496,8 @@ GList *ga_command_blacklist_init(GList *blacklist) const char *list[] = { "guest-get-fsinfo", "guest-fsfreeze-status", "guest-fsfreeze-freeze", "guest-fsfreeze-freeze-list", - "guest-fsfreeze-thaw", "guest-get-fsinfo", NULL}; + "guest-fsfreeze-thaw", "guest-get-fsinfo", + "guest-pipe-open", NULL}; char **p = (char **)list; while (*p) { diff --git a/qga/commands-win32.c b/qga/commands-win32.c index 3ef0549..685dd0f 100644 --- a/qga/commands-win32.c +++ b/qga/commands-win32.c @@ -154,6 +154,12 @@ int64_t qmp_guest_file_open(const char *path, bool has_mode, return fd; } +GuestPipeInfoList *qmp_guest_pipe_open(GuestPipeMode mode, Error **errp) +{ + error_set(errp, QERR_UNSUPPORTED); + return NULL; +} + void qmp_guest_file_close(int64_t handle, Error **errp) { bool ret; @@ -713,7 +719,7 @@ GList *ga_command_blacklist_init(GList *blacklist) "guest-get-memory-blocks", "guest-set-memory-blocks", "guest-get-memory-block-size", "guest-fsfreeze-freeze-list", "guest-get-fsinfo", - "guest-fstrim", NULL}; + "guest-fstrim", "guest-pipe-open", NULL}; char **p = (char **)list_unsupported; while (*p) { diff --git a/qga/qapi-schema.json b/qga/qapi-schema.json index b446dc7..8081213 100644 --- a/qga/qapi-schema.json +++ b/qga/qapi-schema.json @@ -215,12 +215,56 @@ 'returns': 'int' } ## +# @GuestPipeMode +# +# An enumeration of pipe modes +# read: pipe is opened for writing data +# write: pipe is opened for reading data +# +# Since: 2.4 +## +{ 'enum': 'GuestPipeMode', + 'data': [ 'read', 'write' ] } + +## +# @GuestPipeInfo +# +# Information about pipe. +# +# Since: 2.4 +## +{ 'struct': 'GuestPipeInfo', + 'data': {'fd': 'int'} } + +## +# @guest-pipe-open +# +# 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 usable with the same interfaces as a handle returned by +# guest-file-open. +# +# Since: 2.4 +## +{ 'command': 'guest-pipe-open', + 'data': { 'mode': 'GuestPipeMode' }, + 'returns': ['GuestPipeInfo'] } + +## +## # @guest-file-close: # # Close an open file in the guest # # @handle: filehandle returned by guest-file-open # +# Please note that closing the write side of a pipe will block until the read +# side is closed. If you passed the read-side of the pipe to a qga-spawned +# process, make sure the process has exited before attempting to close the +# write side. +# # Returns: Nothing on success. # # Since: 0.15.0