s390/uaccess: whitespace cleanup

Whitespace cleanup to get rid if some checkpatch findings, but mainly
to have consistent coding style within the header file again.

Signed-off-by: Heiko Carstens <hca@linux.ibm.com>

diff --git a/arch/s390/include/asm/uaccess.h b/arch/s390/include/asm/uaccess.h
index 40361072e638db4ea7a09fd3a8dda8d8e0c77dc6..f4511e21d646ca5a8eec3b66e0f8176f795c9f86 100644 (file)
--- a/arch/s390/include/asm/uaccess.h
+++ b/arch/s390/include/asm/uaccess.h
@@ -3,7 +3,7 @@
  *  S390 version
  *    Copyright IBM Corp. 1999, 2000
  *    Author(s): Hartmut Penner (hp@de.ibm.com),
- *               Martin Schwidefsky (schwidefsky@de.ibm.com)
+ *              Martin Schwidefsky (schwidefsky@de.ibm.com)
  *
  *  Derived from "include/asm-i386/uaccess.h"
  */
@@ -194,77 +194,77 @@ static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsign
  * These are the main single-value transfer routines.  They automatically
  * use the right size if we just have the right pointer type.
  */
-#define __put_user(x, ptr) \
-({                                                             \
-       __typeof__(*(ptr)) __x = (x);                           \
-       int __pu_err = -EFAULT;                                 \
-        __chk_user_ptr(ptr);                                    \
-       switch (sizeof (*(ptr))) {                              \
-       case 1:                                                 \
-       case 2:                                                 \
-       case 4:                                                 \
-       case 8:                                                 \
-               __pu_err = __put_user_fn(&__x, ptr,             \
-                                        sizeof(*(ptr)));       \
-               break;                                          \
-       default:                                                \
-               __put_user_bad();                               \
-               break;                                          \
-       }                                                       \
-       __builtin_expect(__pu_err, 0);                          \
+#define __put_user(x, ptr)                                             \
+({                                                                     \
+       __typeof__(*(ptr)) __x = (x);                                   \
+       int __pu_err = -EFAULT;                                         \
+                                                                       \
+       __chk_user_ptr(ptr);                                            \
+       switch (sizeof(*(ptr))) {                                       \
+       case 1:                                                         \
+       case 2:                                                         \
+       case 4:                                                         \
+       case 8:                                                         \
+               __pu_err = __put_user_fn(&__x, ptr, sizeof(*(ptr)));    \
+               break;                                                  \
+       default:                                                        \
+               __put_user_bad();                                       \
+               break;                                                  \
+       }                                                               \
+       __builtin_expect(__pu_err, 0);                                  \
 })
 
-#define put_user(x, ptr)                                       \
-({                                                             \
-       might_fault();                                          \
-       __put_user(x, ptr);                                     \
+#define put_user(x, ptr)                                               \
+({                                                                     \
+       might_fault();                                                  \
+       __put_user(x, ptr);                                             \
 })
 
-
-#define __get_user(x, ptr)                                     \
-({                                                             \
-       int __gu_err = -EFAULT;                                 \
-       __chk_user_ptr(ptr);                                    \
-       switch (sizeof(*(ptr))) {                               \
-       case 1: {                                               \
-               unsigned char __x;                              \
-               __gu_err = __get_user_fn(&__x, ptr,             \
-                                        sizeof(*(ptr)));       \
-               (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
-               break;                                          \
-       };                                                      \
-       case 2: {                                               \
-               unsigned short __x;                             \
-               __gu_err = __get_user_fn(&__x, ptr,             \
-                                        sizeof(*(ptr)));       \
-               (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
-               break;                                          \
-       };                                                      \
-       case 4: {                                               \
-               unsigned int __x;                               \
-               __gu_err = __get_user_fn(&__x, ptr,             \
-                                        sizeof(*(ptr)));       \
-               (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
-               break;                                          \
-       };                                                      \
-       case 8: {                                               \
-               unsigned long __x;                              \
-               __gu_err = __get_user_fn(&__x, ptr,             \
-                                        sizeof(*(ptr)));       \
-               (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
-               break;                                          \
-       };                                                      \
-       default:                                                \
-               __get_user_bad();                               \
-               break;                                          \
-       }                                                       \
-       __builtin_expect(__gu_err, 0);                          \
+#define __get_user(x, ptr)                                             \
+({                                                                     \
+       int __gu_err = -EFAULT;                                         \
+                                                                       \
+       __chk_user_ptr(ptr);                                            \
+       switch (sizeof(*(ptr))) {                                       \
+       case 1: {                                                       \
+               unsigned char __x;                                      \
+                                                                       \
+               __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));    \
+               (x) = *(__force __typeof__(*(ptr)) *)&__x;              \
+               break;                                                  \
+       };                                                              \
+       case 2: {                                                       \
+               unsigned short __x;                                     \
+                                                                       \
+               __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));    \
+               (x) = *(__force __typeof__(*(ptr)) *)&__x;              \
+               break;                                                  \
+       };                                                              \
+       case 4: {                                                       \
+               unsigned int __x;                                       \
+                                                                       \
+               __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));    \
+               (x) = *(__force __typeof__(*(ptr)) *)&__x;              \
+               break;                                                  \
+       };                                                              \
+       case 8: {                                                       \
+               unsigned long __x;                                      \
+                                                                       \
+               __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr)));    \
+               (x) = *(__force __typeof__(*(ptr)) *)&__x;              \
+               break;                                                  \
+       };                                                              \
+       default:                                                        \
+               __get_user_bad();                                       \
+               break;                                                  \
+       }                                                               \
+       __builtin_expect(__gu_err, 0);                                  \
 })
 
-#define get_user(x, ptr)                                       \
-({                                                             \
-       might_fault();                                          \
-       __get_user(x, ptr);                                     \
+#define get_user(x, ptr)                                               \
+({                                                                     \
+       might_fault();                                                  \
+       __get_user(x, ptr);                                             \
 })
 
 /*