x86: fix vmap arguments in map_irq_stack

[linux-2.6-microblaze.git] / fs / userfaultfd.c

diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index 703c1c3..e39fdec 100644 (file)
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c
@@ -314,8 +314,11 @@ static inline bool userfaultfd_must_wait(struct userfaultfd_ctx *ctx,
        if (!pmd_present(_pmd))
                goto out;
 
-       if (pmd_trans_huge(_pmd))
+       if (pmd_trans_huge(_pmd)) {
+               if (!pmd_write(_pmd) && (reason & VM_UFFD_WP))
+                       ret = true;
                goto out;
+       }
 
        /*
         * the pmd is stable (as in !pmd_trans_unstable) so we can re-read it
@@ -328,6 +331,8 @@ static inline bool userfaultfd_must_wait(struct userfaultfd_ctx *ctx,
         */
        if (pte_none(*pte))
                ret = true;
+       if (!pte_write(*pte) && (reason & VM_UFFD_WP))
+               ret = true;
        pte_unmap(pte);
 
 out:
@@ -1287,10 +1292,13 @@ static __always_inline int validate_range(struct mm_struct *mm,
        return 0;
 }
 
-static inline bool vma_can_userfault(struct vm_area_struct *vma)
+static inline bool vma_can_userfault(struct vm_area_struct *vma,
+                                    unsigned long vm_flags)
 {
-       return vma_is_anonymous(vma) || is_vm_hugetlb_page(vma) ||
-               vma_is_shmem(vma);
+       /* FIXME: add WP support to hugetlbfs and shmem */
+       return vma_is_anonymous(vma) ||
+               ((is_vm_hugetlb_page(vma) || vma_is_shmem(vma)) &&
+                !(vm_flags & VM_UFFD_WP));
 }
 
 static int userfaultfd_register(struct userfaultfd_ctx *ctx,
@@ -1322,15 +1330,8 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
        vm_flags = 0;
        if (uffdio_register.mode & UFFDIO_REGISTER_MODE_MISSING)
                vm_flags |= VM_UFFD_MISSING;
-       if (uffdio_register.mode & UFFDIO_REGISTER_MODE_WP) {
+       if (uffdio_register.mode & UFFDIO_REGISTER_MODE_WP)
                vm_flags |= VM_UFFD_WP;
-               /*
-                * FIXME: remove the below error constraint by
-                * implementing the wprotect tracking mode.
-                */
-               ret = -EINVAL;
-               goto out;
-       }
 
        ret = validate_range(mm, &uffdio_register.range.start,
                             uffdio_register.range.len);
@@ -1380,7 +1381,7 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
 
                /* check not compatible vmas */
                ret = -EINVAL;
-               if (!vma_can_userfault(cur))
+               if (!vma_can_userfault(cur, vm_flags))
                        goto out_unlock;
 
                /*
@@ -1408,6 +1409,8 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
                        if (end & (vma_hpagesize - 1))
                                goto out_unlock;
                }
+               if ((vm_flags & VM_UFFD_WP) && !(cur->vm_flags & VM_MAYWRITE))
+                       goto out_unlock;
 
                /*
                 * Check that this vma isn't already owned by a
@@ -1437,7 +1440,7 @@ static int userfaultfd_register(struct userfaultfd_ctx *ctx,
        do {
                cond_resched();
 
-               BUG_ON(!vma_can_userfault(vma));
+               BUG_ON(!vma_can_userfault(vma, vm_flags));
                BUG_ON(vma->vm_userfaultfd_ctx.ctx &&
                       vma->vm_userfaultfd_ctx.ctx != ctx);
                WARN_ON(!(vma->vm_flags & VM_MAYWRITE));
@@ -1492,14 +1495,24 @@ out_unlock:
        up_write(&mm->mmap_sem);
        mmput(mm);
        if (!ret) {
+               __u64 ioctls_out;
+
+               ioctls_out = basic_ioctls ? UFFD_API_RANGE_IOCTLS_BASIC :
+                   UFFD_API_RANGE_IOCTLS;
+
+               /*
+                * Declare the WP ioctl only if the WP mode is
+                * specified and all checks passed with the range
+                */
+               if (!(uffdio_register.mode & UFFDIO_REGISTER_MODE_WP))
+                       ioctls_out &= ~((__u64)1 << _UFFDIO_WRITEPROTECT);
+
                /*
                 * Now that we scanned all vmas we can already tell
                 * userland which ioctls methods are guaranteed to
                 * succeed on this range.
                 */
-               if (put_user(basic_ioctls ? UFFD_API_RANGE_IOCTLS_BASIC :
-                            UFFD_API_RANGE_IOCTLS,
-                            &user_uffdio_register->ioctls))
+               if (put_user(ioctls_out, &user_uffdio_register->ioctls))
                        ret = -EFAULT;
        }
 out:
@@ -1575,7 +1588,7 @@ static int userfaultfd_unregister(struct userfaultfd_ctx *ctx,
                 * provides for more strict behavior to notice
                 * unregistration errors.
                 */
-               if (!vma_can_userfault(cur))
+               if (!vma_can_userfault(cur, cur->vm_flags))
                        goto out_unlock;
 
                found = true;
@@ -1589,7 +1602,7 @@ static int userfaultfd_unregister(struct userfaultfd_ctx *ctx,
        do {
                cond_resched();
 
-               BUG_ON(!vma_can_userfault(vma));
+               BUG_ON(!vma_can_userfault(vma, vma->vm_flags));
 
                /*
                 * Nothing to do: this vma is already registered into this
@@ -1724,11 +1737,12 @@ static int userfaultfd_copy(struct userfaultfd_ctx *ctx,
        ret = -EINVAL;
        if (uffdio_copy.src + uffdio_copy.len <= uffdio_copy.src)
                goto out;
-       if (uffdio_copy.mode & ~UFFDIO_COPY_MODE_DONTWAKE)
+       if (uffdio_copy.mode & ~(UFFDIO_COPY_MODE_DONTWAKE|UFFDIO_COPY_MODE_WP))
                goto out;
        if (mmget_not_zero(ctx->mm)) {
                ret = mcopy_atomic(ctx->mm, uffdio_copy.dst, uffdio_copy.src,
-                                  uffdio_copy.len, &ctx->mmap_changing);
+                                  uffdio_copy.len, &ctx->mmap_changing,
+                                  uffdio_copy.mode);
                mmput(ctx->mm);
        } else {
                return -ESRCH;
@@ -1801,6 +1815,53 @@ out:
        return ret;
 }
 
+static int userfaultfd_writeprotect(struct userfaultfd_ctx *ctx,
+                                   unsigned long arg)
+{
+       int ret;
+       struct uffdio_writeprotect uffdio_wp;
+       struct uffdio_writeprotect __user *user_uffdio_wp;
+       struct userfaultfd_wake_range range;
+       bool mode_wp, mode_dontwake;
+
+       if (READ_ONCE(ctx->mmap_changing))
+               return -EAGAIN;
+
+       user_uffdio_wp = (struct uffdio_writeprotect __user *) arg;
+
+       if (copy_from_user(&uffdio_wp, user_uffdio_wp,
+                          sizeof(struct uffdio_writeprotect)))
+               return -EFAULT;
+
+       ret = validate_range(ctx->mm, &uffdio_wp.range.start,
+                            uffdio_wp.range.len);
+       if (ret)
+               return ret;
+
+       if (uffdio_wp.mode & ~(UFFDIO_WRITEPROTECT_MODE_DONTWAKE |
+                              UFFDIO_WRITEPROTECT_MODE_WP))
+               return -EINVAL;
+
+       mode_wp = uffdio_wp.mode & UFFDIO_WRITEPROTECT_MODE_WP;
+       mode_dontwake = uffdio_wp.mode & UFFDIO_WRITEPROTECT_MODE_DONTWAKE;
+
+       if (mode_wp && mode_dontwake)
+               return -EINVAL;
+
+       ret = mwriteprotect_range(ctx->mm, uffdio_wp.range.start,
+                                 uffdio_wp.range.len, mode_wp,
+                                 &ctx->mmap_changing);
+       if (ret)
+               return ret;
+
+       if (!mode_wp && !mode_dontwake) {
+               range.start = uffdio_wp.range.start;
+               range.len = uffdio_wp.range.len;
+               wake_userfault(ctx, &range);
+       }
+       return ret;
+}
+
 static inline unsigned int uffd_ctx_features(__u64 user_features)
 {
        /*
@@ -1882,6 +1943,9 @@ static long userfaultfd_ioctl(struct file *file, unsigned cmd,
        case UFFDIO_ZEROPAGE:
                ret = userfaultfd_zeropage(ctx, arg);
                break;
+       case UFFDIO_WRITEPROTECT:
+               ret = userfaultfd_writeprotect(ctx, arg);
+               break;
        }
        return ret;
 }