Merge tag 'copy-struct-from-user-v5.4-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux

Pull copy_struct_from_user() helper from Christian Brauner:
 "This contains the copy_struct_from_user() helper which got split out
  from the openat2() patchset. It is a generic interface designed to
  copy a struct from userspace.

  The helper will be especially useful for structs versioned by size of
  which we have quite a few. This allows for backwards compatibility,
  i.e. an extended struct can be passed to an older kernel, or a legacy
  struct can be passed to a newer kernel. For the first case (extended
  struct, older kernel) the new fields in an extended struct can be set
  to zero and the struct safely passed to an older kernel.

  The most obvious benefit is that this helper lets us get rid of
  duplicate code present in at least sched_setattr(), perf_event_open(),
  and clone3(). More importantly it will also help to ensure that users
  implementing versioning-by-size end up with the same core semantics.

  This point is especially crucial since we have at least one case where
  versioning-by-size is used but with slighly different semantics:
  sched_setattr(), perf_event_open(), and clone3() all do do similar
  checks to copy_struct_from_user() while rt_sigprocmask(2) always
  rejects differently-sized struct arguments.

  With this pull request we also switch over sched_setattr(),
  perf_event_open(), and clone3() to use the new helper"

* tag 'copy-struct-from-user-v5.4-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux:
  usercopy: Add parentheses around assignment in test_copy_struct_from_user
  perf_event_open: switch to copy_struct_from_user()
  sched_setattr: switch to copy_struct_from_user()
  clone3: switch to copy_struct_from_user()
  lib: introduce copy_struct_from_user() helper

3 files changed, 23 insertions, 101 deletions

diff --git a/kernel/events/core.c b/kernel/events/core.c
index 4655adbbae10..3f0cb82e4fbc 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -10586,55 +10586,26 @@ static int perf_copy_attr(struct perf_event_attr __user *uattr,
         u32 size;
         int ret;
 
-        if (!access_ok(uattr, PERF_ATTR_SIZE_VER0))
-                return -EFAULT;
-
-        /*
-         * zero the full structure, so that a short copy will be nice.
-         */
+        /* Zero the full structure, so that a short copy will be nice. */
         memset(attr, 0, sizeof(*attr));
 
         ret = get_user(size, &uattr->size);
         if (ret)
                 return ret;
 
-        if (size > PAGE_SIZE)   /* silly large */
-                goto err_size;
-
-        if (!size)              /* abi compat */
+        /* ABI compatibility quirk: */
+        if (!size)
                 size = PERF_ATTR_SIZE_VER0;
-
-        if (size < PERF_ATTR_SIZE_VER0)
+        if (size < PERF_ATTR_SIZE_VER0 || size > PAGE_SIZE)
                 goto err_size;
 
-        /*
-         * If we're handed a bigger struct than we know of,
-         * ensure all the unknown bits are 0 - i.e. new
-         * user-space does not rely on any kernel feature
-         * extensions we dont know about yet.
-         */
-        if (size > sizeof(*attr)) {
-                unsigned char __user *addr;
-                unsigned char __user *end;
-                unsigned char val;
-
-                addr = (void __user *)uattr + sizeof(*attr);
-                end  = (void __user *)uattr + size;
-
-                for (; addr < end; addr++) {
-                        ret = get_user(val, addr);
-                        if (ret)
-                                return ret;
-                        if (val)
-                                goto err_size;
-                }
-                size = sizeof(*attr);
+        ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
+        if (ret) {
+                if (ret == -E2BIG)
+                        goto err_size;
+                return ret;
         }
 
-        ret = copy_from_user(attr, uattr, size);
-        if (ret)
-                return -EFAULT;
-
         attr->size = size;
 
         if (attr->__reserved_1)
diff --git a/kernel/fork.c b/kernel/fork.c
index bf11cf39579a..1f6c45f6a734 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -2525,39 +2525,19 @@ SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
 #ifdef __ARCH_WANT_SYS_CLONE3
 noinline static int copy_clone_args_from_user(struct kernel_clone_args *kargs,
                                               struct clone_args __user *uargs,
-                                              size_t size)
+                                              size_t usize)
 {
+        int err;
         struct clone_args args;
 
-        if (unlikely(size > PAGE_SIZE))
+        if (unlikely(usize > PAGE_SIZE))
                 return -E2BIG;
-
-        if (unlikely(size < sizeof(struct clone_args)))
+        if (unlikely(usize < CLONE_ARGS_SIZE_VER0))
                 return -EINVAL;
 
-        if (unlikely(!access_ok(uargs, size)))
-                return -EFAULT;
-
-        if (size > sizeof(struct clone_args)) {
-                unsigned char __user *addr;
-                unsigned char __user *end;
-                unsigned char val;
-
-                addr = (void __user *)uargs + sizeof(struct clone_args);
-                end = (void __user *)uargs + size;
-
-                for (; addr < end; addr++) {
-                        if (get_user(val, addr))
-                                return -EFAULT;
-                        if (val)
-                                return -E2BIG;
-                }
-
-                size = sizeof(struct clone_args);
-        }
-
-        if (copy_from_user(&args, uargs, size))
-                return -EFAULT;
+        err = copy_struct_from_user(&args, sizeof(args), uargs, usize);
+        if (err)
+                return err;
 
         /*
          * Verify that higher 32bits of exit_signal are unset and that
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 7880f4f64d0e..dd05a378631a 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5106,9 +5106,6 @@ static int sched_copy_attr(struct sched_attr __user *uattr, struct sched_attr *a
         u32 size;
         int ret;
 
-        if (!access_ok(uattr, SCHED_ATTR_SIZE_VER0))
-                return -EFAULT;
-
         /* Zero the full structure, so that a short copy will be nice: */
         memset(attr, 0, sizeof(*attr));
 
@@ -5116,45 +5113,19 @@ static int sched_copy_attr(struct sched_attr __user *uattr, struct sched_attr *a
         if (ret)
                 return ret;
 
-        /* Bail out on silly large: */
-        if (size > PAGE_SIZE)
-                goto err_size;
-
         /* ABI compatibility quirk: */
         if (!size)
                 size = SCHED_ATTR_SIZE_VER0;
-
-        if (size < SCHED_ATTR_SIZE_VER0)
+        if (size < SCHED_ATTR_SIZE_VER0 || size > PAGE_SIZE)
                 goto err_size;
 
-        /*
-         * If we're handed a bigger struct than we know of,
-         * ensure all the unknown bits are 0 - i.e. new
-         * user-space does not rely on any kernel feature
-         * extensions we dont know about yet.
-         */
-        if (size > sizeof(*attr)) {
-                unsigned char __user *addr;
-                unsigned char __user *end;
-                unsigned char val;
-
-                addr = (void __user *)uattr + sizeof(*attr);
-                end  = (void __user *)uattr + size;
-
-                for (; addr < end; addr++) {
-                        ret = get_user(val, addr);
-                        if (ret)
-                                return ret;
-                        if (val)
-                                goto err_size;
-                }
-                size = sizeof(*attr);
+        ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
+        if (ret) {
+                if (ret == -E2BIG)
+                        goto err_size;
+                return ret;
         }
 
-        ret = copy_from_user(attr, uattr, size);
-        if (ret)
-                return -EFAULT;
-
         if ((attr->sched_flags & SCHED_FLAG_UTIL_CLAMP) &&
             size < SCHED_ATTR_SIZE_VER1)
                 return -EINVAL;
@@ -5354,7 +5325,7 @@ sched_attr_copy_to_user(struct sched_attr __user *uattr,
  * sys_sched_getattr - similar to sched_getparam, but with sched_attr
  * @pid: the pid in question.
  * @uattr: structure containing the extended parameters.
- * @usize: sizeof(attr) that user-space knows about, for forwards and backwards compatibility.
+ * @usize: sizeof(attr) for fwd/bwd comp.
  * @flags: for future extension.
  */
 SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,