eventfd.c File Reference

#include <linux/kvm_host.h>
#include <linux/kvm.h>
#include <linux/kvm_irqfd.h>
#include <linux/workqueue.h>
#include <linux/syscalls.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/file.h>
#include <linux/list.h>
#include <linux/eventfd.h>
#include <linux/kernel.h>
#include <linux/srcu.h>
#include <linux/slab.h>
#include <linux/seqlock.h>
#include <linux/irqbypass.h>
#include <trace/events/kvm.h>
#include <kvm/iodev.h>

Include dependency graph for eventfd.c:

Go to the source code of this file.

Classes
struct	_ioeventfd

Functions
static struct _ioeventfd *	to_ioeventfd (struct kvm_io_device *dev)
static void	ioeventfd_release (struct _ioeventfd *p)
static bool	ioeventfd_in_range (struct _ioeventfd *p, gpa_t addr, int len, const void *val)
static int	ioeventfd_write (struct kvm_vcpu *vcpu, struct kvm_io_device *this, gpa_t addr, int len, const void *val)
static void	ioeventfd_destructor (struct kvm_io_device *this)
static bool	ioeventfd_check_collision (struct kvm *kvm, struct _ioeventfd *p)
static enum kvm_bus	ioeventfd_bus_from_flags (__u32 flags)
static int	kvm_assign_ioeventfd_idx (struct kvm *kvm, enum kvm_bus bus_idx, struct kvm_ioeventfd *args)
static int	kvm_deassign_ioeventfd_idx (struct kvm *kvm, enum kvm_bus bus_idx, struct kvm_ioeventfd *args)
static int	kvm_deassign_ioeventfd (struct kvm *kvm, struct kvm_ioeventfd *args)
static int	kvm_assign_ioeventfd (struct kvm *kvm, struct kvm_ioeventfd *args)
int	kvm_ioeventfd (struct kvm *kvm, struct kvm_ioeventfd *args)
void	kvm_eventfd_init (struct kvm *kvm)

Variables
static const struct kvm_io_device_ops	ioeventfd_ops

Function Documentation

ioeventfd_bus_from_flags()

static enum kvm_bus ioeventfd_bus_from_flags ( __u32  flags )

static

Definition at line 798 of file eventfd.c.

{
    if (flags & KVM_IOEVENTFD_FLAG_PIO)
        return KVM_PIO_BUS;
    if (flags & KVM_IOEVENTFD_FLAG_VIRTIO_CCW_NOTIFY)
        return KVM_VIRTIO_CCW_NOTIFY_BUS;
    return KVM_MMIO_BUS;
}

Here is the caller graph for this function:

ioeventfd_check_collision()

static bool ioeventfd_check_collision ( struct kvm *  kvm, struct _ioeventfd *  p  )

static

Definition at line 798 of file eventfd.c.

{
    struct _ioeventfd *_p;
 
    list_for_each_entry(_p, &kvm->ioeventfds, list)
        if (_p->bus_idx == p->bus_idx &&
            _p->addr == p->addr &&
            (!_p->length || !p->length ||
             (_p->length == p->length &&
              (_p->wildcard || p->wildcard ||
               _p->datamatch == p->datamatch))))
            return true;
 
    return false;
}

Here is the caller graph for this function:

ioeventfd_destructor()

static void ioeventfd_destructor ( struct kvm_io_device *  this )

static

Definition at line 784 of file eventfd.c.

{
    struct _ioeventfd *p = to_ioeventfd(this);
 
    ioeventfd_release(p);
}

Here is the call graph for this function:

ioeventfd_in_range()

static bool ioeventfd_in_range ( struct _ioeventfd *  p, gpa_t  addr, int  len, const void *  val  )

static

Definition at line 721 of file eventfd.c.

{
    u64 _val;
 
    if (addr != p->addr)
        /* address must be precise for a hit */
        return false;
 
    if (!p->length)
        /* length = 0 means only look at the address, so always a hit */
        return true;
 
    if (len != p->length)
        /* address-range must be precise for a hit */
        return false;
 
    if (p->wildcard)
        /* all else equal, wildcard is always a hit */
        return true;
 
    /* otherwise, we have to actually compare the data */
 
    BUG_ON(!IS_ALIGNED((unsigned long)val, len));
 
    switch (len) {
    case 1:
        _val = *(u8 *)val;
        break;
    case 2:
        _val = *(u16 *)val;
        break;
    case 4:
        _val = *(u32 *)val;
        break;
    case 8:
        _val = *(u64 *)val;
        break;
    default:
        return false;
    }
 
    return _val == p->datamatch;
}

Here is the caller graph for this function:

ioeventfd_release()

static void ioeventfd_release ( struct _ioeventfd *  p )

static

Definition at line 713 of file eventfd.c.

{
    eventfd_ctx_put(p->eventfd);
    list_del(&p->list);
    kfree(p);
}

Here is the caller graph for this function:

ioeventfd_write()

static int ioeventfd_write ( struct kvm_vcpu *  vcpu, struct kvm_io_device *  this, gpa_t  addr, int  len, const void *  val  )

static

Definition at line 767 of file eventfd.c.

{
    struct _ioeventfd *p = to_ioeventfd(this);
 
    if (!ioeventfd_in_range(p, addr, len, val))
        return -EOPNOTSUPP;
 
    eventfd_signal(p->eventfd);
    return 0;
}

Here is the call graph for this function:

kvm_assign_ioeventfd()

static int kvm_assign_ioeventfd ( struct kvm *  kvm, struct kvm_ioeventfd *  args  )

static

Definition at line 942 of file eventfd.c.

{
    enum kvm_bus              bus_idx;
    int ret;
 
    bus_idx = ioeventfd_bus_from_flags(args->flags);
    /* must be natural-word sized, or 0 to ignore length */
    switch (args->len) {
    case 0:
    case 1:
    case 2:
    case 4:
    case 8:
        break;
    default:
        return -EINVAL;
    }
 
    /* check for range overflow */
    if (args->addr + args->len < args->addr)
        return -EINVAL;
 
    /* check for extra flags that we don't understand */
    if (args->flags & ~KVM_IOEVENTFD_VALID_FLAG_MASK)
        return -EINVAL;
 
    /* ioeventfd with no length can't be combined with DATAMATCH */
    if (!args->len && (args->flags & KVM_IOEVENTFD_FLAG_DATAMATCH))
        return -EINVAL;
 
    ret = kvm_assign_ioeventfd_idx(kvm, bus_idx, args);
    if (ret)
        goto fail;
 
    /* When length is ignored, MMIO is also put on a separate bus, for
     * faster lookups.
     */
    if (!args->len && bus_idx == KVM_MMIO_BUS) {
        ret = kvm_assign_ioeventfd_idx(kvm, KVM_FAST_MMIO_BUS, args);
        if (ret < 0)
            goto fast_fail;
    }
 
    return 0;
 
fast_fail:
    kvm_deassign_ioeventfd_idx(kvm, bus_idx, args);
fail:
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_assign_ioeventfd_idx()

static int kvm_assign_ioeventfd_idx ( struct kvm *  kvm, enum kvm_bus  bus_idx, struct kvm_ioeventfd *  args  )

static

Definition at line 823 of file eventfd.c.

{
 
    struct eventfd_ctx *eventfd;
    struct _ioeventfd *p;
    int ret;
 
    eventfd = eventfd_ctx_fdget(args->fd);
    if (IS_ERR(eventfd))
        return PTR_ERR(eventfd);
 
    p = kzalloc(sizeof(*p), GFP_KERNEL_ACCOUNT);
    if (!p) {
        ret = -ENOMEM;
        goto fail;
    }
 
    INIT_LIST_HEAD(&p->list);
    p->addr    = args->addr;
    p->bus_idx = bus_idx;
    p->length  = args->len;
    p->eventfd = eventfd;
 
    /* The datamatch feature is optional, otherwise this is a wildcard */
    if (args->flags & KVM_IOEVENTFD_FLAG_DATAMATCH)
        p->datamatch = args->datamatch;
    else
        p->wildcard = true;
 
    mutex_lock(&kvm->slots_lock);
 
    /* Verify that there isn't a match already */
    if (ioeventfd_check_collision(kvm, p)) {
        ret = -EEXIST;
        goto unlock_fail;
    }
 
    kvm_iodevice_init(&p->dev, &ioeventfd_ops);
 
    ret = kvm_io_bus_register_dev(kvm, bus_idx, p->addr, p->length,
                      &p->dev);
    if (ret < 0)
        goto unlock_fail;
 
    kvm_get_bus(kvm, bus_idx)->ioeventfd_count++;
    list_add_tail(&p->list, &kvm->ioeventfds);
 
    mutex_unlock(&kvm->slots_lock);
 
    return 0;
 
unlock_fail:
    mutex_unlock(&kvm->slots_lock);
    kfree(p);
 
fail:
    eventfd_ctx_put(eventfd);
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_deassign_ioeventfd()

static int kvm_deassign_ioeventfd ( struct kvm *  kvm, struct kvm_ioeventfd *  args  )

static

Definition at line 930 of file eventfd.c.

{
    enum kvm_bus bus_idx = ioeventfd_bus_from_flags(args->flags);
    int ret = kvm_deassign_ioeventfd_idx(kvm, bus_idx, args);
 
    if (!args->len && bus_idx == KVM_MMIO_BUS)
        kvm_deassign_ioeventfd_idx(kvm, KVM_FAST_MMIO_BUS, args);
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_deassign_ioeventfd_idx()

static int kvm_deassign_ioeventfd_idx ( struct kvm *  kvm, enum kvm_bus  bus_idx, struct kvm_ioeventfd *  args  )

static

Definition at line 887 of file eventfd.c.

{
    struct _ioeventfd        *p;
    struct eventfd_ctx       *eventfd;
    struct kvm_io_bus    *bus;
    int                       ret = -ENOENT;
    bool                      wildcard;
 
    eventfd = eventfd_ctx_fdget(args->fd);
    if (IS_ERR(eventfd))
        return PTR_ERR(eventfd);
 
    wildcard = !(args->flags & KVM_IOEVENTFD_FLAG_DATAMATCH);
 
    mutex_lock(&kvm->slots_lock);
 
    list_for_each_entry(p, &kvm->ioeventfds, list) {
        if (p->bus_idx != bus_idx ||
            p->eventfd != eventfd  ||
            p->addr != args->addr  ||
            p->length != args->len ||
            p->wildcard != wildcard)
            continue;
 
        if (!p->wildcard && p->datamatch != args->datamatch)
            continue;
 
        kvm_io_bus_unregister_dev(kvm, bus_idx, &p->dev);
        bus = kvm_get_bus(kvm, bus_idx);
        if (bus)
            bus->ioeventfd_count--;
        ret = 0;
        break;
    }
 
    mutex_unlock(&kvm->slots_lock);
 
    eventfd_ctx_put(eventfd);
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_eventfd_init()

void kvm_eventfd_init

(

struct kvm *

kvm

)

Definition at line 1003 of file eventfd.c.

{
#ifdef CONFIG_HAVE_KVM_IRQCHIP
    spin_lock_init(&kvm->irqfds.lock);
    INIT_LIST_HEAD(&kvm->irqfds.items);
    INIT_LIST_HEAD(&kvm->irqfds.resampler_list);
    mutex_init(&kvm->irqfds.resampler_lock);
#endif
    INIT_LIST_HEAD(&kvm->ioeventfds);
}

Here is the caller graph for this function:

kvm_ioeventfd()

int kvm_ioeventfd	(	struct kvm *	kvm,
		struct kvm_ioeventfd *	args
	)

Definition at line 994 of file eventfd.c.

{
    if (args->flags & KVM_IOEVENTFD_FLAG_DEASSIGN)
        return kvm_deassign_ioeventfd(kvm, args);
 
    return kvm_assign_ioeventfd(kvm, args);
}

Here is the call graph for this function:

to_ioeventfd()

static struct _ioeventfd* to_ioeventfd ( struct kvm_io_device *  dev )

inlinestatic

Definition at line 707 of file eventfd.c.

{
    return container_of(dev, struct _ioeventfd, dev);
}

Here is the caller graph for this function:

Variable Documentation

ioeventfd_ops

const struct kvm_io_device_ops ioeventfd_ops

static

Initial value:

= {
    .write      = ioeventfd_write,
    .destructor = ioeventfd_destructor,
}

Definition at line 784 of file eventfd.c.