History

kvm: Add VFIO device

So far we've succeeded at making KVM and VFIO mostly unaware of each other, but areas are cropping up where a connection beyond eventfds and irqfds needs to be made. This patch introduces a KVM-VFIO device that is meant to be a gateway for such interaction. The user creates the device and can add and remove VFIO groups to it via file descriptors. When a group is added, KVM verifies the group is valid and gets a reference to it via the VFIO external user interface.

Alex Williamson committed 13 years ago

Commit ec535001 parent 84cffe48 files · +257 −1Browse files

Unified · Split

8 files
  1. Documentation/virtual/kvm/devices/vfio.txt +22 −0
  2. arch/x86/kvm/Kconfig +1 −0
  3. arch/x86/kvm/Makefile +1 −1
  4. include/linux/kvm_host.h +1 −0
  5. include/uapi/linux/kvm.h +4 −0
  6. virt/kvm/Kconfig +3 −0
  7. virt/kvm/kvm_main.c +5 −0
  8. virt/kvm/vfio.c +220 −0
Documentation/virtual/kvm/devices/vfio.txt+22−0
@@ -0,0 +1,22 @@
1VFIO virtual device
2===================
3
4Device types supported:
5 KVM_DEV_TYPE_VFIO
6
7Only one VFIO instance may be created per VM. The created device
8tracks VFIO groups in use by the VM and features of those groups
9important to the correctness and acceleration of the VM. As groups
10are enabled and disabled for use by the VM, KVM should be updated
11about their presence. When registered with KVM, a reference to the
12VFIO-group is held by KVM.
13
14Groups:
15 KVM_DEV_VFIO_GROUP
16
17KVM_DEV_VFIO_GROUP attributes:
18 KVM_DEV_VFIO_GROUP_ADD: Add a VFIO group to VFIO-KVM device tracking
19 KVM_DEV_VFIO_GROUP_DEL: Remove a VFIO group from VFIO-KVM device tracking
20
21For each, kvm_device_attr.addr points to an int32_t file descriptor
22for the VFIO group.
arch/x86/kvm/Kconfig+1−0
@@ -38,6 +38,7 @@ config KVM · 37 unmodified lines
38 select PERF_EVENTS38 select PERF_EVENTS
39 select HAVE_KVM_MSI39 select HAVE_KVM_MSI
40 select HAVE_KVM_CPU_RELAX_INTERCEPT40 select HAVE_KVM_CPU_RELAX_INTERCEPT
41 select KVM_VFIO
41 ---help---42 ---help---
42 Support hosting fully virtualized guest machines using hardware43 Support hosting fully virtualized guest machines using hardware
43 virtualization extensions. You will need a fairly recent44 virtualization extensions. You will need a fairly recent
arch/x86/kvm/Makefile+1−1
@@ -9,7 +9,7 @@ KVM := ../../../virt/kvm · 8 unmodified lines
9 9
10kvm-y += $(KVM)/kvm_main.o $(KVM)/ioapic.o \10kvm-y += $(KVM)/kvm_main.o $(KVM)/ioapic.o \
11 $(KVM)/coalesced_mmio.o $(KVM)/irq_comm.o \11 $(KVM)/coalesced_mmio.o $(KVM)/irq_comm.o \
12 $(KVM)/eventfd.o $(KVM)/irqchip.o12 $(KVM)/eventfd.o $(KVM)/irqchip.o $(KVM)/vfio.o
13kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT) += $(KVM)/assigned-dev.o $(KVM)/iommu.o13kvm-$(CONFIG_KVM_DEVICE_ASSIGNMENT) += $(KVM)/assigned-dev.o $(KVM)/iommu.o
14kvm-$(CONFIG_KVM_ASYNC_PF) += $(KVM)/async_pf.o14kvm-$(CONFIG_KVM_ASYNC_PF) += $(KVM)/async_pf.o
15 15
include/linux/kvm_host.h+1−0
@@ -1058,6 +1058,7 @@ struct kvm_device *kvm_device_from_filp(struct file *filp); · 1057 unmodified lines
1058 1058
1059extern struct kvm_device_ops kvm_mpic_ops;1059extern struct kvm_device_ops kvm_mpic_ops;
1060extern struct kvm_device_ops kvm_xics_ops;1060extern struct kvm_device_ops kvm_xics_ops;
1061extern struct kvm_device_ops kvm_vfio_ops;
1061 1062
1062#ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT1063#ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
1063 1064
include/uapi/linux/kvm.h+4−0
@@ -845,6 +845,10 @@ struct kvm_device_attr { · 844 unmodified lines
845#define KVM_DEV_TYPE_FSL_MPIC_20 1845#define KVM_DEV_TYPE_FSL_MPIC_20 1
846#define KVM_DEV_TYPE_FSL_MPIC_42 2846#define KVM_DEV_TYPE_FSL_MPIC_42 2
847#define KVM_DEV_TYPE_XICS 3847#define KVM_DEV_TYPE_XICS 3
848#define KVM_DEV_TYPE_VFIO 4
849#define KVM_DEV_VFIO_GROUP 1
850#define KVM_DEV_VFIO_GROUP_ADD 1
851#define KVM_DEV_VFIO_GROUP_DEL 2
848 852
849/*853/*
850 * ioctls for VM fds854 * ioctls for VM fds
virt/kvm/Kconfig+3−0
@@ -27,3 +27,6 @@ config HAVE_KVM_MSI · 26 unmodified lines
27 27
28config HAVE_KVM_CPU_RELAX_INTERCEPT28config HAVE_KVM_CPU_RELAX_INTERCEPT
29 bool29 bool
30
31config KVM_VFIO
32 bool
virt/kvm/kvm_main.c+5−0
@@ -2270,6 +2270,11 @@ static int kvm_ioctl_create_device(struct kvm *kvm, · 2269 unmodified lines
2270 case KVM_DEV_TYPE_XICS:2270 case KVM_DEV_TYPE_XICS:
2271 ops = &kvm_xics_ops;2271 ops = &kvm_xics_ops;
2272 break;2272 break;
2273#endif
2274#ifdef CONFIG_KVM_VFIO
2275 case KVM_DEV_TYPE_VFIO:
2276 ops = &kvm_vfio_ops;
2277 break;
2273#endif2278#endif
2274 default:2279 default:
2275 return -ENODEV;2280 return -ENODEV;
virt/kvm/vfio.c+220−0
@@ -0,0 +1,220 @@
1/*
2 * VFIO-KVM bridge pseudo device
3 *
4 * Copyright (C) 2013 Red Hat, Inc. All rights reserved.
5 * Author: Alex Williamson <alex.williamson@redhat.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/errno.h>
13#include <linux/file.h>
14#include <linux/kvm_host.h>
15#include <linux/list.h>
16#include <linux/module.h>
17#include <linux/mutex.h>
18#include <linux/slab.h>
19#include <linux/uaccess.h>
20#include <linux/vfio.h>
21
22struct kvm_vfio_group {
23 struct list_head node;
24 struct vfio_group *vfio_group;
25};
26
27struct kvm_vfio {
28 struct list_head group_list;
29 struct mutex lock;
30};
31
32static struct vfio_group *kvm_vfio_group_get_external_user(struct file *filep)
33{
34 struct vfio_group *vfio_group;
35 struct vfio_group *(*fn)(struct file *);
36
37 fn = symbol_get(vfio_group_get_external_user);
38 if (!fn)
39 return ERR_PTR(-EINVAL);
40
41 vfio_group = fn(filep);
42
43 symbol_put(vfio_group_get_external_user);
44
45 return vfio_group;
46}
47
48static void kvm_vfio_group_put_external_user(struct vfio_group *vfio_group)
49{
50 void (*fn)(struct vfio_group *);
51
52 fn = symbol_get(vfio_group_put_external_user);
53 if (!fn)
54 return;
55
56 fn(vfio_group);
57
58 symbol_put(vfio_group_put_external_user);
59}
60
61static int kvm_vfio_set_group(struct kvm_device *dev, long attr, u64 arg)
62{
63 struct kvm_vfio *kv = dev->private;
64 struct vfio_group *vfio_group;
65 struct kvm_vfio_group *kvg;
66 void __user *argp = (void __user *)arg;
67 struct fd f;
68 int32_t fd;
69 int ret;
70
71 switch (attr) {
72 case KVM_DEV_VFIO_GROUP_ADD:
73 if (get_user(fd, (int32_t __user *)argp))
74 return -EFAULT;
75
76 f = fdget(fd);
77 if (!f.file)
78 return -EBADF;
79
80 vfio_group = kvm_vfio_group_get_external_user(f.file);
81 fdput(f);
82
83 if (IS_ERR(vfio_group))
84 return PTR_ERR(vfio_group);
85
86 mutex_lock(&kv->lock);
87
88 list_for_each_entry(kvg, &kv->group_list, node) {
89 if (kvg->vfio_group == vfio_group) {
90 mutex_unlock(&kv->lock);
91 kvm_vfio_group_put_external_user(vfio_group);
92 return -EEXIST;
93 }
94 }
95
96 kvg = kzalloc(sizeof(*kvg), GFP_KERNEL);
97 if (!kvg) {
98 mutex_unlock(&kv->lock);
99 kvm_vfio_group_put_external_user(vfio_group);
100 return -ENOMEM;
101 }
102
103 list_add_tail(&kvg->node, &kv->group_list);
104 kvg->vfio_group = vfio_group;
105
106 mutex_unlock(&kv->lock);
107
108 return 0;
109
110 case KVM_DEV_VFIO_GROUP_DEL:
111 if (get_user(fd, (int32_t __user *)argp))
112 return -EFAULT;
113
114 f = fdget(fd);
115 if (!f.file)
116 return -EBADF;
117
118 vfio_group = kvm_vfio_group_get_external_user(f.file);
119 fdput(f);
120
121 if (IS_ERR(vfio_group))
122 return PTR_ERR(vfio_group);
123
124 ret = -ENOENT;
125
126 mutex_lock(&kv->lock);
127
128 list_for_each_entry(kvg, &kv->group_list, node) {
129 if (kvg->vfio_group != vfio_group)
130 continue;
131
132 list_del(&kvg->node);
133 kvm_vfio_group_put_external_user(kvg->vfio_group);
134 kfree(kvg);
135 ret = 0;
136 break;
137 }
138
139 mutex_unlock(&kv->lock);
140
141 kvm_vfio_group_put_external_user(vfio_group);
142
143 return ret;
144 }
145
146 return -ENXIO;
147}
148
149static int kvm_vfio_set_attr(struct kvm_device *dev,
150 struct kvm_device_attr *attr)
151{
152 switch (attr->group) {
153 case KVM_DEV_VFIO_GROUP:
154 return kvm_vfio_set_group(dev, attr->attr, attr->addr);
155 }
156
157 return -ENXIO;
158}
159
160static int kvm_vfio_has_attr(struct kvm_device *dev,
161 struct kvm_device_attr *attr)
162{
163 switch (attr->group) {
164 case KVM_DEV_VFIO_GROUP:
165 switch (attr->attr) {
166 case KVM_DEV_VFIO_GROUP_ADD:
167 case KVM_DEV_VFIO_GROUP_DEL:
168 return 0;
169 }
170
171 break;
172 }
173
174 return -ENXIO;
175}
176
177static void kvm_vfio_destroy(struct kvm_device *dev)
178{
179 struct kvm_vfio *kv = dev->private;
180 struct kvm_vfio_group *kvg, *tmp;
181
182 list_for_each_entry_safe(kvg, tmp, &kv->group_list, node) {
183 kvm_vfio_group_put_external_user(kvg->vfio_group);
184 list_del(&kvg->node);
185 kfree(kvg);
186 }
187
188 kfree(kv);
189 kfree(dev); /* alloc by kvm_ioctl_create_device, free by .destroy */
190}
191
192static int kvm_vfio_create(struct kvm_device *dev, u32 type)
193{
194 struct kvm_device *tmp;
195 struct kvm_vfio *kv;
196
197 /* Only one VFIO "device" per VM */
198 list_for_each_entry(tmp, &dev->kvm->devices, vm_node)
199 if (tmp->ops == &kvm_vfio_ops)
200 return -EBUSY;
201
202 kv = kzalloc(sizeof(*kv), GFP_KERNEL);
203 if (!kv)
204 return -ENOMEM;
205
206 INIT_LIST_HEAD(&kv->group_list);
207 mutex_init(&kv->lock);
208
209 dev->private = kv;
210
211 return 0;
212}
213
214struct kvm_device_ops kvm_vfio_ops = {
215 .name = "kvm-vfio",
216 .create = kvm_vfio_create,
217 .destroy = kvm_vfio_destroy,
218 .set_attr = kvm_vfio_set_attr,
219 .has_attr = kvm_vfio_has_attr,
220};

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t