// SPDX-License-Identifier: GPL-2.0 OR MIT /****************************************************************************** * privcmd-buf.c * * Mmap of hypercall buffers. * * Copyright (c) 2018 Juergen Gross */ #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt #include <linux/kernel.h>#include <linux/module.h>#include <linux/list.h>#include <linux/miscdevice.h>#include <linux/mm.h>#include <linux/slab.h> #include "privcmd.h" MODULE_DESCRIPTION("Xen Mmap of hypercall buffers");MODULE_LICENSE("GPL"); struct privcmd_buf_private {	struct mutex lock;	struct list_head list;}; struct privcmd_buf_vma_private {	struct privcmd_buf_private *file_priv;	struct list_head list;	unsigned int users;	unsigned int n_pages;	struct page *pages[];}; static int privcmd_buf_open(struct inode *ino, struct file *file){	struct privcmd_buf_private *file_priv; 	file_priv = kzalloc_obj(*file_priv);	if (!file_priv)		return -ENOMEM; 	mutex_init(&file_priv->lock);	INIT_LIST_HEAD(&file_priv->list); 	file->private_data = file_priv; 	return 0;} static void privcmd_buf_vmapriv_free(struct privcmd_buf_vma_private *vma_priv){	unsigned int i; 	list_del(&vma_priv->list); 	for (i = 0; i < vma_priv->n_pages; i++)		__free_page(vma_priv->pages[i]); 	kfree(vma_priv);} static int privcmd_buf_release(struct inode *ino, struct file *file){	struct privcmd_buf_private *file_priv = file->private_data;	struct privcmd_buf_vma_private *vma_priv; 	mutex_lock(&file_priv->lock); 	while (!list_empty(&file_priv->list)) {		vma_priv = list_first_entry(&file_priv->list,					    struct privcmd_buf_vma_private,					    list);		privcmd_buf_vmapriv_free(vma_priv);	} 	mutex_unlock(&file_priv->lock); 	kfree(file_priv); 	return 0;} static void privcmd_buf_vma_open(struct vm_area_struct *vma){	struct privcmd_buf_vma_private *vma_priv = vma->vm_private_data; 	if (!vma_priv)		return; 	mutex_lock(&vma_priv->file_priv->lock);	vma_priv->users++;	mutex_unlock(&vma_priv->file_priv->lock);} static void privcmd_buf_vma_close(struct vm_area_struct *vma){	struct privcmd_buf_vma_private *vma_priv = vma->vm_private_data;	struct privcmd_buf_private *file_priv; 	if (!vma_priv)		return; 	file_priv = vma_priv->file_priv; 	mutex_lock(&file_priv->lock); 	vma_priv->users--;	if (!vma_priv->users)		privcmd_buf_vmapriv_free(vma_priv); 	mutex_unlock(&file_priv->lock);} static vm_fault_t privcmd_buf_vma_fault(struct vm_fault *vmf){	pr_debug("fault: vma=%p %lx-%lx, pgoff=%lx, uv=%p\n",		 vmf->vma, vmf->vma->vm_start, vmf->vma->vm_end,		 vmf->pgoff, (void *)vmf->address); 	return VM_FAULT_SIGBUS;} static const struct vm_operations_struct privcmd_buf_vm_ops = {	.open = privcmd_buf_vma_open,	.close = privcmd_buf_vma_close,	.fault = privcmd_buf_vma_fault,}; static int privcmd_buf_mmap(struct file *file, struct vm_area_struct *vma){	struct privcmd_buf_private *file_priv = file->private_data;	struct privcmd_buf_vma_private *vma_priv;	unsigned long count = vma_pages(vma);	unsigned int i;	int ret = 0; 	if (!(vma->vm_flags & VM_SHARED))		return -EINVAL; 	vma_priv = kzalloc_flex(*vma_priv, pages, count);	if (!vma_priv)		return -ENOMEM; 	for (i = 0; i < count; i++) {		vma_priv->pages[i] = alloc_page(GFP_KERNEL | __GFP_ZERO);		if (!vma_priv->pages[i])			break;		vma_priv->n_pages++;	} 	mutex_lock(&file_priv->lock); 	vma_priv->file_priv = file_priv;	vma_priv->users = 1; 	vm_flags_set(vma, VM_IO | VM_DONTEXPAND);	vma->vm_ops = &privcmd_buf_vm_ops;	vma->vm_private_data = vma_priv; 	list_add(&vma_priv->list, &file_priv->list); 	if (vma_priv->n_pages != count)		ret = -ENOMEM;	else		ret = vm_map_pages_zero(vma, vma_priv->pages,						vma_priv->n_pages); 	if (ret)		privcmd_buf_vmapriv_free(vma_priv); 	mutex_unlock(&file_priv->lock); 	return ret;} const struct file_operations xen_privcmdbuf_fops = {	.owner = THIS_MODULE,	.open = privcmd_buf_open,	.release = privcmd_buf_release,	.mmap = privcmd_buf_mmap,};EXPORT_SYMBOL_GPL(xen_privcmdbuf_fops); struct miscdevice xen_privcmdbuf_dev = {	.minor = MISC_DYNAMIC_MINOR,	.name = "xen/hypercall",	.fops = &xen_privcmdbuf_fops,};