From patchwork Thu Jan 4 09:00:23 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510899 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 74B96C4707B for ; Thu, 4 Jan 2024 09:01:21 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661122.1030821 (Exim 4.92) (envelope-from ) id 1rLJbA-0007p5-CJ; Thu, 04 Jan 2024 09:01:08 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661122.1030821; Thu, 04 Jan 2024 09:01:08 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbA-0007ow-9h; Thu, 04 Jan 2024 09:01:08 +0000 Received: by outflank-mailman (input) for mailman id 661122; Thu, 04 Jan 2024 09:01:07 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJb9-0007Zm-1w for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:07 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id cae1fdd1-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:01:05 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 2679921F8C; Thu, 4 Jan 2024 09:01:05 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 0333D13722; Thu, 4 Jan 2024 09:01:04 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id 86syO9BzlmV2WAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:04 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: cae1fdd1-aadf-11ee-9b0f-b553b5be7939 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 01/33] tools: add access macros for unaligned data Date: Thu, 4 Jan 2024 10:00:23 +0100 Message-Id: <20240104090055.27323-2-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 2679921F8C Add the basic access macros for unaligned data to common-macros.h. Signed-off-by: Juergen Gross Acked-by: Andrew Cooper --- V3: - new patch --- tools/include/xen-tools/common-macros.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tools/include/xen-tools/common-macros.h b/tools/include/xen-tools/common-macros.h index e5ed603904..81fba2e9f5 100644 --- a/tools/include/xen-tools/common-macros.h +++ b/tools/include/xen-tools/common-macros.h @@ -79,6 +79,10 @@ #define __must_check __attribute__((__warn_unused_result__)) #endif +#ifndef __packed +#define __packed __attribute__((__packed__)) +#endif + #define container_of(ptr, type, member) ({ \ typeof(((type *)0)->member) *mptr__ = (ptr); \ (type *)((char *)mptr__ - offsetof(type, member)); \ @@ -87,4 +91,17 @@ #define __AC(X, Y) (X ## Y) #define _AC(X, Y) __AC(X, Y) +#define get_unaligned_t(type, ptr) ({ \ + const struct { type x; } __packed *ptr_ = (typeof(ptr_))(ptr); \ + ptr_->x; \ +}) + +#define put_unaligned_t(type, val, ptr) do { \ + struct { type x; } __packed *ptr_ = (typeof(ptr_))(ptr); \ + ptr_->x = val; \ +} while (0) + +#define get_unaligned(ptr) get_unaligned_t(typeof(*(ptr)), ptr) +#define put_unaligned(val, ptr) put_unaligned_t(typeof(*(ptr)), val, ptr) + #endif /* __XEN_TOOLS_COMMON_MACROS__ */ From patchwork Thu Jan 4 09:00:24 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510900 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7E6ACC4707C for ; Thu, 4 Jan 2024 09:01:21 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661123.1030831 (Exim 4.92) (envelope-from ) id 1rLJbE-00086i-Nz; Thu, 04 Jan 2024 09:01:12 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661123.1030831; Thu, 04 Jan 2024 09:01:12 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbE-00086Z-Kt; Thu, 04 Jan 2024 09:01:12 +0000 Received: by outflank-mailman (input) for mailman id 661123; Thu, 04 Jan 2024 09:01:11 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbD-00085z-Ri for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:11 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id ce16e9ce-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:10 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 9B22C21F94; Thu, 4 Jan 2024 09:01:10 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 7B83813722; Thu, 4 Jan 2024 09:01:10 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id PV71HNZzlmWHWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:10 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: ce16e9ce-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Jason Andryuk Subject: [PATCH v3 02/33] xen/public: add some more 9pfs xenstore paths Date: Thu, 4 Jan 2024 10:00:24 +0100 Message-Id: <20240104090055.27323-3-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: 9B22C21F94 Add some optional additional backend paths for 9pfs PV devices. Those paths will be supported by the new xen-9pfsd 9pfs backend. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- xen/include/public/io/9pfs.h | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/xen/include/public/io/9pfs.h b/xen/include/public/io/9pfs.h index 9ad2773082..ac4bf0434b 100644 --- a/xen/include/public/io/9pfs.h +++ b/xen/include/public/io/9pfs.h @@ -71,6 +71,40 @@ * created on the guest (no user ownership squash or remap) * Only "none" is supported in this version of the protocol. * + * max-files + * Values: + * + * The maximum number of files (including directories) allowed for + * this device. Backend support of this node is optional. If the node + * is not present or the value is zero the number of files is not + * limited. + * + * max-open-files + * Values: + * + * The maximum number of files the guest is allowed to have opened + * concurrently. Multiple concurrent opens of the same file are counted + * individually. Backend support of this node is optional. If the node + * is not present or the value is zero a backend specific default is + * applied. + * + * max-space + * Values: + * + * The maximum file space in MiBs the guest is allowed to use for this + * device. Backend support of this node is optional. If the node is + * not present or the value is zero the space is not limited. + * + * auto-delete + * Values: + * + * When set to "1" the backend will delete the file with the oldest + * modification date below in case the allowed maximum file + * space (see ) or file number (see ) is being + * exceeded due to guest activity (creation or extension of files). + * Files currently opened by the guest won't be deleted. Backend + * support of this node is optional. + * ****************************************************************************** * Frontend XenBus Nodes ****************************************************************************** From patchwork Thu Jan 4 09:00:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510901 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 08BBFC47074 for ; Thu, 4 Jan 2024 09:01:28 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661124.1030841 (Exim 4.92) (envelope-from ) id 1rLJbL-0008SB-0I; Thu, 04 Jan 2024 09:01:19 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661124.1030841; Thu, 04 Jan 2024 09:01:18 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbK-0008Ry-Sm; Thu, 04 Jan 2024 09:01:18 +0000 Received: by outflank-mailman (input) for mailman id 661124; Thu, 04 Jan 2024 09:01:17 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbJ-00085z-5T for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:17 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id d167242d-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:16 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 2D5F921EE1; Thu, 4 Jan 2024 09:01:16 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 03AEA13722; Thu, 4 Jan 2024 09:01:15 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id +7k+O9tzlmWSWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:15 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: d167242d-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 03/33] tools: add a new xen logging daemon Date: Thu, 4 Jan 2024 10:00:25 +0100 Message-Id: <20240104090055.27323-4-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: 2D5F921EE1 Add "xen-9pfsd", a new logging daemon meant to support infrastructure domains (e.g. xenstore-stubdom) to access files in dom0. For now only add the code needed for starting the daemon and registering it with Xenstore via a new "libxl/xen-9pfs/state" node by writing the "running" state to it. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Acked-by: Andrew Cooper , although one other --- V2: - rename from xenlogd to xen-9pfsd (Andrew Cooper) - use a backend domain local Xenstore node (Jason Andryuk) - use "volatile" for stop_me (Andrew Cooper) V3: - fix SPDX Identifier (Andrew Cooper) --- tools/Makefile | 1 + tools/xen-9pfsd/.gitignore | 1 + tools/xen-9pfsd/Makefile | 38 ++++++++++ tools/xen-9pfsd/xen-9pfsd.c | 145 ++++++++++++++++++++++++++++++++++++ 4 files changed, 185 insertions(+) create mode 100644 tools/xen-9pfsd/.gitignore create mode 100644 tools/xen-9pfsd/Makefile create mode 100644 tools/xen-9pfsd/xen-9pfsd.c diff --git a/tools/Makefile b/tools/Makefile index 3a510663a0..f8faa3a902 100644 --- a/tools/Makefile +++ b/tools/Makefile @@ -32,6 +32,7 @@ SUBDIRS-y += xenpmd SUBDIRS-$(CONFIG_GOLANG) += golang SUBDIRS-y += xl SUBDIRS-y += helpers +SUBDIRS-y += xen-9pfsd SUBDIRS-$(CONFIG_X86) += xenpaging SUBDIRS-$(CONFIG_X86) += debugger SUBDIRS-$(CONFIG_TESTS) += tests diff --git a/tools/xen-9pfsd/.gitignore b/tools/xen-9pfsd/.gitignore new file mode 100644 index 0000000000..d0c2d223ef --- /dev/null +++ b/tools/xen-9pfsd/.gitignore @@ -0,0 +1 @@ +/xen-9pfsd diff --git a/tools/xen-9pfsd/Makefile b/tools/xen-9pfsd/Makefile new file mode 100644 index 0000000000..4e35202f08 --- /dev/null +++ b/tools/xen-9pfsd/Makefile @@ -0,0 +1,38 @@ +# +# tools/xen-9pfsd/Makefile +# + +XEN_ROOT = $(CURDIR)/../.. +include $(XEN_ROOT)/tools/Rules.mk + +CFLAGS += $(PTHREAD_CFLAGS) +LDFLAGS += $(PTHREAD_LDFLAGS) + +TARGETS := xen-9pfsd + +XEN-9PFSD_OBJS = xen-9pfsd.o +$(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxenstore) +$(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxenevtchn) +$(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxengnttab) +xen-9pfsd: LDLIBS += $(call xenlibs-ldlibs,store evtchn gnttab) + +.PHONY: all +all: $(TARGETS) + +xen-9pfsd: $(XEN-9PFSD_OBJS) + $(CC) $(LDFLAGS) -o $@ $(XEN-9PFSD_OBJS) $(LDLIBS) $(APPEND_LDFLAGS) + +.PHONY: install +install: all + $(INSTALL_DIR) $(DESTDIR)$(LIBEXEC_BIN) + for i in $(TARGETS); do $(INSTALL_PROG) $$i $(DESTDIR)$(LIBEXEC_BIN); done + +.PHONY: uninstall +uninstall: + for i in $(TARGETS); do rm -f $(DESTDIR)$(LIBEXEC_BIN)/$$i; done + +.PHONY: clean +clean: + $(RM) *.o $(TARGETS) $(DEPS_RM) + +distclean: clean diff --git a/tools/xen-9pfsd/xen-9pfsd.c b/tools/xen-9pfsd/xen-9pfsd.c new file mode 100644 index 0000000000..22cfff0c4e --- /dev/null +++ b/tools/xen-9pfsd/xen-9pfsd.c @@ -0,0 +1,145 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +/* + * xen-9pfsd - Xen 9pfs daemon + * + * Copyright (C) 2023 Juergen Gross + * + * Daemon to enable guests to access a directory of the dom0 file system. + * Access is made via the 9pfs protocol (xen-9pfsd acts as a PV 9pfs backend). + * + * Usage: xen-9pfsd + * + * xen-9pfsd does NOT support writing any links (neither soft links nor hard + * links), and it is accepting only canonicalized file paths in order to + * avoid the possibility to "escape" from the guest specific directory. + * + * The backend device string is "xen_9pfs", the tag used for mounting the + * 9pfs device is "Xen". + * + * As an additional security measure the maximum file space used by the guest + * can be limited by the backend Xenstore node "max-size" specifying the size + * in MBytes. This size includes the size of the root directory of the guest. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static volatile bool stop_me; +static bool daemon_running; +static struct xs_handle *xs; +static xengnttab_handle *xg; +static xenevtchn_handle *xe; + +static void handle_stop(int sig) +{ + stop_me = true; +} + +static void close_all(void) +{ + if ( daemon_running ) + xs_rm(xs, XBT_NULL, "libxl/xen-9pfs"); + if ( xe ) + xenevtchn_close(xe); + if ( xg ) + xengnttab_close(xg); + if ( xs ) + xs_close(xs); + closelog(); +} + +static void do_err(const char *msg) +{ + syslog(LOG_ALERT, "%s, errno = %d", msg, errno); + close_all(); + exit(1); +} + +static void xen_connect(void) +{ + xs_transaction_t t; + char *val; + unsigned int len; + + xs = xs_open(0); + if ( xs == NULL ) + do_err("xs_open() failed"); + + xg = xengnttab_open(NULL, 0); + if ( xg == NULL ) + do_err("xengnttab_open() failed"); + + xe = xenevtchn_open(NULL, 0); + if ( xe == NULL ) + do_err("xenevtchn_open() failed"); + + while ( true ) + { + t = xs_transaction_start(xs); + if ( t == XBT_NULL ) + do_err("xs_transaction_start() failed"); + + val = xs_read(xs, t, "libxl/xen-9pfs/state", &len); + if ( val ) + { + free(val); + xs_transaction_end(xs, t, true); + do_err("daemon already running"); + } + + if ( !xs_write(xs, t, "libxl/xen-9pfs/state", "running", + strlen("running")) ) + { + xs_transaction_end(xs, t, true); + do_err("xs_write() failed writing state"); + } + + if ( xs_transaction_end(xs, t, false) ) + break; + if ( errno != EAGAIN ) + do_err("xs_transaction_end() failed"); + } + + daemon_running = true; +} + +int main(int argc, char *argv[]) +{ + struct sigaction act = { .sa_handler = handle_stop, }; + int syslog_mask = LOG_MASK(LOG_WARNING) | LOG_MASK(LOG_ERR) | + LOG_MASK(LOG_CRIT) | LOG_MASK(LOG_ALERT) | + LOG_MASK(LOG_EMERG); + + umask(027); + if ( getenv("XEN_9PFSD_VERBOSE") ) + syslog_mask |= LOG_MASK(LOG_NOTICE) | LOG_MASK(LOG_INFO); + openlog("xen-9pfsd", LOG_CONS, LOG_DAEMON); + setlogmask(syslog_mask); + + sigemptyset(&act.sa_mask); + sigaction(SIGHUP, &act, NULL); + + xen_connect(); + + while ( !stop_me ) + { + sleep(60); + } + + close_all(); + + return 0; +} From patchwork Thu Jan 4 09:00:26 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510902 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id EFE3BC47074 for ; Thu, 4 Jan 2024 09:01:36 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661127.1030851 (Exim 4.92) (envelope-from ) id 1rLJbS-0000RG-8A; Thu, 04 Jan 2024 09:01:26 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661127.1030851; Thu, 04 Jan 2024 09:01:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbS-0000R7-4S; Thu, 04 Jan 2024 09:01:26 +0000 Received: by outflank-mailman (input) for mailman id 661127; Thu, 04 Jan 2024 09:01:24 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbQ-0007Zm-AR for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:24 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id d4c6e305-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:01:22 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id AF72221EE1; Thu, 4 Jan 2024 09:01:21 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 870B313722; Thu, 4 Jan 2024 09:01:21 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id rFG4H+FzlmWYWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:21 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: d4c6e305-aadf-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358881; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9l1zFck36AXwEapU2Gj9ECie0Zocm/mcpIzingvfm50=; b=oJb1G/Ximy9O2WBkntcRwp4qve9sbCEZkIXToIvqnK6MZXB71gzoybmZn1rEEAdzUFMabL utWTYnmc5frDsWl+pHLWudXVojY454lsy3idO2NadM6wkHXX/OJq5GG5Gaa9uf4W/yOYgR qkqBa90Tbh2r5S88rnGt73V5UOYSrcA= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358881; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9l1zFck36AXwEapU2Gj9ECie0Zocm/mcpIzingvfm50=; b=oJb1G/Ximy9O2WBkntcRwp4qve9sbCEZkIXToIvqnK6MZXB71gzoybmZn1rEEAdzUFMabL utWTYnmc5frDsWl+pHLWudXVojY454lsy3idO2NadM6wkHXX/OJq5GG5Gaa9uf4W/yOYgR qkqBa90Tbh2r5S88rnGt73V5UOYSrcA= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 04/33] tools/xenlogd: connect to frontend Date: Thu, 4 Jan 2024 10:00:26 +0100 Message-Id: <20240104090055.27323-5-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [-6.58 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; TO_DN_SOME(0.00)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; NEURAL_HAM_LONG(-0.28)[-0.280]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-3.00)[100.00%] Add the code for connecting to frontends to xenlogd. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - support multiple rings per device (Jason Andryuk) - don't set .revents initially (Jason Andryuk) - call poll() with infinite timeout (Jason Andryuk) - take mutex before calling pthread_cond_signal() V3: - fix SPDX indentifier (Andrew Cooper) - better validation of host path (Jason Andryuk) - don't hard-code dom0 in backend nodes (Jason Andryuk) - use bool instead of int for some functions' return types - open root directory (Jason Andryuk) Signed-off-by: Juergen Gross --- tools/xen-9pfsd/Makefile | 2 +- tools/xen-9pfsd/io.c | 45 +++ tools/xen-9pfsd/xen-9pfsd.c | 653 +++++++++++++++++++++++++++++++++++- tools/xen-9pfsd/xen-9pfsd.h | 61 ++++ 4 files changed, 757 insertions(+), 4 deletions(-) create mode 100644 tools/xen-9pfsd/io.c create mode 100644 tools/xen-9pfsd/xen-9pfsd.h diff --git a/tools/xen-9pfsd/Makefile b/tools/xen-9pfsd/Makefile index 4e35202f08..2023b19c62 100644 --- a/tools/xen-9pfsd/Makefile +++ b/tools/xen-9pfsd/Makefile @@ -10,7 +10,7 @@ LDFLAGS += $(PTHREAD_LDFLAGS) TARGETS := xen-9pfsd -XEN-9PFSD_OBJS = xen-9pfsd.o +XEN-9PFSD_OBJS = xen-9pfsd.o io.o $(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxenstore) $(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxenevtchn) $(XEN-9PFSD_OBJS): CFLAGS += $(CFLAGS_libxengnttab) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c new file mode 100644 index 0000000000..027e87af4c --- /dev/null +++ b/tools/xen-9pfsd/io.c @@ -0,0 +1,45 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +/* + * xen-9pfsd - Xen 9pfs daemon + * + * Copyright (C) 2023 Juergen Gross + * + * I/O thread handling. + */ + +#include +#include +#include + +#include "xen-9pfsd.h" + +static bool io_work_pending(struct ring *ring) +{ + if ( ring->stop_thread ) + return true; + return false; +} + +void *io_thread(void *arg) +{ + struct ring *ring = arg; + + while ( !ring->stop_thread ) + { + pthread_mutex_lock(&ring->mutex); + if ( !io_work_pending(ring) ) + { + if ( xenevtchn_unmask(xe, ring->evtchn) < 0 ) + syslog(LOG_WARNING, "xenevtchn_unmask() failed"); + pthread_cond_wait(&ring->cond, &ring->mutex); + } + pthread_mutex_unlock(&ring->mutex); + + /* TODO: I/O handling. */ + } + + ring->thread_active = false; + + return NULL; +} diff --git a/tools/xen-9pfsd/xen-9pfsd.c b/tools/xen-9pfsd/xen-9pfsd.c index 22cfff0c4e..9ce9ae559b 100644 --- a/tools/xen-9pfsd/xen-9pfsd.c +++ b/tools/xen-9pfsd/xen-9pfsd.c @@ -24,34 +24,632 @@ #include #include +#include +#include +#include #include #include #include #include #include #include +#include #include #include #include -#include #include #include +#include "xen-9pfsd.h" + +/* + * List of currently known devices. + * The list itself is modified only in the main thread. When a device is being + * removed its memory needs to be freed after the I/O thread (if existing) + * has stopped. + */ +static XEN_TAILQ_HEAD(devhead, device) devs = XEN_TAILQ_HEAD_INITIALIZER(devs); + +struct path { + char path[100]; +}; + static volatile bool stop_me; static bool daemon_running; static struct xs_handle *xs; static xengnttab_handle *xg; -static xenevtchn_handle *xe; +static unsigned int now; + +xenevtchn_handle *xe; static void handle_stop(int sig) { stop_me = true; } +static int check_host_path(device *device) +{ + struct stat statbuf; + char *path, *p; + int ret = 1; + + if ( !device->host_path ) + return 1; + + /* Path must be absolute. */ + if ( device->host_path[0] != '/' ) + return 1; + + /* No double "/". */ + if ( strstr(device->host_path, "//") ) + return 1; + + /* No trailing "/" (includes refusing to share "/"). */ + if ( device->host_path[strlen(device->host_path) - 1] == '/' ) + return 1; + + path = strdup(device->host_path); + if ( !path ) + { + syslog(LOG_CRIT, "memory allocation failure!"); + return 1; + } + + for ( p = path; p; ) + { + p = strchr(p + 1, '/'); + if ( p ) + *p = 0; + if ( !stat(path, &statbuf) ) + { + if ( !(statbuf.st_mode & S_IFDIR) ) + break; + if ( !p ) + { + ret = 0; + break; + } + *p = '/'; + continue; + } + if ( mkdir(path, 0777) ) + break; + if ( p ) + *p = '/'; + } + + free(path); + return ret; +} + +static void construct_frontend_path(device *device, const char *node, + struct path *p) +{ + snprintf(p->path, sizeof(p->path), "/local/domain/%u/device/9pfs/%u/%s", + device->domid, device->devid, node); +} + +static void construct_backend_path(device *device, const char *node, + struct path *p) +{ + snprintf(p->path, sizeof(p->path), "backend/xen_9pfs/%u/%u/%s", + device->domid, device->devid, node); +} + +static char *read_backend_node(device *device, const char *node) +{ + struct path p; + char *val; + unsigned int len; + + construct_backend_path(device, node, &p); + val = xs_read(xs, XBT_NULL, p.path, &len); + + return val; +} + +static unsigned int uint_from_string(char *string, unsigned int def) +{ + unsigned long val; + char *end; + + if ( !string ) + return def; + + val = strtoul(string, &end, 10); + if ( *end || val > UINT_MAX ) + val = def; + free(string); + + return val; +} + +static unsigned int read_backend_node_uint(device *device, const char *node, + unsigned int def) +{ + return uint_from_string(read_backend_node(device, node), def); +} + +static unsigned int read_frontend_node_uint(device *device, const char *node, + unsigned int def) +{ + struct path p; + unsigned int len; + + construct_frontend_path(device, node, &p); + + return uint_from_string(xs_read(xs, XBT_NULL, p.path, &len), def); +} + +static bool write_backend_node(device *device, const char *node, + const char *val) +{ + struct path p; + unsigned int num_perms; + struct xs_permissions *old_perms; + struct xs_permissions perms[2] = { + { .id = 0, .perms = XS_PERM_NONE }, + { .id = device->domid, .perms = XS_PERM_READ } + }; + + construct_backend_path(device, node, &p); + if ( !xs_write(xs, XBT_NULL, p.path, val, strlen(val)) ) + { + syslog(LOG_ERR, "error writing bacḱend node \"%s\" for device %u/%u", + node, device->domid, device->devid); + return false; + } + + old_perms = xs_get_permissions(xs, XBT_NULL, p.path, &num_perms); + if ( !old_perms ) + { + syslog(LOG_ERR, "error getting permissions for \"%s\"", p.path); + return false; + } + + perms[0] = old_perms[0]; + free(old_perms); + if ( !xs_set_permissions(xs, XBT_NULL, p.path, perms, 2) ) + { + syslog(LOG_ERR, "error setting permissions for \"%s\"", p.path); + return false; + } + + return true; +} + +static bool write_backend_node_uint(device *device, const char *node, + unsigned int val) +{ + char str[12]; + + snprintf(str, sizeof(str), "%u", val); + + return write_backend_node(device, node, str); +} + +static bool write_backend_state(device *device, enum xenbus_state state) +{ + struct path p; + char val[2]; + + snprintf(val, sizeof(val), "%u", state); + construct_backend_path(device, "state", &p); + if ( !xs_write(xs, XBT_NULL, p.path, val, 1) ) + { + syslog(LOG_ERR, "error writing backend state %u for device %u/%u", + state, device->domid, device->devid); + return false; + } + + device->backend_state = state; + + return true; +} + +static device *find_device(unsigned int domid, unsigned int devid) +{ + device *device; + + XEN_TAILQ_FOREACH( device, &devs, list ) + { + if ( domid == device->domid && devid == device->devid ) + return device; + } + + return NULL; +} + +static void free_device(device *device) +{ + char token[20]; + struct path p; + + construct_frontend_path(device, "state", &p); + snprintf(token, sizeof(token), "%u/%u", device->domid, device->devid); + xs_unwatch(xs, p.path, token); + + if ( device->root_fd >= 0 ) + close(device->root_fd); + + free(device->host_path); + free(device); +} + +static device *new_device(unsigned int domid, unsigned int devid) +{ + device *device; + char token[20]; + struct path p; + char *val; + + device = calloc(1, sizeof(*device)); + if ( !device ) + { + syslog(LOG_CRIT, "Got no memory for new device %u/%u", domid, devid); + return NULL; + } + + device->domid = domid; + device->devid = devid; + device->root_fd = -1; + + construct_frontend_path(device, "state", &p); + snprintf(token, sizeof(token), "%u/%u", domid, devid); + if ( !xs_watch(xs, p.path, token) ) + { + syslog(LOG_ERR, "Setting up watch for device %u/%u failed", + domid, devid); + free(device); + return NULL; + } + + val = read_backend_node(device, "security_model"); + if ( !val || strcmp(val, "none") ) + { + syslog(LOG_ERR, "Security model \"%s\" for device %u/%u invalid.", + val, domid, devid); + free(val); + goto err; + } + free(val); + + device->max_space = read_backend_node_uint(device, "max-space", 0); + device->max_files = read_backend_node_uint(device, "max-files", 0); + device->max_open_files = + read_backend_node_uint(device, "max-open-files", 0) + ?: MAX_OPEN_FILES_DEFAULT; + device->auto_delete = read_backend_node_uint(device, "auto-delete", 0); + + device->host_path = read_backend_node(device, "path"); + if ( check_host_path(device) ) + { + syslog(LOG_ERR, "Host path \"%s\" for device %u/%u invalid.", + device->host_path, domid, devid); + goto err; + } + device->root_fd = open(device->host_path, O_RDONLY | O_DIRECTORY); + if ( device->root_fd < 0 ) + goto err; + + if ( !write_backend_node(device, "versions", "1") ) + goto err; + if ( !write_backend_node_uint(device, "max-rings", MAX_RINGS) ) + goto err; + if ( !write_backend_node_uint(device, "max-ring-page-order", + MAX_RING_ORDER) ) + goto err; + + if ( !write_backend_state(device, XenbusStateInitWait) ) + goto err; + + XEN_TAILQ_INSERT_TAIL(&devs, device, list); + syslog(LOG_INFO, "New device %u/%u added", domid, devid); + + return device; + + err: + free_device(device); + return NULL; +} + +static void disconnect_ring(struct ring *ring) +{ + if ( !ring ) + return; + + if ( ring->thread_active ) + { + ring->stop_thread = true; + pthread_cond_signal(&ring->cond); + pthread_join(ring->thread, NULL); + ring->stop_thread = false; + } + + if ( ring->data.in ) + { + xengnttab_unmap(xg, ring->data.in, 1 << ring->ring_order); + ring->data.in = NULL; + } + if ( ring->intf ) + { + xengnttab_unmap(xg, ring->intf, 1 ); + ring->intf = NULL; + } + + if ( ring->evtchn ) + { + xenevtchn_unbind(xe, ring->evtchn); + ring->evtchn = 0; + } + + pthread_mutex_destroy(&ring->mutex); + pthread_cond_destroy(&ring->cond); +} + +static void disconnect_guest(device *device) +{ + unsigned int ring_idx; + + for ( ring_idx = 0; ring_idx < device->num_rings; ring_idx++ ) + { + disconnect_ring(device->ring[ring_idx]); + free(device->ring[ring_idx]); + device->ring[ring_idx] = NULL; + } + + device->num_rings = 0; +} + +static void close_device(device *device, enum xenbus_state state) +{ + disconnect_guest(device); + write_backend_state(device, state); +} + +static void connect_err(device *device, const char *msg) +{ + syslog(LOG_WARNING, "%s", msg); + close_device(device, XenbusStateClosed); +} + +static void connect_device(device *device) +{ + unsigned int val; + unsigned int ring_idx; + char node[20]; + struct ring *ring; + xenevtchn_port_or_error_t evtchn; + + val = read_frontend_node_uint(device, "version", 0); + if ( val != 1 ) + return connect_err(device, "frontend specifies illegal version"); + device->num_rings = read_frontend_node_uint(device, "num-rings", 0); + if ( device->num_rings < 1 || device->num_rings > MAX_RINGS ) + return connect_err(device, "frontend specifies illegal ring number"); + + for ( ring_idx = 0; ring_idx < device->num_rings; ring_idx++ ) + { + ring = calloc(1, sizeof(*ring)); + if ( !ring ) + return connect_err(device, "could not allocate ring memory"); + device->ring[ring_idx] = ring; + ring->device = device; + pthread_cond_init(&ring->cond, NULL); + pthread_mutex_init(&ring->mutex, NULL); + + snprintf(node, sizeof(node), "event-channel-%u", ring_idx); + val = read_frontend_node_uint(device, node, 0); + if ( val == 0 ) + return connect_err(device, "frontend specifies illegal evtchn"); + evtchn = xenevtchn_bind_interdomain(xe, device->domid, val); + if ( evtchn < 0 ) + return connect_err(device, "could not bind to event channel"); + ring->evtchn = evtchn; + + snprintf(node, sizeof(node), "ring-ref%u", ring_idx); + val = read_frontend_node_uint(device, node, 0); + if ( val == 0 ) + return connect_err(device, + "frontend specifies illegal grant for ring"); + ring->intf = xengnttab_map_grant_ref(xg, device->domid, val, + PROT_READ | PROT_WRITE); + if ( !ring->intf ) + return connect_err(device, "could not map interface page"); + ring->ring_order = ring->intf->ring_order; + if ( ring->ring_order > MAX_RING_ORDER || ring->ring_order < 1 ) + return connect_err(device, "frontend specifies illegal ring order"); + ring->ring_size = XEN_FLEX_RING_SIZE(ring->ring_order); + ring->data.in = xengnttab_map_domain_grant_refs(xg, + 1 << ring->ring_order, + device->domid, + ring->intf->ref, + PROT_READ | PROT_WRITE); + if ( !ring->data.in ) + return connect_err(device, "could not map ring pages"); + ring->data.out = ring->data.in + ring->ring_size; + + if ( pthread_create(&ring->thread, NULL, io_thread, ring) ) + return connect_err(device, "could not start I/O thread"); + ring->thread_active = true; + } + + write_backend_state(device, XenbusStateConnected); +} + +static void remove_device(device *device) +{ + XEN_TAILQ_REMOVE(&devs, device, list); + + disconnect_guest(device); + free_device(device); +} + +static void remove_all_devices(void) +{ + device *device, *tmp; + + XEN_TAILQ_FOREACH_SAFE( device, &devs, list, tmp ) + remove_device(device); +} + +static void frontend_changed(device *device) +{ + struct path p; + char *state, *end; + unsigned int len; + unsigned long new_state; + + construct_frontend_path(device, "state", &p); + state = xs_read(xs, XBT_NULL, p.path, &len); + if ( !state ) + { + close_device(device, XenbusStateClosed); + return; + } + + new_state = strtoul(state, &end, 10); + if ( *end || new_state > XenbusStateReconfigured ) + { + syslog(LOG_WARNING, "unknown state \"%s\" seen for device %u/%u", state, + device->domid, device->devid); + new_state = XenbusStateUnknown; + } + free(state); + + if ( new_state == device->frontend_state ) + return; + + switch ( new_state ) + { + case XenbusStateInitialising: + break; + + case XenbusStateInitialised: + connect_device(device); + break; + + case XenbusStateConnected: + break; + + case XenbusStateClosing: + close_device(device, XenbusStateClosing); + break; + + case XenbusStateClosed: + close_device(device, XenbusStateClosed); + break; + + default: + syslog(LOG_WARNING, "not handled frontend state %lu for device %u/%u", + new_state, device->domid, device->devid); + break; + } + + device->frontend_state = new_state; +} + +static void check_device(unsigned int domid, unsigned int devid) +{ + device *device; + + device = find_device(domid, devid); + if ( !device ) + { + device = new_device(domid, devid); + if ( !device ) + return; + } + + device->last_seen = now; +} + +static void scan_backend(void) +{ + char **doms; + unsigned int n_doms, dom; + char **devices; + unsigned int n_devs, dev; + char dom_path[24]; + unsigned long domid, devid; + char *end; + device *device, *tmp; + + now++; + + doms = xs_directory(xs, XBT_NULL, "backend/xen_9pfs", &n_doms); + if ( doms == NULL ) + return; + + for ( dom = 0; dom < n_doms; dom++ ) + { + errno = 0; + domid = strtoul(doms[dom], &end, 10); + if ( errno || *end || domid >= DOMID_FIRST_RESERVED ) + continue; + + snprintf(dom_path, sizeof(dom_path), "backend/xen_9pfs/%lu", domid); + devices = xs_directory(xs, XBT_NULL, dom_path, &n_devs); + + for ( dev = 0; dev < n_devs; dev++ ) + { + errno = 0; + devid = strtoul(devices[dev], &end, 10); + if ( errno || *end || devid > UINT_MAX ) + continue; + + check_device(domid, devid); + } + + free(devices); + } + + free(doms); + + XEN_TAILQ_FOREACH_SAFE( device, &devs, list, tmp ) + { + if ( device->last_seen != now ) + remove_device(device); + } +} + +static void handle_watch(char *path, char *token) +{ + unsigned int domid, devid; + device *device; + + if ( !strcmp(token, "main") ) + { + scan_backend(); + return; + } + + if ( sscanf(token, "%u/%u", &domid, &devid) != 2 ) + { + syslog(LOG_WARNING, "unknown watch event %s %s", path, token); + return; + } + + device = find_device(domid, devid); + if ( !device ) + { + syslog(LOG_WARNING, "watch event for unknown device %u/%u", + domid, devid); + return; + } + + frontend_changed(device); +} + static void close_all(void) { if ( daemon_running ) + { xs_rm(xs, XBT_NULL, "libxl/xen-9pfs"); + xs_unwatch(xs, "backend/xen_9pfs", "main"); + + remove_all_devices(); + } if ( xe ) xenevtchn_close(xe); if ( xg ) @@ -68,6 +666,33 @@ static void do_err(const char *msg) exit(1); } +static void handle_event(void) +{ + xenevtchn_port_or_error_t evtchn; + device *device; + struct ring *ring; + unsigned int ring_idx; + + evtchn = xenevtchn_pending(xe); + if ( evtchn < 0 ) + do_err("xenevtchn_pending() failed"); + + XEN_TAILQ_FOREACH( device, &devs, list ) + { + for ( ring_idx = 0; ring_idx < device->num_rings; ring_idx++ ) + { + ring = device->ring[ring_idx]; + if ( ring && ring->evtchn == evtchn ) + { + pthread_mutex_lock(&ring->mutex); + pthread_cond_signal(&ring->cond); + pthread_mutex_unlock(&ring->mutex); + return; + } + } + } +} + static void xen_connect(void) { xs_transaction_t t; @@ -122,6 +747,11 @@ int main(int argc, char *argv[]) int syslog_mask = LOG_MASK(LOG_WARNING) | LOG_MASK(LOG_ERR) | LOG_MASK(LOG_CRIT) | LOG_MASK(LOG_ALERT) | LOG_MASK(LOG_EMERG); + char **watch; + struct pollfd p[2] = { + { .events = POLLIN }, + { .events = POLLIN } + }; umask(027); if ( getenv("XEN_9PFSD_VERBOSE") ) @@ -134,9 +764,26 @@ int main(int argc, char *argv[]) xen_connect(); + if ( !xs_watch(xs, "backend/xen_9pfs", "main") ) + do_err("xs_watch() in main thread failed"); + p[0].fd = xs_fileno(xs); + p[1].fd = xenevtchn_fd(xe); + + scan_backend(); + while ( !stop_me ) { - sleep(60); + while ( (p[0].revents & POLLIN) && + (watch = xs_check_watch(xs)) != NULL ) + { + handle_watch(watch[XS_WATCH_PATH], watch[XS_WATCH_TOKEN]); + free(watch); + } + + if ( p[1].revents & POLLIN ) + handle_event(); + + poll(p, 2, -1); } close_all(); diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h new file mode 100644 index 0000000000..ff3562164a --- /dev/null +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -0,0 +1,61 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef XEN_9PFSD_H +#define XEN_9PFSD_H + +#include +#include +#include +#include +#include +#include +#include + +#define MAX_RINGS 4 +#define MAX_RING_ORDER 9 +#define MAX_OPEN_FILES_DEFAULT 5 + +typedef struct device device; + +struct ring { + device *device; + pthread_t thread; + bool thread_active; + bool stop_thread; + pthread_cond_t cond; + pthread_mutex_t mutex; + + evtchn_port_t evtchn; + struct xen_9pfs_data_intf *intf; + unsigned int ring_order; + RING_IDX ring_size; + struct xen_9pfs_data data; +}; + +struct device { + /* Admin data. */ + XEN_TAILQ_ENTRY(device) list; + unsigned int last_seen; /* Set in scan_backend(). */ + unsigned int domid; + unsigned int devid; + + /* Tool side configuration data. */ + char *host_path; + unsigned int max_space; + unsigned int max_files; + unsigned int max_open_files; + bool auto_delete; + + /* Connection data. */ + enum xenbus_state backend_state; + enum xenbus_state frontend_state; + unsigned int num_rings; + struct ring *ring[MAX_RINGS]; + int root_fd; +}; + +extern xenevtchn_handle *xe; + +void *io_thread(void *arg); + +#endif /* XEN_9PFSD_H */ From patchwork Thu Jan 4 09:00:27 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510903 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 8C481C47073 for ; Thu, 4 Jan 2024 09:01:38 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661131.1030861 (Exim 4.92) (envelope-from ) id 1rLJbV-0000ni-Nb; Thu, 04 Jan 2024 09:01:29 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661131.1030861; Thu, 04 Jan 2024 09:01:29 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbV-0000nR-Js; Thu, 04 Jan 2024 09:01:29 +0000 Received: by outflank-mailman (input) for mailman id 661131; Thu, 04 Jan 2024 09:01:28 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbU-00085z-9Y for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:28 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id d7fcfc33-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:27 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 39A491F7F8; Thu, 4 Jan 2024 09:01:27 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 0E77913722; Thu, 4 Jan 2024 09:01:27 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id Yo1HAudzlmWeWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:27 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: d7fcfc33-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 05/33] tools/xenlogd: add transport layer Date: Thu, 4 Jan 2024 10:00:27 +0100 Message-Id: <20240104090055.27323-6-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 39A491F7F8 Add the transport layer of 9pfs. This is basically the infrastructure to receive requests from the frontend and to send the related answers via the rings. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - rename put_request_bytes() (Jason Andryuk) - rename get_request_bytes() and put_response_bytes() len parameter (Jason Andryuk) - don't unmask event channel if error indicator is set (Jason Andryuk) --- tools/xen-9pfsd/io.c | 143 +++++++++++++++++++++++++++++++++++- tools/xen-9pfsd/xen-9pfsd.h | 16 ++++ 2 files changed, 156 insertions(+), 3 deletions(-) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 027e87af4c..0b8814a97e 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -6,39 +6,176 @@ * Copyright (C) 2023 Juergen Gross * * I/O thread handling. + * + * Only handle one request at a time, pushing out the complete response + * before looking for the next request. */ #include +#include #include #include +#include /* For cpu barriers. */ +#include #include "xen-9pfsd.h" +/* + * Note that the ring names "in" and "out" are from the frontend's + * perspective, so the "in" ring will be used for responses to the frontend, + * while the "out" ring is used for requests from the frontend to the + * backend. + */ +static unsigned int ring_in_free(struct ring *ring) +{ + unsigned int queued; + + queued = xen_9pfs_queued(ring->prod_pvt_in, ring->intf->in_cons, + ring->ring_size); + xen_rmb(); + + return ring->ring_size - queued; +} + +static unsigned int ring_out_data(struct ring *ring) +{ + unsigned int queued; + + queued = xen_9pfs_queued(ring->intf->out_prod, ring->cons_pvt_out, + ring->ring_size); + xen_rmb(); + + return queued; +} + +static unsigned int get_request_bytes(struct ring *ring, unsigned int off, + unsigned int total_len) +{ + unsigned int size; + unsigned int out_data = ring_out_data(ring); + RING_IDX prod, cons; + + size = min(total_len - off, out_data); + prod = xen_9pfs_mask(ring->intf->out_prod, ring->ring_size); + cons = xen_9pfs_mask(ring->cons_pvt_out, ring->ring_size); + xen_9pfs_read_packet(ring->buffer + off, ring->data.out, size, + prod, &cons, ring->ring_size); + + xen_rmb(); /* Read data out before setting visible consumer. */ + ring->cons_pvt_out += size; + ring->intf->out_cons = ring->cons_pvt_out; + + /* Signal that more space is available now. */ + xenevtchn_notify(xe, ring->evtchn); + + return size; +} + +static unsigned int put_response_bytes(struct ring *ring, unsigned int off, + unsigned int total_len) +{ + unsigned int size; + unsigned int in_data = ring_in_free(ring); + RING_IDX prod, cons; + + size = min(total_len - off, in_data); + prod = xen_9pfs_mask(ring->prod_pvt_in, ring->ring_size); + cons = xen_9pfs_mask(ring->intf->in_cons, ring->ring_size); + xen_9pfs_write_packet(ring->data.in, ring->buffer + off, size, + &prod, cons, ring->ring_size); + + xen_wmb(); /* Write data out before setting visible producer. */ + ring->prod_pvt_in += size; + ring->intf->in_prod = ring->prod_pvt_in; + + return size; +} + static bool io_work_pending(struct ring *ring) { if ( ring->stop_thread ) return true; - return false; + if ( ring->error ) + return false; + return ring->handle_response ? ring_in_free(ring) : ring_out_data(ring); } void *io_thread(void *arg) { struct ring *ring = arg; + unsigned int count = 0; + struct p9_header hdr; + bool in_hdr = true; + + ring->max_size = ring->ring_size; + ring->buffer = malloc(ring->max_size); + if ( !ring->buffer ) + { + syslog(LOG_CRIT, "memory allocation failure!"); + return NULL; + } while ( !ring->stop_thread ) { pthread_mutex_lock(&ring->mutex); if ( !io_work_pending(ring) ) { - if ( xenevtchn_unmask(xe, ring->evtchn) < 0 ) + if ( !ring->error && xenevtchn_unmask(xe, ring->evtchn) < 0 ) syslog(LOG_WARNING, "xenevtchn_unmask() failed"); pthread_cond_wait(&ring->cond, &ring->mutex); } pthread_mutex_unlock(&ring->mutex); - /* TODO: I/O handling. */ + if ( ring->stop_thread || ring->error ) + continue; + + if ( !ring->handle_response ) + { + if ( in_hdr ) + { + count += get_request_bytes(ring, count, sizeof(hdr)); + if ( count != sizeof(hdr) ) + continue; + hdr = *(struct p9_header *)ring->buffer; + if ( hdr.size > ring->max_size || hdr.size < sizeof(hdr) ) + { + syslog(LOG_ERR, "%u.%u specified illegal request length %u", + ring->device->domid, ring->device->devid, hdr.size); + ring->error = true; + continue; + } + in_hdr = false; + } + + count += get_request_bytes(ring, count, hdr.size); + if ( count < hdr.size ) + continue; + + /* TODO: handle request (will rewrite hdr.size). */ + + ring->handle_response = true; + hdr.size = ((struct p9_header *)ring->buffer)->size; + count = 0; + } + + if ( ring->handle_response ) + { + count += put_response_bytes(ring, count, hdr.size); + + if ( count == hdr.size ) + { + /* Signal presence of response. */ + xenevtchn_notify(xe, ring->evtchn); + + ring->handle_response = false; + in_hdr = true; + count = 0; + } + } } + free(ring->buffer); + ring->thread_active = false; return NULL; diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h index ff3562164a..d587f59a32 100644 --- a/tools/xen-9pfsd/xen-9pfsd.h +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -15,6 +15,12 @@ #define MAX_RING_ORDER 9 #define MAX_OPEN_FILES_DEFAULT 5 +struct p9_header { + uint32_t size; + uint8_t cmd; + uint16_t tag; +} __attribute__((packed)); + typedef struct device device; struct ring { @@ -29,7 +35,17 @@ struct ring { struct xen_9pfs_data_intf *intf; unsigned int ring_order; RING_IDX ring_size; + + /* Transport layer data. */ struct xen_9pfs_data data; + RING_IDX prod_pvt_in; + RING_IDX cons_pvt_out; + + /* Request and response handling. */ + uint32_t max_size; + bool error; /* Protocol error - stop processing. */ + bool handle_response; /* Main loop now handling response. */ + void *buffer; /* Request/response buffer. */ }; struct device { From patchwork Thu Jan 4 09:00:28 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510904 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 2259DC47073 for ; Thu, 4 Jan 2024 09:01:44 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661138.1030870 (Exim 4.92) (envelope-from ) id 1rLJbb-0001NB-W2; Thu, 04 Jan 2024 09:01:35 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661138.1030870; Thu, 04 Jan 2024 09:01:35 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbb-0001N4-T9; Thu, 04 Jan 2024 09:01:35 +0000 Received: by outflank-mailman (input) for mailman id 661138; Thu, 04 Jan 2024 09:01:34 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJba-0007Zm-QO for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:34 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id db48d92d-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:01:33 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id B409E22044; Thu, 4 Jan 2024 09:01:32 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 90CFE13722; Thu, 4 Jan 2024 09:01:32 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id Dd4fIuxzlmWpWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:32 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: db48d92d-aadf-11ee-9b0f-b553b5be7939 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 06/33] tools/xenlogd: add 9pfs response generation support Date: Thu, 4 Jan 2024 10:00:28 +0100 Message-Id: <20240104090055.27323-7-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: B409E22044 Add support for generation a 9pfs protocol response via a format based approach. Strings are stored in a per device string buffer and they are referenced via their offset in this buffer. This allows to avoid having to dynamically allocate memory for each single string. As a first user of the response handling add a generic p9_error() function which will be used to return any error to the client. Add all format parsing variants in order to avoid additional code churn later when adding the users of those variants. Prepare a special case for the "read" case already (format character 'D'): in order to avoid adding another buffer for read data support doing the read I/O directly into the response buffer. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - check parameter size limits (Jason Andryuk) V3: - use new unaligned access macros (Jason Andryuk) --- tools/xen-9pfsd/io.c | 199 +++++++++++++++++++++++++++++++++++- tools/xen-9pfsd/xen-9pfsd.h | 3 + 2 files changed, 201 insertions(+), 1 deletion(-) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 0b8814a97e..476562298b 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -11,6 +11,7 @@ * before looking for the next request. */ +#include #include #include #include @@ -20,6 +21,16 @@ #include "xen-9pfsd.h" +/* P9 protocol commands (response is either cmd+1 or P9_CMD_ERROR). */ +#define P9_CMD_ERROR 107 + +struct p9_qid { + uint8_t type; +#define QID_TYPE_DIR 0x80 + uint32_t version; + uint64_t path; +}; + /* * Note that the ring names "in" and "out" are from the frontend's * perspective, so the "in" ring will be used for responses to the frontend, @@ -100,6 +111,182 @@ static bool io_work_pending(struct ring *ring) return ring->handle_response ? ring_in_free(ring) : ring_out_data(ring); } +static void fmt_err(const char *fmt) +{ + syslog(LOG_CRIT, "illegal format %s passed to fill_buffer()", fmt); + exit(1); +} + +/* + * Fill buffer with response data. + * fmt is a sequence of format characters. Supported characters are: + * a: an array (2 bytes number of elements + the following format as elements) + * The number of elements is passed in the first unsigned int parameter, the + * next parameter is a pointer to an array of elements as denoted by the next + * format character. + * b: 2 byte unsigned integer + * The parameter is a pointer to a uint16_t value + * D: Data blob (4 byte length + bytes) + * 2 parameters are consumed, first an unsigned int for the length, then a + * pointer to the first uint8_t value. + * No array support. + * L: 8 byte unsigned integer + * The parameter is a pointer to a uint64_t value + * Q: Qid (struct p9_qid) + * S: String (2 byte length + characters) + * The length is obtained via strlen() of the parameter, being a pointer + * to the first character of the string + * U: 4 byte unsigned integer + * The parameter is a pointer to a uint32_t value + */ +static void fill_buffer(struct ring *ring, uint8_t cmd, uint16_t tag, + const char *fmt, ...) +{ + struct p9_header *hdr = ring->buffer; + void *data = hdr + 1; + const char *f; + const void *par; + const char *str_val; + const struct p9_qid *qid; + unsigned int len; + va_list ap; + unsigned int array_sz = 0; + unsigned int elem_sz = 0; + + hdr->cmd = cmd; + hdr->tag = tag; + + va_start(ap, fmt); + + for ( f = fmt; *f; f++ ) + { + if ( !array_sz ) + par = va_arg(ap, const void *); + else + { + par += elem_sz; + array_sz--; + } + + switch ( *f ) + { + case 'a': + f++; + if ( !*f || array_sz ) + fmt_err(fmt); + array_sz = *(const unsigned int *)par; + if ( array_sz > 0xffff ) + { + syslog(LOG_CRIT, "array size %u in fill_buffer()", array_sz); + exit(1); + } + put_unaligned(array_sz, (uint16_t *)data); + data += sizeof(uint16_t); + par = va_arg(ap, const void *); + elem_sz = 0; + break; + + case 'u': + put_unaligned(*(const uint16_t *)par, (uint16_t *)data); + elem_sz = sizeof(uint16_t); + data += sizeof(uint16_t); + break; + + case 'D': + if ( array_sz ) + fmt_err(fmt); + len = *(const unsigned int *)par; + put_unaligned(len, (uint32_t *)data); + data += sizeof(uint32_t); + par = va_arg(ap, const void *); + if ( data != par ) + memcpy(data, par, len); + data += len; + break; + + case 'L': + put_unaligned(*(const uint64_t *)par, (uint64_t *)data); + elem_sz = sizeof(uint64_t); + data += sizeof(uint64_t); + break; + + case 'Q': + qid = par; + elem_sz = sizeof(*qid); + *(uint8_t *)data = qid->type; + data += sizeof(uint8_t); + put_unaligned(qid->version, (uint32_t *)data); + data += sizeof(uint32_t); + put_unaligned(qid->path, (uint64_t *)data); + data += sizeof(uint64_t); + break; + + case 'S': + str_val = par; + elem_sz = sizeof(str_val); + len = strlen(str_val); + if ( len > 0xffff ) + { + syslog(LOG_CRIT, "string length %u in fill_buffer()", len); + exit(1); + } + put_unaligned(len, (uint16_t *)data); + data += sizeof(uint16_t); + memcpy(data, str_val, len); + data += len; + break; + + case 'U': + put_unaligned(*(const uint32_t *)par, (uint32_t *)data); + elem_sz = sizeof(uint32_t); + data += sizeof(uint32_t); + break; + + default: + fmt_err(fmt); + } + + if ( array_sz ) + f--; + } + + hdr->size = data - ring->buffer; +} + +static unsigned int add_string(struct ring *ring, const char *str, + unsigned int len) +{ + char *tmp; + unsigned int ret; + + if ( ring->str_used + len + 1 > ring->str_size ) + { + tmp = realloc(ring->str, ring->str_used + len + 1); + if ( !tmp ) + return ~0; + ring->str = tmp; + ring->str_size = ring->str_used + len + 1; + } + + ret = ring->str_used; + memcpy(ring->str + ret, str, len); + ring->str_used += len; + ring->str[ring->str_used++] = 0; + + return ret; +} + +static void p9_error(struct ring *ring, uint16_t tag, uint32_t err) +{ + unsigned int erroff; + + strerror_r(err, ring->buffer, ring->ring_size); + erroff = add_string(ring, ring->buffer, strlen(ring->buffer)); + fill_buffer(ring, P9_CMD_ERROR, tag, "SU", + erroff != ~0 ? ring->str + erroff : "cannot allocate memory", + &err); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -151,7 +338,16 @@ void *io_thread(void *arg) if ( count < hdr.size ) continue; - /* TODO: handle request (will rewrite hdr.size). */ + ring->str_used = 0; + + switch ( hdr.cmd ) + { + default: + syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", + ring->device->domid, ring->device->devid, hdr.cmd); + p9_error(ring, hdr.tag, EOPNOTSUPP); + break; + } ring->handle_response = true; hdr.size = ((struct p9_header *)ring->buffer)->size; @@ -174,6 +370,7 @@ void *io_thread(void *arg) } } + free(ring->str); free(ring->buffer); ring->thread_active = false; diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h index d587f59a32..0cde0d2bb8 100644 --- a/tools/xen-9pfsd/xen-9pfsd.h +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -46,6 +46,9 @@ struct ring { bool error; /* Protocol error - stop processing. */ bool handle_response; /* Main loop now handling response. */ void *buffer; /* Request/response buffer. */ + char *str; /* String work space. */ + unsigned int str_size; /* Size of *str. */ + unsigned int str_used; /* Currently used size of *str. */ }; struct device { From patchwork Thu Jan 4 09:00:29 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510905 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 3F94CC47074 for ; Thu, 4 Jan 2024 09:01:49 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661143.1030881 (Exim 4.92) (envelope-from ) id 1rLJbh-0001s5-9Y; Thu, 04 Jan 2024 09:01:41 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661143.1030881; Thu, 04 Jan 2024 09:01:41 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbh-0001rw-5B; Thu, 04 Jan 2024 09:01:41 +0000 Received: by outflank-mailman (input) for mailman id 661143; Thu, 04 Jan 2024 09:01:39 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbf-00085z-Ok for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:39 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id de938e00-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:38 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 457AD21F8C; Thu, 4 Jan 2024 09:01:38 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 1646213722; Thu, 4 Jan 2024 09:01:38 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id Df8yBPJzlmWyWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:38 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: de938e00-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 07/33] tools/xenlogd: add 9pfs version request support Date: Thu, 4 Jan 2024 10:00:29 +0100 Message-Id: <20240104090055.27323-8-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 457AD21F8C Add the version request of the 9pfs protocol. For the version use the "9P2000.u" variant, as it is supported by Mini-OS and Linux. For the request parsing add all format items needed even in future in order to avoid code churn for those additions later. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V3: - use unaligned helper macros (Jason Andryuk) --- tools/xen-9pfsd/io.c | 201 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 201 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 476562298b..245faeb9a6 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -22,8 +22,12 @@ #include "xen-9pfsd.h" /* P9 protocol commands (response is either cmd+1 or P9_CMD_ERROR). */ +#define P9_CMD_VERSION 100 #define P9_CMD_ERROR 107 +#define P9_MIN_MSIZE 2048 +#define P9_VERSION "9P2000.u" + struct p9_qid { uint8_t type; #define QID_TYPE_DIR 0x80 @@ -276,6 +280,169 @@ static unsigned int add_string(struct ring *ring, const char *str, return ret; } +static bool chk_data(struct ring *ring, void *data, unsigned int len) +{ + struct p9_header *hdr = ring->buffer; + + if ( data + len <= ring->buffer + hdr->size ) + return true; + + errno = E2BIG; + + return false; +} + +static bool fill_data_elem(void **par, void **array, unsigned int *array_sz, + unsigned int elem_sz, void *data) +{ + if ( *array_sz && !*array ) + { + *array = calloc(*array_sz, elem_sz); + if ( !*array ) + return false; + *par = *array; + } + + memcpy(*par, data, elem_sz); + + if ( *array_sz ) + { + *par += elem_sz; + *array_sz -= 1; + } + + return true; +} + +/* + * Fill variables with request data. + * fmt is a sequence of format characters. Supported characters are: + * a: an array (2 bytes number of elements + the following format as elements) + * The number of elements is stored in the first unsigned int parameter, the + * next parameter is a pointer to an array of elements as denoted by the next + * format character. The array is allocated dynamically. + * b: 1 byte unsigned integer + * The value is stored in the next parameter with type uint8_t. + * D: Data blob (4 byte length + bytes) + * 2 parameters are consumed, first an unsigned int for the length, then a + * pointer to the first uint8_t value. + * No array support. + * L: 8 byte unsigned integer + * The value is stored in the next parameter with type uint64_t. + * S: String (2 byte length + characters) + * The 0-terminated string is stored in device->str + off, off is stored in + * the next parameter with type unsigned int. + * U: 4 byte unsigned integer + * The value is stored in the next parameter with type uint32_t. + * + * Return value: number of filled variables, errno will be set in case of + * error. + */ +static int fill_data(struct ring *ring, const char *fmt, ...) +{ + struct p9_header *hdr = ring->buffer; + void *data = hdr + 1; + void *par; + unsigned int pars = 0; + const char *f; + va_list ap; + unsigned int len; + unsigned int str_off; + unsigned int array_sz = 0; + void **array = NULL; + + va_start(ap, fmt); + + for ( f = fmt; *f; f++ ) + { + if ( !array_sz ) + par = va_arg(ap, void *); + + switch ( *f ) + { + case 'a': + f++; + if ( !*f || array_sz ) + fmt_err(fmt); + if ( !chk_data(ring, data, sizeof(uint16_t)) ) + return pars; + array_sz = get_unaligned((uint16_t *)data); + data += sizeof(uint16_t); + *(unsigned int *)par = array_sz; + array = va_arg(ap, void **); + *array = NULL; + break; + + case 'b': + if ( !chk_data(ring, data, sizeof(uint8_t)) ) + return pars; + if ( !fill_data_elem(&par, array, &array_sz, sizeof(uint8_t), + data) ) + return pars; + data += sizeof(uint8_t); + break; + + case 'D': + if ( array_sz ) + fmt_err(fmt); + if ( !chk_data(ring, data, sizeof(uint32_t)) ) + return pars; + len = get_unaligned((uint32_t *)data); + data += sizeof(uint32_t); + *(unsigned int *)par = len; + par = va_arg(ap, void *); + if ( !chk_data(ring, data, len) ) + return pars; + memcpy(par, data, len); + data += len; + break; + + case 'L': + if ( !chk_data(ring, data, sizeof(uint64_t)) ) + return pars; + if ( !fill_data_elem(&par, array, &array_sz, sizeof(uint64_t), + data) ) + return pars; + data += sizeof(uint64_t); + break; + + case 'S': + if ( !chk_data(ring, data, sizeof(uint16_t)) ) + return pars; + len = get_unaligned((uint16_t *)data); + data += sizeof(uint16_t); + if ( !chk_data(ring, data, len) ) + return pars; + str_off = add_string(ring, data, len); + if ( str_off == ~0 ) + return pars; + if ( !fill_data_elem(&par, array, &array_sz, sizeof(unsigned int), + &str_off) ) + return pars; + data += len; + break; + + case 'U': + if ( !chk_data(ring, data, sizeof(uint32_t)) ) + return pars; + if ( !fill_data_elem(&par, array, &array_sz, sizeof(uint32_t), + data) ) + return pars; + data += sizeof(uint32_t); + break; + + default: + fmt_err(fmt); + } + + if ( array_sz ) + f--; + pars++; + } + + return pars; +} + static void p9_error(struct ring *ring, uint16_t tag, uint32_t err) { unsigned int erroff; @@ -287,6 +454,36 @@ static void p9_error(struct ring *ring, uint16_t tag, uint32_t err) &err); } +static void p9_version(struct ring *ring, struct p9_header *hdr) +{ + uint32_t max_size; + unsigned int off; + char *version; + int ret; + + ret = fill_data(ring, "US", &max_size, &off); + if ( ret != 2 ) + { + p9_error(ring, hdr->tag, errno); + return; + } + + if ( max_size < P9_MIN_MSIZE ) + { + p9_error(ring, hdr->tag, EMSGSIZE); + return; + } + + if ( max_size < ring->max_size ) + ring->max_size = max_size; + + version = ring->str + off; + if ( strcmp(version, P9_VERSION) ) + version = "unknown"; + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "US", &ring->max_size, version); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -342,6 +539,10 @@ void *io_thread(void *arg) switch ( hdr.cmd ) { + case P9_CMD_VERSION: + p9_version(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); From patchwork Thu Jan 4 09:00:30 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510932 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id DD518C47255 for ; Thu, 4 Jan 2024 09:12:36 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661278.1031020 (Exim 4.92) (envelope-from ) id 1rLJm8-0003eH-Bx; Thu, 04 Jan 2024 09:12:28 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661278.1031020; Thu, 04 Jan 2024 09:12:28 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm8-0003bu-7V; Thu, 04 Jan 2024 09:12:28 +0000 Received: by outflank-mailman (input) for mailman id 661278; Thu, 04 Jan 2024 09:12:26 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbq-00085z-R5 for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:50 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id e1d5a6ba-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:44 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id B7F4321EE1; Thu, 4 Jan 2024 09:01:43 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 92CB613722; Thu, 4 Jan 2024 09:01:43 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id ps+ZIvdzlmW4WAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:43 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: e1d5a6ba-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 08/33] tools/xenlogd: add 9pfs attach request support Date: Thu, 4 Jan 2024 10:00:30 +0100 Message-Id: <20240104090055.27323-9-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: B7F4321EE1 Add the attach request of the 9pfs protocol. This introduces the "fid" scheme of the 9pfs protocol. As this will be needed later, use a dedicated memory allocation function in alloc_fid() and prepare a fid reference count. For filling the qid data take the approach from the qemu 9pfs backend implementation. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - make fill_qid() parameter stbuf const (Jason Andryuk) - free fids after disconnecting guest (Jason Andryuk) V3: - only store relative path in fid (Jason Andryuk) --- tools/xen-9pfsd/io.c | 167 ++++++++++++++++++++++++++++++++++++ tools/xen-9pfsd/xen-9pfsd.c | 6 ++ tools/xen-9pfsd/xen-9pfsd.h | 14 +++ 3 files changed, 187 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 245faeb9a6..241f0df5e2 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -11,11 +11,14 @@ * before looking for the next request. */ +#include #include #include #include #include #include +#include +#include #include /* For cpu barriers. */ #include @@ -23,6 +26,7 @@ /* P9 protocol commands (response is either cmd+1 or P9_CMD_ERROR). */ #define P9_CMD_VERSION 100 +#define P9_CMD_ATTACH 104 #define P9_CMD_ERROR 107 #define P9_MIN_MSIZE 2048 @@ -443,6 +447,129 @@ static int fill_data(struct ring *ring, const char *fmt, ...) return pars; } +static struct p9_fid *find_fid(device *device, unsigned int fid) +{ + struct p9_fid *fidp; + + XEN_TAILQ_FOREACH(fidp, &device->fids, list) + { + if ( fidp->fid == fid ) + return fidp; + } + + return NULL; +} + +static struct p9_fid *alloc_fid_mem(device *device, unsigned int fid, + const char *path) +{ + struct p9_fid *fidp; + size_t pathlen; + + /* Paths always start with "/" as they are starting at the mount point. */ + assert(path[0] == '/'); + + pathlen = strlen(path); + fidp = calloc(sizeof(*fidp) + pathlen + 1, 1); + if ( !fidp ) + return NULL; + + fidp->fid = fid; + strncpy(fidp->path, path, pathlen); + + return fidp; +} + +static struct p9_fid *alloc_fid(device *device, unsigned int fid, + const char *path) +{ + struct p9_fid *fidp = NULL; + + pthread_mutex_lock(&device->fid_mutex); + + if ( find_fid(device, fid) ) + { + errno = EBADFD; + goto out; + } + + if ( device->n_fids >= device->max_open_files ) + { + errno = EMFILE; + goto out; + } + + fidp = alloc_fid_mem(device, fid, path); + if ( !fidp ) + goto out; + + fidp->ref = 1; + XEN_TAILQ_INSERT_HEAD(&device->fids, fidp, list); + device->n_fids++; + + out: + pthread_mutex_unlock(&device->fid_mutex); + + return fidp; +} + +static void free_fid(device *device, struct p9_fid *fidp) +{ + if ( !fidp ) + return; + + pthread_mutex_lock(&device->fid_mutex); + + fidp->ref--; + if ( !fidp->ref ) + { + device->n_fids--; + XEN_TAILQ_REMOVE(&device->fids, fidp, list); + free(fidp); + } + + pthread_mutex_unlock(&device->fid_mutex); +} + +void free_fids(device *device) +{ + struct p9_fid *fidp; + + while ( (fidp = XEN_TAILQ_FIRST(&device->fids)) != NULL ) + { + XEN_TAILQ_REMOVE(&device->fids, fidp, list); + free(fidp); + } +} + +static const char *relpath_from_path(const char *path) +{ + if (!strcmp(path, "/")) + return "."; + + return (path[0] == '/') ? path + 1 : path; +} + +static int fill_qid(device *device, const char *path, struct p9_qid *qid, + const struct stat *stbuf) +{ + struct stat st; + + if ( !stbuf ) + { + if ( fstatat(device->root_fd, relpath_from_path(path), &st, 0) ) + return errno; + + stbuf = &st; + } + + qid->type = S_ISDIR(stbuf->st_mode) ? QID_TYPE_DIR : 0; + qid->version = stbuf->st_mtime ^ (stbuf->st_size << 8); + qid->path = stbuf->st_ino; + + return 0; +} + static void p9_error(struct ring *ring, uint16_t tag, uint32_t err) { unsigned int erroff; @@ -484,6 +611,42 @@ static void p9_version(struct ring *ring, struct p9_header *hdr) fill_buffer(ring, hdr->cmd + 1, hdr->tag, "US", &ring->max_size, version); } +static void p9_attach(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + uint32_t dummy_u32; + unsigned int dummy_uint; + struct p9_qid qid; + int ret; + + ret = fill_data(ring, "UUSSU", &fid, &dummy_u32, &dummy_uint, &dummy_uint, + &dummy_u32); + if ( ret != 5 ) + { + p9_error(ring, hdr->tag, errno); + return; + } + + device->root_fid = alloc_fid(device, fid, "/"); + if ( !device->root_fid ) + { + p9_error(ring, hdr->tag, errno); + return; + } + + ret = fill_qid(device, "/", &qid, NULL); + if ( ret ) + { + free_fid(device, device->root_fid); + device->root_fid = NULL; + p9_error(ring, hdr->tag, ret); + return; + } + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "Q", &qid); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -543,6 +706,10 @@ void *io_thread(void *arg) p9_version(ring, &hdr); break; + case P9_CMD_ATTACH: + p9_attach(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); diff --git a/tools/xen-9pfsd/xen-9pfsd.c b/tools/xen-9pfsd/xen-9pfsd.c index 9ce9ae559b..294b415875 100644 --- a/tools/xen-9pfsd/xen-9pfsd.c +++ b/tools/xen-9pfsd/xen-9pfsd.c @@ -304,6 +304,9 @@ static device *new_device(unsigned int domid, unsigned int devid) return NULL; } + pthread_mutex_init(&device->fid_mutex, NULL); + XEN_TAILQ_INIT(&device->fids); + val = read_backend_node(device, "security_model"); if ( !val || strcmp(val, "none") ) { @@ -399,6 +402,8 @@ static void disconnect_guest(device *device) } device->num_rings = 0; + + free_fids(device); } static void close_device(device *device, enum xenbus_state state) @@ -482,6 +487,7 @@ static void remove_device(device *device) XEN_TAILQ_REMOVE(&devs, device, list); disconnect_guest(device); + pthread_mutex_destroy(&device->fid_mutex); free_device(device); } diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h index 0cde0d2bb8..6c755411a7 100644 --- a/tools/xen-9pfsd/xen-9pfsd.h +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -21,6 +21,13 @@ struct p9_header { uint16_t tag; } __attribute__((packed)); +struct p9_fid { + XEN_TAILQ_ENTRY(struct p9_fid) list; + unsigned int fid; + unsigned int ref; + char path[]; +}; + typedef struct device device; struct ring { @@ -71,10 +78,17 @@ struct device { unsigned int num_rings; struct ring *ring[MAX_RINGS]; int root_fd; + + /* File system handling. */ + pthread_mutex_t fid_mutex; + XEN_TAILQ_HEAD(fidhead, struct p9_fid) fids; + struct p9_fid *root_fid; + unsigned int n_fids; }; extern xenevtchn_handle *xe; void *io_thread(void *arg); +void free_fids(device *device); #endif /* XEN_9PFSD_H */ From patchwork Thu Jan 4 09:00:31 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510923 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 0C862C4707B for ; Thu, 4 Jan 2024 09:10:44 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661232.1030966 (Exim 4.92) (envelope-from ) id 1rLJkJ-0000Ub-GR; Thu, 04 Jan 2024 09:10:35 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661232.1030966; Thu, 04 Jan 2024 09:10:35 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJkJ-0000Tj-9e; Thu, 04 Jan 2024 09:10:35 +0000 Received: by outflank-mailman (input) for mailman id 661232; Thu, 04 Jan 2024 09:10:33 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbx-00085z-SJ for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:57 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id e5202d3e-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:01:49 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 437E621EE1; Thu, 4 Jan 2024 09:01:49 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 1D66513722; Thu, 4 Jan 2024 09:01:49 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id aGjfBf1zlmXEWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:49 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: e5202d3e-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 09/33] tools/xenlogd: add 9pfs walk request support Date: Thu, 4 Jan 2024 10:00:31 +0100 Message-Id: <20240104090055.27323-10-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: 437E621EE1 Add the walk request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - don't allow walking across symbolic links --- tools/xen-9pfsd/io.c | 172 ++++++++++++++++++++++++++++++++++++ tools/xen-9pfsd/xen-9pfsd.h | 1 + 2 files changed, 173 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 241f0df5e2..8aff33fd38 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -28,9 +28,11 @@ #define P9_CMD_VERSION 100 #define P9_CMD_ATTACH 104 #define P9_CMD_ERROR 107 +#define P9_CMD_WALK 110 #define P9_MIN_MSIZE 2048 #define P9_VERSION "9P2000.u" +#define P9_WALK_MAXELEM 16 struct p9_qid { uint8_t type; @@ -460,6 +462,21 @@ static struct p9_fid *find_fid(device *device, unsigned int fid) return NULL; } +static struct p9_fid *get_fid_ref(device *device, unsigned int fid) +{ + struct p9_fid *fidp; + + pthread_mutex_lock(&device->fid_mutex); + + fidp = find_fid(device, fid); + if ( fidp ) + fidp->ref++; + + pthread_mutex_unlock(&device->fid_mutex); + + return fidp; +} + static struct p9_fid *alloc_fid_mem(device *device, unsigned int fid, const char *path) { @@ -563,6 +580,10 @@ static int fill_qid(device *device, const char *path, struct p9_qid *qid, stbuf = &st; } + /* Don't allow symbolic links. */ + if ( S_ISLNK(stbuf->st_mode) ) + return EMLINK; + qid->type = S_ISDIR(stbuf->st_mode) ? QID_TYPE_DIR : 0; qid->version = stbuf->st_mtime ^ (stbuf->st_size << 8); qid->path = stbuf->st_ino; @@ -570,6 +591,20 @@ static int fill_qid(device *device, const char *path, struct p9_qid *qid, return 0; } +static bool name_ok(const char *str) +{ + if ( !*str ) + return false; + + if ( strchr(str, '/' ) ) + return false; + + if ( !strcmp(str, "..") || !strcmp(str, ".") ) + return false; + + return true; +} + static void p9_error(struct ring *ring, uint16_t tag, uint32_t err) { unsigned int erroff; @@ -647,6 +682,139 @@ static void p9_attach(struct ring *ring, struct p9_header *hdr) fill_buffer(ring, hdr->cmd + 1, hdr->tag, "Q", &qid); } +static void p9_walk(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + uint32_t newfid; + struct p9_fid *fidp = NULL; + struct p9_qid *qids = NULL; + unsigned int n_names = 0; + unsigned int *names = NULL; + unsigned int walked = 0; + unsigned int i; + char *path = NULL; + unsigned int path_len; + int ret; + + ret = fill_data(ring, "UUaS", &fid, &newfid, &n_names, &names); + if ( n_names > P9_WALK_MAXELEM ) + { + p9_error(ring, hdr->tag, EINVAL); + goto out; + } + if ( ret != 3 + n_names ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp ) + { + p9_error(ring, hdr->tag, ENOENT); + goto out; + } + if ( fidp->opened ) + { + p9_error(ring, hdr->tag, EINVAL); + goto out; + } + + path_len = strlen(fidp->path) + 1; + for ( i = 0; i < n_names; i++ ) + { + if ( !name_ok(ring->str + names[i]) ) + { + p9_error(ring, hdr->tag, ENOENT); + goto out; + } + path_len += strlen(ring->str + names[i]) + 1; + } + path = calloc(path_len + 1, 1); + if ( !path ) + { + p9_error(ring, hdr->tag, ENOMEM); + goto out; + } + strcpy(path, fidp->path); + + if ( n_names ) + { + qids = calloc(n_names, sizeof(*qids)); + if ( !qids ) + { + p9_error(ring, hdr->tag, ENOMEM); + goto out; + } + for ( i = 0; i < n_names; i++ ) + { + if (strcmp(path, "/")) + strcat(path, "/"); + strcat(path, ring->str + names[i]); + ret = fill_qid(device, path, qids + i, NULL); + if ( ret ) + { + if ( !walked ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + break; + } + walked++; + } + } + + if ( walked == n_names ) + { + bool ok = false; + + if ( fid == newfid ) + { + struct p9_fid *new_fidp; + + pthread_mutex_lock(&device->fid_mutex); + + if ( fidp->ref != 2 ) + { + errno = EBUSY; + } + else + { + new_fidp = alloc_fid_mem(device, fid, path); + if ( new_fidp ) + { + new_fidp->ref = 2; + XEN_TAILQ_REMOVE(&device->fids, fidp, list); + XEN_TAILQ_INSERT_HEAD(&device->fids, new_fidp, list); + free(fidp); + fidp = new_fidp; + ok = true; + } + } + + pthread_mutex_unlock(&device->fid_mutex); + } + else + ok = alloc_fid(device, newfid, path); + + if ( !ok ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + } + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "aQ", &walked, qids); + + out: + free_fid(device, fidp); + free(qids); + free(path); + free(names); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -710,6 +878,10 @@ void *io_thread(void *arg) p9_attach(ring, &hdr); break; + case P9_CMD_WALK: + p9_walk(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h index 6c755411a7..f01fffb0bb 100644 --- a/tools/xen-9pfsd/xen-9pfsd.h +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -25,6 +25,7 @@ struct p9_fid { XEN_TAILQ_ENTRY(struct p9_fid) list; unsigned int fid; unsigned int ref; + bool opened; char path[]; }; From patchwork Thu Jan 4 09:00:32 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510937 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id AE649C47074 for ; Thu, 4 Jan 2024 09:13:29 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661322.1031101 (Exim 4.92) (envelope-from ) id 1rLJn0-00006b-3s; Thu, 04 Jan 2024 09:13:22 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661322.1031101; Thu, 04 Jan 2024 09:13:22 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJn0-00006U-0x; Thu, 04 Jan 2024 09:13:22 +0000 Received: by outflank-mailman (input) for mailman id 661322; Thu, 04 Jan 2024 09:13:21 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJbw-0007Zm-LE for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:01:56 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id e86b9a0c-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:01:55 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id BDE611F7F8; Thu, 4 Jan 2024 09:01:54 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 9939813722; Thu, 4 Jan 2024 09:01:54 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id aokSJAJ0lmXMWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:01:54 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: e86b9a0c-aadf-11ee-9b0f-b553b5be7939 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 10/33] tools/xenlogd: add 9pfs open request support Date: Thu, 4 Jan 2024 10:00:32 +0100 Message-Id: <20240104090055.27323-11-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Queue-Id: BDE611F7F8 Add the open request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - don't allow to open symbolic link V3: - use openat() (Jason Andryuk) - use common error handling in p9_open() --- tools/xen-9pfsd/io.c | 139 ++++++++++++++++++++++++++++++++++++ tools/xen-9pfsd/xen-9pfsd.h | 4 ++ 2 files changed, 143 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 8aff33fd38..e7db90a972 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -19,6 +19,8 @@ #include #include #include +#include +#include #include /* For cpu barriers. */ #include @@ -29,6 +31,15 @@ #define P9_CMD_ATTACH 104 #define P9_CMD_ERROR 107 #define P9_CMD_WALK 110 +#define P9_CMD_OPEN 112 + +/* P9 protocol open flags. */ +#define P9_OREAD 0 /* read */ +#define P9_OWRITE 1 /* write */ +#define P9_ORDWR 2 /* read and write */ +#define P9_OMODEMASK 0x03 +#define P9_OTRUNC 0x10 /* or'ed in, truncate file first */ +#define P9_OREMOVE 0x40 /* or'ed in, remove file after clunk */ #define P9_MIN_MSIZE 2048 #define P9_VERSION "9P2000.u" @@ -815,6 +826,130 @@ static void p9_walk(struct ring *ring, struct p9_header *hdr) free(names); } +static int open_flags_from_mode(uint8_t mode) +{ + int flags; + + switch ( mode & P9_OMODEMASK ) + { + case P9_OREAD: + flags = O_RDONLY; + break; + + case P9_OWRITE: + flags = O_WRONLY; + break; + + case P9_ORDWR: + flags = O_RDWR; + break; + + default: + errno = EINVAL; + return -1; + } + + if ( mode & P9_OTRUNC ) + flags |= O_TRUNC; + + return flags; +} + +static unsigned int get_iounit(struct ring *ring, struct stat *st) +{ + return (ring->max_size - st->st_blksize) & ~(st->st_blksize - 1); +} + +static void p9_open(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + uint8_t mode; + struct p9_fid *fidp; + struct stat st; + struct p9_qid qid; + uint32_t iounit; + int flags; + int ret; + + ret = fill_data(ring, "Ub", &fid, &mode); + if ( ret != 2 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + if ( mode & ~(P9_OMODEMASK | P9_OTRUNC | P9_OREMOVE) ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp ) + { + p9_error(ring, hdr->tag, ENOENT); + return; + } + if ( fidp->opened ) + { + errno = EINVAL; + goto err; + } + + if ( fstatat(device->root_fd, relpath_from_path(fidp->path), &st, 0) < 0 ) + { + errno = ENOENT; + goto err; + } + + if ( S_ISLNK(st.st_mode) ) + { + errno = EMLINK; + goto err; + } + + fidp->isdir = S_ISDIR(st.st_mode); + fidp->mode = mode; + if ( fidp->isdir ) + { + if ( mode != P9_OREAD ) + { + errno = EINVAL; + goto err; + } + fidp->fd = openat(device->root_fd, relpath_from_path(fidp->path), + O_RDONLY); + if ( fidp->fd < 0 ) + goto err; + fidp->data = fdopendir(fidp->fd); + if ( !fidp->data ) + goto err; + } + else + { + flags = open_flags_from_mode(mode); + if ( flags < 0 ) + goto err; + + fidp->fd = openat(device->root_fd, relpath_from_path(fidp->path), + flags); + if ( fidp->fd < 0 ) + goto err; + } + + fill_qid(device, fidp->path, &qid, &st); + iounit = get_iounit(ring, &st); + fidp->opened = true; + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "QU", &qid, &iounit); + + return; + + err: + free_fid(device, fidp); + p9_error(ring, hdr->tag, errno); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -882,6 +1017,10 @@ void *io_thread(void *arg) p9_walk(ring, &hdr); break; + case P9_CMD_OPEN: + p9_open(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); diff --git a/tools/xen-9pfsd/xen-9pfsd.h b/tools/xen-9pfsd/xen-9pfsd.h index f01fffb0bb..757be2da4b 100644 --- a/tools/xen-9pfsd/xen-9pfsd.h +++ b/tools/xen-9pfsd/xen-9pfsd.h @@ -25,7 +25,11 @@ struct p9_fid { XEN_TAILQ_ENTRY(struct p9_fid) list; unsigned int fid; unsigned int ref; + int fd; + uint8_t mode; bool opened; + bool isdir; + void *data; /* File type specific. */ char path[]; }; From patchwork Thu Jan 4 09:00:33 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510931 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A345EC4707C for ; Thu, 4 Jan 2024 09:12:36 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661276.1031015 (Exim 4.92) (envelope-from ) id 1rLJm8-0003XS-1V; Thu, 04 Jan 2024 09:12:28 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661276.1031015; Thu, 04 Jan 2024 09:12:28 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm7-0003WF-SR; Thu, 04 Jan 2024 09:12:27 +0000 Received: by outflank-mailman (input) for mailman id 661276; Thu, 04 Jan 2024 09:12:26 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJc3-0007Zm-K2 for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:03 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id ebc0d355-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:02:00 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 4703521F8C; Thu, 4 Jan 2024 09:02:00 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 2237313722; Thu, 4 Jan 2024 09:02:00 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id Y/4kBwh0lmXVWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:00 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: ebc0d355-aadf-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358920; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=83zu8qXzCws1nGkvYOUtCjUN1acN1YTYVZrj0SieEXM=; b=MGBXku8Uqv5OTyrf79PNCpfNsXNldQC5y1DTA9g1JyasJsekDCw5e4NQEEiSeFwYln8i1m 9h4mZQ/14zo04logZ5vQjv+ZQAI3iWhZOiU3eKzP2gXO97LQwbMMKCXn1mQzwEW+VQsa0a +0oKfhkW9QXQJb2UQB+SrKWlLKlL98w= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358920; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=83zu8qXzCws1nGkvYOUtCjUN1acN1YTYVZrj0SieEXM=; b=MGBXku8Uqv5OTyrf79PNCpfNsXNldQC5y1DTA9g1JyasJsekDCw5e4NQEEiSeFwYln8i1m 9h4mZQ/14zo04logZ5vQjv+ZQAI3iWhZOiU3eKzP2gXO97LQwbMMKCXn1mQzwEW+VQsa0a +0oKfhkW9QXQJb2UQB+SrKWlLKlL98w= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 11/33] tools/xenlogd: add 9pfs clunk request support Date: Thu, 4 Jan 2024 10:00:33 +0100 Message-Id: <20240104090055.27323-12-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Spamd-Result: default: False [0.21 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCVD_COUNT_THREE(0.00)[3]; TO_DN_SOME(0.00)[]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-0.69)[83.29%] Authentication-Results: smtp-out1.suse.de; none Add the clunk request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V3: - use unlinkat() (Jason Andryuk) --- tools/xen-9pfsd/io.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index e7db90a972..4adef6715f 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -32,6 +32,7 @@ #define P9_CMD_ERROR 107 #define P9_CMD_WALK 110 #define P9_CMD_OPEN 112 +#define P9_CMD_CLUNK 120 /* P9 protocol open flags. */ #define P9_OREAD 0 /* read */ @@ -950,6 +951,44 @@ static void p9_open(struct ring *ring, struct p9_header *hdr) p9_error(ring, hdr->tag, errno); } +static void p9_clunk(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + struct p9_fid *fidp; + int ret; + + ret = fill_data(ring, "U", &fid); + if ( ret != 1 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp ) + { + p9_error(ring, hdr->tag, ENOENT); + return; + } + + if ( fidp->opened ) + { + fidp->opened = false; + free_fid(device, fidp); + close(fidp->fd); + if ( fidp->mode & P9_OREMOVE ) + unlinkat(device->root_fd, relpath_from_path(fidp->path), + fidp->isdir ? AT_REMOVEDIR : 0); + } + + /* 2 calls of free_fid(): one for our reference, and one to free it. */ + free_fid(device, fidp); + free_fid(device, fidp); + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, ""); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -1021,6 +1060,10 @@ void *io_thread(void *arg) p9_open(ring, &hdr); break; + case P9_CMD_CLUNK: + p9_clunk(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); From patchwork Thu Jan 4 09:00:34 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510934 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A60B7C4707B for ; Thu, 4 Jan 2024 09:12:59 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661296.1031061 (Exim 4.92) (envelope-from ) id 1rLJmU-00067O-L6; Thu, 04 Jan 2024 09:12:50 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661296.1031061; Thu, 04 Jan 2024 09:12:50 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJmU-00066x-Hj; Thu, 04 Jan 2024 09:12:50 +0000 Received: by outflank-mailman (input) for mailman id 661296; Thu, 04 Jan 2024 09:12:49 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJc8-0007Zm-7Y for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:08 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id ef0dd399-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:02:06 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id C75D921F8C; Thu, 4 Jan 2024 09:02:05 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id A1CE513722; Thu, 4 Jan 2024 09:02:05 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id Q5AiJg10lmXYWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:05 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: ef0dd399-aadf-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358925; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=u9IiqoAT56C+h23tOpIynn8xmHY6LcxxwPGqEgbggL8=; b=NIhr69+OtpqXstkMNcDOKP0hbE+nWmJOYDF4ITusVK6zKDXPfIdNKXx7hYm3pnjL8y+Kdd 9btmPoyXHbrF5GRjVMwY+DG3emoadrQ0q2nhzKKbnYJipTQCLJssGnyUeLDdY/6K75w2sK 2ENuFPrvJz5KUHd8OTMuPrAGGmp0gl4= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358925; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=u9IiqoAT56C+h23tOpIynn8xmHY6LcxxwPGqEgbggL8=; b=NIhr69+OtpqXstkMNcDOKP0hbE+nWmJOYDF4ITusVK6zKDXPfIdNKXx7hYm3pnjL8y+Kdd 9btmPoyXHbrF5GRjVMwY+DG3emoadrQ0q2nhzKKbnYJipTQCLJssGnyUeLDdY/6K75w2sK 2ENuFPrvJz5KUHd8OTMuPrAGGmp0gl4= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 12/33] tools/xenlogd: add 9pfs create request support Date: Thu, 4 Jan 2024 10:00:34 +0100 Message-Id: <20240104090055.27323-13-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Spamd-Result: default: False [-2.10 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCVD_COUNT_THREE(0.00)[3]; TO_DN_SOME(0.00)[]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-3.00)[100.00%] Authentication-Results: smtp-out1.suse.de; none Add the create request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - set permissions correctly (Jason Andryuk) V3: - use opendirat() etc. (Jason Andryuk) - rework error handling a little bit --- tools/xen-9pfsd/io.c | 155 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 4adef6715f..9d816dc97e 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -32,6 +32,7 @@ #define P9_CMD_ERROR 107 #define P9_CMD_WALK 110 #define P9_CMD_OPEN 112 +#define P9_CMD_CREATE 114 #define P9_CMD_CLUNK 120 /* P9 protocol open flags. */ @@ -42,6 +43,12 @@ #define P9_OTRUNC 0x10 /* or'ed in, truncate file first */ #define P9_OREMOVE 0x40 /* or'ed in, remove file after clunk */ +/* P9 protocol create permission masks. */ +#define P9_CREATE_PERM_DIR 0x80000000 +#define P9_CREATE_PERM_NOTSUPP 0x03b00000 /* link, symlink, ... */ +#define P9_CREATE_PERM_DIR_MASK 0777 +#define P9_CREATE_PERM_FILE_MASK 0666 + #define P9_MIN_MSIZE 2048 #define P9_VERSION "9P2000.u" #define P9_WALK_MAXELEM 16 @@ -951,6 +958,150 @@ static void p9_open(struct ring *ring, struct p9_header *hdr) p9_error(ring, hdr->tag, errno); } +static void p9_create(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + unsigned int name_off; + uint32_t perm; + uint8_t mode; + unsigned int ext_off; + struct p9_fid *fidp; + struct p9_fid *new_fidp; + char *path; + const char *relpath; + struct stat st; + struct p9_qid qid; + uint32_t iounit; + int flags; + int ret; + + ret = fill_data(ring, "USUbS", &fid, &name_off, &perm, &mode, &ext_off); + if ( ret != 5 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + if ( !name_ok(ring->str + name_off) ) + { + p9_error(ring, hdr->tag, ENOENT); + return; + } + + if ( perm & P9_CREATE_PERM_NOTSUPP ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp || fidp->opened ) + { + free_fid(device, fidp); + p9_error(ring, hdr->tag, EINVAL); + return; + } + if ( fstatat(device->root_fd, relpath_from_path(fidp->path), &st, 0) < 0 ) + { + free_fid(device, fidp); + p9_error(ring, hdr->tag, errno); + return; + } + + path = malloc(strlen(fidp->path) + strlen(ring->str + name_off) + 2); + if ( !path ) + { + free_fid(device, fidp); + p9_error(ring, hdr->tag, ENOMEM); + return; + } + sprintf(path, "%s/%s", strcmp(fidp->path, "/") ? fidp->path : "", + ring->str + name_off); + new_fidp = alloc_fid_mem(device, fid, path); + free(path); + if ( !new_fidp ) + { + free_fid(device, fidp); + p9_error(ring, hdr->tag, ENOMEM); + return; + } + + relpath = relpath_from_path(new_fidp->path); + + pthread_mutex_lock(&device->fid_mutex); + + new_fidp->ref = fidp->ref; + + if ( perm & P9_CREATE_PERM_DIR ) + { + perm &= P9_CREATE_PERM_DIR_MASK & st.st_mode; + if ( mode != P9_OREAD ) + { + errno = EINVAL; + goto err; + } + if ( mkdirat(device->root_fd, relpath, perm) < 0 ) + goto err; + + XEN_TAILQ_REMOVE(&device->fids, fidp, list); + XEN_TAILQ_INSERT_HEAD(&device->fids, new_fidp, list); + free(fidp); + fidp = new_fidp; + new_fidp = NULL; + + fidp->fd = openat(device->root_fd, relpath, O_RDONLY); + if ( fidp->fd < 0 ) + goto err; + fidp->data = fdopendir(fidp->fd); + if ( !fidp->data ) + goto err; + } + else + { + flags = open_flags_from_mode(mode); + if ( flags < 0 ) + { + errno = EINVAL; + goto err; + } + perm &= P9_CREATE_PERM_FILE_MASK & st.st_mode; + + XEN_TAILQ_REMOVE(&device->fids, fidp, list); + XEN_TAILQ_INSERT_HEAD(&device->fids, new_fidp, list); + free(fidp); + fidp = new_fidp; + new_fidp = NULL; + + fidp->fd = openat(device->root_fd, relpath, flags | O_CREAT | O_EXCL, + perm); + if ( fidp->fd < 0 ) + goto err; + } + + if ( fstatat(device->root_fd, relpath, &st, 0) < 0 ) + goto err; + + fill_qid(device, fidp->path, &qid, &st); + iounit = get_iounit(ring, &st); + fidp->opened = true; + fidp->mode = mode; + + pthread_mutex_unlock(&device->fid_mutex); + + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "QU", &qid, &iounit); + + return; + + err: + p9_error(ring, hdr->tag, errno); + + pthread_mutex_unlock(&device->fid_mutex); + + free(new_fidp); + free_fid(device, fidp); +} + static void p9_clunk(struct ring *ring, struct p9_header *hdr) { device *device = ring->device; @@ -1060,6 +1211,10 @@ void *io_thread(void *arg) p9_open(ring, &hdr); break; + case P9_CMD_CREATE: + p9_create(ring, &hdr); + break; + case P9_CMD_CLUNK: p9_clunk(ring, &hdr); break; From patchwork Thu Jan 4 09:00:35 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510929 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7E5A1C47074 for ; Thu, 4 Jan 2024 09:12:36 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661281.1031034 (Exim 4.92) (envelope-from ) id 1rLJm9-0003uM-8S; Thu, 04 Jan 2024 09:12:29 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661281.1031034; Thu, 04 Jan 2024 09:12:29 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm8-0003ra-VT; Thu, 04 Jan 2024 09:12:28 +0000 Received: by outflank-mailman (input) for mailman id 661281; Thu, 04 Jan 2024 09:12:26 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcD-0007Zm-C2 for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:13 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id f254ffa5-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:02:11 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 4E93721EE1; Thu, 4 Jan 2024 09:02:11 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 2963E13722; Thu, 4 Jan 2024 09:02:11 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id QhXeCBN0lmXlWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:11 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: f254ffa5-aadf-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358931; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=H8wa9pWvrMOGw1akjDhfhUuR8F7bLlS3/Tu/6p/vKMw=; b=NyPjfCnUel768c1HJYvf92BSkfRaB74bir+jAuLF/c4m3dvbFqyKScxmWz3g/kE7yB1sGP N4JjFGw1jonvOMzB6Ba2oU1hWRDfrNNcsbFzmuT83zhveATgAK2RPy4giTnpkdJOgjhdmC dxmrphTSvM5sH7TVzAzuRuFgNAjPVg4= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358931; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=H8wa9pWvrMOGw1akjDhfhUuR8F7bLlS3/Tu/6p/vKMw=; b=NyPjfCnUel768c1HJYvf92BSkfRaB74bir+jAuLF/c4m3dvbFqyKScxmWz3g/kE7yB1sGP N4JjFGw1jonvOMzB6Ba2oU1hWRDfrNNcsbFzmuT83zhveATgAK2RPy4giTnpkdJOgjhdmC dxmrphTSvM5sH7TVzAzuRuFgNAjPVg4= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD Subject: [PATCH v3 13/33] tools/xenlogd: add 9pfs stat request support Date: Thu, 4 Jan 2024 10:00:35 +0100 Message-Id: <20240104090055.27323-14-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [1.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCVD_COUNT_THREE(0.00)[3]; TO_DN_SOME(0.00)[]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-3.00)[100.00%] Add the stat request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V3: - use fstatat() (Jason Andryuk) --- tools/xen-9pfsd/io.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 9d816dc97e..7d40747b60 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -34,6 +34,7 @@ #define P9_CMD_OPEN 112 #define P9_CMD_CREATE 114 #define P9_CMD_CLUNK 120 +#define P9_CMD_STAT 124 /* P9 protocol open flags. */ #define P9_OREAD 0 /* read */ @@ -60,6 +61,25 @@ struct p9_qid { uint64_t path; }; +struct p9_stat { + uint16_t size; + uint16_t type; + uint32_t dev; + struct p9_qid qid; + uint32_t mode; + uint32_t atime; + uint32_t mtime; + uint64_t length; + const char *name; + const char *uid; + const char *gid; + const char *muid; + const char *extension; + uint32_t n_uid; + uint32_t n_gid; + uint32_t n_muid; +}; + /* * Note that the ring names "in" and "out" are from the frontend's * perspective, so the "in" ring will be used for responses to the frontend, @@ -1140,6 +1160,75 @@ static void p9_clunk(struct ring *ring, struct p9_header *hdr) fill_buffer(ring, hdr->cmd + 1, hdr->tag, ""); } +static void fill_p9_stat(device *device, struct p9_stat *p9s, struct stat *st, + const char *name) +{ + memset(p9s, 0, sizeof(*p9s)); + fill_qid(device, NULL, &p9s->qid, st); + p9s->mode = st->st_mode & 0777; + if ( S_ISDIR(st->st_mode) ) + p9s->mode |= P9_CREATE_PERM_DIR; + p9s->atime = st->st_atime; + p9s->mtime = st->st_mtime; + p9s->length = st->st_size; + p9s->name = name; + p9s->uid = ""; + p9s->gid = ""; + p9s->muid = ""; + p9s->extension = ""; + p9s->n_uid = 0; + p9s->n_gid = 0; + p9s->n_muid = 0; + + /* + * Size of individual fields without the size field, including 5 2-byte + * string length fields. + */ + p9s->size = 71 + strlen(p9s->name); +} + +static void p9_stat(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + struct p9_fid *fidp; + struct p9_stat p9s; + struct stat st; + uint16_t total_length; + int ret; + + ret = fill_data(ring, "U", &fid); + if ( ret != 1 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp ) + { + p9_error(ring, hdr->tag, ENOENT); + return; + } + + if ( fstatat(device->root_fd, relpath_from_path(fidp->path), &st, 0) < 0 ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + fill_p9_stat(device, &p9s, &st, strrchr(fidp->path, '/') + 1); + + total_length = p9s.size + sizeof(p9s.size); + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "uuuUQUUULSSSSSUUU", + &total_length, &p9s.size, &p9s.type, &p9s.dev, &p9s.qid, + &p9s.mode, &p9s.atime, &p9s.mtime, &p9s.length, p9s.name, + p9s.uid, p9s.gid, p9s.muid, p9s.extension, &p9s.n_uid, + &p9s.n_gid, &p9s.n_muid); + + out: + free_fid(device, fidp); +} + void *io_thread(void *arg) { struct ring *ring = arg; @@ -1219,6 +1308,10 @@ void *io_thread(void *arg) p9_clunk(ring, &hdr); break; + case P9_CMD_STAT: + p9_stat(ring, &hdr); + break; + default: syslog(LOG_DEBUG, "%u.%u sent unhandled command %u\n", ring->device->domid, ring->device->devid, hdr.cmd); From patchwork Thu Jan 4 09:00:36 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510927 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4DE25C47073 for ; Thu, 4 Jan 2024 09:12:34 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661274.1031010 (Exim 4.92) (envelope-from ) id 1rLJm7-0003UL-NG; Thu, 04 Jan 2024 09:12:27 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661274.1031010; Thu, 04 Jan 2024 09:12:27 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm7-0003U3-KG; Thu, 04 Jan 2024 09:12:27 +0000 Received: by outflank-mailman (input) for mailman id 661274; Thu, 04 Jan 2024 09:12:25 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcH-00085z-LY for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:17 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id f590f3ed-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:17 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id D0BF721EE1; Thu, 4 Jan 2024 09:02:16 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id A630413722; Thu, 4 Jan 2024 09:02:16 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id PwgpJxh0lmXpWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:16 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: f590f3ed-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 14/33] tools/xenlogd: add 9pfs write request support Date: Thu, 4 Jan 2024 10:00:36 +0100 Message-Id: <20240104090055.27323-15-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: D0BF721EE1 Add the write request of the 9pfs protocol. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- tools/xen-9pfsd/io.c | 54 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index 7d40747b60..c357342a91 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -33,6 +33,7 @@ #define P9_CMD_WALK 110 #define P9_CMD_OPEN 112 #define P9_CMD_CREATE 114 +#define P9_CMD_WRITE 118 #define P9_CMD_CLUNK 120 #define P9_CMD_STAT 124 @@ -1122,6 +1123,55 @@ static void p9_create(struct ring *ring, struct p9_header *hdr) free_fid(device, fidp); } +static void p9_write(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + uint64_t off; + unsigned int len; + uint32_t written; + void *buf; + struct p9_fid *fidp; + int ret; + + ret = fill_data(ring, "ULD", &fid, &off, &len, ring->buffer); + if ( ret != 3 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp || !fidp->opened || fidp->isdir ) + { + p9_error(ring, hdr->tag, EBADF); + goto out; + } + + buf = ring->buffer; + + while ( len != 0 ) + { + ret = pwrite(fidp->fd, buf, len, off); + if ( ret < 0 ) + break; + len -= ret; + buf += ret; + off += ret; + } + + written = buf - ring->buffer; + if ( written == 0 ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "U", &written); + + out: + free_fid(device, fidp); +} + static void p9_clunk(struct ring *ring, struct p9_header *hdr) { device *device = ring->device; @@ -1304,6 +1354,10 @@ void *io_thread(void *arg) p9_create(ring, &hdr); break; + case P9_CMD_WRITE: + p9_write(ring, &hdr); + break; + case P9_CMD_CLUNK: p9_clunk(ring, &hdr); break; From patchwork Thu Jan 4 09:00:37 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510941 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 1F6EFC47074 for ; Thu, 4 Jan 2024 09:14:40 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661343.1031141 (Exim 4.92) (envelope-from ) id 1rLJo6-0002jv-Ee; Thu, 04 Jan 2024 09:14:30 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661343.1031141; Thu, 04 Jan 2024 09:14:30 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJo6-0002jo-C2; Thu, 04 Jan 2024 09:14:30 +0000 Received: by outflank-mailman (input) for mailman id 661343; Thu, 04 Jan 2024 09:14:28 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcO-0007Zm-6w for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:24 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id f8df8a52-aadf-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:02:22 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 5C55B1F7F8; Thu, 4 Jan 2024 09:02:22 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 3247513722; Thu, 4 Jan 2024 09:02:22 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id qDXrCh50lmXtWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:22 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: f8df8a52-aadf-11ee-9b0f-b553b5be7939 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 15/33] tools/xenlogd: add 9pfs read request support Date: Thu, 4 Jan 2024 10:00:37 +0100 Message-Id: <20240104090055.27323-16-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 5C55B1F7F8 Add the read request of the 9pfs protocol. For now support only reading plain files (no directories). Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - make error check more readable (Jason Andryuk) --- tools/xen-9pfsd/io.c | 64 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/tools/xen-9pfsd/io.c b/tools/xen-9pfsd/io.c index c357342a91..651c5cbb2b 100644 --- a/tools/xen-9pfsd/io.c +++ b/tools/xen-9pfsd/io.c @@ -33,6 +33,7 @@ #define P9_CMD_WALK 110 #define P9_CMD_OPEN 112 #define P9_CMD_CREATE 114 +#define P9_CMD_READ 116 #define P9_CMD_WRITE 118 #define P9_CMD_CLUNK 120 #define P9_CMD_STAT 124 @@ -1123,6 +1124,65 @@ static void p9_create(struct ring *ring, struct p9_header *hdr) free_fid(device, fidp); } +static void p9_read(struct ring *ring, struct p9_header *hdr) +{ + device *device = ring->device; + uint32_t fid; + uint64_t off; + unsigned int len; + uint32_t count; + void *buf; + struct p9_fid *fidp; + int ret; + + ret = fill_data(ring, "ULU", &fid, &off, &count); + if ( ret != 3 ) + { + p9_error(ring, hdr->tag, EINVAL); + return; + } + + fidp = get_fid_ref(device, fid); + if ( !fidp || !fidp->opened ) + { + p9_error(ring, hdr->tag, EBADF); + goto out; + } + + if ( fidp->isdir ) + { + p9_error(ring, hdr->tag, EOPNOTSUPP); + goto out; + } + else + { + len = count; + buf = ring->buffer + sizeof(*hdr) + sizeof(uint32_t); + + while ( len != 0 ) + { + ret = pread(fidp->fd, buf, len, off); + if ( ret <= 0 ) + break; + len -= ret; + buf += ret; + off += ret; + } + if ( ret < 0 && len == count ) + { + p9_error(ring, hdr->tag, errno); + goto out; + } + + buf = ring->buffer + sizeof(*hdr) + sizeof(uint32_t); + len = count - len; + fill_buffer(ring, hdr->cmd + 1, hdr->tag, "D", &len, buf); + } + + out: + free_fid(device, fidp); +} + static void p9_write(struct ring *ring, struct p9_header *hdr) { device *device = ring->device; @@ -1354,6 +1414,10 @@ void *io_thread(void *arg) p9_create(ring, &hdr); break; + case P9_CMD_READ: + p9_read(ring, &hdr); + break; + case P9_CMD_WRITE: p9_write(ring, &hdr); break; From patchwork Thu Jan 4 09:00:38 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510938 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 38158C47074 for ; Thu, 4 Jan 2024 09:13:35 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661324.1031111 (Exim 4.92) (envelope-from ) id 1rLJn4-0000Tc-DX; Thu, 04 Jan 2024 09:13:26 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661324.1031111; Thu, 04 Jan 2024 09:13:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJn4-0000TV-Al; Thu, 04 Jan 2024 09:13:26 +0000 Received: by outflank-mailman (input) for mailman id 661324; Thu, 04 Jan 2024 09:13:24 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcT-00085z-4E for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:29 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id fc311d61-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:28 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id ECFDB1F7FA; Thu, 4 Jan 2024 09:02:27 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id B20CE13722; Thu, 4 Jan 2024 09:02:27 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id L80rKiN0lmXwWAAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:27 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: fc311d61-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , George Dunlap , Nick Rosbrook , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 16/33] tools/libs/light: add backend type for 9pfs PV devices Date: Thu, 4 Jan 2024 10:00:38 +0100 Message-Id: <20240104090055.27323-17-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Queue-Id: ECFDB1F7FA Make the backend type of 9pfs PV devices configurable. The default is "qemu" with the related Xenstore backend-side directory being "9pfs". Add another type "xen-9pfsd" with the related Xenstore backend-side directory "xen_9pfs". As additional security features it is possible to specify: - "max-space" for limiting the maximum space consumed on the filesystem in MBs - "max-files" for limiting the maximum number of files in the filesystem - "max-open-files" for limiting the maximum number of concurrent open files For convenience "auto-delete" is available to let the backend delete the oldest file of the guest in case otherwise "max-space" or "max-files" would be violated. The xen-9pfsd daemon will be started by libxenlight automatically when the first "xen_9pfs" device is being created. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Acked-by: George Dunlap --- V3: - regenerate go bindings --- tools/golang/xenlight/helpers.gen.go | 10 ++ tools/golang/xenlight/types.gen.go | 12 ++ tools/libs/light/libxl_9pfs.c | 145 +++++++++++++++++++++- tools/libs/light/libxl_create.c | 4 +- tools/libs/light/libxl_dm.c | 2 +- tools/libs/light/libxl_types.idl | 11 ++ tools/libs/light/libxl_types_internal.idl | 1 + 7 files changed, 178 insertions(+), 7 deletions(-) diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go index 35e209ff1b..72bcb918f7 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -2434,6 +2434,11 @@ x.Tag = C.GoString(xc.tag) x.Path = C.GoString(xc.path) x.SecurityModel = C.GoString(xc.security_model) x.Devid = Devid(xc.devid) +x.Type = P9Type(xc._type) +x.MaxSpace = int(xc.max_space) +x.MaxFiles = int(xc.max_files) +x.MaxOpenFiles = int(xc.max_open_files) +x.AutoDelete = bool(xc.auto_delete) return nil} @@ -2452,6 +2457,11 @@ xc.path = C.CString(x.Path)} if x.SecurityModel != "" { xc.security_model = C.CString(x.SecurityModel)} xc.devid = C.libxl_devid(x.Devid) +xc._type = C.libxl_p9_type(x.Type) +xc.max_space = C.int(x.MaxSpace) +xc.max_files = C.int(x.MaxFiles) +xc.max_open_files = C.int(x.MaxOpenFiles) +xc.auto_delete = C.bool(x.AutoDelete) return nil } diff --git a/tools/golang/xenlight/types.gen.go b/tools/golang/xenlight/types.gen.go index 7907aa8999..4ca5d2b332 100644 --- a/tools/golang/xenlight/types.gen.go +++ b/tools/golang/xenlight/types.gen.go @@ -122,6 +122,13 @@ NicTypeVifIoemu NicType = 1 NicTypeVif NicType = 2 ) +type P9Type int +const( +P9TypeUnknown P9Type = 0 +P9TypeQemu P9Type = 1 +P9TypeXen9Pfsd P9Type = 2 +) + type ActionOnShutdown int const( ActionOnShutdownDestroy ActionOnShutdown = 1 @@ -888,6 +895,11 @@ Tag string Path string SecurityModel string Devid Devid +Type P9Type +MaxSpace int +MaxFiles int +MaxOpenFiles int +AutoDelete bool } type DevicePvcallsif struct { diff --git a/tools/libs/light/libxl_9pfs.c b/tools/libs/light/libxl_9pfs.c index 5ab0d3aa21..486bc4326e 100644 --- a/tools/libs/light/libxl_9pfs.c +++ b/tools/libs/light/libxl_9pfs.c @@ -33,20 +33,159 @@ static int libxl__set_xenstore_p9(libxl__gc *gc, uint32_t domid, flexarray_append_pair(front, "tag", p9->tag); + if (p9->type == LIBXL_P9_TYPE_XEN_9PFSD) { + flexarray_append_pair(back, "max-space", + GCSPRINTF("%u", p9->max_space)); + flexarray_append_pair(back, "max-files", + GCSPRINTF("%u", p9->max_files)); + flexarray_append_pair(back, "max-open-files", + GCSPRINTF("%u", p9->max_open_files)); + flexarray_append_pair(back, "auto-delete", + p9->auto_delete ? "1" : "0"); + } + + return 0; +} + +static int libxl__device_from_p9(libxl__gc *gc, uint32_t domid, + libxl_device_p9 *type, libxl__device *device) +{ + device->backend_devid = type->devid; + device->backend_domid = type->backend_domid; + device->backend_kind = type->type == LIBXL_P9_TYPE_QEMU + ? LIBXL__DEVICE_KIND_9PFS + : LIBXL__DEVICE_KIND_XEN_9PFS; + device->devid = type->devid; + device->domid = domid; + device->kind = LIBXL__DEVICE_KIND_9PFS; + return 0; } -#define libxl__add_p9s NULL +static int libxl_device_p9_dm_needed(void *e, unsigned domid) +{ + libxl_device_p9 *elem = e; + + return elem->type == LIBXL_P9_TYPE_QEMU && elem->backend_domid == domid; +} + +typedef struct libxl__aop9_state libxl__aop9_state; + +struct libxl__aop9_state { + libxl__spawn_state spawn; + libxl__ao_device *aodev; + libxl_device_p9 *p9; + uint32_t domid; + void (*callback)(libxl__egc *, libxl__aop9_state *, int); +}; + +static void xen9pfsd_spawn_outcome(libxl__egc *egc, libxl__aop9_state *aop9, + int rc) +{ + aop9->aodev->rc = rc; + if (rc) + aop9->aodev->callback(egc, aop9->aodev); + else + libxl__device_add_async(egc, aop9->domid, &libxl__p9_devtype, + aop9->p9, aop9->aodev); +} + +static void xen9pfsd_confirm(libxl__egc *egc, libxl__spawn_state *spawn, + const char *xsdata) +{ + STATE_AO_GC(spawn->ao); + + if (!xsdata) + return; + + if (strcmp(xsdata, "running")) + return; + + libxl__spawn_initiate_detach(gc, spawn); +} + +static void xen9pfsd_failed(libxl__egc *egc, libxl__spawn_state *spawn, int rc) +{ + libxl__aop9_state *aop9 = CONTAINER_OF(spawn, *aop9, spawn); + + xen9pfsd_spawn_outcome(egc, aop9, rc); +} + +static void xen9pfsd_detached(libxl__egc *egc, libxl__spawn_state *spawn) +{ + libxl__aop9_state *aop9 = CONTAINER_OF(spawn, *aop9, spawn); + + xen9pfsd_spawn_outcome(egc, aop9, 0); +} + +static int xen9pfsd_spawn(libxl__egc *egc, uint32_t domid, libxl_device_p9 *p9, + libxl__ao_device *aodev) +{ + STATE_AO_GC(aodev->ao); + struct libxl__aop9_state *aop9; + int rc; + char *args[] = { "xen-9pfsd", NULL }; + char *path = GCSPRINTF("/local/domain/%u/libxl/xen-9pfs", + p9->backend_domid); + + if (p9->type != LIBXL_P9_TYPE_XEN_9PFSD || + libxl__xs_read(gc, XBT_NULL, GCSPRINTF("%s/state", path))) + return 0; + + GCNEW(aop9); + aop9->aodev = aodev; + aop9->p9 = p9; + aop9->domid = domid; + aop9->callback = xen9pfsd_spawn_outcome; + + aop9->spawn.ao = aodev->ao; + aop9->spawn.what = "xen-9pfs daemon"; + aop9->spawn.xspath = GCSPRINTF("%s/state", path); + aop9->spawn.timeout_ms = LIBXL_DEVICE_MODEL_START_TIMEOUT * 1000; + aop9->spawn.pidpath = GCSPRINTF("%s/pid", path); + aop9->spawn.midproc_cb = libxl__spawn_record_pid; + aop9->spawn.confirm_cb = xen9pfsd_confirm; + aop9->spawn.failure_cb = xen9pfsd_failed; + aop9->spawn.detached_cb = xen9pfsd_detached; + rc = libxl__spawn_spawn(egc, &aop9->spawn); + if (rc < 0) + return rc; + if (!rc) { + setsid(); + libxl__exec(gc, -1, -1, -1, LIBEXEC_BIN "/xen-9pfsd", args, NULL); + } + + return 1; +} + +static void libxl__device_p9_add(libxl__egc *egc, uint32_t domid, + libxl_device_p9 *p9, + libxl__ao_device *aodev) +{ + int rc; + + rc = xen9pfsd_spawn(egc, domid, p9, aodev); + if (rc == 1) + return; + + if (rc == 0) + libxl__device_add_async(egc, domid, &libxl__p9_devtype, p9, aodev); + + aodev->rc = rc; + if (rc) + aodev->callback(egc, aodev); +} + #define libxl_device_p9_list NULL #define libxl_device_p9_compare NULL static LIBXL_DEFINE_UPDATE_DEVID(p9) -static LIBXL_DEFINE_DEVICE_FROM_TYPE(p9) +static LIBXL_DEFINE_DEVICES_ADD(p9) LIBXL_DEFINE_DEVICE_REMOVE(p9) DEFINE_DEVICE_TYPE_STRUCT(p9, 9PFS, p9s, - .skip_attach = 1, .set_xenstore_config = (device_set_xenstore_config_fn_t) libxl__set_xenstore_p9, + .dm_needed = libxl_device_p9_dm_needed, ); diff --git a/tools/libs/light/libxl_create.c b/tools/libs/light/libxl_create.c index ce1d431103..b19e9379b6 100644 --- a/tools/libs/light/libxl_create.c +++ b/tools/libs/light/libxl_create.c @@ -1760,9 +1760,6 @@ static void domcreate_launch_dm(libxl__egc *egc, libxl__multidev *multidev, libxl__device_console_dispose(&console); } - for (i = 0; i < d_config->num_p9s; i++) - libxl__device_add(gc, domid, &libxl__p9_devtype, &d_config->p9s[i]); - for (i = 0; i < d_config->num_pvcallsifs; i++) libxl__device_add(gc, domid, &libxl__pvcallsif_devtype, &d_config->pvcallsifs[i]); @@ -1899,6 +1896,7 @@ const libxl__device_type *device_type_tbl[] = { &libxl__vdispl_devtype, &libxl__vsnd_devtype, &libxl__virtio_devtype, + &libxl__p9_devtype, NULL }; diff --git a/tools/libs/light/libxl_dm.c b/tools/libs/light/libxl_dm.c index 14b593110f..2aaaeb5aa7 100644 --- a/tools/libs/light/libxl_dm.c +++ b/tools/libs/light/libxl_dm.c @@ -3761,7 +3761,7 @@ int libxl__need_xenpv_qemu(libxl__gc *gc, libxl_domain_config *d_config) goto out; } - if (d_config->num_vfbs > 0 || d_config->num_p9s > 0) { + if (d_config->num_vfbs > 0) { ret = 1; goto out; } diff --git a/tools/libs/light/libxl_types.idl b/tools/libs/light/libxl_types.idl index 7d8bd5d216..82565c4c10 100644 --- a/tools/libs/light/libxl_types.idl +++ b/tools/libs/light/libxl_types.idl @@ -150,6 +150,12 @@ libxl_nic_type = Enumeration("nic_type", [ (2, "VIF"), ]) +libxl_p9_type = Enumeration("p9_type", [ + (0, "unknown"), + (1, "qemu"), + (2, "xen_9pfsd"), + ]) + libxl_action_on_shutdown = Enumeration("action_on_shutdown", [ (1, "DESTROY"), @@ -942,6 +948,11 @@ libxl_device_p9 = Struct("device_p9", [ ("path", string), ("security_model", string), ("devid", libxl_devid), + ("type", libxl_p9_type), + ("max_space", integer), + ("max_files", integer), + ("max_open_files", integer), + ("auto_delete", bool), ]) libxl_device_pvcallsif = Struct("device_pvcallsif", [ diff --git a/tools/libs/light/libxl_types_internal.idl b/tools/libs/light/libxl_types_internal.idl index e24288f1a5..39da71cef5 100644 --- a/tools/libs/light/libxl_types_internal.idl +++ b/tools/libs/light/libxl_types_internal.idl @@ -34,6 +34,7 @@ libxl__device_kind = Enumeration("device_kind", [ (16, "VINPUT"), (17, "VIRTIO_DISK"), (18, "VIRTIO"), + (19, "XEN_9PFS"), ]) libxl__console_backend = Enumeration("console_backend", [ From patchwork Thu Jan 4 09:00:39 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510936 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 20217C4707B for ; Thu, 4 Jan 2024 09:13:04 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661305.1031091 (Exim 4.92) (envelope-from ) id 1rLJmZ-00076O-Rd; Thu, 04 Jan 2024 09:12:55 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661305.1031091; Thu, 04 Jan 2024 09:12:55 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJmZ-00076F-O7; Thu, 04 Jan 2024 09:12:55 +0000 Received: by outflank-mailman (input) for mailman id 661305; Thu, 04 Jan 2024 09:12:54 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcY-00085z-CH for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:34 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id ff7cdd4a-aadf-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:33 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 779F41F7F8; Thu, 4 Jan 2024 09:02:33 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 4C03013722; Thu, 4 Jan 2024 09:02:33 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id RjdAESl0lmUBWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:33 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: ff7cdd4a-aadf-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 17/33] tools/xl: support new 9pfs backend xen-9pfsd Date: Thu, 4 Jan 2024 10:00:39 +0100 Message-Id: <20240104090055.27323-18-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Queue-Id: 779F41F7F8 Add support for the new 9pfs backend "xen-9pfsd". For this backend type the tag defaults to "Xen" and the host side path to "/var/log/xen/guests/". Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - test max_files and max_open_files, too (Jason Andryuk) --- docs/man/xl.cfg.5.pod.in | 36 ++++++++++++++++++++++++++++++++++-- tools/xl/xl_parse.c | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 2 deletions(-) diff --git a/docs/man/xl.cfg.5.pod.in b/docs/man/xl.cfg.5.pod.in index 2e234b450e..80011adbf3 100644 --- a/docs/man/xl.cfg.5.pod.in +++ b/docs/man/xl.cfg.5.pod.in @@ -772,10 +772,16 @@ settings, from the following list: =over 4 +=item B + +The backendtype for the PV device. Supported values are B and +B. The default is B. + =item B 9pfs tag to identify the filesystem share. The tag is needed on the -guest side to mount it. +guest side to mount it. For the backendtype of B the tag defaults to +"Xen". =item B @@ -785,12 +791,38 @@ squash or remap). =item B -Filesystem path on the backend to export. +Filesystem path on the backend to export. For the backendtype of B +the path defaults to "@XEN_LOG_DIR@/guests/". =item B Specify the backend domain name or id, defaults to dom0. +=item B + +Specify the maximum number of files below B. A value of 0 (which +is the default) doesn't limit the number of files. Only valid for +B. + +=item B + +Specify the maximum number of concurrently opened files below B. +Multiple opens of the same file are counted individually. Only valid for +B, which has a default of B. + +=item B + +Specify the maximum used disk space in MiB below B. A value of 0 (which +is the default) doesn't limit the usable disk space. Only valid for +B. + +=item B + +When set the backend will delete the oldest file which is currently not +opened by the guest in case the disk space limit set via B or the +file limit set via B is being reached. Only valid for +B. + =back =item B diff --git a/tools/xl/xl_parse.c b/tools/xl/xl_parse.c index ed983200c3..3ded557ebc 100644 --- a/tools/xl/xl_parse.c +++ b/tools/xl/xl_parse.c @@ -2232,6 +2232,20 @@ void parse_config_data(const char *config_source, replace_string(&p9->tag, value); } else if (!strcmp(key, "backend")) { replace_string(&p9->backend_domname, value); + } else if (!strcmp(key, "type")) { + if (libxl_p9_type_from_string(value, &p9->type)) { + fprintf(stderr, "failed to parse 9pfs type: %s\n", + value); + exit(1); + } + } else if (!strcmp(key, "max-files")) { + p9->max_files = parse_ulong(value); + } else if (!strcmp(key, "max-open-files")) { + p9->max_open_files = parse_ulong(value); + } else if (!strcmp(key, "max-space")) { + p9->max_space = parse_ulong(value); + } else if (!strcmp(key, "auto-delete")) { + p9->auto_delete = strtoul(value, NULL, 0); } else { fprintf(stderr, "Unknown 9pfs parameter '%s'\n", key); exit(1); @@ -2242,6 +2256,28 @@ void parse_config_data(const char *config_source, libxl_string_list_dispose(&pairs); + if (p9->type == LIBXL_P9_TYPE_UNKNOWN) { + p9->type = LIBXL_P9_TYPE_QEMU; + } + if (p9->type == LIBXL_P9_TYPE_QEMU && + (p9->max_files || p9->max_open_files || p9->max_space || + p9->auto_delete)) { + fprintf(stderr, "Illegal 9pfs parameter combination\n"); + exit(1); + } + if (p9->type == LIBXL_P9_TYPE_XEN_9PFSD) { + if (!p9->tag) { + replace_string(&p9->tag, "Xen"); + } + if (!p9->path) { + char *path; + + xasprintf(&path, XEN_LOG_DIR "/guests/%s", c_info->name); + replace_string(&p9->path, path); + free(path); + } + } + if (!p9->path || !p9->security_model || !p9->tag) { fprintf(stderr, "9pfs spec missing required field!\n"); exit(1); From patchwork Thu Jan 4 09:00:40 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510920 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 47F1EC47074 for ; Thu, 4 Jan 2024 09:09:37 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661193.1030931 (Exim 4.92) (envelope-from ) id 1rLJjB-000626-7H; Thu, 04 Jan 2024 09:09:25 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661193.1030931; Thu, 04 Jan 2024 09:09:25 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJjB-00061z-4X; Thu, 04 Jan 2024 09:09:25 +0000 Received: by outflank-mailman (input) for mailman id 661193; Thu, 04 Jan 2024 09:09:23 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcd-00085z-Qr for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:39 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 02c8d04a-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:39 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 0760F1F7F8; Thu, 4 Jan 2024 09:02:39 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id CBC9813722; Thu, 4 Jan 2024 09:02:38 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id G2Z3MC50lmUIWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:38 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 02c8d04a-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 18/33] tools/helpers: allocate xenstore event channel for xenstore stubdom Date: Thu, 4 Jan 2024 10:00:40 +0100 Message-Id: <20240104090055.27323-19-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Queue-Id: 0760F1F7F8 In order to prepare support of PV frontends in xenstore-stubdom, add allocation of a Xenstore event channel to init-xenstore-domain.c. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- tools/helpers/init-xenstore-domain.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tools/helpers/init-xenstore-domain.c b/tools/helpers/init-xenstore-domain.c index b2d5df8ba5..140ed610ae 100644 --- a/tools/helpers/init-xenstore-domain.c +++ b/tools/helpers/init-xenstore-domain.c @@ -248,6 +248,13 @@ static int build(xc_interface *xch) dom->cmdline = xc_dom_strdup(dom, cmdline); dom->xenstore_domid = domid; dom->console_evtchn = console_evtchn; + rv = xc_evtchn_alloc_unbound(xch, domid, domid); + if ( rv < 0 ) + { + fprintf(stderr, "xc_evtchn_alloc_unbound failed\n"); + goto err; + } + dom->xenstore_evtchn = rv; rv = xc_dom_mem_init(dom, memory); if ( rv ) From patchwork Thu Jan 4 09:00:41 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510930 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 69D04C47073 for ; Thu, 4 Jan 2024 09:12:37 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661280.1031028 (Exim 4.92) (envelope-from ) id 1rLJm8-0003kD-PV; Thu, 04 Jan 2024 09:12:28 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661280.1031028; Thu, 04 Jan 2024 09:12:28 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm8-0003iR-Ih; Thu, 04 Jan 2024 09:12:28 +0000 Received: by outflank-mailman (input) for mailman id 661280; Thu, 04 Jan 2024 09:12:26 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcj-00085z-FK for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:45 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 061b23c4-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:44 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 9270121EE1; Thu, 4 Jan 2024 09:02:44 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 5DB9413722; Thu, 4 Jan 2024 09:02:44 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id RlydFTR0lmUSWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:44 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 061b23c4-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Julien Grall , Jason Andryuk Subject: [PATCH v3 19/33] tools/xenstored: rename xenbus_evtchn() Date: Thu, 4 Jan 2024 10:00:41 +0100 Message-Id: <20240104090055.27323-20-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 9270121EE1 Rename the xenbus_evtchn() function to get_xenbus_evtchn() in order to avoid two externally visible symbols with the same name when Xenstore- stubdom is being built with a Mini-OS with CONFIG_XENBUS set. Signed-off-by: Juergen Gross Reviewed-by: Julien Grall Reviewed-by: Jason Andryuk --- tools/xenstored/core.h | 2 +- tools/xenstored/domain.c | 2 +- tools/xenstored/minios.c | 2 +- tools/xenstored/posix.c | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index ad87199042..480b0f5f7b 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -383,7 +383,7 @@ static inline bool domain_is_unprivileged(const struct connection *conn) } /* Return the event channel used by xenbus. */ -evtchn_port_t xenbus_evtchn(void); +evtchn_port_t get_xenbus_evtchn(void); /* Write out the pidfile */ void write_pidfile(const char *pidfile); diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index 409b53acf9..6ef136e01f 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -1208,7 +1208,7 @@ void dom0_init(void) evtchn_port_t port; struct domain *dom0; - port = xenbus_evtchn(); + port = get_xenbus_evtchn(); if (port == -1) barf_perror("Failed to initialize dom0 port"); diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index b5c3a205e6..0779efbf91 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -38,7 +38,7 @@ void init_pipe(int reopen_log_pipe[2]) reopen_log_pipe[1] = -1; } -evtchn_port_t xenbus_evtchn(void) +evtchn_port_t get_xenbus_evtchn(void) { return dom0_event; } diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index 6ac45fdb45..7e03dd982d 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -111,7 +111,7 @@ void unmap_xenbus(void *interface) munmap(interface, getpagesize()); } -evtchn_port_t xenbus_evtchn(void) +evtchn_port_t get_xenbus_evtchn(void) { int fd; int rc; From patchwork Thu Jan 4 09:00:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510922 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 2B296C47074 for ; Thu, 4 Jan 2024 09:10:27 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661226.1030951 (Exim 4.92) (envelope-from ) id 1rLJk3-0008QR-T5; Thu, 04 Jan 2024 09:10:19 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661226.1030951; Thu, 04 Jan 2024 09:10:19 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJk3-0008QK-Pl; Thu, 04 Jan 2024 09:10:19 +0000 Received: by outflank-mailman (input) for mailman id 661226; Thu, 04 Jan 2024 09:10:18 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcp-00085z-0J for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:51 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 096f51fa-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:02:50 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 1AB1121EE1; Thu, 4 Jan 2024 09:02:50 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id EA5E413722; Thu, 4 Jan 2024 09:02:49 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id gcMHODl0lmUfWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:49 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 096f51fa-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358970; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=/eJaaQzJFr9iaY84hbFZ6eF6VnkmvJwoY+5FWl4+J1Y=; b=gHkbmH218y0KMHOUNSXdUqKGLonH7D6XONOMfoCygBk+o9WiVnBd9twUa+LYfdx2fqc3gd TDa3LHwPa1rEKsFhxrsNNXs4XxS5Cvro14MSKiZKithqqSTuNbc706fJL3MjKuqlNnqA6s 8/jY/cg1pp5uQOrBJGhXQJ2Gdo5AQ9A= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358970; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=/eJaaQzJFr9iaY84hbFZ6eF6VnkmvJwoY+5FWl4+J1Y=; b=gHkbmH218y0KMHOUNSXdUqKGLonH7D6XONOMfoCygBk+o9WiVnBd9twUa+LYfdx2fqc3gd TDa3LHwPa1rEKsFhxrsNNXs4XxS5Cvro14MSKiZKithqqSTuNbc706fJL3MjKuqlNnqA6s 8/jY/cg1pp5uQOrBJGhXQJ2Gdo5AQ9A= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Samuel Thibault , Jason Andryuk Subject: [PATCH v3 20/33] stubdom: extend xenstore stubdom configs Date: Thu, 4 Jan 2024 10:00:42 +0100 Message-Id: <20240104090055.27323-21-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [4.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; RCPT_COUNT_THREE(0.00)[4]; FREEMAIL_ENVRCPT(0.00)[gmail.com]; R_MISSING_CHARSET(2.50)[]; MIME_GOOD(-0.10)[text/plain]; TO_MATCH_ENVRCPT_ALL(0.00)[]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCVD_COUNT_THREE(0.00)[3]; TO_DN_SOME(0.00)[]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; FREEMAIL_CC(0.00)[suse.com,ens-lyon.org,gmail.com]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-0.00)[41.34%] Extend the config files of the Xenstore stubdoms to include XENBUS and 9PFRONT items in order to support file based logging. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- stubdom/xenstore-minios.cfg | 2 +- stubdom/xenstorepvh-minios.cfg | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/stubdom/xenstore-minios.cfg b/stubdom/xenstore-minios.cfg index a41704bb6b..239da519b9 100644 --- a/stubdom/xenstore-minios.cfg +++ b/stubdom/xenstore-minios.cfg @@ -3,7 +3,7 @@ CONFIG_NETFRONT=n CONFIG_FBFRONT=n CONFIG_KBDFRONT=n CONFIG_CONSFRONT=n -CONFIG_XENBUS=n CONFIG_LWIP=n +CONFIG_9PFRONT=y CONFIG_BALLOON=y XEN_INTERFACE_VERSION=__XEN_LATEST_INTERFACE_VERSION__ diff --git a/stubdom/xenstorepvh-minios.cfg b/stubdom/xenstorepvh-minios.cfg index 6af51f5753..752b90d7d3 100644 --- a/stubdom/xenstorepvh-minios.cfg +++ b/stubdom/xenstorepvh-minios.cfg @@ -4,7 +4,7 @@ CONFIG_NETFRONT=n CONFIG_FBFRONT=n CONFIG_KBDFRONT=n CONFIG_CONSFRONT=n -CONFIG_XENBUS=n CONFIG_LWIP=n +CONFIG_9PFRONT=y CONFIG_BALLOON=y XEN_INTERFACE_VERSION=__XEN_LATEST_INTERFACE_VERSION__ From patchwork Thu Jan 4 09:00:43 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510906 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 2EFFCC47074 for ; Thu, 4 Jan 2024 09:03:08 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661159.1030891 (Exim 4.92) (envelope-from ) id 1rLJcw-0003eR-Sj; Thu, 04 Jan 2024 09:02:58 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661159.1030891; Thu, 04 Jan 2024 09:02:58 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcw-0003eK-O8; Thu, 04 Jan 2024 09:02:58 +0000 Received: by outflank-mailman (input) for mailman id 661159; Thu, 04 Jan 2024 09:02:58 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJcw-0003cj-7D for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:02:58 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id 0cc99ad6-aae0-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:02:56 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id A7BE61F7F8; Thu, 4 Jan 2024 09:02:55 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 779C913722; Thu, 4 Jan 2024 09:02:55 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id +YvzGz90lmUmWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:02:55 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 0cc99ad6-aae0-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358975; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=cv7YGjBYuGXTYJDwZMRTRJp5WAVNs/V6S8PomLV1qxc=; b=kVTrFXfMkiXcby2vjtC11Ap+no9XNstVooLq/KAtRlmvcmqPK5xtoU04H5A3b3dD/2V51m zTI/eBbQOUmvApFuvywuI3djP+2DOn3C1dNc/FLcSBGyRj0f2kjyM2AWTQwAAlnslDo8Ne Zhi831CR7H7zgfrwCjVyIlrxbkOSRKc= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358975; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=cv7YGjBYuGXTYJDwZMRTRJp5WAVNs/V6S8PomLV1qxc=; b=kVTrFXfMkiXcby2vjtC11Ap+no9XNstVooLq/KAtRlmvcmqPK5xtoU04H5A3b3dD/2V51m zTI/eBbQOUmvApFuvywuI3djP+2DOn3C1dNc/FLcSBGyRj0f2kjyM2AWTQwAAlnslDo8Ne Zhi831CR7H7zgfrwCjVyIlrxbkOSRKc= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 21/33] tools: add 9pfs device to xenstore-stubdom Date: Thu, 4 Jan 2024 10:00:43 +0100 Message-Id: <20240104090055.27323-22-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Spamd-Result: default: False [0.90 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; FREEMAIL_ENVRCPT(0.00)[gmail.com]; R_MISSING_CHARSET(2.50)[]; MIME_GOOD(-0.10)[text/plain]; TO_MATCH_ENVRCPT_ALL(0.00)[]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[6]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; FREEMAIL_CC(0.00)[suse.com,xen.org,citrix.com,gmail.com]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-0.00)[13.62%] Authentication-Results: smtp-out2.suse.de; none Add a 9pfs device to Xenstore stubdom in order to allow it to do e.g. logging into a dom0 file. Use the following parameters for the new device: - tag = "xen" - type = "xen-9pfsd" - path = "/var/lib/xen/xenstore" - security-model = "none" For now don't limit allowed file space or number of files. Add a new libxl function for adding it similar to the function for adding the console device. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V2: - add security_model parameter to new libxl function (Jason Andryuk) --- tools/helpers/init-xenstore-domain.c | 2 ++ tools/include/libxl.h | 17 ++++++++++++++++ tools/libs/light/libxl_9pfs.c | 29 ++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+) diff --git a/tools/helpers/init-xenstore-domain.c b/tools/helpers/init-xenstore-domain.c index 140ed610ae..591cb3766d 100644 --- a/tools/helpers/init-xenstore-domain.c +++ b/tools/helpers/init-xenstore-domain.c @@ -543,6 +543,8 @@ int main(int argc, char** argv) } libxl_console_add_xenstore(ctx, domid, 0, console_evtchn, console_gfn, NULL); + libxl_p9_add_xenstore(ctx, domid, 0, LIBXL_P9_TYPE_XEN_9PFSD, "xen", + XEN_LIB_DIR"/xenstore", "none", 0, 0, 0, 0, NULL); libxl_ctx_free(ctx); fd = creat(XEN_RUN_DIR "/xenstored.pid", 0666); diff --git a/tools/include/libxl.h b/tools/include/libxl.h index 907aa0a330..00693264f7 100644 --- a/tools/include/libxl.h +++ b/tools/include/libxl.h @@ -583,6 +583,13 @@ * libxl_console_add_xenstore() in libxl. */ #define LIBXL_HAVE_CONSOLE_ADD_XENSTORE 1 + +/* + * LIBXL_HAVE_P9_ADD_XENSTORE indicates presence of the function + * libxl_p9_add_xenstore() in libxl. + */ +#define LIBXL_HAVE_P9_ADD_XENSTORE 1 + /* * libxl ABI compatibility * @@ -2060,6 +2067,16 @@ int libxl_console_add_xenstore(libxl_ctx *ctx, uint32_t domid, uint32_t backend, const libxl_asyncop_how *ao_how) LIBXL_EXTERNAL_CALLERS_ONLY; +/* libxl_p9_add_xenstore writes the Xenstore entries for a domain's + * primary 9pfs device based on domid, backend type and device parameters. + */ +int libxl_p9_add_xenstore(libxl_ctx *ctx, uint32_t domid, uint32_t backend, + libxl_p9_type type, char *tag, char *path, + char *security_model, unsigned int max_space, + unsigned int max_files, unsigned int max_open_files, + bool auto_delete, const libxl_asyncop_how *ao_how) + LIBXL_EXTERNAL_CALLERS_ONLY; + /* May be called with info_r == NULL to check for domain's existence. * Returns ERROR_DOMAIN_NOTFOUND if domain does not exist (used to return * ERROR_INVAL for this scenario). */ diff --git a/tools/libs/light/libxl_9pfs.c b/tools/libs/light/libxl_9pfs.c index 486bc4326e..17501c3eaa 100644 --- a/tools/libs/light/libxl_9pfs.c +++ b/tools/libs/light/libxl_9pfs.c @@ -176,6 +176,35 @@ static void libxl__device_p9_add(libxl__egc *egc, uint32_t domid, aodev->callback(egc, aodev); } +int libxl_p9_add_xenstore(libxl_ctx *ctx, uint32_t domid, uint32_t backend, + libxl_p9_type type, char *tag, char *path, + char *security_model, unsigned int max_space, + unsigned int max_files, unsigned int max_open_files, + bool auto_delete, const libxl_asyncop_how *ao_how) +{ + AO_CREATE(ctx, domid, ao_how); + libxl__ao_device *aodev; + libxl_device_p9 p9 = { .backend_domid = backend, + .tag = tag, + .path = path, + .security_model = security_model, + .type = type, + .max_space = max_space, + .max_files = max_files, + .max_open_files = max_open_files, + .auto_delete = auto_delete, + }; + + GCNEW(aodev); + libxl__prepare_ao_device(ao, aodev); + aodev->action = LIBXL__DEVICE_ACTION_ADD; + aodev->callback = device_addrm_aocomplete; + + libxl__device_p9_add(egc, domid, &p9, aodev); + + return AO_INPROGRESS; +} + #define libxl_device_p9_list NULL #define libxl_device_p9_compare NULL From patchwork Thu Jan 4 09:00:44 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510928 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id DE52BC4707B for ; Thu, 4 Jan 2024 09:12:35 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661273.1031000 (Exim 4.92) (envelope-from ) id 1rLJm6-0003Er-G2; Thu, 04 Jan 2024 09:12:26 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661273.1031000; Thu, 04 Jan 2024 09:12:26 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJm6-0003Ek-DC; Thu, 04 Jan 2024 09:12:26 +0000 Received: by outflank-mailman (input) for mailman id 661273; Thu, 04 Jan 2024 09:12:25 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJd0-00085z-4d for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:02 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 10047a47-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:01 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 38B011F7F8; Thu, 4 Jan 2024 09:03:01 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 0523813722; Thu, 4 Jan 2024 09:03:01 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id BooHAEV0lmUrWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:01 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 10047a47-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 22/33] tools/xenstored: add early_init() function Date: Thu, 4 Jan 2024 10:00:44 +0100 Message-Id: <20240104090055.27323-23-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 38B011F7F8 Some xenstored initialization needs to be done in the daemon case only, so split it out into a new early_init() function being a stub in the stubdom case. Remove the call of talloc_enable_leak_report_full(), as it serves no real purpose: the daemon only ever exits due to a crash, in which case a log of talloc()ed memory hardly has any value. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V2: - rename function - move patch earlier in the series V3: - add more init code for the daemon to early_init() - move mkdir(XENSTORE_LIB_DIR) into a later patch (Julien Grall) - remove stale stubs in minios.c --- tools/xenstored/core.c | 30 +++--------------------------- tools/xenstored/core.h | 7 +++---- tools/xenstored/minios.c | 11 +++-------- tools/xenstored/posix.c | 31 +++++++++++++++++++++++++++++-- 4 files changed, 38 insertions(+), 41 deletions(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index d4c76d71dc..eba7744fde 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -79,7 +79,7 @@ char **orig_argv; LIST_HEAD(connections); int tracefd = -1; bool keep_orphans = false; -static int reopen_log_pipe[2]; +int reopen_log_pipe[2]; static int reopen_log_pipe0_pollfd_idx = -1; char *tracefile = NULL; static struct hashtable *nodes; @@ -2612,7 +2612,7 @@ static void destroy_fds(void) close(sock); } -static void init_sockets(void) +void init_sockets(void) { struct sockaddr_un addr; const char *soc_str = xenstore_daemon_path(); @@ -2903,34 +2903,10 @@ int main(int argc, char *argv[]) if (optind != argc) barf("%s: No arguments desired", argv[0]); - reopen_log(); - - /* Make sure xenstored directory exists. */ - /* Errors ignored here, will be reported when we open files */ - mkdir(xenstore_daemon_rundir(), 0755); - - if (dofork) { - openlog("xenstored", 0, LOG_DAEMON); - if (!live_update) - daemonize(); - } - if (pidfile) - write_pidfile(pidfile); - - /* Talloc leak reports go to stderr, which is closed if we fork. */ - if (!dofork) - talloc_enable_leak_report_full(); - - /* Don't kill us with SIGPIPE. */ - signal(SIGPIPE, SIG_IGN); + early_init(live_update, dofork, pidfile); talloc_enable_null_tracking(); -#ifndef NO_SOCKETS - if (!live_update) - init_sockets(); -#endif - init_pipe(reopen_log_pipe); /* Listen to hypervisor. */ diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index 480b0f5f7b..72173f1684 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -384,12 +384,11 @@ static inline bool domain_is_unprivileged(const struct connection *conn) /* Return the event channel used by xenbus. */ evtchn_port_t get_xenbus_evtchn(void); +void early_init(bool live_update, bool dofork, const char *pidfile); -/* Write out the pidfile */ -void write_pidfile(const char *pidfile); +void init_sockets(void); +extern int reopen_log_pipe[2]; -/* Fork but do not close terminal FDs */ -void daemonize(void); /* Close stdin/stdout/stderr to complete daemonize */ void finish_daemonize(void); diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 0779efbf91..4f48f63083 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -20,14 +20,6 @@ #include "core.h" #include -void write_pidfile(const char *pidfile) -{ -} - -void daemonize(void) -{ -} - void finish_daemonize(void) { } @@ -54,3 +46,6 @@ void unmap_xenbus(void *interface) xengnttab_unmap(*xgt_handle, interface, 1); } +void early_init(bool live_update, bool dofork, const char *pidfile) +{ +} diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index 7e03dd982d..9463ef5c8d 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -20,14 +20,17 @@ #include #include #include +#include #include +#include #include +#include #include "utils.h" #include "core.h" #include "osdep.h" -void write_pidfile(const char *pidfile) +static void write_pidfile(const char *pidfile) { char buf[100]; int len; @@ -49,7 +52,7 @@ void write_pidfile(const char *pidfile) } /* Stevens. */ -void daemonize(void) +static void daemonize(void) { pid_t pid; @@ -157,3 +160,27 @@ void *xenbus_map(void) return addr; } + +void early_init(bool live_update, bool dofork, const char *pidfile) +{ + reopen_log(); + + /* Make sure xenstored directory exists. */ + /* Errors ignored here, will be reported when we open files */ + mkdir(xenstore_daemon_rundir(), 0755); + + if (dofork) { + openlog("xenstored", 0, LOG_DAEMON); + if (!live_update) + daemonize(); + } + + if (pidfile) + write_pidfile(pidfile); + + /* Don't kill us with SIGPIPE. */ + signal(SIGPIPE, SIG_IGN); + + if (!live_update) + init_sockets(); +} From patchwork Thu Jan 4 09:00:45 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510933 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id E2347C47073 for ; Thu, 4 Jan 2024 09:12:58 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661297.1031067 (Exim 4.92) (envelope-from ) id 1rLJmV-0006DC-1E; Thu, 04 Jan 2024 09:12:51 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661297.1031067; Thu, 04 Jan 2024 09:12:50 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJmU-0006CW-RZ; Thu, 04 Jan 2024 09:12:50 +0000 Received: by outflank-mailman (input) for mailman id 661297; Thu, 04 Jan 2024 09:12:50 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJd5-00085z-Jz for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:07 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [2a07:de40:b251:101:10:150:64:2]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 1352774b-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:07 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id AA03D1F7F8; Thu, 4 Jan 2024 09:03:06 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 8011813722; Thu, 4 Jan 2024 09:03:06 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id +FH+HUp0lmU0WQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:06 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 1352774b-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358986; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Ssx28FcEWEf2WDI9VVHEBGrcITBSOtj2P4cTrF0KhcY=; b=mg93sztlJ1BGH9KTiHaoUtYeL3OkskcbD0YDM0CwRBw0bFUNtu0hN/Ze9elQfPDslAEZmJ TD98sq+9mo1YwK9My4O1xmS0E9t5r1aPbIvwatkaJMGD1zY/ScYrRLGbZnxDGV3wQDVSus QkzoOGkonSXVYL+eJxKm8Bil5zOofGk= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704358986; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Ssx28FcEWEf2WDI9VVHEBGrcITBSOtj2P4cTrF0KhcY=; b=mg93sztlJ1BGH9KTiHaoUtYeL3OkskcbD0YDM0CwRBw0bFUNtu0hN/Ze9elQfPDslAEZmJ TD98sq+9mo1YwK9My4O1xmS0E9t5r1aPbIvwatkaJMGD1zY/ScYrRLGbZnxDGV3wQDVSus QkzoOGkonSXVYL+eJxKm8Bil5zOofGk= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 23/33] tools/xenstored: move systemd handling to posix.c Date: Thu, 4 Jan 2024 10:00:45 +0100 Message-Id: <20240104090055.27323-24-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Spamd-Result: default: False [0.90 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[5]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[] Authentication-Results: smtp-out2.suse.de; none Move systemd handling to a new late_init() function in posix.c. This prepares a future removal of the NO_SOCKETS macro. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V3: - new patch --- tools/xenstored/core.c | 17 +---------------- tools/xenstored/core.h | 1 + tools/xenstored/minios.c | 4 ++++ tools/xenstored/posix.c | 13 +++++++++++++ 4 files changed, 19 insertions(+), 16 deletions(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index eba7744fde..7b5e1d0c0f 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -54,16 +54,6 @@ #include "control.h" #include "lu.h" -#ifndef NO_SOCKETS -#if defined(HAVE_SYSTEMD) -#define XEN_SYSTEMD_ENABLED 1 -#endif -#endif - -#if defined(XEN_SYSTEMD_ENABLED) -#include -#endif - extern xenevtchn_handle *xce_handle; /* in domain.c */ static int xce_pollfd_idx = -1; static struct pollfd *fds; @@ -2938,12 +2928,7 @@ int main(int argc, char *argv[]) /* Get ready to listen to the tools. */ initialize_fds(&sock_pollfd_idx, &timeout); -#if defined(XEN_SYSTEMD_ENABLED) - if (!live_update) { - sd_notify(1, "READY=1"); - fprintf(stderr, SD_NOTICE "xenstored is ready\n"); - } -#endif + late_init(live_update); /* Main loop. */ for (;;) { diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index 72173f1684..0de2d8a26e 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -385,6 +385,7 @@ static inline bool domain_is_unprivileged(const struct connection *conn) /* Return the event channel used by xenbus. */ evtchn_port_t get_xenbus_evtchn(void); void early_init(bool live_update, bool dofork, const char *pidfile); +void late_init(bool live_update); void init_sockets(void); extern int reopen_log_pipe[2]; diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 4f48f63083..45bb0440be 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -49,3 +49,7 @@ void unmap_xenbus(void *interface) void early_init(bool live_update, bool dofork, const char *pidfile) { } + +void late_init(bool live_update) +{ +} diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index 9463ef5c8d..97c8dcaba3 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -24,6 +24,9 @@ #include #include #include +#if defined(HAVE_SYSTEMD) +#include +#endif #include #include "utils.h" @@ -184,3 +187,13 @@ void early_init(bool live_update, bool dofork, const char *pidfile) if (!live_update) init_sockets(); } + +void late_init(bool live_update) +{ +#if defined(HAVE_SYSTEMD) + if (!live_update) { + sd_notify(1, "READY=1"); + fprintf(stderr, SD_NOTICE "xenstored is ready\n"); + } +#endif +} From patchwork Thu Jan 4 09:00:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510926 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id EB3DAC47074 for ; Thu, 4 Jan 2024 09:11:25 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661255.1030991 (Exim 4.92) (envelope-from ) id 1rLJl0-0002MJ-6g; Thu, 04 Jan 2024 09:11:18 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661255.1030991; Thu, 04 Jan 2024 09:11:18 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJl0-0002MA-45; Thu, 04 Jan 2024 09:11:18 +0000 Received: by outflank-mailman (input) for mailman id 661255; Thu, 04 Jan 2024 09:11:17 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdB-00085z-8T for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:13 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 1695d1a6-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:12 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 3D54621EE1; Thu, 4 Jan 2024 09:03:12 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 1272F13722; Thu, 4 Jan 2024 09:03:12 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id VRIuA1B0lmVAWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:12 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 1695d1a6-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 24/33] tools/xenstored: move all log-pipe handling into posix.c Date: Thu, 4 Jan 2024 10:00:46 +0100 Message-Id: <20240104090055.27323-25-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 3D54621EE1 All of the log-pipe handling is needed only when running as daemon. Move it into posix.c. This requires to have a service function in the main event loop for handling the related requests and one for setting the fds[] array. Use a generic name for those functions, as socket handling can be added to them later, too. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V3: - new patch --- tools/xenstored/core.c | 41 ++++------------------------------- tools/xenstored/core.h | 11 ++++++---- tools/xenstored/minios.c | 14 ++++++------ tools/xenstored/posix.c | 46 +++++++++++++++++++++++++++++++++++++++- 4 files changed, 64 insertions(+), 48 deletions(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index 7b5e1d0c0f..650c1d1574 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -56,7 +56,7 @@ extern xenevtchn_handle *xce_handle; /* in domain.c */ static int xce_pollfd_idx = -1; -static struct pollfd *fds; +struct pollfd *fds; static unsigned int current_array_size; static unsigned int nr_fds; static unsigned int delayed_requests; @@ -69,8 +69,6 @@ char **orig_argv; LIST_HEAD(connections); int tracefd = -1; bool keep_orphans = false; -int reopen_log_pipe[2]; -static int reopen_log_pipe0_pollfd_idx = -1; char *tracefile = NULL; static struct hashtable *nodes; unsigned int trace_flags = TRACE_OBJ | TRACE_IO; @@ -145,18 +143,6 @@ void trace_destroy(const void *data, const char *type) trace("obj: DESTROY %s %p\n", type, data); } -/** - * Signal handler for SIGHUP, which requests that the trace log is reopened - * (in the main loop). A single byte is written to reopen_log_pipe, to awaken - * the poll() in the main loop. - */ -static void trigger_reopen_log(int signal __attribute__((unused))) -{ - char c = 'A'; - int dummy; - dummy = write(reopen_log_pipe[1], &c, 1); -} - void close_log(void) { if (tracefd >= 0) @@ -467,7 +453,7 @@ static bool conn_can_write(struct connection *conn) } /* This function returns index inside the array if succeed, -1 if fail */ -static int set_fd(int fd, short events) +int set_fd(int fd, short events) { int ret; if (current_array_size < nr_fds + 1) { @@ -512,11 +498,9 @@ static void initialize_fds(int *p_sock_pollfd_idx, int *ptimeout) /* In case of delayed requests pause for max 1 second. */ *ptimeout = delayed_requests ? 1000 : -1; + set_special_fds(); if (sock != -1) *p_sock_pollfd_idx = set_fd(sock, POLLIN|POLLPRI); - if (reopen_log_pipe[0] != -1) - reopen_log_pipe0_pollfd_idx = - set_fd(reopen_log_pipe[0], POLLIN|POLLPRI); if (xce_handle != NULL) xce_pollfd_idx = set_fd(xenevtchn_fd(xce_handle), @@ -2897,8 +2881,6 @@ int main(int argc, char *argv[]) talloc_enable_null_tracking(); - init_pipe(reopen_log_pipe); - /* Listen to hypervisor. */ if (!live_update) { domain_init(-1); @@ -2913,7 +2895,6 @@ int main(int argc, char *argv[]) xprintf = trace; #endif - signal(SIGHUP, trigger_reopen_log); if (tracefile) tracefile = talloc_strdup(NULL, tracefile); @@ -2940,21 +2921,7 @@ int main(int argc, char *argv[]) barf_perror("Poll failed"); } - if (reopen_log_pipe0_pollfd_idx != -1) { - if (fds[reopen_log_pipe0_pollfd_idx].revents - & ~POLLIN) { - close(reopen_log_pipe[0]); - close(reopen_log_pipe[1]); - init_pipe(reopen_log_pipe); - } else if (fds[reopen_log_pipe0_pollfd_idx].revents - & POLLIN) { - char c; - if (read(reopen_log_pipe[0], &c, 1) != 1) - barf_perror("read failed"); - reopen_log(); - } - reopen_log_pipe0_pollfd_idx = -1; - } + handle_special_fds(); if (sock_pollfd_idx != -1) { if (fds[sock_pollfd_idx].revents & ~POLLIN) { diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index 0de2d8a26e..6944f48719 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -361,6 +362,8 @@ extern int dom0_event; extern int priv_domid; extern bool keep_orphans; +extern struct pollfd *fds; + extern unsigned int timeout_watch_event_msec; /* Get internal time in milliseconds. */ @@ -387,15 +390,15 @@ evtchn_port_t get_xenbus_evtchn(void); void early_init(bool live_update, bool dofork, const char *pidfile); void late_init(bool live_update); +int set_fd(int fd, short events); +void set_special_fds(void); +void handle_special_fds(void); + void init_sockets(void); -extern int reopen_log_pipe[2]; /* Close stdin/stdout/stderr to complete daemonize */ void finish_daemonize(void); -/* Open a pipe for signal handling */ -void init_pipe(int reopen_log_pipe[2]); - #ifndef NO_SOCKETS extern const struct interface_funcs socket_funcs; #endif diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 45bb0440be..3208169187 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -24,12 +24,6 @@ void finish_daemonize(void) { } -void init_pipe(int reopen_log_pipe[2]) -{ - reopen_log_pipe[0] = -1; - reopen_log_pipe[1] = -1; -} - evtchn_port_t get_xenbus_evtchn(void) { return dom0_event; @@ -53,3 +47,11 @@ void early_init(bool live_update, bool dofork, const char *pidfile) void late_init(bool live_update) { } + +void set_special_fds(void) +{ +} + +void handle_special_fds(void) +{ +} diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index 97c8dcaba3..2dbbef4a0b 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -33,6 +33,9 @@ #include "core.h" #include "osdep.h" +static int reopen_log_pipe0_pollfd_idx = -1; +static int reopen_log_pipe[2]; + static void write_pidfile(const char *pidfile) { char buf[100]; @@ -82,6 +85,19 @@ static void daemonize(void) umask(0); } +/* + * Signal handler for SIGHUP, which requests that the trace log is reopened + * (in the main loop). A single byte is written to reopen_log_pipe, to awaken + * the poll() in the main loop. + */ +static void trigger_reopen_log(int signal __attribute__((unused))) +{ + char c = 'A'; + int dummy; + + dummy = write(reopen_log_pipe[1], &c, 1); +} + void finish_daemonize(void) { int devnull = open("/dev/null", O_RDWR); @@ -93,7 +109,7 @@ void finish_daemonize(void) close(devnull); } -void init_pipe(int reopen_log_pipe[2]) +static void init_pipe(void) { int flags; unsigned int i; @@ -183,9 +199,37 @@ void early_init(bool live_update, bool dofork, const char *pidfile) /* Don't kill us with SIGPIPE. */ signal(SIGPIPE, SIG_IGN); + signal(SIGHUP, trigger_reopen_log); if (!live_update) init_sockets(); + + init_pipe(); +} + +void set_special_fds(void) +{ + if (reopen_log_pipe[0] != -1) + reopen_log_pipe0_pollfd_idx = + set_fd(reopen_log_pipe[0], POLLIN|POLLPRI); +} + +void handle_special_fds(void) +{ + if (reopen_log_pipe0_pollfd_idx != -1) { + if (fds[reopen_log_pipe0_pollfd_idx].revents & ~POLLIN) { + close(reopen_log_pipe[0]); + close(reopen_log_pipe[1]); + init_pipe(); + } else if (fds[reopen_log_pipe0_pollfd_idx].revents & POLLIN) { + char c; + + if (read(reopen_log_pipe[0], &c, 1) != 1) + barf_perror("read failed"); + reopen_log(); + } + reopen_log_pipe0_pollfd_idx = -1; + } } void late_init(bool live_update) From patchwork Thu Jan 4 09:00:47 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510921 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 52899C4707B for ; Thu, 4 Jan 2024 09:09:58 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661206.1030940 (Exim 4.92) (envelope-from ) id 1rLJja-0006rU-Kc; Thu, 04 Jan 2024 09:09:50 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661206.1030940; Thu, 04 Jan 2024 09:09:50 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJja-0006rM-HZ; Thu, 04 Jan 2024 09:09:50 +0000 Received: by outflank-mailman (input) for mailman id 661206; Thu, 04 Jan 2024 09:09:49 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdG-00085z-Vu for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:19 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 19e4093b-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:18 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id C16FD21EE1; Thu, 4 Jan 2024 09:03:17 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 928C513722; Thu, 4 Jan 2024 09:03:17 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id rZKNIlV0lmVEWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:17 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 19e4093b-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 25/33] tools/xenstored: move all socket handling into posix.c Date: Thu, 4 Jan 2024 10:00:47 +0100 Message-Id: <20240104090055.27323-26-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: C16FD21EE1 All of the socket handling is needed only when running as daemon. Move it into posix.c, allowing to remove the NO_SOCKETS macro. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- V3: - new patch --- tools/xenstored/Makefile.common | 4 - tools/xenstored/core.c | 156 +------------------------------- tools/xenstored/core.h | 8 +- tools/xenstored/domain.c | 9 +- tools/xenstored/minios.c | 6 ++ tools/xenstored/posix.c | 153 +++++++++++++++++++++++++++++++ 6 files changed, 167 insertions(+), 169 deletions(-) diff --git a/tools/xenstored/Makefile.common b/tools/xenstored/Makefile.common index 189ab81b8d..ef63ef650c 100644 --- a/tools/xenstored/Makefile.common +++ b/tools/xenstored/Makefile.common @@ -16,10 +16,6 @@ CFLAGS += $(CFLAGS_libxenctrl) CFLAGS += $(CFLAGS_libxenguest) CFLAGS += $(CFLAGS_libxentoolcore) -ifdef CONFIG_STUBDOM -CFLAGS += -DNO_SOCKETS=1 -endif - $(XENSTORED_OBJS-y): CFLAGS += $(CFLAGS_libxengnttab) xenstored.a: $(XENSTORED_OBJS-y) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index 650c1d1574..8ff1faccef 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -20,10 +20,6 @@ #include #include #include -#ifndef NO_SOCKETS -#include -#include -#endif #include #include #include @@ -61,7 +57,7 @@ static unsigned int current_array_size; static unsigned int nr_fds; static unsigned int delayed_requests; -static int sock = -1; +int sock = -1; int orig_argc; char **orig_argv; @@ -486,7 +482,7 @@ fail: return -1; } -static void initialize_fds(int *p_sock_pollfd_idx, int *ptimeout) +static void initialize_fds(int *ptimeout) { struct connection *conn; uint64_t msecs; @@ -499,8 +495,6 @@ static void initialize_fds(int *p_sock_pollfd_idx, int *ptimeout) *ptimeout = delayed_requests ? 1000 : -1; set_special_fds(); - if (sock != -1) - *p_sock_pollfd_idx = set_fd(sock, POLLIN|POLLPRI); if (xce_handle != NULL) xce_pollfd_idx = set_fd(xenevtchn_fd(xce_handle), @@ -2260,97 +2254,6 @@ struct connection *get_connection_by_id(unsigned int conn_id) return NULL; } -#ifdef NO_SOCKETS -static void accept_connection(int sock) -{ -} -#else -static int writefd(struct connection *conn, const void *data, unsigned int len) -{ - int rc; - - while ((rc = write(conn->fd, data, len)) < 0) { - if (errno == EAGAIN) { - rc = 0; - break; - } - if (errno != EINTR) - break; - } - - return rc; -} - -static int readfd(struct connection *conn, void *data, unsigned int len) -{ - int rc; - - while ((rc = read(conn->fd, data, len)) < 0) { - if (errno == EAGAIN) { - rc = 0; - break; - } - if (errno != EINTR) - break; - } - - /* Reading zero length means we're done with this connection. */ - if ((rc == 0) && (len != 0)) { - errno = EBADF; - rc = -1; - } - - return rc; -} - -static bool socket_can_process(struct connection *conn, int mask) -{ - if (conn->pollfd_idx == -1) - return false; - - if (fds[conn->pollfd_idx].revents & ~(POLLIN | POLLOUT)) { - talloc_free(conn); - return false; - } - - return (fds[conn->pollfd_idx].revents & mask); -} - -static bool socket_can_write(struct connection *conn) -{ - return socket_can_process(conn, POLLOUT); -} - -static bool socket_can_read(struct connection *conn) -{ - return socket_can_process(conn, POLLIN); -} - -const struct interface_funcs socket_funcs = { - .write = writefd, - .read = readfd, - .can_write = socket_can_write, - .can_read = socket_can_read, -}; - -static void accept_connection(int sock) -{ - int fd; - struct connection *conn; - - fd = accept(sock, NULL, NULL); - if (fd < 0) - return; - - conn = new_connection(&socket_funcs); - if (conn) { - conn->fd = fd; - conn->id = dom0_domid; - } else - close(fd); -} -#endif - /* We create initial nodes manually. */ static void manual_node(const char *name, const char *child) { @@ -2579,46 +2482,6 @@ void corrupt(struct connection *conn, const char *fmt, ...) errno = saved_errno; } -#ifndef NO_SOCKETS -static void destroy_fds(void) -{ - if (sock >= 0) - close(sock); -} - -void init_sockets(void) -{ - struct sockaddr_un addr; - const char *soc_str = xenstore_daemon_path(); - - if (!soc_str) - barf_perror("Failed to obtain xs domain socket"); - - /* Create sockets for them to listen to. */ - atexit(destroy_fds); - sock = socket(PF_UNIX, SOCK_STREAM, 0); - if (sock < 0) - barf_perror("Could not create socket"); - - /* FIXME: Be more sophisticated, don't mug running daemon. */ - unlink(soc_str); - - addr.sun_family = AF_UNIX; - - if(strlen(soc_str) >= sizeof(addr.sun_path)) - barf_perror("socket string '%s' too long", soc_str); - strcpy(addr.sun_path, soc_str); - if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) != 0) - barf_perror("Could not bind socket to %s", soc_str); - - if (chmod(soc_str, 0600) != 0) - barf_perror("Could not chmod sockets"); - - if (listen(sock, 1) != 0) - barf_perror("Could not listen on sockets"); -} -#endif - static void usage(void) { fprintf(stderr, @@ -2796,7 +2659,6 @@ int set_trace_switch(const char *arg) int main(int argc, char *argv[]) { int opt; - int sock_pollfd_idx = -1; bool dofork = true; bool live_update = false; const char *pidfile = NULL; @@ -2907,7 +2769,7 @@ int main(int argc, char *argv[]) check_store(); /* Get ready to listen to the tools. */ - initialize_fds(&sock_pollfd_idx, &timeout); + initialize_fds(&timeout); late_init(live_update); @@ -2923,16 +2785,6 @@ int main(int argc, char *argv[]) handle_special_fds(); - if (sock_pollfd_idx != -1) { - if (fds[sock_pollfd_idx].revents & ~POLLIN) { - barf_perror("sock poll failed"); - break; - } else if (fds[sock_pollfd_idx].revents & POLLIN) { - accept_connection(sock); - sock_pollfd_idx = -1; - } - } - if (xce_pollfd_idx != -1) { if (fds[xce_pollfd_idx].revents & ~POLLIN) { barf_perror("xce_handle poll failed"); @@ -2986,7 +2838,7 @@ int main(int argc, char *argv[]) } } - initialize_fds(&sock_pollfd_idx, &timeout); + initialize_fds(&timeout); } } diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index 6944f48719..ddc345050c 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -301,6 +301,7 @@ int rm_node(struct connection *conn, const void *ctx, const char *name); void setup_structure(bool live_update); struct connection *new_connection(const struct interface_funcs *funcs); +struct connection *add_socket_connection(int fd); struct connection *get_connection_by_id(unsigned int conn_id); void check_store(void); void corrupt(struct connection *conn, const char *fmt, ...); @@ -335,6 +336,8 @@ void close_log(void); errno = _saved_errno; \ } while (0) +extern int sock; + extern int orig_argc; extern char **orig_argv; @@ -394,14 +397,9 @@ int set_fd(int fd, short events); void set_special_fds(void); void handle_special_fds(void); -void init_sockets(void); - /* Close stdin/stdout/stderr to complete daemonize */ void finish_daemonize(void); -#ifndef NO_SOCKETS -extern const struct interface_funcs socket_funcs; -#endif extern xengnttab_handle **xgt_handle; int remember_string(struct hashtable *hash, const char *str); diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index 6ef136e01f..040df98b8c 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -1739,14 +1739,7 @@ void read_state_connection(const void *ctx, const void *state) struct domain *domain, *tdomain; if (sc->conn_type == XS_STATE_CONN_TYPE_SOCKET) { -#ifdef NO_SOCKETS - barf("socket based connection without sockets"); -#else - conn = new_connection(&socket_funcs); - if (!conn) - barf("error restoring connection"); - conn->fd = sc->spec.socket_fd; -#endif + conn = add_socket_connection(sc->spec.socket_fd); } else { domain = introduce_domain(ctx, sc->spec.ring.domid, sc->spec.ring.evtchn, true); diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 3208169187..5d59cc90cc 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -18,12 +18,18 @@ #include #include #include "core.h" +#include "utils.h" #include void finish_daemonize(void) { } +struct connection *add_socket_connection(int fd) +{ + barf("socket based connection without sockets"); +} + evtchn_port_t get_xenbus_evtchn(void) { return dom0_event; diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index 2dbbef4a0b..f72c8406d2 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -24,6 +24,8 @@ #include #include #include +#include +#include #if defined(HAVE_SYSTEMD) #include #endif @@ -32,10 +34,13 @@ #include "utils.h" #include "core.h" #include "osdep.h" +#include "talloc.h" static int reopen_log_pipe0_pollfd_idx = -1; static int reopen_log_pipe[2]; +static int sock_pollfd_idx = -1; + static void write_pidfile(const char *pidfile) { char buf[100]; @@ -180,6 +185,142 @@ void *xenbus_map(void) return addr; } +static int writefd(struct connection *conn, const void *data, unsigned int len) +{ + int rc; + + while ((rc = write(conn->fd, data, len)) < 0) { + if (errno == EAGAIN) { + rc = 0; + break; + } + if (errno != EINTR) + break; + } + + return rc; +} + +static int readfd(struct connection *conn, void *data, unsigned int len) +{ + int rc; + + while ((rc = read(conn->fd, data, len)) < 0) { + if (errno == EAGAIN) { + rc = 0; + break; + } + if (errno != EINTR) + break; + } + + /* Reading zero length means we're done with this connection. */ + if ((rc == 0) && (len != 0)) { + errno = EBADF; + rc = -1; + } + + return rc; +} + +static bool socket_can_process(struct connection *conn, int mask) +{ + if (conn->pollfd_idx == -1) + return false; + + if (fds[conn->pollfd_idx].revents & ~(POLLIN | POLLOUT)) { + talloc_free(conn); + return false; + } + + return (fds[conn->pollfd_idx].revents & mask); +} + +static bool socket_can_write(struct connection *conn) +{ + return socket_can_process(conn, POLLOUT); +} + +static bool socket_can_read(struct connection *conn) +{ + return socket_can_process(conn, POLLIN); +} + +static const struct interface_funcs socket_funcs = { + .write = writefd, + .read = readfd, + .can_write = socket_can_write, + .can_read = socket_can_read, +}; + +static void accept_connection(int sock) +{ + int fd; + struct connection *conn; + + fd = accept(sock, NULL, NULL); + if (fd < 0) + return; + + conn = new_connection(&socket_funcs); + if (conn) { + conn->fd = fd; + conn->id = dom0_domid; + } else + close(fd); +} + +static void destroy_fds(void) +{ + if (sock >= 0) + close(sock); +} + +static void init_sockets(void) +{ + struct sockaddr_un addr; + const char *soc_str = xenstore_daemon_path(); + + if (!soc_str) + barf_perror("Failed to obtain xs domain socket"); + + /* Create sockets for them to listen to. */ + atexit(destroy_fds); + sock = socket(PF_UNIX, SOCK_STREAM, 0); + if (sock < 0) + barf_perror("Could not create socket"); + + /* FIXME: Be more sophisticated, don't mug running daemon. */ + unlink(soc_str); + + addr.sun_family = AF_UNIX; + + if (strlen(soc_str) >= sizeof(addr.sun_path)) + barf_perror("socket string '%s' too long", soc_str); + strcpy(addr.sun_path, soc_str); + if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) != 0) + barf_perror("Could not bind socket to %s", soc_str); + + if (chmod(soc_str, 0600) != 0) + barf_perror("Could not chmod sockets"); + + if (listen(sock, 1) != 0) + barf_perror("Could not listen on sockets"); +} + + +struct connection *add_socket_connection(int fd) +{ + struct connection *conn; + + conn = new_connection(&socket_funcs); + if (!conn) + barf("error restoring connection"); + conn->fd = fd; + + return conn; +} + void early_init(bool live_update, bool dofork, const char *pidfile) { reopen_log(); @@ -212,6 +353,9 @@ void set_special_fds(void) if (reopen_log_pipe[0] != -1) reopen_log_pipe0_pollfd_idx = set_fd(reopen_log_pipe[0], POLLIN|POLLPRI); + + if (sock != -1) + sock_pollfd_idx = set_fd(sock, POLLIN|POLLPRI); } void handle_special_fds(void) @@ -230,6 +374,15 @@ void handle_special_fds(void) } reopen_log_pipe0_pollfd_idx = -1; } + + if (sock_pollfd_idx != -1) { + if (fds[sock_pollfd_idx].revents & ~POLLIN) { + barf_perror("sock poll failed"); + } else if (fds[sock_pollfd_idx].revents & POLLIN) { + accept_connection(sock); + sock_pollfd_idx = -1; + } + } } void late_init(bool live_update) From patchwork Thu Jan 4 09:00:48 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510925 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7EC4AC47073 for ; Thu, 4 Jan 2024 09:10:53 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661237.1030981 (Exim 4.92) (envelope-from ) id 1rLJkT-0001Gm-Ue; Thu, 04 Jan 2024 09:10:45 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661237.1030981; Thu, 04 Jan 2024 09:10:45 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJkT-0001Gb-Pc; Thu, 04 Jan 2024 09:10:45 +0000 Received: by outflank-mailman (input) for mailman id 661237; Thu, 04 Jan 2024 09:10:44 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdM-00085z-DL for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:24 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 1d428195-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:23 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 46D4F21EE1; Thu, 4 Jan 2024 09:03:23 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 1D5F213722; Thu, 4 Jan 2024 09:03:23 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id UID0BVt0lmVOWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:23 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 1d428195-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359003; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=PRwkEgUlvhygA2ICPfUBXzv+stFJ1TKHPnwBlk1TeGM=; b=QVOpiHqAsreGoPLztZ/HrswmhEh1C1Zswv9NFUuJkfyIfyX6LSJvfuQ2yrKNknn7wa7MN9 cAaqTt42rwbzJkhGyqvVNyfwef/+HNfPxOQ1grfNR61UBZKeewnAXOjymmLsc9BQRiBuF9 QQU8K26TLOUwpcYJoRMbWUueXGz5ABE= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359003; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=PRwkEgUlvhygA2ICPfUBXzv+stFJ1TKHPnwBlk1TeGM=; b=QVOpiHqAsreGoPLztZ/HrswmhEh1C1Zswv9NFUuJkfyIfyX6LSJvfuQ2yrKNknn7wa7MN9 cAaqTt42rwbzJkhGyqvVNyfwef/+HNfPxOQ1grfNR61UBZKeewnAXOjymmLsc9BQRiBuF9 QQU8K26TLOUwpcYJoRMbWUueXGz5ABE= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 26/33] tools/xenstored: get own domid in stubdom case Date: Thu, 4 Jan 2024 10:00:48 +0100 Message-Id: <20240104090055.27323-27-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [4.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[5]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[] Obtain the own domid when running as stubdom. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V2: - replacement of V1 patch (Andrew Cooper) V3: - rename called function to get_domid() (Julien Grall) - change stub_domid type to domid_t (Julien Grall) --- tools/xenstored/core.c | 1 + tools/xenstored/core.h | 1 + tools/xenstored/minios.c | 4 ++++ 3 files changed, 6 insertions(+) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index 8ff1faccef..edb2ab97b8 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -2559,6 +2559,7 @@ static struct option options[] = { int dom0_domid = 0; int dom0_event = 0; int priv_domid = 0; +domid_t stub_domid = DOMID_INVALID; static unsigned int get_optval_uint(const char *arg) { diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index ddc345050c..a20c7ee3a0 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -363,6 +363,7 @@ do { \ extern int dom0_domid; extern int dom0_event; extern int priv_domid; +extern domid_t stub_domid; extern bool keep_orphans; extern struct pollfd *fds; diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 5d59cc90cc..38a51e671a 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -20,6 +20,7 @@ #include "core.h" #include "utils.h" #include +#include void finish_daemonize(void) { @@ -48,6 +49,9 @@ void unmap_xenbus(void *interface) void early_init(bool live_update, bool dofork, const char *pidfile) { + stub_domid = get_domid(); + if (stub_domid == DOMID_INVALID) + barf("could not get own domid"); } void late_init(bool live_update) From patchwork Thu Jan 4 09:00:49 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510940 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 70D4AC47074 for ; Thu, 4 Jan 2024 09:14:03 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661336.1031131 (Exim 4.92) (envelope-from ) id 1rLJnX-0001qz-6N; Thu, 04 Jan 2024 09:13:55 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661336.1031131; Thu, 04 Jan 2024 09:13:55 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJnX-0001qm-3b; Thu, 04 Jan 2024 09:13:55 +0000 Received: by outflank-mailman (input) for mailman id 661336; Thu, 04 Jan 2024 09:13:53 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdR-00085z-NY for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:29 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 2081e669-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:29 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id DA59A21EE1; Thu, 4 Jan 2024 09:03:28 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id A1BA913722; Thu, 4 Jan 2024 09:03:28 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id wAo8JmB0lmVSWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:28 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 2081e669-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk , Julien Grall Subject: [PATCH v3 27/33] tools/xenstored: rework ring page (un)map functions Date: Thu, 4 Jan 2024 10:00:49 +0100 Message-Id: <20240104090055.27323-28-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: DA59A21EE1 When [un]mapping the ring page of a Xenstore client, different actions are required for "normal" guests and dom0. Today this distinction is made at call site. Move this distinction into [un]map_interface() instead, avoiding code duplication and preparing special handling for [un]mapping the stub domain's ring page. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- tools/xenstored/domain.c | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index 040df98b8c..af80a8221d 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -497,14 +497,20 @@ static const struct interface_funcs domain_funcs = { static void *map_interface(domid_t domid) { + if (domid == xenbus_master_domid()) + return xenbus_map(); + return xengnttab_map_grant_ref(*xgt_handle, domid, GNTTAB_RESERVED_XENSTORE, PROT_READ|PROT_WRITE); } -static void unmap_interface(void *interface) +static void unmap_interface(domid_t domid, void *interface) { - xengnttab_unmap(*xgt_handle, interface, 1); + if (domid == xenbus_master_domid()) + unmap_xenbus(interface); + else + xengnttab_unmap(*xgt_handle, interface, 1); } static int domain_tree_remove_sub(const void *ctx, struct connection *conn, @@ -594,14 +600,8 @@ static int destroy_domain(void *_domain) eprintf("> Unbinding port %i failed!\n", domain->port); } - if (domain->interface) { - /* Domain 0 was mapped by dom0_init, so it must be unmapped - using munmap() and not the grant unmap call. */ - if (domain->domid == dom0_domid) - unmap_xenbus(domain->interface); - else - unmap_interface(domain->interface); - } + if (domain->interface) + unmap_interface(domain->domid, domain->interface); fire_special_watches("@releaseDomain"); @@ -966,18 +966,13 @@ static struct domain *introduce_domain(const void *ctx, return NULL; if (!domain->introduced) { - interface = is_master_domain ? xenbus_map() - : map_interface(domid); + interface = map_interface(domid); if (!interface && !restore) return NULL; if (new_domain(domain, port, restore)) { rc = errno; - if (interface) { - if (is_master_domain) - unmap_xenbus(interface); - else - unmap_interface(interface); - } + if (interface) + unmap_interface(domid, interface); errno = rc; return NULL; } From patchwork Thu Jan 4 09:00:50 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510911 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 8FEC3C47074 for ; Thu, 4 Jan 2024 09:03:44 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661164.1030900 (Exim 4.92) (envelope-from ) id 1rLJdZ-0004KS-3u; Thu, 04 Jan 2024 09:03:37 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661164.1030900; Thu, 04 Jan 2024 09:03:37 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdZ-0004KL-1D; Thu, 04 Jan 2024 09:03:37 +0000 Received: by outflank-mailman (input) for mailman id 661164; Thu, 04 Jan 2024 09:03:36 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdY-0003cj-Ed for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:36 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id 23e2e423-aae0-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:03:34 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 6CF6D1F7F8; Thu, 4 Jan 2024 09:03:34 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 4251F13722; Thu, 4 Jan 2024 09:03:34 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id QEOLDmZ0lmVZWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:34 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 23e2e423-aae0-11ee-9b0f-b553b5be7939 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359014; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=ZKr5v0Zd94TOVTPo8zPTfeG2cAkiSDv00zjyFxNqKFg=; b=ZVmbxzBnf+KsJMz/aKlkijuouiQXOEosoguDbdisleC+cJxuuPZ7XxycmMm95AOZWf9hvL LZhiY9OQc+b8a1HwNo3z98qDLP2UBELAU5W3UyJXVqX1ynCiB9svEieGp2+2CeYMAnAJgl JLRUlRnrRTvJdOAdp3Rffg/fKOoxdeo= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359014; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=ZKr5v0Zd94TOVTPo8zPTfeG2cAkiSDv00zjyFxNqKFg=; b=ZVmbxzBnf+KsJMz/aKlkijuouiQXOEosoguDbdisleC+cJxuuPZ7XxycmMm95AOZWf9hvL LZhiY9OQc+b8a1HwNo3z98qDLP2UBELAU5W3UyJXVqX1ynCiB9svEieGp2+2CeYMAnAJgl JLRUlRnrRTvJdOAdp3Rffg/fKOoxdeo= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 28/33] tools/xenstored: split domain_init() Date: Thu, 4 Jan 2024 10:00:50 +0100 Message-Id: <20240104090055.27323-29-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Spamd-Result: default: False [4.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; R_MISSING_CHARSET(2.50)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; MIME_GOOD(-0.10)[text/plain]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[5]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; RCVD_TLS_ALL(0.00)[] Today domain_init() is called either just before calling dom0_init() in case no live update is being performed, or it is called after reading the global state from read_state_global(), as the event channel fd is needed. Split up domain_init() into a preparation part which can be called unconditionally, and in a part setting up the event channel handle. Note that there is no chance that chk_domain_generation() can be called now before xc_handle has been setup, so there is no need for the related special case anymore. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V3: - rename new function to domain_early_init() (Julien Grall) --- tools/xenstored/core.c | 2 ++ tools/xenstored/domain.c | 12 ++++++------ tools/xenstored/domain.h | 1 + 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index edb2ab97b8..637c2ac113 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -2744,6 +2744,8 @@ int main(int argc, char *argv[]) talloc_enable_null_tracking(); + domain_early_init(); + /* Listen to hypervisor. */ if (!live_update) { domain_init(-1); diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index af80a8221d..621b415088 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -1224,10 +1224,8 @@ static int domeq_fn(const void *key1, const void *key2) return *(const unsigned int *)key1 == *(const unsigned int *)key2; } -void domain_init(int evtfd) +void domain_early_init(void) { - int rc; - /* Start with a random rather low domain count for the hashtable. */ domhash = create_hashtable(NULL, "domains", domhash_fn, domeq_fn, 0); if (!domhash) @@ -1258,6 +1256,11 @@ void domain_init(int evtfd) xengnttab_set_max_grants(*xgt_handle, DOMID_FIRST_RESERVED); talloc_set_destructor(xgt_handle, close_xgt_handle); +} + +void domain_init(int evtfd) +{ + int rc; if (evtfd < 0) xce_handle = xenevtchn_open(NULL, XENEVTCHN_NO_CLOEXEC); @@ -1291,9 +1294,6 @@ static bool chk_domain_generation(unsigned int domid, uint64_t gen) { struct domain *d; - if (!xc_handle && domid == dom0_domid) - return true; - d = find_domain_struct(domid); return d && d->generation <= gen; diff --git a/tools/xenstored/domain.h b/tools/xenstored/domain.h index 7625dca8cd..224c4c23e2 100644 --- a/tools/xenstored/domain.h +++ b/tools/xenstored/domain.h @@ -82,6 +82,7 @@ int do_get_domain_path(const void *ctx, struct connection *conn, int do_reset_watches(const void *ctx, struct connection *conn, struct buffered_data *in); +void domain_early_init(void); void domain_init(int evtfd); void dom0_init(void); void domain_deinit(void); From patchwork Thu Jan 4 09:00:51 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510912 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 58A44C47074 for ; Thu, 4 Jan 2024 09:03:50 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661165.1030911 (Exim 4.92) (envelope-from ) id 1rLJdf-0004f2-Bw; Thu, 04 Jan 2024 09:03:43 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661165.1030911; Thu, 04 Jan 2024 09:03:43 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdf-0004ev-87; Thu, 04 Jan 2024 09:03:43 +0000 Received: by outflank-mailman (input) for mailman id 661165; Thu, 04 Jan 2024 09:03:41 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdd-0003cj-RH for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:41 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id 272098ea-aae0-11ee-9b0f-b553b5be7939; Thu, 04 Jan 2024 10:03:40 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id EE03A21EE1; Thu, 4 Jan 2024 09:03:39 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id C454613722; Thu, 4 Jan 2024 09:03:39 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id tgyuLmt0lmViWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:39 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 272098ea-aae0-11ee-9b0f-b553b5be7939 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD Subject: [PATCH v3 29/33] tools/xenstored: map stubdom interface Date: Thu, 4 Jan 2024 10:00:51 +0100 Message-Id: <20240104090055.27323-30-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 X-Rspamd-Server: rspamd1.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] Authentication-Results: smtp-out1.suse.de; none X-Rspamd-Queue-Id: EE03A21EE1 When running as stubdom, map the stubdom's Xenstore ring page in order to support using the 9pfs frontend. Use the same pattern as in dom0_init() when running as daemon in dom0 (introduce the own domain, then send an event to the client side to signal Xenstore is ready to communicate). Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- tools/xenstored/core.c | 2 ++ tools/xenstored/domain.c | 27 ++++++++++++++++++++++++++- tools/xenstored/domain.h | 1 + 3 files changed, 29 insertions(+), 1 deletion(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index 637c2ac113..b648af16fa 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -2769,6 +2769,8 @@ int main(int argc, char *argv[]) lu_read_state(); #endif + stubdom_init(); + check_store(); /* Get ready to listen to the tools. */ diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index 621b415088..1a7d5e9756 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -37,6 +37,10 @@ #include #include +#ifdef __MINIOS__ +#include +#endif + static xc_interface **xc_handle; xengnttab_handle **xgt_handle; static evtchn_port_t virq_port; @@ -500,6 +504,11 @@ static void *map_interface(domid_t domid) if (domid == xenbus_master_domid()) return xenbus_map(); +#ifdef __MINIOS__ + if (domid == stub_domid) + return xenstore_buf; +#endif + return xengnttab_map_grant_ref(*xgt_handle, domid, GNTTAB_RESERVED_XENSTORE, PROT_READ|PROT_WRITE); @@ -509,7 +518,7 @@ static void unmap_interface(domid_t domid, void *interface) { if (domid == xenbus_master_domid()) unmap_xenbus(interface); - else + else if (domid != stub_domid) xengnttab_unmap(*xgt_handle, interface, 1); } @@ -1214,6 +1223,22 @@ void dom0_init(void) xenevtchn_notify(xce_handle, dom0->port); } +void stubdom_init(void) +{ +#ifdef __MINIOS__ + struct domain *stubdom; + + if (stub_domid < 0) + return; + + stubdom = introduce_domain(NULL, stub_domid, xenbus_evtchn, false); + if (!stubdom) + barf_perror("Failed to initialize stubdom"); + + xenevtchn_notify(xce_handle, stubdom->port); +#endif +} + static unsigned int domhash_fn(const void *k) { return *(const unsigned int *)k; diff --git a/tools/xenstored/domain.h b/tools/xenstored/domain.h index 224c4c23e2..844ac11510 100644 --- a/tools/xenstored/domain.h +++ b/tools/xenstored/domain.h @@ -85,6 +85,7 @@ int do_reset_watches(const void *ctx, struct connection *conn, void domain_early_init(void); void domain_init(int evtfd); void dom0_init(void); +void stubdom_init(void); void domain_deinit(void); void ignore_connection(struct connection *conn, unsigned int err); From patchwork Thu Jan 4 09:00:52 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510919 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A7686C47073 for ; Thu, 4 Jan 2024 09:09:35 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661191.1030921 (Exim 4.92) (envelope-from ) id 1rLJjA-0005nf-0N; Thu, 04 Jan 2024 09:09:24 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661191.1030921; Thu, 04 Jan 2024 09:09:23 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJj9-0005nY-TI; Thu, 04 Jan 2024 09:09:23 +0000 Received: by outflank-mailman (input) for mailman id 661191; Thu, 04 Jan 2024 09:09:22 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdi-00085z-MP for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:46 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [2a07:de40:b251:101:10:150:64:1]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 2a8f7e8d-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:46 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 8B7E021EE1; Thu, 4 Jan 2024 09:03:45 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 5226E13722; Thu, 4 Jan 2024 09:03:45 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id 9zrOEnF0lmVqWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:45 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 2a8f7e8d-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359025; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9KFYlg3KmBFIQsnRzXZPEKmI+cJA9iig/fH3IH6rFN4=; b=FrMHG+SvOZEpCyhF5i7igK1KfwUBywjoAJX+ZWoyO5KDereFeSh7wO8QyEP6Y6YsU/lPIE imcNmJTVxzHhn8BeeLBq5OAgOyxX5n7Abp+miBmX3NAxt8Mjssl5Y44Pwxp8JzMAemnYaw oA5bP6qV19STvVOY/N66ZcavoMTnIVg= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359025; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9KFYlg3KmBFIQsnRzXZPEKmI+cJA9iig/fH3IH6rFN4=; b=FrMHG+SvOZEpCyhF5i7igK1KfwUBywjoAJX+ZWoyO5KDereFeSh7wO8QyEP6Y6YsU/lPIE imcNmJTVxzHhn8BeeLBq5OAgOyxX5n7Abp+miBmX3NAxt8Mjssl5Y44Pwxp8JzMAemnYaw oA5bP6qV19STvVOY/N66ZcavoMTnIVg= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 30/33] tools/xenstored: mount 9pfs device in stubdom Date: Thu, 4 Jan 2024 10:00:52 +0100 Message-Id: <20240104090055.27323-31-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [4.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; FREEMAIL_ENVRCPT(0.00)[gmail.com]; R_MISSING_CHARSET(2.50)[]; MIME_GOOD(-0.10)[text/plain]; TO_MATCH_ENVRCPT_ALL(0.00)[]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[6]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; FREEMAIL_CC(0.00)[suse.com,xen.org,citrix.com,gmail.com]; RCVD_TLS_ALL(0.00)[] Mount the 9pfs device in stubdom enabling it to use files. This has to happen in a worker thread in order to allow the main thread handling the required Xenstore accesses in parallel. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V3: - add logging in case of errors (Julien Grall) --- tools/xenstored/core.h | 6 +++++ tools/xenstored/domain.c | 2 ++ tools/xenstored/minios.c | 54 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+) diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index a20c7ee3a0..0cb3a272b5 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -36,6 +36,8 @@ #include "list.h" #include "hashtable.h" +#define XENSTORE_LIB_DIR XEN_LIB_DIR "/xenstore" + #ifndef O_CLOEXEC #define O_CLOEXEC 0 /* O_CLOEXEC support is needed for Live Update in the daemon case. */ @@ -398,6 +400,10 @@ int set_fd(int fd, short events); void set_special_fds(void); void handle_special_fds(void); +#ifdef __MINIOS__ +void mount_9pfs(void); +#endif + /* Close stdin/stdout/stderr to complete daemonize */ void finish_daemonize(void); diff --git a/tools/xenstored/domain.c b/tools/xenstored/domain.c index 1a7d5e9756..64c8fd0cc3 100644 --- a/tools/xenstored/domain.c +++ b/tools/xenstored/domain.c @@ -1236,6 +1236,8 @@ void stubdom_init(void) barf_perror("Failed to initialize stubdom"); xenevtchn_notify(xce_handle, stubdom->port); + + mount_9pfs(); #endif } diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 38a51e671a..10e1765f8d 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -17,10 +17,20 @@ */ #include #include +#include +#include "talloc.h" #include "core.h" #include "utils.h" #include #include +#include +#include +#include +#include + +#define P9_STATE_PATH "device/9pfs/0/state" + +static void *p9_device; void finish_daemonize(void) { @@ -65,3 +75,47 @@ void set_special_fds(void) void handle_special_fds(void) { } + +static void mount_thread(void *p) +{ + xenbus_event_queue events = NULL; + char *err; + char *dummy; + + err = xenbus_watch_path_token(XBT_NIL, P9_STATE_PATH, "9pfs", &events); + if (err) { + log("error \"%s\" when setting watch on \"%s\"\n", err, + P9_STATE_PATH); + free(err); + return; + } + + for (;;) { + xenbus_wait_for_watch(&events); + + /* + * We only care for existence of the state node. + * State changes are handled in init_9pfront(). + */ + err = xenbus_read(XBT_NIL, P9_STATE_PATH, &dummy); + if (!err) + break; + free(err); + } + + free(dummy); + + err = xenbus_unwatch_path_token(XBT_NIL, P9_STATE_PATH, "9pfs"); + if (err) { + log("error \"%s\" when unwatching \"%s\", leaking watch\n", + err, P9_STATE_PATH); + free(err); + } + + p9_device = init_9pfront(0, XENSTORE_LIB_DIR); +} + +void mount_9pfs(void) +{ + create_thread("mount-9pfs", mount_thread, NULL); +} From patchwork Thu Jan 4 09:00:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510939 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 16175C47073 for ; Thu, 4 Jan 2024 09:13:49 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661331.1031121 (Exim 4.92) (envelope-from ) id 1rLJnI-0001Ep-UD; Thu, 04 Jan 2024 09:13:40 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661331.1031121; Thu, 04 Jan 2024 09:13:40 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJnI-0001Eg-Qu; Thu, 04 Jan 2024 09:13:40 +0000 Received: by outflank-mailman (input) for mailman id 661331; Thu, 04 Jan 2024 09:13:40 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdo-00085z-7J for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:52 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 2dd082b5-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:51 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 20C2D1F7F9; Thu, 4 Jan 2024 09:03:51 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id D959713722; Thu, 4 Jan 2024 09:03:50 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id EX3KM3Z0lmVxWQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:50 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 2dd082b5-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359031; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=l9WYZ2iW1RdmjGibq9R7j87elTm1vcsn9R88rXyUUm0=; b=aEx8FKBo4+XJhZY/OUXfWBn34j3uoghPNj1AUc4RaBJJq6AbpPfOqaRiqumOBidao8jErn 2KnWyxX2JAHC0xx3XVIWap3pz+61pi36rHE8wsRHw05+OZMExGSGf5StZ+XZ0Kq8oT5Ec/ NuROYfKHD5UKTccpVFmutBGByXRkH0Q= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359031; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=l9WYZ2iW1RdmjGibq9R7j87elTm1vcsn9R88rXyUUm0=; b=aEx8FKBo4+XJhZY/OUXfWBn34j3uoghPNj1AUc4RaBJJq6AbpPfOqaRiqumOBidao8jErn 2KnWyxX2JAHC0xx3XVIWap3pz+61pi36rHE8wsRHw05+OZMExGSGf5StZ+XZ0Kq8oT5Ec/ NuROYfKHD5UKTccpVFmutBGByXRkH0Q= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 31/33] tools/xenstored: add helpers for filename handling Date: Thu, 4 Jan 2024 10:00:53 +0100 Message-Id: <20240104090055.27323-32-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Spamd-Result: default: False [1.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; FREEMAIL_ENVRCPT(0.00)[gmail.com]; R_MISSING_CHARSET(2.50)[]; MIME_GOOD(-0.10)[text/plain]; TO_MATCH_ENVRCPT_ALL(0.00)[]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[6]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; FREEMAIL_CC(0.00)[suse.com,xen.org,citrix.com,gmail.com]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-3.00)[100.00%] Add some helpers for handling filenames which might need different implementations between stubdom and daemon environments: - expansion of relative filenames (those are not really defined today, just expand them to be relative to /var/lib/xen/xenstore) - expansion of xenstore_daemon_rundir() (used e.g. for saving the state file in case of live update - needs to be unchanged in the daemon case, but should result in /var/lib/xen/xenstore for stubdom) Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V3: - make absolute_filename() return a pointer to const (Julien Grall) --- tools/xenstored/core.c | 15 +++++++++++++-- tools/xenstored/core.h | 5 ++++- tools/xenstored/lu_daemon.c | 4 ++-- tools/xenstored/minios.c | 5 +++++ tools/xenstored/posix.c | 8 +++++++- 5 files changed, 31 insertions(+), 6 deletions(-) diff --git a/tools/xenstored/core.c b/tools/xenstored/core.c index b648af16fa..711be878dc 100644 --- a/tools/xenstored/core.c +++ b/tools/xenstored/core.c @@ -65,7 +65,7 @@ char **orig_argv; LIST_HEAD(connections); int tracefd = -1; bool keep_orphans = false; -char *tracefile = NULL; +const char *tracefile = NULL; static struct hashtable *nodes; unsigned int trace_flags = TRACE_OBJ | TRACE_IO; @@ -139,6 +139,17 @@ void trace_destroy(const void *data, const char *type) trace("obj: DESTROY %s %p\n", type, data); } +/* + * Return an absolute filename. + * In case of a relative filename given as input, prepend XENSTORE_LIB_DIR. + */ +const char *absolute_filename(const void *ctx, const char *filename) +{ + if (filename[0] != '/') + return talloc_asprintf(ctx, XENSTORE_LIB_DIR "/%s", filename); + return talloc_strdup(ctx, filename); +} + void close_log(void) { if (tracefd >= 0) @@ -2761,7 +2772,7 @@ int main(int argc, char *argv[]) #endif if (tracefile) - tracefile = talloc_strdup(NULL, tracefile); + tracefile = absolute_filename(NULL, tracefile); #ifndef NO_LIVE_UPDATE /* Read state in case of live update. */ diff --git a/tools/xenstored/core.h b/tools/xenstored/core.h index 0cb3a272b5..9a5615fcbe 100644 --- a/tools/xenstored/core.h +++ b/tools/xenstored/core.h @@ -343,7 +343,7 @@ extern int sock; extern int orig_argc; extern char **orig_argv; -extern char *tracefile; +extern const char *tracefile; extern int tracefd; /* Trace flag values must be kept in sync with trace_switches[] contents. */ @@ -404,6 +404,9 @@ void handle_special_fds(void); void mount_9pfs(void); #endif +const char *xenstore_rundir(void); +const char *absolute_filename(const void *ctx, const char *filename); + /* Close stdin/stdout/stderr to complete daemonize */ void finish_daemonize(void); diff --git a/tools/xenstored/lu_daemon.c b/tools/xenstored/lu_daemon.c index 71bcabadd3..6351111ab0 100644 --- a/tools/xenstored/lu_daemon.c +++ b/tools/xenstored/lu_daemon.c @@ -24,7 +24,7 @@ void lu_get_dump_state(struct lu_dump_state *state) state->size = 0; state->filename = talloc_asprintf(NULL, "%s/state_dump", - xenstore_daemon_rundir()); + xenstore_rundir()); if (!state->filename) barf("Allocation failure"); @@ -65,7 +65,7 @@ FILE *lu_dump_open(const void *ctx) int fd; filename = talloc_asprintf(ctx, "%s/state_dump", - xenstore_daemon_rundir()); + xenstore_rundir()); if (!filename) return NULL; diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 10e1765f8d..24fc3150b7 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -119,3 +119,8 @@ void mount_9pfs(void) { create_thread("mount-9pfs", mount_thread, NULL); } + +const char *xenstore_rundir(void) +{ + return XENSTORE_LIB_DIR; +} diff --git a/tools/xenstored/posix.c b/tools/xenstored/posix.c index f72c8406d2..ad6e874c1e 100644 --- a/tools/xenstored/posix.c +++ b/tools/xenstored/posix.c @@ -325,9 +325,10 @@ void early_init(bool live_update, bool dofork, const char *pidfile) { reopen_log(); - /* Make sure xenstored directory exists. */ + /* Make sure xenstored directories exist. */ /* Errors ignored here, will be reported when we open files */ mkdir(xenstore_daemon_rundir(), 0755); + mkdir(XENSTORE_LIB_DIR, 0755); if (dofork) { openlog("xenstored", 0, LOG_DAEMON); @@ -394,3 +395,8 @@ void late_init(bool live_update) } #endif } + +const char *xenstore_rundir(void) +{ + return xenstore_daemon_rundir(); +} From patchwork Thu Jan 4 09:00:54 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510924 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 0B271C47074 for ; Thu, 4 Jan 2024 09:10:46 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661231.1030961 (Exim 4.92) (envelope-from ) id 1rLJkJ-0000RU-50; Thu, 04 Jan 2024 09:10:35 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661231.1030961; Thu, 04 Jan 2024 09:10:35 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJkJ-0000RL-1Q; Thu, 04 Jan 2024 09:10:35 +0000 Received: by outflank-mailman (input) for mailman id 661231; Thu, 04 Jan 2024 09:10:33 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdt-00085z-OW for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:03:57 +0000 Received: from smtp-out1.suse.de (smtp-out1.suse.de [195.135.223.130]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 312a8c3b-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:03:57 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [10.150.64.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out1.suse.de (Postfix) with ESMTPS id 9F63321EE1; Thu, 4 Jan 2024 09:03:56 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 7099813722; Thu, 4 Jan 2024 09:03:56 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id BBBBGnx0lmV7WQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:03:56 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 312a8c3b-aae0-11ee-98ef-6d05b1d4d9a1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359036; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=e42eKBZw7TAPTT4+EA67aOP59NBUobdQXn2DchzlAu4=; b=PHmDFHRLAvyx6DSPcrHLKIRnd/XR7onewPSypyD6VA0sxd11fpqBGDjlaNIvBEaSpALOLe Y98ZmUcPv1Mr6K7gLT76HRyrA4f/iENOQvJG5mMV1GiO36oI8bLeYTlsMHvIrxQO5MuNhy gY7tsHYPgWLUkuW9OvKrnCpYBiQ/F0I= DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=susede1; t=1704359036; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=e42eKBZw7TAPTT4+EA67aOP59NBUobdQXn2DchzlAu4=; b=PHmDFHRLAvyx6DSPcrHLKIRnd/XR7onewPSypyD6VA0sxd11fpqBGDjlaNIvBEaSpALOLe Y98ZmUcPv1Mr6K7gLT76HRyrA4f/iENOQvJG5mMV1GiO36oI8bLeYTlsMHvIrxQO5MuNhy gY7tsHYPgWLUkuW9OvKrnCpYBiQ/F0I= From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Anthony PERARD , Julien Grall , Jason Andryuk Subject: [PATCH v3 32/33] tools/xenstored: support complete log capabilities in stubdom Date: Thu, 4 Jan 2024 10:00:54 +0100 Message-Id: <20240104090055.27323-33-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out1.suse.de; none X-Spamd-Result: default: False [1.20 / 50.00]; ARC_NA(0.00)[]; RCVD_VIA_SMTP_AUTH(0.00)[]; FROM_HAS_DN(0.00)[]; TO_DN_SOME(0.00)[]; FREEMAIL_ENVRCPT(0.00)[gmail.com]; R_MISSING_CHARSET(2.50)[]; MIME_GOOD(-0.10)[text/plain]; TO_MATCH_ENVRCPT_ALL(0.00)[]; REPLY(-4.00)[]; BROKEN_CONTENT_TYPE(1.50)[]; RCPT_COUNT_FIVE(0.00)[6]; RCVD_COUNT_THREE(0.00)[3]; DKIM_SIGNED(0.00)[suse.com:s=susede1]; NEURAL_HAM_SHORT(-0.20)[-1.000]; NEURAL_SPAM_LONG(3.50)[1.000]; MID_CONTAINS_FROM(1.00)[]; DBL_BLOCKED_OPENRESOLVER(0.00)[suse.com:email]; FUZZY_BLOCKED(0.00)[rspamd.com]; FROM_EQ_ENVFROM(0.00)[]; MIME_TRACE(0.00)[0:+]; FREEMAIL_CC(0.00)[suse.com,xen.org,citrix.com,gmail.com]; RCVD_TLS_ALL(0.00)[]; BAYES_HAM(-3.00)[100.00%] With 9pfs being fully available in Xenstore-stubdom now, there is no reason to not fully support all logging capabilities in stubdom. Open the logfile on stubdom only after the 9pfs file system has been mounted. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk Reviewed-by: Julien Grall --- V3: - remove now stale comment in sysconfig.xencommons.in (Julien Grall) --- .../Linux/init.d/sysconfig.xencommons.in | 1 - tools/hotplug/Linux/launch-xenstore.in | 1 + tools/xenstored/control.c | 30 +++++++++---------- tools/xenstored/minios.c | 3 ++ 4 files changed, 19 insertions(+), 16 deletions(-) diff --git a/tools/hotplug/Linux/init.d/sysconfig.xencommons.in b/tools/hotplug/Linux/init.d/sysconfig.xencommons.in index 433e4849af..1bdd830d8a 100644 --- a/tools/hotplug/Linux/init.d/sysconfig.xencommons.in +++ b/tools/hotplug/Linux/init.d/sysconfig.xencommons.in @@ -58,7 +58,6 @@ XENSTORED_ARGS= ## Default: Not defined, tracing off # # Log xenstored messages -# Only evaluated if XENSTORETYPE is "daemon". #XENSTORED_TRACE=[yes|on|1] ## Type: integer diff --git a/tools/hotplug/Linux/launch-xenstore.in b/tools/hotplug/Linux/launch-xenstore.in index e854ca1eb8..da4eeca7c5 100644 --- a/tools/hotplug/Linux/launch-xenstore.in +++ b/tools/hotplug/Linux/launch-xenstore.in @@ -98,6 +98,7 @@ test -f @CONFIG_DIR@/@CONFIG_LEAF_DIR@/xencommons && . @CONFIG_DIR@/@CONFIG_LEAF [ -z "$XENSTORE_DOMAIN_SIZE" ] && XENSTORE_DOMAIN_SIZE=8 XENSTORE_DOMAIN_ARGS="$XENSTORE_DOMAIN_ARGS --memory $XENSTORE_DOMAIN_SIZE" [ -z "$XENSTORE_MAX_DOMAIN_SIZE" ] || XENSTORE_DOMAIN_ARGS="$XENSTORE_DOMAIN_ARGS --maxmem $XENSTORE_MAX_DOMAIN_SIZE" + [ -z "$XENSTORED_TRACE" ] || XENSTORE_DOMAIN_ARGS="$XENSTORE_DOMAIN_ARGS -T xenstored-trace.log" echo -n Starting $XENSTORE_DOMAIN_KERNEL... ${LIBEXEC_BIN}/init-xenstore-domain $XENSTORE_DOMAIN_ARGS || exit 1 diff --git a/tools/xenstored/control.c b/tools/xenstored/control.c index b2f64d674f..dae23a5ac0 100644 --- a/tools/xenstored/control.c +++ b/tools/xenstored/control.c @@ -201,19 +201,6 @@ static int do_control_quota_s(const void *ctx, struct connection *conn, return EINVAL; } -#ifdef __MINIOS__ -static int do_control_memreport(const void *ctx, struct connection *conn, - const char **vec, int num) -{ - if (num) - return EINVAL; - - talloc_report_full(NULL, stdout); - - send_ack(conn, XS_CONTROL); - return 0; -} -#else static int do_control_logfile(const void *ctx, struct connection *conn, const char **vec, int num) { @@ -222,13 +209,26 @@ static int do_control_logfile(const void *ctx, struct connection *conn, close_log(); talloc_free(tracefile); - tracefile = talloc_strdup(NULL, vec[0]); + tracefile = absolute_filename(NULL, vec[0]); reopen_log(); send_ack(conn, XS_CONTROL); return 0; } +#ifdef __MINIOS__ +static int do_control_memreport(const void *ctx, struct connection *conn, + const char **vec, int num) +{ + if (num) + return EINVAL; + + talloc_report_full(NULL, stdout); + + send_ack(conn, XS_CONTROL); + return 0; +} +#else static int do_control_memreport(const void *ctx, struct connection *conn, const char **vec, int num) { @@ -309,10 +309,10 @@ static struct cmd_s cmds[] = { "[-c ] [-F] [-t ] \n" " Default timeout is 60 seconds.", 5 }, #endif + { "logfile", do_control_logfile, "" }, #ifdef __MINIOS__ { "memreport", do_control_memreport, "" }, #else - { "logfile", do_control_logfile, "" }, { "memreport", do_control_memreport, "[]" }, #endif { "print", do_control_print, "" }, diff --git a/tools/xenstored/minios.c b/tools/xenstored/minios.c index 24fc3150b7..3f3c4b5bc0 100644 --- a/tools/xenstored/minios.c +++ b/tools/xenstored/minios.c @@ -113,6 +113,9 @@ static void mount_thread(void *p) } p9_device = init_9pfront(0, XENSTORE_LIB_DIR); + + /* Start logging if selected. */ + reopen_log(); } void mount_9pfs(void) From patchwork Thu Jan 4 09:00:55 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?b?SsO8cmdlbiBHcm/Dnw==?= X-Patchwork-Id: 13510935 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id C6635C47074 for ; Thu, 4 Jan 2024 09:13:00 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.661298.1031081 (Exim 4.92) (envelope-from ) id 1rLJmW-0006hF-Hz; Thu, 04 Jan 2024 09:12:52 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 661298.1031081; Thu, 04 Jan 2024 09:12:52 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJmW-0006h6-Dd; Thu, 04 Jan 2024 09:12:52 +0000 Received: by outflank-mailman (input) for mailman id 661298; Thu, 04 Jan 2024 09:12:50 +0000 Received: from se1-gles-sth1-in.inumbo.com ([159.253.27.254] helo=se1-gles-sth1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1rLJdz-00085z-24 for xen-devel@lists.xenproject.org; Thu, 04 Jan 2024 09:04:03 +0000 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by se1-gles-sth1.inumbo.com (Halon) with ESMTPS id 346225e0-aae0-11ee-98ef-6d05b1d4d9a1; Thu, 04 Jan 2024 10:04:02 +0100 (CET) Received: from imap1.dmz-prg2.suse.org (imap1.dmz-prg2.suse.org [IPv6:2a07:de40:b281:104:10:150:64:97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 3ACDA1F7F8; Thu, 4 Jan 2024 09:04:02 +0000 (UTC) Received: from imap1.dmz-prg2.suse.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by imap1.dmz-prg2.suse.org (Postfix) with ESMTPS id 00BCE13722; Thu, 4 Jan 2024 09:04:01 +0000 (UTC) Received: from dovecot-director2.suse.de ([2a07:de40:b281:106:10:150:64:167]) by imap1.dmz-prg2.suse.org with ESMTPSA id cmd+OoF0lmV/WQAAD6G6ig (envelope-from ); Thu, 04 Jan 2024 09:04:01 +0000 X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 346225e0-aae0-11ee-98ef-6d05b1d4d9a1 From: Juergen Gross To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Wei Liu , Julien Grall , Anthony PERARD , Jason Andryuk Subject: [PATCH v3 33/33] tools/xenstored: have a single do_control_memreport() Date: Thu, 4 Jan 2024 10:00:55 +0100 Message-Id: <20240104090055.27323-34-jgross@suse.com> X-Mailer: git-send-email 2.35.3 In-Reply-To: <20240104090055.27323-1-jgross@suse.com> References: <20240104090055.27323-1-jgross@suse.com> MIME-Version: 1.0 Authentication-Results: smtp-out2.suse.de; none X-Rspamd-Server: rspamd2.dmz-prg2.suse.org X-Spamd-Result: default: False [-4.00 / 50.00]; REPLY(-4.00)[] X-Rspamd-Queue-Id: 3ACDA1F7F8 With 9pfs now available in Xenstore-stubdom, there is no reason to have distinct do_control_memreport() variants for the daemon and the stubdom implementations. Signed-off-by: Juergen Gross Reviewed-by: Jason Andryuk --- tools/xenstored/control.c | 27 +++++++-------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/tools/xenstored/control.c b/tools/xenstored/control.c index dae23a5ac0..9561289179 100644 --- a/tools/xenstored/control.c +++ b/tools/xenstored/control.c @@ -216,23 +216,11 @@ static int do_control_logfile(const void *ctx, struct connection *conn, return 0; } -#ifdef __MINIOS__ -static int do_control_memreport(const void *ctx, struct connection *conn, - const char **vec, int num) -{ - if (num) - return EINVAL; - - talloc_report_full(NULL, stdout); - - send_ack(conn, XS_CONTROL); - return 0; -} -#else static int do_control_memreport(const void *ctx, struct connection *conn, const char **vec, int num) { FILE *fp; + const char *filename; int fd; if (num > 1) @@ -255,8 +243,12 @@ static int do_control_memreport(const void *ctx, struct connection *conn, if (!fp) close(fd); } - } else - fp = fopen(vec[0], "a"); + } else { + filename = absolute_filename(ctx, vec[0]); + if (!filename) + return ENOMEM; + fp = fopen(filename, "a"); + } if (!fp) return EBADF; @@ -267,7 +259,6 @@ static int do_control_memreport(const void *ctx, struct connection *conn, send_ack(conn, XS_CONTROL); return 0; } -#endif static int do_control_print(const void *ctx, struct connection *conn, const char **vec, int num) @@ -310,11 +301,7 @@ static struct cmd_s cmds[] = { " Default timeout is 60 seconds.", 5 }, #endif { "logfile", do_control_logfile, "" }, -#ifdef __MINIOS__ - { "memreport", do_control_memreport, "" }, -#else { "memreport", do_control_memreport, "[]" }, -#endif { "print", do_control_print, "" }, { "quota", do_control_quota, "[set ||max [-r]]" },