xen-project/xen
1
0 Fork 1
mirror of https://github.com/xen-project/xen.git synced 2026-10-28 18:21:39 +01:00
Code Issues Activity
Files
df09dfb94de66f7523837c050616a382aa2c7d17
xen/tools/libs/light/libxl_usb.c
T
Paul Durrant e43780f15f libxl: s/pcidev/pci and remove DEFINE_DEVICE_TYPE_STRUCT_X 
The seemingly arbitrary use of 'pci' and 'pcidev' in the code in libxl_pci.c
is confusing and also compromises use of some macros used for other device
types. Indeed it seems that DEFINE_DEVICE_TYPE_STRUCT_X exists solely because
of this duality.

This patch purges use of 'pcidev' from the libxl internal code, but
unfortunately the 'pcidevs' and 'num_pcidevs' fields in 'libxl_domain_config'
are part of the API and need to be retained to avoid breaking callers,
particularly libvirt.

DEFINE_DEVICE_TYPE_STRUCT_X is still removed to avoid the special case in
libxl_pci.c but DEFINE_DEVICE_TYPE_STRUCT is given an extra 'array' argument
which is used to identify the fields in 'libxl_domain_config' relating to
the device type.

NOTE: Some of the more gross formatting errors (such as lack of spaces after
      keywords) that came into context have been fixed in libxl_pci.c.

Signed-off-by: Paul Durrant <pdurrant@amazon.com>
Acked-by: Wei Liu <wl@xen.org>
2020-12-15 16:24:16 +00:00

2159 lines
68 KiB
C
Raw Blame History

/*
* Copyright (C) 2015 SUSE LINUX Products GmbH, Nuernberg, Germany.
* Author Chunyan Liu <cyliu@suse.com>
*
* This program 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; version 2.1 only. with the special
* exception on linking described in file 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 Lesser General Public License for more details.
*/
#include "libxl_osdeps.h" /* must come before any other headers */
#include "libxl_internal.h"
#include <inttypes.h>
#include <xen/io/usbif.h>
#define USBBACK_INFO_PATH "/libxl/usbback"
#define USBHUB_CLASS_CODE 9
static int usbback_is_loaded(libxl__gc *gc)
{
int r;
struct stat st;
r = lstat(SYSFS_USBBACK_DRIVER, &st);
if (r == 0)
return 1;
if (r < 0 && errno == ENOENT)
return 0;
LOGE(ERROR, "Accessing %s", SYSFS_USBBACK_DRIVER);
return ERROR_FAIL;
}
static int libxl__device_usbctrl_setdefault(libxl__gc *gc, uint32_t domid,
libxl_device_usbctrl *usbctrl,
bool hotplug)
{
int rc;
libxl_domain_type domtype = libxl__domain_type(gc, domid);
if (usbctrl->type == LIBXL_USBCTRL_TYPE_AUTO) {
if (domtype != LIBXL_DOMAIN_TYPE_HVM) {
rc = usbback_is_loaded(gc);
if (rc < 0)
goto out;
usbctrl->type = rc ? LIBXL_USBCTRL_TYPE_PV
: LIBXL_USBCTRL_TYPE_QUSB;
} else {
/* FIXME: See if we can detect PV frontend */
usbctrl->type = LIBXL_USBCTRL_TYPE_DEVICEMODEL;
}
}
switch (usbctrl->type) {
case LIBXL_USBCTRL_TYPE_PV:
case LIBXL_USBCTRL_TYPE_QUSB:
if (!usbctrl->version)
usbctrl->version = 2;
if (usbctrl->version < 1 || usbctrl->version > 2) {
LOG(ERROR,
"USB version for paravirtualized devices must be 1 or 2");
rc = ERROR_INVAL;
goto out;
}
if (!usbctrl->ports)
usbctrl->ports = 8;
if (usbctrl->ports < 1 || usbctrl->ports > USBIF_MAX_PORTNR) {
LOG(ERROR, "Number of ports for USB controller is limited to %u",
USBIF_MAX_PORTNR);
rc = ERROR_INVAL;
goto out;
}
break;
case LIBXL_USBCTRL_TYPE_DEVICEMODEL:
if (!usbctrl->version)
usbctrl->version = 2;
switch (usbctrl->version) {
case 1:
/* uhci controller in qemu has fixed number of ports. */
if (usbctrl->ports && usbctrl->ports != 2) {
LOG(ERROR,
"Number of ports for USB controller of version 1 is always 2");
rc = ERROR_INVAL;
goto out;
}
usbctrl->ports = 2;
break;
case 2:
/* ehci controller in qemu has fixed number of ports. */
if (usbctrl->ports && usbctrl->ports != 6) {
LOG(ERROR,
"Number of ports for USB controller of version 2 is always 6");
rc = ERROR_INVAL;
goto out;
}
usbctrl->ports = 6;
break;
case 3:
if (!usbctrl->ports)
usbctrl->ports = 8;
/* xhci controller in qemu supports up to 15 ports. */
if (usbctrl->ports > 15) {
LOG(ERROR,
"Number of ports for USB controller of version 3 is limited to 15");
rc = ERROR_INVAL;
goto out;
}
break;
default:
LOG(ERROR, "Illegal USB version");
rc = ERROR_INVAL;
goto out;
}
break;
default:
break;
}
rc = libxl__resolve_domid(gc, usbctrl->backend_domname,
&usbctrl->backend_domid);
out:
return rc;
}
static int libxl__device_from_usbctrl(libxl__gc *gc, uint32_t domid,
libxl_device_usbctrl *usbctrl,
libxl__device *device)
{
device->backend_devid = usbctrl->devid;
device->backend_domid = usbctrl->backend_domid;
switch (usbctrl->type) {
case LIBXL_USBCTRL_TYPE_PV:
device->backend_kind = LIBXL__DEVICE_KIND_VUSB;
break;
case LIBXL_USBCTRL_TYPE_QUSB:
device->backend_kind = LIBXL__DEVICE_KIND_QUSB;
break;
case LIBXL_USBCTRL_TYPE_DEVICEMODEL:
device->backend_kind = LIBXL__DEVICE_KIND_NONE;
break;
default:
abort(); /* can't really happen. */
}
device->devid = usbctrl->devid;
device->domid = domid;
device->kind = LIBXL__DEVICE_KIND_VUSB;
return 0;
}
static const char *vusb_be_from_xs_libxl_type(libxl__gc *gc,
const char *libxl_path,
libxl_usbctrl_type type)
{
const char *be_path = NULL, *tmp;
int r;
if (type == LIBXL_USBCTRL_TYPE_AUTO) {
r = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/type", libxl_path), &tmp);
if (r || libxl_usbctrl_type_from_string(tmp, &type))
goto out;
}
if (type == LIBXL_USBCTRL_TYPE_DEVICEMODEL) {
be_path = libxl_path;
goto out;
}
r = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/backend", libxl_path),
&be_path);
if (r)
be_path = NULL;
out:
return be_path;
}
/* Add usbctrl information to xenstore.
*
* Adding a usb controller will add a new 'qusb' or 'vusb' device in xenstore,
* and add corresponding frontend, backend information to it. According to
* "update_json", decide whether to update json config file.
*/
static int libxl__device_usbctrl_add_xenstore(libxl__gc *gc, uint32_t domid,
libxl_device_usbctrl *usbctrl,
bool update_json)
{
libxl__device *device;
flexarray_t *front = NULL;
flexarray_t *back;
xs_transaction_t t = XBT_NULL;
int i, rc;
libxl_domain_config d_config;
libxl_device_usbctrl usbctrl_saved;
libxl__flock *lock = NULL;
libxl_domain_config_init(&d_config);
libxl_device_usbctrl_init(&usbctrl_saved);
libxl_device_usbctrl_copy(CTX, &usbctrl_saved, usbctrl);
GCNEW(device);
rc = libxl__device_from_usbctrl(gc, domid, usbctrl, device);
if (rc) goto out;
back = flexarray_make(gc, 12, 1);
if (device->backend_kind != LIBXL__DEVICE_KIND_NONE) {
front = flexarray_make(gc, 4, 1);
flexarray_append_pair(back, "frontend-id", GCSPRINTF("%d", domid));
flexarray_append_pair(back, "online", "1");
flexarray_append_pair(back, "state",
GCSPRINTF("%d", XenbusStateInitialising));
flexarray_append_pair(front, "backend-id",
GCSPRINTF("%d", usbctrl->backend_domid));
flexarray_append_pair(front, "state",
GCSPRINTF("%d", XenbusStateInitialising));
}
flexarray_append_pair(back, "type",
(char *)libxl_usbctrl_type_to_string(usbctrl->type));
flexarray_append_pair(back, "usb-ver", GCSPRINTF("%d", usbctrl->version));
flexarray_append_pair(back, "num-ports", GCSPRINTF("%d", usbctrl->ports));
flexarray_append_pair(back, "port", "");
for (i = 0; i < usbctrl->ports; i++)
flexarray_append_pair(back, GCSPRINTF("port/%d", i + 1), "");
if (update_json) {
lock = libxl__lock_domain_userdata(gc, domid);
if (!lock) {
rc = ERROR_LOCK_FAIL;
goto out;
}
rc = libxl__get_domain_configuration(gc, domid, &d_config);
if (rc) goto out;
device_add_domain_config(gc, &d_config, &libxl__usbctrl_devtype,
&usbctrl_saved);
rc = libxl__dm_check_start(gc, &d_config, domid);
if (rc) goto out;
if (usbctrl->type == LIBXL_USBCTRL_TYPE_QUSB) {
if (!libxl__query_qemu_backend(gc, domid, usbctrl->backend_domid,
"qusb", false)) {
LOGD(ERROR, domid, "backend type not supported by device model");
rc = ERROR_FAIL;
goto out;
}
}
}
for (;;) {
rc = libxl__xs_transaction_start(gc, &t);
if (rc) goto out;
rc = libxl__device_exists(gc, t, device);
if (rc < 0) goto out;
if (rc == 1) {
/* already exists in xenstore */
LOGD(ERROR, domid, "device already exists in xenstore");
rc = ERROR_DEVICE_EXISTS;
goto out;
}
if (update_json) {
rc = libxl__set_domain_configuration(gc, domid, &d_config);
if (rc) goto out;
}
libxl__device_generic_add(gc, t, device,
libxl__xs_kvs_of_flexarray(gc, back),
libxl__xs_kvs_of_flexarray(gc, front),
NULL);
rc = libxl__xs_transaction_commit(gc, &t);
if (!rc) break;
if (rc < 0) goto out;
}
out:
libxl__xs_transaction_abort(gc, &t);
if (lock) libxl__unlock_file(lock);
libxl_device_usbctrl_dispose(&usbctrl_saved);
libxl_domain_config_dispose(&d_config);
return rc;
}
static const char *vusb_be_from_xs_libxl(libxl__gc *gc, const char *libxl_path)
{
return vusb_be_from_xs_libxl_type(gc, libxl_path, LIBXL_USBCTRL_TYPE_AUTO);
}
static void libxl__device_usbctrl_del_xenstore(libxl__gc *gc, uint32_t domid,
libxl_device_usbctrl *usbctrl)
{
const char *libxl_path, *be_path;
xs_transaction_t t = XBT_NULL;
int rc;
libxl_path = libxl__domain_device_libxl_path(gc, domid, usbctrl->devid,
LIBXL__DEVICE_KIND_VUSB);
be_path = vusb_be_from_xs_libxl_type(gc, libxl_path, usbctrl->type);
for (;;) {
rc = libxl__xs_transaction_start(gc, &t);
if (rc) goto out;
libxl__xs_path_cleanup(gc, t, be_path);
rc = libxl__xs_transaction_commit(gc, &t);
if (!rc) break;
if (rc < 0) goto out;
}
return;
out:
libxl__xs_transaction_abort(gc, &t);
}
static char *pvusb_get_device_type(libxl_usbctrl_type type)
{
switch (type) {
case LIBXL_USBCTRL_TYPE_PV:
return "vusb";
case LIBXL_USBCTRL_TYPE_QUSB:
return "qusb";
default:
return NULL;
}
}
/* Send qmp commands to create a usb controller in qemu.
*
* Depending on the speed (usbctrl->version) we create:
* - piix3-usb-uhci (version=1), always 2 ports
* - usb-ehci (version=2), always 6 ports
* - nec-usb-xhci (version=3), up to 15 ports
*/
static int libxl__device_usbctrl_add_hvm(libxl__egc *egc, libxl__ev_qmp *qmp,
libxl_device_usbctrl *usbctrl)
{
EGC_GC;
libxl__json_object *qmp_args = NULL;
switch (usbctrl->version) {
case 1:
libxl__qmp_param_add_string(gc, &qmp_args,
"driver", "piix3-usb-uhci");
break;
case 2:
libxl__qmp_param_add_string(gc, &qmp_args,
"driver", "usb-ehci");
break;
case 3:
libxl__qmp_param_add_string(gc, &qmp_args,
"driver", "nec-usb-xhci");
libxl__qmp_param_add_string(gc, &qmp_args, "p2",
GCSPRINTF("%d", usbctrl->ports));
libxl__qmp_param_add_string(gc, &qmp_args, "p3",
GCSPRINTF("%d", usbctrl->ports));
break;
default:
abort(); /* Should not be possible. */
}
libxl__qmp_param_add_string(gc, &qmp_args, "id",
GCSPRINTF("xenusb-%d", usbctrl->devid));
return libxl__ev_qmp_send(egc, qmp, "device_add", qmp_args);
}
/* Send qmp commands to delete a usb controller in qemu. */
static int libxl__device_usbctrl_del_hvm(libxl__egc *egc,
libxl__ev_qmp *qmp,
int devid)
{
EGC_GC;
libxl__json_object *qmp_args = NULL;
libxl__qmp_param_add_string(gc, &qmp_args,
"id", GCSPRINTF("xenusb-%d", devid));
return libxl__ev_qmp_send(egc, qmp, "device_del", qmp_args);
}
/* Send qmp commands to create a usb device in qemu. */
static int libxl__device_usbdev_add_hvm(libxl__egc *egc, libxl__ev_qmp *qmp,
libxl_device_usbdev *usbdev)
{
EGC_GC;
libxl__json_object *qmp_args = NULL;
libxl__qmp_param_add_string(gc, &qmp_args, "id",
GCSPRINTF("xenusb-%d-%d", usbdev->u.hostdev.hostbus,
usbdev->u.hostdev.hostaddr));
libxl__qmp_param_add_string(gc, &qmp_args, "driver", "usb-host");
libxl__qmp_param_add_string(gc, &qmp_args, "bus",
GCSPRINTF("xenusb-%d.0", usbdev->ctrl));
libxl__qmp_param_add_string(gc, &qmp_args, "port",
GCSPRINTF("%d", usbdev->port));
libxl__qmp_param_add_string(gc, &qmp_args, "hostbus",
GCSPRINTF("%d", usbdev->u.hostdev.hostbus));
libxl__qmp_param_add_string(gc, &qmp_args, "hostaddr",
GCSPRINTF("%d", usbdev->u.hostdev.hostaddr));
return libxl__ev_qmp_send(egc, qmp, "device_add", qmp_args);
}
/* Send qmp commands to delete a usb device in qemu. */
static int libxl__device_usbdev_del_hvm(libxl__egc *egc, libxl__ev_qmp *qmp,
libxl_device_usbdev *usbdev)
{
EGC_GC;
libxl__json_object *qmp_args = NULL;
libxl__qmp_param_add_string(gc, &qmp_args, "id",
GCSPRINTF("xenusb-%d-%d", usbdev->u.hostdev.hostbus,
usbdev->u.hostdev.hostaddr));
return libxl__ev_qmp_send(egc, qmp, "device_del", qmp_args);
}
static LIBXL_DEFINE_UPDATE_DEVID(usbctrl)
static void device_usbctrl_add_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc);
static void device_usbctrl_add_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp, const libxl__json_object *r, int rc);
static void device_usbctrl_add_done(libxl__egc *egc,
libxl__ao_device *aodev, int rc);
/* AO operation to add a usb controller.
*
* Generally, it does:
* 1) fill in necessary usb controler information with default value
* 2) write usb controller frontend/backend info to xenstore, update json
* config file if necessary.
* 3) wait for device connection. PVUSB frontend and backend driver will
* probe xenstore paths and build connection between frontend and backend.
*
* Before calling this function, aodev should be properly filled:
* aodev->ao, aodev->callback, aodev->update_json, ...
*/
static void libxl__device_usbctrl_add(libxl__egc *egc, uint32_t domid,
libxl_device_usbctrl *usbctrl,
libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
libxl__device *device;
int rc;
/* Store *usbctrl to be used by callbacks */
aodev->device_config = usbctrl;
aodev->device_type = &libxl__usbctrl_devtype;
rc = libxl__device_usbctrl_setdefault(gc, domid, usbctrl,
aodev->update_json);
if (rc < 0) goto out;
rc = libxl__device_usbctrl_update_devid(gc, domid, usbctrl);
if (rc) goto out;
rc = libxl__device_usbctrl_add_xenstore(gc, domid, usbctrl,
aodev->update_json);
if (rc) goto out;
GCNEW(device);
rc = libxl__device_from_usbctrl(gc, domid, usbctrl, device);
if (rc) goto outrm;
aodev->dev = device;
if (device->backend_kind == LIBXL__DEVICE_KIND_NONE) {
libxl__ev_qmp *const qmp = &aodev->qmp;
rc = libxl__ev_time_register_rel(ao, &aodev->timeout,
device_usbctrl_add_timeout,
LIBXL_QMP_CMD_TIMEOUT * 1000);
if (rc) goto outrm;
qmp->ao = ao;
qmp->domid = domid;
qmp->payload_fd = -1;
qmp->callback = device_usbctrl_add_qmp_cb;
rc = libxl__device_usbctrl_add_hvm(egc, qmp, usbctrl);
if (rc) goto outrm;
return;
}
aodev->action = LIBXL__DEVICE_ACTION_ADD;
libxl__wait_device_connection(egc, aodev);
return;
outrm:
libxl__device_usbctrl_del_xenstore(gc, domid, usbctrl);
out:
device_usbctrl_add_done(egc, aodev, rc);
}
static void device_usbctrl_add_timeout(libxl__egc *egc, libxl__ev_time *ev,
const struct timeval *requested_abs,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(ev, *aodev, timeout);
if (rc == ERROR_TIMEDOUT)
LOGD(ERROR, aodev->dev->domid, "Adding usbctrl to QEMU timed out");
device_usbctrl_add_qmp_cb(egc, &aodev->qmp, NULL, rc);
}
static void device_usbctrl_add_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp,
const libxl__json_object *r,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(qmp, *aodev, qmp);
libxl_device_usbctrl *const usbctrl = aodev->device_config;
if (rc)
libxl__device_usbctrl_del_xenstore(gc, aodev->dev->domid, usbctrl);
device_usbctrl_add_done(egc, aodev, rc);
}
static void device_usbctrl_add_done(libxl__egc *egc,
libxl__ao_device *aodev,
int rc)
{
EGC_GC;
libxl__ev_qmp_dispose(gc, &aodev->qmp);
libxl__ev_time_deregister(gc, &aodev->timeout);
aodev->rc = rc;
aodev->callback(egc, aodev);
}
LIBXL_DEFINE_DEVICE_ADD(usbctrl)
static LIBXL_DEFINE_DEVICES_ADD(usbctrl)
LIBXL_DEFINE_DEVICE_REMOVE_CUSTOM(usbctrl)
static int libxl__device_usbdev_list_for_usbctrl(libxl__gc *gc, uint32_t domid,
libxl_devid usbctrl,
libxl_device_usbdev **usbdevs,
int *num);
static void libxl__device_usbdev_remove(libxl__egc *egc,
uint32_t domid, libxl_device_usbdev *usbdev, libxl__ao_device *aodev);
static void device_usbctrl_usbdevs_removed(libxl__egc *,
libxl__multidev *, int rc);
static void device_usbctrl_remove_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc);
static void device_usbctrl_remove_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp, const libxl__json_object *resp, int rc);
static void device_usbctrl_remove_done(libxl__egc *egc,
libxl__ao_device *, int rc);
typedef struct {
libxl__multidev multidev;
libxl__ao_device *aodev;
} usbctrl_remove_state;
/* AO function to remove a usb controller.
*
* Generally, it does:
* 1) check if the usb controller exists or not
* 2) remove all usb devices under controller
* 3) remove usb controller information from xenstore
*
* Before calling this function, aodev should be properly filled:
* aodev->ao, aodev->dev, aodev->callback, ...
*/
void libxl__initiate_device_usbctrl_remove(libxl__egc *egc,
libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
libxl_device_usbdev *usbdevs = NULL;
int num_usbdev = 0;
int i, rc;
uint32_t domid = aodev->dev->domid;
int usbctrl_devid = aodev->dev->devid;
libxl_device_usbctrl *usbctrl;
usbctrl_remove_state *ucrs;
GCNEW(ucrs);
ucrs->aodev = aodev;
ucrs->multidev.callback = device_usbctrl_usbdevs_removed;
libxl__multidev_begin(ao, &ucrs->multidev);
GCNEW(usbctrl);
libxl_device_usbctrl_init(usbctrl);
rc = libxl_devid_to_device_usbctrl(CTX, domid, usbctrl_devid,
usbctrl);
if (rc) goto out;
/* Store *usbctrl to be used by callbacks */
aodev->device_config = usbctrl;
aodev->device_type = &libxl__usbctrl_devtype;
/* Remove usb devices first */
rc = libxl__device_usbdev_list_for_usbctrl(gc, domid, usbctrl_devid,
&usbdevs, &num_usbdev);
if (rc) goto out;
for (i = 0; i < num_usbdev; i++) {
libxl__ao_device *usbdev_aodev =
libxl__multidev_prepare(&ucrs->multidev);
usbdev_aodev->action = LIBXL__DEVICE_ACTION_REMOVE;
libxl__device_usbdev_remove(egc, domid, &usbdevs[i], usbdev_aodev);
}
out:
libxl__multidev_prepared(egc, &ucrs->multidev, rc); /* must be last */
}
static void device_usbctrl_usbdevs_removed(libxl__egc *egc,
libxl__multidev *multidev,
int rc)
{
usbctrl_remove_state *ucrs =
CONTAINER_OF(multidev, *ucrs, multidev);
libxl__ao_device *aodev = ucrs->aodev;
STATE_AO_GC(aodev->ao);
libxl_device_usbctrl *const usbctrl = aodev->device_config;
if (rc) goto out;
/* Remove usbctrl */
if (usbctrl->type == LIBXL_USBCTRL_TYPE_DEVICEMODEL) {
libxl__ev_qmp *const qmp = &aodev->qmp;
rc = libxl__ev_time_register_rel(ao, &aodev->timeout,
device_usbctrl_remove_timeout,
LIBXL_QMP_CMD_TIMEOUT * 1000);
if (rc) goto out;
qmp->ao = ao;
qmp->domid = aodev->dev->domid;
qmp->callback = device_usbctrl_remove_qmp_cb;
qmp->payload_fd = -1;
rc = libxl__device_usbctrl_del_hvm(egc, qmp, aodev->dev->devid);
if (rc) goto out;
return;
}
libxl_device_usbctrl_dispose(usbctrl);
/* Remove usbctrl */
libxl__initiate_device_generic_remove(egc, aodev); /* must be last */
return;
out:
device_usbctrl_remove_done(egc, aodev, rc); /* must be last */
}
static void device_usbctrl_remove_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(ev, *aodev, timeout);
if (rc == ERROR_TIMEDOUT)
LOGD(ERROR, aodev->dev->domid,
"Removing usbctrl from QEMU timed out");
device_usbctrl_remove_qmp_cb(egc, &aodev->qmp, NULL, rc);
}
static void device_usbctrl_remove_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp,
const libxl__json_object *resp,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(qmp, *aodev, qmp);
libxl_device_usbctrl *const usbctrl = aodev->device_config;
if (!rc)
libxl__device_usbctrl_del_xenstore(gc, aodev->dev->domid, usbctrl);
device_usbctrl_remove_done(egc, aodev, rc);
}
static void device_usbctrl_remove_done(libxl__egc *egc,
libxl__ao_device *aodev,
int rc)
{
EGC_GC;
libxl_device_usbctrl *const usbctrl = aodev->device_config;
libxl_device_usbctrl_dispose(usbctrl);
libxl__ev_qmp_dispose(gc, &aodev->qmp);
libxl__ev_time_deregister(gc, &aodev->timeout);
aodev->rc = rc;
aodev->callback(egc, aodev);
}
static int libxl__usbctrl_from_xenstore(libxl__gc *gc,
const char *libxl_path,
libxl_devid devid,
libxl_device_usbctrl *usbctrl_r)
{
int rc;
const char *tmp;
const char *be_path;
#define READ_SUBPATH(path, subpath) ({ \
rc = libxl__xs_read_checked(gc, XBT_NULL, \
GCSPRINTF("%s/" subpath, path), \
&tmp); \
if (rc) goto out; \
(char *)tmp; \
})
#define READ_SUBPATH_INT(path, subpath) ({ \
rc = libxl__xs_read_checked(gc, XBT_NULL, \
GCSPRINTF("%s/" subpath, path), \
&tmp); \
if (rc) goto out; \
tmp ? atoi(tmp) : -1; \
})
usbctrl_r->devid = devid;
libxl_usbctrl_type_from_string(READ_SUBPATH(libxl_path, "type"),
&usbctrl_r->type);
if (usbctrl_r->type == LIBXL_USBCTRL_TYPE_DEVICEMODEL) {
be_path = libxl_path;
rc = libxl__get_domid(gc, &usbctrl_r->backend_domid);
} else {
be_path = READ_SUBPATH(libxl_path, "backend");
if (!be_path) goto out;
rc = libxl__backendpath_parse_domid(gc, be_path,
&usbctrl_r->backend_domid);
}
if (rc) goto out;
usbctrl_r->version = READ_SUBPATH_INT(be_path, "usb-ver");
usbctrl_r->ports = READ_SUBPATH_INT(be_path, "num-ports");
#undef READ_SUBPATH
#undef READ_SUBPATH_INT
out:
if (rc)
libxl_device_usbctrl_dispose(usbctrl_r);
return rc;
}
int libxl_device_usbctrl_getinfo(libxl_ctx *ctx, uint32_t domid,
const libxl_device_usbctrl *usbctrl,
libxl_usbctrlinfo *usbctrlinfo)
{
GC_INIT(ctx);
const char *fe_path, *be_path, *tmp;
const char *libxl_path;
int rc;
usbctrlinfo->devid = usbctrl->devid;
#define READ_SUBPATH(path, subpath) ({ \
rc = libxl__xs_read_mandatory(gc, XBT_NULL, \
GCSPRINTF("%s/" subpath, path), \
&tmp); \
if (rc) goto out; \
(char *)tmp; \
})
#define READ_SUBPATH_INT(path, subpath) ({ \
rc = libxl__xs_read_checked(gc, XBT_NULL, \
GCSPRINTF("%s/" subpath, path), \
&tmp); \
if (rc) goto out; \
tmp ? atoi(tmp) : -1; \
})
libxl_path = libxl__domain_device_libxl_path(gc, domid, usbctrl->devid,
LIBXL__DEVICE_KIND_VUSB);
libxl_usbctrl_type_from_string(READ_SUBPATH(libxl_path, "type"),
&usbctrlinfo->type);
if (usbctrlinfo->type != LIBXL_USBCTRL_TYPE_DEVICEMODEL) {
fe_path = libxl__domain_device_frontend_path(gc, domid, usbctrl->devid,
LIBXL__DEVICE_KIND_VUSB);
be_path = READ_SUBPATH(libxl_path, "backend");
usbctrlinfo->backend = libxl__strdup(NOGC, be_path);
rc = libxl__backendpath_parse_domid(gc, be_path,
&usbctrlinfo->backend_id);
if (rc) goto out;
usbctrlinfo->state = READ_SUBPATH_INT(fe_path, "state");
usbctrlinfo->evtch = READ_SUBPATH_INT(fe_path, "event-channel");
usbctrlinfo->ref_urb = READ_SUBPATH_INT(fe_path, "urb-ring-ref");
usbctrlinfo->ref_conn = READ_SUBPATH_INT(fe_path, "urb-ring-ref");
usbctrlinfo->frontend = libxl__strdup(NOGC, fe_path);
usbctrlinfo->frontend_id = domid;
usbctrlinfo->ports = READ_SUBPATH_INT(be_path, "num-ports");
usbctrlinfo->version = READ_SUBPATH_INT(be_path, "usb-ver");
} else {
usbctrlinfo->ports = READ_SUBPATH_INT(libxl_path, "num-ports");
usbctrlinfo->version = READ_SUBPATH_INT(libxl_path, "usb-ver");
rc = libxl__get_domid(gc, &usbctrlinfo->backend_id);
if (rc) goto out;
}
#undef READ_SUBPATH
#undef READ_SUBPATH_INT
rc = 0;
out:
GC_FREE;
return rc;
}
static char *usbdev_busaddr_to_busid(libxl__gc *gc, int bus, int addr)
{
DIR *dir;
char *busid = NULL;
struct dirent *de;
/* invalid hostbus or hostaddr */
if (bus < 1 || addr < 1)
return NULL;
dir = opendir(SYSFS_USB_DEV);
if (!dir) {
LOGE(ERROR, "opendir failed: '%s'", SYSFS_USB_DEV);
return NULL;
}
for (;;) {
char *filename;
void *buf;
int busnum = -1;
int devnum = -1;
errno = 0;
de = readdir(dir);
if (!de && errno) {
LOGE(ERROR, "failed to readdir %s", SYSFS_USB_DEV);
break;
}
if (!de)
break;
if (!strcmp(de->d_name, ".") ||
!strcmp(de->d_name, ".."))
continue;
filename = GCSPRINTF(SYSFS_USB_DEV "/%s/devnum", de->d_name);
if (!libxl__read_sysfs_file_contents(gc, filename, &buf, NULL))
devnum = atoi(buf);
filename = GCSPRINTF(SYSFS_USB_DEV "/%s/busnum", de->d_name);
if (!libxl__read_sysfs_file_contents(gc, filename, &buf, NULL))
busnum = atoi(buf);
if (bus == busnum && addr == devnum) {
busid = libxl__strdup(gc, de->d_name);
break;
}
}
closedir(dir);
return busid;
}
static int usbdev_busaddr_from_busid(libxl__gc *gc, const char *busid,
uint8_t *bus, uint8_t *addr)
{
char *filename;
void *buf;
filename = GCSPRINTF(SYSFS_USB_DEV "/%s/busnum", busid);
if (!libxl__read_sysfs_file_contents(gc, filename, &buf, NULL))
*bus = atoi(buf);
else
return ERROR_FAIL;
filename = GCSPRINTF(SYSFS_USB_DEV "/%s/devnum", busid);
if (!libxl__read_sysfs_file_contents(gc, filename, &buf, NULL))
*addr = atoi(buf);
else
return ERROR_FAIL;
return 0;
}
static int get_assigned_devices(libxl__gc *gc,
libxl_device_usbdev **list, int *num)
{
char **domlist;
unsigned int ndom = 0;
int i, j, k;
int rc;
*list = NULL;
*num = 0;
domlist = libxl__xs_directory(gc, XBT_NULL, "/local/domain", &ndom);
for (i = 0; i < ndom; i++) {
char *libxl_vusbs_path;
char **usbctrls;
unsigned int nc = 0;
uint32_t domid = atoi(domlist[i]);
libxl_vusbs_path = GCSPRINTF("%s/device/%s",
libxl__xs_libxl_path(gc, domid),
libxl__device_kind_to_string(LIBXL__DEVICE_KIND_VUSB));
usbctrls = libxl__xs_directory(gc, XBT_NULL,
libxl_vusbs_path, &nc);
for (j = 0; j < nc; j++) {
libxl_device_usbdev *tmp = NULL;
int nd = 0;
rc = libxl__device_usbdev_list_for_usbctrl(gc, domid,
atoi(usbctrls[j]),
&tmp, &nd);
if (rc) goto out;
if (!nd) continue;
GCREALLOC_ARRAY(*list, *num + nd);
for (k = 0; k < nd; k++) {
libxl_device_usbdev_copy(CTX, *list + *num, tmp + k);
(*num)++;
}
}
}
return 0;
out:
LOG(ERROR, "fail to get assigned devices");
return rc;
}
static bool is_usbdev_in_array(libxl_device_usbdev *usbdevs, int num,
libxl_device_usbdev *usbdev)
{
int i;
for (i = 0; i < num; i++) {
if (usbdevs[i].u.hostdev.hostbus == usbdev->u.hostdev.hostbus &&
usbdevs[i].u.hostdev.hostaddr == usbdev->u.hostdev.hostaddr)
return true;
}
return false;
}
/* check if USB device type is assignable */
static bool is_usbdev_assignable(libxl__gc *gc, libxl_device_usbdev *usbdev)
{
int classcode;
char *filename;
void *buf = NULL;
char *busid = NULL;
busid = usbdev_busaddr_to_busid(gc, usbdev->u.hostdev.hostbus,
usbdev->u.hostdev.hostaddr);
if (!busid) return false;
filename = GCSPRINTF(SYSFS_USB_DEV "/%s/bDeviceClass", busid);
if (libxl__read_sysfs_file_contents(gc, filename, &buf, NULL))
return false;
classcode = atoi(buf);
return classcode != USBHUB_CLASS_CODE;
}
/* get usb devices under certain usb controller */
static int
libxl__device_usbdev_list_for_usbctrl(libxl__gc *gc,
uint32_t domid,
libxl_devid usbctrl,
libxl_device_usbdev **usbdevs,
int *num)
{
const char *libxl_path, *be_path, *num_devs;
int n, i, rc;
*usbdevs = NULL;
*num = 0;
libxl_path = libxl__domain_device_libxl_path(gc, domid, usbctrl,
LIBXL__DEVICE_KIND_VUSB);
be_path = vusb_be_from_xs_libxl(gc, libxl_path);
if (!be_path) {
rc = ERROR_FAIL;
goto out;
}
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/num-ports", be_path),
&num_devs);
if (rc) goto out;
n = num_devs ? atoi(num_devs) : 0;
for (i = 0; i < n; i++) {
const char *busid;
libxl_device_usbdev *usbdev;
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/port/%d", be_path, i + 1),
&busid);
if (rc) goto out;
if (busid && strcmp(busid, "")) {
GCREALLOC_ARRAY(*usbdevs, *num + 1);
usbdev = *usbdevs + *num;
(*num)++;
libxl_device_usbdev_init(usbdev);
usbdev->ctrl = usbctrl;
usbdev->port = i + 1;
usbdev->type = LIBXL_USBDEV_TYPE_HOSTDEV;
rc = usbdev_busaddr_from_busid(gc, busid,
&usbdev->u.hostdev.hostbus,
&usbdev->u.hostdev.hostaddr);
if (rc) goto out;
}
}
rc = 0;
out:
return rc;
}
/* get all usb devices of the domain */
libxl_device_usbdev *
libxl_device_usbdev_list(libxl_ctx *ctx, uint32_t domid, int *num)
{
GC_INIT(ctx);
libxl_device_usbdev *usbdevs = NULL;
const char *libxl_vusbs_path;
char **usbctrls;
unsigned int nc = 0;
int i, j;
*num = 0;
libxl_vusbs_path = GCSPRINTF("%s/device/%s",
libxl__xs_libxl_path(gc, domid),
libxl__device_kind_to_string(
LIBXL__DEVICE_KIND_VUSB));
usbctrls = libxl__xs_directory(gc, XBT_NULL, libxl_vusbs_path, &nc);
for (i = 0; i < nc; i++) {
int rc, nd = 0;
libxl_device_usbdev *tmp = NULL;
rc = libxl__device_usbdev_list_for_usbctrl(gc, domid,
atoi(usbctrls[i]),
&tmp, &nd);
if (rc || !nd) continue;
usbdevs = libxl__realloc(NOGC, usbdevs,
sizeof(*usbdevs) * (*num + nd));
for (j = 0; j < nd; j++) {
libxl_device_usbdev_copy(ctx, usbdevs + *num, tmp + j);
(*num)++;
}
}
GC_FREE;
return usbdevs;
}
static char *vusb_get_port_path(libxl__gc *gc, uint32_t domid,
libxl_usbctrl_type type, int ctrl, int port)
{
char *path;
if (type == LIBXL_USBCTRL_TYPE_DEVICEMODEL)
path = GCSPRINTF("%s/device/%s", libxl__xs_libxl_path(gc, domid),
libxl__device_kind_to_string(LIBXL__DEVICE_KIND_VUSB));
else
path = GCSPRINTF("%s/backend/%s/%d",
libxl__xs_get_dompath(gc, LIBXL_TOOLSTACK_DOMID),
pvusb_get_device_type(type), domid);
return GCSPRINTF("%s/%d/port/%d", path, ctrl, port);
}
/* find first unused controller:port and give that to usb device */
static int
libxl__device_usbdev_set_default_usbctrl(libxl__gc *gc, uint32_t domid,
libxl_device_usbdev *usbdev)
{
libxl_device_usbctrl *usbctrls = NULL;
int numctrl = 0;
int i, j, rc;
usbctrls = libxl_device_usbctrl_list(CTX, domid, &numctrl);
if (!numctrl || !usbctrls) {
rc = ERROR_FAIL;
goto out;
}
for (i = 0; i < numctrl; i++) {
for (j = 0; j < usbctrls[i].ports; j++) {
const char *path, *tmp;
path = vusb_get_port_path(gc, domid, usbctrls[i].type,
usbctrls[i].devid, j + 1);
rc = libxl__xs_read_checked(gc, XBT_NULL, path, &tmp);
if (rc) goto out;
if (tmp && !strcmp(tmp, "")) {
usbdev->ctrl = usbctrls[i].devid;
usbdev->port = j + 1;
rc = 0;
goto out;
}
}
}
/* no available controller:port */
rc = ERROR_FAIL;
out:
libxl_device_usbctrl_list_free(usbctrls, numctrl);
return rc;
}
/* Fill in usb information with default value.
*
* Generally, it does:
* 1) if "controller" is not specified:
* - if "port" is not specified, try to find an available controller:port,
* if found, use that; otherwise, create a new controller, use this
* controller and its first port
* - if "port" is specified, report error.
* 2) if "controller" is specified, but port is not specified:
* try to find an available port under this controller, if found, use
* that, otherwise, report error.
* 3) if both "controller" and "port" are specified:
* check the controller:port is available, if not, report error.
*/
static int libxl__device_usbdev_setdefault(libxl__gc *gc,
uint32_t domid,
libxl_device_usbdev *usbdev,
bool update_json)
{
int rc;
if (!usbdev->type)
usbdev->type = LIBXL_USBDEV_TYPE_HOSTDEV;
if (usbdev->ctrl == -1) {
if (usbdev->port) {
LOGD(ERROR, domid,
"USB controller must be specified if you specify port");
return ERROR_INVAL;
}
rc = libxl__device_usbdev_set_default_usbctrl(gc, domid, usbdev);
/* If no existing controller to host this usb device, add a new one */
if (rc) {
libxl_device_usbctrl *usbctrl;
GCNEW(usbctrl);
libxl_device_usbctrl_init(usbctrl);
rc = libxl__device_usbctrl_setdefault(gc, domid, usbctrl,
update_json);
if (rc < 0) goto out;
rc = libxl__device_usbctrl_update_devid(gc, domid, usbctrl);
if (rc) goto out;
rc = libxl__device_usbctrl_add_xenstore(gc, domid, usbctrl,
update_json);
if (rc) goto out;
usbdev->ctrl = usbctrl->devid;
usbdev->port = 1;
}
} else {
/* A controller was specified; look it up */
const char *libxl_path, *be_path, *tmp;
libxl_path = libxl__domain_device_libxl_path(gc, domid, usbdev->ctrl,
LIBXL__DEVICE_KIND_VUSB);
be_path = vusb_be_from_xs_libxl(gc, libxl_path);
if (!be_path) {
rc = ERROR_FAIL;
goto out;
}
if (usbdev->port) {
/* A specific port was requested; see if it's available */
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/port/%d",
be_path, usbdev->port),
&tmp);
if (rc) goto out;
if (tmp && strcmp(tmp, "")) {
LOGD(ERROR, domid, "The controller port isn't available");
rc = ERROR_FAIL;
goto out;
}
} else {
/* No port was requested. Choose free port. */
int i, ports;
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/num-ports", be_path), &tmp);
if (rc) goto out;
ports = tmp ? atoi(tmp) : 0;
for (i = 0; i < ports; i++) {
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/port/%d", be_path, i + 1),
&tmp);
if (rc) goto out;
if (tmp && !strcmp(tmp, "")) {
usbdev->port = i + 1;
break;
}
}
if (!usbdev->port) {
LOGD(ERROR, domid, "No available port under specified controller");
rc = ERROR_FAIL;
goto out;
}
}
}
rc = 0;
out:
return rc;
}
/* Add usb information to xenstore
*
* Adding a usb device won't create new 'qusb'/'vusb' device, but only write
* the device busid to the controller:port in xenstore.
*/
static int libxl__device_usbdev_add_xenstore(libxl__gc *gc, uint32_t domid,
libxl_device_usbdev *usbdev,
libxl_usbctrl_type type,
bool update_json)
{
char *be_path, *busid;
int rc;
xs_transaction_t t = XBT_NULL;
libxl_domain_config d_config;
libxl_device_usbdev usbdev_saved;
libxl__flock *lock = NULL;
libxl_domain_config_init(&d_config);
libxl_device_usbdev_init(&usbdev_saved);
libxl_device_usbdev_copy(CTX, &usbdev_saved, usbdev);
busid = usbdev_busaddr_to_busid(gc, usbdev->u.hostdev.hostbus,
usbdev->u.hostdev.hostaddr);
if (!busid) {
LOGD(DEBUG, domid, "Fail to get busid of usb device");
rc = ERROR_FAIL;
goto out;
}
if (update_json) {
lock = libxl__lock_domain_userdata(gc, domid);
if (!lock) {
rc = ERROR_LOCK_FAIL;
goto out;
}
rc = libxl__get_domain_configuration(gc, domid, &d_config);
if (rc) goto out;
device_add_domain_config(gc, &d_config, &libxl__usbdev_devtype,
&usbdev_saved);
rc = libxl__dm_check_start(gc, &d_config, domid);
if (rc) goto out;
}
for (;;) {
rc = libxl__xs_transaction_start(gc, &t);
if (rc) goto out;
if (update_json) {
rc = libxl__set_domain_configuration(gc, domid, &d_config);
if (rc) goto out;
}
be_path = vusb_get_port_path(gc, domid, type, usbdev->ctrl,
usbdev->port);
LOGD(DEBUG, domid, "Adding usb device %s to xenstore: controller %d, port %d",
busid, usbdev->ctrl, usbdev->port);
rc = libxl__xs_write_checked(gc, t, be_path, busid);
if (rc) goto out;
rc = libxl__xs_transaction_commit(gc, &t);
if (!rc) break;
if (rc < 0) goto out;
}
rc = 0;
out:
if (lock) libxl__unlock_file(lock);
libxl_device_usbdev_dispose(&usbdev_saved);
libxl_domain_config_dispose(&d_config);
return rc;
}
static int libxl__device_usbdev_remove_xenstore(libxl__gc *gc, uint32_t domid,
libxl_device_usbdev *usbdev,
libxl_usbctrl_type type)
{
char *be_path;
be_path = vusb_get_port_path(gc, domid, type, usbdev->ctrl, usbdev->port);
LOGD(DEBUG, domid, "Removing usb device from xenstore: controller %d, port %d",
usbdev->ctrl, usbdev->port);
return libxl__xs_write_checked(gc, XBT_NULL, be_path, "");
}
static char *usbdev_busid_from_ctrlport(libxl__gc *gc, uint32_t domid,
libxl_device_usbdev *usbdev,
libxl_usbctrl_type type)
{
return libxl__xs_read(gc, XBT_NULL,
vusb_get_port_path(gc, domid, type, usbdev->ctrl,
usbdev->port));
}
/* get original driver path of usb interface, stored in @drvpath */
static int usbintf_get_drvpath(libxl__gc *gc, const char *intf, char **drvpath)
{
char *spath, *dp = NULL;
spath = GCSPRINTF(SYSFS_USB_DEV "/%s/driver", intf);
/* Find the canonical path to the driver. */
dp = libxl__zalloc(gc, PATH_MAX);
dp = realpath(spath, dp);
if (!dp && errno != ENOENT) {
LOGE(ERROR, "get realpath failed: '%s'", spath);
return ERROR_FAIL;
}
*drvpath = dp;
return 0;
}
static int unbind_usbintf(libxl__gc *gc, const char *intf)
{
char *path;
int fd = -1;
int rc;
path = GCSPRINTF(SYSFS_USB_DEV "/%s/driver/unbind", intf);
fd = open(path, O_WRONLY);
if (fd < 0) {
LOGE(ERROR, "open file failed: '%s'", path);
rc = ERROR_FAIL;
goto out;
}
if (libxl_write_exactly(CTX, fd, intf, strlen(intf), path, intf)) {
rc = ERROR_FAIL;
goto out;
}
rc = 0;
out:
if (fd >= 0) close(fd);
return rc;
}
static int bind_usbintf(libxl__gc *gc, const char *intf, const char *drvpath)
{
char *bind_path, *intf_path;
struct stat st;
int fd = -1;
int rc, r;
intf_path = GCSPRINTF("%s/%s", drvpath, intf);
/* check through lstat, if intf already exists under drvpath,
* it's already bound, return directly; if it doesn't exist,
* continue to do bind work; otherwise, return error.
*/
r = lstat(intf_path, &st);
if (r == 0)
return 0;
if (r < 0 && errno != ENOENT)
return ERROR_FAIL;
bind_path = GCSPRINTF("%s/bind", drvpath);
fd = open(bind_path, O_WRONLY);
if (fd < 0) {
LOGE(ERROR, "open file failed: '%s'", bind_path);
rc = ERROR_FAIL;
goto out;
}
if (libxl_write_exactly(CTX, fd, intf, strlen(intf), bind_path, intf)) {
rc = ERROR_FAIL;
goto out;
}
rc = 0;
out:
if (fd >= 0) close(fd);
return rc;
}
/* Is usb interface bound to usbback? */
static int usbintf_is_assigned(libxl__gc *gc, char *intf)
{
char *spath;
int r;
struct stat st;
spath = GCSPRINTF(SYSFS_USBBACK_DRIVER "/%s", intf);
r = lstat(spath, &st);
if (r == 0)
return 1;
if (r < 0 && errno == ENOENT)
return 0;
LOGE(ERROR, "Accessing %s", spath);
return -1;
}
static int usbdev_get_all_interfaces(libxl__gc *gc, const char *busid,
char ***intfs, int *num)
{
DIR *dir;
char *buf;
struct dirent *de;
int rc;
*intfs = NULL;
*num = 0;
buf = GCSPRINTF("%s:", busid);
dir = opendir(SYSFS_USB_DEV);
if (!dir) {
LOGE(ERROR, "opendir failed: '%s'", SYSFS_USB_DEV);
return ERROR_FAIL;
}
for (;;) {
errno = 0;
de = readdir(dir);
if (!de && errno) {
LOGE(ERROR, "failed to readdir %s", SYSFS_USB_DEV);
rc = ERROR_FAIL;
goto out;
}
if (!de)
break;
if (!strcmp(de->d_name, ".") ||
!strcmp(de->d_name, ".."))
continue;
if (!strncmp(de->d_name, buf, strlen(buf))) {
GCREALLOC_ARRAY(*intfs, *num + 1);
(*intfs)[*num] = libxl__strdup(gc, de->d_name);
(*num)++;
}
}
rc = 0;
out:
closedir(dir);
return rc;
}
/* Encode usb interface so that it could be written to xenstore as a key.
*
* Since xenstore key cannot include '.' or ':', we'll change '.' to '_',
* change ':' to '@'. For example, 3-1:2.1 will be encoded to 3-1@2_1.
* This will be used to save original driver of USB device to xenstore.
*/
static char *usb_interface_xenstore_encode(libxl__gc *gc, const char *busid)
{
char *str = libxl__strdup(gc, busid);
int i, len = strlen(str);
for (i = 0; i < len; i++) {
if (str[i] == '.') str[i] = '_';
if (str[i] == ':') str[i] = '@';
}
return str;
}
/* Unbind USB device from "usbback" driver.
*
* If there are many interfaces under USB device, check each interface,
* unbind from "usbback" driver.
*/
static int usbback_dev_unassign(libxl__gc *gc, const char *busid)
{
char **intfs = NULL;
int i, num = 0;
int rc;
rc = usbdev_get_all_interfaces(gc, busid, &intfs, &num);
if (rc) goto out;
for (i = 0; i < num; i++) {
char *intf = intfs[i];
/* check if the USB interface is already bound to "usbback" */
if (usbintf_is_assigned(gc, intf) > 0) {
/* unbind interface from usbback driver */
rc = unbind_usbintf(gc, intf);
if (rc) {
LOGE(ERROR, "Couldn't unbind %s from usbback", intf);
goto out;
}
}
}
rc = 0;
out:
return rc;
}
/* rebind USB device to original driver.
*
* If there are many interfaces under USB device, for reach interface,
* read driver_path from xenstore (if there is) and rebind to its
* original driver, then remove driver_path information from xenstore.
*/
static int usbdev_rebind(libxl__gc *gc, const char *busid)
{
char **intfs = NULL;
char *usbdev_encode = NULL;
char *path = NULL;
int i, num = 0;
int rc;
rc = usbdev_get_all_interfaces(gc, busid, &intfs, &num);
if (rc) goto out;
usbdev_encode = usb_interface_xenstore_encode(gc, busid);
for (i = 0; i < num; i++) {
char *intf = intfs[i];
char *usbintf_encode = NULL;
const char *drvpath;
/* rebind USB interface to its originial driver */
usbintf_encode = usb_interface_xenstore_encode(gc, intf);
path = GCSPRINTF(USBBACK_INFO_PATH "/%s/%s/driver_path",
usbdev_encode, usbintf_encode);
rc = libxl__xs_read_checked(gc, XBT_NULL, path, &drvpath);
if (rc) goto out;
if (drvpath) {
rc = bind_usbintf(gc, intf, drvpath);
if (rc) {
LOGE(ERROR, "Couldn't rebind %s to %s", intf, drvpath);
goto out;
}
}
}
out:
path = GCSPRINTF(USBBACK_INFO_PATH "/%s", usbdev_encode);
libxl__xs_rm_checked(gc, XBT_NULL, path);
return rc;
}
/* Bind USB device to "usbback" driver.
*
* If there are many interfaces under USB device, check each interface,
* unbind from original driver and bind to "usbback" driver.
*/
static int usbback_dev_assign(libxl__gc *gc, const char *busid)
{
char **intfs = NULL;
int num = 0, i;
int rc;
char *usbdev_encode = NULL;
rc = usbdev_get_all_interfaces(gc, busid, &intfs, &num);
if (rc) return rc;
usbdev_encode = usb_interface_xenstore_encode(gc, busid);
for (i = 0; i < num; i++) {
char *intf = intfs[i];
char *drvpath = NULL;
/* already assigned to usbback */
if (usbintf_is_assigned(gc, intf) > 0)
continue;
rc = usbintf_get_drvpath(gc, intf, &drvpath);
if (rc) goto out;
if (drvpath) {
/* write driver path to xenstore for later rebinding */
char *usbintf_encode = NULL;
char *path;
usbintf_encode = usb_interface_xenstore_encode(gc, intf);
path = GCSPRINTF(USBBACK_INFO_PATH "/%s/%s/driver_path",
usbdev_encode, usbintf_encode);
rc = libxl__xs_write_checked(gc, XBT_NULL, path, drvpath);
if (rc) goto out;
/* unbind interface from original driver */
rc = unbind_usbintf(gc, intf);
if (rc) goto out;
}
/* bind interface to usbback */
rc = bind_usbintf(gc, intf, SYSFS_USBBACK_DRIVER);
if (rc) {
LOG(ERROR, "Couldn't bind %s to %s", intf, SYSFS_USBBACK_DRIVER);
goto out;
}
}
return 0;
out:
/* some interfaces might be bound to usbback, unbind it and
* rebind it to its original driver
*/
usbback_dev_unassign(gc, busid);
usbdev_rebind(gc, busid);
return rc;
}
static void device_usbdev_add_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp, const libxl__json_object *r, int rc);
static void device_usbdev_add_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc);
static void device_usbdev_add_done(libxl__egc *egc,
libxl__ao_device *aodev, int rc);
/* AO operation to add a usb device.
*
* Generally, it does:
* 1) check if the usb device type is assignable
* 2) check if the usb device is already assigned to a domain
* 3) add 'busid' of the usb device to xenstore contoller/port/.
* (PVUSB driver watches the xenstore changes and will detect that.)
* 4) unbind usb device from original driver and bind to usbback.
* If usb device has many interfaces, then:
* - unbind each interface from its original driver and bind to usbback.
* - store the original driver to xenstore for later rebinding when
* detaching the device.
*
* Before calling this function, aodev should be properly filled:
* aodev->ao, aodev->callback, aodev->update_json, ...
*/
static void libxl__device_usbdev_add(libxl__egc *egc, uint32_t domid,
libxl_device_usbdev *usbdev,
libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
int rc;
libxl_device_usbdev *assigned;
int num_assigned;
libxl_device_usbctrl usbctrl;
char *busid;
bool has_callback = false;
libxl_device_usbctrl_init(&usbctrl);
/* Store *usbdev to be used by callbacks */
aodev->device_config = usbdev;
aodev->device_type = &libxl__usbdev_devtype;
/* Currently only support adding USB device from Dom0 backend.
* So, if USB controller is specified, check its backend domain,
* if it's not Dom0, report error.
*/
if (usbdev->ctrl != -1) {
rc = libxl_devid_to_device_usbctrl(CTX, domid, usbdev->ctrl,
&usbctrl);
if (rc) goto out;
if (usbctrl.backend_domid != LIBXL_TOOLSTACK_DOMID) {
LOGD(ERROR, domid,
"Don't support adding USB device from non-Dom0 backend");
rc = ERROR_INVAL;
goto out;
}
libxl_device_usbctrl_dispose(&usbctrl);
}
/* check usb device is assignable type */
if (!is_usbdev_assignable(gc, usbdev)) {
LOGD(ERROR, domid, "USB device is not assignable.");
rc = ERROR_FAIL;
goto out;
}
/* check usb device is already assigned */
rc = get_assigned_devices(gc, &assigned, &num_assigned);
if (rc) {
LOGD(ERROR, domid, "cannot determine if device is assigned,"
" refusing to continue");
goto out;
}
if (is_usbdev_in_array(assigned, num_assigned, usbdev)) {
LOGD(ERROR, domid, "USB device already attached to a domain");
rc = ERROR_INVAL;
goto out;
}
/* fill default values, e.g, if usbdev->ctrl and usbdev->port
* not specified, choose available controller:port and fill in. */
rc = libxl__device_usbdev_setdefault(gc, domid, usbdev,
aodev->update_json);
if (rc) goto out;
rc = libxl_devid_to_device_usbctrl(CTX, domid, usbdev->ctrl, &usbctrl);
if (rc) goto out;
/* do actual adding usb device operation */
switch (usbctrl.type) {
case LIBXL_USBCTRL_TYPE_PV:
busid = usbdev_busaddr_to_busid(gc, usbdev->u.hostdev.hostbus,
usbdev->u.hostdev.hostaddr);
if (!busid) {
rc = ERROR_FAIL;
goto out;
}
rc = libxl__device_usbdev_add_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_PV,
aodev->update_json);
if (rc) goto out;
rc = usbback_dev_assign(gc, busid);
if (rc) {
libxl__device_usbdev_remove_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_PV);
goto out;
}
break;
case LIBXL_USBCTRL_TYPE_QUSB:
rc = libxl__device_usbdev_add_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_QUSB,
aodev->update_json);
if (rc) goto out;
break;
case LIBXL_USBCTRL_TYPE_DEVICEMODEL:
rc = libxl__device_usbdev_add_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_DEVICEMODEL,
aodev->update_json);
if (rc) goto out;
rc = libxl__ev_time_register_rel(ao, &aodev->timeout,
device_usbdev_add_timeout,
LIBXL_QMP_CMD_TIMEOUT * 1000);
if (rc) goto out;
aodev->qmp.ao = ao;
aodev->qmp.domid = domid;
aodev->qmp.callback = device_usbdev_add_qmp_cb;
aodev->qmp.payload_fd = -1;
rc = libxl__device_usbdev_add_hvm(egc, &aodev->qmp, usbdev);
if (rc) {
libxl__device_usbdev_remove_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_DEVICEMODEL);
goto out;
}
has_callback = true;
break;
default:
LOGD(ERROR, domid, "Unsupported usb controller type");
rc = ERROR_FAIL;
goto out;
}
rc = 0;
out:
libxl_device_usbctrl_dispose(&usbctrl);
/* Only call _done if no callback have been setup */
if (!has_callback)
device_usbdev_add_done(egc, aodev, rc); /* must be last */
}
static void device_usbdev_add_timeout(libxl__egc *egc,
libxl__ev_time *ev,
const struct timeval *requested_abs,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(ev, *aodev, timeout);
if (rc == ERROR_TIMEDOUT)
LOGD(ERROR, aodev->qmp.domid,
"Adding usbdev to QEMU timed out");
device_usbdev_add_qmp_cb(egc, &aodev->qmp, NULL, rc);
}
static void device_usbdev_add_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp,
const libxl__json_object *r,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(qmp, *aodev, qmp);
libxl_device_usbdev *const usbdev = aodev->device_config;
if (rc)
libxl__device_usbdev_remove_xenstore(gc, qmp->domid,
usbdev, LIBXL_USBCTRL_TYPE_DEVICEMODEL);
device_usbdev_add_done(egc, aodev, rc); /* must be last */
}
static void device_usbdev_add_done(libxl__egc *egc,
libxl__ao_device *aodev,
int rc)
{
EGC_GC;
libxl__ev_time_deregister(gc, &aodev->timeout);
libxl__ev_qmp_dispose(gc, &aodev->qmp);
aodev->rc = rc;
aodev->callback(egc, aodev);
}
LIBXL_DEFINE_DEVICE_ADD(usbdev)
static LIBXL_DEFINE_DEVICES_ADD(usbdev)
static void device_usbdev_remove_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc);
static void device_usbdev_remove_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp, const libxl__json_object *r, int rc);
static void device_usbdev_remove_done(libxl__egc *egc,
libxl__ao_device *aodev, int rc);
/* Operation to remove usb device.
*
* Generally, it does:
* 1) check if the usb device is assigned to the domain
* 2) remove the usb device from xenstore controller/port.
* 3) unbind usb device from usbback and rebind to its original driver.
* If usb device has many interfaces, do it to each interface.
*
* Before calling this function, aodev should be properly filled:
* aodev->ao, aodev->callback, ...
*/
static void libxl__device_usbdev_remove(libxl__egc *egc, uint32_t domid,
libxl_device_usbdev *usbdev,
libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
int rc;
char *busid;
libxl_device_usbctrl usbctrl;
bool has_callback = false;
/* Store *usbdev to be used by callbacks */
aodev->device_config = usbdev;
aodev->device_type = &libxl__usbdev_devtype;
libxl_device_usbctrl_init(&usbctrl);
if (usbdev->ctrl < 0 || usbdev->port < 1) {
LOGD(ERROR, domid, "Invalid USB device");
rc = ERROR_FAIL;
goto out;
}
rc = libxl_devid_to_device_usbctrl(CTX, domid, usbdev->ctrl, &usbctrl);
if (rc) goto out;
if (usbctrl.backend_domid != LIBXL_TOOLSTACK_DOMID) {
LOGD(ERROR, domid,
"Don't support removing USB device from non-Dom0 backend");
rc = ERROR_INVAL;
goto out;
}
/* do actual removing usb device operation */
switch (usbctrl.type) {
case LIBXL_USBCTRL_TYPE_PV:
busid = usbdev_busid_from_ctrlport(gc, domid, usbdev, usbctrl.type);
if (!busid) {
rc = ERROR_FAIL;
goto out;
}
/* Things are done in order of:
* unbind USB device from usbback,
* remove USB device from xenstore,
* rebind USB device to original driver.
* It is to balance simplicity with robustness in case of failure:
* - We unbind all interfaces before rebinding any interfaces, so
* that we never get into a situation where some interfaces are
* assigned to usbback and some are assigned to the original drivers.
* - We also unbind the interfaces before removing the pvusb xenstore
* nodes, so that if the unbind fails in the middle, the device still
* shows up in xl usb-list, and the user can re-try removing it.
*/
rc = usbback_dev_unassign(gc, busid);
if (rc) {
LOGD(ERROR, domid, "Error removing device from guest."
" Try running usbdev-detach again.");
goto out;
}
rc = libxl__device_usbdev_remove_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_PV);
if (rc) {
LOGD(ERROR, domid, "Error removing device from guest."
" Try running usbdev-detach again.");
goto out;
}
rc = usbdev_rebind(gc, busid);
if (rc) {
LOGD(ERROR, domid, "USB device removed from guest, but couldn't"
" re-bind to domain 0. Try removing and re-inserting"
" the USB device or reloading the driver modules.");
goto out;
}
break;
case LIBXL_USBCTRL_TYPE_QUSB:
rc = libxl__device_usbdev_remove_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_QUSB);
if (rc) goto out;
break;
case LIBXL_USBCTRL_TYPE_DEVICEMODEL:
rc = libxl__device_usbdev_remove_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_DEVICEMODEL);
if (rc) goto out;
rc = libxl__ev_time_register_rel(ao, &aodev->timeout,
device_usbdev_remove_timeout,
LIBXL_QMP_CMD_TIMEOUT * 1000);
if (rc) goto out;
aodev->qmp.ao = ao;
aodev->qmp.domid = domid;
aodev->qmp.callback = device_usbdev_remove_qmp_cb;
aodev->qmp.payload_fd = -1;
rc = libxl__device_usbdev_del_hvm(egc, &aodev->qmp, usbdev);
if (rc) {
libxl__device_usbdev_add_xenstore(gc, domid, usbdev,
LIBXL_USBCTRL_TYPE_DEVICEMODEL,
false);
goto out;
}
has_callback = true;
break;
default:
LOGD(ERROR, domid, "Unsupported usb controller type");
rc = ERROR_FAIL;
goto out;
}
rc = 0;
out:
libxl_device_usbctrl_dispose(&usbctrl);
/* Only call _done if no callback have been setup */
if (!has_callback)
device_usbdev_remove_done(egc, aodev, rc); /* must be last */
}
static void device_usbdev_remove_timeout(libxl__egc *egc,
libxl__ev_time *ev, const struct timeval *requested_abs, int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(ev, *aodev, timeout);
if (rc == ERROR_TIMEDOUT)
LOGD(ERROR, aodev->qmp.domid,
"Removing usbdev from QEMU timed out");
device_usbdev_remove_qmp_cb(egc, &aodev->qmp, NULL, rc);
}
static void device_usbdev_remove_qmp_cb(libxl__egc *egc,
libxl__ev_qmp *qmp,
const libxl__json_object *r,
int rc)
{
EGC_GC;
libxl__ao_device *aodev = CONTAINER_OF(qmp, *aodev, qmp);
libxl_device_usbdev *const usbdev = aodev->device_config;
if (rc) {
libxl__device_usbdev_add_xenstore(gc, qmp->domid, usbdev,
LIBXL_USBCTRL_TYPE_DEVICEMODEL,
false);
}
device_usbdev_remove_done(egc, aodev, rc); /* must be last */
}
static void device_usbdev_remove_done(libxl__egc *egc,
libxl__ao_device *aodev,
int rc)
{
EGC_GC;
libxl__ev_time_deregister(gc, &aodev->timeout);
libxl__ev_qmp_dispose(gc, &aodev->qmp);
aodev->rc = rc;
aodev->callback(egc, aodev);
}
int libxl_device_usbdev_remove(libxl_ctx *ctx, uint32_t domid,
libxl_device_usbdev *usbdev,
const libxl_asyncop_how *ao_how)
{
AO_CREATE(ctx, domid, ao_how);
libxl__ao_device *aodev;
GCNEW(aodev);
libxl__prepare_ao_device(ao, aodev);
aodev->action = LIBXL__DEVICE_ACTION_REMOVE;
aodev->callback = device_addrm_aocomplete;
libxl__device_usbdev_remove(egc, domid, usbdev, aodev);
return AO_INPROGRESS;
}
int libxl_ctrlport_to_device_usbdev(libxl_ctx *ctx,
uint32_t domid,
int ctrl,
int port,
libxl_device_usbdev *usbdev)
{
GC_INIT(ctx);
const char *libxl_path, *be_path, *busid;
int rc;
libxl_path = libxl__domain_device_libxl_path(gc, domid, ctrl,
LIBXL__DEVICE_KIND_VUSB);
be_path = vusb_be_from_xs_libxl(gc, libxl_path);
if (!be_path) {
rc = ERROR_FAIL;
goto out;
}
rc = libxl__xs_read_checked(gc, XBT_NULL,
GCSPRINTF("%s/port/%d", be_path, port),
&busid);
if (rc) goto out;
if (!busid || !strcmp(busid, "")) {
rc = ERROR_FAIL;
goto out;
}
usbdev->ctrl = ctrl;
usbdev->port = port;
usbdev->type = LIBXL_USBDEV_TYPE_HOSTDEV;
rc = usbdev_busaddr_from_busid(gc, busid,
&usbdev->u.hostdev.hostbus,
&usbdev->u.hostdev.hostaddr);
out:
GC_FREE;
return rc;
}
static int libxl_device_usbctrl_compare(const libxl_device_usbctrl *d1,
const libxl_device_usbctrl *d2)
{
return COMPARE_USBCTRL(d1, d2);
}
static int libxl_device_usbctrl_dm_needed(void *e, unsigned domid)
{
libxl_device_usbctrl *elem = e;
return elem->type == LIBXL_USBCTRL_TYPE_QUSB &&
elem->backend_domid == domid;
}
static int libxl_device_usbdev_compare(const libxl_device_usbdev *d1,
const libxl_device_usbdev *d2)
{
return COMPARE_USB(d1, d2);
}
void libxl_device_usbdev_list_free(libxl_device_usbdev *list, int nr)
{
int i;
for (i = 0; i < nr; i++)
libxl_device_usbdev_dispose(&list[i]);
free(list);
}
#define libxl__device_usbctrl_update_devid NULL
LIBXL_DEFINE_DEVID_TO_DEVICE(usbctrl)
LIBXL_DEFINE_DEVICE_LIST(usbctrl)
DEFINE_DEVICE_TYPE_STRUCT(usbctrl, VUSB, usbctrls,
.from_xenstore = (device_from_xenstore_fn_t)libxl__usbctrl_from_xenstore,
.dm_needed = libxl_device_usbctrl_dm_needed
);
#define libxl__device_from_usbdev NULL
#define libxl__device_usbdev_update_devid NULL
DEFINE_DEVICE_TYPE_STRUCT(usbdev, VUSB, usbdevs);
/*
* Local variables:
* mode: C
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*/
Reference in new issue View Git Blame Copy Permalink