| // SPDX-License-Identifier: MIT |
| /* |
| * Copyright © 2020 Intel Corporation |
| */ |
| |
| #include <linux/mm.h> |
| #include <linux/pagemap.h> |
| #include <linux/shmem_fs.h> |
| |
| #include "gem/i915_gem_object.h" |
| #include "shmem_utils.h" |
| |
| struct file *shmem_create_from_data(const char *name, void *data, size_t len) |
| { |
| struct file *file; |
| int err; |
| |
| file = shmem_file_setup(name, PAGE_ALIGN(len), VM_NORESERVE); |
| if (IS_ERR(file)) |
| return file; |
| |
| err = shmem_write(file, 0, data, len); |
| if (err) { |
| fput(file); |
| return ERR_PTR(err); |
| } |
| |
| return file; |
| } |
| |
| struct file *shmem_create_from_object(struct drm_i915_gem_object *obj) |
| { |
| struct file *file; |
| void *ptr; |
| |
| if (obj->ops == &i915_gem_shmem_ops) { |
| file = obj->base.filp; |
| atomic_long_inc(&file->f_count); |
| return file; |
| } |
| |
| ptr = i915_gem_object_pin_map(obj, I915_MAP_WB); |
| if (IS_ERR(ptr)) |
| return ERR_CAST(ptr); |
| |
| file = shmem_create_from_data("", ptr, obj->base.size); |
| i915_gem_object_unpin_map(obj); |
| |
| return file; |
| } |
| |
| static size_t shmem_npte(struct file *file) |
| { |
| return file->f_mapping->host->i_size >> PAGE_SHIFT; |
| } |
| |
| static void __shmem_unpin_map(struct file *file, void *ptr, size_t n_pte) |
| { |
| unsigned long pfn; |
| |
| vunmap(ptr); |
| |
| for (pfn = 0; pfn < n_pte; pfn++) { |
| struct page *page; |
| |
| page = shmem_read_mapping_page_gfp(file->f_mapping, pfn, |
| GFP_KERNEL); |
| if (!WARN_ON(IS_ERR(page))) { |
| put_page(page); |
| put_page(page); |
| } |
| } |
| } |
| |
| void *shmem_pin_map(struct file *file) |
| { |
| const size_t n_pte = shmem_npte(file); |
| pte_t *stack[32], **ptes, **mem; |
| struct vm_struct *area; |
| unsigned long pfn; |
| |
| mem = stack; |
| if (n_pte > ARRAY_SIZE(stack)) { |
| mem = kvmalloc_array(n_pte, sizeof(*mem), GFP_KERNEL); |
| if (!mem) |
| return NULL; |
| } |
| |
| area = alloc_vm_area(n_pte << PAGE_SHIFT, mem); |
| if (!area) { |
| if (mem != stack) |
| kvfree(mem); |
| return NULL; |
| } |
| |
| ptes = mem; |
| for (pfn = 0; pfn < n_pte; pfn++) { |
| struct page *page; |
| |
| page = shmem_read_mapping_page_gfp(file->f_mapping, pfn, |
| GFP_KERNEL); |
| if (IS_ERR(page)) |
| goto err_page; |
| |
| **ptes++ = mk_pte(page, PAGE_KERNEL); |
| } |
| |
| if (mem != stack) |
| kvfree(mem); |
| |
| mapping_set_unevictable(file->f_mapping); |
| return area->addr; |
| |
| err_page: |
| if (mem != stack) |
| kvfree(mem); |
| |
| __shmem_unpin_map(file, area->addr, pfn); |
| return NULL; |
| } |
| |
| void shmem_unpin_map(struct file *file, void *ptr) |
| { |
| mapping_clear_unevictable(file->f_mapping); |
| __shmem_unpin_map(file, ptr, shmem_npte(file)); |
| } |
| |
| static int __shmem_rw(struct file *file, loff_t off, |
| void *ptr, size_t len, |
| bool write) |
| { |
| unsigned long pfn; |
| |
| for (pfn = off >> PAGE_SHIFT; len; pfn++) { |
| unsigned int this = |
| min_t(size_t, PAGE_SIZE - offset_in_page(off), len); |
| struct page *page; |
| void *vaddr; |
| |
| page = shmem_read_mapping_page_gfp(file->f_mapping, pfn, |
| GFP_KERNEL); |
| if (IS_ERR(page)) |
| return PTR_ERR(page); |
| |
| vaddr = kmap(page); |
| if (write) |
| memcpy(vaddr + offset_in_page(off), ptr, this); |
| else |
| memcpy(ptr, vaddr + offset_in_page(off), this); |
| kunmap(page); |
| put_page(page); |
| |
| len -= this; |
| ptr += this; |
| off = 0; |
| } |
| |
| return 0; |
| } |
| |
| int shmem_read(struct file *file, loff_t off, void *dst, size_t len) |
| { |
| return __shmem_rw(file, off, dst, len, false); |
| } |
| |
| int shmem_write(struct file *file, loff_t off, void *src, size_t len) |
| { |
| return __shmem_rw(file, off, src, len, true); |
| } |
| |
| #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) |
| #include "st_shmem_utils.c" |
| #endif |