tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

cris: macro whitespace fixes

While working on arch/cris/include/asm/uaccess.h, I noticed
that some macros within this header are made harder to read because they
violate a coding style rule: space is missing after comma.

Fix it up.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>

Michael S. Tsirkin 00eaf4c0 d13beabe

+58 -55
+58 -55
arch/cris/include/asm/uaccess.h
··· 47 47 #define get_fs() (current_thread_info()->addr_limit) 48 48 #define set_fs(x) (current_thread_info()->addr_limit = (x)) 49 49 50 - #define segment_eq(a,b) ((a).seg == (b).seg) 50 + #define segment_eq(a, b) ((a).seg == (b).seg) 51 51 52 52 #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS)) 53 - #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size))) 54 - #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size))) 55 - #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size)) 53 + #define __user_ok(addr, size) \ 54 + (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size))) 55 + #define __access_ok(addr, size) (__kernel_ok || __user_ok((addr), (size))) 56 + #define access_ok(type, addr, size) __access_ok((unsigned long)(addr), (size)) 56 57 57 58 #include <arch/uaccess.h> 58 59 ··· 93 92 * CRIS, we can just do these as direct assignments. (Of course, the 94 93 * exception handling means that it's no longer "just"...) 95 94 */ 96 - #define get_user(x,ptr) \ 97 - __get_user_check((x),(ptr),sizeof(*(ptr))) 98 - #define put_user(x,ptr) \ 99 - __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr))) 95 + #define get_user(x, ptr) \ 96 + __get_user_check((x), (ptr), sizeof(*(ptr))) 97 + #define put_user(x, ptr) \ 98 + __put_user_check((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr))) 100 99 101 - #define __get_user(x,ptr) \ 102 - __get_user_nocheck((x),(ptr),sizeof(*(ptr))) 103 - #define __put_user(x,ptr) \ 104 - __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr))) 100 + #define __get_user(x, ptr) \ 101 + __get_user_nocheck((x), (ptr), sizeof(*(ptr))) 102 + #define __put_user(x, ptr) \ 103 + __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr))) 105 104 106 105 extern long __put_user_bad(void); 107 106 108 - #define __put_user_size(x,ptr,size,retval) \ 109 - do { \ 110 - retval = 0; \ 111 - switch (size) { \ 112 - case 1: __put_user_asm(x,ptr,retval,"move.b"); break; \ 113 - case 2: __put_user_asm(x,ptr,retval,"move.w"); break; \ 114 - case 4: __put_user_asm(x,ptr,retval,"move.d"); break; \ 115 - case 8: __put_user_asm_64(x,ptr,retval); break; \ 116 - default: __put_user_bad(); \ 117 - } \ 107 + #define __put_user_size(x, ptr, size, retval) \ 108 + do { \ 109 + retval = 0; \ 110 + switch (size) { \ 111 + case 1: __put_user_asm(x, ptr, retval, "move.b"); break; \ 112 + case 2: __put_user_asm(x, ptr, retval, "move.w"); break; \ 113 + case 4: __put_user_asm(x, ptr, retval, "move.d"); break; \ 114 + case 8: __put_user_asm_64(x, ptr, retval); break; \ 115 + default: __put_user_bad(); \ 116 + } \ 118 117 } while (0) 119 118 120 - #define __get_user_size(x,ptr,size,retval) \ 121 - do { \ 122 - retval = 0; \ 123 - switch (size) { \ 124 - case 1: __get_user_asm(x,ptr,retval,"move.b"); break; \ 125 - case 2: __get_user_asm(x,ptr,retval,"move.w"); break; \ 126 - case 4: __get_user_asm(x,ptr,retval,"move.d"); break; \ 127 - case 8: __get_user_asm_64(x,ptr,retval); break; \ 128 - default: (x) = __get_user_bad(); \ 129 - } \ 119 + #define __get_user_size(x, ptr, size, retval) \ 120 + do { \ 121 + retval = 0; \ 122 + switch (size) { \ 123 + case 1: __get_user_asm(x, ptr, retval, "move.b"); break; \ 124 + case 2: __get_user_asm(x, ptr, retval, "move.w"); break; \ 125 + case 4: __get_user_asm(x, ptr, retval, "move.d"); break; \ 126 + case 8: __get_user_asm_64(x, ptr, retval); break; \ 127 + default: (x) = __get_user_bad(); \ 128 + } \ 130 129 } while (0) 131 130 132 - #define __put_user_nocheck(x,ptr,size) \ 131 + #define __put_user_nocheck(x, ptr, size) \ 133 132 ({ \ 134 133 long __pu_err; \ 135 - __put_user_size((x),(ptr),(size),__pu_err); \ 134 + __put_user_size((x), (ptr), (size), __pu_err); \ 136 135 __pu_err; \ 137 136 }) 138 137 139 - #define __put_user_check(x,ptr,size) \ 140 - ({ \ 141 - long __pu_err = -EFAULT; \ 142 - __typeof__(*(ptr)) *__pu_addr = (ptr); \ 143 - if (access_ok(VERIFY_WRITE,__pu_addr,size)) \ 144 - __put_user_size((x),__pu_addr,(size),__pu_err); \ 145 - __pu_err; \ 138 + #define __put_user_check(x, ptr, size) \ 139 + ({ \ 140 + long __pu_err = -EFAULT; \ 141 + __typeof__(*(ptr)) *__pu_addr = (ptr); \ 142 + if (access_ok(VERIFY_WRITE, __pu_addr, size)) \ 143 + __put_user_size((x), __pu_addr, (size), __pu_err); \ 144 + __pu_err; \ 146 145 }) 147 146 148 147 struct __large_struct { unsigned long buf[100]; }; ··· 150 149 151 150 152 151 153 - #define __get_user_nocheck(x,ptr,size) \ 152 + #define __get_user_nocheck(x, ptr, size) \ 154 153 ({ \ 155 154 long __gu_err, __gu_val; \ 156 - __get_user_size(__gu_val,(ptr),(size),__gu_err); \ 155 + __get_user_size(__gu_val, (ptr), (size), __gu_err); \ 157 156 (x) = (__force __typeof__(*(ptr)))__gu_val; \ 158 157 __gu_err; \ 159 158 }) 160 159 161 - #define __get_user_check(x,ptr,size) \ 160 + #define __get_user_check(x, ptr, size) \ 162 161 ({ \ 163 162 long __gu_err = -EFAULT, __gu_val = 0; \ 164 163 const __typeof__(*(ptr)) *__gu_addr = (ptr); \ 165 - if (access_ok(VERIFY_READ,__gu_addr,size)) \ 166 - __get_user_size(__gu_val,__gu_addr,(size),__gu_err); \ 164 + if (access_ok(VERIFY_READ, __gu_addr, size)) \ 165 + __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \ 167 166 (x) = (__force __typeof__(*(ptr)))__gu_val; \ 168 167 __gu_err; \ 169 168 }) ··· 181 180 __generic_copy_to_user(void __user *to, const void *from, unsigned long n) 182 181 { 183 182 if (access_ok(VERIFY_WRITE, to, n)) 184 - return __copy_user(to,from,n); 183 + return __copy_user(to, from, n); 185 184 return n; 186 185 } 187 186 ··· 189 188 __generic_copy_from_user(void *to, const void __user *from, unsigned long n) 190 189 { 191 190 if (access_ok(VERIFY_READ, from, n)) 192 - return __copy_user_zeroing(to,from,n); 191 + return __copy_user_zeroing(to, from, n); 193 192 return n; 194 193 } 195 194 ··· 197 196 __generic_clear_user(void __user *to, unsigned long n) 198 197 { 199 198 if (access_ok(VERIFY_WRITE, to, n)) 200 - return __do_clear_user(to,n); 199 + return __do_clear_user(to, n); 201 200 return n; 202 201 } 203 202 ··· 374 373 __generic_copy_from_user_nocheck(void *to, const void __user *from, 375 374 unsigned long n) 376 375 { 377 - return __copy_user_zeroing(to,from,n); 376 + return __copy_user_zeroing(to, from, n); 378 377 } 379 378 380 379 static inline unsigned long 381 380 __generic_copy_to_user_nocheck(void __user *to, const void *from, 382 381 unsigned long n) 383 382 { 384 - return __copy_user(to,from,n); 383 + return __copy_user(to, from, n); 385 384 } 386 385 387 386 static inline unsigned long 388 387 __generic_clear_user_nocheck(void __user *to, unsigned long n) 389 388 { 390 - return __do_clear_user(to,n); 389 + return __do_clear_user(to, n); 391 390 } 392 391 393 392 /* without checking */ 394 393 395 - #define __copy_to_user(to,from,n) __generic_copy_to_user_nocheck((to),(from),(n)) 396 - #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n)) 394 + #define __copy_to_user(to, from, n) \ 395 + __generic_copy_to_user_nocheck((to), (from), (n)) 396 + #define __copy_from_user(to, from, n) \ 397 + __generic_copy_from_user_nocheck((to), (from), (n)) 397 398 #define __copy_to_user_inatomic __copy_to_user 398 399 #define __copy_from_user_inatomic __copy_from_user 399 - #define __clear_user(to,n) __generic_clear_user_nocheck((to),(n)) 400 + #define __clear_user(to, n) __generic_clear_user_nocheck((to), (n)) 400 401 401 402 #define strlen_user(str) strnlen_user((str), 0x7ffffffe) 402 403