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