1// SPDX-License-Identifier: GPL-2.0+
  2
  3#include <linux/dma-buf.h>
  4#include <linux/shmem_fs.h>
  5#include <linux/vmalloc.h>
  6#include <drm/drm_prime.h>
  7
  8#include "vkms_drv.h"
  9
 10static struct vkms_gem_object *__vkms_gem_create(struct drm_device *dev,
 11						 u64 size)
 12{
 13	struct vkms_gem_object *obj;
 14	int ret;
 15
 16	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
 17	if (!obj)
 18		return ERR_PTR(-ENOMEM);
 19
 20	size = roundup(size, PAGE_SIZE);
 21	ret = drm_gem_object_init(dev, &obj->gem, size);
 22	if (ret) {
 23		kfree(obj);
 24		return ERR_PTR(ret);
 25	}
 26
 27	mutex_init(&obj->pages_lock);
 28
 29	return obj;
 30}
 31
 32void vkms_gem_free_object(struct drm_gem_object *obj)
 33{
 34	struct vkms_gem_object *gem = container_of(obj, struct vkms_gem_object,
 35						   gem);
 36
 37	WARN_ON(gem->pages);
 38	WARN_ON(gem->vaddr);
 39
 40	mutex_destroy(&gem->pages_lock);
 41	drm_gem_object_release(obj);
 42	kfree(gem);
 43}
 44
 45vm_fault_t vkms_gem_fault(struct vm_fault *vmf)
 46{
 47	struct vm_area_struct *vma = vmf->vma;
 48	struct vkms_gem_object *obj = vma->vm_private_data;
 49	unsigned long vaddr = vmf->address;
 50	pgoff_t page_offset;
 51	loff_t num_pages;
 52	vm_fault_t ret = VM_FAULT_SIGBUS;
 53
 54	page_offset = (vaddr - vma->vm_start) >> PAGE_SHIFT;
 55	num_pages = DIV_ROUND_UP(obj->gem.size, PAGE_SIZE);
 56
 57	if (page_offset > num_pages)
 58		return VM_FAULT_SIGBUS;
 59
 60	mutex_lock(&obj->pages_lock);
 61	if (obj->pages) {
 62		get_page(obj->pages[page_offset]);
 63		vmf->page = obj->pages[page_offset];
 64		ret = 0;
 65	}
 66	mutex_unlock(&obj->pages_lock);
 67	if (ret) {
 68		struct page *page;
 69		struct address_space *mapping;
 70
 71		mapping = file_inode(obj->gem.filp)->i_mapping;
 72		page = shmem_read_mapping_page(mapping, page_offset);
 73
 74		if (!IS_ERR(page)) {
 75			vmf->page = page;
 76			ret = 0;
 77		} else {
 78			switch (PTR_ERR(page)) {
 79			case -ENOSPC:
 80			case -ENOMEM:
 81				ret = VM_FAULT_OOM;
 82				break;
 83			case -EBUSY:
 84				ret = VM_FAULT_RETRY;
 85				break;
 86			case -EFAULT:
 87			case -EINVAL:
 88				ret = VM_FAULT_SIGBUS;
 89				break;
 90			default:
 91				WARN_ON(PTR_ERR(page));
 92				ret = VM_FAULT_SIGBUS;
 93				break;
 94			}
 95		}
 96	}
 97	return ret;
 98}
 99
100static struct drm_gem_object *vkms_gem_create(struct drm_device *dev,
101					      struct drm_file *file,
102					      u32 *handle,
103					      u64 size)
104{
105	struct vkms_gem_object *obj;
106	int ret;
107
108	if (!file || !dev || !handle)
109		return ERR_PTR(-EINVAL);
110
111	obj = __vkms_gem_create(dev, size);
112	if (IS_ERR(obj))
113		return ERR_CAST(obj);
114
115	ret = drm_gem_handle_create(file, &obj->gem, handle);
116	if (ret)
117		return ERR_PTR(ret);
118
119	return &obj->gem;
120}
121
122int vkms_dumb_create(struct drm_file *file, struct drm_device *dev,
123		     struct drm_mode_create_dumb *args)
124{
125	struct drm_gem_object *gem_obj;
126	u64 pitch, size;
127
128	if (!args || !dev || !file)
129		return -EINVAL;
130
131	pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
132	size = pitch * args->height;
133
134	if (!size)
135		return -EINVAL;
136
137	gem_obj = vkms_gem_create(dev, file, &args->handle, size);
138	if (IS_ERR(gem_obj))
139		return PTR_ERR(gem_obj);
140
141	args->size = gem_obj->size;
142	args->pitch = pitch;
143
144	drm_gem_object_put(gem_obj);
145
146	DRM_DEBUG_DRIVER("Created object of size %lld\n", size);
147
148	return 0;
149}
150
151static struct page **_get_pages(struct vkms_gem_object *vkms_obj)
152{
153	struct drm_gem_object *gem_obj = &vkms_obj->gem;
154
155	if (!vkms_obj->pages) {
156		struct page **pages = drm_gem_get_pages(gem_obj);
157
158		if (IS_ERR(pages))
159			return pages;
160
161		if (cmpxchg(&vkms_obj->pages, NULL, pages))
162			drm_gem_put_pages(gem_obj, pages, false, true);
163	}
164
165	return vkms_obj->pages;
166}
167
168void vkms_gem_vunmap(struct drm_gem_object *obj)
169{
170	struct vkms_gem_object *vkms_obj = drm_gem_to_vkms_gem(obj);
171
172	mutex_lock(&vkms_obj->pages_lock);
173	if (vkms_obj->vmap_count < 1) {
174		WARN_ON(vkms_obj->vaddr);
175		WARN_ON(vkms_obj->pages);
176		mutex_unlock(&vkms_obj->pages_lock);
177		return;
178	}
179
180	vkms_obj->vmap_count--;
181
182	if (vkms_obj->vmap_count == 0) {
183		vunmap(vkms_obj->vaddr);
184		vkms_obj->vaddr = NULL;
185		drm_gem_put_pages(obj, vkms_obj->pages, false, true);
186		vkms_obj->pages = NULL;
187	}
188
189	mutex_unlock(&vkms_obj->pages_lock);
190}
191
192int vkms_gem_vmap(struct drm_gem_object *obj)
193{
194	struct vkms_gem_object *vkms_obj = drm_gem_to_vkms_gem(obj);
195	int ret = 0;
196
197	mutex_lock(&vkms_obj->pages_lock);
198
199	if (!vkms_obj->vaddr) {
200		unsigned int n_pages = obj->size >> PAGE_SHIFT;
201		struct page **pages = _get_pages(vkms_obj);
202
203		if (IS_ERR(pages)) {
204			ret = PTR_ERR(pages);
205			goto out;
206		}
207
208		vkms_obj->vaddr = vmap(pages, n_pages, VM_MAP, PAGE_KERNEL);
209		if (!vkms_obj->vaddr)
210			goto err_vmap;
211	}
212
213	vkms_obj->vmap_count++;
214	goto out;
215
216err_vmap:
217	ret = -ENOMEM;
218	drm_gem_put_pages(obj, vkms_obj->pages, false, true);
219	vkms_obj->pages = NULL;
220out:
221	mutex_unlock(&vkms_obj->pages_lock);
222	return ret;
223}
224
225struct drm_gem_object *
226vkms_prime_import_sg_table(struct drm_device *dev,
227			   struct dma_buf_attachment *attach,
228			   struct sg_table *sg)
229{
230	struct vkms_gem_object *obj;
231	int npages;
232
233	obj = __vkms_gem_create(dev, attach->dmabuf->size);
234	if (IS_ERR(obj))
235		return ERR_CAST(obj);
236
237	npages = PAGE_ALIGN(attach->dmabuf->size) / PAGE_SIZE;
238	DRM_DEBUG_PRIME("Importing %d pages\n", npages);
239
240	obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
241	if (!obj->pages) {
242		vkms_gem_free_object(&obj->gem);
243		return ERR_PTR(-ENOMEM);
244	}
245
246	drm_prime_sg_to_page_addr_arrays(sg, obj->pages, NULL, npages);
247	return &obj->gem;
248}