2009-04-22 17:19:15 +02:00
|
|
|
/*
|
|
|
|
* xen backend driver infrastructure
|
|
|
|
* (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; under version 2 of the License.
|
|
|
|
*
|
|
|
|
* This program 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
2009-07-16 22:47:01 +02:00
|
|
|
* with this program; if not, see <http://www.gnu.org/licenses/>.
|
2012-01-13 17:44:23 +01:00
|
|
|
*
|
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2009-04-22 17:19:15 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: add some xenbus / xenstore concepts overview here.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:06 +01:00
|
|
|
#include "qemu/osdep.h"
|
2009-04-22 17:19:15 +02:00
|
|
|
#include <sys/signal.h>
|
|
|
|
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/hw.h"
|
2016-06-13 11:12:21 +02:00
|
|
|
#include "hw/sysbus.h"
|
2016-11-22 07:10:58 +01:00
|
|
|
#include "hw/boards.h"
|
2013-04-08 16:55:25 +02:00
|
|
|
#include "sysemu/char.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/log.h"
|
2016-11-22 07:10:56 +01:00
|
|
|
#include "qapi/error.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/xen/xen_backend.h"
|
2016-10-25 07:50:09 +02:00
|
|
|
#include "hw/xen/xen_pvdev.h"
|
2016-11-22 07:10:58 +01:00
|
|
|
#include "monitor/qdev.h"
|
2009-04-22 17:19:15 +02:00
|
|
|
|
2012-06-21 13:43:59 +02:00
|
|
|
#include <xen/grant_table.h>
|
|
|
|
|
2016-06-13 11:12:21 +02:00
|
|
|
DeviceState *xen_sysdev;
|
2016-11-22 07:10:56 +01:00
|
|
|
BusState *xen_sysbus;
|
2016-06-13 11:12:21 +02:00
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/* public */
|
2016-02-10 12:07:03 +01:00
|
|
|
xc_interface *xen_xc = NULL;
|
xen: Switch uses of xc_map_foreign_{pages,bulk} to use libxenforeignmemory API.
In Xen 4.7 we are refactoring parts libxenctrl into a number of
separate libraries which will provide backward and forward API and ABI
compatiblity.
One such library will be libxenforeignmemory which provides access to
privileged foreign mappings and which will provide an interface
equivalent to xc_map_foreign_{pages,bulk}.
The new xenforeignmemory_map() function behaves like
xc_map_foreign_pages() when the err argument is NULL and like
xc_map_foreign_bulk() when err is non-NULL, which maps into the shim
here onto checking err == NULL and calling the appropriate old
function.
Note that xenforeignmemory_map() takes the number of pages before the
arrays themselves, in order to support potentially future use of
variable-length-arrays in the prototype (in the future, when Xen's
baseline toolchain requirements are new enough to ensure VLAs are
supported).
In preparation for adding support for libxenforeignmemory add support
to the <=4.0 and <=4.6 compat code in xen_common.h to allow us to
switch to using the new API. These shims will disappear for versions
of Xen which include libxenforeignmemory.
Since libxenforeignmemory will have its own handle type but for <= 4.6
the functionality is provided by using a libxenctrl handle we
introduce a new global xen_fmem alongside the existing xen_xc. In fact
we make xen_fmem a pointer to the existing xen_xc, which then works
correctly with both <=4.0 (xc handle is an int) and <=4.6 (xc handle
is a pointer). In the latter case xen_fmem is actually a double
indirect pointer, but it all falls out in the wash.
Unlike libxenctrl libxenforeignmemory has an explicit unmap function,
rather than just specifying that munmap should be used, so the unmap
paths are updated to use xenforeignmemory_unmap, which is a shim for
munmap on these versions of xen. The mappings in xen-hvm.c do not
appear to be unmapped (which makes sense for a qemu-dm process)
In fb_disconnect this results in a change from simply mmap over the
existing mapping (with an implicit munmap) to expliclty unmapping with
xenforeignmemory_unmap and then mapping the required anonymous memory
in the same hole. I don't think this is a problem since any other
thread which was racily touching this region would already be running
the risk of hitting the mapping halfway through the call. If this is
thought to be a problem then we could consider adding an extra API to
the libxenforeignmemory interface to replace a foreign mapping with
anonymous shared memory, but I'd prefer not to.
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Reviewed-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
2016-01-15 14:23:41 +01:00
|
|
|
xenforeignmemory_handle *xen_fmem = NULL;
|
2009-04-22 17:19:15 +02:00
|
|
|
struct xs_handle *xenstore = NULL;
|
2009-04-22 17:19:39 +02:00
|
|
|
const char *xen_protocol;
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
/* private */
|
2016-10-25 07:50:07 +02:00
|
|
|
static int debug;
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val)
|
|
|
|
{
|
|
|
|
return xenstore_write_str(xendev->be, node, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival)
|
|
|
|
{
|
|
|
|
return xenstore_write_int(xendev->be, node, ival);
|
|
|
|
}
|
|
|
|
|
2013-04-05 17:37:32 +02:00
|
|
|
int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival)
|
|
|
|
{
|
|
|
|
return xenstore_write_int64(xendev->be, node, ival);
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
char *xenstore_read_be_str(struct XenDevice *xendev, const char *node)
|
|
|
|
{
|
|
|
|
return xenstore_read_str(xendev->be, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2016-10-25 07:50:08 +02:00
|
|
|
int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node,
|
|
|
|
uint64_t *uval)
|
2013-12-18 20:17:31 +01:00
|
|
|
{
|
|
|
|
return xenstore_read_uint64(xendev->fe, node, uval);
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
|
|
|
|
int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = xenstore_write_be_int(xendev, "state", state);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (rc < 0) {
|
|
|
|
return rc;
|
|
|
|
}
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
|
2010-09-23 13:28:45 +02:00
|
|
|
xenbus_strstate(xendev->be_state), xenbus_strstate(state));
|
2009-04-22 17:19:15 +02:00
|
|
|
xendev->be_state = state;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get xen backend device, allocate a new one if it doesn't exist.
|
|
|
|
*/
|
|
|
|
static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
|
|
|
|
struct XenDevOps *ops)
|
|
|
|
{
|
|
|
|
struct XenDevice *xendev;
|
|
|
|
|
2016-10-25 07:50:18 +02:00
|
|
|
xendev = xen_pv_find_xendev(type, dom, dev);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev) {
|
|
|
|
return xendev;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
/* init new xendev */
|
2011-08-21 05:09:37 +02:00
|
|
|
xendev = g_malloc0(ops->size);
|
2016-11-22 07:10:58 +01:00
|
|
|
object_initialize(&xendev->qdev, ops->size, TYPE_XENBACKEND);
|
|
|
|
qdev_set_parent_bus(&xendev->qdev, xen_sysbus);
|
|
|
|
qdev_set_id(&xendev->qdev, g_strdup_printf("xen-%s-%d", type, dev));
|
|
|
|
qdev_init_nofail(&xendev->qdev);
|
|
|
|
object_unref(OBJECT(&xendev->qdev));
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
xendev->type = type;
|
|
|
|
xendev->dom = dom;
|
|
|
|
xendev->dev = dev;
|
|
|
|
xendev->ops = ops;
|
|
|
|
|
2013-10-10 16:25:52 +02:00
|
|
|
snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d",
|
|
|
|
xendev->type, xendev->dom, xendev->dev);
|
2009-04-22 17:19:15 +02:00
|
|
|
snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->type, xendev->dev);
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
xendev->debug = debug;
|
|
|
|
xendev->local_port = -1;
|
|
|
|
|
2016-01-15 14:23:38 +01:00
|
|
|
xendev->evtchndev = xenevtchn_open(NULL, 0);
|
|
|
|
if (xendev->evtchndev == NULL) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(NULL, 0, "can't open evtchn device\n");
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(xendev);
|
2010-09-23 13:28:45 +02:00
|
|
|
return NULL;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
2016-01-15 14:23:38 +01:00
|
|
|
fcntl(xenevtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC);
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
|
2016-01-15 14:23:39 +01:00
|
|
|
xendev->gnttabdev = xengnttab_open(NULL, 0);
|
|
|
|
if (xendev->gnttabdev == NULL) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(NULL, 0, "can't open gnttab device\n");
|
2016-01-15 14:23:38 +01:00
|
|
|
xenevtchn_close(xendev->evtchndev);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(xendev);
|
2010-09-23 13:28:45 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
} else {
|
2016-01-15 14:23:39 +01:00
|
|
|
xendev->gnttabdev = NULL;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
2016-10-25 07:50:12 +02:00
|
|
|
xen_pv_insert_xendev(xendev);
|
2009-04-22 17:19:15 +02:00
|
|
|
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->ops->alloc) {
|
|
|
|
xendev->ops->alloc(xendev);
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
|
|
|
|
return xendev;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sync internal data structures on xenstore updates.
|
|
|
|
* Node specifies the changed field. node = NULL means
|
|
|
|
* update all fields (used for initialization).
|
|
|
|
*/
|
|
|
|
static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
|
|
|
|
{
|
|
|
|
if (node == NULL || strcmp(node, "online") == 0) {
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) {
|
|
|
|
xendev->online = 0;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (node) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "backend update: %s\n", node);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->ops->backend_changed) {
|
|
|
|
xendev->ops->backend_changed(xendev, node);
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
|
|
|
|
{
|
|
|
|
int fe_state;
|
|
|
|
|
|
|
|
if (node == NULL || strcmp(node, "state") == 0) {
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
|
|
|
|
fe_state = XenbusStateUnknown;
|
|
|
|
}
|
|
|
|
if (xendev->fe_state != fe_state) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
|
2010-09-23 13:28:45 +02:00
|
|
|
xenbus_strstate(xendev->fe_state),
|
|
|
|
xenbus_strstate(fe_state));
|
|
|
|
}
|
|
|
|
xendev->fe_state = fe_state;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
if (node == NULL || strcmp(node, "protocol") == 0) {
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(xendev->protocol);
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
|
|
|
|
if (xendev->protocol) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "frontend protocol: %s\n",
|
2016-10-25 07:50:08 +02:00
|
|
|
xendev->protocol);
|
2010-09-23 13:28:45 +02:00
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (node) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->ops->frontend_changed) {
|
|
|
|
xendev->ops->frontend_changed(xendev, node);
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
/* Check for possible state transitions and perform them. */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initial xendev setup. Read frontend path, register watch for it.
|
|
|
|
* Should succeed once xend finished setting up the backend device.
|
|
|
|
*
|
|
|
|
* Also sets initial state (-> Initializing) when done. Which
|
|
|
|
* only affects the xendev->be_state variable as xenbus should
|
|
|
|
* already be put into that state by xend.
|
|
|
|
*/
|
|
|
|
static int xen_be_try_setup(struct XenDevice *xendev)
|
|
|
|
{
|
|
|
|
char token[XEN_BUFSIZE];
|
|
|
|
int be_state;
|
|
|
|
|
|
|
|
if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "reading backend state failed\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (be_state != XenbusStateInitialising) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
|
2010-09-23 13:28:45 +02:00
|
|
|
xenbus_strstate(be_state));
|
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
xendev->fe = xenstore_read_be_str(xendev, "frontend");
|
|
|
|
if (xendev->fe == NULL) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "reading frontend path failed\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* setup frontend watch */
|
|
|
|
snprintf(token, sizeof(token), "fe:%p", xendev);
|
|
|
|
if (!xs_watch(xenstore, xendev->fe, token)) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->fe);
|
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
xen_be_set_state(xendev, XenbusStateInitialising);
|
|
|
|
|
|
|
|
xen_be_backend_changed(xendev, NULL);
|
|
|
|
xen_be_frontend_changed(xendev, NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try initialize xendev. Prepare everything the backend can do
|
|
|
|
* without synchronizing with the frontend. Fakes hotplug-status. No
|
|
|
|
* hotplug involved here because this is about userspace drivers, thus
|
|
|
|
* there are kernel backend devices which could invoke hotplug.
|
|
|
|
*
|
|
|
|
* Goes to InitWait on success.
|
|
|
|
*/
|
|
|
|
static int xen_be_try_init(struct XenDevice *xendev)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (!xendev->online) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "not online\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->ops->init) {
|
|
|
|
rc = xendev->ops->init(xendev);
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
if (rc != 0) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "init() failed\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return rc;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
xenstore_write_be_str(xendev, "hotplug-status", "connected");
|
|
|
|
xen_be_set_state(xendev, XenbusStateInitWait);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-06-17 14:15:35 +02:00
|
|
|
* Try to initialise xendev. Depends on the frontend being ready
|
2009-04-22 17:19:15 +02:00
|
|
|
* for it (shared ring and evtchn info in xenstore, state being
|
|
|
|
* Initialised or Connected).
|
|
|
|
*
|
|
|
|
* Goes to Connected on success.
|
|
|
|
*/
|
2011-06-17 14:15:35 +02:00
|
|
|
static int xen_be_try_initialise(struct XenDevice *xendev)
|
2009-04-22 17:19:15 +02:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (xendev->fe_state != XenbusStateInitialised &&
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->fe_state != XenbusStateConnected) {
|
|
|
|
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
} else {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
2011-06-17 14:15:35 +02:00
|
|
|
if (xendev->ops->initialise) {
|
|
|
|
rc = xendev->ops->initialise(xendev);
|
2010-09-23 13:28:45 +02:00
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
if (rc != 0) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "initialise() failed\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return rc;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
xen_be_set_state(xendev, XenbusStateConnected);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-17 14:15:35 +02:00
|
|
|
/*
|
|
|
|
* Try to let xendev know that it is connected. Depends on the
|
|
|
|
* frontend being Connected. Note that this may be called more
|
|
|
|
* than once since the backend state is not modified.
|
|
|
|
*/
|
|
|
|
static void xen_be_try_connected(struct XenDevice *xendev)
|
|
|
|
{
|
|
|
|
if (!xendev->ops->connected) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xendev->fe_state != XenbusStateConnected) {
|
|
|
|
if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
|
2011-06-17 14:15:35 +02:00
|
|
|
} else {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
|
2011-06-17 14:15:35 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
xendev->ops->connected(xendev);
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
/*
|
|
|
|
* Teardown connection.
|
|
|
|
*
|
|
|
|
* Goes to Closed when done.
|
|
|
|
*/
|
|
|
|
static void xen_be_disconnect(struct XenDevice *xendev, enum xenbus_state state)
|
|
|
|
{
|
|
|
|
if (xendev->be_state != XenbusStateClosing &&
|
|
|
|
xendev->be_state != XenbusStateClosed &&
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->ops->disconnect) {
|
|
|
|
xendev->ops->disconnect(xendev);
|
|
|
|
}
|
|
|
|
if (xendev->be_state != state) {
|
2009-04-22 17:19:15 +02:00
|
|
|
xen_be_set_state(xendev, state);
|
2010-09-23 13:28:45 +02:00
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to reset xendev, for reconnection by another frontend instance.
|
|
|
|
*/
|
|
|
|
static int xen_be_try_reset(struct XenDevice *xendev)
|
|
|
|
{
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->fe_state != XenbusStateInitialising) {
|
2009-04-22 17:19:15 +02:00
|
|
|
return -1;
|
2010-09-23 13:28:45 +02:00
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
|
2009-04-22 17:19:15 +02:00
|
|
|
xen_be_set_state(xendev, XenbusStateInitialising);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* state change dispatcher function
|
|
|
|
*/
|
|
|
|
void xen_be_check_state(struct XenDevice *xendev)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
/* frontend may request shutdown from almost anywhere */
|
|
|
|
if (xendev->fe_state == XenbusStateClosing ||
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev->fe_state == XenbusStateClosed) {
|
|
|
|
xen_be_disconnect(xendev, xendev->fe_state);
|
|
|
|
return;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check for possible backend state transitions */
|
|
|
|
for (;;) {
|
2010-09-23 13:28:45 +02:00
|
|
|
switch (xendev->be_state) {
|
|
|
|
case XenbusStateUnknown:
|
|
|
|
rc = xen_be_try_setup(xendev);
|
|
|
|
break;
|
|
|
|
case XenbusStateInitialising:
|
|
|
|
rc = xen_be_try_init(xendev);
|
|
|
|
break;
|
|
|
|
case XenbusStateInitWait:
|
2011-06-17 14:15:35 +02:00
|
|
|
rc = xen_be_try_initialise(xendev);
|
|
|
|
break;
|
|
|
|
case XenbusStateConnected:
|
|
|
|
/* xendev->be_state doesn't change */
|
|
|
|
xen_be_try_connected(xendev);
|
|
|
|
rc = -1;
|
2010-09-23 13:28:45 +02:00
|
|
|
break;
|
2009-04-22 17:19:15 +02:00
|
|
|
case XenbusStateClosed:
|
|
|
|
rc = xen_be_try_reset(xendev);
|
|
|
|
break;
|
2010-09-23 13:28:45 +02:00
|
|
|
default:
|
|
|
|
rc = -1;
|
|
|
|
}
|
|
|
|
if (rc != 0) {
|
|
|
|
break;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
|
|
|
|
{
|
|
|
|
struct XenDevice *xendev;
|
|
|
|
char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
|
2013-10-10 16:25:52 +02:00
|
|
|
char **dev = NULL;
|
2009-04-22 17:19:15 +02:00
|
|
|
unsigned int cdev, j;
|
|
|
|
|
|
|
|
/* setup watch */
|
|
|
|
snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops);
|
2013-10-10 16:25:52 +02:00
|
|
|
snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
|
2009-04-22 17:19:15 +02:00
|
|
|
if (!xs_watch(xenstore, path, token)) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n",
|
2016-10-25 07:50:08 +02:00
|
|
|
path);
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* look for backends */
|
|
|
|
dev = xs_directory(xenstore, 0, path, &cdev);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (!dev) {
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
for (j = 0; j < cdev; j++) {
|
2010-09-23 13:28:45 +02:00
|
|
|
xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops);
|
|
|
|
if (xendev == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
xen_be_check_state(xendev);
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
free(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-25 07:50:10 +02:00
|
|
|
void xenstore_update_be(char *watch, char *type, int dom,
|
|
|
|
struct XenDevOps *ops)
|
2009-04-22 17:19:15 +02:00
|
|
|
{
|
|
|
|
struct XenDevice *xendev;
|
2013-10-10 16:25:52 +02:00
|
|
|
char path[XEN_BUFSIZE], *bepath;
|
2009-04-22 17:19:15 +02:00
|
|
|
unsigned int len, dev;
|
|
|
|
|
2013-10-10 16:25:52 +02:00
|
|
|
len = snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (strncmp(path, watch, len) != 0) {
|
|
|
|
return;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
if (sscanf(watch+len, "/%u/%255s", &dev, path) != 2) {
|
2010-09-23 13:28:45 +02:00
|
|
|
strcpy(path, "");
|
|
|
|
if (sscanf(watch+len, "/%u", &dev) != 1) {
|
|
|
|
dev = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (dev == -1) {
|
|
|
|
return;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
xendev = xen_be_get_xendev(type, dom, dev, ops);
|
|
|
|
if (xendev != NULL) {
|
2012-03-30 16:33:03 +02:00
|
|
|
bepath = xs_read(xenstore, 0, xendev->be, &len);
|
|
|
|
if (bepath == NULL) {
|
2016-10-25 07:50:19 +02:00
|
|
|
xen_pv_del_xendev(xendev);
|
2012-03-30 16:33:03 +02:00
|
|
|
} else {
|
|
|
|
free(bepath);
|
|
|
|
xen_be_backend_changed(xendev, path);
|
|
|
|
xen_be_check_state(xendev);
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-25 07:50:10 +02:00
|
|
|
void xenstore_update_fe(char *watch, struct XenDevice *xendev)
|
2009-04-22 17:19:15 +02:00
|
|
|
{
|
|
|
|
char *node;
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
len = strlen(xendev->fe);
|
2010-09-23 13:28:45 +02:00
|
|
|
if (strncmp(xendev->fe, watch, len) != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (watch[len] != '/') {
|
|
|
|
return;
|
|
|
|
}
|
2009-04-22 17:19:15 +02:00
|
|
|
node = watch + len + 1;
|
|
|
|
|
|
|
|
xen_be_frontend_changed(xendev, node);
|
|
|
|
xen_be_check_state(xendev);
|
|
|
|
}
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
int xen_be_init(void)
|
|
|
|
{
|
|
|
|
xenstore = xs_daemon_open();
|
|
|
|
if (!xenstore) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
|
|
|
|
2015-06-04 08:45:22 +02:00
|
|
|
qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL);
|
2009-04-22 17:19:15 +02:00
|
|
|
|
2016-02-10 12:07:03 +01:00
|
|
|
if (xen_xc == NULL || xen_fmem == NULL) {
|
2010-08-19 13:27:56 +02:00
|
|
|
/* Check if xen_init() have been called */
|
2010-09-23 13:28:45 +02:00
|
|
|
goto err;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
2016-06-13 11:12:21 +02:00
|
|
|
|
|
|
|
xen_sysdev = qdev_create(NULL, TYPE_XENSYSDEV);
|
|
|
|
qdev_init_nofail(xen_sysdev);
|
2016-11-22 07:10:56 +01:00
|
|
|
xen_sysbus = qbus_create(TYPE_XENSYSBUS, DEVICE(xen_sysdev), "xen-sysbus");
|
|
|
|
qbus_set_bus_hotplug_handler(xen_sysbus, &error_abort);
|
2016-06-13 11:12:21 +02:00
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
qemu_set_fd_handler(xs_fileno(xenstore), NULL, NULL, NULL);
|
|
|
|
xs_daemon_close(xenstore);
|
|
|
|
xenstore = NULL;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-11-22 07:10:58 +01:00
|
|
|
static void xen_set_dynamic_sysbus(void)
|
|
|
|
{
|
|
|
|
Object *machine = qdev_get_machine();
|
|
|
|
ObjectClass *oc = object_get_class(machine);
|
|
|
|
MachineClass *mc = MACHINE_CLASS(oc);
|
|
|
|
|
|
|
|
mc->has_dynamic_sysbus = true;
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
int xen_be_register(const char *type, struct XenDevOps *ops)
|
|
|
|
{
|
2016-05-12 16:13:40 +02:00
|
|
|
char path[50];
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (ops->backend_register) {
|
|
|
|
rc = ops->backend_register();
|
|
|
|
if (rc) {
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid,
|
|
|
|
type);
|
|
|
|
xenstore_mkdir(path, XS_PERM_NONE);
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
return xenstore_scan(type, xen_domid, ops);
|
|
|
|
}
|
|
|
|
|
2016-08-02 08:32:32 +02:00
|
|
|
void xen_be_register_common(void)
|
|
|
|
{
|
2016-11-22 07:10:58 +01:00
|
|
|
xen_set_dynamic_sysbus();
|
|
|
|
|
2016-08-02 08:32:32 +02:00
|
|
|
xen_be_register("console", &xen_console_ops);
|
|
|
|
xen_be_register("vkbd", &xen_kbdmouse_ops);
|
|
|
|
xen_be_register("qdisk", &xen_blkdev_ops);
|
|
|
|
#ifdef CONFIG_USB_LIBUSB
|
|
|
|
xen_be_register("qusb", &xen_usb_ops);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-04-22 17:19:15 +02:00
|
|
|
int xen_be_bind_evtchn(struct XenDevice *xendev)
|
|
|
|
{
|
2010-09-23 13:28:45 +02:00
|
|
|
if (xendev->local_port != -1) {
|
|
|
|
return 0;
|
|
|
|
}
|
2016-01-15 14:23:38 +01:00
|
|
|
xendev->local_port = xenevtchn_bind_interdomain
|
2010-09-23 13:28:45 +02:00
|
|
|
(xendev->evtchndev, xendev->dom, xendev->remote_port);
|
2009-04-22 17:19:15 +02:00
|
|
|
if (xendev->local_port == -1) {
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
|
2010-09-23 13:28:45 +02:00
|
|
|
return -1;
|
2009-04-22 17:19:15 +02:00
|
|
|
}
|
2016-10-25 07:50:14 +02:00
|
|
|
xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
|
2016-01-15 14:23:38 +01:00
|
|
|
qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
|
2016-10-25 07:50:17 +02:00
|
|
|
xen_pv_evtchn_event, NULL, xendev);
|
2009-04-22 17:19:15 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-13 11:12:21 +02:00
|
|
|
|
2016-11-22 07:10:58 +01:00
|
|
|
static Property xendev_properties[] = {
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void xendev_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
dc->props = xendev_properties;
|
|
|
|
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo xendev_type_info = {
|
|
|
|
.name = TYPE_XENBACKEND,
|
|
|
|
.parent = TYPE_XENSYSDEV,
|
|
|
|
.class_init = xendev_class_init,
|
|
|
|
.instance_size = sizeof(struct XenDevice),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void xen_sysbus_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
|
|
|
|
|
|
|
|
hc->unplug = qdev_simple_device_unplug_cb;
|
|
|
|
}
|
|
|
|
|
2016-11-22 07:10:56 +01:00
|
|
|
static const TypeInfo xensysbus_info = {
|
|
|
|
.name = TYPE_XENSYSBUS,
|
|
|
|
.parent = TYPE_BUS,
|
2016-11-22 07:10:58 +01:00
|
|
|
.class_init = xen_sysbus_class_init,
|
2016-11-22 07:10:56 +01:00
|
|
|
.interfaces = (InterfaceInfo[]) {
|
|
|
|
{ TYPE_HOTPLUG_HANDLER },
|
|
|
|
{ }
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-06-13 11:12:21 +02:00
|
|
|
static int xen_sysdev_init(SysBusDevice *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Property xen_sysdev_properties[] = {
|
|
|
|
{/* end of property list */},
|
|
|
|
};
|
|
|
|
|
|
|
|
static void xen_sysdev_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
|
|
|
|
|
|
|
|
k->init = xen_sysdev_init;
|
|
|
|
dc->props = xen_sysdev_properties;
|
2016-11-22 07:10:56 +01:00
|
|
|
dc->bus_type = TYPE_XENSYSBUS;
|
2016-06-13 11:12:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo xensysdev_info = {
|
|
|
|
.name = TYPE_XENSYSDEV,
|
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.instance_size = sizeof(SysBusDevice),
|
|
|
|
.class_init = xen_sysdev_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void xenbe_register_types(void)
|
|
|
|
{
|
2016-11-22 07:10:56 +01:00
|
|
|
type_register_static(&xensysbus_info);
|
2016-06-13 11:12:21 +02:00
|
|
|
type_register_static(&xensysdev_info);
|
2016-11-22 07:10:58 +01:00
|
|
|
type_register_static(&xendev_type_info);
|
2016-06-13 11:12:21 +02:00
|
|
|
}
|
|
|
|
|
2016-11-22 07:10:56 +01:00
|
|
|
type_init(xenbe_register_types)
|