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 #include "vfio.h" 22 23 struct kvm_vfio_group { 24 struct list_head node; 25 struct vfio_group *vfio_group; 26 }; 27 28 struct kvm_vfio { 29 struct list_head group_list; 30 struct mutex lock; 31 bool noncoherent; 32 }; 33 34 static struct vfio_group *kvm_vfio_group_get_external_user(struct file *filep) 35 { 36 struct vfio_group *vfio_group; 37 struct vfio_group *(*fn)(struct file *); 38 39 fn = symbol_get(vfio_group_get_external_user); 40 if (!fn) 41 return ERR_PTR(-EINVAL); 42 43 vfio_group = fn(filep); 44 45 symbol_put(vfio_group_get_external_user); 46 47 return vfio_group; 48 } 49 50 static void kvm_vfio_group_put_external_user(struct vfio_group *vfio_group) 51 { 52 void (*fn)(struct vfio_group *); 53 54 fn = symbol_get(vfio_group_put_external_user); 55 if (!fn) 56 return; 57 58 fn(vfio_group); 59 60 symbol_put(vfio_group_put_external_user); 61 } 62 63 static bool kvm_vfio_group_is_coherent(struct vfio_group *vfio_group) 64 { 65 long (*fn)(struct vfio_group *, unsigned long); 66 long ret; 67 68 fn = symbol_get(vfio_external_check_extension); 69 if (!fn) 70 return false; 71 72 ret = fn(vfio_group, VFIO_DMA_CC_IOMMU); 73 74 symbol_put(vfio_external_check_extension); 75 76 return ret > 0; 77 } 78 79 /* 80 * Groups can use the same or different IOMMU domains. If the same then 81 * adding a new group may change the coherency of groups we've previously 82 * been told about. We don't want to care about any of that so we retest 83 * each group and bail as soon as we find one that's noncoherent. This 84 * means we only ever [un]register_noncoherent_dma once for the whole device. 85 */ 86 static void kvm_vfio_update_coherency(struct kvm_device *dev) 87 { 88 struct kvm_vfio *kv = dev->private; 89 bool noncoherent = false; 90 struct kvm_vfio_group *kvg; 91 92 mutex_lock(&kv->lock); 93 94 list_for_each_entry(kvg, &kv->group_list, node) { 95 if (!kvm_vfio_group_is_coherent(kvg->vfio_group)) { 96 noncoherent = true; 97 break; 98 } 99 } 100 101 if (noncoherent != kv->noncoherent) { 102 kv->noncoherent = noncoherent; 103 104 if (kv->noncoherent) 105 kvm_arch_register_noncoherent_dma(dev->kvm); 106 else 107 kvm_arch_unregister_noncoherent_dma(dev->kvm); 108 } 109 110 mutex_unlock(&kv->lock); 111 } 112 113 static int kvm_vfio_set_group(struct kvm_device *dev, long attr, u64 arg) 114 { 115 struct kvm_vfio *kv = dev->private; 116 struct vfio_group *vfio_group; 117 struct kvm_vfio_group *kvg; 118 int32_t __user *argp = (int32_t __user *)(unsigned long)arg; 119 struct fd f; 120 int32_t fd; 121 int ret; 122 123 switch (attr) { 124 case KVM_DEV_VFIO_GROUP_ADD: 125 if (get_user(fd, argp)) 126 return -EFAULT; 127 128 f = fdget(fd); 129 if (!f.file) 130 return -EBADF; 131 132 vfio_group = kvm_vfio_group_get_external_user(f.file); 133 fdput(f); 134 135 if (IS_ERR(vfio_group)) 136 return PTR_ERR(vfio_group); 137 138 mutex_lock(&kv->lock); 139 140 list_for_each_entry(kvg, &kv->group_list, node) { 141 if (kvg->vfio_group == vfio_group) { 142 mutex_unlock(&kv->lock); 143 kvm_vfio_group_put_external_user(vfio_group); 144 return -EEXIST; 145 } 146 } 147 148 kvg = kzalloc(sizeof(*kvg), GFP_KERNEL); 149 if (!kvg) { 150 mutex_unlock(&kv->lock); 151 kvm_vfio_group_put_external_user(vfio_group); 152 return -ENOMEM; 153 } 154 155 list_add_tail(&kvg->node, &kv->group_list); 156 kvg->vfio_group = vfio_group; 157 158 kvm_arch_start_assignment(dev->kvm); 159 160 mutex_unlock(&kv->lock); 161 162 kvm_vfio_update_coherency(dev); 163 164 return 0; 165 166 case KVM_DEV_VFIO_GROUP_DEL: 167 if (get_user(fd, argp)) 168 return -EFAULT; 169 170 f = fdget(fd); 171 if (!f.file) 172 return -EBADF; 173 174 vfio_group = kvm_vfio_group_get_external_user(f.file); 175 fdput(f); 176 177 if (IS_ERR(vfio_group)) 178 return PTR_ERR(vfio_group); 179 180 ret = -ENOENT; 181 182 mutex_lock(&kv->lock); 183 184 list_for_each_entry(kvg, &kv->group_list, node) { 185 if (kvg->vfio_group != vfio_group) 186 continue; 187 188 list_del(&kvg->node); 189 kvm_vfio_group_put_external_user(kvg->vfio_group); 190 kfree(kvg); 191 ret = 0; 192 break; 193 } 194 195 kvm_arch_end_assignment(dev->kvm); 196 197 mutex_unlock(&kv->lock); 198 199 kvm_vfio_group_put_external_user(vfio_group); 200 201 kvm_vfio_update_coherency(dev); 202 203 return ret; 204 } 205 206 return -ENXIO; 207 } 208 209 static int kvm_vfio_set_attr(struct kvm_device *dev, 210 struct kvm_device_attr *attr) 211 { 212 switch (attr->group) { 213 case KVM_DEV_VFIO_GROUP: 214 return kvm_vfio_set_group(dev, attr->attr, attr->addr); 215 } 216 217 return -ENXIO; 218 } 219 220 static int kvm_vfio_has_attr(struct kvm_device *dev, 221 struct kvm_device_attr *attr) 222 { 223 switch (attr->group) { 224 case KVM_DEV_VFIO_GROUP: 225 switch (attr->attr) { 226 case KVM_DEV_VFIO_GROUP_ADD: 227 case KVM_DEV_VFIO_GROUP_DEL: 228 return 0; 229 } 230 231 break; 232 } 233 234 return -ENXIO; 235 } 236 237 static void kvm_vfio_destroy(struct kvm_device *dev) 238 { 239 struct kvm_vfio *kv = dev->private; 240 struct kvm_vfio_group *kvg, *tmp; 241 242 list_for_each_entry_safe(kvg, tmp, &kv->group_list, node) { 243 kvm_vfio_group_put_external_user(kvg->vfio_group); 244 list_del(&kvg->node); 245 kfree(kvg); 246 kvm_arch_end_assignment(dev->kvm); 247 } 248 249 kvm_vfio_update_coherency(dev); 250 251 kfree(kv); 252 kfree(dev); /* alloc by kvm_ioctl_create_device, free by .destroy */ 253 } 254 255 static int kvm_vfio_create(struct kvm_device *dev, u32 type); 256 257 static struct kvm_device_ops kvm_vfio_ops = { 258 .name = "kvm-vfio", 259 .create = kvm_vfio_create, 260 .destroy = kvm_vfio_destroy, 261 .set_attr = kvm_vfio_set_attr, 262 .has_attr = kvm_vfio_has_attr, 263 }; 264 265 static int kvm_vfio_create(struct kvm_device *dev, u32 type) 266 { 267 struct kvm_device *tmp; 268 struct kvm_vfio *kv; 269 270 /* Only one VFIO "device" per VM */ 271 list_for_each_entry(tmp, &dev->kvm->devices, vm_node) 272 if (tmp->ops == &kvm_vfio_ops) 273 return -EBUSY; 274 275 kv = kzalloc(sizeof(*kv), GFP_KERNEL); 276 if (!kv) 277 return -ENOMEM; 278 279 INIT_LIST_HEAD(&kv->group_list); 280 mutex_init(&kv->lock); 281 282 dev->private = kv; 283 284 return 0; 285 } 286 287 int kvm_vfio_ops_init(void) 288 { 289 return kvm_register_device_ops(&kvm_vfio_ops, KVM_DEV_TYPE_VFIO); 290 } 291 292 void kvm_vfio_ops_exit(void) 293 { 294 kvm_unregister_device_ops(KVM_DEV_TYPE_VFIO); 295 } 296