* [PATCH 01/19] xen: Create a new file xen_pvdev.c
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 02/19] xen: Create a new file xen_frontend.c Emil Condrea
` (22 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
The purpose of the new file is to store generic functions shared by frontend
and backends such as xenstore operations, xendevs.
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/Makefile.objs | 2 +-
hw/xen/xen_backend.c | 125 +-----------------------------------
hw/xen/xen_pvdev.c | 149 +++++++++++++++++++++++++++++++++++++++++++
include/hw/xen/xen_backend.h | 63 +-----------------
include/hw/xen/xen_pvdev.h | 71 +++++++++++++++++++++
5 files changed, 223 insertions(+), 187 deletions(-)
create mode 100644 hw/xen/xen_pvdev.c
create mode 100644 include/hw/xen/xen_pvdev.h
diff --git a/hw/xen/Makefile.objs b/hw/xen/Makefile.objs
index d367094..591cdc2 100644
--- a/hw/xen/Makefile.objs
+++ b/hw/xen/Makefile.objs
@@ -1,5 +1,5 @@
# xen backend driver support
-common-obj-$(CONFIG_XEN_BACKEND) += xen_backend.o xen_devconfig.o
+common-obj-$(CONFIG_XEN_BACKEND) += xen_backend.o xen_devconfig.o xen_pvdev.o
obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen-host-pci-device.o
obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen_pt.o xen_pt_config_init.o xen_pt_graphics.o xen_pt_msi.o
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index bab79b1..a251a4a 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -30,6 +30,7 @@
#include "sysemu/char.h"
#include "qemu/log.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_pvdev.h"
#include <xen/grant_table.h>
@@ -56,8 +57,6 @@ static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup =
static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs);
static int debug = 0;
-/* ------------------------------------------------------------- */
-
static void xenstore_cleanup_dir(char *dir)
{
struct xs_dirs *d;
@@ -76,34 +75,6 @@ void xen_config_cleanup(void)
}
}
-int xenstore_write_str(const char *base, const char *node, const char *val)
-{
- char abspath[XEN_BUFSIZE];
-
- snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
- if (!xs_write(xenstore, 0, abspath, val, strlen(val))) {
- return -1;
- }
- return 0;
-}
-
-char *xenstore_read_str(const char *base, const char *node)
-{
- char abspath[XEN_BUFSIZE];
- unsigned int len;
- char *str, *ret = NULL;
-
- snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
- str = xs_read(xenstore, 0, abspath, &len);
- if (str != NULL) {
- /* move to qemu-allocated memory to make sure
- * callers can savely g_free() stuff. */
- ret = g_strdup(str);
- free(str);
- }
- return ret;
-}
-
int xenstore_mkdir(char *path, int p)
{
struct xs_permissions perms[2] = {
@@ -128,48 +99,6 @@ int xenstore_mkdir(char *path, int p)
return 0;
}
-int xenstore_write_int(const char *base, const char *node, int ival)
-{
- char val[12];
-
- snprintf(val, sizeof(val), "%d", ival);
- return xenstore_write_str(base, node, val);
-}
-
-int xenstore_write_int64(const char *base, const char *node, int64_t ival)
-{
- char val[21];
-
- snprintf(val, sizeof(val), "%"PRId64, ival);
- return xenstore_write_str(base, node, val);
-}
-
-int xenstore_read_int(const char *base, const char *node, int *ival)
-{
- char *val;
- int rc = -1;
-
- val = xenstore_read_str(base, node);
- if (val && 1 == sscanf(val, "%d", ival)) {
- rc = 0;
- }
- g_free(val);
- return rc;
-}
-
-int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval)
-{
- char *val;
- int rc = -1;
-
- val = xenstore_read_str(base, node);
- if (val && 1 == sscanf(val, "%"SCNu64, uval)) {
- rc = 0;
- }
- g_free(val);
- return rc;
-}
-
int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val)
{
return xenstore_write_str(xendev->be, node, val);
@@ -212,20 +141,6 @@ int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t
/* ------------------------------------------------------------- */
-const char *xenbus_strstate(enum xenbus_state state)
-{
- static const char *const name[] = {
- [ XenbusStateUnknown ] = "Unknown",
- [ XenbusStateInitialising ] = "Initialising",
- [ XenbusStateInitWait ] = "InitWait",
- [ XenbusStateInitialised ] = "Initialised",
- [ XenbusStateConnected ] = "Connected",
- [ XenbusStateClosing ] = "Closing",
- [ XenbusStateClosed ] = "Closed",
- };
- return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
-}
-
int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
{
int rc;
@@ -833,44 +748,6 @@ int xen_be_send_notify(struct XenDevice *xendev)
return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
}
-/*
- * msg_level:
- * 0 == errors (stderr + logfile).
- * 1 == informative debug messages (logfile only).
- * 2 == noisy debug messages (logfile only).
- * 3 == will flood your log (logfile only).
- */
-void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
-{
- va_list args;
-
- if (xendev) {
- if (msg_level > xendev->debug) {
- return;
- }
- qemu_log("xen be: %s: ", xendev->name);
- if (msg_level == 0) {
- fprintf(stderr, "xen be: %s: ", xendev->name);
- }
- } else {
- if (msg_level > debug) {
- return;
- }
- qemu_log("xen be core: ");
- if (msg_level == 0) {
- fprintf(stderr, "xen be core: ");
- }
- }
- va_start(args, fmt);
- qemu_log_vprintf(fmt, args);
- va_end(args);
- if (msg_level == 0) {
- va_start(args, fmt);
- vfprintf(stderr, fmt, args);
- va_end(args);
- }
- qemu_log_flush();
-}
static int xen_sysdev_init(SysBusDevice *dev)
{
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
new file mode 100644
index 0000000..a444855
--- /dev/null
+++ b/hw/xen/xen_pvdev.c
@@ -0,0 +1,149 @@
+/*
+ * Xen para-virtualization device
+ *
+ * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>
+ */
+
+#include "qemu/osdep.h"
+
+#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_pvdev.h"
+
+static int debug = 0;
+/* ------------------------------------------------------------- */
+
+int xenstore_write_str(const char *base, const char *node, const char *val)
+{
+ char abspath[XEN_BUFSIZE];
+
+ snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
+ if (!xs_write(xenstore, 0, abspath, val, strlen(val))) {
+ return -1;
+ }
+ return 0;
+}
+
+char *xenstore_read_str(const char *base, const char *node)
+{
+ char abspath[XEN_BUFSIZE];
+ unsigned int len;
+ char *str, *ret = NULL;
+
+ snprintf(abspath, sizeof(abspath), "%s/%s", base, node);
+ str = xs_read(xenstore, 0, abspath, &len);
+ if (str != NULL) {
+ /* move to qemu-allocated memory to make sure
+ * callers can savely g_free() stuff. */
+ ret = g_strdup(str);
+ free(str);
+ }
+ return ret;
+}
+
+int xenstore_write_int(const char *base, const char *node, int ival)
+{
+ char val[12];
+
+ snprintf(val, sizeof(val), "%d", ival);
+ return xenstore_write_str(base, node, val);
+}
+
+int xenstore_write_int64(const char *base, const char *node, int64_t ival)
+{
+ char val[21];
+
+ snprintf(val, sizeof(val), "%"PRId64, ival);
+ return xenstore_write_str(base, node, val);
+}
+
+int xenstore_read_int(const char *base, const char *node, int *ival)
+{
+ char *val;
+ int rc = -1;
+
+ val = xenstore_read_str(base, node);
+ if (val && 1 == sscanf(val, "%d", ival)) {
+ rc = 0;
+ }
+ g_free(val);
+ return rc;
+}
+
+int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval)
+{
+ char *val;
+ int rc = -1;
+
+ val = xenstore_read_str(base, node);
+ if (val && 1 == sscanf(val, "%"SCNu64, uval)) {
+ rc = 0;
+ }
+ g_free(val);
+ return rc;
+}
+
+const char *xenbus_strstate(enum xenbus_state state)
+{
+ static const char *const name[] = {
+ [ XenbusStateUnknown ] = "Unknown",
+ [ XenbusStateInitialising ] = "Initialising",
+ [ XenbusStateInitWait ] = "InitWait",
+ [ XenbusStateInitialised ] = "Initialised",
+ [ XenbusStateConnected ] = "Connected",
+ [ XenbusStateClosing ] = "Closing",
+ [ XenbusStateClosed ] = "Closed",
+ };
+ return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
+}
+
+/*
+ * msg_level:
+ * 0 == errors (stderr + logfile).
+ * 1 == informative debug messages (logfile only).
+ * 2 == noisy debug messages (logfile only).
+ * 3 == will flood your log (logfile only).
+ */
+void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
+{
+ va_list args;
+
+ if (xendev) {
+ if (msg_level > xendev->debug) {
+ return;
+ }
+ qemu_log("xen be: %s: ", xendev->name);
+ if (msg_level == 0) {
+ fprintf(stderr, "xen be: %s: ", xendev->name);
+ }
+ } else {
+ if (msg_level > debug) {
+ return;
+ }
+ qemu_log("xen be core: ");
+ if (msg_level == 0) {
+ fprintf(stderr, "xen be core: ");
+ }
+ }
+ va_start(args, fmt);
+ qemu_log_vprintf(fmt, args);
+ va_end(args);
+ if (msg_level == 0) {
+ va_start(args, fmt);
+ vfprintf(stderr, fmt, args);
+ va_end(args);
+ }
+ qemu_log_flush();
+}
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 6e18a46..0f009e3 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -2,60 +2,10 @@
#define QEMU_HW_XEN_BACKEND_H 1
#include "hw/xen/xen_common.h"
+#include "hw/xen/xen_pvdev.h"
#include "sysemu/sysemu.h"
#include "net/net.h"
-/* ------------------------------------------------------------- */
-
-#define XEN_BUFSIZE 1024
-
-struct XenDevice;
-
-/* driver uses grant tables -> open gntdev device (xendev->gnttabdev) */
-#define DEVOPS_FLAG_NEED_GNTDEV 1
-/* don't expect frontend doing correct state transitions (aka console quirk) */
-#define DEVOPS_FLAG_IGNORE_STATE 2
-
-struct XenDevOps {
- size_t size;
- uint32_t flags;
- void (*alloc)(struct XenDevice *xendev);
- int (*init)(struct XenDevice *xendev);
- int (*initialise)(struct XenDevice *xendev);
- void (*connected)(struct XenDevice *xendev);
- void (*event)(struct XenDevice *xendev);
- void (*disconnect)(struct XenDevice *xendev);
- int (*free)(struct XenDevice *xendev);
- void (*backend_changed)(struct XenDevice *xendev, const char *node);
- void (*frontend_changed)(struct XenDevice *xendev, const char *node);
- int (*backend_register)(void);
-};
-
-struct XenDevice {
- const char *type;
- int dom;
- int dev;
- char name[64];
- int debug;
-
- enum xenbus_state be_state;
- enum xenbus_state fe_state;
- int online;
- char be[XEN_BUFSIZE];
- char *fe;
- char *protocol;
- int remote_port;
- int local_port;
-
- xenevtchn_handle *evtchndev;
- xengnttab_handle *gnttabdev;
-
- struct XenDevOps *ops;
- QTAILQ_ENTRY(XenDevice) next;
-};
-
-/* ------------------------------------------------------------- */
-
/* variables */
extern xc_interface *xen_xc;
extern xenforeignmemory_handle *xen_fmem;
@@ -63,14 +13,7 @@ extern struct xs_handle *xenstore;
extern const char *xen_protocol;
extern DeviceState *xen_sysdev;
-/* xenstore helper functions */
int xenstore_mkdir(char *path, int p);
-int xenstore_write_str(const char *base, const char *node, const char *val);
-int xenstore_write_int(const char *base, const char *node, int ival);
-int xenstore_write_int64(const char *base, const char *node, int64_t ival);
-char *xenstore_read_str(const char *base, const char *node);
-int xenstore_read_int(const char *base, const char *node, int *ival);
-
int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val);
int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival);
int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival);
@@ -78,10 +21,8 @@ char *xenstore_read_be_str(struct XenDevice *xendev, const char *node);
int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival);
char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node);
int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
-int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval);
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
-const char *xenbus_strstate(enum xenbus_state state);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_check_state(struct XenDevice *xendev);
@@ -92,8 +33,6 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state);
int xen_be_bind_evtchn(struct XenDevice *xendev);
void xen_be_unbind_evtchn(struct XenDevice *xendev);
int xen_be_send_notify(struct XenDevice *xendev);
-void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
- GCC_FMT_ATTR(3, 4);
/* actual backend drivers */
extern struct XenDevOps xen_console_ops; /* xen_console.c */
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
new file mode 100644
index 0000000..f60bfae
--- /dev/null
+++ b/include/hw/xen/xen_pvdev.h
@@ -0,0 +1,71 @@
+#ifndef QEMU_HW_XEN_PVDEV_H
+#define QEMU_HW_XEN_PVDEV_H 1
+
+#include "hw/xen/xen_common.h"
+#include <inttypes.h>
+
+/* ------------------------------------------------------------- */
+
+#define XEN_BUFSIZE 1024
+
+struct XenDevice;
+
+/* driver uses grant tables -> open gntdev device (xendev->gnttabdev) */
+#define DEVOPS_FLAG_NEED_GNTDEV 1
+/* don't expect frontend doing correct state transitions (aka console quirk) */
+#define DEVOPS_FLAG_IGNORE_STATE 2
+
+struct XenDevOps {
+ size_t size;
+ uint32_t flags;
+ void (*alloc)(struct XenDevice *xendev);
+ int (*init)(struct XenDevice *xendev);
+ int (*initialise)(struct XenDevice *xendev);
+ void (*connected)(struct XenDevice *xendev);
+ void (*event)(struct XenDevice *xendev);
+ void (*disconnect)(struct XenDevice *xendev);
+ int (*free)(struct XenDevice *xendev);
+ void (*backend_changed)(struct XenDevice *xendev, const char *node);
+ void (*frontend_changed)(struct XenDevice *xendev, const char *node);
+ int (*backend_register)(void);
+};
+
+struct XenDevice {
+ const char *type;
+ int dom;
+ int dev;
+ char name[64];
+ int debug;
+
+ enum xenbus_state be_state;
+ enum xenbus_state fe_state;
+ int online;
+ char be[XEN_BUFSIZE];
+ char *fe;
+ char *protocol;
+ int remote_port;
+ int local_port;
+
+ xenevtchn_handle *evtchndev;
+ xengnttab_handle *gnttabdev;
+
+ struct XenDevOps *ops;
+ QTAILQ_ENTRY(XenDevice) next;
+};
+
+/* ------------------------------------------------------------- */
+
+/* xenstore helper functions */
+int xenstore_write_str(const char *base, const char *node, const char *val);
+int xenstore_write_int(const char *base, const char *node, int ival);
+int xenstore_write_int64(const char *base, const char *node, int64_t ival);
+char *xenstore_read_str(const char *base, const char *node);
+int xenstore_read_int(const char *base, const char *node, int *ival);
+int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval);
+
+const char *xenbus_strstate(enum xenbus_state state);
+
+void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
+ GCC_FMT_ATTR(3, 4);
+
+#endif /* QEMU_HW_XEN_PVDEV_H */
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 02/19] xen: Create a new file xen_frontend.c
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
2016-07-10 11:47 ` [PATCH 01/19] xen: Create a new file xen_pvdev.c Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-25 13:45 ` Anthony PERARD
2016-07-10 11:47 ` [PATCH 03/19] xen: Move xenstore_update to xen_pvdev.c Emil Condrea
` (21 subsequent siblings)
23 siblings, 1 reply; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Its purpose is to store frontend related functions.
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/block/xen_disk.c | 1 +
hw/display/xenfb.c | 1 +
hw/net/xen_nic.c | 1 +
hw/xen/Makefile.objs | 2 +-
hw/xen/xen_backend.c | 47 +----------------------------
hw/xen/xen_frontend.c | 70 +++++++++++++++++++++++++++++++++++++++++++
include/hw/xen/xen_backend.h | 3 --
include/hw/xen/xen_frontend.h | 10 +++++++
8 files changed, 85 insertions(+), 50 deletions(-)
create mode 100644 hw/xen/xen_frontend.c
create mode 100644 include/hw/xen/xen_frontend.h
diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c
index 90aca73..28fbf24 100644
--- a/hw/block/xen_disk.c
+++ b/hw/block/xen_disk.c
@@ -25,6 +25,7 @@
#include "hw/hw.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include "xen_blkif.h"
#include "sysemu/blockdev.h"
#include "sysemu/block-backend.h"
diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
index 46b7d5e..5751113 100644
--- a/hw/display/xenfb.c
+++ b/hw/display/xenfb.c
@@ -30,6 +30,7 @@
#include "ui/console.h"
#include "sysemu/char.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include <xen/event_channel.h>
#include <xen/io/fbif.h>
diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
index 0b4ddae..bdfa789 100644
--- a/hw/net/xen_nic.c
+++ b/hw/net/xen_nic.c
@@ -29,6 +29,7 @@
#include "net/checksum.h"
#include "net/util.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include <xen/io/netif.h>
diff --git a/hw/xen/Makefile.objs b/hw/xen/Makefile.objs
index 591cdc2..1000294 100644
--- a/hw/xen/Makefile.objs
+++ b/hw/xen/Makefile.objs
@@ -1,5 +1,5 @@
# xen backend driver support
-common-obj-$(CONFIG_XEN_BACKEND) += xen_backend.o xen_devconfig.o xen_pvdev.o
+common-obj-$(CONFIG_XEN_BACKEND) += xen_backend.o xen_frontend.o xen_devconfig.o xen_pvdev.o
obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen-host-pci-device.o
obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen_pt.o xen_pt_config_init.o xen_pt_graphics.o xen_pt_msi.o
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index a251a4a..7a83a7d 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -30,6 +30,7 @@
#include "sysemu/char.h"
#include "qemu/log.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include "hw/xen/xen_pvdev.h"
#include <xen/grant_table.h>
@@ -124,21 +125,6 @@ int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival)
return xenstore_read_int(xendev->be, node, ival);
}
-char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
-{
- return xenstore_read_str(xendev->fe, node);
-}
-
-int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival)
-{
- return xenstore_read_int(xendev->fe, node, ival);
-}
-
-int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval)
-{
- return xenstore_read_uint64(xendev->fe, node, uval);
-}
-
/* ------------------------------------------------------------- */
int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
@@ -301,37 +287,6 @@ static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
}
}
-static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
-{
- int fe_state;
-
- if (node == NULL || strcmp(node, "state") == 0) {
- if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
- fe_state = XenbusStateUnknown;
- }
- if (xendev->fe_state != fe_state) {
- xen_be_printf(xendev, 1, "frontend state: %s -> %s\n",
- xenbus_strstate(xendev->fe_state),
- xenbus_strstate(fe_state));
- }
- xendev->fe_state = fe_state;
- }
- if (node == NULL || strcmp(node, "protocol") == 0) {
- g_free(xendev->protocol);
- xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
- if (xendev->protocol) {
- xen_be_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol);
- }
- }
-
- if (node) {
- xen_be_printf(xendev, 2, "frontend update: %s\n", node);
- if (xendev->ops->frontend_changed) {
- xendev->ops->frontend_changed(xendev, node);
- }
- }
-}
-
/* ------------------------------------------------------------- */
/* Check for possible state transitions and perform them. */
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
new file mode 100644
index 0000000..b4bf8da
--- /dev/null
+++ b/hw/xen/xen_frontend.c
@@ -0,0 +1,70 @@
+/*
+ * Xen frontend driver infrastructure
+ *
+ * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>
+ */
+
+#include "qemu/osdep.h"
+
+#include "hw/xen/xen_pvdev.h"
+#include "hw/xen/xen_frontend.h"
+#include "hw/xen/xen_backend.h"
+
+char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
+{
+ return xenstore_read_str(xendev->fe, node);
+}
+
+int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival)
+{
+ return xenstore_read_int(xendev->fe, node, ival);
+}
+
+int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval)
+{
+ return xenstore_read_uint64(xendev->fe, node, uval);
+}
+
+void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
+{
+ int fe_state;
+
+ if (node == NULL || strcmp(node, "state") == 0) {
+ if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
+ fe_state = XenbusStateUnknown;
+ }
+ if (xendev->fe_state != fe_state) {
+ xen_be_printf(xendev, 1, "frontend state: %s -> %s\n",
+ xenbus_strstate(xendev->fe_state),
+ xenbus_strstate(fe_state));
+ }
+ xendev->fe_state = fe_state;
+ }
+ if (node == NULL || strcmp(node, "protocol") == 0) {
+ g_free(xendev->protocol);
+ xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
+ if (xendev->protocol) {
+ xen_be_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol);
+ }
+ }
+
+ if (node) {
+ xen_be_printf(xendev, 2, "frontend update: %s\n", node);
+ if (xendev->ops->frontend_changed) {
+ xendev->ops->frontend_changed(xendev, node);
+ }
+ }
+}
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 0f009e3..0daaf7c 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -19,9 +19,6 @@ int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival);
int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival);
char *xenstore_read_be_str(struct XenDevice *xendev, const char *node);
int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival);
-char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node);
-int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
-int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_check_state(struct XenDevice *xendev);
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
new file mode 100644
index 0000000..46485b9
--- /dev/null
+++ b/include/hw/xen/xen_frontend.h
@@ -0,0 +1,10 @@
+#ifndef QEMU_HW_XEN_FRONTEND_H
+#define QEMU_HW_XEN_FRONTEND_H 1
+
+char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node);
+int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
+int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
+
+void xen_be_frontend_changed(struct XenDevice *xendev, const char *node);
+
+#endif /* QEMU_HW_XEN_FRONTEND_H */
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [PATCH 02/19] xen: Create a new file xen_frontend.c
2016-07-10 11:47 ` [PATCH 02/19] xen: Create a new file xen_frontend.c Emil Condrea
@ 2016-07-25 13:45 ` Anthony PERARD
0 siblings, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 13:45 UTC (permalink / raw)
To: Emil Condrea
Cc: wei.liu2, stefano.stabellini, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra, eblake
On Sun, Jul 10, 2016 at 02:47:33PM +0300, Emil Condrea wrote:
> Its purpose is to store frontend related functions.
>
> Signed-off-by: Quan Xu <quan.xu@intel.com>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> ---
> hw/block/xen_disk.c | 1 +
> hw/display/xenfb.c | 1 +
> hw/net/xen_nic.c | 1 +
> hw/xen/Makefile.objs | 2 +-
> hw/xen/xen_backend.c | 47 +----------------------------
> hw/xen/xen_frontend.c | 70 +++++++++++++++++++++++++++++++++++++++++++
> include/hw/xen/xen_backend.h | 3 --
> include/hw/xen/xen_frontend.h | 10 +++++++
> 8 files changed, 85 insertions(+), 50 deletions(-)
> create mode 100644 hw/xen/xen_frontend.c
> create mode 100644 include/hw/xen/xen_frontend.h
>
> diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c
> index 90aca73..28fbf24 100644
> --- a/hw/block/xen_disk.c
> +++ b/hw/block/xen_disk.c
> @@ -25,6 +25,7 @@
>
> #include "hw/hw.h"
> #include "hw/xen/xen_backend.h"
> +#include "hw/xen/xen_frontend.h"
> #include "xen_blkif.h"
> #include "sysemu/blockdev.h"
> #include "sysemu/block-backend.h"
> diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
> index 46b7d5e..5751113 100644
> --- a/hw/display/xenfb.c
> +++ b/hw/display/xenfb.c
> @@ -30,6 +30,7 @@
> #include "ui/console.h"
> #include "sysemu/char.h"
> #include "hw/xen/xen_backend.h"
> +#include "hw/xen/xen_frontend.h"
>
> #include <xen/event_channel.h>
> #include <xen/io/fbif.h>
> diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
> index 0b4ddae..bdfa789 100644
> --- a/hw/net/xen_nic.c
> +++ b/hw/net/xen_nic.c
> @@ -29,6 +29,7 @@
> #include "net/checksum.h"
> #include "net/util.h"
> #include "hw/xen/xen_backend.h"
> +#include "hw/xen/xen_frontend.h"
>
> #include <xen/io/netif.h>
>
There is also "hw/usb/xen-usb.c" that needs to be updated to include
"hw/xen/xen_frontend.h".
> diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
> new file mode 100644
> index 0000000..46485b9
> --- /dev/null
> +++ b/include/hw/xen/xen_frontend.h
> @@ -0,0 +1,10 @@
> +#ifndef QEMU_HW_XEN_FRONTEND_H
> +#define QEMU_HW_XEN_FRONTEND_H 1
No need for the 1 here.
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 03/19] xen: Move xenstore_update to xen_pvdev.c
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
2016-07-10 11:47 ` [PATCH 01/19] xen: Create a new file xen_pvdev.c Emil Condrea
2016-07-10 11:47 ` [PATCH 02/19] xen: Create a new file xen_frontend.c Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 04/19] xen: Move evtchn functions " Emil Condrea
` (20 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
* xenstore_update -> xen_pvdev.c
* xenstore_update_fe -> xen_frontend.c
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 43 +------------------------------------------
hw/xen/xen_frontend.c | 18 ++++++++++++++++++
hw/xen/xen_pvdev.c | 24 ++++++++++++++++++++++++
include/hw/xen/xen_backend.h | 1 +
include/hw/xen/xen_frontend.h | 1 +
include/hw/xen/xen_pvdev.h | 1 +
6 files changed, 46 insertions(+), 42 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 7a83a7d..0a9f9bb 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -527,7 +527,7 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
return 0;
}
-static void xenstore_update_be(char *watch, char *type, int dom,
+void xenstore_update_be(char *watch, char *type, int dom,
struct XenDevOps *ops)
{
struct XenDevice *xendev;
@@ -561,47 +561,6 @@ static void xenstore_update_be(char *watch, char *type, int dom,
}
}
-static void xenstore_update_fe(char *watch, struct XenDevice *xendev)
-{
- char *node;
- unsigned int len;
-
- len = strlen(xendev->fe);
- if (strncmp(xendev->fe, watch, len) != 0) {
- return;
- }
- if (watch[len] != '/') {
- return;
- }
- node = watch + len + 1;
-
- xen_be_frontend_changed(xendev, node);
- xen_be_check_state(xendev);
-}
-
-static void xenstore_update(void *unused)
-{
- char **vec = NULL;
- intptr_t type, ops, ptr;
- unsigned int dom, count;
-
- vec = xs_read_watch(xenstore, &count);
- if (vec == NULL) {
- goto cleanup;
- }
-
- if (sscanf(vec[XS_WATCH_TOKEN], "be:%" PRIxPTR ":%d:%" PRIxPTR,
- &type, &dom, &ops) == 3) {
- xenstore_update_be(vec[XS_WATCH_PATH], (void*)type, dom, (void*)ops);
- }
- if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR, &ptr) == 1) {
- xenstore_update_fe(vec[XS_WATCH_PATH], (void*)ptr);
- }
-
-cleanup:
- free(vec);
-}
-
static void xen_be_evtchn_event(void *opaque)
{
struct XenDevice *xendev = opaque;
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
index b4bf8da..4e01169 100644
--- a/hw/xen/xen_frontend.c
+++ b/hw/xen/xen_frontend.c
@@ -68,3 +68,21 @@ void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
}
}
}
+
+void xenstore_update_fe(char *watch, struct XenDevice *xendev)
+{
+ char *node;
+ unsigned int len;
+
+ len = strlen(xendev->fe);
+ if (strncmp(xendev->fe, watch, len) != 0) {
+ return;
+ }
+ if (watch[len] != '/') {
+ return;
+ }
+ node = watch + len + 1;
+
+ xen_be_frontend_changed(xendev, node);
+ xen_be_check_state(xendev);
+}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index a444855..001fda2 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -20,6 +20,7 @@
#include "qemu/osdep.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include "hw/xen/xen_pvdev.h"
static int debug = 0;
@@ -95,6 +96,29 @@ int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval)
return rc;
}
+void xenstore_update(void *unused)
+{
+ char **vec = NULL;
+ intptr_t type, ops, ptr;
+ unsigned int dom, count;
+
+ vec = xs_read_watch(xenstore, &count);
+ if (vec == NULL) {
+ goto cleanup;
+ }
+
+ if (sscanf(vec[XS_WATCH_TOKEN], "be:%" PRIxPTR ":%d:%" PRIxPTR,
+ &type, &dom, &ops) == 3) {
+ xenstore_update_be(vec[XS_WATCH_PATH], (void*)type, dom, (void*)ops);
+ }
+ if (sscanf(vec[XS_WATCH_TOKEN], "fe:%" PRIxPTR, &ptr) == 1) {
+ xenstore_update_fe(vec[XS_WATCH_PATH], (void*)ptr);
+ }
+
+cleanup:
+ free(vec);
+}
+
const char *xenbus_strstate(enum xenbus_state state)
{
static const char *const name[] = {
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 0daaf7c..4832f79 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -19,6 +19,7 @@ int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival);
int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival);
char *xenstore_read_be_str(struct XenDevice *xendev, const char *node);
int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival);
+void xenstore_update_be(char *watch, char *type, int dom, struct XenDevOps *ops);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_check_state(struct XenDevice *xendev);
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
index 46485b9..7d87da4 100644
--- a/include/hw/xen/xen_frontend.h
+++ b/include/hw/xen/xen_frontend.h
@@ -4,6 +4,7 @@
char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node);
int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
+void xenstore_update_fe(char *watch, struct XenDevice *xendev);
void xen_be_frontend_changed(struct XenDevice *xendev, const char *node);
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index f60bfae..cc49636 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -62,6 +62,7 @@ int xenstore_write_int64(const char *base, const char *node, int64_t ival);
char *xenstore_read_str(const char *base, const char *node);
int xenstore_read_int(const char *base, const char *node, int *ival);
int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval);
+void xenstore_update(void *unused);
const char *xenbus_strstate(enum xenbus_state state);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 04/19] xen: Move evtchn functions to xen_pvdev.c
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (2 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 03/19] xen: Move xenstore_update to xen_pvdev.c Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-25 13:53 ` Anthony PERARD
[not found] ` <20160725135311.GI1835@perard.uk.xensource.com>
2016-07-10 11:47 ` [PATCH 05/19] xen: Prepare xendev qtail to be shared with frontends Emil Condrea
` (19 subsequent siblings)
23 siblings, 2 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
The name of the functions moved:
* xen_be_evtchn_event
* xen_be_unbind_evtchn
* xen_be_send_notify
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 37 +------------------------------------
hw/xen/xen_pvdev.c | 35 +++++++++++++++++++++++++++++++++++
include/hw/xen/xen_backend.h | 2 --
include/hw/xen/xen_pvdev.h | 4 ++++
4 files changed, 40 insertions(+), 38 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 0a9f9bb..5f2821a 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -561,25 +561,6 @@ void xenstore_update_be(char *watch, char *type, int dom,
}
}
-static void xen_be_evtchn_event(void *opaque)
-{
- struct XenDevice *xendev = opaque;
- evtchn_port_t port;
-
- port = xenevtchn_pending(xendev->evtchndev);
- if (port != xendev->local_port) {
- xen_be_printf(xendev, 0,
- "xenevtchn_pending returned %d (expected %d)\n",
- port, xendev->local_port);
- return;
- }
- xenevtchn_unmask(xendev->evtchndev, port);
-
- if (xendev->ops->event) {
- xendev->ops->event(xendev);
- }
-}
-
/* -------------------------------------------------------------------- */
int xen_be_init(void)
@@ -646,22 +627,6 @@ int xen_be_bind_evtchn(struct XenDevice *xendev)
return 0;
}
-void xen_be_unbind_evtchn(struct XenDevice *xendev)
-{
- if (xendev->local_port == -1) {
- return;
- }
- qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
- xenevtchn_unbind(xendev->evtchndev, xendev->local_port);
- xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
- xendev->local_port = -1;
-}
-
-int xen_be_send_notify(struct XenDevice *xendev)
-{
- return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
-}
-
static int xen_sysdev_init(SysBusDevice *dev)
{
@@ -693,4 +658,4 @@ static void xenbe_register_types(void)
type_register_static(&xensysdev_info);
}
-type_init(xenbe_register_types);
+type_init(xenbe_register_types);
\ No newline at end of file
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 001fda2..7876724 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -171,3 +171,38 @@ void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...
}
qemu_log_flush();
}
+
+void xen_be_evtchn_event(void *opaque)
+{
+ struct XenDevice *xendev = opaque;
+ evtchn_port_t port;
+
+ port = xenevtchn_pending(xendev->evtchndev);
+ if (port != xendev->local_port) {
+ xen_be_printf(xendev, 0,
+ "xenevtchn_pending returned %d (expected %d)\n",
+ port, xendev->local_port);
+ return;
+ }
+ xenevtchn_unmask(xendev->evtchndev, port);
+
+ if (xendev->ops->event) {
+ xendev->ops->event(xendev);
+ }
+}
+
+void xen_be_unbind_evtchn(struct XenDevice *xendev)
+{
+ if (xendev->local_port == -1) {
+ return;
+ }
+ qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
+ xenevtchn_unbind(xendev->evtchndev, xendev->local_port);
+ xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
+ xendev->local_port = -1;
+}
+
+int xen_be_send_notify(struct XenDevice *xendev)
+{
+ return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
+}
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 4832f79..60b634e 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -29,8 +29,6 @@ int xen_be_init(void);
int xen_be_register(const char *type, struct XenDevOps *ops);
int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state);
int xen_be_bind_evtchn(struct XenDevice *xendev);
-void xen_be_unbind_evtchn(struct XenDevice *xendev);
-int xen_be_send_notify(struct XenDevice *xendev);
/* actual backend drivers */
extern struct XenDevOps xen_console_ops; /* xen_console.c */
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index cc49636..f269b04 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -66,6 +66,10 @@ void xenstore_update(void *unused);
const char *xenbus_strstate(enum xenbus_state state);
+void xen_be_evtchn_event(void *opaque);
+void xen_be_unbind_evtchn(struct XenDevice *xendev);
+int xen_be_send_notify(struct XenDevice *xendev);
+
void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
GCC_FMT_ATTR(3, 4);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [PATCH 04/19] xen: Move evtchn functions to xen_pvdev.c
2016-07-10 11:47 ` [PATCH 04/19] xen: Move evtchn functions " Emil Condrea
@ 2016-07-25 13:53 ` Anthony PERARD
[not found] ` <20160725135311.GI1835@perard.uk.xensource.com>
1 sibling, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 13:53 UTC (permalink / raw)
To: Emil Condrea
Cc: wei.liu2, stefano.stabellini, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra, eblake
On Sun, Jul 10, 2016 at 02:47:35PM +0300, Emil Condrea wrote:
> The name of the functions moved:
> * xen_be_evtchn_event
> * xen_be_unbind_evtchn
> * xen_be_send_notify
>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> ---
> hw/xen/xen_backend.c | 37 +------------------------------------
> hw/xen/xen_pvdev.c | 35 +++++++++++++++++++++++++++++++++++
> include/hw/xen/xen_backend.h | 2 --
> include/hw/xen/xen_pvdev.h | 4 ++++
> 4 files changed, 40 insertions(+), 38 deletions(-)
>
> diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
> index 0a9f9bb..5f2821a 100644
> --- a/hw/xen/xen_backend.c
> +++ b/hw/xen/xen_backend.c
> @@ -693,4 +658,4 @@ static void xenbe_register_types(void)
> type_register_static(&xensysdev_info);
> }
>
> -type_init(xenbe_register_types);
> +type_init(xenbe_register_types);
> \ No newline at end of file
Looks like this change does not belong to this patch.
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread[parent not found: <20160725135311.GI1835@perard.uk.xensource.com>]
* Re: [PATCH 04/19] xen: Move evtchn functions to xen_pvdev.c
[not found] ` <20160725135311.GI1835@perard.uk.xensource.com>
@ 2016-07-27 23:16 ` Eric Blake
2016-07-31 9:47 ` Emil Condrea
1 sibling, 0 replies; 35+ messages in thread
From: Eric Blake @ 2016-07-27 23:16 UTC (permalink / raw)
To: Anthony PERARD, Emil Condrea
Cc: wei.liu2, stefano.stabellini, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra
[-- Attachment #1.1.1: Type: text/plain, Size: 1332 bytes --]
On 07/25/2016 07:53 AM, Anthony PERARD wrote:
> On Sun, Jul 10, 2016 at 02:47:35PM +0300, Emil Condrea wrote:
>> The name of the functions moved:
>> * xen_be_evtchn_event
>> * xen_be_unbind_evtchn
>> * xen_be_send_notify
>>
>> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
>> ---
>> hw/xen/xen_backend.c | 37 +------------------------------------
>> hw/xen/xen_pvdev.c | 35 +++++++++++++++++++++++++++++++++++
>> include/hw/xen/xen_backend.h | 2 --
>> include/hw/xen/xen_pvdev.h | 4 ++++
>> 4 files changed, 40 insertions(+), 38 deletions(-)
>>
>> diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
>> index 0a9f9bb..5f2821a 100644
>> --- a/hw/xen/xen_backend.c
>> +++ b/hw/xen/xen_backend.c
>> @@ -693,4 +658,4 @@ static void xenbe_register_types(void)
>> type_register_static(&xensysdev_info);
>> }
>>
>> -type_init(xenbe_register_types);
>> +type_init(xenbe_register_types);
>> \ No newline at end of file
>
> Looks like this change does not belong to this patch.
For that matter, we prefer that all text files in qemu.git end in a
newline (since according to POSIX, a non-empty file that does not end in
newline is not a text file).
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #1.2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
[-- Attachment #2: Type: text/plain, Size: 127 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread* Re: [PATCH 04/19] xen: Move evtchn functions to xen_pvdev.c
[not found] ` <20160725135311.GI1835@perard.uk.xensource.com>
2016-07-27 23:16 ` Eric Blake
@ 2016-07-31 9:47 ` Emil Condrea
1 sibling, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-31 9:47 UTC (permalink / raw)
To: Anthony PERARD
Cc: wei.liu2, Stefano Stabellini, stefanb, qemu-devel, xen-devel, Xu,
Quan, Daniel De Graaf, Eric Blake
[-- Attachment #1.1: Type: text/plain, Size: 1129 bytes --]
On Mon, Jul 25, 2016 at 4:53 PM, Anthony PERARD <anthony.perard@citrix.com>
wrote:
> On Sun, Jul 10, 2016 at 02:47:35PM +0300, Emil Condrea wrote:
> > The name of the functions moved:
> > * xen_be_evtchn_event
> > * xen_be_unbind_evtchn
> > * xen_be_send_notify
> >
> > Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> > ---
> > hw/xen/xen_backend.c | 37 +------------------------------------
> > hw/xen/xen_pvdev.c | 35 +++++++++++++++++++++++++++++++++++
> > include/hw/xen/xen_backend.h | 2 --
> > include/hw/xen/xen_pvdev.h | 4 ++++
> > 4 files changed, 40 insertions(+), 38 deletions(-)
> >
> > diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
> > index 0a9f9bb..5f2821a 100644
> > --- a/hw/xen/xen_backend.c
> > +++ b/hw/xen/xen_backend.c
> > @@ -693,4 +658,4 @@ static void xenbe_register_types(void)
> > type_register_static(&xensysdev_info);
> > }
> >
> > -type_init(xenbe_register_types);
> > +type_init(xenbe_register_types);
> > \ No newline at end of file
>
> Looks like this change does not belong to this patch.
>
Will fix this in v10.
>
> --
> Anthony PERARD
>
[-- Attachment #1.2: Type: text/html, Size: 1907 bytes --]
[-- Attachment #2: Type: text/plain, Size: 127 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 05/19] xen: Prepare xendev qtail to be shared with frontends
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (3 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 04/19] xen: Move evtchn functions " Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 06/19] xen: Rename xen_be_printf to xen_pv_printf Emil Condrea
` (18 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
* move xendevs qtail to xen_pvdev.c
* change xen_be_get_xendev to use a new function: xen_pv_insert_xendev
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 70 +---------------------------------------
hw/xen/xen_pvdev.c | 75 +++++++++++++++++++++++++++++++++++++++++++
include/hw/xen/xen_backend.h | 1 -
include/hw/xen/xen_frontend.h | 2 ++
include/hw/xen/xen_pvdev.h | 4 +++
5 files changed, 82 insertions(+), 70 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 5f2821a..2f7f1a6 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -55,7 +55,6 @@ struct xs_dirs {
static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup =
QTAILQ_HEAD_INITIALIZER(xs_cleanup);
-static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs);
static int debug = 0;
static void xenstore_cleanup_dir(char *dir)
@@ -141,27 +140,6 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
return 0;
}
-/* ------------------------------------------------------------- */
-
-struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev)
-{
- struct XenDevice *xendev;
-
- QTAILQ_FOREACH(xendev, &xendevs, next) {
- if (xendev->dom != dom) {
- continue;
- }
- if (xendev->dev != dev) {
- continue;
- }
- if (strcmp(xendev->type, type) != 0) {
- continue;
- }
- return xendev;
- }
- return NULL;
-}
-
/*
* get xen backend device, allocate a new one if it doesn't exist.
*/
@@ -210,7 +188,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
xendev->gnttabdev = NULL;
}
- QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
+ xen_pv_insert_xendev(xendev);
if (xendev->ops->alloc) {
xendev->ops->alloc(xendev);
@@ -219,52 +197,6 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
return xendev;
}
-/*
- * release xen backend device.
- */
-static struct XenDevice *xen_be_del_xendev(int dom, int dev)
-{
- struct XenDevice *xendev, *xnext;
-
- /*
- * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but
- * we save the next pointer in xnext because we might free xendev.
- */
- xnext = xendevs.tqh_first;
- while (xnext) {
- xendev = xnext;
- xnext = xendev->next.tqe_next;
-
- if (xendev->dom != dom) {
- continue;
- }
- if (xendev->dev != dev && dev != -1) {
- continue;
- }
-
- if (xendev->ops->free) {
- xendev->ops->free(xendev);
- }
-
- if (xendev->fe) {
- char token[XEN_BUFSIZE];
- snprintf(token, sizeof(token), "fe:%p", xendev);
- xs_unwatch(xenstore, xendev->fe, token);
- g_free(xendev->fe);
- }
-
- if (xendev->evtchndev != NULL) {
- xenevtchn_close(xendev->evtchndev);
- }
- if (xendev->gnttabdev != NULL) {
- xengnttab_close(xendev->gnttabdev);
- }
-
- QTAILQ_REMOVE(&xendevs, xendev, next);
- g_free(xendev);
- }
- return NULL;
-}
/*
* Sync internal data structures on xenstore updates.
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 7876724..042adeb 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -23,7 +23,9 @@
#include "hw/xen/xen_frontend.h"
#include "hw/xen/xen_pvdev.h"
+/* private */
static int debug = 0;
+static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs);
/* ------------------------------------------------------------- */
int xenstore_write_str(const char *base, const char *node, const char *val)
@@ -206,3 +208,76 @@ int xen_be_send_notify(struct XenDevice *xendev)
{
return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
}
+
+/* ------------------------------------------------------------- */
+
+struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev)
+{
+ struct XenDevice *xendev;
+
+ QTAILQ_FOREACH(xendev, &xendevs, next) {
+ if (xendev->dom != dom) {
+ continue;
+ }
+ if (xendev->dev != dev) {
+ continue;
+ }
+ if (strcmp(xendev->type, type) != 0) {
+ continue;
+ }
+ return xendev;
+ }
+ return NULL;
+}
+
+/*
+ * release xen backend device.
+ */
+struct XenDevice *xen_be_del_xendev(int dom, int dev)
+{
+ struct XenDevice *xendev, *xnext;
+
+ /*
+ * This is pretty much like QTAILQ_FOREACH(xendev, &xendevs, next) but
+ * we save the next pointer in xnext because we might free xendev.
+ */
+ xnext = xendevs.tqh_first;
+ while (xnext) {
+ xendev = xnext;
+ xnext = xendev->next.tqe_next;
+
+ if (xendev->dom != dom) {
+ continue;
+ }
+ if (xendev->dev != dev && dev != -1) {
+ continue;
+ }
+
+ if (xendev->ops->free) {
+ xendev->ops->free(xendev);
+ }
+
+ if (xendev->fe) {
+ char token[XEN_BUFSIZE];
+ snprintf(token, sizeof(token), "fe:%p", xendev);
+ xs_unwatch(xenstore, xendev->fe, token);
+ g_free(xendev->fe);
+ }
+
+ if (xendev->evtchndev != NULL) {
+ xenevtchn_close(xendev->evtchndev);
+ }
+ if (xendev->gnttabdev != NULL) {
+ xengnttab_close(xendev->gnttabdev);
+ }
+
+ QTAILQ_REMOVE(&xendevs, xendev, next);
+ g_free(xendev);
+ }
+ return NULL;
+}
+
+void xen_pv_insert_xendev(struct XenDevice *xendev)
+{
+ QTAILQ_INSERT_TAIL(&xendevs, xendev, next);
+}
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 60b634e..71dd158 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -21,7 +21,6 @@ char *xenstore_read_be_str(struct XenDevice *xendev, const char *node);
int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival);
void xenstore_update_be(char *watch, char *type, int dom, struct XenDevOps *ops);
-struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_check_state(struct XenDevice *xendev);
/* xen backend driver bits */
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
index 7d87da4..ae587e1 100644
--- a/include/hw/xen/xen_frontend.h
+++ b/include/hw/xen/xen_frontend.h
@@ -1,6 +1,8 @@
#ifndef QEMU_HW_XEN_FRONTEND_H
#define QEMU_HW_XEN_FRONTEND_H 1
+#include "hw/xen/xen_pvdev.h"
+
char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node);
int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index f269b04..234e111 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -67,6 +67,10 @@ void xenstore_update(void *unused);
const char *xenbus_strstate(enum xenbus_state state);
void xen_be_evtchn_event(void *opaque);
+void xen_pv_insert_xendev(struct XenDevice *xendev);
+struct XenDevice *xen_be_del_xendev(int dom, int dev);
+struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
+
void xen_be_unbind_evtchn(struct XenDevice *xendev);
int xen_be_send_notify(struct XenDevice *xendev);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 06/19] xen: Rename xen_be_printf to xen_pv_printf
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (4 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 05/19] xen: Prepare xendev qtail to be shared with frontends Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 07/19] xen: Rename xen_be_unbind_evtchn Emil Condrea
` (17 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_printf to be used by both backend and frontends:
* xen_be_printf -> xen_pv_printf
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/block/xen_disk.c | 52 +++++++++++++++++++++++-----------------------
hw/char/xen_console.c | 10 ++++-----
hw/display/xenfb.c | 42 ++++++++++++++++++-------------------
hw/net/xen_nic.c | 22 ++++++++++----------
hw/usb/xen-usb.c | 38 ++++++++++++++++-----------------
hw/xen/xen_backend.c | 44 +++++++++++++++++++--------------------
hw/xen/xen_devconfig.c | 4 ++--
hw/xen/xen_frontend.c | 6 +++---
hw/xen/xen_pvdev.c | 6 +++---
include/hw/xen/xen_pvdev.h | 2 +-
xen-common.c | 4 ++--
11 files changed, 115 insertions(+), 115 deletions(-)
diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c
index 28fbf24..ad3f519 100644
--- a/hw/block/xen_disk.c
+++ b/hw/block/xen_disk.c
@@ -165,12 +165,12 @@ static void destroy_grant(gpointer pgnt)
xengnttab_handle *gnt = grant->blkdev->xendev.gnttabdev;
if (xengnttab_unmap(gnt, grant->page, 1) != 0) {
- xen_be_printf(&grant->blkdev->xendev, 0,
+ xen_pv_printf(&grant->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n",
strerror(errno));
}
grant->blkdev->persistent_gnt_count--;
- xen_be_printf(&grant->blkdev->xendev, 3,
+ xen_pv_printf(&grant->blkdev->xendev, 3,
"unmapped grant %p\n", grant->page);
g_free(grant);
}
@@ -182,11 +182,11 @@ static void remove_persistent_region(gpointer data, gpointer dev)
xengnttab_handle *gnt = blkdev->xendev.gnttabdev;
if (xengnttab_unmap(gnt, region->addr, region->num) != 0) {
- xen_be_printf(&blkdev->xendev, 0,
+ xen_pv_printf(&blkdev->xendev, 0,
"xengnttab_unmap region %p failed: %s\n",
region->addr, strerror(errno));
}
- xen_be_printf(&blkdev->xendev, 3,
+ xen_pv_printf(&blkdev->xendev, 3,
"unmapped grant region %p with %d pages\n",
region->addr, region->num);
g_free(region);
@@ -253,7 +253,7 @@ static int ioreq_parse(struct ioreq *ioreq)
size_t len;
int i;
- xen_be_printf(&blkdev->xendev, 3,
+ xen_pv_printf(&blkdev->xendev, 3,
"op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n",
ioreq->req.operation, ioreq->req.nr_segments,
ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number);
@@ -273,28 +273,28 @@ static int ioreq_parse(struct ioreq *ioreq)
case BLKIF_OP_DISCARD:
return 0;
default:
- xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
+ xen_pv_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n",
ioreq->req.operation);
goto err;
};
if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') {
- xen_be_printf(&blkdev->xendev, 0, "error: write req for ro device\n");
+ xen_pv_printf(&blkdev->xendev, 0, "error: write req for ro device\n");
goto err;
}
ioreq->start = ioreq->req.sector_number * blkdev->file_blk;
for (i = 0; i < ioreq->req.nr_segments; i++) {
if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) {
- xen_be_printf(&blkdev->xendev, 0, "error: nr_segments too big\n");
+ xen_pv_printf(&blkdev->xendev, 0, "error: nr_segments too big\n");
goto err;
}
if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) {
- xen_be_printf(&blkdev->xendev, 0, "error: first > last sector\n");
+ xen_pv_printf(&blkdev->xendev, 0, "error: first > last sector\n");
goto err;
}
if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) {
- xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n");
+ xen_pv_printf(&blkdev->xendev, 0, "error: page crossing\n");
goto err;
}
@@ -306,7 +306,7 @@ static int ioreq_parse(struct ioreq *ioreq)
qemu_iovec_add(&ioreq->v, (void*)mem, len);
}
if (ioreq->start + ioreq->v.size > blkdev->file_size) {
- xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n");
+ xen_pv_printf(&blkdev->xendev, 0, "error: access beyond end of file\n");
goto err;
}
return 0;
@@ -329,7 +329,7 @@ static void ioreq_unmap(struct ioreq *ioreq)
return;
}
if (xengnttab_unmap(gnt, ioreq->pages, ioreq->num_unmap) != 0) {
- xen_be_printf(&ioreq->blkdev->xendev, 0,
+ xen_pv_printf(&ioreq->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n",
strerror(errno));
}
@@ -341,7 +341,7 @@ static void ioreq_unmap(struct ioreq *ioreq)
continue;
}
if (xengnttab_unmap(gnt, ioreq->page[i], 1) != 0) {
- xen_be_printf(&ioreq->blkdev->xendev, 0,
+ xen_pv_printf(&ioreq->blkdev->xendev, 0,
"xengnttab_unmap failed: %s\n",
strerror(errno));
}
@@ -379,7 +379,7 @@ static int ioreq_map(struct ioreq *ioreq)
if (grant != NULL) {
page[i] = grant->page;
- xen_be_printf(&ioreq->blkdev->xendev, 3,
+ xen_pv_printf(&ioreq->blkdev->xendev, 3,
"using persistent-grant %" PRIu32 "\n",
ioreq->refs[i]);
} else {
@@ -408,7 +408,7 @@ static int ioreq_map(struct ioreq *ioreq)
ioreq->pages = xengnttab_map_grant_refs
(gnt, new_maps, domids, refs, ioreq->prot);
if (ioreq->pages == NULL) {
- xen_be_printf(&ioreq->blkdev->xendev, 0,
+ xen_pv_printf(&ioreq->blkdev->xendev, 0,
"can't map %d grant refs (%s, %d maps)\n",
new_maps, strerror(errno), ioreq->blkdev->cnt_map);
return -1;
@@ -424,7 +424,7 @@ static int ioreq_map(struct ioreq *ioreq)
ioreq->page[i] = xengnttab_map_grant_ref
(gnt, domids[i], refs[i], ioreq->prot);
if (ioreq->page[i] == NULL) {
- xen_be_printf(&ioreq->blkdev->xendev, 0,
+ xen_pv_printf(&ioreq->blkdev->xendev, 0,
"can't map grant ref %d (%s, %d maps)\n",
refs[i], strerror(errno), ioreq->blkdev->cnt_map);
ioreq->mapped = 1;
@@ -472,7 +472,7 @@ static int ioreq_map(struct ioreq *ioreq)
grant->page = ioreq->page[new_maps];
}
grant->blkdev = ioreq->blkdev;
- xen_be_printf(&ioreq->blkdev->xendev, 3,
+ xen_pv_printf(&ioreq->blkdev->xendev, 3,
"adding grant %" PRIu32 " page: %p\n",
refs[new_maps], grant->page);
g_tree_insert(ioreq->blkdev->persistent_gnts,
@@ -497,7 +497,7 @@ static void qemu_aio_complete(void *opaque, int ret)
struct ioreq *ioreq = opaque;
if (ret != 0) {
- xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
+ xen_pv_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n",
ioreq->req.operation == BLKIF_OP_READ ? "read" : "write");
ioreq->aio_errors++;
}
@@ -773,7 +773,7 @@ static void blk_alloc(struct XenDevice *xendev)
}
if (xengnttab_set_max_grants(xendev->gnttabdev,
MAX_GRANTS(max_requests, BLKIF_MAX_SEGMENTS_PER_REQUEST)) < 0) {
- xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
+ xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
strerror(errno));
}
}
@@ -919,11 +919,11 @@ static int blk_connect(struct XenDevice *xendev)
}
/* setup via xenbus -> create new block driver instance */
- xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n");
+ xen_pv_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n");
blkdev->blk = blk_new_open(blkdev->filename, NULL, options,
qflags, &local_err);
if (!blkdev->blk) {
- xen_be_printf(&blkdev->xendev, 0, "error: %s\n",
+ xen_pv_printf(&blkdev->xendev, 0, "error: %s\n",
error_get_pretty(local_err));
error_free(local_err);
return -1;
@@ -931,10 +931,10 @@ static int blk_connect(struct XenDevice *xendev)
blk_set_enable_write_cache(blkdev->blk, !writethrough);
} else {
/* setup via qemu cmdline -> already setup for us */
- xen_be_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n");
+ xen_pv_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n");
blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo);
if (blk_is_read_only(blkdev->blk) && !readonly) {
- xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive");
+ xen_pv_printf(&blkdev->xendev, 0, "Unexpected read-only drive");
blkdev->blk = NULL;
return -1;
}
@@ -947,13 +947,13 @@ static int blk_connect(struct XenDevice *xendev)
if (blkdev->file_size < 0) {
BlockDriverState *bs = blk_bs(blkdev->blk);
const char *drv_name = bs ? bdrv_get_format_name(bs) : NULL;
- xen_be_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n",
+ xen_pv_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n",
(int)blkdev->file_size, strerror(-blkdev->file_size),
drv_name ?: "-");
blkdev->file_size = 0;
}
- xen_be_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
+ xen_pv_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\","
" size %" PRId64 " (%" PRId64 " MB)\n",
blkdev->type, blkdev->fileproto, blkdev->filename,
blkdev->file_size, blkdev->file_size >> 20);
@@ -1032,7 +1032,7 @@ static int blk_connect(struct XenDevice *xendev)
xen_be_bind_evtchn(&blkdev->xendev);
- xen_be_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, "
+ xen_pv_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, "
"remote port %d, local port %d\n",
blkdev->xendev.protocol, blkdev->ring_ref,
blkdev->xendev.remote_port, blkdev->xendev.local_port);
diff --git a/hw/char/xen_console.c b/hw/char/xen_console.c
index 83108b0..e6bae67 100644
--- a/hw/char/xen_console.c
+++ b/hw/char/xen_console.c
@@ -156,13 +156,13 @@ static void xencons_send(struct XenConsole *con)
if (len < 1) {
if (!con->backlog) {
con->backlog = 1;
- xen_be_printf(&con->xendev, 1, "backlog piling up, nobody listening?\n");
+ xen_pv_printf(&con->xendev, 1, "backlog piling up, nobody listening?\n");
}
} else {
buffer_advance(&con->buffer, len);
if (con->backlog && len == size) {
con->backlog = 0;
- xen_be_printf(&con->xendev, 1, "backlog is gone\n");
+ xen_pv_printf(&con->xendev, 1, "backlog is gone\n");
}
}
}
@@ -187,7 +187,7 @@ static int con_init(struct XenDevice *xendev)
type = xenstore_read_str(con->console, "type");
if (!type || strcmp(type, "ioemu") != 0) {
- xen_be_printf(xendev, 1, "not for me (type=%s)\n", type);
+ xen_pv_printf(xendev, 1, "not for me (type=%s)\n", type);
ret = -1;
goto out;
}
@@ -240,14 +240,14 @@ static int con_initialise(struct XenDevice *xendev)
qemu_chr_add_handlers(con->chr, xencons_can_receive,
xencons_receive, NULL, con);
} else {
- xen_be_printf(xendev, 0,
+ xen_pv_printf(xendev, 0,
"xen_console_init error chardev %s already used\n",
con->chr->label);
con->chr = NULL;
}
}
- xen_be_printf(xendev, 1, "ring mfn %d, remote port %d, local port %d, limit %zd\n",
+ xen_pv_printf(xendev, 1, "ring mfn %d, remote port %d, local port %d, limit %zd\n",
con->ring_ref,
con->xendev.remote_port,
con->xendev.local_port,
diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
index 5751113..b1e8b3b 100644
--- a/hw/display/xenfb.c
+++ b/hw/display/xenfb.c
@@ -104,7 +104,7 @@ static int common_bind(struct common *c)
return -1;
xen_be_bind_evtchn(&c->xendev);
- xen_be_printf(&c->xendev, 1, "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n",
+ xen_pv_printf(&c->xendev, 1, "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n",
mfn, c->xendev.remote_port, c->xendev.local_port);
return 0;
@@ -346,7 +346,7 @@ static int input_initialise(struct XenDevice *xendev)
int rc;
if (!in->c.con) {
- xen_be_printf(xendev, 1, "ds not set (yet)\n");
+ xen_pv_printf(xendev, 1, "ds not set (yet)\n");
return -1;
}
@@ -511,38 +511,38 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
int max_width, max_height;
if (fb_len_lim > fb_len_max) {
- xen_be_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n",
fb_len_lim, fb_len_max);
fb_len_lim = fb_len_max;
}
if (fb_len_lim && fb_len > fb_len_lim) {
- xen_be_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n",
fb_len, fb_len_lim);
fb_len = fb_len_lim;
}
if (depth != 8 && depth != 16 && depth != 24 && depth != 32) {
- xen_be_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n",
depth);
return -1;
}
if (row_stride <= 0 || row_stride > fb_len) {
- xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride);
+ xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride);
return -1;
}
max_width = row_stride / (depth / 8);
if (width < 0 || width > max_width) {
- xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n",
width, max_width);
width = max_width;
}
if (offset < 0 || offset >= fb_len) {
- xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n",
offset, fb_len - 1);
return -1;
}
max_height = (fb_len - offset) / row_stride;
if (height < 0 || height > max_height) {
- xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n",
height, max_height);
height = max_height;
}
@@ -554,7 +554,7 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
xenfb->offset = offset;
xenfb->up_fullscreen = 1;
xenfb->do_resize = 1;
- xen_be_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n",
+ xen_pv_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n",
width, height, depth, offset, row_stride);
return 0;
}
@@ -632,7 +632,7 @@ static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
}
}
if (oops) /* should not happen */
- xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
+ xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
__FUNCTION__, xenfb->depth, bpp);
dpy_gfx_update(xenfb->c.con, x, y, w, h);
@@ -722,7 +722,7 @@ static void xenfb_update(void *opaque)
break;
}
dpy_gfx_replace_surface(xenfb->c.con, surface);
- xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
+ xen_pv_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
xenfb->width, xenfb->height, xenfb->depth,
is_buffer_shared(surface) ? " (shared)" : "");
xenfb->up_fullscreen = 1;
@@ -730,10 +730,10 @@ static void xenfb_update(void *opaque)
/* run queued updates */
if (xenfb->up_fullscreen) {
- xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
+ xen_pv_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
} else if (xenfb->up_count) {
- xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
+ xen_pv_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
for (i = 0; i < xenfb->up_count; i++)
xenfb_guest_copy(xenfb,
xenfb->up_rects[i].x,
@@ -741,7 +741,7 @@ static void xenfb_update(void *opaque)
xenfb->up_rects[i].w,
xenfb->up_rects[i].h);
} else {
- xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n");
+ xen_pv_printf(&xenfb->c.xendev, 3, "update: nothing\n");
}
xenfb->up_count = 0;
xenfb->up_fullscreen = 0;
@@ -795,14 +795,14 @@ static void xenfb_handle_events(struct XenFB *xenfb)
w = MIN(event->update.width, xenfb->width - x);
h = MIN(event->update.height, xenfb->height - y);
if (w < 0 || h < 0) {
- xen_be_printf(&xenfb->c.xendev, 1, "bogus update ignored\n");
+ xen_pv_printf(&xenfb->c.xendev, 1, "bogus update ignored\n");
break;
}
if (x != event->update.x ||
y != event->update.y ||
w != event->update.width ||
h != event->update.height) {
- xen_be_printf(&xenfb->c.xendev, 1, "bogus update clipped\n");
+ xen_pv_printf(&xenfb->c.xendev, 1, "bogus update clipped\n");
}
if (w == xenfb->width && h > xenfb->height / 2) {
/* scroll detector: updated more than 50% of the lines,
@@ -884,7 +884,7 @@ static int fb_initialise(struct XenDevice *xendev)
if (fb->feature_update)
xenstore_write_be_int(xendev, "request-update", 1);
- xen_be_printf(xendev, 1, "feature-update=%d, videoram=%d\n",
+ xen_pv_printf(xendev, 1, "feature-update=%d, videoram=%d\n",
fb->feature_update, videoram);
return 0;
}
@@ -903,7 +903,7 @@ static void fb_disconnect(struct XenDevice *xendev)
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON,
-1, 0);
if (fb->pixels == MAP_FAILED) {
- xen_be_printf(xendev, 0,
+ xen_pv_printf(xendev, 0,
"Couldn't replace the framebuffer with anonymous memory errno=%d\n",
errno);
}
@@ -924,7 +924,7 @@ static void fb_frontend_changed(struct XenDevice *xendev, const char *node)
if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 &&
xendev->fe_state == XenbusStateConnected &&
xendev->be_state == XenbusStateConnected) {
- xen_be_printf(xendev, 2, "re-trigger connected (frontend bug)\n");
+ xen_pv_printf(xendev, 2, "re-trigger connected (frontend bug)\n");
xen_be_set_state(xendev, XenbusStateConnected);
fb->bug_trigger = 1; /* only once */
}
@@ -985,7 +985,7 @@ wait_more:
usleep(10000);
goto wait_more;
}
- xen_be_printf(NULL, 1, "displaystate setup failed\n");
+ xen_pv_printf(NULL, 1, "displaystate setup failed\n");
return;
}
diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
index bdfa789..91126b5 100644
--- a/hw/net/xen_nic.c
+++ b/hw/net/xen_nic.c
@@ -129,30 +129,30 @@ static void net_tx_packets(struct XenNetDev *netdev)
/* should not happen in theory, we don't announce the *
* feature-{sg,gso,whatelse} flags in xenstore (yet?) */
if (txreq.flags & NETTXF_extra_info) {
- xen_be_printf(&netdev->xendev, 0, "FIXME: extra info flag\n");
+ xen_pv_printf(&netdev->xendev, 0, "FIXME: extra info flag\n");
net_tx_error(netdev, &txreq, rc);
continue;
}
if (txreq.flags & NETTXF_more_data) {
- xen_be_printf(&netdev->xendev, 0, "FIXME: more data flag\n");
+ xen_pv_printf(&netdev->xendev, 0, "FIXME: more data flag\n");
net_tx_error(netdev, &txreq, rc);
continue;
}
#endif
if (txreq.size < 14) {
- xen_be_printf(&netdev->xendev, 0, "bad packet size: %d\n", txreq.size);
+ xen_pv_printf(&netdev->xendev, 0, "bad packet size: %d\n", txreq.size);
net_tx_error(netdev, &txreq, rc);
continue;
}
if ((txreq.offset + txreq.size) > XC_PAGE_SIZE) {
- xen_be_printf(&netdev->xendev, 0, "error: page crossing\n");
+ xen_pv_printf(&netdev->xendev, 0, "error: page crossing\n");
net_tx_error(netdev, &txreq, rc);
continue;
}
- xen_be_printf(&netdev->xendev, 3, "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",
+ xen_pv_printf(&netdev->xendev, 3, "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",
txreq.gref, txreq.offset, txreq.size, txreq.flags,
(txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "",
(txreq.flags & NETTXF_data_validated) ? " data_validated" : "",
@@ -163,7 +163,7 @@ static void net_tx_packets(struct XenNetDev *netdev)
netdev->xendev.dom,
txreq.gref, PROT_READ);
if (page == NULL) {
- xen_be_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n",
+ xen_pv_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n",
txreq.gref);
net_tx_error(netdev, &txreq, rc);
continue;
@@ -212,7 +212,7 @@ static void net_rx_response(struct XenNetDev *netdev,
resp->status = (int16_t)st;
}
- xen_be_printf(&netdev->xendev, 3, "rx response: idx %d, status %d, flags 0x%x\n",
+ xen_pv_printf(&netdev->xendev, 3, "rx response: idx %d, status %d, flags 0x%x\n",
i, resp->status, resp->flags);
netdev->rx_ring.rsp_prod_pvt = ++i;
@@ -243,7 +243,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
return 0;
}
if (size > XC_PAGE_SIZE - NET_IP_ALIGN) {
- xen_be_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
+ xen_pv_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
(unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN);
return -1;
}
@@ -255,7 +255,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
netdev->xendev.dom,
rxreq.gref, PROT_WRITE);
if (page == NULL) {
- xen_be_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n",
+ xen_pv_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n",
rxreq.gref);
net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);
return -1;
@@ -329,7 +329,7 @@ static int net_connect(struct XenDevice *xendev)
rx_copy = 0;
}
if (rx_copy == 0) {
- xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n");
+ xen_pv_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n");
return -1;
}
@@ -354,7 +354,7 @@ static int net_connect(struct XenDevice *xendev)
xen_be_bind_evtchn(&netdev->xendev);
- xen_be_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, "
+ xen_pv_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, "
"remote port %d, local port %d\n",
netdev->tx_ring_ref, netdev->rx_ring_ref,
netdev->xendev.remote_port, netdev->xendev.local_port);
diff --git a/hw/usb/xen-usb.c b/hw/usb/xen-usb.c
index 0fd34c6..bcf5c2e 100644
--- a/hw/usb/xen-usb.c
+++ b/hw/usb/xen-usb.c
@@ -47,7 +47,7 @@
struct timeval tv; \
\
gettimeofday(&tv, NULL); \
- xen_be_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \
+ xen_pv_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \
tv.tv_sec, tv.tv_usec, __func__, ##args); \
}
#define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args)
@@ -151,7 +151,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
}
if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) {
- xen_be_printf(xendev, 0, "bad number of segments in request (%d)\n",
+ xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n",
nr_segs);
return -EINVAL;
}
@@ -159,7 +159,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
for (i = 0; i < nr_segs; i++) {
if ((unsigned)usbback_req->req.seg[i].offset +
(unsigned)usbback_req->req.seg[i].length > PAGE_SIZE) {
- xen_be_printf(xendev, 0, "segment crosses page boundary\n");
+ xen_pv_printf(xendev, 0, "segment crosses page boundary\n");
return -EINVAL;
}
}
@@ -197,7 +197,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req)
*/
if (!usbback_req->nr_extra_segs) {
- xen_be_printf(xendev, 0, "iso request without descriptor segments\n");
+ xen_pv_printf(xendev, 0, "iso request without descriptor segments\n");
return -EINVAL;
}
@@ -548,14 +548,14 @@ static void usbback_dispatch(struct usbback_req *usbback_req)
ret = usbback_init_packet(usbback_req);
if (ret) {
- xen_be_printf(&usbif->xendev, 0, "invalid request\n");
+ xen_pv_printf(&usbif->xendev, 0, "invalid request\n");
ret = -ESHUTDOWN;
goto fail_free_urb;
}
ret = usbback_gnttab_map(usbback_req);
if (ret) {
- xen_be_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret);
+ xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret);
ret = -ESHUTDOWN;
goto fail_free_urb;
}
@@ -643,7 +643,7 @@ static void usbback_bh(void *opaque)
if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) {
rc = urb_ring->rsp_prod_pvt;
- xen_be_printf(&usbif->xendev, 0, "domU provided bogus ring requests "
+ xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests "
"(%#x - %#x = %u). Halting ring processing.\n",
rp, rc, rp - rc);
usbif->ring_error = true;
@@ -716,7 +716,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
portname = strchr(busid, '-');
if (!portname) {
- xen_be_printf(&usbif->xendev, 0, "device %s illegal specification\n",
+ xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n",
busid);
return;
}
@@ -755,7 +755,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
break;
}
if (speed == USBIF_SPEED_NONE) {
- xen_be_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid);
+ xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid);
object_unparent(OBJECT(usbif->ports[port - 1].dev));
usbif->ports[port - 1].dev = NULL;
return;
@@ -772,7 +772,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
err:
QDECREF(qdict);
snprintf(p->path, sizeof(p->path), "%d", 99);
- xen_be_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid);
+ xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid);
}
static void usbback_process_port(struct usbback_info *usbif, unsigned port)
@@ -783,7 +783,7 @@ static void usbback_process_port(struct usbback_info *usbif, unsigned port)
snprintf(node, sizeof(node), "port/%d", port);
busid = xenstore_read_be_str(&usbif->xendev, node);
if (busid == NULL) {
- xen_be_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node);
+ xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node);
return;
}
@@ -844,15 +844,15 @@ static int usbback_connect(struct XenDevice *xendev)
usbif = container_of(xendev, struct usbback_info, xendev);
if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) {
- xen_be_printf(xendev, 0, "error reading urb-ring-ref\n");
+ xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n");
return -1;
}
if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) {
- xen_be_printf(xendev, 0, "error reading conn-ring-ref\n");
+ xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n");
return -1;
}
if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) {
- xen_be_printf(xendev, 0, "error reading event-channel\n");
+ xen_pv_printf(xendev, 0, "error reading event-channel\n");
return -1;
}
@@ -863,7 +863,7 @@ static int usbback_connect(struct XenDevice *xendev)
conn_ring_ref,
PROT_READ | PROT_WRITE);
if (!usbif->urb_sring || !usbif->conn_sring) {
- xen_be_printf(xendev, 0, "error mapping rings\n");
+ xen_pv_printf(xendev, 0, "error mapping rings\n");
usbback_disconnect(xendev);
return -1;
}
@@ -875,7 +875,7 @@ static int usbback_connect(struct XenDevice *xendev)
xen_be_bind_evtchn(xendev);
- xen_be_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, "
+ xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, "
"remote port %d, local port %d\n", urb_ring_ref,
conn_ring_ref, xendev->remote_port, xendev->local_port);
@@ -911,12 +911,12 @@ static int usbback_init(struct XenDevice *xendev)
if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) ||
usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) {
- xen_be_printf(xendev, 0, "num-ports not readable or out of bounds\n");
+ xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n");
return -1;
}
if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) ||
(usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) {
- xen_be_printf(xendev, 0, "usb-ver not readable or out of bounds\n");
+ xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n");
return -1;
}
@@ -998,7 +998,7 @@ static void usbback_alloc(struct XenDevice *xendev)
/* max_grants: for each request and for the rings (request and connect). */
max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2;
if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) {
- xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
+ xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n",
strerror(errno));
}
}
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 2f7f1a6..46e1944 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -87,13 +87,13 @@ int xenstore_mkdir(char *path, int p)
};
if (!xs_mkdir(xenstore, 0, path)) {
- xen_be_printf(NULL, 0, "xs_mkdir %s: failed\n", path);
+ xen_pv_printf(NULL, 0, "xs_mkdir %s: failed\n", path);
return -1;
}
xenstore_cleanup_dir(g_strdup(path));
if (!xs_set_permissions(xenstore, 0, path, perms, 2)) {
- xen_be_printf(NULL, 0, "xs_set_permissions %s: failed\n", path);
+ xen_pv_printf(NULL, 0, "xs_set_permissions %s: failed\n", path);
return -1;
}
return 0;
@@ -134,7 +134,7 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
if (rc < 0) {
return rc;
}
- xen_be_printf(xendev, 1, "backend state: %s -> %s\n",
+ xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
xenbus_strstate(xendev->be_state), xenbus_strstate(state));
xendev->be_state = state;
return 0;
@@ -170,7 +170,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
xendev->evtchndev = xenevtchn_open(NULL, 0);
if (xendev->evtchndev == NULL) {
- xen_be_printf(NULL, 0, "can't open evtchn device\n");
+ xen_pv_printf(NULL, 0, "can't open evtchn device\n");
g_free(xendev);
return NULL;
}
@@ -179,7 +179,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
xendev->gnttabdev = xengnttab_open(NULL, 0);
if (xendev->gnttabdev == NULL) {
- xen_be_printf(NULL, 0, "can't open gnttab device\n");
+ xen_pv_printf(NULL, 0, "can't open gnttab device\n");
xenevtchn_close(xendev->evtchndev);
g_free(xendev);
return NULL;
@@ -212,7 +212,7 @@ static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
}
if (node) {
- xen_be_printf(xendev, 2, "backend update: %s\n", node);
+ xen_pv_printf(xendev, 2, "backend update: %s\n", node);
if (xendev->ops->backend_changed) {
xendev->ops->backend_changed(xendev, node);
}
@@ -236,26 +236,26 @@ static int xen_be_try_setup(struct XenDevice *xendev)
int be_state;
if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
- xen_be_printf(xendev, 0, "reading backend state failed\n");
+ xen_pv_printf(xendev, 0, "reading backend state failed\n");
return -1;
}
if (be_state != XenbusStateInitialising) {
- xen_be_printf(xendev, 0, "initial backend state is wrong (%s)\n",
+ xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
xenbus_strstate(be_state));
return -1;
}
xendev->fe = xenstore_read_be_str(xendev, "frontend");
if (xendev->fe == NULL) {
- xen_be_printf(xendev, 0, "reading frontend path failed\n");
+ xen_pv_printf(xendev, 0, "reading frontend path failed\n");
return -1;
}
/* setup frontend watch */
snprintf(token, sizeof(token), "fe:%p", xendev);
if (!xs_watch(xenstore, xendev->fe, token)) {
- xen_be_printf(xendev, 0, "watching frontend path (%s) failed\n",
+ xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
xendev->fe);
return -1;
}
@@ -279,7 +279,7 @@ static int xen_be_try_init(struct XenDevice *xendev)
int rc = 0;
if (!xendev->online) {
- xen_be_printf(xendev, 1, "not online\n");
+ xen_pv_printf(xendev, 1, "not online\n");
return -1;
}
@@ -287,7 +287,7 @@ static int xen_be_try_init(struct XenDevice *xendev)
rc = xendev->ops->init(xendev);
}
if (rc != 0) {
- xen_be_printf(xendev, 1, "init() failed\n");
+ xen_pv_printf(xendev, 1, "init() failed\n");
return rc;
}
@@ -310,9 +310,9 @@ static int xen_be_try_initialise(struct XenDevice *xendev)
if (xendev->fe_state != XenbusStateInitialised &&
xendev->fe_state != XenbusStateConnected) {
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
- xen_be_printf(xendev, 2, "frontend not ready, ignoring\n");
+ xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
} else {
- xen_be_printf(xendev, 2, "frontend not ready (yet)\n");
+ xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
return -1;
}
}
@@ -321,7 +321,7 @@ static int xen_be_try_initialise(struct XenDevice *xendev)
rc = xendev->ops->initialise(xendev);
}
if (rc != 0) {
- xen_be_printf(xendev, 0, "initialise() failed\n");
+ xen_pv_printf(xendev, 0, "initialise() failed\n");
return rc;
}
@@ -342,9 +342,9 @@ static void xen_be_try_connected(struct XenDevice *xendev)
if (xendev->fe_state != XenbusStateConnected) {
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
- xen_be_printf(xendev, 2, "frontend not ready, ignoring\n");
+ xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
} else {
- xen_be_printf(xendev, 2, "frontend not ready (yet)\n");
+ xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
return;
}
}
@@ -378,7 +378,7 @@ static int xen_be_try_reset(struct XenDevice *xendev)
return -1;
}
- xen_be_printf(xendev, 1, "device reset (for re-connect)\n");
+ xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
xen_be_set_state(xendev, XenbusStateInitialising);
return 0;
}
@@ -439,7 +439,7 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops);
snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
if (!xs_watch(xenstore, path, token)) {
- xen_be_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", path);
+ xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", path);
return -1;
}
@@ -499,7 +499,7 @@ int xen_be_init(void)
{
xenstore = xs_daemon_open();
if (!xenstore) {
- xen_be_printf(NULL, 0, "can't connect to xenstored\n");
+ xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
return -1;
}
@@ -550,10 +550,10 @@ int xen_be_bind_evtchn(struct XenDevice *xendev)
xendev->local_port = xenevtchn_bind_interdomain
(xendev->evtchndev, xendev->dom, xendev->remote_port);
if (xendev->local_port == -1) {
- xen_be_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
+ xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
return -1;
}
- xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
+ xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
xen_be_evtchn_event, NULL, xendev);
return 0;
diff --git a/hw/xen/xen_devconfig.c b/hw/xen/xen_devconfig.c
index b7d290d..a80e78c 100644
--- a/hw/xen/xen_devconfig.c
+++ b/hw/xen/xen_devconfig.c
@@ -55,7 +55,7 @@ int xen_config_dev_blk(DriveInfo *disk)
const char *filename = qemu_opt_get(disk->opts, "file");
snprintf(device_name, sizeof(device_name), "xvd%c", 'a' + disk->unit);
- xen_be_printf(NULL, 1, "config disk %d [%s]: %s\n",
+ xen_pv_printf(NULL, 1, "config disk %d [%s]: %s\n",
disk->unit, device_name, filename);
xen_config_dev_dirs("vbd", "qdisk", vdev, fe, be, sizeof(fe));
@@ -83,7 +83,7 @@ int xen_config_dev_nic(NICInfo *nic)
snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x",
nic->macaddr.a[0], nic->macaddr.a[1], nic->macaddr.a[2],
nic->macaddr.a[3], nic->macaddr.a[4], nic->macaddr.a[5]);
- xen_be_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac);
+ xen_pv_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac);
xen_config_dev_dirs("vif", "qnic", vlan_id, fe, be, sizeof(fe));
/* frontend */
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
index 4e01169..474c74a 100644
--- a/hw/xen/xen_frontend.c
+++ b/hw/xen/xen_frontend.c
@@ -47,7 +47,7 @@ void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
fe_state = XenbusStateUnknown;
}
if (xendev->fe_state != fe_state) {
- xen_be_printf(xendev, 1, "frontend state: %s -> %s\n",
+ xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
xenbus_strstate(xendev->fe_state),
xenbus_strstate(fe_state));
}
@@ -57,12 +57,12 @@ void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
g_free(xendev->protocol);
xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
if (xendev->protocol) {
- xen_be_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol);
+ xen_pv_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol);
}
}
if (node) {
- xen_be_printf(xendev, 2, "frontend update: %s\n", node);
+ xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
if (xendev->ops->frontend_changed) {
xendev->ops->frontend_changed(xendev, node);
}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 042adeb..7375b43 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -142,7 +142,7 @@ const char *xenbus_strstate(enum xenbus_state state)
* 2 == noisy debug messages (logfile only).
* 3 == will flood your log (logfile only).
*/
-void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
+void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
{
va_list args;
@@ -181,7 +181,7 @@ void xen_be_evtchn_event(void *opaque)
port = xenevtchn_pending(xendev->evtchndev);
if (port != xendev->local_port) {
- xen_be_printf(xendev, 0,
+ xen_pv_printf(xendev, 0,
"xenevtchn_pending returned %d (expected %d)\n",
port, xendev->local_port);
return;
@@ -200,7 +200,7 @@ void xen_be_unbind_evtchn(struct XenDevice *xendev)
}
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL);
xenevtchn_unbind(xendev->evtchndev, xendev->local_port);
- xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
+ xen_pv_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port);
xendev->local_port = -1;
}
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index 234e111..3e2dfd8 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -74,7 +74,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_be_unbind_evtchn(struct XenDevice *xendev);
int xen_be_send_notify(struct XenDevice *xendev);
-void xen_be_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
+void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
GCC_FMT_ATTR(3, 4);
#endif /* QEMU_HW_XEN_PVDEV_H */
diff --git a/xen-common.c b/xen-common.c
index e641ad1..9099760 100644
--- a/xen-common.c
+++ b/xen-common.c
@@ -116,12 +116,12 @@ static int xen_init(MachineState *ms)
{
xen_xc = xc_interface_open(0, 0, 0);
if (xen_xc == NULL) {
- xen_be_printf(NULL, 0, "can't open xen interface\n");
+ xen_pv_printf(NULL, 0, "can't open xen interface\n");
return -1;
}
xen_fmem = xenforeignmemory_open(0, 0);
if (xen_fmem == NULL) {
- xen_be_printf(NULL, 0, "can't open xen fmem interface\n");
+ xen_pv_printf(NULL, 0, "can't open xen fmem interface\n");
xc_interface_close(xen_xc);
return -1;
}
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 07/19] xen: Rename xen_be_unbind_evtchn
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (5 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 06/19] xen: Rename xen_be_printf to xen_pv_printf Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-25 13:56 ` Anthony PERARD
2016-07-10 11:47 ` [PATCH 08/19] xen: Rename xen_be_send_notify Emil Condrea
` (16 subsequent siblings)
23 siblings, 1 reply; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_unbind_evtchn to be shared with frontends:
* xen_be_unbind_evtchn -> xen_pv_unbind_evtchn
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/block/xen_disk.c | 2 +-
hw/char/xen_console.c | 2 +-
hw/display/xenfb.c | 2 +-
hw/net/xen_nic.c | 2 +-
hw/xen/xen_pvdev.c | 2 +-
include/hw/xen/xen_pvdev.h | 2 +-
6 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c
index ad3f519..0716ca2 100644
--- a/hw/block/xen_disk.c
+++ b/hw/block/xen_disk.c
@@ -1048,7 +1048,7 @@ static void blk_disconnect(struct XenDevice *xendev)
blk_unref(blkdev->blk);
blkdev->blk = NULL;
}
- xen_be_unbind_evtchn(&blkdev->xendev);
+ xen_pv_unbind_evtchn(&blkdev->xendev);
if (blkdev->sring) {
xengnttab_unmap(blkdev->xendev.gnttabdev, blkdev->sring, 1);
diff --git a/hw/char/xen_console.c b/hw/char/xen_console.c
index e6bae67..889f7b2 100644
--- a/hw/char/xen_console.c
+++ b/hw/char/xen_console.c
@@ -263,7 +263,7 @@ static void con_disconnect(struct XenDevice *xendev)
qemu_chr_add_handlers(con->chr, NULL, NULL, NULL, NULL);
qemu_chr_fe_release(con->chr);
}
- xen_be_unbind_evtchn(&con->xendev);
+ xen_pv_unbind_evtchn(&con->xendev);
if (con->sring) {
if (!xendev->dev) {
diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
index b1e8b3b..250dbc2 100644
--- a/hw/display/xenfb.c
+++ b/hw/display/xenfb.c
@@ -112,7 +112,7 @@ static int common_bind(struct common *c)
static void common_unbind(struct common *c)
{
- xen_be_unbind_evtchn(&c->xendev);
+ xen_pv_unbind_evtchn(&c->xendev);
if (c->page) {
xenforeignmemory_unmap(xen_fmem, c->page, 1);
c->page = NULL;
diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
index 91126b5..1fc6a22 100644
--- a/hw/net/xen_nic.c
+++ b/hw/net/xen_nic.c
@@ -367,7 +367,7 @@ static void net_disconnect(struct XenDevice *xendev)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
- xen_be_unbind_evtchn(&netdev->xendev);
+ xen_pv_unbind_evtchn(&netdev->xendev);
if (netdev->txs) {
xengnttab_unmap(netdev->xendev.gnttabdev, netdev->txs, 1);
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 7375b43..6bf1ae4 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -193,7 +193,7 @@ void xen_be_evtchn_event(void *opaque)
}
}
-void xen_be_unbind_evtchn(struct XenDevice *xendev)
+void xen_pv_unbind_evtchn(struct XenDevice *xendev)
{
if (xendev->local_port == -1) {
return;
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index 3e2dfd8..5c27184 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -71,7 +71,7 @@ void xen_pv_insert_xendev(struct XenDevice *xendev);
struct XenDevice *xen_be_del_xendev(int dom, int dev);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
-void xen_be_unbind_evtchn(struct XenDevice *xendev);
+void xen_pv_unbind_evtchn(struct XenDevice *xendev);
int xen_be_send_notify(struct XenDevice *xendev);
void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [PATCH 07/19] xen: Rename xen_be_unbind_evtchn
2016-07-10 11:47 ` [PATCH 07/19] xen: Rename xen_be_unbind_evtchn Emil Condrea
@ 2016-07-25 13:56 ` Anthony PERARD
0 siblings, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 13:56 UTC (permalink / raw)
To: Emil Condrea
Cc: wei.liu2, stefano.stabellini, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra, eblake
On Sun, Jul 10, 2016 at 02:47:38PM +0300, Emil Condrea wrote:
> Prepare xen_be_unbind_evtchn to be shared with frontends:
> * xen_be_unbind_evtchn -> xen_pv_unbind_evtchn
>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> ---
> hw/block/xen_disk.c | 2 +-
> hw/char/xen_console.c | 2 +-
> hw/display/xenfb.c | 2 +-
> hw/net/xen_nic.c | 2 +-
> hw/xen/xen_pvdev.c | 2 +-
> include/hw/xen/xen_pvdev.h | 2 +-
> 6 files changed, 6 insertions(+), 6 deletions(-)
There is one change missing in hw/usb/xen-usb.c.
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 08/19] xen: Rename xen_be_send_notify
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (6 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 07/19] xen: Rename xen_be_unbind_evtchn Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-25 13:58 ` Anthony PERARD
2016-07-10 11:47 ` [PATCH 09/19] xen: Rename xen_be_evtchn_event Emil Condrea
` (15 subsequent siblings)
23 siblings, 1 reply; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_send_notify to be shared with frontends:
* xen_be_send_notify -> xen_pv_send_notify
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/block/xen_disk.c | 4 ++--
hw/char/xen_console.c | 4 ++--
hw/display/xenfb.c | 8 ++++----
hw/net/xen_nic.c | 4 ++--
hw/xen/xen_pvdev.c | 2 +-
include/hw/xen/xen_pvdev.h | 2 +-
6 files changed, 12 insertions(+), 12 deletions(-)
diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c
index 0716ca2..c36b08b 100644
--- a/hw/block/xen_disk.c
+++ b/hw/block/xen_disk.c
@@ -659,7 +659,7 @@ static void blk_send_response_all(struct XenBlkDev *blkdev)
ioreq_release(ioreq, true);
}
if (send_notify) {
- xen_be_send_notify(&blkdev->xendev);
+ xen_pv_send_notify(&blkdev->xendev);
}
}
@@ -729,7 +729,7 @@ static void blk_handle_requests(struct XenBlkDev *blkdev)
};
if (blk_send_response_one(ioreq)) {
- xen_be_send_notify(&blkdev->xendev);
+ xen_pv_send_notify(&blkdev->xendev);
}
ioreq_release(ioreq, false);
continue;
diff --git a/hw/char/xen_console.c b/hw/char/xen_console.c
index 889f7b2..94e6ab0 100644
--- a/hw/char/xen_console.c
+++ b/hw/char/xen_console.c
@@ -72,7 +72,7 @@ static void buffer_append(struct XenConsole *con)
xen_mb();
intf->out_cons = cons;
- xen_be_send_notify(&con->xendev);
+ xen_pv_send_notify(&con->xendev);
if (buffer->max_capacity &&
buffer->size > buffer->max_capacity) {
@@ -140,7 +140,7 @@ static void xencons_receive(void *opaque, const uint8_t *buf, int len)
}
xen_wmb();
intf->in_prod = prod;
- xen_be_send_notify(&con->xendev);
+ xen_pv_send_notify(&con->xendev);
}
static void xencons_send(struct XenConsole *con)
diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
index 250dbc2..01ae00f 100644
--- a/hw/display/xenfb.c
+++ b/hw/display/xenfb.c
@@ -215,7 +215,7 @@ static int xenfb_kbd_event(struct XenInput *xenfb,
XENKBD_IN_RING_REF(page, prod) = *event;
xen_wmb(); /* ensure ring contents visible */
page->in_prod = prod + 1;
- return xen_be_send_notify(&xenfb->c.xendev);
+ return xen_pv_send_notify(&xenfb->c.xendev);
}
/* Send a keyboard (or mouse button) event */
@@ -397,7 +397,7 @@ static void input_event(struct XenDevice *xendev)
if (page->out_prod == page->out_cons)
return;
page->out_cons = page->out_prod;
- xen_be_send_notify(&xenfb->c.xendev);
+ xen_pv_send_notify(&xenfb->c.xendev);
}
/* -------------------------------------------------------------------- */
@@ -664,7 +664,7 @@ static void xenfb_send_event(struct XenFB *xenfb, union xenfb_in_event *event)
xen_wmb(); /* ensure ring contents visible */
page->in_prod = prod + 1;
- xen_be_send_notify(&xenfb->c.xendev);
+ xen_pv_send_notify(&xenfb->c.xendev);
}
static void xenfb_send_refresh_period(struct XenFB *xenfb, int period)
@@ -935,7 +935,7 @@ static void fb_event(struct XenDevice *xendev)
struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev);
xenfb_handle_events(xenfb);
- xen_be_send_notify(&xenfb->c.xendev);
+ xen_pv_send_notify(&xenfb->c.xendev);
}
/* -------------------------------------------------------------------- */
diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c
index 1fc6a22..f46c745 100644
--- a/hw/net/xen_nic.c
+++ b/hw/net/xen_nic.c
@@ -70,7 +70,7 @@ static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, i
netdev->tx_ring.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->tx_ring, notify);
if (notify) {
- xen_be_send_notify(&netdev->xendev);
+ xen_pv_send_notify(&netdev->xendev);
}
if (i == netdev->tx_ring.req_cons) {
@@ -218,7 +218,7 @@ static void net_rx_response(struct XenNetDev *netdev,
netdev->rx_ring.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->rx_ring, notify);
if (notify) {
- xen_be_send_notify(&netdev->xendev);
+ xen_pv_send_notify(&netdev->xendev);
}
}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 6bf1ae4..3d8b2c2 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -204,7 +204,7 @@ void xen_pv_unbind_evtchn(struct XenDevice *xendev)
xendev->local_port = -1;
}
-int xen_be_send_notify(struct XenDevice *xendev)
+int xen_pv_send_notify(struct XenDevice *xendev)
{
return xenevtchn_notify(xendev->evtchndev, xendev->local_port);
}
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index 5c27184..80e242f 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -72,7 +72,7 @@ struct XenDevice *xen_be_del_xendev(int dom, int dev);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
void xen_pv_unbind_evtchn(struct XenDevice *xendev);
-int xen_be_send_notify(struct XenDevice *xendev);
+int xen_pv_send_notify(struct XenDevice *xendev);
void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...)
GCC_FMT_ATTR(3, 4);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [PATCH 08/19] xen: Rename xen_be_send_notify
2016-07-10 11:47 ` [PATCH 08/19] xen: Rename xen_be_send_notify Emil Condrea
@ 2016-07-25 13:58 ` Anthony PERARD
0 siblings, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 13:58 UTC (permalink / raw)
To: Emil Condrea
Cc: wei.liu2, stefano.stabellini, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra, eblake
On Sun, Jul 10, 2016 at 02:47:39PM +0300, Emil Condrea wrote:
> Prepare xen_be_send_notify to be shared with frontends:
> * xen_be_send_notify -> xen_pv_send_notify
>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> ---
> hw/block/xen_disk.c | 4 ++--
> hw/char/xen_console.c | 4 ++--
> hw/display/xenfb.c | 8 ++++----
> hw/net/xen_nic.c | 4 ++--
> hw/xen/xen_pvdev.c | 2 +-
> include/hw/xen/xen_pvdev.h | 2 +-
> 6 files changed, 12 insertions(+), 12 deletions(-)
hw/usb/xen-usb.c needs to be updated as well.
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 09/19] xen: Rename xen_be_evtchn_event
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (7 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 08/19] xen: Rename xen_be_send_notify Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 10/19] xen: Rename xen_be_find_xendev Emil Condrea
` (14 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_evtchn_event to be shared with frontends:
* xen_be_evtchn_event -> xen_pv_evtchn_event
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 2 +-
hw/xen/xen_pvdev.c | 2 +-
include/hw/xen/xen_pvdev.h | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 46e1944..d6c04c7 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -555,7 +555,7 @@ int xen_be_bind_evtchn(struct XenDevice *xendev)
}
xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
- xen_be_evtchn_event, NULL, xendev);
+ xen_pv_evtchn_event, NULL, xendev);
return 0;
}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 3d8b2c2..5482ab0 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -174,7 +174,7 @@ void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...
qemu_log_flush();
}
-void xen_be_evtchn_event(void *opaque)
+void xen_pv_evtchn_event(void *opaque)
{
struct XenDevice *xendev = opaque;
evtchn_port_t port;
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index 80e242f..a06afb6 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -66,7 +66,7 @@ void xenstore_update(void *unused);
const char *xenbus_strstate(enum xenbus_state state);
-void xen_be_evtchn_event(void *opaque);
+void xen_pv_evtchn_event(void *opaque);
void xen_pv_insert_xendev(struct XenDevice *xendev);
struct XenDevice *xen_be_del_xendev(int dom, int dev);
struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 10/19] xen: Rename xen_be_find_xendev
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (8 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 09/19] xen: Rename xen_be_evtchn_event Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 11/19] xen: Rename xen_be_del_xendev Emil Condrea
` (13 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_find_xendev to be shared with frontends:
* xen_be_find_xendev -> xen_pv_find_xendev
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/display/xenfb.c | 4 ++--
hw/xen/xen_backend.c | 2 +-
hw/xen/xen_pvdev.c | 2 +-
include/hw/xen/xen_pvdev.h | 2 +-
4 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c
index 01ae00f..df13912 100644
--- a/hw/display/xenfb.c
+++ b/hw/display/xenfb.c
@@ -978,8 +978,8 @@ void xen_init_display(int domid)
wait_more:
i++;
main_loop_wait(true);
- xfb = xen_be_find_xendev("vfb", domid, 0);
- xin = xen_be_find_xendev("vkbd", domid, 0);
+ xfb = xen_pv_find_xendev("vfb", domid, 0);
+ xin = xen_pv_find_xendev("vkbd", domid, 0);
if (!xfb || !xin) {
if (i < 256) {
usleep(10000);
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index d6c04c7..51afb1c 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -148,7 +148,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
{
struct XenDevice *xendev;
- xendev = xen_be_find_xendev(type, dom, dev);
+ xendev = xen_pv_find_xendev(type, dom, dev);
if (xendev) {
return xendev;
}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 5482ab0..24266fa 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -211,7 +211,7 @@ int xen_pv_send_notify(struct XenDevice *xendev)
/* ------------------------------------------------------------- */
-struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev)
+struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev)
{
struct XenDevice *xendev;
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index a06afb6..f26d82a 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -69,7 +69,7 @@ const char *xenbus_strstate(enum xenbus_state state);
void xen_pv_evtchn_event(void *opaque);
void xen_pv_insert_xendev(struct XenDevice *xendev);
struct XenDevice *xen_be_del_xendev(int dom, int dev);
-struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev);
+struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev);
void xen_pv_unbind_evtchn(struct XenDevice *xendev);
int xen_pv_send_notify(struct XenDevice *xendev);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 11/19] xen: Rename xen_be_del_xendev
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (9 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 10/19] xen: Rename xen_be_find_xendev Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 12/19] xen: Rename xen_be_frontend_changed Emil Condrea
` (12 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Prepare xen_be_del_xendev to be shared with frontends:
* xen_be_del_xendev -> xen_pv_del_xendev
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 2 +-
hw/xen/xen_pvdev.c | 2 +-
include/hw/xen/xen_pvdev.h | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 51afb1c..9efe4b9 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -484,7 +484,7 @@ void xenstore_update_be(char *watch, char *type, int dom,
if (xendev != NULL) {
bepath = xs_read(xenstore, 0, xendev->be, &len);
if (bepath == NULL) {
- xen_be_del_xendev(dom, dev);
+ xen_pv_del_xendev(dom, dev);
} else {
free(bepath);
xen_be_backend_changed(xendev, path);
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 24266fa..394ddc1 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -233,7 +233,7 @@ struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev)
/*
* release xen backend device.
*/
-struct XenDevice *xen_be_del_xendev(int dom, int dev)
+struct XenDevice *xen_pv_del_xendev(int dom, int dev)
{
struct XenDevice *xendev, *xnext;
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index f26d82a..c19e1df 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -68,7 +68,7 @@ const char *xenbus_strstate(enum xenbus_state state);
void xen_pv_evtchn_event(void *opaque);
void xen_pv_insert_xendev(struct XenDevice *xendev);
-struct XenDevice *xen_be_del_xendev(int dom, int dev);
+struct XenDevice *xen_pv_del_xendev(int dom, int dev);
struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev);
void xen_pv_unbind_evtchn(struct XenDevice *xendev);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 12/19] xen: Rename xen_be_frontend_changed
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (10 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 11/19] xen: Rename xen_be_del_xendev Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 13/19] xen: Distinguish between frontend and backend devops Emil Condrea
` (11 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
xen_be_frontend_changed -> xen_fe_frontend_changed
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
hw/xen/xen_backend.c | 2 +-
hw/xen/xen_frontend.c | 4 ++--
include/hw/xen/xen_frontend.h | 2 +-
3 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index 9efe4b9..d0e3f50 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -262,7 +262,7 @@ static int xen_be_try_setup(struct XenDevice *xendev)
xen_be_set_state(xendev, XenbusStateInitialising);
xen_be_backend_changed(xendev, NULL);
- xen_be_frontend_changed(xendev, NULL);
+ xen_fe_frontend_changed(xendev, NULL);
return 0;
}
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
index 474c74a..6b92cf1 100644
--- a/hw/xen/xen_frontend.c
+++ b/hw/xen/xen_frontend.c
@@ -38,7 +38,7 @@ int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t
return xenstore_read_uint64(xendev->fe, node, uval);
}
-void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
+void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node)
{
int fe_state;
@@ -83,6 +83,6 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev)
}
node = watch + len + 1;
- xen_be_frontend_changed(xendev, node);
+ xen_fe_frontend_changed(xendev, node);
xen_be_check_state(xendev);
}
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
index ae587e1..5d03f4e 100644
--- a/include/hw/xen/xen_frontend.h
+++ b/include/hw/xen/xen_frontend.h
@@ -8,6 +8,6 @@ int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
void xenstore_update_fe(char *watch, struct XenDevice *xendev);
-void xen_be_frontend_changed(struct XenDevice *xendev, const char *node);
+void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node);
#endif /* QEMU_HW_XEN_FRONTEND_H */
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 13/19] xen: Distinguish between frontend and backend devops
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (11 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 12/19] xen: Rename xen_be_frontend_changed Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 14/19] Qemu-Xen-vTPM: Support for Xen stubdom vTPM command line options Emil Condrea
` (10 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
xen_be_check_state should not be called for frontends
Use DEVOPS_FLAG_FE flag to distinguish a frontend.
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Signed-off-by: Quan Xu <quan.xu@intel.com>
---
Changes in v9:
* Removed not needed strstr from xenstore_update_be
It was left over from first patch series when domu was included in xenstore
schema: "%s/backend/%s/%d/%d"
---
hw/xen/xen_backend.c | 4 +++-
include/hw/xen/xen_pvdev.h | 2 ++
2 files changed, 5 insertions(+), 1 deletion(-)
diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c
index d0e3f50..3931128 100644
--- a/hw/xen/xen_backend.c
+++ b/hw/xen/xen_backend.c
@@ -488,7 +488,9 @@ void xenstore_update_be(char *watch, char *type, int dom,
} else {
free(bepath);
xen_be_backend_changed(xendev, path);
- xen_be_check_state(xendev);
+ if (!(ops->flags & DEVOPS_FLAG_FE)) {
+ xen_be_check_state(xendev);
+ }
}
}
}
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index c19e1df..c985a9d 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -14,6 +14,8 @@ struct XenDevice;
#define DEVOPS_FLAG_NEED_GNTDEV 1
/* don't expect frontend doing correct state transitions (aka console quirk) */
#define DEVOPS_FLAG_IGNORE_STATE 2
+/*dev is frontend device*/
+#define DEVOPS_FLAG_FE 4
struct XenDevOps {
size_t size;
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 14/19] Qemu-Xen-vTPM: Support for Xen stubdom vTPM command line options
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (12 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 13/19] xen: Distinguish between frontend and backend devops Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure Emil Condrea
` (9 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
Changes in v9:
* Replace `type` with `struct` as required by 895a2a80e
* Change `qpm_query_tpm_inst` as required by ce21131a0
---
configure | 14 ++++++++++++++
hmp.c | 2 ++
qapi-schema.json | 16 ++++++++++++++--
qemu-options.hx | 13 +++++++++++--
tpm.c | 7 ++++++-
5 files changed, 47 insertions(+), 5 deletions(-)
diff --git a/configure b/configure
index e9090a0..29e982e 100755
--- a/configure
+++ b/configure
@@ -3242,6 +3242,16 @@ else
fi
##########################################
+# TPM xenstubdoms is only on x86 Linux
+
+if test "$targetos" = Linux && test "$cpu" = i386 -o "$cpu" = x86_64 && \
+ test "$xen" = "yes"; then
+ tpm_xenstubdoms=$tpm
+else
+ tpm_xenstubdoms=no
+fi
+
+##########################################
# attr probe
if test "$attr" != "no" ; then
@@ -4891,6 +4901,7 @@ echo "gcov $gcov_tool"
echo "gcov enabled $gcov"
echo "TPM support $tpm"
echo "libssh2 support $libssh2"
+echo "TPM xenstubdoms $tpm_xenstubdoms"
echo "TPM passthrough $tpm_passthrough"
echo "QOM debugging $qom_cast_debug"
echo "vhdx $vhdx"
@@ -5431,6 +5442,9 @@ if test "$tpm" = "yes"; then
if test "$tpm_passthrough" = "yes"; then
echo "CONFIG_TPM_PASSTHROUGH=y" >> $config_host_mak
fi
+ if test "$tpm_xenstubdoms" = "yes"; then
+ echo "CONFIG_TPM_XENSTUBDOMS=y" >> $config_host_mak
+ fi
fi
echo "TRACE_BACKENDS=$trace_backends" >> $config_host_mak
diff --git a/hmp.c b/hmp.c
index 0cf5baa..1ed7a28 100644
--- a/hmp.c
+++ b/hmp.c
@@ -883,6 +883,8 @@ void hmp_info_tpm(Monitor *mon, const QDict *qdict)
tpo->has_cancel_path ? ",cancel-path=" : "",
tpo->has_cancel_path ? tpo->cancel_path : "");
break;
+ case TPM_TYPE_OPTIONS_KIND_XENSTUBDOMS:
+ break;
case TPM_TYPE_OPTIONS_KIND__MAX:
break;
}
diff --git a/qapi-schema.json b/qapi-schema.json
index d2d6506..12efb23 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -3502,9 +3502,11 @@
#
# @passthrough: TPM passthrough type
#
+# @xenstubdoms: TPM xenstubdoms type (since 2.7)
+#
# Since: 1.5
##
-{ 'enum': 'TpmType', 'data': [ 'passthrough' ] }
+{ 'enum': 'TpmType', 'data': [ 'passthrough', 'xenstubdoms' ] }
##
# @query-tpm-types:
@@ -3533,6 +3535,15 @@
'*cancel-path' : 'str'} }
##
+# @TPMXenstubdomsOptions:
+#
+# Information about the TPM xenstubdoms type
+#
+# Since: 2.7
+##
+{ 'struct': 'TPMXenstubdomsOptions', 'data': { } }
+
+##
# @TpmTypeOptions:
#
# A union referencing different TPM backend types' configuration options
@@ -3542,7 +3553,8 @@
# Since: 1.5
##
{ 'union': 'TpmTypeOptions',
- 'data': { 'passthrough' : 'TPMPassthroughOptions' } }
+ 'data': { 'passthrough' : 'TPMPassthroughOptions',
+ 'xenstubdoms' : 'TPMXenstubdomsOptions' } }
##
# @TpmInfo:
diff --git a/qemu-options.hx b/qemu-options.hx
index 8e0d9a5..748fb62 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -2748,7 +2748,8 @@ DEF("tpmdev", HAS_ARG, QEMU_OPTION_tpmdev, \
"-tpmdev passthrough,id=id[,path=path][,cancel-path=path]\n"
" use path to provide path to a character device; default is /dev/tpm0\n"
" use cancel-path to provide path to TPM's cancel sysfs entry; if\n"
- " not provided it will be searched for in /sys/class/misc/tpm?/device\n",
+ " not provided it will be searched for in /sys/class/misc/tpm?/device\n"
+ "-tpmdev xenstubdoms,id=id\n",
QEMU_ARCH_ALL)
STEXI
@@ -2758,7 +2759,8 @@ The general form of a TPM device option is:
@item -tpmdev @var{backend} ,id=@var{id} [,@var{options}]
@findex -tpmdev
Backend type must be:
-@option{passthrough}.
+@option{passthrough}, or
+@option{xenstubdoms}.
The specific backend type will determine the applicable options.
The @code{-tpmdev} option creates the TPM backend and requires a
@@ -2808,6 +2810,13 @@ To create a passthrough TPM use the following two options:
Note that the @code{-tpmdev} id is @code{tpm0} and is referenced by
@code{tpmdev=tpm0} in the device option.
+To create a xenstubdoms TPM use the following two options:
+@example
+-tpmdev xenstubdoms,id=tpm0 -device tpm-tis,tpmdev=tpm0
+@end example
+Note that the @code{-tpmdev} id is @code{tpm0} and is referenced by
+@code{tpmdev=tpm0} in the device option.
+
@end table
ETEXI
diff --git a/tpm.c b/tpm.c
index 9a7c711..df1b9b0 100644
--- a/tpm.c
+++ b/tpm.c
@@ -25,7 +25,7 @@ static QLIST_HEAD(, TPMBackend) tpm_backends =
#define TPM_MAX_MODELS 1
-#define TPM_MAX_DRIVERS 1
+#define TPM_MAX_DRIVERS 2
static TPMDriverOps const *be_drivers[TPM_MAX_DRIVERS] = {
NULL,
@@ -253,6 +253,7 @@ static TPMInfo *qmp_query_tpm_inst(TPMBackend *drv)
{
TPMInfo *res = g_new0(TPMInfo, 1);
TPMPassthroughOptions *tpo;
+ TPMXenstubdomsOptions *txo;
res->id = g_strdup(drv->id);
res->model = drv->fe_model;
@@ -272,6 +273,10 @@ static TPMInfo *qmp_query_tpm_inst(TPMBackend *drv)
tpo->has_cancel_path = true;
}
break;
+ case TPM_TYPE_XENSTUBDOMS:
+ res->options->type = TPM_TYPE_OPTIONS_KIND_XENSTUBDOMS;
+ txo = g_new0(TPMXenstubdomsOptions, 1);
+ res->options->u.xenstubdoms.data = txo;
case TPM_TYPE__MAX:
break;
}
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (13 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 14/19] Qemu-Xen-vTPM: Support for Xen stubdom vTPM command line options Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-25 16:01 ` Anthony PERARD
2016-07-10 11:47 ` [PATCH 16/19] Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver Emil Condrea
` (8 subsequent siblings)
23 siblings, 1 reply; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
This patch adds infrastructure for xen front drivers living in qemu,
so drivers don't need to implement common stuff on their own. It's
mostly xenbus management stuff: some functions to access XenStore,
setting up XenStore watches, callbacks on device discovery and state
changes, and handle event channel between the virtual machines.
Call xen_fe_register() function to register XenDevOps, and make sure,
XenDevOps's flags is DEVOPS_FLAG_FE, which is flag bit to point out
the XenDevOps is Xen frontend.
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
---
Changes in v9:
* xenstore_dev should not be global, it will not work correctly with
multiple xen frontends living in qemu
* reuse some common functions:
- xen_fe_printf -> xen_pv_printf
- xen_fe_evtchn_event -> xen_pv_evtchn_event
* use libxenevtchn stable API instead of xc_* calls:
- xc_evtchn_fd -> xenevtchn_fd
- xc_evtchn_close -> xenevtchn_close
- xc_evtchn_bind_unbound_port -> xenevtchn_bind_unbound_port
---
hw/xen/xen_frontend.c | 308 ++++++++++++++++++++++++++++++++++++++++++
hw/xen/xen_pvdev.c | 15 ++
include/hw/xen/xen_frontend.h | 6 +
include/hw/xen/xen_pvdev.h | 1 +
4 files changed, 330 insertions(+)
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
index 6b92cf1..7b305ce 100644
--- a/hw/xen/xen_frontend.c
+++ b/hw/xen/xen_frontend.c
@@ -3,6 +3,10 @@
*
* (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
*
+ * Copyright (c) 2015 Intel Corporation
+ * Authors:
+ * Quan Xu <quan.xu@intel.com>
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
@@ -23,6 +27,8 @@
#include "hw/xen/xen_frontend.h"
#include "hw/xen/xen_backend.h"
+static int debug = 0;
+
char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
{
return xenstore_read_str(xendev->fe, node);
@@ -86,3 +92,305 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev)
xen_fe_frontend_changed(xendev, node);
xen_be_check_state(xendev);
}
+
+struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev,
+ char *backend, struct XenDevOps *ops)
+{
+ struct XenDevice *xendev;
+
+ xendev = xen_pv_find_xendev(type, dom, dev);
+ if (xendev) {
+ return xendev;
+ }
+
+ /* init new xendev */
+ xendev = g_malloc0(ops->size);
+ xendev->type = type;
+ xendev->dom = dom;
+ xendev->dev = dev;
+ xendev->ops = ops;
+
+ /*return if the ops->flags is not DEVOPS_FLAG_FE*/
+ if (!(ops->flags & DEVOPS_FLAG_FE)) {
+ return NULL;
+ }
+
+ snprintf(xendev->be, sizeof(xendev->be), "%s", backend);
+ snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
+ xendev->type, xendev->dev);
+
+ xendev->debug = debug;
+ xendev->local_port = -1;
+
+ xendev->evtchndev = xenevtchn_open(NULL, 0);
+ if (xendev->evtchndev == NULL) {
+ xen_pv_printf(NULL, 0, "can't open evtchn device\n");
+ g_free(xendev);
+ return NULL;
+ }
+ fcntl(xenevtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC);
+
+ if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
+ xendev->gnttabdev = xengnttab_open(NULL, 0);
+ if (xendev->gnttabdev == NULL) {
+ xen_pv_printf(NULL, 0, "can't open gnttab device\n");
+ xenevtchn_close(xendev->evtchndev);
+ g_free(xendev);
+ return NULL;
+ }
+ } else {
+ xendev->gnttabdev = NULL;
+ }
+
+ xen_pv_insert_xendev(xendev);
+
+ if (xendev->ops->alloc) {
+ xendev->ops->alloc(xendev);
+ }
+
+ return xendev;
+}
+
+int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom){
+ xendev->local_port = xenevtchn_bind_unbound_port(xendev->evtchndev,
+ remote_dom);
+ if (xendev->local_port == -1) {
+ xen_pv_printf(xendev, 0, "xenevtchn_bind_unbound_port failed\n");
+ return -1;
+ }
+ xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
+ qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
+ xen_pv_evtchn_event, NULL, xendev);
+ return 0;
+}
+
+/*
+ * Make sure, initialize the 'xendev->fe' in xendev->ops->init() or
+ * xendev->ops->initialize()
+ */
+int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus)
+{
+ xs_transaction_t xbt = XBT_NULL;
+
+ if (xendev->fe_state == xbus) {
+ return 0;
+ }
+
+ xendev->fe_state = xbus;
+ if (xendev->fe == NULL) {
+ xen_pv_printf(NULL, 0, "xendev->fe is NULL\n");
+ return -1;
+ }
+
+retry_transaction:
+ xbt = xs_transaction_start(xenstore);
+ if (xbt == XBT_NULL) {
+ goto abort_transaction;
+ }
+
+ if (xenstore_write_int(xendev->fe, "state", xbus)) {
+ goto abort_transaction;
+ }
+
+ if (!xs_transaction_end(xenstore, xbt, 0)) {
+ if (errno == EAGAIN) {
+ goto retry_transaction;
+ }
+ }
+
+ return 0;
+
+abort_transaction:
+ xs_transaction_end(xenstore, xbt, 1);
+ return -1;
+}
+
+/*
+ * Simplify QEMU side, a thread is running in Xen backend, which will
+ * connect frontend when the frontend is initialised. Call these initialised
+ * functions.
+ */
+static int xen_fe_try_init(void *opaque)
+{
+ struct XenDevOps *ops = opaque;
+ int rc = -1;
+
+ if (ops->init) {
+ rc = ops->init(NULL);
+ }
+
+ return rc;
+}
+
+static int xen_fe_try_initialise(struct XenDevice *xendev)
+{
+ int rc = 0, fe_state;
+
+ if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
+ fe_state = XenbusStateUnknown;
+ }
+ xendev->fe_state = fe_state;
+
+ if (xendev->ops->initialise) {
+ rc = xendev->ops->initialise(xendev);
+ }
+ if (rc != 0) {
+ xen_pv_printf(xendev, 0, "initialise() failed\n");
+ return rc;
+ }
+
+ xenbus_switch_state(xendev, XenbusStateInitialised);
+ return 0;
+}
+
+static void xen_fe_try_connected(struct XenDevice *xendev)
+{
+ if (!xendev->ops->connected) {
+ return;
+ }
+
+ if (xendev->fe_state != XenbusStateConnected) {
+ if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
+ xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
+ } else {
+ xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
+ return;
+ }
+ }
+
+ xendev->ops->connected(xendev);
+}
+
+static int xen_fe_check(struct XenDevice *xendev, uint32_t domid,
+ int handle)
+{
+ int rc = 0;
+
+ rc = xen_fe_try_initialise(xendev);
+ if (rc != 0) {
+ xen_pv_printf(xendev, 0, "xendev %s initialise error\n",
+ xendev->name);
+ goto err;
+ }
+ xen_fe_try_connected(xendev);
+
+ return rc;
+
+err:
+ xen_pv_del_xendev(domid, handle);
+ return -1;
+}
+
+static char *xenstore_fe_get_backend(const char *type, int be_domid,
+ uint32_t domid, int *hdl)
+{
+ char *name, *str, *ret = NULL;
+ uint32_t i, cdev;
+ int handle = 0;
+ char path[XEN_BUFSIZE];
+ char **dev = NULL;
+
+ name = xenstore_get_domain_name(domid);
+ snprintf(path, sizeof(path), "frontend/%s/%d", type, be_domid);
+ dev = xs_directory(xenstore, 0, path, &cdev);
+ for (i = 0; i < cdev; i++) {
+ handle = i;
+ snprintf(path, sizeof(path), "frontend/%s/%d/%d",
+ type, be_domid, handle);
+ str = xenstore_read_str(path, "domain");
+ if (!strcmp(name, str)) {
+ break;
+ }
+
+ free(str);
+
+ /* Not the backend domain */
+ if (handle == (cdev - 1)) {
+ goto err;
+ }
+ }
+
+ snprintf(path, sizeof(path), "frontend/%s/%d/%d",
+ type, be_domid, handle);
+ str = xenstore_read_str(path, "backend");
+ if (str != NULL) {
+ ret = g_strdup(str);
+ free(str);
+ }
+
+ *hdl = handle;
+ free(dev);
+
+ return ret;
+err:
+ *hdl = -1;
+ free(dev);
+ return NULL;
+}
+
+static int xenstore_fe_scan(const char *type, uint32_t domid,
+ struct XenDevOps *ops)
+{
+ struct XenDevice *xendev;
+ char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
+ unsigned int cdev, j;
+ char *backend;
+ char **dev = NULL;
+ int rc;
+ int xenstore_dev;
+
+ /* ops .init check, xendev is NOT initialized */
+ rc = xen_fe_try_init(ops);
+ if (rc != 0) {
+ return -1;
+ }
+
+ /* Get /local/domain/0/${type}/{} directory */
+ snprintf(path, sizeof(path), "frontend/%s", type);
+ dev = xs_directory(xenstore, 0, path, &cdev);
+ if (dev == NULL) {
+ return 0;
+ }
+
+ for (j = 0; j < cdev; j++) {
+
+ /* Get backend via domain name */
+ backend = xenstore_fe_get_backend(type, atoi(dev[j]),
+ domid, &xenstore_dev);
+ if (backend == NULL) {
+ continue;
+ }
+
+ xendev = xen_fe_get_xendev(type, domid, xenstore_dev, backend, ops);
+ free(backend);
+ if (xendev == NULL) {
+ xen_pv_printf(xendev, 0, "xendev is NULL.\n");
+ continue;
+ }
+
+ /*
+ * Simplify QEMU side, a thread is running in Xen backend, which will
+ * connect frontend when the frontend is initialised.
+ */
+ if (xen_fe_check(xendev, domid, xenstore_dev) < 0) {
+ xen_pv_printf(xendev, 0, "xendev fe_check error.\n");
+ continue;
+ }
+
+ /* Setup watch */
+ snprintf(token, sizeof(token), "be:%p:%d:%p",
+ type, domid, xendev->ops);
+ if (!xs_watch(xenstore, xendev->be, token)) {
+ xen_pv_printf(xendev, 0, "xs_watch failed.\n");
+ continue;
+ }
+ }
+
+ free(dev);
+ return 0;
+}
+
+int xen_fe_register(const char *type, struct XenDevOps *ops)
+{
+ return xenstore_fe_scan(type, xen_domid, ops);
+}
diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c
index 394ddc1..cb51e87 100644
--- a/hw/xen/xen_pvdev.c
+++ b/hw/xen/xen_pvdev.c
@@ -121,6 +121,21 @@ cleanup:
free(vec);
}
+char *xenstore_get_domain_name(uint32_t domid)
+{
+ char *dom_path, *str, *ret = NULL;
+
+ dom_path = xs_get_domain_path(xenstore, domid);
+ str = xenstore_read_str(dom_path, "name");
+ free(dom_path);
+ if (str != NULL) {
+ ret = g_strdup(str);
+ free(str);
+ }
+
+ return ret;
+}
+
const char *xenbus_strstate(enum xenbus_state state)
{
static const char *const name[] = {
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
index 5d03f4e..8fc0422 100644
--- a/include/hw/xen/xen_frontend.h
+++ b/include/hw/xen/xen_frontend.h
@@ -8,6 +8,12 @@ int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival);
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, uint64_t *uval);
void xenstore_update_fe(char *watch, struct XenDevice *xendev);
+struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev,
+ char *backend, struct XenDevOps *ops);
void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node);
+int xen_fe_register(const char *type, struct XenDevOps *ops);
+int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom);
+int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus);
+
#endif /* QEMU_HW_XEN_FRONTEND_H */
diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
index c985a9d..11bab56 100644
--- a/include/hw/xen/xen_pvdev.h
+++ b/include/hw/xen/xen_pvdev.h
@@ -65,6 +65,7 @@ char *xenstore_read_str(const char *base, const char *node);
int xenstore_read_int(const char *base, const char *node, int *ival);
int xenstore_read_uint64(const char *base, const char *node, uint64_t *uval);
void xenstore_update(void *unused);
+char *xenstore_get_domain_name(uint32_t domid);
const char *xenbus_strstate(enum xenbus_state state);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure
2016-07-10 11:47 ` [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure Emil Condrea
@ 2016-07-25 16:01 ` Anthony PERARD
2016-08-07 11:39 ` Emil Condrea
[not found] ` <CAAULxKKk-UiLFPWn8GH4oDEqQEAowBSgdUHCPGvfX_Ubr_rztg@mail.gmail.com>
0 siblings, 2 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 16:01 UTC (permalink / raw)
To: Emil Condrea
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra, eblake
On Sun, Jul 10, 2016 at 02:47:46PM +0300, Emil Condrea wrote:
> This patch adds infrastructure for xen front drivers living in qemu,
> so drivers don't need to implement common stuff on their own. It's
> mostly xenbus management stuff: some functions to access XenStore,
> setting up XenStore watches, callbacks on device discovery and state
> changes, and handle event channel between the virtual machines.
>
> Call xen_fe_register() function to register XenDevOps, and make sure,
> XenDevOps's flags is DEVOPS_FLAG_FE, which is flag bit to point out
> the XenDevOps is Xen frontend.
>
> Signed-off-by: Quan Xu <quan.xu@intel.com>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
>
> ---
> Changes in v9:
> * xenstore_dev should not be global, it will not work correctly with
> multiple xen frontends living in qemu
> * reuse some common functions:
> - xen_fe_printf -> xen_pv_printf
> - xen_fe_evtchn_event -> xen_pv_evtchn_event
> * use libxenevtchn stable API instead of xc_* calls:
> - xc_evtchn_fd -> xenevtchn_fd
> - xc_evtchn_close -> xenevtchn_close
> - xc_evtchn_bind_unbound_port -> xenevtchn_bind_unbound_port
> ---
> hw/xen/xen_frontend.c | 308 ++++++++++++++++++++++++++++++++++++++++++
> hw/xen/xen_pvdev.c | 15 ++
> include/hw/xen/xen_frontend.h | 6 +
> include/hw/xen/xen_pvdev.h | 1 +
> 4 files changed, 330 insertions(+)
>
> diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
> index 6b92cf1..7b305ce 100644
> --- a/hw/xen/xen_frontend.c
> +++ b/hw/xen/xen_frontend.c
> @@ -3,6 +3,10 @@
> *
> * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
> *
> + * Copyright (c) 2015 Intel Corporation
> + * Authors:
> + * Quan Xu <quan.xu@intel.com>
> + *
> * This library is free software; you can redistribute it and/or
> * modify it under the terms of the GNU Lesser General Public
> * License as published by the Free Software Foundation; either
> @@ -23,6 +27,8 @@
> #include "hw/xen/xen_frontend.h"
> #include "hw/xen/xen_backend.h"
>
> +static int debug = 0;
> +
> char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
> {
> return xenstore_read_str(xendev->fe, node);
> @@ -86,3 +92,305 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev)
> xen_fe_frontend_changed(xendev, node);
> xen_be_check_state(xendev);
> }
> +
> +struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev,
> + char *backend, struct XenDevOps *ops)
This function looks similare to xen_be_get_xendev(), could they be
shared?
In any case, there is a few issue with this implementation.
> +{
> + struct XenDevice *xendev;
> +
> + xendev = xen_pv_find_xendev(type, dom, dev);
> + if (xendev) {
> + return xendev;
> + }
> +
> + /* init new xendev */
> + xendev = g_malloc0(ops->size);
> + xendev->type = type;
> + xendev->dom = dom;
> + xendev->dev = dev;
> + xendev->ops = ops;
> +
> + /*return if the ops->flags is not DEVOPS_FLAG_FE*/
> + if (!(ops->flags & DEVOPS_FLAG_FE)) {
Here, xendev is leaked.
> + return NULL;
> + }
> +
> + snprintf(xendev->be, sizeof(xendev->be), "%s", backend);
> + snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
> + xendev->type, xendev->dev);
> +
> + xendev->debug = debug;
> + xendev->local_port = -1;
> +
> + xendev->evtchndev = xenevtchn_open(NULL, 0);
> + if (xendev->evtchndev == NULL) {
> + xen_pv_printf(NULL, 0, "can't open evtchn device\n");
> + g_free(xendev);
We could use goto here, so there would be only one cleanup path.
> + return NULL;
> + }
> + fcntl(xenevtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC);
> +
> + if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
> + xendev->gnttabdev = xengnttab_open(NULL, 0);
> + if (xendev->gnttabdev == NULL) {
> + xen_pv_printf(NULL, 0, "can't open gnttab device\n");
> + xenevtchn_close(xendev->evtchndev);
> + g_free(xendev);
goto, same as before.
> + return NULL;
> + }
> + } else {
> + xendev->gnttabdev = NULL;
> + }
> +
> + xen_pv_insert_xendev(xendev);
> +
> + if (xendev->ops->alloc) {
> + xendev->ops->alloc(xendev);
> + }
> +
> + return xendev;
> +}
> +
> +int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom){
'{' should be on a new line.
> + xendev->local_port = xenevtchn_bind_unbound_port(xendev->evtchndev,
> + remote_dom);
> + if (xendev->local_port == -1) {
> + xen_pv_printf(xendev, 0, "xenevtchn_bind_unbound_port failed\n");
> + return -1;
> + }
> + xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
> + qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
> + xen_pv_evtchn_event, NULL, xendev);
> + return 0;
> +}
> +
> +/*
> + * Make sure, initialize the 'xendev->fe' in xendev->ops->init() or
> + * xendev->ops->initialize()
> + */
> +int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus)
There is a function that do a similar job for backends,
xen_be_set_state(). I think we could rename this function
xen_fe_set_state. Also "xbus" is a confusing name, "state" would be
fine.
> +{
> + xs_transaction_t xbt = XBT_NULL;
> +
> + if (xendev->fe_state == xbus) {
> + return 0;
> + }
> +
> + xendev->fe_state = xbus;
> + if (xendev->fe == NULL) {
> + xen_pv_printf(NULL, 0, "xendev->fe is NULL\n");
> + return -1;
> + }
> +
> +retry_transaction:
> + xbt = xs_transaction_start(xenstore);
> + if (xbt == XBT_NULL) {
> + goto abort_transaction;
> + }
There is a transaction started, but I don't think it is used by the
function below. Could you remove the transaction?
> + if (xenstore_write_int(xendev->fe, "state", xbus)) {
> + goto abort_transaction;
> + }
> +
> + if (!xs_transaction_end(xenstore, xbt, 0)) {
> + if (errno == EAGAIN) {
> + goto retry_transaction;
> + }
> + }
> +
> + return 0;
> +
> +abort_transaction:
> + xs_transaction_end(xenstore, xbt, 1);
> + return -1;
> +}
> +
> +/*
> + * Simplify QEMU side, a thread is running in Xen backend, which will
> + * connect frontend when the frontend is initialised. Call these initialised
> + * functions.
> + */
This comment does not make much sense to me.
> +static int xen_fe_try_init(void *opaque)
> +{
> + struct XenDevOps *ops = opaque;
> + int rc = -1;
> +
> + if (ops->init) {
> + rc = ops->init(NULL);
> + }
> +
> + return rc;
> +}
> +
> +static int xen_fe_try_initialise(struct XenDevice *xendev)
> +{
> + int rc = 0, fe_state;
> +
> + if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
> + fe_state = XenbusStateUnknown;
> + }
> + xendev->fe_state = fe_state;
> +
> + if (xendev->ops->initialise) {
> + rc = xendev->ops->initialise(xendev);
> + }
> + if (rc != 0) {
> + xen_pv_printf(xendev, 0, "initialise() failed\n");
> + return rc;
> + }
> +
> + xenbus_switch_state(xendev, XenbusStateInitialised);
> + return 0;
> +}
> +
> +static void xen_fe_try_connected(struct XenDevice *xendev)
This function looks exactly the same as xen_be_try_connected, should not
it be different and check the status of the backend?
> +{
> + if (!xendev->ops->connected) {
> + return;
> + }
> +
> + if (xendev->fe_state != XenbusStateConnected) {
> + if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
> + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
> + } else {
> + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
> + return;
> + }
> + }
> +
> + xendev->ops->connected(xendev);
> +}
> +
> +static int xen_fe_check(struct XenDevice *xendev, uint32_t domid,
> + int handle)
What is this function checking? The name of the function is not very
helpfull.
> +{
> + int rc = 0;
> +
> + rc = xen_fe_try_initialise(xendev);
> + if (rc != 0) {
> + xen_pv_printf(xendev, 0, "xendev %s initialise error\n",
> + xendev->name);
> + goto err;
> + }
> + xen_fe_try_connected(xendev);
> +
> + return rc;
> +
> +err:
> + xen_pv_del_xendev(domid, handle);
> + return -1;
> +}
> +
> +static char *xenstore_fe_get_backend(const char *type, int be_domid,
> + uint32_t domid, int *hdl)
> +{
> + char *name, *str, *ret = NULL;
> + uint32_t i, cdev;
> + int handle = 0;
> + char path[XEN_BUFSIZE];
> + char **dev = NULL;
> +
> + name = xenstore_get_domain_name(domid);
The path backend of the backend would normally be located in:
device/$type/$devid/backend
Could not you use that instead of a domain name?
> + snprintf(path, sizeof(path), "frontend/%s/%d", type, be_domid);
> + dev = xs_directory(xenstore, 0, path, &cdev);
> + for (i = 0; i < cdev; i++) {
> + handle = i;
> + snprintf(path, sizeof(path), "frontend/%s/%d/%d",
> + type, be_domid, handle);
> + str = xenstore_read_str(path, "domain");
> + if (!strcmp(name, str)) {
> + break;
> + }
> +
> + free(str);
> +
> + /* Not the backend domain */
> + if (handle == (cdev - 1)) {
> + goto err;
> + }
> + }
> +
> + snprintf(path, sizeof(path), "frontend/%s/%d/%d",
> + type, be_domid, handle);
> + str = xenstore_read_str(path, "backend");
> + if (str != NULL) {
> + ret = g_strdup(str);
> + free(str);
> + }
> +
> + *hdl = handle;
> + free(dev);
> +
> + return ret;
> +err:
> + *hdl = -1;
> + free(dev);
> + return NULL;
> +}
> +
> +static int xenstore_fe_scan(const char *type, uint32_t domid,
> + struct XenDevOps *ops)
> +{
> + struct XenDevice *xendev;
> + char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
> + unsigned int cdev, j;
> + char *backend;
> + char **dev = NULL;
> + int rc;
> + int xenstore_dev;
> +
> + /* ops .init check, xendev is NOT initialized */
> + rc = xen_fe_try_init(ops);
> + if (rc != 0) {
> + return -1;
> + }
> +
> + /* Get /local/domain/0/${type}/{} directory */
This comment does not reflect what is done by the next line, also what
is "{}"?
> + snprintf(path, sizeof(path), "frontend/%s", type);
I have not seen "frontend" used anywhere else, frontends are usully
within "device", like "device/vbd/$DEVID/*" for a block device
frontend. Can this be change?
> + dev = xs_directory(xenstore, 0, path, &cdev);
> + if (dev == NULL) {
> + return 0;
> + }
> +
> + for (j = 0; j < cdev; j++) {
> +
> + /* Get backend via domain name */
> + backend = xenstore_fe_get_backend(type, atoi(dev[j]),
> + domid, &xenstore_dev);
> + if (backend == NULL) {
> + continue;
> + }
> +
> + xendev = xen_fe_get_xendev(type, domid, xenstore_dev, backend, ops);
> + free(backend);
> + if (xendev == NULL) {
> + xen_pv_printf(xendev, 0, "xendev is NULL.\n");
> + continue;
> + }
> +
> + /*
> + * Simplify QEMU side, a thread is running in Xen backend, which will
> + * connect frontend when the frontend is initialised.
> + */
> + if (xen_fe_check(xendev, domid, xenstore_dev) < 0) {
> + xen_pv_printf(xendev, 0, "xendev fe_check error.\n");
> + continue;
> + }
> +
> + /* Setup watch */
> + snprintf(token, sizeof(token), "be:%p:%d:%p",
> + type, domid, xendev->ops);
> + if (!xs_watch(xenstore, xendev->be, token)) {
> + xen_pv_printf(xendev, 0, "xs_watch failed.\n");
> + continue;
> + }
> + }
> +
> + free(dev);
> + return 0;
> +}
> +
> +int xen_fe_register(const char *type, struct XenDevOps *ops)
> +{
> + return xenstore_fe_scan(type, xen_domid, ops);
> +}
Thanks,
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread* Re: [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure
2016-07-25 16:01 ` Anthony PERARD
@ 2016-08-07 11:39 ` Emil Condrea
[not found] ` <CAAULxKKk-UiLFPWn8GH4oDEqQEAowBSgdUHCPGvfX_Ubr_rztg@mail.gmail.com>
1 sibling, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-08-07 11:39 UTC (permalink / raw)
To: Anthony PERARD
Cc: xuquan8, Stefano Stabellini, wei.liu2, stefanb, qemu-devel,
xen-devel, Daniel De Graaf, Eric Blake
On Mon, Jul 25, 2016 at 7:01 PM, Anthony PERARD
<anthony.perard@citrix.com> wrote:
>
> On Sun, Jul 10, 2016 at 02:47:46PM +0300, Emil Condrea wrote:
> > This patch adds infrastructure for xen front drivers living in qemu,
> > so drivers don't need to implement common stuff on their own. It's
> > mostly xenbus management stuff: some functions to access XenStore,
> > setting up XenStore watches, callbacks on device discovery and state
> > changes, and handle event channel between the virtual machines.
> >
> > Call xen_fe_register() function to register XenDevOps, and make sure,
> > XenDevOps's flags is DEVOPS_FLAG_FE, which is flag bit to point out
> > the XenDevOps is Xen frontend.
> >
> > Signed-off-by: Quan Xu <quan.xu@intel.com>
> > Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> >
> > ---
> > Changes in v9:
> > * xenstore_dev should not be global, it will not work correctly with
> > multiple xen frontends living in qemu
> > * reuse some common functions:
> > - xen_fe_printf -> xen_pv_printf
> > - xen_fe_evtchn_event -> xen_pv_evtchn_event
> > * use libxenevtchn stable API instead of xc_* calls:
> > - xc_evtchn_fd -> xenevtchn_fd
> > - xc_evtchn_close -> xenevtchn_close
> > - xc_evtchn_bind_unbound_port -> xenevtchn_bind_unbound_port
> > ---
> > hw/xen/xen_frontend.c | 308 ++++++++++++++++++++++++++++++++++++++++++
> > hw/xen/xen_pvdev.c | 15 ++
> > include/hw/xen/xen_frontend.h | 6 +
> > include/hw/xen/xen_pvdev.h | 1 +
> > 4 files changed, 330 insertions(+)
> >
> > diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
> > index 6b92cf1..7b305ce 100644
> > --- a/hw/xen/xen_frontend.c
> > +++ b/hw/xen/xen_frontend.c
> > @@ -3,6 +3,10 @@
> > *
> > * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
> > *
> > + * Copyright (c) 2015 Intel Corporation
> > + * Authors:
> > + * Quan Xu <quan.xu@intel.com>
> > + *
> > * This library is free software; you can redistribute it and/or
> > * modify it under the terms of the GNU Lesser General Public
> > * License as published by the Free Software Foundation; either
> > @@ -23,6 +27,8 @@
> > #include "hw/xen/xen_frontend.h"
> > #include "hw/xen/xen_backend.h"
> >
> > +static int debug = 0;
> > +
> > char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
> > {
> > return xenstore_read_str(xendev->fe, node);
> > @@ -86,3 +92,305 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev)
> > xen_fe_frontend_changed(xendev, node);
> > xen_be_check_state(xendev);
> > }
> > +
> > +struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev,
> > + char *backend, struct XenDevOps *ops)
>
> This function looks similare to xen_be_get_xendev(), could they be
> shared?
>
> In any case, there is a few issue with this implementation.
There is some special initialization in each function but we can group
common behavior in xen_pv_get_xendev which will be called by
xen_be_get_xendev and xen_fe_get_xendev
>
> > +{
> > + struct XenDevice *xendev;
> > +
> > + xendev = xen_pv_find_xendev(type, dom, dev);
> > + if (xendev) {
> > + return xendev;
> > + }
> > +
> > + /* init new xendev */
> > + xendev = g_malloc0(ops->size);
> > + xendev->type = type;
> > + xendev->dom = dom;
> > + xendev->dev = dev;
> > + xendev->ops = ops;
> > +
> > + /*return if the ops->flags is not DEVOPS_FLAG_FE*/
> > + if (!(ops->flags & DEVOPS_FLAG_FE)) {
>
> Here, xendev is leaked.
Will fix in v10
>
>
> > + return NULL;
> > + }
> > +
> > + snprintf(xendev->be, sizeof(xendev->be), "%s", backend);
> > + snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
> > + xendev->type, xendev->dev);
> > +
> > + xendev->debug = debug;
> > + xendev->local_port = -1;
> > +
> > + xendev->evtchndev = xenevtchn_open(NULL, 0);
> > + if (xendev->evtchndev == NULL) {
> > + xen_pv_printf(NULL, 0, "can't open evtchn device\n");
> > + g_free(xendev);
>
> We could use goto here, so there would be only one cleanup path.
Will fix in v10
>
>
> > + return NULL;
> > + }
> > + fcntl(xenevtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC);
> > +
> > + if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
> > + xendev->gnttabdev = xengnttab_open(NULL, 0);
> > + if (xendev->gnttabdev == NULL) {
> > + xen_pv_printf(NULL, 0, "can't open gnttab device\n");
> > + xenevtchn_close(xendev->evtchndev);
> > + g_free(xendev);
>
> goto, same as before.
Will fix in v10
>
>
> > + return NULL;
> > + }
> > + } else {
> > + xendev->gnttabdev = NULL;
> > + }
> > +
> > + xen_pv_insert_xendev(xendev);
> > +
> > + if (xendev->ops->alloc) {
> > + xendev->ops->alloc(xendev);
> > + }
> > +
> > + return xendev;
> > +}
> > +
> > +int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom){
>
> '{' should be on a new line.
>
> > + xendev->local_port = xenevtchn_bind_unbound_port(xendev->evtchndev,
> > + remote_dom);
> > + if (xendev->local_port == -1) {
> > + xen_pv_printf(xendev, 0, "xenevtchn_bind_unbound_port failed\n");
> > + return -1;
> > + }
> > + xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
> > + qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
> > + xen_pv_evtchn_event, NULL, xendev);
> > + return 0;
> > +}
> > +
> > +/*
> > + * Make sure, initialize the 'xendev->fe' in xendev->ops->init() or
> > + * xendev->ops->initialize()
> > + */
> > +int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus)
>
> There is a function that do a similar job for backends,
> xen_be_set_state(). I think we could rename this function
> xen_fe_set_state. Also "xbus" is a confusing name, "state" would be
> fine.
I will rename the function and the variable in v10
>
>
> > +{
> > + xs_transaction_t xbt = XBT_NULL;
> > +
> > + if (xendev->fe_state == xbus) {
> > + return 0;
> > + }
> > +
> > + xendev->fe_state = xbus;
> > + if (xendev->fe == NULL) {
> > + xen_pv_printf(NULL, 0, "xendev->fe is NULL\n");
> > + return -1;
> > + }
> > +
> > +retry_transaction:
> > + xbt = xs_transaction_start(xenstore);
> > + if (xbt == XBT_NULL) {
> > + goto abort_transaction;
> > + }
>
> There is a transaction started, but I don't think it is used by the
> function below. Could you remove the transaction?
I will remove it. For current version I don't see a direct usage of
this transaction.
Quan, did you have a specific reason for past versions for this transaction?
>
>
> > + if (xenstore_write_int(xendev->fe, "state", xbus)) {
> > + goto abort_transaction;
> > + }
> > +
> > + if (!xs_transaction_end(xenstore, xbt, 0)) {
> > + if (errno == EAGAIN) {
> > + goto retry_transaction;
> > + }
> > + }
> > +
> > + return 0;
> > +
> > +abort_transaction:
> > + xs_transaction_end(xenstore, xbt, 1);
> > + return -1;
> > +}
> > +
> > +/*
> > + * Simplify QEMU side, a thread is running in Xen backend, which will
> > + * connect frontend when the frontend is initialised. Call these initialised
> > + * functions.
> > + */
>
> This comment does not make much sense to me.
>
>
> > +static int xen_fe_try_init(void *opaque)
> > +{
> > + struct XenDevOps *ops = opaque;
> > + int rc = -1;
> > +
> > + if (ops->init) {
> > + rc = ops->init(NULL);
> > + }
> > +
> > + return rc;
> > +}
> > +
> > +static int xen_fe_try_initialise(struct XenDevice *xendev)
> > +{
> > + int rc = 0, fe_state;
> > +
> > + if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
> > + fe_state = XenbusStateUnknown;
> > + }
> > + xendev->fe_state = fe_state;
> > +
> > + if (xendev->ops->initialise) {
> > + rc = xendev->ops->initialise(xendev);
> > + }
> > + if (rc != 0) {
> > + xen_pv_printf(xendev, 0, "initialise() failed\n");
> > + return rc;
> > + }
> > +
> > + xenbus_switch_state(xendev, XenbusStateInitialised);
> > + return 0;
> > +}
> > +
> > +static void xen_fe_try_connected(struct XenDevice *xendev)
>
> This function looks exactly the same as xen_be_try_connected, should not
> it be different and check the status of the backend?
You are right, I will fix this in v10.
>
>
> > +{
> > + if (!xendev->ops->connected) {
> > + return;
> > + }
> > +
> > + if (xendev->fe_state != XenbusStateConnected) {
> > + if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
> > + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
> > + } else {
> > + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
> > + return;
> > + }
> > + }
> > +
> > + xendev->ops->connected(xendev);
> > +}
> > +
> > +static int xen_fe_check(struct XenDevice *xendev, uint32_t domid,
> > + int handle)
>
> What is this function checking? The name of the function is not very
> helpfull.
I will rename it to xen_fe_connect
>
>
> > +{
> > + int rc = 0;
> > +
> > + rc = xen_fe_try_initialise(xendev);
> > + if (rc != 0) {
> > + xen_pv_printf(xendev, 0, "xendev %s initialise error\n",
> > + xendev->name);
> > + goto err;
> > + }
> > + xen_fe_try_connected(xendev);
> > +
> > + return rc;
> > +
> > +err:
> > + xen_pv_del_xendev(domid, handle);
> > + return -1;
> > +}
> > +
> > +static char *xenstore_fe_get_backend(const char *type, int be_domid,
> > + uint32_t domid, int *hdl)
> > +{
> > + char *name, *str, *ret = NULL;
> > + uint32_t i, cdev;
> > + int handle = 0;
> > + char path[XEN_BUFSIZE];
> > + char **dev = NULL;
> > +
> > + name = xenstore_get_domain_name(domid);
>
> The path backend of the backend would normally be located in:
> device/$type/$devid/backend
>
> Could not you use that instead of a domain name?
Multiple domains might share one vTPM.
All frontends are under domain 0. For example, for 2 guests sharing a vTPM:
/local/domain/0/frontend/vtpm = ""
/local/domain/0/frontend/vtpm/41 = ""
/local/domain/0/frontend/vtpm/41/0 = ""
/local/domain/0/frontend/vtpm/41/0/backend = "/local/domain/41/backend/vtpm/0/0"
/local/domain/0/frontend/vtpm/41/0/backend-id = "41"
/local/domain/0/frontend/vtpm/41/0/state = "3"
/local/domain/0/frontend/vtpm/41/0/handle = "0"
/local/domain/0/frontend/vtpm/41/0/domain = "hvm-guest"
/local/domain/0/frontend/vtpm/41/0/ring-ref = "8"
/local/domain/0/frontend/vtpm/41/0/event-channel = "99"
/local/domain/0/frontend/vtpm/41/0/feature-protocol-v2 = "1"
/local/domain/0/frontend/vtpm/41/1 = ""
/local/domain/0/frontend/vtpm/41/1/backend = "/local/domain/41/backend/vtpm/0/1"
/local/domain/0/frontend/vtpm/41/1/backend-id = "41"
/local/domain/0/frontend/vtpm/41/1/state = "3"
/local/domain/0/frontend/vtpm/41/1/handle = "1"
/local/domain/0/frontend/vtpm/41/1/domain = "hvm-guest2"
/local/domain/0/frontend/vtpm/41/1/ring-ref = "9"
/local/domain/0/frontend/vtpm/41/1/event-channel = "104"
/local/domain/0/frontend/vtpm/41/1/feature-protocol-v2 = "1"
>
>
> > + snprintf(path, sizeof(path), "frontend/%s/%d", type, be_domid);
> > + dev = xs_directory(xenstore, 0, path, &cdev);
> > + for (i = 0; i < cdev; i++) {
> > + handle = i;
> > + snprintf(path, sizeof(path), "frontend/%s/%d/%d",
> > + type, be_domid, handle);
> > + str = xenstore_read_str(path, "domain");
> > + if (!strcmp(name, str)) {
> > + break;
> > + }
> > +
> > + free(str);
> > +
> > + /* Not the backend domain */
> > + if (handle == (cdev - 1)) {
> > + goto err;
> > + }
> > + }
> > +
> > + snprintf(path, sizeof(path), "frontend/%s/%d/%d",
> > + type, be_domid, handle);
> > + str = xenstore_read_str(path, "backend");
> > + if (str != NULL) {
> > + ret = g_strdup(str);
> > + free(str);
> > + }
> > +
> > + *hdl = handle;
> > + free(dev);
> > +
> > + return ret;
> > +err:
> > + *hdl = -1;
> > + free(dev);
> > + return NULL;
> > +}
> > +
> > +static int xenstore_fe_scan(const char *type, uint32_t domid,
> > + struct XenDevOps *ops)
> > +{
> > + struct XenDevice *xendev;
> > + char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
> > + unsigned int cdev, j;
> > + char *backend;
> > + char **dev = NULL;
> > + int rc;
> > + int xenstore_dev;
> > +
> > + /* ops .init check, xendev is NOT initialized */
> > + rc = xen_fe_try_init(ops);
> > + if (rc != 0) {
> > + return -1;
> > + }
> > +
> > + /* Get /local/domain/0/${type}/{} directory */
>
> This comment does not reflect what is done by the next line, also what
> is "{}"?
Will update the comment.
frontend/vtpm/ is a directory with all xen hvm vtpm frontends.
Eg. frontend/vtpm/[vtpm-domain-id]
>
>
> > + snprintf(path, sizeof(path), "frontend/%s", type);
>
> I have not seen "frontend" used anywhere else, frontends are usully
> within "device", like "device/vbd/$DEVID/*" for a block device
> frontend. Can this be change?
vTPM for pv architecture use /local/domain/0/device/ and it was
proposed that /local/domain/0/frontend/ would be used for hvm vTPM.
The design for this protocol was discussed last year here:
http://markmail.org/message/blpbzgyfzbpskwbf
>
>
> > + dev = xs_directory(xenstore, 0, path, &cdev);
> > + if (dev == NULL) {
> > + return 0;
> > + }
> > +
> > + for (j = 0; j < cdev; j++) {
> > +
> > + /* Get backend via domain name */
> > + backend = xenstore_fe_get_backend(type, atoi(dev[j]),
> > + domid, &xenstore_dev);
> > + if (backend == NULL) {
> > + continue;
> > + }
> > +
> > + xendev = xen_fe_get_xendev(type, domid, xenstore_dev, backend, ops);
> > + free(backend);
> > + if (xendev == NULL) {
> > + xen_pv_printf(xendev, 0, "xendev is NULL.\n");
> > + continue;
> > + }
> > +
> > + /*
> > + * Simplify QEMU side, a thread is running in Xen backend, which will
> > + * connect frontend when the frontend is initialised.
> > + */
> > + if (xen_fe_check(xendev, domid, xenstore_dev) < 0) {
> > + xen_pv_printf(xendev, 0, "xendev fe_check error.\n");
> > + continue;
> > + }
> > +
> > + /* Setup watch */
> > + snprintf(token, sizeof(token), "be:%p:%d:%p",
> > + type, domid, xendev->ops);
> > + if (!xs_watch(xenstore, xendev->be, token)) {
> > + xen_pv_printf(xendev, 0, "xs_watch failed.\n");
> > + continue;
> > + }
> > + }
> > +
> > + free(dev);
> > + return 0;
> > +}
> > +
> > +int xen_fe_register(const char *type, struct XenDevOps *ops)
> > +{
> > + return xenstore_fe_scan(type, xen_domid, ops);
> > +}
>
Thanks for the review, Anthony.
>
> Thanks,
>
> --
> Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread[parent not found: <CAAULxKKk-UiLFPWn8GH4oDEqQEAowBSgdUHCPGvfX_Ubr_rztg@mail.gmail.com>]
* Re: [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure
[not found] ` <CAAULxKKk-UiLFPWn8GH4oDEqQEAowBSgdUHCPGvfX_Ubr_rztg@mail.gmail.com>
@ 2016-08-09 11:40 ` Xuquan (Euler)
0 siblings, 0 replies; 35+ messages in thread
From: Xuquan (Euler) @ 2016-08-09 11:40 UTC (permalink / raw)
To: Emil Condrea, Anthony PERARD
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel,
Daniel De Graaf, Eric Blake
On August 07, 2016 7:39 PM, Emil Condrea <emilcondrea@gmail.com> wrote:
On Mon, Jul 25, 2016 at 7:01 PM, Anthony PERARD <anthony.perard@citrix.com> wrote:
> >
> > > +{
> > > + xs_transaction_t xbt = XBT_NULL;
> > > +
> > > + if (xendev->fe_state == xbus) {
> > > + return 0;
> > > + }
> > > +
> > > + xendev->fe_state = xbus;
> > > + if (xendev->fe == NULL) {
> > > + xen_pv_printf(NULL, 0, "xendev->fe is NULL\n");
> > > + return -1;
> > > + }
> > > +
> > > +retry_transaction:
Add a space here, then
s/retry_transaction:/ retry_transaction:/
the same for the other cases..
> > > + xbt = xs_transaction_start(xenstore);
> > > + if (xbt == XBT_NULL) {
> > > + goto abort_transaction;
> > > + }
> >
> > There is a transaction started, but I don't think it is used by the
> > function below. Could you remove the transaction?
>
> I will remove it. For current version I don't see a direct usage of this transaction.
> Quan, did you have a specific reason for past versions for this transaction?
No specific reason, maybe I copied these code from xen / libxl ..
btw, why does libxl use ' retry_transaction: ' logic ... but QEMU doesn't ?
Thank you both.
Quan
> >
> >
> > > + if (xenstore_write_int(xendev->fe, "state", xbus)) {
> > > + goto abort_transaction;
> > > + }
> > > +
> > > + if (!xs_transaction_end(xenstore, xbt, 0)) {
> > > + if (errno == EAGAIN) {
> > > + goto retry_transaction;
> > > + }
> > > + }
> > > +
> > > + return 0;
> > > +
> > > +abort_transaction:
> > > + xs_transaction_end(xenstore, xbt, 1);
> > > + return -1;
> > > +}
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* [PATCH 16/19] Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (14 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 15/19] Qemu-Xen-vTPM: Xen frontend driver infrastructure Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 17/19] Qemu-Xen-vTPM: Move tpm_passthrough_is_selftest() into tpm_util.c Emil Condrea
` (7 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
This driver transfers any request/repond between TPM xenstubdoms
driver and Xen vTPM stubdom, and facilitates communications between
Xen vTPM stubdom domain and vTPM xenstubdoms driver. It is a glue for
the TPM xenstubdoms driver and Xen stubdom vTPM domain that provides
the actual TPM functionality.
(Xen) Xen backend driver should run before running this frontend, and
initialize XenStore as the following for communication.
[XenStore]
for example:
Domain 0: runs QEMU for guest A
Domain 1: vtpmmgr
Domain 2: vTPM for guest A
Domain 3: HVM guest A
[...]
local = ""
domain = ""
0 = ""
frontend = ""
vtpm = ""
2 = ""
0 = ""
backend = "/local/domain/2/backend/vtpm/0/0"
backend-id = "2"
state = "*"
handle = "0"
domain = "Domain3's name"
ring-ref = "*"
event-channel = "*"
feature-protocol-v2 = "1"
backend = ""
qdisk = ""
[...]
console = ""
vif = ""
[...]
2 = ""
[...]
backend = ""
vtpm = ""
0 = ""
0 = ""
frontend = "/local/domain/0/frontend/vtpm/2/0"
frontend-id = "0" ('0', frontend is running in Domain-0)
[...]
3 = ""
[...]
device = "" (frontend device, the backend is running in QEMU/.etc)
vkbd = ""
[...]
vif = ""
[...]
..
(QEMU) xen_vtpmdev_ops is initialized with the following process:
xen_hvm_init()
[...]
-->xen_fe_register("vtpm", ...)
-->xenstore_fe_scan()
-->xen_fe_try_init(ops)
--> XenDevOps.init()
-->xen_fe_get_xendev()
--> XenDevOps.alloc()
-->xen_fe_check()
-->xen_fe_try_initialise()
--> XenDevOps.initialise()
-->xen_fe_try_connected()
--> XenDevOps.connected()
-->xs_watch()
[...]
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Reviewed-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
Changed in v9:
* instead of xen_frontend.c global variable xenstore_dev, use vtpm specific
xenstore_vtpm_dev (since it will be needed just for tpm_xenstubdoms qemu driver)
* added xen_vtpm_frontend.h
* move vtpm_backend_changed -> xen_fe_backend_changed to xen_frontend.c
* use libxengnttab, libxenevtchn stable API instead of xc_* calls:
- xc_gntshr_share_pages -> xengntshr_share_pages
- xc_gntshr_munmap -> xengntshr_unshare
- xc_interface_close -> xengntshr_close
- xc_evtchn_unmask -> xenevtchn_unmask
---
hw/tpm/Makefile.objs | 1 +
hw/tpm/xen_vtpm_frontend.c | 303 ++++++++++++++++++++++++++++++++++++++++++
hw/tpm/xen_vtpm_frontend.h | 10 ++
hw/xen/xen_frontend.c | 20 +++
include/hw/xen/xen_backend.h | 1 +
include/hw/xen/xen_frontend.h | 1 +
xen-hvm.c | 6 +
7 files changed, 342 insertions(+)
create mode 100644 hw/tpm/xen_vtpm_frontend.c
create mode 100644 hw/tpm/xen_vtpm_frontend.h
diff --git a/hw/tpm/Makefile.objs b/hw/tpm/Makefile.objs
index 64cecc3..b0a821c 100644
--- a/hw/tpm/Makefile.objs
+++ b/hw/tpm/Makefile.objs
@@ -1,2 +1,3 @@
common-obj-$(CONFIG_TPM_TIS) += tpm_tis.o
common-obj-$(CONFIG_TPM_PASSTHROUGH) += tpm_passthrough.o tpm_util.o
+common-obj-$(CONFIG_TPM_XENSTUBDOMS) += xen_vtpm_frontend.o
diff --git a/hw/tpm/xen_vtpm_frontend.c b/hw/tpm/xen_vtpm_frontend.c
new file mode 100644
index 0000000..cf3eb5e
--- /dev/null
+++ b/hw/tpm/xen_vtpm_frontend.c
@@ -0,0 +1,303 @@
+/*
+ * Connect to Xen vTPM stubdom domain
+ *
+ * Copyright (c) 2015 Intel Corporation
+ * Authors:
+ * Quan Xu <quan.xu@intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>
+ */
+
+#include "qemu/osdep.h"
+
+#include "xen_vtpm_frontend.h"
+#include "hw/xen/xen_frontend.h"
+#include "hw/xen/xen_backend.h"
+
+int xenstore_vtpm_dev;
+#ifndef XS_STUBDOM_VTPM_ENABLE
+#define XS_STUBDOM_VTPM_ENABLE "1"
+#endif
+
+#ifndef VTPM_PAGE_SIZE
+#define VTPM_PAGE_SIZE 4096
+#endif
+
+enum tpmif_state {
+ /* No contents, vTPM idle, cancel complete */
+ TPMIF_STATE_IDLE,
+ /* Request ready or vTPM working */
+ TPMIF_STATE_SUBMIT,
+ /* Response ready or vTPM idle */
+ TPMIF_STATE_FINISH,
+ /* Cancel requested or vTPM working */
+ TPMIF_STATE_CANCEL,
+};
+
+static AioContext *vtpm_aio_ctx;
+
+enum status_bits {
+ VTPM_STATUS_RUNNING = 0x1,
+ VTPM_STATUS_IDLE = 0x2,
+ VTPM_STATUS_RESULT = 0x4,
+ VTPM_STATUS_CANCELED = 0x8,
+};
+
+struct tpmif_shared_page {
+ /* Request and response length in bytes */
+ uint32_t length;
+ /* Enum tpmif_state */
+ uint8_t state;
+ /* For the current request */
+ uint8_t locality;
+ /* Should be zero */
+ uint8_t pad;
+ /* Extra pages for long packets; may be zero */
+ uint8_t nr_extra_pages;
+ /*
+ * Grant IDs, the length is actually nr_extra_pages.
+ * beyond the extra_pages entries is the actual request
+ * and response.
+ */
+ uint32_t extra_pages[0];
+};
+
+struct xen_vtpm_dev {
+ struct XenDevice xendev; /* must be first */
+ struct tpmif_shared_page *shr;
+ xengntshr_handle *xen_xcs;
+ int ring_ref;
+ int bedomid;
+ QEMUBH *sr_bh;
+};
+
+static uint8_t vtpm_status(struct xen_vtpm_dev *vtpmdev)
+{
+ switch (vtpmdev->shr->state) {
+ case TPMIF_STATE_IDLE:
+ case TPMIF_STATE_FINISH:
+ return VTPM_STATUS_IDLE;
+ case TPMIF_STATE_SUBMIT:
+ case TPMIF_STATE_CANCEL:
+ return VTPM_STATUS_RUNNING;
+ default:
+ return 0;
+ }
+}
+
+static bool vtpm_aio_wait(AioContext *ctx)
+{
+ return aio_poll(ctx, true);
+}
+
+static void sr_bh_handler(void *opaque)
+{
+}
+
+int vtpm_recv(struct XenDevice *xendev, uint8_t* buf, size_t *count)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+ struct tpmif_shared_page *shr = vtpmdev->shr;
+ unsigned int offset;
+ size_t length = shr->length;
+
+ if (shr->state == TPMIF_STATE_IDLE) {
+ return -ECANCELED;
+ }
+
+ offset = sizeof(*shr) + sizeof(shr->extra_pages[0])*shr->nr_extra_pages;
+ if (offset > VTPM_PAGE_SIZE) {
+ return -EIO;
+ }
+
+ if (offset + length > VTPM_PAGE_SIZE) {
+ length = VTPM_PAGE_SIZE - offset;
+ }
+
+ memcpy(buf, offset + (uint8_t *)shr, length);
+ *count = length;
+
+ return 0;
+}
+
+int vtpm_send(struct XenDevice *xendev, uint8_t* buf, size_t count)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+ struct tpmif_shared_page *shr = vtpmdev->shr;
+ unsigned int offset = sizeof(*shr) +
+ sizeof(shr->extra_pages[0])*shr->nr_extra_pages;
+
+ if (offset > VTPM_PAGE_SIZE) {
+ return -EIO;
+ }
+
+ if (offset + count > VTPM_PAGE_SIZE) {
+ return -ECANCELED;
+ }
+
+ while (vtpm_status(vtpmdev) != VTPM_STATUS_IDLE) {
+ vtpm_aio_wait(vtpm_aio_ctx);
+ }
+
+ memcpy(offset + (uint8_t *)shr, buf, count);
+ shr->length = count;
+ barrier();
+ shr->state = TPMIF_STATE_SUBMIT;
+ xen_wmb();
+ xen_pv_send_notify(&vtpmdev->xendev);
+
+ while (vtpm_status(vtpmdev) != VTPM_STATUS_IDLE) {
+ vtpm_aio_wait(vtpm_aio_ctx);
+ }
+
+ return count;
+}
+
+static int vtpm_initialise(struct XenDevice *xendev)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+ xs_transaction_t xbt = XBT_NULL;
+ unsigned int ring_ref;
+
+ vtpmdev->xendev.fe = xenstore_read_be_str(&vtpmdev->xendev, "frontend");
+ if (vtpmdev->xendev.fe == NULL) {
+ return -1;
+ }
+
+ /* Get backend domid */
+ if (xenstore_read_fe_int(&vtpmdev->xendev, "backend-id",
+ &vtpmdev->bedomid)) {
+ return -1;
+ }
+
+ /* Alloc shared page */
+ vtpmdev->shr = xengntshr_share_pages(vtpmdev->xen_xcs, vtpmdev->bedomid, 1,
+ &ring_ref, PROT_READ|PROT_WRITE);
+ vtpmdev->ring_ref = ring_ref;
+ if (vtpmdev->shr == NULL) {
+ return -1;
+ }
+
+ /* Create event channel */
+ if (xen_fe_alloc_unbound(&vtpmdev->xendev, 0, vtpmdev->bedomid)) {
+ xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1);
+ return -1;
+ }
+
+ xenevtchn_unmask(vtpmdev->xendev.evtchndev,
+ vtpmdev->xendev.local_port);
+
+again:
+ xbt = xs_transaction_start(xenstore);
+ if (xbt == XBT_NULL) {
+ goto abort_transaction;
+ }
+
+ if (xenstore_write_int(vtpmdev->xendev.fe, "ring-ref",
+ vtpmdev->ring_ref)) {
+ goto abort_transaction;
+ }
+
+ if (xenstore_write_int(vtpmdev->xendev.fe, "event-channel",
+ vtpmdev->xendev.local_port)) {
+ goto abort_transaction;
+ }
+
+ /* Publish protocol v2 feature */
+ if (xenstore_write_int(vtpmdev->xendev.fe, "feature-protocol-v2", 1)) {
+ goto abort_transaction;
+ }
+
+ if (!xs_transaction_end(xenstore, xbt, 0)) {
+ if (errno == EAGAIN) {
+ goto again;
+ }
+ }
+
+ return 0;
+
+abort_transaction:
+ xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1);
+ xs_transaction_end(xenstore, xbt, 1);
+ return -1;
+}
+
+static int vtpm_free(struct XenDevice *xendev)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+
+ aio_poll(vtpm_aio_ctx, false);
+ qemu_bh_delete(vtpmdev->sr_bh);
+ if (vtpmdev->shr) {
+ xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1);
+ }
+ xengntshr_close(vtpmdev->xen_xcs);
+ return 0;
+}
+
+static int vtpm_init(struct XenDevice *xendev)
+{
+ char path[XEN_BUFSIZE];
+ char *value;
+ unsigned int stubdom_vtpm = 0;
+
+ snprintf(path, sizeof(path), "/local/domain/%d/platform/acpi_stubdom_vtpm",
+ xen_domid);
+ value = xs_read(xenstore, 0, path, &stubdom_vtpm);
+ if (stubdom_vtpm <= 0 || strcmp(value, XS_STUBDOM_VTPM_ENABLE)) {
+ free(value);
+ return -1;
+ }
+ free(value);
+ return 0;
+}
+
+static void vtpm_alloc(struct XenDevice *xendev)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+
+ vtpm_aio_ctx = aio_context_new(NULL);
+ if (vtpm_aio_ctx == NULL) {
+ return;
+ }
+ vtpmdev->sr_bh = aio_bh_new(vtpm_aio_ctx, sr_bh_handler, vtpmdev);
+ qemu_bh_schedule(vtpmdev->sr_bh);
+ vtpmdev->xen_xcs = xengntshr_open(0, 0);
+ xenstore_vtpm_dev = xendev->dev;
+}
+
+static void vtpm_event(struct XenDevice *xendev)
+{
+ struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev,
+ xendev);
+
+ qemu_bh_schedule(vtpmdev->sr_bh);
+}
+
+struct XenDevOps xen_vtpmdev_ops = {
+ .size = sizeof(struct xen_vtpm_dev),
+ .flags = DEVOPS_FLAG_IGNORE_STATE |
+ DEVOPS_FLAG_FE,
+ .event = vtpm_event,
+ .free = vtpm_free,
+ .init = vtpm_init,
+ .alloc = vtpm_alloc,
+ .initialise = vtpm_initialise,
+ .backend_changed = xen_fe_backend_changed,
+};
\ No newline at end of file
diff --git a/hw/tpm/xen_vtpm_frontend.h b/hw/tpm/xen_vtpm_frontend.h
new file mode 100644
index 0000000..72f586b
--- /dev/null
+++ b/hw/tpm/xen_vtpm_frontend.h
@@ -0,0 +1,10 @@
+#ifndef TPM_XEN_VTPM_FRONTEND_H
+#define TPM_XEN_VTPM_FRONTEND_H 1
+
+struct XenDevice;
+extern int xenstore_vtpm_dev;
+/* Xen vtpm */
+int vtpm_send(struct XenDevice *xendev, uint8_t* buf, size_t count);
+int vtpm_recv(struct XenDevice *xendev, uint8_t* buf, size_t *count);
+
+#endif /* TPM_XEN_VTPM_FRONTEND_H */
diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c
index 7b305ce..f110411 100644
--- a/hw/xen/xen_frontend.c
+++ b/hw/xen/xen_frontend.c
@@ -75,6 +75,26 @@ void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node)
}
}
+void xen_fe_backend_changed(struct XenDevice *xendev, const char *node)
+{
+ int be_state;
+
+ if (strcmp(node, "state") == 0) {
+ xenstore_read_be_int(xendev, node, &be_state);
+ switch (be_state) {
+ case XenbusStateConnected:
+ /* TODO */
+ break;
+ case XenbusStateClosing:
+ case XenbusStateClosed:
+ xenbus_switch_state(xendev, XenbusStateClosing);
+ break;
+ default:
+ break;
+ }
+ }
+}
+
void xenstore_update_fe(char *watch, struct XenDevice *xendev)
{
char *node;
diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h
index 71dd158..4a8808e 100644
--- a/include/hw/xen/xen_backend.h
+++ b/include/hw/xen/xen_backend.h
@@ -35,6 +35,7 @@ extern struct XenDevOps xen_kbdmouse_ops; /* xen_framebuffer.c */
extern struct XenDevOps xen_framebuffer_ops; /* xen_framebuffer.c */
extern struct XenDevOps xen_blkdev_ops; /* xen_disk.c */
extern struct XenDevOps xen_netdev_ops; /* xen_nic.c */
+extern struct XenDevOps xen_vtpmdev_ops; /* xen_vtpm_frontend.c*/
#ifdef CONFIG_USB_LIBUSB
extern struct XenDevOps xen_usb_ops; /* xen-usb.c */
#endif
diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h
index 8fc0422..912f333 100644
--- a/include/hw/xen/xen_frontend.h
+++ b/include/hw/xen/xen_frontend.h
@@ -11,6 +11,7 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev);
struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev,
char *backend, struct XenDevOps *ops);
void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node);
+void xen_fe_backend_changed(struct XenDevice *xendev, const char *node);
int xen_fe_register(const char *type, struct XenDevOps *ops);
int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom);
int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus);
diff --git a/xen-hvm.c b/xen-hvm.c
index eb57792..ef3fc53 100644
--- a/xen-hvm.c
+++ b/xen-hvm.c
@@ -16,6 +16,7 @@
#include "hw/i386/apic-msidef.h"
#include "hw/xen/xen_common.h"
#include "hw/xen/xen_backend.h"
+#include "hw/xen/xen_frontend.h"
#include "qmp-commands.h"
#include "sysemu/char.h"
@@ -1318,6 +1319,11 @@ void xen_hvm_init(PCMachineState *pcms, MemoryRegion **ram_memory)
error_report("xen backend core setup failed");
goto err;
}
+
+#ifdef CONFIG_TPM_XENSTUBDOMS
+ xen_fe_register("vtpm", &xen_vtpmdev_ops);
+#endif
+
xen_be_register("console", &xen_console_ops);
xen_be_register("vkbd", &xen_kbdmouse_ops);
xen_be_register("qdisk", &xen_blkdev_ops);
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 17/19] Qemu-Xen-vTPM: Move tpm_passthrough_is_selftest() into tpm_util.c
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (15 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 16/19] Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 18/19] Qemu-Xen-vTPM: Qemu vTPM xenstubdoms backend Emil Condrea
` (6 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
Also rename it to tpm_util_is_selftest().
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Reviewed-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
hw/tpm/Makefile.objs | 2 +-
hw/tpm/tpm_passthrough.c | 13 +------------
hw/tpm/tpm_util.c | 11 +++++++++++
hw/tpm/tpm_util.h | 1 +
4 files changed, 14 insertions(+), 13 deletions(-)
diff --git a/hw/tpm/Makefile.objs b/hw/tpm/Makefile.objs
index b0a821c..16b1447 100644
--- a/hw/tpm/Makefile.objs
+++ b/hw/tpm/Makefile.objs
@@ -1,3 +1,3 @@
-common-obj-$(CONFIG_TPM_TIS) += tpm_tis.o
+common-obj-$(CONFIG_TPM_TIS) += tpm_tis.o tpm_util.o
common-obj-$(CONFIG_TPM_PASSTHROUGH) += tpm_passthrough.o tpm_util.o
common-obj-$(CONFIG_TPM_XENSTUBDOMS) += xen_vtpm_frontend.o
diff --git a/hw/tpm/tpm_passthrough.c b/hw/tpm/tpm_passthrough.c
index e88c0d2..dba408b 100644
--- a/hw/tpm/tpm_passthrough.c
+++ b/hw/tpm/tpm_passthrough.c
@@ -137,17 +137,6 @@ static void tpm_write_fatal_error_response(uint8_t *out, uint32_t out_len)
}
}
-static bool tpm_passthrough_is_selftest(const uint8_t *in, uint32_t in_len)
-{
- struct tpm_req_hdr *hdr = (struct tpm_req_hdr *)in;
-
- if (in_len >= sizeof(*hdr)) {
- return (be32_to_cpu(hdr->ordinal) == TPM_ORD_ContinueSelfTest);
- }
-
- return false;
-}
-
static int tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt,
const uint8_t *in, uint32_t in_len,
uint8_t *out, uint32_t out_len,
@@ -161,7 +150,7 @@ static int tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt,
tpm_pt->tpm_executing = true;
*selftest_done = false;
- is_selftest = tpm_passthrough_is_selftest(in, in_len);
+ is_selftest = tpm_util_is_selftest(in, in_len);
ret = tpm_passthrough_unix_write(tpm_pt->tpm_fd, in, in_len);
if (ret != in_len) {
diff --git a/hw/tpm/tpm_util.c b/hw/tpm/tpm_util.c
index 7b35429..323f4ae 100644
--- a/hw/tpm/tpm_util.c
+++ b/hw/tpm/tpm_util.c
@@ -125,3 +125,14 @@ int tpm_util_test_tpmdev(int tpm_fd, TPMVersion *tpm_version)
return 1;
}
+
+bool tpm_util_is_selftest(const uint8_t *in, uint32_t in_len)
+{
+ struct tpm_req_hdr *hdr = (struct tpm_req_hdr *)in;
+
+ if (in_len >= sizeof(*hdr)) {
+ return (be32_to_cpu(hdr->ordinal) == TPM_ORD_ContinueSelfTest);
+ }
+
+ return false;
+}
diff --git a/hw/tpm/tpm_util.h b/hw/tpm/tpm_util.h
index e7f354a..b629663 100644
--- a/hw/tpm/tpm_util.h
+++ b/hw/tpm/tpm_util.h
@@ -24,5 +24,6 @@
#include "sysemu/tpm_backend.h"
int tpm_util_test_tpmdev(int tpm_fd, TPMVersion *tpm_version);
+bool tpm_util_is_selftest(const uint8_t *in, uint32_t in_len);
#endif /* TPM_TPM_UTILS_H */
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 18/19] Qemu-Xen-vTPM: Qemu vTPM xenstubdoms backend
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (16 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 17/19] Qemu-Xen-vTPM: Move tpm_passthrough_is_selftest() into tpm_util.c Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-10 11:47 ` [PATCH 19/19] Qemu-Xen-vTPM: QEMU machine class is initialized before tpm_init() Emil Condrea
` (5 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
This Patch provides the glue for the TPM_TIS(Qemu frontend) to Xen
stubdom vTPM domain that provides the actual TPM functionality. It
sends data and TPM commends with xen_vtpm_frontend. It is similar as
another two vTPM backends:
*vTPM passthrough backend Since QEMU 1.5.
*vTPM libtpms-based backend.
Some details:
This part of the patch provides support for the spawning of a thread
that will interact with stubdom vTPM domain by the xen_vtpm_frontend.
It expects a signal from the frontend to wake and pick up the TPM
command that is supposed to be processed and delivers the response
packet using a callback function provided by the frontend.
The backend connects itself to the frontend by filling out an interface
structure with pointers to the function implementing support for various
operations.
(QEMU) vTPM XenStubdoms backend is initialized by Qemu command line options,
"-tpmdev xenstubdoms,id=xenvtpm0 -device tpm-tis,tpmdev=xenvtpm0"
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Reviewed-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
Changes in v9:
* added reset_tpm_established_flag and get_tpm_version for TPMDriverOps
* readded tpm_backend_thread_tpm_reset which was removed because it
was not used
* tpm_xenstubdoms_unix_transfer use xenstore_vtpm_dev instead of xenstore_dev
---
backends/tpm.c | 11 ++
hw/tpm/Makefile.objs | 2 +-
hw/tpm/tpm_xenstubdoms.c | 284 +++++++++++++++++++++++++++++++++++++++
include/sysemu/tpm_backend_int.h | 2 +
4 files changed, 298 insertions(+), 1 deletion(-)
create mode 100644 hw/tpm/tpm_xenstubdoms.c
diff --git a/backends/tpm.c b/backends/tpm.c
index 536f262..9e0dfaa 100644
--- a/backends/tpm.c
+++ b/backends/tpm.c
@@ -181,6 +181,17 @@ void tpm_backend_thread_end(TPMBackendThread *tbt)
}
}
+void tpm_backend_thread_tpm_reset(TPMBackendThread *tbt,
+ GFunc func, gpointer user_data)
+{
+ if (!tbt->pool) {
+ tpm_backend_thread_create(tbt, func, user_data);
+ } else {
+ g_thread_pool_push(tbt->pool, (gpointer)TPM_BACKEND_CMD_TPM_RESET,
+ NULL);
+ }
+}
+
static const TypeInfo tpm_backend_info = {
.name = TYPE_TPM_BACKEND,
.parent = TYPE_OBJECT,
diff --git a/hw/tpm/Makefile.objs b/hw/tpm/Makefile.objs
index 16b1447..5e1e282 100644
--- a/hw/tpm/Makefile.objs
+++ b/hw/tpm/Makefile.objs
@@ -1,3 +1,3 @@
common-obj-$(CONFIG_TPM_TIS) += tpm_tis.o tpm_util.o
common-obj-$(CONFIG_TPM_PASSTHROUGH) += tpm_passthrough.o tpm_util.o
-common-obj-$(CONFIG_TPM_XENSTUBDOMS) += xen_vtpm_frontend.o
+common-obj-$(CONFIG_TPM_XENSTUBDOMS) += xen_vtpm_frontend.o tpm_xenstubdoms.o
diff --git a/hw/tpm/tpm_xenstubdoms.c b/hw/tpm/tpm_xenstubdoms.c
new file mode 100644
index 0000000..55223bf
--- /dev/null
+++ b/hw/tpm/tpm_xenstubdoms.c
@@ -0,0 +1,284 @@
+/*
+ * Xen Stubdom vTPM driver
+ *
+ * Copyright (c) 2015 Intel Corporation
+ * Authors:
+ * Quan Xu <quan.xu@intel.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>
+ */
+
+#include "qemu/osdep.h"
+#include "sysemu/tpm_backend.h"
+#include "tpm_int.h"
+#include "tpm_util.h"
+#include "hw/xen/xen_pvdev.h"
+#include "sysemu/tpm_backend_int.h"
+#include "hw/tpm/xen_vtpm_frontend.h"
+
+#define DEBUG_TPM 0
+#define DPRINTF(fmt, ...) do { \
+ if (DEBUG_TPM) { \
+ fprintf(stderr, fmt, ## __VA_ARGS__); \
+ } \
+} while (0)
+
+#define TYPE_TPM_XENSTUBDOMS "tpm-xenstubdoms"
+#define TPM_XENSTUBDOMS(obj) \
+ OBJECT_CHECK(TPMXenstubdomsState, (obj), TYPE_TPM_XENSTUBDOMS)
+
+static const TPMDriverOps tpm_xenstubdoms_driver;
+
+/* Data structures */
+typedef struct TPMXenstubdomsThreadParams {
+ TPMState *tpm_state;
+ TPMRecvDataCB *recv_data_callback;
+ TPMBackend *tb;
+} TPMXenstubdomsThreadParams;
+
+struct TPMXenstubdomsState {
+ TPMBackend parent;
+ TPMBackendThread tbt;
+ TPMXenstubdomsThreadParams tpm_thread_params;
+ bool had_startup_error;
+};
+
+typedef struct TPMXenstubdomsState TPMXenstubdomsState;
+
+/* Functions */
+static void tpm_xenstubdoms_cancel_cmd(TPMBackend *tb);
+
+static int tpm_xenstubdoms_unix_transfer(const TPMLocality *locty_data,
+ bool *selftest_done)
+{
+ size_t rlen;
+ struct XenDevice *xendev;
+ int ret;
+ bool is_selftest;
+ const struct tpm_resp_hdr *hdr;
+
+ is_selftest = tpm_util_is_selftest(locty_data->w_buffer.buffer,
+ locty_data->w_buffer.size);
+
+ xendev = xen_pv_find_xendev("vtpm", xen_domid, xenstore_vtpm_dev);
+ if (xendev == NULL) {
+ xen_pv_printf(xendev, 0, "Can not find vtpm device.\n");
+ return -1;
+ }
+
+ ret = vtpm_send(xendev, locty_data->w_buffer.buffer,
+ locty_data->w_offset);
+ if (ret < 0) {
+ xen_pv_printf(xendev, 0, "Can not send vtpm command.\n");
+ goto err_exit;
+ }
+
+ ret = vtpm_recv(xendev, locty_data->r_buffer.buffer, &rlen);
+ if (ret < 0) {
+ xen_pv_printf(xendev, 0, "vtpm reception command error.\n");
+ goto err_exit;
+ }
+
+ if (is_selftest && (ret >= sizeof(struct tpm_resp_hdr))) {
+ hdr = (struct tpm_resp_hdr *)locty_data->r_buffer.buffer;
+ *selftest_done = (be32_to_cpu(hdr->errcode) == 0);
+ }
+
+err_exit:
+ if (ret < 0) {
+ xen_pv_printf(xendev, 0, "vtpm command error.\n");
+ }
+ return ret;
+}
+
+static void tpm_xenstubdoms_worker_thread(gpointer data,
+ gpointer user_data)
+{
+ TPMXenstubdomsThreadParams *thr_parms = user_data;
+ TPMBackendCmd cmd = (TPMBackendCmd)data;
+ bool selftest_done = false;
+
+ switch (cmd) {
+ case TPM_BACKEND_CMD_PROCESS_CMD:
+ tpm_xenstubdoms_unix_transfer(thr_parms->tpm_state->locty_data,
+ &selftest_done);
+ thr_parms->recv_data_callback(thr_parms->tpm_state,
+ thr_parms->tpm_state->locty_number,
+ selftest_done);
+ break;
+ case TPM_BACKEND_CMD_INIT:
+ case TPM_BACKEND_CMD_END:
+ case TPM_BACKEND_CMD_TPM_RESET:
+
+ /* nothing to do */
+ break;
+ }
+}
+
+/*
+ *Start the TPM (thread). If it had been started before, then terminate and
+ *start it again.
+ */
+static int tpm_xenstubdoms_startup_tpm(TPMBackend *tb)
+{
+ TPMXenstubdomsState *tpm_xs = TPM_XENSTUBDOMS(tb);
+
+ tpm_backend_thread_tpm_reset(&tpm_xs->tbt, tpm_xenstubdoms_worker_thread,
+ &tpm_xs->tpm_thread_params);
+
+ return 0;
+}
+
+static void tpm_xenstubdoms_reset(TPMBackend *tb)
+{
+ TPMXenstubdomsState *tpm_xs = TPM_XENSTUBDOMS(tb);
+
+ tpm_backend_thread_end(&tpm_xs->tbt);
+ tpm_xs->had_startup_error = false;
+}
+
+static int tpm_xenstubdoms_init(TPMBackend *tb, TPMState *s,
+ TPMRecvDataCB *recv_data_cb)
+{
+ TPMXenstubdomsState *tpm_xs = TPM_XENSTUBDOMS(tb);
+
+ tpm_xs->tpm_thread_params.tpm_state = s;
+ tpm_xs->tpm_thread_params.recv_data_callback = recv_data_cb;
+ tpm_xs->tpm_thread_params.tb = tb;
+ return 0;
+}
+
+static bool tpm_xenstubdoms_get_tpm_established_flag(TPMBackend *tb)
+{
+ return false;
+}
+
+static bool tpm_xenstubdoms_get_startup_error(TPMBackend *tb)
+{
+ TPMXenstubdomsState *tpm_xs = TPM_XENSTUBDOMS(tb);
+
+ return tpm_xs->had_startup_error;
+}
+
+static size_t tpm_xenstubdoms_realloc_buffer(TPMSizedBuffer *sb)
+{
+ size_t wanted_size = 4096; /* Linux tpm.c buffer size */
+
+ if (sb->size != wanted_size) {
+ sb->buffer = g_realloc(sb->buffer, wanted_size);
+ sb->size = wanted_size;
+ }
+ return sb->size;
+}
+
+static void tpm_xenstubdoms_deliver_request(TPMBackend *tb)
+{
+ TPMXenstubdomsState *tpm_xs = TPM_XENSTUBDOMS(tb);
+
+ tpm_backend_thread_deliver_request(&tpm_xs->tbt);
+}
+
+static void tpm_xenstubdoms_cancel_cmd(TPMBackend *tb)
+{
+}
+
+static const char *tpm_xenstubdoms_create_desc(void)
+{
+ return "Xenstubdoms TPM backend driver";
+}
+
+static TPMBackend *tpm_xenstubdoms_create(QemuOpts *opts, const char *id)
+{
+ Object *obj = object_new(TYPE_TPM_XENSTUBDOMS);
+ TPMBackend *tb = TPM_BACKEND(obj);
+
+ tb->id = g_strdup(id);
+ tb->fe_model = -1;
+ tb->ops = &tpm_xenstubdoms_driver;
+ return tb;
+}
+
+static void tpm_xenstubdoms_destroy(TPMBackend *tb)
+{
+ TPMXenstubdomsState *tpm_xh = TPM_XENSTUBDOMS(tb);
+
+ tpm_backend_thread_end(&tpm_xh->tbt);
+ g_free(tb->id);
+}
+
+static int tpm_xenstubdoms_reset_tpm_established_flag(TPMBackend *tb,
+ uint8_t locty)
+{
+ /* only a TPM 2.0 will support this */
+ return 0;
+}
+static TPMVersion tpm_xenstubdoms_get_tpm_version(TPMBackend *tb)
+{
+ return TPM_VERSION_1_2;
+}
+
+static const QemuOptDesc tpm_xenstubdoms_cmdline_opts[] = {
+ TPM_STANDARD_CMDLINE_OPTS,
+ {},
+};
+
+static const TPMDriverOps tpm_xenstubdoms_driver = {
+ .type = TPM_TYPE_XENSTUBDOMS,
+ .opts = tpm_xenstubdoms_cmdline_opts,
+ .desc = tpm_xenstubdoms_create_desc,
+ .create = tpm_xenstubdoms_create,
+ .destroy = tpm_xenstubdoms_destroy,
+ .init = tpm_xenstubdoms_init,
+ .startup_tpm = tpm_xenstubdoms_startup_tpm,
+ .realloc_buffer = tpm_xenstubdoms_realloc_buffer,
+ .reset = tpm_xenstubdoms_reset,
+ .had_startup_error = tpm_xenstubdoms_get_startup_error,
+ .deliver_request = tpm_xenstubdoms_deliver_request,
+ .cancel_cmd = tpm_xenstubdoms_cancel_cmd,
+ .get_tpm_established_flag = tpm_xenstubdoms_get_tpm_established_flag,
+ .reset_tpm_established_flag = tpm_xenstubdoms_reset_tpm_established_flag,
+ .get_tpm_version = tpm_xenstubdoms_get_tpm_version
+};
+
+static void tpm_xenstubdoms_inst_init(Object *obj)
+{
+}
+
+static void tpm_xenstubdoms_inst_finalize(Object *obj)
+{
+}
+
+static void tpm_xenstubdoms_class_init(ObjectClass *klass, void *data)
+{
+ TPMBackendClass *tbc = TPM_BACKEND_CLASS(klass);
+
+ tbc->ops = &tpm_xenstubdoms_driver;
+}
+
+static const TypeInfo tpm_xenstubdoms_info = {
+ .name = TYPE_TPM_XENSTUBDOMS,
+ .parent = TYPE_TPM_BACKEND,
+ .instance_size = sizeof(TPMXenstubdomsState),
+ .class_init = tpm_xenstubdoms_class_init,
+ .instance_init = tpm_xenstubdoms_inst_init,
+ .instance_finalize = tpm_xenstubdoms_inst_finalize,
+};
+
+static void tpm_xenstubdoms_register(void)
+{
+ type_register_static(&tpm_xenstubdoms_info);
+ tpm_register_driver(&tpm_xenstubdoms_driver);
+}
+
+type_init(tpm_xenstubdoms_register)
diff --git a/include/sysemu/tpm_backend_int.h b/include/sysemu/tpm_backend_int.h
index cc0dcb3..c840ae9 100644
--- a/include/sysemu/tpm_backend_int.h
+++ b/include/sysemu/tpm_backend_int.h
@@ -31,6 +31,8 @@ void tpm_backend_thread_deliver_request(TPMBackendThread *tbt);
void tpm_backend_thread_create(TPMBackendThread *tbt,
GFunc func, gpointer user_data);
void tpm_backend_thread_end(TPMBackendThread *tbt);
+void tpm_backend_thread_tpm_reset(TPMBackendThread *tbt,
+ GFunc func, gpointer user_data);
typedef enum TPMBackendCmd {
TPM_BACKEND_CMD_INIT = 1,
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* [PATCH 19/19] Qemu-Xen-vTPM: QEMU machine class is initialized before tpm_init()
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (17 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 18/19] Qemu-Xen-vTPM: Qemu vTPM xenstubdoms backend Emil Condrea
@ 2016-07-10 11:47 ` Emil Condrea
2016-07-13 2:55 ` [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part) Xu, Quan
` (4 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-10 11:47 UTC (permalink / raw)
To: qemu-devel
Cc: wei.liu2, stefanb, stefano.stabellini, xen-devel, quan.xu,
dgdegra, eblake, emilcondrea
make sure QEMU machine class is initialized and QEMU has registered
Xen stubdom vTPM driver when call tpm_init()
Signed-off-by: Quan Xu <quan.xu@intel.com>
Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
Reviewed-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
vl.c | 17 +++++++++++------
1 file changed, 11 insertions(+), 6 deletions(-)
diff --git a/vl.c b/vl.c
index 5cd0f2a..a22b0c9 100644
--- a/vl.c
+++ b/vl.c
@@ -4353,12 +4353,6 @@ int main(int argc, char **argv, char **envp)
exit(1);
}
-#ifdef CONFIG_TPM
- if (tpm_init() < 0) {
- exit(1);
- }
-#endif
-
/* init the bluetooth world */
if (foreach_device_config(DEV_BT, bt_parse))
exit(1);
@@ -4477,6 +4471,17 @@ int main(int argc, char **argv, char **envp)
exit(1);
}
+ /*
+ * For compatible with Xen stubdom vTPM driver, make
+ * sure QEMU machine class is initialized and QEMU has
+ * registered Xen stubdom vTPM driver.
+ */
+#ifdef CONFIG_TPM
+ if (tpm_init() < 0) {
+ exit(1);
+ }
+#endif
+
/* Check if IGD GFX passthrough. */
igd_gfx_passthru();
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply related [flat|nested] 35+ messages in thread* Re: [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (18 preceding siblings ...)
2016-07-10 11:47 ` [PATCH 19/19] Qemu-Xen-vTPM: QEMU machine class is initialized before tpm_init() Emil Condrea
@ 2016-07-13 2:55 ` Xu, Quan
[not found] ` <945CA011AD5F084CBEA3E851C0AB28894B8FD7C8@SHSMSX101.ccr.corp.intel.com>
` (3 subsequent siblings)
23 siblings, 0 replies; 35+ messages in thread
From: Xu, Quan @ 2016-07-13 2:55 UTC (permalink / raw)
To: Emil Condrea, qemu-devel, Stefano Stabellini, stefanb
Cc: wei.liu2, stefano.stabellini, xen-devel, dgdegra, eblake, quan.xu2
Emil, Thanks for your effort ( today I just come back to return my laptop).
btw, sstabellini@kernel.org may be the right email.
Stefan / Stefano, could you help us review these patches? Thanks in advance!!
Quan
On July 10, 2016 7:48 PM, Emil Condrea <emilcondrea@gmail.com> wrote:
> *INTRODUCTION*
> The goal of virtual Trusted Platform Module (vTPM) is to provide a TPM
> functionality to virtual machines (Fedora, Ubuntu, Redhat, Windows .etc).
> This allows programs to interact with a TPM in a virtual machine the same way
> they interact with a TPM on the physical system. Each virtual machine gets its
> own unique, emulated, software TPM. Each major component of vTPM is
> implemented as a stubdom, providing secure separation guaranteed by the
> hypervisor.
>
> The vTPM stubdom is a Xen mini-OS domain that emulates a TPM for the
> virtual machine to use. It is a small wrapper around the Berlios TPM emulator.
> TPM commands are passed from mini-os TPM backend driver.
>
> *ARCHITECTURE*
> The architecture of stubdom vTPM for HVM virtual machine:
>
> +--------------------+
> | Windows/Linux DomU | ...
> | | ^ |
> | v | |
> | Qemu tpm1.2 Tis |
> | | ^ |
> | v | |
> | XenStubdoms backend|
> +--------------------+
> | ^
> v |
> +--------------------+
> | XenDevOps |
> +--------------------+
> | ^
> v |
> +--------------------+
> | mini-os/tpmback |
> | | ^ |
> | v | |
> | vtpm-stubdom | ...
> | | ^ |
> | v | |
> | mini-os/tpmfront |
> +--------------------+
> | ^
> v |
> +--------------------+
> | mini-os/tpmback |
> | | ^ |
> | v | |
> | vtpmmgr-stubdom |
> | | ^ |
> | v | |
> | mini-os/tpm_tis |
> +--------------------+
> | ^
> v |
> +--------------------+
> | Hardware TPM |
> +--------------------+
>
> * Windows/Linux DomU:
> The HVM based guest that wants to use a vTPM. There may be
> more than one of these.
>
> * Qemu tpm1.2 Tis:
> Implementation of the tpm1.2 Tis interface for HVM virtual
> machines. It is Qemu emulation device.
>
> * vTPM xenstubdoms driver:
> Qemu vTPM driver. This driver provides vtpm initialization
> and sending data and commends to a para-virtualized vtpm
> stubdom.
>
> * XenDevOps:
> Register Xen stubdom vTPM frontend driver, and transfer any
> request/repond between TPM xenstubdoms driver and Xen vTPM
> stubdom. Facilitate communications between Xen vTPM stubdom
> and vTPM xenstubdoms driver.
>
> * mini-os/tpmback:
> Mini-os TPM backend driver. The Linux frontend driver connects
> to this backend driver to facilitate communications between the
> Linux DomU and its vTPM. This driver is also used by vtpmmgr
> stubdom to communicate with vtpm-stubdom.
>
> * vtpm-stubdom:
> A mini-os stub domain that implements a vTPM. There is a
> one to one mapping between running vtpm-stubdom instances and
> logical vtpms on the system. The vTPM Platform Configuration
> Registers (PCRs) are all initialized to zero.
>
> * mini-os/tpmfront:
> Mini-os TPM frontend driver. The vTPM mini-os domain vtpm
> stubdom uses this driver to communicate with vtpmmgr-stubdom.
> This driver could also be used separately to implement a mini-os
> domain that wishes to use a vTPM of its own.
>
> * vtpmmgr-stubdom:
> A mini-os domain that implements the vTPM manager. There is only
> one vTPM manager and it should be running during the entire lifetime
> of the machine. vtpmmgr domain securely stores encryption keys for
> each of the vtpms and accesses to the hardware TPM to get the root of
> trust for the entire system.
>
> * mini-os/tpm_tis:
> Mini-os TPM version 1.2 TPM Interface Specification (TIS) driver.
> This driver used by vtpmmgr-stubdom to talk directly to the hardware
> TPM. Communication is facilitated by mapping hardware memory pages
> into vtpmmgr stubdom.
>
> * Hardware TPM: The physical TPM 1.2 that is soldered onto the
> motherboard.
>
> ---
> Changes in v9
> High level changes: (each patch has a detailed history versioning)
> * rebase on upstream qemu
> * refactor qemu xendevs, xenstore functions in order to be shared with both
> backend and frontends
> * convert tpm stubdoms to new qapi layout
> * use libxengnttab, libxenevtchn stable API instead of xc_* calls
> * added reset_tpm_established_flag and get_tpm_version for TPMDriverOps
> * instead of xen_frontend.c global variable xenstore_dev, use vtpm specific
> xenstore_vtpm_dev (since it will be needed just for tpm_xenstubdoms qemu
> driver)
>
>
> Emil Condrea (19):
> xen: Create a new file xen_pvdev.c
> xen: Create a new file xen_frontend.c
> xen: Move xenstore_update to xen_pvdev.c
> xen: Move evtchn functions to xen_pvdev.c
> xen: Prepare xendev qtail to be shared with frontends
> xen: Rename xen_be_printf to xen_pv_printf
> xen: Rename xen_be_unbind_evtchn
> xen: Rename xen_be_send_notify
> xen: Rename xen_be_evtchn_event
> xen: Rename xen_be_find_xendev
> xen: Rename xen_be_del_xendev
> xen: Rename xen_be_frontend_changed
> xen: Distinguish between frontend and backend devops
> Qemu-Xen-vTPM: Support for Xen stubdom vTPM command line options
> Qemu-Xen-vTPM: Xen frontend driver infrastructure
> Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver
> Qemu-Xen-vTPM: Move tpm_passthrough_is_selftest() into tpm_util.c
> Qemu-Xen-vTPM: Qemu vTPM xenstubdoms backend
> Qemu-Xen-vTPM: QEMU machine class is initialized before tpm_init()
>
> backends/tpm.c | 11 ++
> configure | 14 ++
> hmp.c | 2 +
> hw/block/xen_disk.c | 59 +++---
> hw/char/xen_console.c | 16 +-
> hw/display/xenfb.c | 57 +++---
> hw/net/xen_nic.c | 29 +--
> hw/tpm/Makefile.objs | 3 +-
> hw/tpm/tpm_passthrough.c | 13 +-
> hw/tpm/tpm_util.c | 11 ++
> hw/tpm/tpm_util.h | 1 +
> hw/tpm/tpm_xenstubdoms.c | 284 ++++++++++++++++++++++++++
> hw/tpm/xen_vtpm_frontend.c | 303 ++++++++++++++++++++++++++++
> hw/tpm/xen_vtpm_frontend.h | 10 +
> hw/usb/xen-usb.c | 38 ++--
> hw/xen/Makefile.objs | 2 +-
> hw/xen/xen_backend.c | 378 ++++-------------------------------
> hw/xen/xen_devconfig.c | 4 +-
> hw/xen/xen_frontend.c | 416
> +++++++++++++++++++++++++++++++++++++++
> hw/xen/xen_pvdev.c | 298 ++++++++++++++++++++++++++++
> include/hw/xen/xen_backend.h | 71 +------
> include/hw/xen/xen_frontend.h | 20 ++
> include/hw/xen/xen_pvdev.h | 83 ++++++++
> include/sysemu/tpm_backend_int.h | 2 +
> qapi-schema.json | 16 +-
> qemu-options.hx | 13 +-
> tpm.c | 7 +-
> vl.c | 17 +-
> xen-common.c | 4 +-
> xen-hvm.c | 6 +
> 30 files changed, 1649 insertions(+), 539 deletions(-) create mode 100644
> hw/tpm/tpm_xenstubdoms.c create mode 100644
> hw/tpm/xen_vtpm_frontend.c create mode 100644
> hw/tpm/xen_vtpm_frontend.h create mode 100644 hw/xen/xen_frontend.c
> create mode 100644 hw/xen/xen_pvdev.c create mode 100644
> include/hw/xen/xen_frontend.h create mode 100644
> include/hw/xen/xen_pvdev.h
>
> --
> 1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread[parent not found: <945CA011AD5F084CBEA3E851C0AB28894B8FD7C8@SHSMSX101.ccr.corp.intel.com>]
* Re: [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] ` <945CA011AD5F084CBEA3E851C0AB28894B8FD7C8@SHSMSX101.ccr.corp.intel.com>
@ 2016-07-14 15:33 ` Stefano Stabellini
2016-07-17 6:56 ` Quan Xu
1 sibling, 0 replies; 35+ messages in thread
From: Stefano Stabellini @ 2016-07-14 15:33 UTC (permalink / raw)
To: Xu, Quan
Cc: Stefano Stabellini, wei.liu2, stefanb, quan.xu2, qemu-devel,
xen-devel, anthony.perard, dgdegra, eblake, Emil Condrea
Hi Quan,
thanks for CC'ing me. sstabellini@kernel.org is the right address to
reach me now.
I am also CC'ing Anthony Perard who is Xen co-maintainer in QEMU.
Cheers,
Stefano
On Wed, 13 Jul 2016, Xu, Quan wrote:
> Emil, Thanks for your effort ( today I just come back to return my laptop).
>
> btw, sstabellini@kernel.org may be the right email.
> Stefan / Stefano, could you help us review these patches? Thanks in advance!!
>
> Quan
>
>
> On July 10, 2016 7:48 PM, Emil Condrea <emilcondrea@gmail.com> wrote:
> > *INTRODUCTION*
> > The goal of virtual Trusted Platform Module (vTPM) is to provide a TPM
> > functionality to virtual machines (Fedora, Ubuntu, Redhat, Windows .etc).
> > This allows programs to interact with a TPM in a virtual machine the same way
> > they interact with a TPM on the physical system. Each virtual machine gets its
> > own unique, emulated, software TPM. Each major component of vTPM is
> > implemented as a stubdom, providing secure separation guaranteed by the
> > hypervisor.
> >
> > The vTPM stubdom is a Xen mini-OS domain that emulates a TPM for the
> > virtual machine to use. It is a small wrapper around the Berlios TPM emulator.
> > TPM commands are passed from mini-os TPM backend driver.
> >
> > *ARCHITECTURE*
> > The architecture of stubdom vTPM for HVM virtual machine:
> >
> > +--------------------+
> > | Windows/Linux DomU | ...
> > | | ^ |
> > | v | |
> > | Qemu tpm1.2 Tis |
> > | | ^ |
> > | v | |
> > | XenStubdoms backend|
> > +--------------------+
> > | ^
> > v |
> > +--------------------+
> > | XenDevOps |
> > +--------------------+
> > | ^
> > v |
> > +--------------------+
> > | mini-os/tpmback |
> > | | ^ |
> > | v | |
> > | vtpm-stubdom | ...
> > | | ^ |
> > | v | |
> > | mini-os/tpmfront |
> > +--------------------+
> > | ^
> > v |
> > +--------------------+
> > | mini-os/tpmback |
> > | | ^ |
> > | v | |
> > | vtpmmgr-stubdom |
> > | | ^ |
> > | v | |
> > | mini-os/tpm_tis |
> > +--------------------+
> > | ^
> > v |
> > +--------------------+
> > | Hardware TPM |
> > +--------------------+
> >
> > * Windows/Linux DomU:
> > The HVM based guest that wants to use a vTPM. There may be
> > more than one of these.
> >
> > * Qemu tpm1.2 Tis:
> > Implementation of the tpm1.2 Tis interface for HVM virtual
> > machines. It is Qemu emulation device.
> >
> > * vTPM xenstubdoms driver:
> > Qemu vTPM driver. This driver provides vtpm initialization
> > and sending data and commends to a para-virtualized vtpm
> > stubdom.
> >
> > * XenDevOps:
> > Register Xen stubdom vTPM frontend driver, and transfer any
> > request/repond between TPM xenstubdoms driver and Xen vTPM
> > stubdom. Facilitate communications between Xen vTPM stubdom
> > and vTPM xenstubdoms driver.
> >
> > * mini-os/tpmback:
> > Mini-os TPM backend driver. The Linux frontend driver connects
> > to this backend driver to facilitate communications between the
> > Linux DomU and its vTPM. This driver is also used by vtpmmgr
> > stubdom to communicate with vtpm-stubdom.
> >
> > * vtpm-stubdom:
> > A mini-os stub domain that implements a vTPM. There is a
> > one to one mapping between running vtpm-stubdom instances and
> > logical vtpms on the system. The vTPM Platform Configuration
> > Registers (PCRs) are all initialized to zero.
> >
> > * mini-os/tpmfront:
> > Mini-os TPM frontend driver. The vTPM mini-os domain vtpm
> > stubdom uses this driver to communicate with vtpmmgr-stubdom.
> > This driver could also be used separately to implement a mini-os
> > domain that wishes to use a vTPM of its own.
> >
> > * vtpmmgr-stubdom:
> > A mini-os domain that implements the vTPM manager. There is only
> > one vTPM manager and it should be running during the entire lifetime
> > of the machine. vtpmmgr domain securely stores encryption keys for
> > each of the vtpms and accesses to the hardware TPM to get the root of
> > trust for the entire system.
> >
> > * mini-os/tpm_tis:
> > Mini-os TPM version 1.2 TPM Interface Specification (TIS) driver.
> > This driver used by vtpmmgr-stubdom to talk directly to the hardware
> > TPM. Communication is facilitated by mapping hardware memory pages
> > into vtpmmgr stubdom.
> >
> > * Hardware TPM: The physical TPM 1.2 that is soldered onto the
> > motherboard.
> >
> > ---
> > Changes in v9
> > High level changes: (each patch has a detailed history versioning)
> > * rebase on upstream qemu
> > * refactor qemu xendevs, xenstore functions in order to be shared with both
> > backend and frontends
> > * convert tpm stubdoms to new qapi layout
> > * use libxengnttab, libxenevtchn stable API instead of xc_* calls
> > * added reset_tpm_established_flag and get_tpm_version for TPMDriverOps
> > * instead of xen_frontend.c global variable xenstore_dev, use vtpm specific
> > xenstore_vtpm_dev (since it will be needed just for tpm_xenstubdoms qemu
> > driver)
> >
> >
> > Emil Condrea (19):
> > xen: Create a new file xen_pvdev.c
> > xen: Create a new file xen_frontend.c
> > xen: Move xenstore_update to xen_pvdev.c
> > xen: Move evtchn functions to xen_pvdev.c
> > xen: Prepare xendev qtail to be shared with frontends
> > xen: Rename xen_be_printf to xen_pv_printf
> > xen: Rename xen_be_unbind_evtchn
> > xen: Rename xen_be_send_notify
> > xen: Rename xen_be_evtchn_event
> > xen: Rename xen_be_find_xendev
> > xen: Rename xen_be_del_xendev
> > xen: Rename xen_be_frontend_changed
> > xen: Distinguish between frontend and backend devops
> > Qemu-Xen-vTPM: Support for Xen stubdom vTPM command line options
> > Qemu-Xen-vTPM: Xen frontend driver infrastructure
> > Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver
> > Qemu-Xen-vTPM: Move tpm_passthrough_is_selftest() into tpm_util.c
> > Qemu-Xen-vTPM: Qemu vTPM xenstubdoms backend
> > Qemu-Xen-vTPM: QEMU machine class is initialized before tpm_init()
> >
> > backends/tpm.c | 11 ++
> > configure | 14 ++
> > hmp.c | 2 +
> > hw/block/xen_disk.c | 59 +++---
> > hw/char/xen_console.c | 16 +-
> > hw/display/xenfb.c | 57 +++---
> > hw/net/xen_nic.c | 29 +--
> > hw/tpm/Makefile.objs | 3 +-
> > hw/tpm/tpm_passthrough.c | 13 +-
> > hw/tpm/tpm_util.c | 11 ++
> > hw/tpm/tpm_util.h | 1 +
> > hw/tpm/tpm_xenstubdoms.c | 284 ++++++++++++++++++++++++++
> > hw/tpm/xen_vtpm_frontend.c | 303 ++++++++++++++++++++++++++++
> > hw/tpm/xen_vtpm_frontend.h | 10 +
> > hw/usb/xen-usb.c | 38 ++--
> > hw/xen/Makefile.objs | 2 +-
> > hw/xen/xen_backend.c | 378 ++++-------------------------------
> > hw/xen/xen_devconfig.c | 4 +-
> > hw/xen/xen_frontend.c | 416
> > +++++++++++++++++++++++++++++++++++++++
> > hw/xen/xen_pvdev.c | 298 ++++++++++++++++++++++++++++
> > include/hw/xen/xen_backend.h | 71 +------
> > include/hw/xen/xen_frontend.h | 20 ++
> > include/hw/xen/xen_pvdev.h | 83 ++++++++
> > include/sysemu/tpm_backend_int.h | 2 +
> > qapi-schema.json | 16 +-
> > qemu-options.hx | 13 +-
> > tpm.c | 7 +-
> > vl.c | 17 +-
> > xen-common.c | 4 +-
> > xen-hvm.c | 6 +
> > 30 files changed, 1649 insertions(+), 539 deletions(-) create mode 100644
> > hw/tpm/tpm_xenstubdoms.c create mode 100644
> > hw/tpm/xen_vtpm_frontend.c create mode 100644
> > hw/tpm/xen_vtpm_frontend.h create mode 100644 hw/xen/xen_frontend.c
> > create mode 100644 hw/xen/xen_pvdev.c create mode 100644
> > include/hw/xen/xen_frontend.h create mode 100644
> > include/hw/xen/xen_pvdev.h
> >
> > --
> > 1.9.1
>
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread* Re: [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] ` <945CA011AD5F084CBEA3E851C0AB28894B8FD7C8@SHSMSX101.ccr.corp.intel.com>
2016-07-14 15:33 ` Stefano Stabellini
@ 2016-07-17 6:56 ` Quan Xu
1 sibling, 0 replies; 35+ messages in thread
From: Quan Xu @ 2016-07-17 6:56 UTC (permalink / raw)
To: Xu, Quan
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel,
anthony.perard, dgdegra, eblake, Emil Condrea
[-- Attachment #1.1: Type: text/plain, Size: 333 bytes --]
On 2016 Jul 14 (Thu) 23:34, Stefano Stabellini <sstabellini@kernel.org> wrote:> Hi Quan,
>
> thanks for CC'ing me. sstabellini@kernel.org is the right address to
> reach me now.
>
> I am also CC'ing Anthony Perard who is Xen co-maintainer in QEMU.
>
> Cheers,
>
> Stefano
thanks in advance!! :):)Quan
[-- Attachment #1.2: Type: text/html, Size: 908 bytes --]
[-- Attachment #2: Type: text/plain, Size: 127 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
[parent not found: <1468151270-12984-2-git-send-email-emilcondrea@gmail.com>]
* Re: [Qemu-devel] [PATCH 01/19] xen: Create a new file xen_pvdev.c
[not found] ` <1468151270-12984-2-git-send-email-emilcondrea@gmail.com>
@ 2016-07-25 13:41 ` Anthony PERARD
0 siblings, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 13:41 UTC (permalink / raw)
To: Emil Condrea
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra
On Sun, Jul 10, 2016 at 02:47:32PM +0300, Emil Condrea wrote:
> The purpose of the new file is to store generic functions shared by frontend
> and backends such as xenstore operations, xendevs.
>
> Signed-off-by: Quan Xu <quan.xu@intel.com>
> Signed-off-by: Emil Condrea <emilcondrea@gmail.com>
> ---
> hw/xen/Makefile.objs | 2 +-
> hw/xen/xen_backend.c | 125 +-----------------------------------
> hw/xen/xen_pvdev.c | 149 +++++++++++++++++++++++++++++++++++++++++++
> include/hw/xen/xen_backend.h | 63 +-----------------
> include/hw/xen/xen_pvdev.h | 71 +++++++++++++++++++++
> 5 files changed, 223 insertions(+), 187 deletions(-)
> create mode 100644 hw/xen/xen_pvdev.c
> create mode 100644 include/hw/xen/xen_pvdev.h
>
> diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h
> new file mode 100644
> index 0000000..f60bfae
> --- /dev/null
> +++ b/include/hw/xen/xen_pvdev.h
> @@ -0,0 +1,71 @@
> +#ifndef QEMU_HW_XEN_PVDEV_H
> +#define QEMU_HW_XEN_PVDEV_H 1
No need for the 1. Just "#define X" is enough.
> +
> +#include "hw/xen/xen_common.h"
> +#include <inttypes.h>
I don't think this include is needed.
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread
* Re: [Qemu-devel] [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] <1468151270-12984-1-git-send-email-emilcondrea@gmail.com>
` (21 preceding siblings ...)
[not found] ` <1468151270-12984-2-git-send-email-emilcondrea@gmail.com>
@ 2016-07-25 14:09 ` Anthony PERARD
[not found] ` <20160725140941.GL1835@perard.uk.xensource.com>
23 siblings, 0 replies; 35+ messages in thread
From: Anthony PERARD @ 2016-07-25 14:09 UTC (permalink / raw)
To: Emil Condrea
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel,
quan.xu, dgdegra
On Sun, Jul 10, 2016 at 02:47:31PM +0300, Emil Condrea wrote:
> Emil Condrea (19):
> xen: Create a new file xen_pvdev.c
> xen: Create a new file xen_frontend.c
> xen: Move xenstore_update to xen_pvdev.c
> xen: Move evtchn functions to xen_pvdev.c
> xen: Prepare xendev qtail to be shared with frontends
> xen: Rename xen_be_printf to xen_pv_printf
> xen: Rename xen_be_unbind_evtchn
> xen: Rename xen_be_send_notify
> xen: Rename xen_be_evtchn_event
> xen: Rename xen_be_find_xendev
> xen: Rename xen_be_del_xendev
> xen: Rename xen_be_frontend_changed
Patches from 1 to 12 looks fine but ./script/checkpatch.pl reveal some
coding style issue in the code that is moved. Could you fix those issues
in separate patches? (Having separate patches for code movement and for
coding style fix makes it easier to review.)
I'll start reviewing the more complicated patches now.
Thanks,
--
Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread[parent not found: <20160725140941.GL1835@perard.uk.xensource.com>]
* Re: [Qemu-devel] [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] ` <20160725140941.GL1835@perard.uk.xensource.com>
@ 2016-07-31 9:57 ` Emil Condrea
2016-10-04 6:52 ` Emil Condrea
1 sibling, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-07-31 9:57 UTC (permalink / raw)
To: Anthony PERARD
Cc: Stefano Stabellini, wei.liu2, stefanb, qemu-devel, xen-devel, Xu,
Quan, Daniel De Graaf
[-- Attachment #1.1: Type: text/plain, Size: 1211 bytes --]
Thanks Anthony for the feedback.
I will send v10 containing fixes for patches 1 to 12 + additional patches
for
fixing code style issues for moved code.
On Mon, Jul 25, 2016 at 5:09 PM, Anthony PERARD <anthony.perard@citrix.com>
wrote:
> On Sun, Jul 10, 2016 at 02:47:31PM +0300, Emil Condrea wrote:
> > Emil Condrea (19):
> > xen: Create a new file xen_pvdev.c
> > xen: Create a new file xen_frontend.c
> > xen: Move xenstore_update to xen_pvdev.c
> > xen: Move evtchn functions to xen_pvdev.c
> > xen: Prepare xendev qtail to be shared with frontends
> > xen: Rename xen_be_printf to xen_pv_printf
> > xen: Rename xen_be_unbind_evtchn
> > xen: Rename xen_be_send_notify
> > xen: Rename xen_be_evtchn_event
> > xen: Rename xen_be_find_xendev
> > xen: Rename xen_be_del_xendev
> > xen: Rename xen_be_frontend_changed
>
> Patches from 1 to 12 looks fine but ./script/checkpatch.pl reveal some
> coding style issue in the code that is moved. Could you fix those issues
> in separate patches? (Having separate patches for code movement and for
> coding style fix makes it easier to review.)
>
> I'll start reviewing the more complicated patches now.
>
> Thanks,
>
> --
> Anthony PERARD
>
[-- Attachment #1.2: Type: text/html, Size: 1827 bytes --]
[-- Attachment #2: Type: text/plain, Size: 127 bytes --]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread* Re: [Qemu-devel] [v9 00/19] QEMU:Xen stubdom vTPM for HVM virtual machine(QEMU Part)
[not found] ` <20160725140941.GL1835@perard.uk.xensource.com>
2016-07-31 9:57 ` Emil Condrea
@ 2016-10-04 6:52 ` Emil Condrea
1 sibling, 0 replies; 35+ messages in thread
From: Emil Condrea @ 2016-10-04 6:52 UTC (permalink / raw)
To: Anthony PERARD
Cc: xuquan8, Stefano Stabellini, wei.liu2, stefanb, qemu-devel,
xen-devel, Daniel De Graaf
Anthony, I've split the reorganization and code style issues in a separate
patch series which I've posted today:
http://markmail.org/message/feu6u3f7py5vt77v
Thanks
On Mon, Jul 25, 2016 at 5:09 PM, Anthony PERARD
<anthony.perard@citrix.com> wrote:
> On Sun, Jul 10, 2016 at 02:47:31PM +0300, Emil Condrea wrote:
>> Emil Condrea (19):
>> xen: Create a new file xen_pvdev.c
>> xen: Create a new file xen_frontend.c
>> xen: Move xenstore_update to xen_pvdev.c
>> xen: Move evtchn functions to xen_pvdev.c
>> xen: Prepare xendev qtail to be shared with frontends
>> xen: Rename xen_be_printf to xen_pv_printf
>> xen: Rename xen_be_unbind_evtchn
>> xen: Rename xen_be_send_notify
>> xen: Rename xen_be_evtchn_event
>> xen: Rename xen_be_find_xendev
>> xen: Rename xen_be_del_xendev
>> xen: Rename xen_be_frontend_changed
>
> Patches from 1 to 12 looks fine but ./script/checkpatch.pl reveal some
> coding style issue in the code that is moved. Could you fix those issues
> in separate patches? (Having separate patches for code movement and for
> coding style fix makes it easier to review.)
>
> I'll start reviewing the more complicated patches now.
>
> Thanks,
>
> --
> Anthony PERARD
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
https://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 35+ messages in thread