userfaultfd: shmem: add tlbflush.h header for microblaze

[karo-tx-linux.git] / mm / shmem.c

diff --git a/mm/shmem.c b/mm/shmem.c
index 3a7587a0314dc73fb4929a824a74f9b8948ea502..26c332c84e14b372f43f313e9d3bbe1f16579664 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -34,6 +34,8 @@
 #include <linux/uio.h>
 #include <linux/khugepaged.h>
 
+#include <asm/tlbflush.h> /* for arch/microblaze update_mmu_cache() */
+
 static struct vfsmount *shm_mnt;
 
 #ifdef CONFIG_SHMEM
@@ -70,6 +72,7 @@ static struct vfsmount *shm_mnt;
 #include <linux/syscalls.h>
 #include <linux/fcntl.h>
 #include <uapi/linux/memfd.h>
+#include <linux/rmap.h>
 
 #include <linux/uaccess.h>
 #include <asm/pgtable.h>
@@ -190,6 +193,11 @@ static const struct inode_operations shmem_special_inode_operations;
 static const struct vm_operations_struct shmem_vm_ops;
 static struct file_system_type shmem_fs_type;
 
+bool vma_is_shmem(struct vm_area_struct *vma)
+{
+       return vma->vm_ops == &shmem_vm_ops;
+}
+
 static LIST_HEAD(shmem_swaplist);
 static DEFINE_MUTEX(shmem_swaplist_mutex);
 
@@ -2175,10 +2183,116 @@ static struct inode *shmem_get_inode(struct super_block *sb, const struct inode
 
 bool shmem_mapping(struct address_space *mapping)
 {
-       if (!mapping->host)
-               return false;
+       return mapping->a_ops == &shmem_aops;
+}
+
+int shmem_mcopy_atomic_pte(struct mm_struct *dst_mm,
+                          pmd_t *dst_pmd,
+                          struct vm_area_struct *dst_vma,
+                          unsigned long dst_addr,
+                          unsigned long src_addr,
+                          struct page **pagep)
+{
+       struct inode *inode = file_inode(dst_vma->vm_file);
+       struct shmem_inode_info *info = SHMEM_I(inode);
+       struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
+       struct address_space *mapping = inode->i_mapping;
+       gfp_t gfp = mapping_gfp_mask(mapping);
+       pgoff_t pgoff = linear_page_index(dst_vma, dst_addr);
+       struct mem_cgroup *memcg;
+       spinlock_t *ptl;
+       void *page_kaddr;
+       struct page *page;
+       pte_t _dst_pte, *dst_pte;
+       int ret;
+
+       if (!*pagep) {
+               ret = -ENOMEM;
+               if (shmem_acct_block(info->flags, 1))
+                       goto out;
+               if (sbinfo->max_blocks) {
+                       if (percpu_counter_compare(&sbinfo->used_blocks,
+                                                  sbinfo->max_blocks) >= 0)
+                               goto out_unacct_blocks;
+                       percpu_counter_inc(&sbinfo->used_blocks);
+               }
+
+               page = shmem_alloc_page(gfp, info, pgoff);
+               if (!page)
+                       goto out_dec_used_blocks;
+
+               page_kaddr = kmap_atomic(page);
+               ret = copy_from_user(page_kaddr, (const void __user *)src_addr,
+                                    PAGE_SIZE);
+               kunmap_atomic(page_kaddr);
+
+               /* fallback to copy_from_user outside mmap_sem */
+               if (unlikely(ret)) {
+                       *pagep = page;
+                       /* don't free the page */
+                       return -EFAULT;
+               }
+       } else {
+               page = *pagep;
+               *pagep = NULL;
+       }
+
+       ret = mem_cgroup_try_charge(page, dst_mm, gfp, &memcg, false);
+       if (ret)
+               goto out_release;
+
+       ret = radix_tree_maybe_preload(gfp & GFP_RECLAIM_MASK);
+       if (!ret) {
+               ret = shmem_add_to_page_cache(page, mapping, pgoff, NULL);
+               radix_tree_preload_end();
+       }
+       if (ret)
+               goto out_release_uncharge;
+
+       mem_cgroup_commit_charge(page, memcg, false, false);
+
+       _dst_pte = mk_pte(page, dst_vma->vm_page_prot);
+       if (dst_vma->vm_flags & VM_WRITE)
+               _dst_pte = pte_mkwrite(pte_mkdirty(_dst_pte));
+
+       ret = -EEXIST;
+       dst_pte = pte_offset_map_lock(dst_mm, dst_pmd, dst_addr, &ptl);
+       if (!pte_none(*dst_pte))
+               goto out_release_uncharge_unlock;
 
-       return mapping->host->i_sb->s_op == &shmem_ops;
+       __SetPageUptodate(page);
+
+       lru_cache_add_anon(page);
+
+       spin_lock(&info->lock);
+       info->alloced++;
+       inode->i_blocks += BLOCKS_PER_PAGE;
+       shmem_recalc_inode(inode);
+       spin_unlock(&info->lock);
+
+       inc_mm_counter(dst_mm, mm_counter_file(page));
+       page_add_file_rmap(page, false);
+       set_pte_at(dst_mm, dst_addr, dst_pte, _dst_pte);
+
+       /* No need to invalidate - it was non-present before */
+       update_mmu_cache(dst_vma, dst_addr, dst_pte);
+       unlock_page(page);
+       pte_unmap_unlock(dst_pte, ptl);
+       ret = 0;
+out:
+       return ret;
+out_release_uncharge_unlock:
+       pte_unmap_unlock(dst_pte, ptl);
+out_release_uncharge:
+       mem_cgroup_cancel_charge(page, memcg, false);
+out_release:
+       put_page(page);
+out_dec_used_blocks:
+       if (sbinfo->max_blocks)
+               percpu_counter_add(&sbinfo->used_blocks, -1);
+out_unacct_blocks:
+       shmem_unacct_blocks(info->flags, 1);
+       goto out;
 }
 
 #ifdef CONFIG_TMPFS