Merge tag 'uaccess_for_upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost into asm-generic

Merge "uaccess: fix sparse warning on get/put_user for bitwise types" from Michael S. Tsirkin:

At the moment, if p and x are both tagged as bitwise types,
some of get_user(x, p), put_user(x, p), __get_user(x, p), __put_user(x, p)
might produce a sparse warning on many architectures.
This is a false positive: *p on these architectures is loaded into long
(typically using asm), then cast back to typeof(*p).

When typeof(*p) is a bitwise type (which is uncommon), such a cast needs
__force, otherwise sparse produces a warning.

Some architectures already have the __force tag, add it
where it's missing.

I verified that adding these __force casts does not supress any useful warnings.

Specifically, vhost wants to read/write bitwise types in userspace memory
using get_user/put_user.
At the moment this triggers sparse errors, since the value is passed through an
integer.

For example:
    __le32 __user *p;
    __u32 x;

both
    put_user(x, p);
and
    get_user(x, p);
should be safe, but produce warnings on some architectures.

While there, I noticed that a bunch of architectures violated
coding style rules within uaccess macros.
Included patches to fix them up.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>

* tag 'uaccess_for_upstream' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost: (37 commits)
  sparc32: nocheck uaccess coding style tweaks
  sparc64: nocheck uaccess coding style tweaks
  xtensa: macro whitespace fixes
  sh: macro whitespace fixes
  parisc: macro whitespace fixes
  m68k: macro whitespace fixes
  m32r: macro whitespace fixes
  frv: macro whitespace fixes
  cris: macro whitespace fixes
  avr32: macro whitespace fixes
  arm64: macro whitespace fixes
  arm: macro whitespace fixes
  alpha: macro whitespace fixes
  blackfin: macro whitespace fixes
  sparc64: uaccess_64 macro whitespace fixes
  sparc32: uaccess_32 macro whitespace fixes
  avr32: whitespace fix
  sh: fix put_user sparse errors
  metag: fix put_user sparse errors
  ia64: fix put_user sparse errors
  ...

1 files changed, 16 insertions, 16 deletions

diff --git a/arch/blackfin/include/asm/uaccess.h b/arch/blackfin/include/asm/uaccess.h
index 57701c3b8a59..90612a7f2cf3 100644
--- a/arch/blackfin/include/asm/uaccess.h
+++ b/arch/blackfin/include/asm/uaccess.h
@@ -27,7 +27,7 @@ static inline void set_fs(mm_segment_t fs)
         current_thread_info()->addr_limit = fs;
 }
 
-#define segment_eq(a,b) ((a) == (b))
+#define segment_eq(a, b) ((a) == (b))
 
 #define VERIFY_READ     0
 #define VERIFY_WRITE    1
@@ -68,11 +68,11 @@ struct exception_table_entry {
  * use the right size if we just have the right pointer type.
  */
 
-#define put_user(x,p)                                           \
+#define put_user(x, p)                                          \
         ({                                                      \
                 int _err = 0;                                   \
                 typeof(*(p)) _x = (x);                          \
-                typeof(*(p)) __user *_p = (p);                          \
+                typeof(*(p)) __user *_p = (p);                  \
                 if (!access_ok(VERIFY_WRITE, _p, sizeof(*(_p)))) {\
                         _err = -EFAULT;                         \
                 }                                               \
@@ -89,10 +89,10 @@ struct exception_table_entry {
                         break;                                  \
                 case 8: {                                       \
                         long _xl, _xh;                          \
-                        _xl = ((long *)&_x)[0];                 \
-                        _xh = ((long *)&_x)[1];                 \
-                        __put_user_asm(_xl, ((long __user *)_p)+0, );   \
-                        __put_user_asm(_xh, ((long __user *)_p)+1, );   \
+                        _xl = ((__force long *)&_x)[0];         \
+                        _xh = ((__force long *)&_x)[1];         \
+                        __put_user_asm(_xl, ((__force long __user *)_p)+0, );\
+                        __put_user_asm(_xh, ((__force long __user *)_p)+1, );\
                 } break;                                        \
                 default:                                        \
                         _err = __put_user_bad();                \
@@ -102,7 +102,7 @@ struct exception_table_entry {
                 _err;                                           \
         })
 
-#define __put_user(x,p) put_user(x,p)
+#define __put_user(x, p) put_user(x, p)
 static inline int bad_user_access_length(void)
 {
         panic("bad_user_access_length");
@@ -121,10 +121,10 @@ static inline int bad_user_access_length(void)
 
 #define __ptr(x) ((unsigned long __force *)(x))
 
-#define __put_user_asm(x,p,bhw)                         \
+#define __put_user_asm(x, p, bhw)                       \
         __asm__ (#bhw"[%1] = %0;\n\t"                   \
                  : /* no outputs */                     \
-                 :"d" (x),"a" (__ptr(p)) : "memory")
+                 :"d" (x), "a" (__ptr(p)) : "memory")
 
 #define get_user(x, ptr)                                        \
 ({                                                              \
@@ -136,10 +136,10 @@ static inline int bad_user_access_length(void)
                 BUILD_BUG_ON(ptr_size >= 8);                    \
                 switch (ptr_size) {                             \
                 case 1:                                         \
-                        __get_user_asm(_val, _p, B,(Z));        \
+                        __get_user_asm(_val, _p, B, (Z));       \
                         break;                                  \
                 case 2:                                         \
-                        __get_user_asm(_val, _p, W,(Z));        \
+                        __get_user_asm(_val, _p, W, (Z));       \
                         break;                                  \
                 case 4:                                         \
                         __get_user_asm(_val, _p,  , );          \
@@ -147,11 +147,11 @@ static inline int bad_user_access_length(void)
                 }                                               \
         } else                                                  \
                 _err = -EFAULT;                                 \
-        x = (typeof(*(ptr)))_val;                               \
+        x = (__force typeof(*(ptr)))_val;                       \
         _err;                                                   \
 })
 
-#define __get_user(x,p) get_user(x,p)
+#define __get_user(x, p) get_user(x, p)
 
 #define __get_user_bad() (bad_user_access_length(), (-EFAULT))
 
@@ -168,10 +168,10 @@ static inline int bad_user_access_length(void)
 #define __copy_to_user_inatomic __copy_to_user
 #define __copy_from_user_inatomic __copy_from_user
 
-#define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n))\
+#define copy_to_user_ret(to, from, n, retval) ({ if (copy_to_user(to, from, n))\
                                                  return retval; })
 
-#define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n))\
+#define copy_from_user_ret(to, from, n, retval) ({ if (copy_from_user(to, from, n))\
                                                    return retval; })
 
 static inline unsigned long __must_check