From mboxrd@z Thu Jan  1 00:00:00 1970
From: rishabhb@codeaurora.org
Subject: usercopy_warn in __copy_to_user
Date: Wed, 19 Dec 2018 11:51:19 -0800
Message-ID: <ecb306ea6f4a83302e78884713ad7823@codeaurora.org>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8;
 format=flowed
Content-Transfer-Encoding: 8bit
Return-path: <linux-kernel-owner@vger.kernel.org>
Sender: linux-kernel-owner@vger.kernel.org
To: keescook@chromium.org, linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org, Linux-arm Kernel <linux-arm-kernel@lists.infradead.org>
Cc: tsoni@codeaurora.org, ckadabi@codeaurora.org
List-Id: linux-arm-msm@vger.kernel.org


In the 4.19 kernel, we are seeing a USERCOPY_WARN in __copy_to_user 
during bootup.
The code-flow is something like this:

(arch/arm64/kernel/signal.c)
struct sigset_t *set;
__copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set))

(include/linux/uaccess.h)
__copy_to_user(void __user *to, const void *from, unsigned long n)
{
                 might_fault();
                 kasan_check_read(from, n);
                 check_object_size(from, n, true);
                 return raw_copy_to_user(to, from, n);
}

(include/linux/thread_info.h)
static __always_inline void check_object_size(const void *ptr,
                                  unsigned long n, bool to_user)
{
                 if (!__builtin_constant_p(n))
                                 __check_object_size(ptr, n, to_user);
}

Since sizeof(*set) is constant, __builtin_constant_p(n) should return 
true.
But we are seeing that its returning the value as false. Because of 
which
the code goes on to __check_object_size and generates a USERCOPY_WARN
("usercopy: WARN() on slab cache usercopy
region violations").

We are using LLVM clang version 6.0 to compile the kernel and not gcc.
In clang, __builtin_constant_p is evaluated immediately, before inlining
or other optimizations run, gcc evaluates it later.
We believe that maybe causing __builtin_constant_p(n) to return false.
There’s upstream work to change LLVM, so __builtin_constant_p works more
like gcc when optimization is enabled, but its still in progress.


For this scenario is there a way to avoid the warning? Should the code 
be
written in a different to avoid dependency on compiler?

Thanks,
Rishabh