KVM 设备虚拟文件接口

static long kvm_vm_ioctl(struct file *filp,   unsigned int ioctl, unsigned long arg) 

 { 

struct kvm *kvm = filp->private_data; 

void __user *argp = (void __user *)arg; 

int r; 



if (kvm->mm != current->mm) 

return -EIO; 

switch (ioctl) { 

case KVM_CREATE_VCPU: 

r = kvm_vm_ioctl_create_vcpu(kvm, arg); 

break; 

case KVM_SET_USER_MEMORY_REGION: { 

struct kvm_userspace_memory_region kvm_userspace_mem; 



r = -EFAULT; 

if (copy_from_user(&kvm_userspace_mem, argp, 

sizeof(kvm_userspace_mem))) 

goto out; 



r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem); 

break; 

} 

case KVM_GET_DIRTY_LOG: { 

struct kvm_dirty_log log; 



r = -EFAULT; 

if (copy_from_user(&log, argp, sizeof(log))) 

goto out; 

r = kvm_vm_ioctl_get_dirty_log(kvm, &log); 

break; 

} 

 #ifdef KVM_COALESCED_MMIO_PAGE_OFFSET 

case KVM_REGISTER_COALESCED_MMIO: { 

struct kvm_coalesced_mmio_zone zone; 



r = -EFAULT; 

if (copy_from_user(&zone, argp, sizeof(zone))) 

goto out; 

r = kvm_vm_ioctl_register_coalesced_mmio(kvm, &zone); 

break; 

} 

case KVM_UNREGISTER_COALESCED_MMIO: { 

struct kvm_coalesced_mmio_zone zone; 



r = -EFAULT; 

if (copy_from_user(&zone, argp, sizeof(zone))) 

goto out; 

r = kvm_vm_ioctl_unregister_coalesced_mmio(kvm, &zone); 

break; 

} 

 #endif 

case KVM_IRQFD: { 

struct kvm_irqfd data; 



r = -EFAULT; 

if (copy_from_user(&data, argp, sizeof(data))) 

goto out; 

r = kvm_irqfd(kvm, &data); 

break; 

} 

case KVM_IOEVENTFD: { 

struct kvm_ioeventfd data; 



r = -EFAULT; 

if (copy_from_user(&data, argp, sizeof(data))) 

goto out; 

r = kvm_ioeventfd(kvm, &data); 

break; 

} 

 #ifdef CONFIG_HAVE_KVM_MSI 

case KVM_SIGNAL_MSI: { 

struct kvm_msi msi; 



r = -EFAULT; 

if (copy_from_user(&msi, argp, sizeof(msi))) 

goto out; 

r = kvm_send_userspace_msi(kvm, &msi); 

break; 

} 

 #endif 

 #ifdef __KVM_HAVE_IRQ_LINE 

case KVM_IRQ_LINE_STATUS: 

case KVM_IRQ_LINE: { 

struct kvm_irq_level irq_event; 



r = -EFAULT; 

if (copy_from_user(&irq_event, argp, sizeof(irq_event))) 

goto out; 



r = kvm_vm_ioctl_irq_line(kvm, &irq_event, 

ioctl == KVM_IRQ_LINE_STATUS); 

if (r) 

goto out; 



r = -EFAULT; 

if (ioctl == KVM_IRQ_LINE_STATUS) { 

if (copy_to_user(argp, &irq_event, sizeof(irq_event))) 

goto out; 

} 



r = 0; 

break; 

} 

 #endif 

 #ifdef CONFIG_HAVE_KVM_IRQ_ROUTING 

case KVM_SET_GSI_ROUTING: { 

struct kvm_irq_routing routing; 

struct kvm_irq_routing __user *urouting; 

struct kvm_irq_routing_entry *entries = NULL; 



r = -EFAULT; 

if (copy_from_user(&routing, argp, sizeof(routing))) 

goto out; 

r = -EINVAL; 

if (routing.nr > KVM_MAX_IRQ_ROUTES) 

goto out; 

if (routing.flags) 

goto out; 

if (routing.nr) { 

r = -ENOMEM; 

entries = vmalloc(routing.nr * sizeof(*entries)); 

if (!entries) 

goto out; 

r = -EFAULT; 

urouting = argp; 

if (copy_from_user(entries, urouting->entries, 

  routing.nr * sizeof(*entries))) 

goto out_free_irq_routing; 

} 

r = kvm_set_irq_routing(kvm, entries, routing.nr, 

routing.flags); 

 out_free_irq_routing: 

vfree(entries); 

break; 

} 

 #endif /* CONFIG_HAVE_KVM_IRQ_ROUTING */ 

case KVM_CREATE_DEVICE: {
struct kvm_create_device cd;


r = -EFAULT;
if (copy_from_user(&cd, argp, sizeof(cd)))
goto out;


r = kvm_ioctl_create_device(kvm, &cd); 

if (r) 

goto out; 



r = -EFAULT; 

if (copy_to_user(argp, &cd, sizeof(cd))) 

goto out; 



r = 0; 

break; 

} 

case KVM_CHECK_EXTENSION: 

r = kvm_vm_ioctl_check_extension_generic(kvm, arg); 

break; 

default: 

r = kvm_arch_vm_ioctl(filp, ioctl, arg); 

} 

 out: 

return r; 
}

 static int kvm_ioctl_create_device(struct kvm *kvm,
  struct kvm_create_device *cd)
 {
struct kvm_device_ops *ops = NULL;
struct kvm_device *dev;
bool test = cd->flags & KVM_CREATE_DEVICE_TEST;
int ret;


if (cd->type >= ARRAY_SIZE(kvm_device_ops_table))
return -ENODEV;


ops = kvm_device_ops_table[cd->type];
if (ops == NULL)
return -ENODEV;


if (test)
return 0;


dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;


dev->ops = ops;
dev->kvm = kvm;


mutex_lock(&kvm->lock);
ret = ops->create(dev, cd->type);
if (ret < 0) {
mutex_unlock(&kvm->lock);
kfree(dev);
return ret;
}
list_add(&dev->vm_node, &kvm->devices);
mutex_unlock(&kvm->lock);


if (ops->init)
ops->init(dev);


ret = anon_inode_getfd(ops->name, &kvm_device_fops, dev, O_RDWR | O_CLOEXEC);
if (ret < 0) {
mutex_lock(&kvm->lock);
list_del(&dev->vm_node);
mutex_unlock(&kvm->lock);
ops->destroy(dev);
return ret;
}


kvm_get_kvm(kvm);
cd->fd = ret;
return 0;
 }
static const struct file_operations kvm_device_fops = {
.unlocked_ioctl = kvm_device_ioctl,
 #ifdef CONFIG_KVM_COMPAT
.compat_ioctl = kvm_device_ioctl,
 #endif
.release = kvm_device_release,
 };
static long kvm_device_ioctl(struct file *filp, unsigned int ioctl,
    unsigned long arg)
 {
struct kvm_device *dev = filp->private_data;


switch (ioctl) {
case KVM_SET_DEVICE_ATTR:
return kvm_device_ioctl_attr(dev, dev->ops->set_attr, arg);
case KVM_GET_DEVICE_ATTR:
return kvm_device_ioctl_attr(dev, dev->ops->get_attr, arg);
case KVM_HAS_DEVICE_ATTR:
return kvm_device_ioctl_attr(dev, dev->ops->has_attr, arg);
default:
if (dev->ops->ioctl)
return dev->ops->ioctl(dev, ioctl, arg);


return -ENOTTY;
}
 }