*/
#include "qemu/osdep.h"
+#include "qapi/error.h"
#include <sys/ioctl.h>
#include <linux/vfio.h>
* and add it into the list of IRQs
* @vbasedev: the VFIO device handle
* @info: irq info struct retrieved from VFIO driver
+ * @errp: error object
*/
static VFIOINTp *vfio_init_intp(VFIODevice *vbasedev,
- struct vfio_irq_info info)
+ struct vfio_irq_info info, Error **errp)
{
int ret;
VFIOPlatformDevice *vdev =
if (ret) {
g_free(intp->interrupt);
g_free(intp);
- error_report("vfio: Error: trigger event_notifier_init failed ");
+ error_setg_errno(errp, -ret,
+ "failed to initialize trigger eventd notifier");
return NULL;
}
if (vfio_irq_is_automasked(intp)) {
g_free(intp->interrupt);
g_free(intp->unmask);
g_free(intp);
- error_report("vfio: Error: resamplefd event_notifier_init failed");
+ error_setg_errno(errp, -ret,
+ "failed to initialize resample eventd notifier");
return NULL;
}
}
*pfd = event_notifier_get_fd(intp->interrupt);
qemu_set_fd_handler(*pfd, (IOHandler *)handler, NULL, intp);
ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set);
- g_free(irq_set);
if (ret < 0) {
error_report("vfio: Failed to set trigger eventfd: %m");
qemu_set_fd_handler(*pfd, NULL, NULL, NULL);
}
+ g_free(irq_set);
return ret;
}
{
int i;
- trace_vfio_platform_mmap_set_enabled(enabled);
-
for (i = 0; i < vdev->vbasedev.num_regions; i++) {
- VFIORegion *region = vdev->regions[i];
-
- memory_region_set_enabled(®ion->mmap_mem, enabled);
+ vfio_region_mmaps_set_enabled(vdev->regions[i], enabled);
}
}
* vfio_populate_device - Allocate and populate MMIO region
* and IRQ structs according to driver returned information
* @vbasedev: the VFIO device handle
+ * @errp: error object
*
*/
-static int vfio_populate_device(VFIODevice *vbasedev)
+static int vfio_populate_device(VFIODevice *vbasedev, Error **errp)
{
VFIOINTp *intp, *tmp;
int i, ret = -1;
container_of(vbasedev, VFIOPlatformDevice, vbasedev);
if (!(vbasedev->flags & VFIO_DEVICE_FLAGS_PLATFORM)) {
- error_report("vfio: Um, this isn't a platform device");
+ error_setg(errp, "this isn't a platform device");
return ret;
}
vdev->regions = g_new0(VFIORegion *, vbasedev->num_regions);
for (i = 0; i < vbasedev->num_regions; i++) {
- struct vfio_region_info *reg_info;
- VFIORegion *ptr;
+ char *name = g_strdup_printf("VFIO %s region %d\n", vbasedev->name, i);
vdev->regions[i] = g_new0(VFIORegion, 1);
- ptr = vdev->regions[i];
- ret = vfio_get_region_info(vbasedev, i, ®_info);
+ ret = vfio_region_setup(OBJECT(vdev), vbasedev,
+ vdev->regions[i], i, name);
+ g_free(name);
if (ret) {
- error_report("vfio: Error getting region %d info: %m", i);
+ error_setg_errno(errp, -ret, "failed to get region %d info", i);
goto reg_error;
}
- ptr->flags = reg_info->flags;
- ptr->size = reg_info->size;
- ptr->fd_offset = reg_info->offset;
- ptr->nr = i;
- ptr->vbasedev = vbasedev;
-
- g_free(reg_info);
-
- trace_vfio_platform_populate_regions(ptr->nr,
- (unsigned long)ptr->flags,
- (unsigned long)ptr->size,
- ptr->vbasedev->fd,
- (unsigned long)ptr->fd_offset);
}
vdev->mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
irq.index = i;
ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, &irq);
if (ret) {
- error_printf("vfio: error getting device %s irq info",
- vbasedev->name);
+ error_setg_errno(errp, -ret, "failed to get device irq info");
goto irq_err;
} else {
trace_vfio_platform_populate_interrupts(irq.index,
irq.count,
irq.flags);
- intp = vfio_init_intp(vbasedev, irq);
+ intp = vfio_init_intp(vbasedev, irq, errp);
if (!intp) {
- error_report("vfio: Error installing IRQ %d up", i);
+ ret = -1;
goto irq_err;
}
}
}
reg_error:
for (i = 0; i < vbasedev->num_regions; i++) {
+ if (vdev->regions[i]) {
+ vfio_region_finalize(vdev->regions[i]);
+ }
g_free(vdev->regions[i]);
}
g_free(vdev->regions);
/**
* vfio_base_device_init - perform preliminary VFIO setup
* @vbasedev: the VFIO device handle
+ * @errp: error object
*
* Implement the VFIO command sequence that allows to discover
* assigned device resources: group extraction, device
* fd retrieval, resource query.
* Precondition: the device name must be initialized
*/
-static int vfio_base_device_init(VFIODevice *vbasedev)
+static int vfio_base_device_init(VFIODevice *vbasedev, Error **errp)
{
VFIOGroup *group;
VFIODevice *vbasedev_iter;
vbasedev->name = g_strdup(basename(vbasedev->sysfsdev));
} else {
if (!vbasedev->name || strchr(vbasedev->name, '/')) {
+ error_setg(errp, "wrong host device name");
return -EINVAL;
}
}
if (stat(vbasedev->sysfsdev, &st) < 0) {
- error_report("vfio: error: no such host device: %s",
- vbasedev->sysfsdev);
+ error_setg_errno(errp, errno,
+ "failed to get the sysfs host device file status");
return -errno;
}
g_free(tmp);
if (len < 0 || len >= sizeof(group_path)) {
- error_report("vfio: error no iommu_group for device");
- return len < 0 ? -errno : -ENAMETOOLONG;
+ ret = len < 0 ? -errno : -ENAMETOOLONG;
+ error_setg_errno(errp, -ret, "no iommu_group found");
+ return ret;
}
group_path[len] = 0;
group_name = basename(group_path);
if (sscanf(group_name, "%d", &groupid) != 1) {
- error_report("vfio: error reading %s: %m", group_path);
+ error_setg_errno(errp, errno, "failed to read %s", group_path);
return -errno;
}
trace_vfio_platform_base_device_init(vbasedev->name, groupid);
- group = vfio_get_group(groupid, &address_space_memory);
+ group = vfio_get_group(groupid, &address_space_memory, errp);
if (!group) {
- error_report("vfio: failed to get group %d", groupid);
return -ENOENT;
}
QLIST_FOREACH(vbasedev_iter, &group->device_list, next) {
if (strcmp(vbasedev_iter->name, vbasedev->name) == 0) {
- error_report("vfio: error: device %s is already attached",
- vbasedev->name);
+ error_setg(errp, "device is already attached");
vfio_put_group(group);
return -EBUSY;
}
}
- ret = vfio_get_device(group, vbasedev->name, vbasedev);
+ ret = vfio_get_device(group, vbasedev->name, vbasedev, errp);
if (ret) {
- error_report("vfio: failed to get device %s", vbasedev->name);
vfio_put_group(group);
return ret;
}
- ret = vfio_populate_device(vbasedev);
+ ret = vfio_populate_device(vbasedev, errp);
if (ret) {
- error_report("vfio: failed to populate device %s", vbasedev->name);
vfio_put_group(group);
}
return ret;
}
-/**
- * vfio_map_region - initialize the 2 memory regions for a given
- * MMIO region index
- * @vdev: the VFIO platform device handle
- * @nr: the index of the region
- *
- * Init the top memory region and the mmapped memory region beneath
- * VFIOPlatformDevice is used since VFIODevice is not a QOM Object
- * and could not be passed to memory region functions
-*/
-static void vfio_map_region(VFIOPlatformDevice *vdev, int nr)
-{
- VFIORegion *region = vdev->regions[nr];
- uint64_t size = region->size;
- char name[64];
-
- if (!size) {
- return;
- }
-
- g_snprintf(name, sizeof(name), "VFIO %s region %d",
- vdev->vbasedev.name, nr);
-
- /* A "slow" read/write mapping underlies all regions */
- memory_region_init_io(®ion->mem, OBJECT(vdev), &vfio_region_ops,
- region, name, size);
-
- g_strlcat(name, " mmap", sizeof(name));
-
- if (vfio_mmap_region(OBJECT(vdev), region, ®ion->mem,
- ®ion->mmap_mem, ®ion->mmap, size, 0, name)) {
- error_report("%s unsupported. Performance may be slow", name);
- }
-}
-
/**
* vfio_platform_realize - the device realize function
* @dev: device state pointer
int i, ret;
vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM;
+ vbasedev->dev = dev;
vbasedev->ops = &vfio_platform_ops;
trace_vfio_platform_realize(vbasedev->sysfsdev ?
vbasedev->sysfsdev : vbasedev->name,
vdev->compat);
- ret = vfio_base_device_init(vbasedev);
+ ret = vfio_base_device_init(vbasedev, errp);
if (ret) {
- error_setg(errp, "vfio: vfio_base_device_init failed for %s",
- vbasedev->name);
- return;
+ goto out;
}
for (i = 0; i < vbasedev->num_regions; i++) {
- vfio_map_region(vdev, i);
- sysbus_init_mmio(sbdev, &vdev->regions[i]->mem);
+ if (vfio_region_mmap(vdev->regions[i])) {
+ error_report("%s mmap unsupported. Performance may be slow",
+ memory_region_name(vdev->regions[i]->mem));
+ }
+ sysbus_init_mmio(sbdev, vdev->regions[i]->mem);
+ }
+out:
+ if (!ret) {
+ return;
+ }
+
+ if (vdev->vbasedev.name) {
+ error_prepend(errp, ERR_PREFIX, vdev->vbasedev.name);
+ } else {
+ error_prepend(errp, "vfio error: ");
}
}
projects / qemu.git / blobdiff