LXR qemu/hw/vfio/spapr.c

   1/*
   2 * DMA memory preregistration
   3 *
   4 * Authors:
   5 *  Alexey Kardashevskiy <aik@ozlabs.ru>
   6 *
   7 * This work is licensed under the terms of the GNU GPL, version 2.  See
   8 * the COPYING file in the top-level directory.
   9 */
  10
  11#include "qemu/osdep.h"
  12#include "cpu.h"
  13#include <sys/ioctl.h>
  14#include <linux/vfio.h>
  15
  16#include "hw/vfio/vfio-common.h"
  17#include "hw/hw.h"
  18#include "exec/ram_addr.h"
  19#include "qemu/error-report.h"
  20#include "qapi/error.h"
  21#include "trace.h"
  22
  23static bool vfio_prereg_listener_skipped_section(MemoryRegionSection *section)
  24{
  25    if (memory_region_is_iommu(section->mr)) {
  26        hw_error("Cannot possibly preregister IOMMU memory");
  27    }
  28
  29    return !memory_region_is_ram(section->mr) ||
  30            memory_region_is_ram_device(section->mr);
  31}
  32
  33static void *vfio_prereg_gpa_to_vaddr(MemoryRegionSection *section, hwaddr gpa)
  34{
  35    return memory_region_get_ram_ptr(section->mr) +
  36        section->offset_within_region +
  37        (gpa - section->offset_within_address_space);
  38}
  39
  40static void vfio_prereg_listener_region_add(MemoryListener *listener,
  41                                            MemoryRegionSection *section)
  42{
  43    VFIOContainer *container = container_of(listener, VFIOContainer,
  44                                            prereg_listener);
  45    const hwaddr gpa = section->offset_within_address_space;
  46    hwaddr end;
  47    int ret;
  48    hwaddr page_mask = qemu_real_host_page_mask;
  49    struct vfio_iommu_spapr_register_memory reg = {
  50        .argsz = sizeof(reg),
  51        .flags = 0,
  52    };
  53
  54    if (vfio_prereg_listener_skipped_section(section)) {
  55        trace_vfio_prereg_listener_region_add_skip(
  56                section->offset_within_address_space,
  57                section->offset_within_address_space +
  58                int128_get64(int128_sub(section->size, int128_one())));
  59        return;
  60    }
  61
  62    if (unlikely((section->offset_within_address_space & ~page_mask) ||
  63                 (section->offset_within_region & ~page_mask) ||
  64                 (int128_get64(section->size) & ~page_mask))) {
  65        error_report("%s received unaligned region", __func__);
  66        return;
  67    }
  68
  69    end = section->offset_within_address_space + int128_get64(section->size);
  70    if (gpa >= end) {
  71        return;
  72    }
  73
  74    memory_region_ref(section->mr);
  75
  76    reg.vaddr = (uintptr_t) vfio_prereg_gpa_to_vaddr(section, gpa);
  77    reg.size = end - gpa;
  78
  79    ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_REGISTER_MEMORY, &reg);
  80    trace_vfio_prereg_register(reg.vaddr, reg.size, ret ? -errno : 0);
  81    if (ret) {
  82        /*
  83         * On the initfn path, store the first error in the container so we
  84         * can gracefully fail.  Runtime, there's not much we can do other
  85         * than throw a hardware error.
  86         */
  87        if (!container->initialized) {
  88            if (!container->error) {
  89                error_setg_errno(&container->error, -ret,
  90                                 "Memory registering failed");
  91            }
  92        } else {
  93            hw_error("vfio: Memory registering failed, unable to continue");
  94        }
  95    }
  96}
  97
  98static void vfio_prereg_listener_region_del(MemoryListener *listener,
  99                                            MemoryRegionSection *section)
 100{
 101    VFIOContainer *container = container_of(listener, VFIOContainer,
 102                                            prereg_listener);
 103    const hwaddr gpa = section->offset_within_address_space;
 104    hwaddr end;
 105    int ret;
 106    hwaddr page_mask = qemu_real_host_page_mask;
 107    struct vfio_iommu_spapr_register_memory reg = {
 108        .argsz = sizeof(reg),
 109        .flags = 0,
 110    };
 111
 112    if (vfio_prereg_listener_skipped_section(section)) {
 113        trace_vfio_prereg_listener_region_del_skip(
 114                section->offset_within_address_space,
 115                section->offset_within_address_space +
 116                int128_get64(int128_sub(section->size, int128_one())));
 117        return;
 118    }
 119
 120    if (unlikely((section->offset_within_address_space & ~page_mask) ||
 121                 (section->offset_within_region & ~page_mask) ||
 122                 (int128_get64(section->size) & ~page_mask))) {
 123        error_report("%s received unaligned region", __func__);
 124        return;
 125    }
 126
 127    end = section->offset_within_address_space + int128_get64(section->size);
 128    if (gpa >= end) {
 129        return;
 130    }
 131
 132    reg.vaddr = (uintptr_t) vfio_prereg_gpa_to_vaddr(section, gpa);
 133    reg.size = end - gpa;
 134
 135    ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY, &reg);
 136    trace_vfio_prereg_unregister(reg.vaddr, reg.size, ret ? -errno : 0);
 137}
 138
 139const MemoryListener vfio_prereg_listener = {
 140    .region_add = vfio_prereg_listener_region_add,
 141    .region_del = vfio_prereg_listener_region_del,
 142};
 143
 144int vfio_spapr_create_window(VFIOContainer *container,
 145                             MemoryRegionSection *section,
 146                             hwaddr *pgsize)
 147{
 148    int ret = 0;
 149    IOMMUMemoryRegion *iommu_mr = IOMMU_MEMORY_REGION(section->mr);
 150    uint64_t pagesize = memory_region_iommu_get_min_page_size(iommu_mr), pgmask;
 151    unsigned entries, bits_total, bits_per_level, max_levels;
 152    struct vfio_iommu_spapr_tce_create create = { .argsz = sizeof(create) };
 153    long rampagesize = qemu_minrampagesize();
 154
 155    /*
 156     * The host might not support the guest supported IOMMU page size,
 157     * so we will use smaller physical IOMMU pages to back them.
 158     */
 159    if (pagesize > rampagesize) {
 160        pagesize = rampagesize;
 161    }
 162    pgmask = container->pgsizes & (pagesize | (pagesize - 1));
 163    pagesize = pgmask ? (1ULL << (63 - clz64(pgmask))) : 0;
 164    if (!pagesize) {
 165        error_report("Host doesn't support page size 0x%"PRIx64
 166                     ", the supported mask is 0x%lx",
 167                     memory_region_iommu_get_min_page_size(iommu_mr),
 168                     container->pgsizes);
 169        return -EINVAL;
 170    }
 171
 172    /*
 173     * FIXME: For VFIO iommu types which have KVM acceleration to
 174     * avoid bouncing all map/unmaps through qemu this way, this
 175     * would be the right place to wire that up (tell the KVM
 176     * device emulation the VFIO iommu handles to use).
 177     */
 178    create.window_size = int128_get64(section->size);
 179    create.page_shift = ctz64(pagesize);
 180    /*
 181     * SPAPR host supports multilevel TCE tables. We try to guess optimal
 182     * levels number and if this fails (for example due to the host memory
 183     * fragmentation), we increase levels. The DMA address structure is:
 184     * rrrrrrrr rxxxxxxx xxxxxxxx xxxxxxxx  xxxxxxxx xxxxxxxx xxxxxxxx iiiiiiii
 185     * where:
 186     *   r = reserved (bits >= 55 are reserved in the existing hardware)
 187     *   i = IOMMU page offset (64K in this example)
 188     *   x = bits to index a TCE which can be split to equal chunks to index
 189     *      within the level.
 190     * The aim is to split "x" to smaller possible number of levels.
 191     */
 192    entries = create.window_size >> create.page_shift;
 193    /* bits_total is number of "x" needed */
 194    bits_total = ctz64(entries * sizeof(uint64_t));
 195    /*
 196     * bits_per_level is a safe guess of how much we can allocate per level:
 197     * 8 is the current minimum for CONFIG_FORCE_MAX_ZONEORDER and MAX_ORDER
 198     * is usually bigger than that.
 199     * Below we look at qemu_real_host_page_size as TCEs are allocated from
 200     * system pages.
 201     */
 202    bits_per_level = ctz64(qemu_real_host_page_size) + 8;
 203    create.levels = bits_total / bits_per_level;
 204    if (bits_total % bits_per_level) {
 205        ++create.levels;
 206    }
 207    max_levels = (64 - create.page_shift) / ctz64(qemu_real_host_page_size);
 208    for ( ; create.levels <= max_levels; ++create.levels) {
 209        ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_TCE_CREATE, &create);
 210        if (!ret) {
 211            break;
 212        }
 213    }
 214    if (ret) {
 215        error_report("Failed to create a window, ret = %d (%m)", ret);
 216        return -errno;
 217    }
 218
 219    if (create.start_addr != section->offset_within_address_space) {
 220        vfio_spapr_remove_window(container, create.start_addr);
 221
 222        error_report("Host doesn't support DMA window at %"HWADDR_PRIx", must be %"PRIx64,
 223                     section->offset_within_address_space,
 224                     (uint64_t)create.start_addr);
 225        return -EINVAL;
 226    }
 227    trace_vfio_spapr_create_window(create.page_shift,
 228                                   create.levels,
 229                                   create.window_size,
 230                                   create.start_addr);
 231    *pgsize = pagesize;
 232
 233    return 0;
 234}
 235
 236int vfio_spapr_remove_window(VFIOContainer *container,
 237                             hwaddr offset_within_address_space)
 238{
 239    struct vfio_iommu_spapr_tce_remove remove = {
 240        .argsz = sizeof(remove),
 241        .start_addr = offset_within_address_space,
 242    };
 243    int ret;
 244
 245    ret = ioctl(container->fd, VFIO_IOMMU_SPAPR_TCE_REMOVE, &remove);
 246    if (ret) {
 247        error_report("Failed to remove window at %"PRIx64,
 248                     (uint64_t)remove.start_addr);
 249        return -errno;
 250    }
 251
 252    trace_vfio_spapr_remove_window(offset_within_address_space);
 253
 254    return 0;
 255}
 256