This switches atomic-instrumented.h to use the generic instrumentation wrappers provided by instrumented.h. No functional change intended.
Unified · Split
| @@ -19,25 +19,12 @@ · 18 unmodified lines | |||
| 19 | 19 | ||
| 20 | #include <linux/build_bug.h> | 20 | #include <linux/build_bug.h> |
| 21 | #include <linux/compiler.h> | 21 | #include <linux/compiler.h> |
| 22 | #include <linux/kasan-checks.h> | 22 | #include <linux/instrumented.h> |
| 23 | #include <linux/kcsan-checks.h> | ||
| 24 | |||
| 25 | static __always_inline void __atomic_check_read(const volatile void *v, size_t size) | ||
| 26 | { | ||
| 27 | kasan_check_read(v, size); | ||
| 28 | kcsan_check_atomic_read(v, size); | ||
| 29 | } | ||
| 30 | |||
| 31 | static __always_inline void __atomic_check_write(const volatile void *v, size_t size) | ||
| 32 | { | ||
| 33 | kasan_check_write(v, size); | ||
| 34 | kcsan_check_atomic_write(v, size); | ||
| 35 | } | ||
| 36 | 23 | ||
| 37 | static __always_inline int | 24 | static __always_inline int |
| 38 | atomic_read(const atomic_t *v) | 25 | atomic_read(const atomic_t *v) |
| 39 | { | 26 | { |
| 40 | __atomic_check_read(v, sizeof(*v)); | 27 | instrument_atomic_read(v, sizeof(*v)); |
| 41 | return arch_atomic_read(v); | 28 | return arch_atomic_read(v); |
| 42 | } | 29 | } |
| 43 | #define atomic_read atomic_read | 30 | #define atomic_read atomic_read |
| @@ -46,7 +33,7 @@ atomic_read(const atomic_t *v) · 2 unmodified lines | |||
| 46 | static __always_inline int | 33 | static __always_inline int |
| 47 | atomic_read_acquire(const atomic_t *v) | 34 | atomic_read_acquire(const atomic_t *v) |
| 48 | { | 35 | { |
| 49 | __atomic_check_read(v, sizeof(*v)); | 36 | instrument_atomic_read(v, sizeof(*v)); |
| 50 | return arch_atomic_read_acquire(v); | 37 | return arch_atomic_read_acquire(v); |
| 51 | } | 38 | } |
| 52 | #define atomic_read_acquire atomic_read_acquire | 39 | #define atomic_read_acquire atomic_read_acquire |
| @@ -55,7 +42,7 @@ atomic_read_acquire(const atomic_t *v) · 2 unmodified lines | |||
| 55 | static __always_inline void | 42 | static __always_inline void |
| 56 | atomic_set(atomic_t *v, int i) | 43 | atomic_set(atomic_t *v, int i) |
| 57 | { | 44 | { |
| 58 | __atomic_check_write(v, sizeof(*v)); | 45 | instrument_atomic_write(v, sizeof(*v)); |
| 59 | arch_atomic_set(v, i); | 46 | arch_atomic_set(v, i); |
| 60 | } | 47 | } |
| 61 | #define atomic_set atomic_set | 48 | #define atomic_set atomic_set |
| @@ -64,7 +51,7 @@ atomic_set(atomic_t *v, int i) · 2 unmodified lines | |||
| 64 | static __always_inline void | 51 | static __always_inline void |
| 65 | atomic_set_release(atomic_t *v, int i) | 52 | atomic_set_release(atomic_t *v, int i) |
| 66 | { | 53 | { |
| 67 | __atomic_check_write(v, sizeof(*v)); | 54 | instrument_atomic_write(v, sizeof(*v)); |
| 68 | arch_atomic_set_release(v, i); | 55 | arch_atomic_set_release(v, i); |
| 69 | } | 56 | } |
| 70 | #define atomic_set_release atomic_set_release | 57 | #define atomic_set_release atomic_set_release |
| @@ -73,7 +60,7 @@ atomic_set_release(atomic_t *v, int i) · 2 unmodified lines | |||
| 73 | static __always_inline void | 60 | static __always_inline void |
| 74 | atomic_add(int i, atomic_t *v) | 61 | atomic_add(int i, atomic_t *v) |
| 75 | { | 62 | { |
| 76 | __atomic_check_write(v, sizeof(*v)); | 63 | instrument_atomic_write(v, sizeof(*v)); |
| 77 | arch_atomic_add(i, v); | 64 | arch_atomic_add(i, v); |
| 78 | } | 65 | } |
| 79 | #define atomic_add atomic_add | 66 | #define atomic_add atomic_add |
| @@ -82,7 +69,7 @@ atomic_add(int i, atomic_t *v) · 2 unmodified lines | |||
| 82 | static __always_inline int | 69 | static __always_inline int |
| 83 | atomic_add_return(int i, atomic_t *v) | 70 | atomic_add_return(int i, atomic_t *v) |
| 84 | { | 71 | { |
| 85 | __atomic_check_write(v, sizeof(*v)); | 72 | instrument_atomic_write(v, sizeof(*v)); |
| 86 | return arch_atomic_add_return(i, v); | 73 | return arch_atomic_add_return(i, v); |
| 87 | } | 74 | } |
| 88 | #define atomic_add_return atomic_add_return | 75 | #define atomic_add_return atomic_add_return |
| @@ -92,7 +79,7 @@ atomic_add_return(int i, atomic_t *v) · 3 unmodified lines | |||
| 92 | static __always_inline int | 79 | static __always_inline int |
| 93 | atomic_add_return_acquire(int i, atomic_t *v) | 80 | atomic_add_return_acquire(int i, atomic_t *v) |
| 94 | { | 81 | { |
| 95 | __atomic_check_write(v, sizeof(*v)); | 82 | instrument_atomic_write(v, sizeof(*v)); |
| 96 | return arch_atomic_add_return_acquire(i, v); | 83 | return arch_atomic_add_return_acquire(i, v); |
| 97 | } | 84 | } |
| 98 | #define atomic_add_return_acquire atomic_add_return_acquire | 85 | #define atomic_add_return_acquire atomic_add_return_acquire |
| @@ -102,7 +89,7 @@ atomic_add_return_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 102 | static __always_inline int | 89 | static __always_inline int |
| 103 | atomic_add_return_release(int i, atomic_t *v) | 90 | atomic_add_return_release(int i, atomic_t *v) |
| 104 | { | 91 | { |
| 105 | __atomic_check_write(v, sizeof(*v)); | 92 | instrument_atomic_write(v, sizeof(*v)); |
| 106 | return arch_atomic_add_return_release(i, v); | 93 | return arch_atomic_add_return_release(i, v); |
| 107 | } | 94 | } |
| 108 | #define atomic_add_return_release atomic_add_return_release | 95 | #define atomic_add_return_release atomic_add_return_release |
| @@ -112,7 +99,7 @@ atomic_add_return_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 112 | static __always_inline int | 99 | static __always_inline int |
| 113 | atomic_add_return_relaxed(int i, atomic_t *v) | 100 | atomic_add_return_relaxed(int i, atomic_t *v) |
| 114 | { | 101 | { |
| 115 | __atomic_check_write(v, sizeof(*v)); | 102 | instrument_atomic_write(v, sizeof(*v)); |
| 116 | return arch_atomic_add_return_relaxed(i, v); | 103 | return arch_atomic_add_return_relaxed(i, v); |
| 117 | } | 104 | } |
| 118 | #define atomic_add_return_relaxed atomic_add_return_relaxed | 105 | #define atomic_add_return_relaxed atomic_add_return_relaxed |
| @@ -122,7 +109,7 @@ atomic_add_return_relaxed(int i, atomic_t *v) · 3 unmodified lines | |||
| 122 | static __always_inline int | 109 | static __always_inline int |
| 123 | atomic_fetch_add(int i, atomic_t *v) | 110 | atomic_fetch_add(int i, atomic_t *v) |
| 124 | { | 111 | { |
| 125 | __atomic_check_write(v, sizeof(*v)); | 112 | instrument_atomic_write(v, sizeof(*v)); |
| 126 | return arch_atomic_fetch_add(i, v); | 113 | return arch_atomic_fetch_add(i, v); |
| 127 | } | 114 | } |
| 128 | #define atomic_fetch_add atomic_fetch_add | 115 | #define atomic_fetch_add atomic_fetch_add |
| @@ -132,7 +119,7 @@ atomic_fetch_add(int i, atomic_t *v) · 3 unmodified lines | |||
| 132 | static __always_inline int | 119 | static __always_inline int |
| 133 | atomic_fetch_add_acquire(int i, atomic_t *v) | 120 | atomic_fetch_add_acquire(int i, atomic_t *v) |
| 134 | { | 121 | { |
| 135 | __atomic_check_write(v, sizeof(*v)); | 122 | instrument_atomic_write(v, sizeof(*v)); |
| 136 | return arch_atomic_fetch_add_acquire(i, v); | 123 | return arch_atomic_fetch_add_acquire(i, v); |
| 137 | } | 124 | } |
| 138 | #define atomic_fetch_add_acquire atomic_fetch_add_acquire | 125 | #define atomic_fetch_add_acquire atomic_fetch_add_acquire |
| @@ -142,7 +129,7 @@ atomic_fetch_add_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 142 | static __always_inline int | 129 | static __always_inline int |
| 143 | atomic_fetch_add_release(int i, atomic_t *v) | 130 | atomic_fetch_add_release(int i, atomic_t *v) |
| 144 | { | 131 | { |
| 145 | __atomic_check_write(v, sizeof(*v)); | 132 | instrument_atomic_write(v, sizeof(*v)); |
| 146 | return arch_atomic_fetch_add_release(i, v); | 133 | return arch_atomic_fetch_add_release(i, v); |
| 147 | } | 134 | } |
| 148 | #define atomic_fetch_add_release atomic_fetch_add_release | 135 | #define atomic_fetch_add_release atomic_fetch_add_release |
| @@ -152,7 +139,7 @@ atomic_fetch_add_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 152 | static __always_inline int | 139 | static __always_inline int |
| 153 | atomic_fetch_add_relaxed(int i, atomic_t *v) | 140 | atomic_fetch_add_relaxed(int i, atomic_t *v) |
| 154 | { | 141 | { |
| 155 | __atomic_check_write(v, sizeof(*v)); | 142 | instrument_atomic_write(v, sizeof(*v)); |
| 156 | return arch_atomic_fetch_add_relaxed(i, v); | 143 | return arch_atomic_fetch_add_relaxed(i, v); |
| 157 | } | 144 | } |
| 158 | #define atomic_fetch_add_relaxed atomic_fetch_add_relaxed | 145 | #define atomic_fetch_add_relaxed atomic_fetch_add_relaxed |
| @@ -161,7 +148,7 @@ atomic_fetch_add_relaxed(int i, atomic_t *v) · 2 unmodified lines | |||
| 161 | static __always_inline void | 148 | static __always_inline void |
| 162 | atomic_sub(int i, atomic_t *v) | 149 | atomic_sub(int i, atomic_t *v) |
| 163 | { | 150 | { |
| 164 | __atomic_check_write(v, sizeof(*v)); | 151 | instrument_atomic_write(v, sizeof(*v)); |
| 165 | arch_atomic_sub(i, v); | 152 | arch_atomic_sub(i, v); |
| 166 | } | 153 | } |
| 167 | #define atomic_sub atomic_sub | 154 | #define atomic_sub atomic_sub |
| @@ -170,7 +157,7 @@ atomic_sub(int i, atomic_t *v) · 2 unmodified lines | |||
| 170 | static __always_inline int | 157 | static __always_inline int |
| 171 | atomic_sub_return(int i, atomic_t *v) | 158 | atomic_sub_return(int i, atomic_t *v) |
| 172 | { | 159 | { |
| 173 | __atomic_check_write(v, sizeof(*v)); | 160 | instrument_atomic_write(v, sizeof(*v)); |
| 174 | return arch_atomic_sub_return(i, v); | 161 | return arch_atomic_sub_return(i, v); |
| 175 | } | 162 | } |
| 176 | #define atomic_sub_return atomic_sub_return | 163 | #define atomic_sub_return atomic_sub_return |
| @@ -180,7 +167,7 @@ atomic_sub_return(int i, atomic_t *v) · 3 unmodified lines | |||
| 180 | static __always_inline int | 167 | static __always_inline int |
| 181 | atomic_sub_return_acquire(int i, atomic_t *v) | 168 | atomic_sub_return_acquire(int i, atomic_t *v) |
| 182 | { | 169 | { |
| 183 | __atomic_check_write(v, sizeof(*v)); | 170 | instrument_atomic_write(v, sizeof(*v)); |
| 184 | return arch_atomic_sub_return_acquire(i, v); | 171 | return arch_atomic_sub_return_acquire(i, v); |
| 185 | } | 172 | } |
| 186 | #define atomic_sub_return_acquire atomic_sub_return_acquire | 173 | #define atomic_sub_return_acquire atomic_sub_return_acquire |
| @@ -190,7 +177,7 @@ atomic_sub_return_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 190 | static __always_inline int | 177 | static __always_inline int |
| 191 | atomic_sub_return_release(int i, atomic_t *v) | 178 | atomic_sub_return_release(int i, atomic_t *v) |
| 192 | { | 179 | { |
| 193 | __atomic_check_write(v, sizeof(*v)); | 180 | instrument_atomic_write(v, sizeof(*v)); |
| 194 | return arch_atomic_sub_return_release(i, v); | 181 | return arch_atomic_sub_return_release(i, v); |
| 195 | } | 182 | } |
| 196 | #define atomic_sub_return_release atomic_sub_return_release | 183 | #define atomic_sub_return_release atomic_sub_return_release |
| @@ -200,7 +187,7 @@ atomic_sub_return_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 200 | static __always_inline int | 187 | static __always_inline int |
| 201 | atomic_sub_return_relaxed(int i, atomic_t *v) | 188 | atomic_sub_return_relaxed(int i, atomic_t *v) |
| 202 | { | 189 | { |
| 203 | __atomic_check_write(v, sizeof(*v)); | 190 | instrument_atomic_write(v, sizeof(*v)); |
| 204 | return arch_atomic_sub_return_relaxed(i, v); | 191 | return arch_atomic_sub_return_relaxed(i, v); |
| 205 | } | 192 | } |
| 206 | #define atomic_sub_return_relaxed atomic_sub_return_relaxed | 193 | #define atomic_sub_return_relaxed atomic_sub_return_relaxed |
| @@ -210,7 +197,7 @@ atomic_sub_return_relaxed(int i, atomic_t *v) · 3 unmodified lines | |||
| 210 | static __always_inline int | 197 | static __always_inline int |
| 211 | atomic_fetch_sub(int i, atomic_t *v) | 198 | atomic_fetch_sub(int i, atomic_t *v) |
| 212 | { | 199 | { |
| 213 | __atomic_check_write(v, sizeof(*v)); | 200 | instrument_atomic_write(v, sizeof(*v)); |
| 214 | return arch_atomic_fetch_sub(i, v); | 201 | return arch_atomic_fetch_sub(i, v); |
| 215 | } | 202 | } |
| 216 | #define atomic_fetch_sub atomic_fetch_sub | 203 | #define atomic_fetch_sub atomic_fetch_sub |
| @@ -220,7 +207,7 @@ atomic_fetch_sub(int i, atomic_t *v) · 3 unmodified lines | |||
| 220 | static __always_inline int | 207 | static __always_inline int |
| 221 | atomic_fetch_sub_acquire(int i, atomic_t *v) | 208 | atomic_fetch_sub_acquire(int i, atomic_t *v) |
| 222 | { | 209 | { |
| 223 | __atomic_check_write(v, sizeof(*v)); | 210 | instrument_atomic_write(v, sizeof(*v)); |
| 224 | return arch_atomic_fetch_sub_acquire(i, v); | 211 | return arch_atomic_fetch_sub_acquire(i, v); |
| 225 | } | 212 | } |
| 226 | #define atomic_fetch_sub_acquire atomic_fetch_sub_acquire | 213 | #define atomic_fetch_sub_acquire atomic_fetch_sub_acquire |
| @@ -230,7 +217,7 @@ atomic_fetch_sub_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 230 | static __always_inline int | 217 | static __always_inline int |
| 231 | atomic_fetch_sub_release(int i, atomic_t *v) | 218 | atomic_fetch_sub_release(int i, atomic_t *v) |
| 232 | { | 219 | { |
| 233 | __atomic_check_write(v, sizeof(*v)); | 220 | instrument_atomic_write(v, sizeof(*v)); |
| 234 | return arch_atomic_fetch_sub_release(i, v); | 221 | return arch_atomic_fetch_sub_release(i, v); |
| 235 | } | 222 | } |
| 236 | #define atomic_fetch_sub_release atomic_fetch_sub_release | 223 | #define atomic_fetch_sub_release atomic_fetch_sub_release |
| @@ -240,7 +227,7 @@ atomic_fetch_sub_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 240 | static __always_inline int | 227 | static __always_inline int |
| 241 | atomic_fetch_sub_relaxed(int i, atomic_t *v) | 228 | atomic_fetch_sub_relaxed(int i, atomic_t *v) |
| 242 | { | 229 | { |
| 243 | __atomic_check_write(v, sizeof(*v)); | 230 | instrument_atomic_write(v, sizeof(*v)); |
| 244 | return arch_atomic_fetch_sub_relaxed(i, v); | 231 | return arch_atomic_fetch_sub_relaxed(i, v); |
| 245 | } | 232 | } |
| 246 | #define atomic_fetch_sub_relaxed atomic_fetch_sub_relaxed | 233 | #define atomic_fetch_sub_relaxed atomic_fetch_sub_relaxed |
| @@ -250,7 +237,7 @@ atomic_fetch_sub_relaxed(int i, atomic_t *v) · 3 unmodified lines | |||
| 250 | static __always_inline void | 237 | static __always_inline void |
| 251 | atomic_inc(atomic_t *v) | 238 | atomic_inc(atomic_t *v) |
| 252 | { | 239 | { |
| 253 | __atomic_check_write(v, sizeof(*v)); | 240 | instrument_atomic_write(v, sizeof(*v)); |
| 254 | arch_atomic_inc(v); | 241 | arch_atomic_inc(v); |
| 255 | } | 242 | } |
| 256 | #define atomic_inc atomic_inc | 243 | #define atomic_inc atomic_inc |
| @@ -260,7 +247,7 @@ atomic_inc(atomic_t *v) · 3 unmodified lines | |||
| 260 | static __always_inline int | 247 | static __always_inline int |
| 261 | atomic_inc_return(atomic_t *v) | 248 | atomic_inc_return(atomic_t *v) |
| 262 | { | 249 | { |
| 263 | __atomic_check_write(v, sizeof(*v)); | 250 | instrument_atomic_write(v, sizeof(*v)); |
| 264 | return arch_atomic_inc_return(v); | 251 | return arch_atomic_inc_return(v); |
| 265 | } | 252 | } |
| 266 | #define atomic_inc_return atomic_inc_return | 253 | #define atomic_inc_return atomic_inc_return |
| @@ -270,7 +257,7 @@ atomic_inc_return(atomic_t *v) · 3 unmodified lines | |||
| 270 | static __always_inline int | 257 | static __always_inline int |
| 271 | atomic_inc_return_acquire(atomic_t *v) | 258 | atomic_inc_return_acquire(atomic_t *v) |
| 272 | { | 259 | { |
| 273 | __atomic_check_write(v, sizeof(*v)); | 260 | instrument_atomic_write(v, sizeof(*v)); |
| 274 | return arch_atomic_inc_return_acquire(v); | 261 | return arch_atomic_inc_return_acquire(v); |
| 275 | } | 262 | } |
| 276 | #define atomic_inc_return_acquire atomic_inc_return_acquire | 263 | #define atomic_inc_return_acquire atomic_inc_return_acquire |
| @@ -280,7 +267,7 @@ atomic_inc_return_acquire(atomic_t *v) · 3 unmodified lines | |||
| 280 | static __always_inline int | 267 | static __always_inline int |
| 281 | atomic_inc_return_release(atomic_t *v) | 268 | atomic_inc_return_release(atomic_t *v) |
| 282 | { | 269 | { |
| 283 | __atomic_check_write(v, sizeof(*v)); | 270 | instrument_atomic_write(v, sizeof(*v)); |
| 284 | return arch_atomic_inc_return_release(v); | 271 | return arch_atomic_inc_return_release(v); |
| 285 | } | 272 | } |
| 286 | #define atomic_inc_return_release atomic_inc_return_release | 273 | #define atomic_inc_return_release atomic_inc_return_release |
| @@ -290,7 +277,7 @@ atomic_inc_return_release(atomic_t *v) · 3 unmodified lines | |||
| 290 | static __always_inline int | 277 | static __always_inline int |
| 291 | atomic_inc_return_relaxed(atomic_t *v) | 278 | atomic_inc_return_relaxed(atomic_t *v) |
| 292 | { | 279 | { |
| 293 | __atomic_check_write(v, sizeof(*v)); | 280 | instrument_atomic_write(v, sizeof(*v)); |
| 294 | return arch_atomic_inc_return_relaxed(v); | 281 | return arch_atomic_inc_return_relaxed(v); |
| 295 | } | 282 | } |
| 296 | #define atomic_inc_return_relaxed atomic_inc_return_relaxed | 283 | #define atomic_inc_return_relaxed atomic_inc_return_relaxed |
| @@ -300,7 +287,7 @@ atomic_inc_return_relaxed(atomic_t *v) · 3 unmodified lines | |||
| 300 | static __always_inline int | 287 | static __always_inline int |
| 301 | atomic_fetch_inc(atomic_t *v) | 288 | atomic_fetch_inc(atomic_t *v) |
| 302 | { | 289 | { |
| 303 | __atomic_check_write(v, sizeof(*v)); | 290 | instrument_atomic_write(v, sizeof(*v)); |
| 304 | return arch_atomic_fetch_inc(v); | 291 | return arch_atomic_fetch_inc(v); |
| 305 | } | 292 | } |
| 306 | #define atomic_fetch_inc atomic_fetch_inc | 293 | #define atomic_fetch_inc atomic_fetch_inc |
| @@ -310,7 +297,7 @@ atomic_fetch_inc(atomic_t *v) · 3 unmodified lines | |||
| 310 | static __always_inline int | 297 | static __always_inline int |
| 311 | atomic_fetch_inc_acquire(atomic_t *v) | 298 | atomic_fetch_inc_acquire(atomic_t *v) |
| 312 | { | 299 | { |
| 313 | __atomic_check_write(v, sizeof(*v)); | 300 | instrument_atomic_write(v, sizeof(*v)); |
| 314 | return arch_atomic_fetch_inc_acquire(v); | 301 | return arch_atomic_fetch_inc_acquire(v); |
| 315 | } | 302 | } |
| 316 | #define atomic_fetch_inc_acquire atomic_fetch_inc_acquire | 303 | #define atomic_fetch_inc_acquire atomic_fetch_inc_acquire |
| @@ -320,7 +307,7 @@ atomic_fetch_inc_acquire(atomic_t *v) · 3 unmodified lines | |||
| 320 | static __always_inline int | 307 | static __always_inline int |
| 321 | atomic_fetch_inc_release(atomic_t *v) | 308 | atomic_fetch_inc_release(atomic_t *v) |
| 322 | { | 309 | { |
| 323 | __atomic_check_write(v, sizeof(*v)); | 310 | instrument_atomic_write(v, sizeof(*v)); |
| 324 | return arch_atomic_fetch_inc_release(v); | 311 | return arch_atomic_fetch_inc_release(v); |
| 325 | } | 312 | } |
| 326 | #define atomic_fetch_inc_release atomic_fetch_inc_release | 313 | #define atomic_fetch_inc_release atomic_fetch_inc_release |
| @@ -330,7 +317,7 @@ atomic_fetch_inc_release(atomic_t *v) · 3 unmodified lines | |||
| 330 | static __always_inline int | 317 | static __always_inline int |
| 331 | atomic_fetch_inc_relaxed(atomic_t *v) | 318 | atomic_fetch_inc_relaxed(atomic_t *v) |
| 332 | { | 319 | { |
| 333 | __atomic_check_write(v, sizeof(*v)); | 320 | instrument_atomic_write(v, sizeof(*v)); |
| 334 | return arch_atomic_fetch_inc_relaxed(v); | 321 | return arch_atomic_fetch_inc_relaxed(v); |
| 335 | } | 322 | } |
| 336 | #define atomic_fetch_inc_relaxed atomic_fetch_inc_relaxed | 323 | #define atomic_fetch_inc_relaxed atomic_fetch_inc_relaxed |
| @@ -340,7 +327,7 @@ atomic_fetch_inc_relaxed(atomic_t *v) · 3 unmodified lines | |||
| 340 | static __always_inline void | 327 | static __always_inline void |
| 341 | atomic_dec(atomic_t *v) | 328 | atomic_dec(atomic_t *v) |
| 342 | { | 329 | { |
| 343 | __atomic_check_write(v, sizeof(*v)); | 330 | instrument_atomic_write(v, sizeof(*v)); |
| 344 | arch_atomic_dec(v); | 331 | arch_atomic_dec(v); |
| 345 | } | 332 | } |
| 346 | #define atomic_dec atomic_dec | 333 | #define atomic_dec atomic_dec |
| @@ -350,7 +337,7 @@ atomic_dec(atomic_t *v) · 3 unmodified lines | |||
| 350 | static __always_inline int | 337 | static __always_inline int |
| 351 | atomic_dec_return(atomic_t *v) | 338 | atomic_dec_return(atomic_t *v) |
| 352 | { | 339 | { |
| 353 | __atomic_check_write(v, sizeof(*v)); | 340 | instrument_atomic_write(v, sizeof(*v)); |
| 354 | return arch_atomic_dec_return(v); | 341 | return arch_atomic_dec_return(v); |
| 355 | } | 342 | } |
| 356 | #define atomic_dec_return atomic_dec_return | 343 | #define atomic_dec_return atomic_dec_return |
| @@ -360,7 +347,7 @@ atomic_dec_return(atomic_t *v) · 3 unmodified lines | |||
| 360 | static __always_inline int | 347 | static __always_inline int |
| 361 | atomic_dec_return_acquire(atomic_t *v) | 348 | atomic_dec_return_acquire(atomic_t *v) |
| 362 | { | 349 | { |
| 363 | __atomic_check_write(v, sizeof(*v)); | 350 | instrument_atomic_write(v, sizeof(*v)); |
| 364 | return arch_atomic_dec_return_acquire(v); | 351 | return arch_atomic_dec_return_acquire(v); |
| 365 | } | 352 | } |
| 366 | #define atomic_dec_return_acquire atomic_dec_return_acquire | 353 | #define atomic_dec_return_acquire atomic_dec_return_acquire |
| @@ -370,7 +357,7 @@ atomic_dec_return_acquire(atomic_t *v) · 3 unmodified lines | |||
| 370 | static __always_inline int | 357 | static __always_inline int |
| 371 | atomic_dec_return_release(atomic_t *v) | 358 | atomic_dec_return_release(atomic_t *v) |
| 372 | { | 359 | { |
| 373 | __atomic_check_write(v, sizeof(*v)); | 360 | instrument_atomic_write(v, sizeof(*v)); |
| 374 | return arch_atomic_dec_return_release(v); | 361 | return arch_atomic_dec_return_release(v); |
| 375 | } | 362 | } |
| 376 | #define atomic_dec_return_release atomic_dec_return_release | 363 | #define atomic_dec_return_release atomic_dec_return_release |
| @@ -380,7 +367,7 @@ atomic_dec_return_release(atomic_t *v) · 3 unmodified lines | |||
| 380 | static __always_inline int | 367 | static __always_inline int |
| 381 | atomic_dec_return_relaxed(atomic_t *v) | 368 | atomic_dec_return_relaxed(atomic_t *v) |
| 382 | { | 369 | { |
| 383 | __atomic_check_write(v, sizeof(*v)); | 370 | instrument_atomic_write(v, sizeof(*v)); |
| 384 | return arch_atomic_dec_return_relaxed(v); | 371 | return arch_atomic_dec_return_relaxed(v); |
| 385 | } | 372 | } |
| 386 | #define atomic_dec_return_relaxed atomic_dec_return_relaxed | 373 | #define atomic_dec_return_relaxed atomic_dec_return_relaxed |
| @@ -390,7 +377,7 @@ atomic_dec_return_relaxed(atomic_t *v) · 3 unmodified lines | |||
| 390 | static __always_inline int | 377 | static __always_inline int |
| 391 | atomic_fetch_dec(atomic_t *v) | 378 | atomic_fetch_dec(atomic_t *v) |
| 392 | { | 379 | { |
| 393 | __atomic_check_write(v, sizeof(*v)); | 380 | instrument_atomic_write(v, sizeof(*v)); |
| 394 | return arch_atomic_fetch_dec(v); | 381 | return arch_atomic_fetch_dec(v); |
| 395 | } | 382 | } |
| 396 | #define atomic_fetch_dec atomic_fetch_dec | 383 | #define atomic_fetch_dec atomic_fetch_dec |
| @@ -400,7 +387,7 @@ atomic_fetch_dec(atomic_t *v) · 3 unmodified lines | |||
| 400 | static __always_inline int | 387 | static __always_inline int |
| 401 | atomic_fetch_dec_acquire(atomic_t *v) | 388 | atomic_fetch_dec_acquire(atomic_t *v) |
| 402 | { | 389 | { |
| 403 | __atomic_check_write(v, sizeof(*v)); | 390 | instrument_atomic_write(v, sizeof(*v)); |
| 404 | return arch_atomic_fetch_dec_acquire(v); | 391 | return arch_atomic_fetch_dec_acquire(v); |
| 405 | } | 392 | } |
| 406 | #define atomic_fetch_dec_acquire atomic_fetch_dec_acquire | 393 | #define atomic_fetch_dec_acquire atomic_fetch_dec_acquire |
| @@ -410,7 +397,7 @@ atomic_fetch_dec_acquire(atomic_t *v) · 3 unmodified lines | |||
| 410 | static __always_inline int | 397 | static __always_inline int |
| 411 | atomic_fetch_dec_release(atomic_t *v) | 398 | atomic_fetch_dec_release(atomic_t *v) |
| 412 | { | 399 | { |
| 413 | __atomic_check_write(v, sizeof(*v)); | 400 | instrument_atomic_write(v, sizeof(*v)); |
| 414 | return arch_atomic_fetch_dec_release(v); | 401 | return arch_atomic_fetch_dec_release(v); |
| 415 | } | 402 | } |
| 416 | #define atomic_fetch_dec_release atomic_fetch_dec_release | 403 | #define atomic_fetch_dec_release atomic_fetch_dec_release |
| @@ -420,7 +407,7 @@ atomic_fetch_dec_release(atomic_t *v) · 3 unmodified lines | |||
| 420 | static __always_inline int | 407 | static __always_inline int |
| 421 | atomic_fetch_dec_relaxed(atomic_t *v) | 408 | atomic_fetch_dec_relaxed(atomic_t *v) |
| 422 | { | 409 | { |
| 423 | __atomic_check_write(v, sizeof(*v)); | 410 | instrument_atomic_write(v, sizeof(*v)); |
| 424 | return arch_atomic_fetch_dec_relaxed(v); | 411 | return arch_atomic_fetch_dec_relaxed(v); |
| 425 | } | 412 | } |
| 426 | #define atomic_fetch_dec_relaxed atomic_fetch_dec_relaxed | 413 | #define atomic_fetch_dec_relaxed atomic_fetch_dec_relaxed |
| @@ -429,7 +416,7 @@ atomic_fetch_dec_relaxed(atomic_t *v) · 2 unmodified lines | |||
| 429 | static __always_inline void | 416 | static __always_inline void |
| 430 | atomic_and(int i, atomic_t *v) | 417 | atomic_and(int i, atomic_t *v) |
| 431 | { | 418 | { |
| 432 | __atomic_check_write(v, sizeof(*v)); | 419 | instrument_atomic_write(v, sizeof(*v)); |
| 433 | arch_atomic_and(i, v); | 420 | arch_atomic_and(i, v); |
| 434 | } | 421 | } |
| 435 | #define atomic_and atomic_and | 422 | #define atomic_and atomic_and |
| @@ -438,7 +425,7 @@ atomic_and(int i, atomic_t *v) · 2 unmodified lines | |||
| 438 | static __always_inline int | 425 | static __always_inline int |
| 439 | atomic_fetch_and(int i, atomic_t *v) | 426 | atomic_fetch_and(int i, atomic_t *v) |
| 440 | { | 427 | { |
| 441 | __atomic_check_write(v, sizeof(*v)); | 428 | instrument_atomic_write(v, sizeof(*v)); |
| 442 | return arch_atomic_fetch_and(i, v); | 429 | return arch_atomic_fetch_and(i, v); |
| 443 | } | 430 | } |
| 444 | #define atomic_fetch_and atomic_fetch_and | 431 | #define atomic_fetch_and atomic_fetch_and |
| @@ -448,7 +435,7 @@ atomic_fetch_and(int i, atomic_t *v) · 3 unmodified lines | |||
| 448 | static __always_inline int | 435 | static __always_inline int |
| 449 | atomic_fetch_and_acquire(int i, atomic_t *v) | 436 | atomic_fetch_and_acquire(int i, atomic_t *v) |
| 450 | { | 437 | { |
| 451 | __atomic_check_write(v, sizeof(*v)); | 438 | instrument_atomic_write(v, sizeof(*v)); |
| 452 | return arch_atomic_fetch_and_acquire(i, v); | 439 | return arch_atomic_fetch_and_acquire(i, v); |
| 453 | } | 440 | } |
| 454 | #define atomic_fetch_and_acquire atomic_fetch_and_acquire | 441 | #define atomic_fetch_and_acquire atomic_fetch_and_acquire |
| @@ -458,7 +445,7 @@ atomic_fetch_and_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 458 | static __always_inline int | 445 | static __always_inline int |
| 459 | atomic_fetch_and_release(int i, atomic_t *v) | 446 | atomic_fetch_and_release(int i, atomic_t *v) |
| 460 | { | 447 | { |
| 461 | __atomic_check_write(v, sizeof(*v)); | 448 | instrument_atomic_write(v, sizeof(*v)); |
| 462 | return arch_atomic_fetch_and_release(i, v); | 449 | return arch_atomic_fetch_and_release(i, v); |
| 463 | } | 450 | } |
| 464 | #define atomic_fetch_and_release atomic_fetch_and_release | 451 | #define atomic_fetch_and_release atomic_fetch_and_release |
| @@ -468,7 +455,7 @@ atomic_fetch_and_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 468 | static __always_inline int | 455 | static __always_inline int |
| 469 | atomic_fetch_and_relaxed(int i, atomic_t *v) | 456 | atomic_fetch_and_relaxed(int i, atomic_t *v) |
| 470 | { | 457 | { |
| 471 | __atomic_check_write(v, sizeof(*v)); | 458 | instrument_atomic_write(v, sizeof(*v)); |
| 472 | return arch_atomic_fetch_and_relaxed(i, v); | 459 | return arch_atomic_fetch_and_relaxed(i, v); |
| 473 | } | 460 | } |
| 474 | #define atomic_fetch_and_relaxed atomic_fetch_and_relaxed | 461 | #define atomic_fetch_and_relaxed atomic_fetch_and_relaxed |
| @@ -478,7 +465,7 @@ atomic_fetch_and_relaxed(int i, atomic_t *v) · 3 unmodified lines | |||
| 478 | static __always_inline void | 465 | static __always_inline void |
| 479 | atomic_andnot(int i, atomic_t *v) | 466 | atomic_andnot(int i, atomic_t *v) |
| 480 | { | 467 | { |
| 481 | __atomic_check_write(v, sizeof(*v)); | 468 | instrument_atomic_write(v, sizeof(*v)); |
| 482 | arch_atomic_andnot(i, v); | 469 | arch_atomic_andnot(i, v); |
| 483 | } | 470 | } |
| 484 | #define atomic_andnot atomic_andnot | 471 | #define atomic_andnot atomic_andnot |
| @@ -488,7 +475,7 @@ atomic_andnot(int i, atomic_t *v) · 3 unmodified lines | |||
| 488 | static __always_inline int | 475 | static __always_inline int |
| 489 | atomic_fetch_andnot(int i, atomic_t *v) | 476 | atomic_fetch_andnot(int i, atomic_t *v) |
| 490 | { | 477 | { |
| 491 | __atomic_check_write(v, sizeof(*v)); | 478 | instrument_atomic_write(v, sizeof(*v)); |
| 492 | return arch_atomic_fetch_andnot(i, v); | 479 | return arch_atomic_fetch_andnot(i, v); |
| 493 | } | 480 | } |
| 494 | #define atomic_fetch_andnot atomic_fetch_andnot | 481 | #define atomic_fetch_andnot atomic_fetch_andnot |
| @@ -498,7 +485,7 @@ atomic_fetch_andnot(int i, atomic_t *v) · 3 unmodified lines | |||
| 498 | static __always_inline int | 485 | static __always_inline int |
| 499 | atomic_fetch_andnot_acquire(int i, atomic_t *v) | 486 | atomic_fetch_andnot_acquire(int i, atomic_t *v) |
| 500 | { | 487 | { |
| 501 | __atomic_check_write(v, sizeof(*v)); | 488 | instrument_atomic_write(v, sizeof(*v)); |
| 502 | return arch_atomic_fetch_andnot_acquire(i, v); | 489 | return arch_atomic_fetch_andnot_acquire(i, v); |
| 503 | } | 490 | } |
| 504 | #define atomic_fetch_andnot_acquire atomic_fetch_andnot_acquire | 491 | #define atomic_fetch_andnot_acquire atomic_fetch_andnot_acquire |
| @@ -508,7 +495,7 @@ atomic_fetch_andnot_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 508 | static __always_inline int | 495 | static __always_inline int |
| 509 | atomic_fetch_andnot_release(int i, atomic_t *v) | 496 | atomic_fetch_andnot_release(int i, atomic_t *v) |
| 510 | { | 497 | { |
| 511 | __atomic_check_write(v, sizeof(*v)); | 498 | instrument_atomic_write(v, sizeof(*v)); |
| 512 | return arch_atomic_fetch_andnot_release(i, v); | 499 | return arch_atomic_fetch_andnot_release(i, v); |
| 513 | } | 500 | } |
| 514 | #define atomic_fetch_andnot_release atomic_fetch_andnot_release | 501 | #define atomic_fetch_andnot_release atomic_fetch_andnot_release |
| @@ -518,7 +505,7 @@ atomic_fetch_andnot_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 518 | static __always_inline int | 505 | static __always_inline int |
| 519 | atomic_fetch_andnot_relaxed(int i, atomic_t *v) | 506 | atomic_fetch_andnot_relaxed(int i, atomic_t *v) |
| 520 | { | 507 | { |
| 521 | __atomic_check_write(v, sizeof(*v)); | 508 | instrument_atomic_write(v, sizeof(*v)); |
| 522 | return arch_atomic_fetch_andnot_relaxed(i, v); | 509 | return arch_atomic_fetch_andnot_relaxed(i, v); |
| 523 | } | 510 | } |
| 524 | #define atomic_fetch_andnot_relaxed atomic_fetch_andnot_relaxed | 511 | #define atomic_fetch_andnot_relaxed atomic_fetch_andnot_relaxed |
| @@ -527,7 +514,7 @@ atomic_fetch_andnot_relaxed(int i, atomic_t *v) · 2 unmodified lines | |||
| 527 | static __always_inline void | 514 | static __always_inline void |
| 528 | atomic_or(int i, atomic_t *v) | 515 | atomic_or(int i, atomic_t *v) |
| 529 | { | 516 | { |
| 530 | __atomic_check_write(v, sizeof(*v)); | 517 | instrument_atomic_write(v, sizeof(*v)); |
| 531 | arch_atomic_or(i, v); | 518 | arch_atomic_or(i, v); |
| 532 | } | 519 | } |
| 533 | #define atomic_or atomic_or | 520 | #define atomic_or atomic_or |
| @@ -536,7 +523,7 @@ atomic_or(int i, atomic_t *v) · 2 unmodified lines | |||
| 536 | static __always_inline int | 523 | static __always_inline int |
| 537 | atomic_fetch_or(int i, atomic_t *v) | 524 | atomic_fetch_or(int i, atomic_t *v) |
| 538 | { | 525 | { |
| 539 | __atomic_check_write(v, sizeof(*v)); | 526 | instrument_atomic_write(v, sizeof(*v)); |
| 540 | return arch_atomic_fetch_or(i, v); | 527 | return arch_atomic_fetch_or(i, v); |
| 541 | } | 528 | } |
| 542 | #define atomic_fetch_or atomic_fetch_or | 529 | #define atomic_fetch_or atomic_fetch_or |
| @@ -546,7 +533,7 @@ atomic_fetch_or(int i, atomic_t *v) · 3 unmodified lines | |||
| 546 | static __always_inline int | 533 | static __always_inline int |
| 547 | atomic_fetch_or_acquire(int i, atomic_t *v) | 534 | atomic_fetch_or_acquire(int i, atomic_t *v) |
| 548 | { | 535 | { |
| 549 | __atomic_check_write(v, sizeof(*v)); | 536 | instrument_atomic_write(v, sizeof(*v)); |
| 550 | return arch_atomic_fetch_or_acquire(i, v); | 537 | return arch_atomic_fetch_or_acquire(i, v); |
| 551 | } | 538 | } |
| 552 | #define atomic_fetch_or_acquire atomic_fetch_or_acquire | 539 | #define atomic_fetch_or_acquire atomic_fetch_or_acquire |
| @@ -556,7 +543,7 @@ atomic_fetch_or_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 556 | static __always_inline int | 543 | static __always_inline int |
| 557 | atomic_fetch_or_release(int i, atomic_t *v) | 544 | atomic_fetch_or_release(int i, atomic_t *v) |
| 558 | { | 545 | { |
| 559 | __atomic_check_write(v, sizeof(*v)); | 546 | instrument_atomic_write(v, sizeof(*v)); |
| 560 | return arch_atomic_fetch_or_release(i, v); | 547 | return arch_atomic_fetch_or_release(i, v); |
| 561 | } | 548 | } |
| 562 | #define atomic_fetch_or_release atomic_fetch_or_release | 549 | #define atomic_fetch_or_release atomic_fetch_or_release |
| @@ -566,7 +553,7 @@ atomic_fetch_or_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 566 | static __always_inline int | 553 | static __always_inline int |
| 567 | atomic_fetch_or_relaxed(int i, atomic_t *v) | 554 | atomic_fetch_or_relaxed(int i, atomic_t *v) |
| 568 | { | 555 | { |
| 569 | __atomic_check_write(v, sizeof(*v)); | 556 | instrument_atomic_write(v, sizeof(*v)); |
| 570 | return arch_atomic_fetch_or_relaxed(i, v); | 557 | return arch_atomic_fetch_or_relaxed(i, v); |
| 571 | } | 558 | } |
| 572 | #define atomic_fetch_or_relaxed atomic_fetch_or_relaxed | 559 | #define atomic_fetch_or_relaxed atomic_fetch_or_relaxed |
| @@ -575,7 +562,7 @@ atomic_fetch_or_relaxed(int i, atomic_t *v) · 2 unmodified lines | |||
| 575 | static __always_inline void | 562 | static __always_inline void |
| 576 | atomic_xor(int i, atomic_t *v) | 563 | atomic_xor(int i, atomic_t *v) |
| 577 | { | 564 | { |
| 578 | __atomic_check_write(v, sizeof(*v)); | 565 | instrument_atomic_write(v, sizeof(*v)); |
| 579 | arch_atomic_xor(i, v); | 566 | arch_atomic_xor(i, v); |
| 580 | } | 567 | } |
| 581 | #define atomic_xor atomic_xor | 568 | #define atomic_xor atomic_xor |
| @@ -584,7 +571,7 @@ atomic_xor(int i, atomic_t *v) · 2 unmodified lines | |||
| 584 | static __always_inline int | 571 | static __always_inline int |
| 585 | atomic_fetch_xor(int i, atomic_t *v) | 572 | atomic_fetch_xor(int i, atomic_t *v) |
| 586 | { | 573 | { |
| 587 | __atomic_check_write(v, sizeof(*v)); | 574 | instrument_atomic_write(v, sizeof(*v)); |
| 588 | return arch_atomic_fetch_xor(i, v); | 575 | return arch_atomic_fetch_xor(i, v); |
| 589 | } | 576 | } |
| 590 | #define atomic_fetch_xor atomic_fetch_xor | 577 | #define atomic_fetch_xor atomic_fetch_xor |
| @@ -594,7 +581,7 @@ atomic_fetch_xor(int i, atomic_t *v) · 3 unmodified lines | |||
| 594 | static __always_inline int | 581 | static __always_inline int |
| 595 | atomic_fetch_xor_acquire(int i, atomic_t *v) | 582 | atomic_fetch_xor_acquire(int i, atomic_t *v) |
| 596 | { | 583 | { |
| 597 | __atomic_check_write(v, sizeof(*v)); | 584 | instrument_atomic_write(v, sizeof(*v)); |
| 598 | return arch_atomic_fetch_xor_acquire(i, v); | 585 | return arch_atomic_fetch_xor_acquire(i, v); |
| 599 | } | 586 | } |
| 600 | #define atomic_fetch_xor_acquire atomic_fetch_xor_acquire | 587 | #define atomic_fetch_xor_acquire atomic_fetch_xor_acquire |
| @@ -604,7 +591,7 @@ atomic_fetch_xor_acquire(int i, atomic_t *v) · 3 unmodified lines | |||
| 604 | static __always_inline int | 591 | static __always_inline int |
| 605 | atomic_fetch_xor_release(int i, atomic_t *v) | 592 | atomic_fetch_xor_release(int i, atomic_t *v) |
| 606 | { | 593 | { |
| 607 | __atomic_check_write(v, sizeof(*v)); | 594 | instrument_atomic_write(v, sizeof(*v)); |
| 608 | return arch_atomic_fetch_xor_release(i, v); | 595 | return arch_atomic_fetch_xor_release(i, v); |
| 609 | } | 596 | } |
| 610 | #define atomic_fetch_xor_release atomic_fetch_xor_release | 597 | #define atomic_fetch_xor_release atomic_fetch_xor_release |
| @@ -614,7 +601,7 @@ atomic_fetch_xor_release(int i, atomic_t *v) · 3 unmodified lines | |||
| 614 | static __always_inline int | 601 | static __always_inline int |
| 615 | atomic_fetch_xor_relaxed(int i, atomic_t *v) | 602 | atomic_fetch_xor_relaxed(int i, atomic_t *v) |
| 616 | { | 603 | { |
| 617 | __atomic_check_write(v, sizeof(*v)); | 604 | instrument_atomic_write(v, sizeof(*v)); |
| 618 | return arch_atomic_fetch_xor_relaxed(i, v); | 605 | return arch_atomic_fetch_xor_relaxed(i, v); |
| 619 | } | 606 | } |
| 620 | #define atomic_fetch_xor_relaxed atomic_fetch_xor_relaxed | 607 | #define atomic_fetch_xor_relaxed atomic_fetch_xor_relaxed |
| @@ -624,7 +611,7 @@ atomic_fetch_xor_relaxed(int i, atomic_t *v) · 3 unmodified lines | |||
| 624 | static __always_inline int | 611 | static __always_inline int |
| 625 | atomic_xchg(atomic_t *v, int i) | 612 | atomic_xchg(atomic_t *v, int i) |
| 626 | { | 613 | { |
| 627 | __atomic_check_write(v, sizeof(*v)); | 614 | instrument_atomic_write(v, sizeof(*v)); |
| 628 | return arch_atomic_xchg(v, i); | 615 | return arch_atomic_xchg(v, i); |
| 629 | } | 616 | } |
| 630 | #define atomic_xchg atomic_xchg | 617 | #define atomic_xchg atomic_xchg |
| @@ -634,7 +621,7 @@ atomic_xchg(atomic_t *v, int i) · 3 unmodified lines | |||
| 634 | static __always_inline int | 621 | static __always_inline int |
| 635 | atomic_xchg_acquire(atomic_t *v, int i) | 622 | atomic_xchg_acquire(atomic_t *v, int i) |
| 636 | { | 623 | { |
| 637 | __atomic_check_write(v, sizeof(*v)); | 624 | instrument_atomic_write(v, sizeof(*v)); |
| 638 | return arch_atomic_xchg_acquire(v, i); | 625 | return arch_atomic_xchg_acquire(v, i); |
| 639 | } | 626 | } |
| 640 | #define atomic_xchg_acquire atomic_xchg_acquire | 627 | #define atomic_xchg_acquire atomic_xchg_acquire |
| @@ -644,7 +631,7 @@ atomic_xchg_acquire(atomic_t *v, int i) · 3 unmodified lines | |||
| 644 | static __always_inline int | 631 | static __always_inline int |
| 645 | atomic_xchg_release(atomic_t *v, int i) | 632 | atomic_xchg_release(atomic_t *v, int i) |
| 646 | { | 633 | { |
| 647 | __atomic_check_write(v, sizeof(*v)); | 634 | instrument_atomic_write(v, sizeof(*v)); |
| 648 | return arch_atomic_xchg_release(v, i); | 635 | return arch_atomic_xchg_release(v, i); |
| 649 | } | 636 | } |
| 650 | #define atomic_xchg_release atomic_xchg_release | 637 | #define atomic_xchg_release atomic_xchg_release |
| @@ -654,7 +641,7 @@ atomic_xchg_release(atomic_t *v, int i) · 3 unmodified lines | |||
| 654 | static __always_inline int | 641 | static __always_inline int |
| 655 | atomic_xchg_relaxed(atomic_t *v, int i) | 642 | atomic_xchg_relaxed(atomic_t *v, int i) |
| 656 | { | 643 | { |
| 657 | __atomic_check_write(v, sizeof(*v)); | 644 | instrument_atomic_write(v, sizeof(*v)); |
| 658 | return arch_atomic_xchg_relaxed(v, i); | 645 | return arch_atomic_xchg_relaxed(v, i); |
| 659 | } | 646 | } |
| 660 | #define atomic_xchg_relaxed atomic_xchg_relaxed | 647 | #define atomic_xchg_relaxed atomic_xchg_relaxed |
| @@ -664,7 +651,7 @@ atomic_xchg_relaxed(atomic_t *v, int i) · 3 unmodified lines | |||
| 664 | static __always_inline int | 651 | static __always_inline int |
| 665 | atomic_cmpxchg(atomic_t *v, int old, int new) | 652 | atomic_cmpxchg(atomic_t *v, int old, int new) |
| 666 | { | 653 | { |
| 667 | __atomic_check_write(v, sizeof(*v)); | 654 | instrument_atomic_write(v, sizeof(*v)); |
| 668 | return arch_atomic_cmpxchg(v, old, new); | 655 | return arch_atomic_cmpxchg(v, old, new); |
| 669 | } | 656 | } |
| 670 | #define atomic_cmpxchg atomic_cmpxchg | 657 | #define atomic_cmpxchg atomic_cmpxchg |
| @@ -674,7 +661,7 @@ atomic_cmpxchg(atomic_t *v, int old, int new) · 3 unmodified lines | |||
| 674 | static __always_inline int | 661 | static __always_inline int |
| 675 | atomic_cmpxchg_acquire(atomic_t *v, int old, int new) | 662 | atomic_cmpxchg_acquire(atomic_t *v, int old, int new) |
| 676 | { | 663 | { |
| 677 | __atomic_check_write(v, sizeof(*v)); | 664 | instrument_atomic_write(v, sizeof(*v)); |
| 678 | return arch_atomic_cmpxchg_acquire(v, old, new); | 665 | return arch_atomic_cmpxchg_acquire(v, old, new); |
| 679 | } | 666 | } |
| 680 | #define atomic_cmpxchg_acquire atomic_cmpxchg_acquire | 667 | #define atomic_cmpxchg_acquire atomic_cmpxchg_acquire |
| @@ -684,7 +671,7 @@ atomic_cmpxchg_acquire(atomic_t *v, int old, int new) · 3 unmodified lines | |||
| 684 | static __always_inline int | 671 | static __always_inline int |
| 685 | atomic_cmpxchg_release(atomic_t *v, int old, int new) | 672 | atomic_cmpxchg_release(atomic_t *v, int old, int new) |
| 686 | { | 673 | { |
| 687 | __atomic_check_write(v, sizeof(*v)); | 674 | instrument_atomic_write(v, sizeof(*v)); |
| 688 | return arch_atomic_cmpxchg_release(v, old, new); | 675 | return arch_atomic_cmpxchg_release(v, old, new); |
| 689 | } | 676 | } |
| 690 | #define atomic_cmpxchg_release atomic_cmpxchg_release | 677 | #define atomic_cmpxchg_release atomic_cmpxchg_release |
| @@ -694,7 +681,7 @@ atomic_cmpxchg_release(atomic_t *v, int old, int new) · 3 unmodified lines | |||
| 694 | static __always_inline int | 681 | static __always_inline int |
| 695 | atomic_cmpxchg_relaxed(atomic_t *v, int old, int new) | 682 | atomic_cmpxchg_relaxed(atomic_t *v, int old, int new) |
| 696 | { | 683 | { |
| 697 | __atomic_check_write(v, sizeof(*v)); | 684 | instrument_atomic_write(v, sizeof(*v)); |
| 698 | return arch_atomic_cmpxchg_relaxed(v, old, new); | 685 | return arch_atomic_cmpxchg_relaxed(v, old, new); |
| 699 | } | 686 | } |
| 700 | #define atomic_cmpxchg_relaxed atomic_cmpxchg_relaxed | 687 | #define atomic_cmpxchg_relaxed atomic_cmpxchg_relaxed |
| @@ -704,8 +691,8 @@ atomic_cmpxchg_relaxed(atomic_t *v, int old, int new) · 3 unmodified lines | |||
| 704 | static __always_inline bool | 691 | static __always_inline bool |
| 705 | atomic_try_cmpxchg(atomic_t *v, int *old, int new) | 692 | atomic_try_cmpxchg(atomic_t *v, int *old, int new) |
| 706 | { | 693 | { |
| 707 | __atomic_check_write(v, sizeof(*v)); | 694 | instrument_atomic_write(v, sizeof(*v)); |
| 708 | __atomic_check_write(old, sizeof(*old)); | 695 | instrument_atomic_write(old, sizeof(*old)); |
| 709 | return arch_atomic_try_cmpxchg(v, old, new); | 696 | return arch_atomic_try_cmpxchg(v, old, new); |
| 710 | } | 697 | } |
| 711 | #define atomic_try_cmpxchg atomic_try_cmpxchg | 698 | #define atomic_try_cmpxchg atomic_try_cmpxchg |
| @@ -715,8 +702,8 @@ atomic_try_cmpxchg(atomic_t *v, int *old, int new) · 3 unmodified lines | |||
| 715 | static __always_inline bool | 702 | static __always_inline bool |
| 716 | atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new) | 703 | atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new) |
| 717 | { | 704 | { |
| 718 | __atomic_check_write(v, sizeof(*v)); | 705 | instrument_atomic_write(v, sizeof(*v)); |
| 719 | __atomic_check_write(old, sizeof(*old)); | 706 | instrument_atomic_write(old, sizeof(*old)); |
| 720 | return arch_atomic_try_cmpxchg_acquire(v, old, new); | 707 | return arch_atomic_try_cmpxchg_acquire(v, old, new); |
| 721 | } | 708 | } |
| 722 | #define atomic_try_cmpxchg_acquire atomic_try_cmpxchg_acquire | 709 | #define atomic_try_cmpxchg_acquire atomic_try_cmpxchg_acquire |
| @@ -726,8 +713,8 @@ atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new) · 3 unmodified lines | |||
| 726 | static __always_inline bool | 713 | static __always_inline bool |
| 727 | atomic_try_cmpxchg_release(atomic_t *v, int *old, int new) | 714 | atomic_try_cmpxchg_release(atomic_t *v, int *old, int new) |
| 728 | { | 715 | { |
| 729 | __atomic_check_write(v, sizeof(*v)); | 716 | instrument_atomic_write(v, sizeof(*v)); |
| 730 | __atomic_check_write(old, sizeof(*old)); | 717 | instrument_atomic_write(old, sizeof(*old)); |
| 731 | return arch_atomic_try_cmpxchg_release(v, old, new); | 718 | return arch_atomic_try_cmpxchg_release(v, old, new); |
| 732 | } | 719 | } |
| 733 | #define atomic_try_cmpxchg_release atomic_try_cmpxchg_release | 720 | #define atomic_try_cmpxchg_release atomic_try_cmpxchg_release |
| @@ -737,8 +724,8 @@ atomic_try_cmpxchg_release(atomic_t *v, int *old, int new) · 3 unmodified lines | |||
| 737 | static __always_inline bool | 724 | static __always_inline bool |
| 738 | atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new) | 725 | atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new) |
| 739 | { | 726 | { |
| 740 | __atomic_check_write(v, sizeof(*v)); | 727 | instrument_atomic_write(v, sizeof(*v)); |
| 741 | __atomic_check_write(old, sizeof(*old)); | 728 | instrument_atomic_write(old, sizeof(*old)); |
| 742 | return arch_atomic_try_cmpxchg_relaxed(v, old, new); | 729 | return arch_atomic_try_cmpxchg_relaxed(v, old, new); |
| 743 | } | 730 | } |
| 744 | #define atomic_try_cmpxchg_relaxed atomic_try_cmpxchg_relaxed | 731 | #define atomic_try_cmpxchg_relaxed atomic_try_cmpxchg_relaxed |
| @@ -748,7 +735,7 @@ atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new) · 3 unmodified lines | |||
| 748 | static __always_inline bool | 735 | static __always_inline bool |
| 749 | atomic_sub_and_test(int i, atomic_t *v) | 736 | atomic_sub_and_test(int i, atomic_t *v) |
| 750 | { | 737 | { |
| 751 | __atomic_check_write(v, sizeof(*v)); | 738 | instrument_atomic_write(v, sizeof(*v)); |
| 752 | return arch_atomic_sub_and_test(i, v); | 739 | return arch_atomic_sub_and_test(i, v); |
| 753 | } | 740 | } |
| 754 | #define atomic_sub_and_test atomic_sub_and_test | 741 | #define atomic_sub_and_test atomic_sub_and_test |
| @@ -758,7 +745,7 @@ atomic_sub_and_test(int i, atomic_t *v) · 3 unmodified lines | |||
| 758 | static __always_inline bool | 745 | static __always_inline bool |
| 759 | atomic_dec_and_test(atomic_t *v) | 746 | atomic_dec_and_test(atomic_t *v) |
| 760 | { | 747 | { |
| 761 | __atomic_check_write(v, sizeof(*v)); | 748 | instrument_atomic_write(v, sizeof(*v)); |
| 762 | return arch_atomic_dec_and_test(v); | 749 | return arch_atomic_dec_and_test(v); |
| 763 | } | 750 | } |
| 764 | #define atomic_dec_and_test atomic_dec_and_test | 751 | #define atomic_dec_and_test atomic_dec_and_test |
| @@ -768,7 +755,7 @@ atomic_dec_and_test(atomic_t *v) · 3 unmodified lines | |||
| 768 | static __always_inline bool | 755 | static __always_inline bool |
| 769 | atomic_inc_and_test(atomic_t *v) | 756 | atomic_inc_and_test(atomic_t *v) |
| 770 | { | 757 | { |
| 771 | __atomic_check_write(v, sizeof(*v)); | 758 | instrument_atomic_write(v, sizeof(*v)); |
| 772 | return arch_atomic_inc_and_test(v); | 759 | return arch_atomic_inc_and_test(v); |
| 773 | } | 760 | } |
| 774 | #define atomic_inc_and_test atomic_inc_and_test | 761 | #define atomic_inc_and_test atomic_inc_and_test |
| @@ -778,7 +765,7 @@ atomic_inc_and_test(atomic_t *v) · 3 unmodified lines | |||
| 778 | static __always_inline bool | 765 | static __always_inline bool |
| 779 | atomic_add_negative(int i, atomic_t *v) | 766 | atomic_add_negative(int i, atomic_t *v) |
| 780 | { | 767 | { |
| 781 | __atomic_check_write(v, sizeof(*v)); | 768 | instrument_atomic_write(v, sizeof(*v)); |
| 782 | return arch_atomic_add_negative(i, v); | 769 | return arch_atomic_add_negative(i, v); |
| 783 | } | 770 | } |
| 784 | #define atomic_add_negative atomic_add_negative | 771 | #define atomic_add_negative atomic_add_negative |
| @@ -788,7 +775,7 @@ atomic_add_negative(int i, atomic_t *v) · 3 unmodified lines | |||
| 788 | static __always_inline int | 775 | static __always_inline int |
| 789 | atomic_fetch_add_unless(atomic_t *v, int a, int u) | 776 | atomic_fetch_add_unless(atomic_t *v, int a, int u) |
| 790 | { | 777 | { |
| 791 | __atomic_check_write(v, sizeof(*v)); | 778 | instrument_atomic_write(v, sizeof(*v)); |
| 792 | return arch_atomic_fetch_add_unless(v, a, u); | 779 | return arch_atomic_fetch_add_unless(v, a, u); |
| 793 | } | 780 | } |
| 794 | #define atomic_fetch_add_unless atomic_fetch_add_unless | 781 | #define atomic_fetch_add_unless atomic_fetch_add_unless |
| @@ -798,7 +785,7 @@ atomic_fetch_add_unless(atomic_t *v, int a, int u) · 3 unmodified lines | |||
| 798 | static __always_inline bool | 785 | static __always_inline bool |
| 799 | atomic_add_unless(atomic_t *v, int a, int u) | 786 | atomic_add_unless(atomic_t *v, int a, int u) |
| 800 | { | 787 | { |
| 801 | __atomic_check_write(v, sizeof(*v)); | 788 | instrument_atomic_write(v, sizeof(*v)); |
| 802 | return arch_atomic_add_unless(v, a, u); | 789 | return arch_atomic_add_unless(v, a, u); |
| 803 | } | 790 | } |
| 804 | #define atomic_add_unless atomic_add_unless | 791 | #define atomic_add_unless atomic_add_unless |
| @@ -808,7 +795,7 @@ atomic_add_unless(atomic_t *v, int a, int u) · 3 unmodified lines | |||
| 808 | static __always_inline bool | 795 | static __always_inline bool |
| 809 | atomic_inc_not_zero(atomic_t *v) | 796 | atomic_inc_not_zero(atomic_t *v) |
| 810 | { | 797 | { |
| 811 | __atomic_check_write(v, sizeof(*v)); | 798 | instrument_atomic_write(v, sizeof(*v)); |
| 812 | return arch_atomic_inc_not_zero(v); | 799 | return arch_atomic_inc_not_zero(v); |
| 813 | } | 800 | } |
| 814 | #define atomic_inc_not_zero atomic_inc_not_zero | 801 | #define atomic_inc_not_zero atomic_inc_not_zero |
| @@ -818,7 +805,7 @@ atomic_inc_not_zero(atomic_t *v) · 3 unmodified lines | |||
| 818 | static __always_inline bool | 805 | static __always_inline bool |
| 819 | atomic_inc_unless_negative(atomic_t *v) | 806 | atomic_inc_unless_negative(atomic_t *v) |
| 820 | { | 807 | { |
| 821 | __atomic_check_write(v, sizeof(*v)); | 808 | instrument_atomic_write(v, sizeof(*v)); |
| 822 | return arch_atomic_inc_unless_negative(v); | 809 | return arch_atomic_inc_unless_negative(v); |
| 823 | } | 810 | } |
| 824 | #define atomic_inc_unless_negative atomic_inc_unless_negative | 811 | #define atomic_inc_unless_negative atomic_inc_unless_negative |
| @@ -828,7 +815,7 @@ atomic_inc_unless_negative(atomic_t *v) · 3 unmodified lines | |||
| 828 | static __always_inline bool | 815 | static __always_inline bool |
| 829 | atomic_dec_unless_positive(atomic_t *v) | 816 | atomic_dec_unless_positive(atomic_t *v) |
| 830 | { | 817 | { |
| 831 | __atomic_check_write(v, sizeof(*v)); | 818 | instrument_atomic_write(v, sizeof(*v)); |
| 832 | return arch_atomic_dec_unless_positive(v); | 819 | return arch_atomic_dec_unless_positive(v); |
| 833 | } | 820 | } |
| 834 | #define atomic_dec_unless_positive atomic_dec_unless_positive | 821 | #define atomic_dec_unless_positive atomic_dec_unless_positive |
| @@ -838,7 +825,7 @@ atomic_dec_unless_positive(atomic_t *v) · 3 unmodified lines | |||
| 838 | static __always_inline int | 825 | static __always_inline int |
| 839 | atomic_dec_if_positive(atomic_t *v) | 826 | atomic_dec_if_positive(atomic_t *v) |
| 840 | { | 827 | { |
| 841 | __atomic_check_write(v, sizeof(*v)); | 828 | instrument_atomic_write(v, sizeof(*v)); |
| 842 | return arch_atomic_dec_if_positive(v); | 829 | return arch_atomic_dec_if_positive(v); |
| 843 | } | 830 | } |
| 844 | #define atomic_dec_if_positive atomic_dec_if_positive | 831 | #define atomic_dec_if_positive atomic_dec_if_positive |
| @@ -847,7 +834,7 @@ atomic_dec_if_positive(atomic_t *v) · 2 unmodified lines | |||
| 847 | static __always_inline s64 | 834 | static __always_inline s64 |
| 848 | atomic64_read(const atomic64_t *v) | 835 | atomic64_read(const atomic64_t *v) |
| 849 | { | 836 | { |
| 850 | __atomic_check_read(v, sizeof(*v)); | 837 | instrument_atomic_read(v, sizeof(*v)); |
| 851 | return arch_atomic64_read(v); | 838 | return arch_atomic64_read(v); |
| 852 | } | 839 | } |
| 853 | #define atomic64_read atomic64_read | 840 | #define atomic64_read atomic64_read |
| @@ -856,7 +843,7 @@ atomic64_read(const atomic64_t *v) · 2 unmodified lines | |||
| 856 | static __always_inline s64 | 843 | static __always_inline s64 |
| 857 | atomic64_read_acquire(const atomic64_t *v) | 844 | atomic64_read_acquire(const atomic64_t *v) |
| 858 | { | 845 | { |
| 859 | __atomic_check_read(v, sizeof(*v)); | 846 | instrument_atomic_read(v, sizeof(*v)); |
| 860 | return arch_atomic64_read_acquire(v); | 847 | return arch_atomic64_read_acquire(v); |
| 861 | } | 848 | } |
| 862 | #define atomic64_read_acquire atomic64_read_acquire | 849 | #define atomic64_read_acquire atomic64_read_acquire |
| @@ -865,7 +852,7 @@ atomic64_read_acquire(const atomic64_t *v) · 2 unmodified lines | |||
| 865 | static __always_inline void | 852 | static __always_inline void |
| 866 | atomic64_set(atomic64_t *v, s64 i) | 853 | atomic64_set(atomic64_t *v, s64 i) |
| 867 | { | 854 | { |
| 868 | __atomic_check_write(v, sizeof(*v)); | 855 | instrument_atomic_write(v, sizeof(*v)); |
| 869 | arch_atomic64_set(v, i); | 856 | arch_atomic64_set(v, i); |
| 870 | } | 857 | } |
| 871 | #define atomic64_set atomic64_set | 858 | #define atomic64_set atomic64_set |
| @@ -874,7 +861,7 @@ atomic64_set(atomic64_t *v, s64 i) · 2 unmodified lines | |||
| 874 | static __always_inline void | 861 | static __always_inline void |
| 875 | atomic64_set_release(atomic64_t *v, s64 i) | 862 | atomic64_set_release(atomic64_t *v, s64 i) |
| 876 | { | 863 | { |
| 877 | __atomic_check_write(v, sizeof(*v)); | 864 | instrument_atomic_write(v, sizeof(*v)); |
| 878 | arch_atomic64_set_release(v, i); | 865 | arch_atomic64_set_release(v, i); |
| 879 | } | 866 | } |
| 880 | #define atomic64_set_release atomic64_set_release | 867 | #define atomic64_set_release atomic64_set_release |
| @@ -883,7 +870,7 @@ atomic64_set_release(atomic64_t *v, s64 i) · 2 unmodified lines | |||
| 883 | static __always_inline void | 870 | static __always_inline void |
| 884 | atomic64_add(s64 i, atomic64_t *v) | 871 | atomic64_add(s64 i, atomic64_t *v) |
| 885 | { | 872 | { |
| 886 | __atomic_check_write(v, sizeof(*v)); | 873 | instrument_atomic_write(v, sizeof(*v)); |
| 887 | arch_atomic64_add(i, v); | 874 | arch_atomic64_add(i, v); |
| 888 | } | 875 | } |
| 889 | #define atomic64_add atomic64_add | 876 | #define atomic64_add atomic64_add |
| @@ -892,7 +879,7 @@ atomic64_add(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 892 | static __always_inline s64 | 879 | static __always_inline s64 |
| 893 | atomic64_add_return(s64 i, atomic64_t *v) | 880 | atomic64_add_return(s64 i, atomic64_t *v) |
| 894 | { | 881 | { |
| 895 | __atomic_check_write(v, sizeof(*v)); | 882 | instrument_atomic_write(v, sizeof(*v)); |
| 896 | return arch_atomic64_add_return(i, v); | 883 | return arch_atomic64_add_return(i, v); |
| 897 | } | 884 | } |
| 898 | #define atomic64_add_return atomic64_add_return | 885 | #define atomic64_add_return atomic64_add_return |
| @@ -902,7 +889,7 @@ atomic64_add_return(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 902 | static __always_inline s64 | 889 | static __always_inline s64 |
| 903 | atomic64_add_return_acquire(s64 i, atomic64_t *v) | 890 | atomic64_add_return_acquire(s64 i, atomic64_t *v) |
| 904 | { | 891 | { |
| 905 | __atomic_check_write(v, sizeof(*v)); | 892 | instrument_atomic_write(v, sizeof(*v)); |
| 906 | return arch_atomic64_add_return_acquire(i, v); | 893 | return arch_atomic64_add_return_acquire(i, v); |
| 907 | } | 894 | } |
| 908 | #define atomic64_add_return_acquire atomic64_add_return_acquire | 895 | #define atomic64_add_return_acquire atomic64_add_return_acquire |
| @@ -912,7 +899,7 @@ atomic64_add_return_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 912 | static __always_inline s64 | 899 | static __always_inline s64 |
| 913 | atomic64_add_return_release(s64 i, atomic64_t *v) | 900 | atomic64_add_return_release(s64 i, atomic64_t *v) |
| 914 | { | 901 | { |
| 915 | __atomic_check_write(v, sizeof(*v)); | 902 | instrument_atomic_write(v, sizeof(*v)); |
| 916 | return arch_atomic64_add_return_release(i, v); | 903 | return arch_atomic64_add_return_release(i, v); |
| 917 | } | 904 | } |
| 918 | #define atomic64_add_return_release atomic64_add_return_release | 905 | #define atomic64_add_return_release atomic64_add_return_release |
| @@ -922,7 +909,7 @@ atomic64_add_return_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 922 | static __always_inline s64 | 909 | static __always_inline s64 |
| 923 | atomic64_add_return_relaxed(s64 i, atomic64_t *v) | 910 | atomic64_add_return_relaxed(s64 i, atomic64_t *v) |
| 924 | { | 911 | { |
| 925 | __atomic_check_write(v, sizeof(*v)); | 912 | instrument_atomic_write(v, sizeof(*v)); |
| 926 | return arch_atomic64_add_return_relaxed(i, v); | 913 | return arch_atomic64_add_return_relaxed(i, v); |
| 927 | } | 914 | } |
| 928 | #define atomic64_add_return_relaxed atomic64_add_return_relaxed | 915 | #define atomic64_add_return_relaxed atomic64_add_return_relaxed |
| @@ -932,7 +919,7 @@ atomic64_add_return_relaxed(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 932 | static __always_inline s64 | 919 | static __always_inline s64 |
| 933 | atomic64_fetch_add(s64 i, atomic64_t *v) | 920 | atomic64_fetch_add(s64 i, atomic64_t *v) |
| 934 | { | 921 | { |
| 935 | __atomic_check_write(v, sizeof(*v)); | 922 | instrument_atomic_write(v, sizeof(*v)); |
| 936 | return arch_atomic64_fetch_add(i, v); | 923 | return arch_atomic64_fetch_add(i, v); |
| 937 | } | 924 | } |
| 938 | #define atomic64_fetch_add atomic64_fetch_add | 925 | #define atomic64_fetch_add atomic64_fetch_add |
| @@ -942,7 +929,7 @@ atomic64_fetch_add(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 942 | static __always_inline s64 | 929 | static __always_inline s64 |
| 943 | atomic64_fetch_add_acquire(s64 i, atomic64_t *v) | 930 | atomic64_fetch_add_acquire(s64 i, atomic64_t *v) |
| 944 | { | 931 | { |
| 945 | __atomic_check_write(v, sizeof(*v)); | 932 | instrument_atomic_write(v, sizeof(*v)); |
| 946 | return arch_atomic64_fetch_add_acquire(i, v); | 933 | return arch_atomic64_fetch_add_acquire(i, v); |
| 947 | } | 934 | } |
| 948 | #define atomic64_fetch_add_acquire atomic64_fetch_add_acquire | 935 | #define atomic64_fetch_add_acquire atomic64_fetch_add_acquire |
| @@ -952,7 +939,7 @@ atomic64_fetch_add_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 952 | static __always_inline s64 | 939 | static __always_inline s64 |
| 953 | atomic64_fetch_add_release(s64 i, atomic64_t *v) | 940 | atomic64_fetch_add_release(s64 i, atomic64_t *v) |
| 954 | { | 941 | { |
| 955 | __atomic_check_write(v, sizeof(*v)); | 942 | instrument_atomic_write(v, sizeof(*v)); |
| 956 | return arch_atomic64_fetch_add_release(i, v); | 943 | return arch_atomic64_fetch_add_release(i, v); |
| 957 | } | 944 | } |
| 958 | #define atomic64_fetch_add_release atomic64_fetch_add_release | 945 | #define atomic64_fetch_add_release atomic64_fetch_add_release |
| @@ -962,7 +949,7 @@ atomic64_fetch_add_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 962 | static __always_inline s64 | 949 | static __always_inline s64 |
| 963 | atomic64_fetch_add_relaxed(s64 i, atomic64_t *v) | 950 | atomic64_fetch_add_relaxed(s64 i, atomic64_t *v) |
| 964 | { | 951 | { |
| 965 | __atomic_check_write(v, sizeof(*v)); | 952 | instrument_atomic_write(v, sizeof(*v)); |
| 966 | return arch_atomic64_fetch_add_relaxed(i, v); | 953 | return arch_atomic64_fetch_add_relaxed(i, v); |
| 967 | } | 954 | } |
| 968 | #define atomic64_fetch_add_relaxed atomic64_fetch_add_relaxed | 955 | #define atomic64_fetch_add_relaxed atomic64_fetch_add_relaxed |
| @@ -971,7 +958,7 @@ atomic64_fetch_add_relaxed(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 971 | static __always_inline void | 958 | static __always_inline void |
| 972 | atomic64_sub(s64 i, atomic64_t *v) | 959 | atomic64_sub(s64 i, atomic64_t *v) |
| 973 | { | 960 | { |
| 974 | __atomic_check_write(v, sizeof(*v)); | 961 | instrument_atomic_write(v, sizeof(*v)); |
| 975 | arch_atomic64_sub(i, v); | 962 | arch_atomic64_sub(i, v); |
| 976 | } | 963 | } |
| 977 | #define atomic64_sub atomic64_sub | 964 | #define atomic64_sub atomic64_sub |
| @@ -980,7 +967,7 @@ atomic64_sub(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 980 | static __always_inline s64 | 967 | static __always_inline s64 |
| 981 | atomic64_sub_return(s64 i, atomic64_t *v) | 968 | atomic64_sub_return(s64 i, atomic64_t *v) |
| 982 | { | 969 | { |
| 983 | __atomic_check_write(v, sizeof(*v)); | 970 | instrument_atomic_write(v, sizeof(*v)); |
| 984 | return arch_atomic64_sub_return(i, v); | 971 | return arch_atomic64_sub_return(i, v); |
| 985 | } | 972 | } |
| 986 | #define atomic64_sub_return atomic64_sub_return | 973 | #define atomic64_sub_return atomic64_sub_return |
| @@ -990,7 +977,7 @@ atomic64_sub_return(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 990 | static __always_inline s64 | 977 | static __always_inline s64 |
| 991 | atomic64_sub_return_acquire(s64 i, atomic64_t *v) | 978 | atomic64_sub_return_acquire(s64 i, atomic64_t *v) |
| 992 | { | 979 | { |
| 993 | __atomic_check_write(v, sizeof(*v)); | 980 | instrument_atomic_write(v, sizeof(*v)); |
| 994 | return arch_atomic64_sub_return_acquire(i, v); | 981 | return arch_atomic64_sub_return_acquire(i, v); |
| 995 | } | 982 | } |
| 996 | #define atomic64_sub_return_acquire atomic64_sub_return_acquire | 983 | #define atomic64_sub_return_acquire atomic64_sub_return_acquire |
| @@ -1000,7 +987,7 @@ atomic64_sub_return_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1000 | static __always_inline s64 | 987 | static __always_inline s64 |
| 1001 | atomic64_sub_return_release(s64 i, atomic64_t *v) | 988 | atomic64_sub_return_release(s64 i, atomic64_t *v) |
| 1002 | { | 989 | { |
| 1003 | __atomic_check_write(v, sizeof(*v)); | 990 | instrument_atomic_write(v, sizeof(*v)); |
| 1004 | return arch_atomic64_sub_return_release(i, v); | 991 | return arch_atomic64_sub_return_release(i, v); |
| 1005 | } | 992 | } |
| 1006 | #define atomic64_sub_return_release atomic64_sub_return_release | 993 | #define atomic64_sub_return_release atomic64_sub_return_release |
| @@ -1010,7 +997,7 @@ atomic64_sub_return_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1010 | static __always_inline s64 | 997 | static __always_inline s64 |
| 1011 | atomic64_sub_return_relaxed(s64 i, atomic64_t *v) | 998 | atomic64_sub_return_relaxed(s64 i, atomic64_t *v) |
| 1012 | { | 999 | { |
| 1013 | __atomic_check_write(v, sizeof(*v)); | 1000 | instrument_atomic_write(v, sizeof(*v)); |
| 1014 | return arch_atomic64_sub_return_relaxed(i, v); | 1001 | return arch_atomic64_sub_return_relaxed(i, v); |
| 1015 | } | 1002 | } |
| 1016 | #define atomic64_sub_return_relaxed atomic64_sub_return_relaxed | 1003 | #define atomic64_sub_return_relaxed atomic64_sub_return_relaxed |
| @@ -1020,7 +1007,7 @@ atomic64_sub_return_relaxed(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1020 | static __always_inline s64 | 1007 | static __always_inline s64 |
| 1021 | atomic64_fetch_sub(s64 i, atomic64_t *v) | 1008 | atomic64_fetch_sub(s64 i, atomic64_t *v) |
| 1022 | { | 1009 | { |
| 1023 | __atomic_check_write(v, sizeof(*v)); | 1010 | instrument_atomic_write(v, sizeof(*v)); |
| 1024 | return arch_atomic64_fetch_sub(i, v); | 1011 | return arch_atomic64_fetch_sub(i, v); |
| 1025 | } | 1012 | } |
| 1026 | #define atomic64_fetch_sub atomic64_fetch_sub | 1013 | #define atomic64_fetch_sub atomic64_fetch_sub |
| @@ -1030,7 +1017,7 @@ atomic64_fetch_sub(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1030 | static __always_inline s64 | 1017 | static __always_inline s64 |
| 1031 | atomic64_fetch_sub_acquire(s64 i, atomic64_t *v) | 1018 | atomic64_fetch_sub_acquire(s64 i, atomic64_t *v) |
| 1032 | { | 1019 | { |
| 1033 | __atomic_check_write(v, sizeof(*v)); | 1020 | instrument_atomic_write(v, sizeof(*v)); |
| 1034 | return arch_atomic64_fetch_sub_acquire(i, v); | 1021 | return arch_atomic64_fetch_sub_acquire(i, v); |
| 1035 | } | 1022 | } |
| 1036 | #define atomic64_fetch_sub_acquire atomic64_fetch_sub_acquire | 1023 | #define atomic64_fetch_sub_acquire atomic64_fetch_sub_acquire |
| @@ -1040,7 +1027,7 @@ atomic64_fetch_sub_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1040 | static __always_inline s64 | 1027 | static __always_inline s64 |
| 1041 | atomic64_fetch_sub_release(s64 i, atomic64_t *v) | 1028 | atomic64_fetch_sub_release(s64 i, atomic64_t *v) |
| 1042 | { | 1029 | { |
| 1043 | __atomic_check_write(v, sizeof(*v)); | 1030 | instrument_atomic_write(v, sizeof(*v)); |
| 1044 | return arch_atomic64_fetch_sub_release(i, v); | 1031 | return arch_atomic64_fetch_sub_release(i, v); |
| 1045 | } | 1032 | } |
| 1046 | #define atomic64_fetch_sub_release atomic64_fetch_sub_release | 1033 | #define atomic64_fetch_sub_release atomic64_fetch_sub_release |
| @@ -1050,7 +1037,7 @@ atomic64_fetch_sub_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1050 | static __always_inline s64 | 1037 | static __always_inline s64 |
| 1051 | atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v) | 1038 | atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v) |
| 1052 | { | 1039 | { |
| 1053 | __atomic_check_write(v, sizeof(*v)); | 1040 | instrument_atomic_write(v, sizeof(*v)); |
| 1054 | return arch_atomic64_fetch_sub_relaxed(i, v); | 1041 | return arch_atomic64_fetch_sub_relaxed(i, v); |
| 1055 | } | 1042 | } |
| 1056 | #define atomic64_fetch_sub_relaxed atomic64_fetch_sub_relaxed | 1043 | #define atomic64_fetch_sub_relaxed atomic64_fetch_sub_relaxed |
| @@ -1060,7 +1047,7 @@ atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1060 | static __always_inline void | 1047 | static __always_inline void |
| 1061 | atomic64_inc(atomic64_t *v) | 1048 | atomic64_inc(atomic64_t *v) |
| 1062 | { | 1049 | { |
| 1063 | __atomic_check_write(v, sizeof(*v)); | 1050 | instrument_atomic_write(v, sizeof(*v)); |
| 1064 | arch_atomic64_inc(v); | 1051 | arch_atomic64_inc(v); |
| 1065 | } | 1052 | } |
| 1066 | #define atomic64_inc atomic64_inc | 1053 | #define atomic64_inc atomic64_inc |
| @@ -1070,7 +1057,7 @@ atomic64_inc(atomic64_t *v) · 3 unmodified lines | |||
| 1070 | static __always_inline s64 | 1057 | static __always_inline s64 |
| 1071 | atomic64_inc_return(atomic64_t *v) | 1058 | atomic64_inc_return(atomic64_t *v) |
| 1072 | { | 1059 | { |
| 1073 | __atomic_check_write(v, sizeof(*v)); | 1060 | instrument_atomic_write(v, sizeof(*v)); |
| 1074 | return arch_atomic64_inc_return(v); | 1061 | return arch_atomic64_inc_return(v); |
| 1075 | } | 1062 | } |
| 1076 | #define atomic64_inc_return atomic64_inc_return | 1063 | #define atomic64_inc_return atomic64_inc_return |
| @@ -1080,7 +1067,7 @@ atomic64_inc_return(atomic64_t *v) · 3 unmodified lines | |||
| 1080 | static __always_inline s64 | 1067 | static __always_inline s64 |
| 1081 | atomic64_inc_return_acquire(atomic64_t *v) | 1068 | atomic64_inc_return_acquire(atomic64_t *v) |
| 1082 | { | 1069 | { |
| 1083 | __atomic_check_write(v, sizeof(*v)); | 1070 | instrument_atomic_write(v, sizeof(*v)); |
| 1084 | return arch_atomic64_inc_return_acquire(v); | 1071 | return arch_atomic64_inc_return_acquire(v); |
| 1085 | } | 1072 | } |
| 1086 | #define atomic64_inc_return_acquire atomic64_inc_return_acquire | 1073 | #define atomic64_inc_return_acquire atomic64_inc_return_acquire |
| @@ -1090,7 +1077,7 @@ atomic64_inc_return_acquire(atomic64_t *v) · 3 unmodified lines | |||
| 1090 | static __always_inline s64 | 1077 | static __always_inline s64 |
| 1091 | atomic64_inc_return_release(atomic64_t *v) | 1078 | atomic64_inc_return_release(atomic64_t *v) |
| 1092 | { | 1079 | { |
| 1093 | __atomic_check_write(v, sizeof(*v)); | 1080 | instrument_atomic_write(v, sizeof(*v)); |
| 1094 | return arch_atomic64_inc_return_release(v); | 1081 | return arch_atomic64_inc_return_release(v); |
| 1095 | } | 1082 | } |
| 1096 | #define atomic64_inc_return_release atomic64_inc_return_release | 1083 | #define atomic64_inc_return_release atomic64_inc_return_release |
| @@ -1100,7 +1087,7 @@ atomic64_inc_return_release(atomic64_t *v) · 3 unmodified lines | |||
| 1100 | static __always_inline s64 | 1087 | static __always_inline s64 |
| 1101 | atomic64_inc_return_relaxed(atomic64_t *v) | 1088 | atomic64_inc_return_relaxed(atomic64_t *v) |
| 1102 | { | 1089 | { |
| 1103 | __atomic_check_write(v, sizeof(*v)); | 1090 | instrument_atomic_write(v, sizeof(*v)); |
| 1104 | return arch_atomic64_inc_return_relaxed(v); | 1091 | return arch_atomic64_inc_return_relaxed(v); |
| 1105 | } | 1092 | } |
| 1106 | #define atomic64_inc_return_relaxed atomic64_inc_return_relaxed | 1093 | #define atomic64_inc_return_relaxed atomic64_inc_return_relaxed |
| @@ -1110,7 +1097,7 @@ atomic64_inc_return_relaxed(atomic64_t *v) · 3 unmodified lines | |||
| 1110 | static __always_inline s64 | 1097 | static __always_inline s64 |
| 1111 | atomic64_fetch_inc(atomic64_t *v) | 1098 | atomic64_fetch_inc(atomic64_t *v) |
| 1112 | { | 1099 | { |
| 1113 | __atomic_check_write(v, sizeof(*v)); | 1100 | instrument_atomic_write(v, sizeof(*v)); |
| 1114 | return arch_atomic64_fetch_inc(v); | 1101 | return arch_atomic64_fetch_inc(v); |
| 1115 | } | 1102 | } |
| 1116 | #define atomic64_fetch_inc atomic64_fetch_inc | 1103 | #define atomic64_fetch_inc atomic64_fetch_inc |
| @@ -1120,7 +1107,7 @@ atomic64_fetch_inc(atomic64_t *v) · 3 unmodified lines | |||
| 1120 | static __always_inline s64 | 1107 | static __always_inline s64 |
| 1121 | atomic64_fetch_inc_acquire(atomic64_t *v) | 1108 | atomic64_fetch_inc_acquire(atomic64_t *v) |
| 1122 | { | 1109 | { |
| 1123 | __atomic_check_write(v, sizeof(*v)); | 1110 | instrument_atomic_write(v, sizeof(*v)); |
| 1124 | return arch_atomic64_fetch_inc_acquire(v); | 1111 | return arch_atomic64_fetch_inc_acquire(v); |
| 1125 | } | 1112 | } |
| 1126 | #define atomic64_fetch_inc_acquire atomic64_fetch_inc_acquire | 1113 | #define atomic64_fetch_inc_acquire atomic64_fetch_inc_acquire |
| @@ -1130,7 +1117,7 @@ atomic64_fetch_inc_acquire(atomic64_t *v) · 3 unmodified lines | |||
| 1130 | static __always_inline s64 | 1117 | static __always_inline s64 |
| 1131 | atomic64_fetch_inc_release(atomic64_t *v) | 1118 | atomic64_fetch_inc_release(atomic64_t *v) |
| 1132 | { | 1119 | { |
| 1133 | __atomic_check_write(v, sizeof(*v)); | 1120 | instrument_atomic_write(v, sizeof(*v)); |
| 1134 | return arch_atomic64_fetch_inc_release(v); | 1121 | return arch_atomic64_fetch_inc_release(v); |
| 1135 | } | 1122 | } |
| 1136 | #define atomic64_fetch_inc_release atomic64_fetch_inc_release | 1123 | #define atomic64_fetch_inc_release atomic64_fetch_inc_release |
| @@ -1140,7 +1127,7 @@ atomic64_fetch_inc_release(atomic64_t *v) · 3 unmodified lines | |||
| 1140 | static __always_inline s64 | 1127 | static __always_inline s64 |
| 1141 | atomic64_fetch_inc_relaxed(atomic64_t *v) | 1128 | atomic64_fetch_inc_relaxed(atomic64_t *v) |
| 1142 | { | 1129 | { |
| 1143 | __atomic_check_write(v, sizeof(*v)); | 1130 | instrument_atomic_write(v, sizeof(*v)); |
| 1144 | return arch_atomic64_fetch_inc_relaxed(v); | 1131 | return arch_atomic64_fetch_inc_relaxed(v); |
| 1145 | } | 1132 | } |
| 1146 | #define atomic64_fetch_inc_relaxed atomic64_fetch_inc_relaxed | 1133 | #define atomic64_fetch_inc_relaxed atomic64_fetch_inc_relaxed |
| @@ -1150,7 +1137,7 @@ atomic64_fetch_inc_relaxed(atomic64_t *v) · 3 unmodified lines | |||
| 1150 | static __always_inline void | 1137 | static __always_inline void |
| 1151 | atomic64_dec(atomic64_t *v) | 1138 | atomic64_dec(atomic64_t *v) |
| 1152 | { | 1139 | { |
| 1153 | __atomic_check_write(v, sizeof(*v)); | 1140 | instrument_atomic_write(v, sizeof(*v)); |
| 1154 | arch_atomic64_dec(v); | 1141 | arch_atomic64_dec(v); |
| 1155 | } | 1142 | } |
| 1156 | #define atomic64_dec atomic64_dec | 1143 | #define atomic64_dec atomic64_dec |
| @@ -1160,7 +1147,7 @@ atomic64_dec(atomic64_t *v) · 3 unmodified lines | |||
| 1160 | static __always_inline s64 | 1147 | static __always_inline s64 |
| 1161 | atomic64_dec_return(atomic64_t *v) | 1148 | atomic64_dec_return(atomic64_t *v) |
| 1162 | { | 1149 | { |
| 1163 | __atomic_check_write(v, sizeof(*v)); | 1150 | instrument_atomic_write(v, sizeof(*v)); |
| 1164 | return arch_atomic64_dec_return(v); | 1151 | return arch_atomic64_dec_return(v); |
| 1165 | } | 1152 | } |
| 1166 | #define atomic64_dec_return atomic64_dec_return | 1153 | #define atomic64_dec_return atomic64_dec_return |
| @@ -1170,7 +1157,7 @@ atomic64_dec_return(atomic64_t *v) · 3 unmodified lines | |||
| 1170 | static __always_inline s64 | 1157 | static __always_inline s64 |
| 1171 | atomic64_dec_return_acquire(atomic64_t *v) | 1158 | atomic64_dec_return_acquire(atomic64_t *v) |
| 1172 | { | 1159 | { |
| 1173 | __atomic_check_write(v, sizeof(*v)); | 1160 | instrument_atomic_write(v, sizeof(*v)); |
| 1174 | return arch_atomic64_dec_return_acquire(v); | 1161 | return arch_atomic64_dec_return_acquire(v); |
| 1175 | } | 1162 | } |
| 1176 | #define atomic64_dec_return_acquire atomic64_dec_return_acquire | 1163 | #define atomic64_dec_return_acquire atomic64_dec_return_acquire |
| @@ -1180,7 +1167,7 @@ atomic64_dec_return_acquire(atomic64_t *v) · 3 unmodified lines | |||
| 1180 | static __always_inline s64 | 1167 | static __always_inline s64 |
| 1181 | atomic64_dec_return_release(atomic64_t *v) | 1168 | atomic64_dec_return_release(atomic64_t *v) |
| 1182 | { | 1169 | { |
| 1183 | __atomic_check_write(v, sizeof(*v)); | 1170 | instrument_atomic_write(v, sizeof(*v)); |
| 1184 | return arch_atomic64_dec_return_release(v); | 1171 | return arch_atomic64_dec_return_release(v); |
| 1185 | } | 1172 | } |
| 1186 | #define atomic64_dec_return_release atomic64_dec_return_release | 1173 | #define atomic64_dec_return_release atomic64_dec_return_release |
| @@ -1190,7 +1177,7 @@ atomic64_dec_return_release(atomic64_t *v) · 3 unmodified lines | |||
| 1190 | static __always_inline s64 | 1177 | static __always_inline s64 |
| 1191 | atomic64_dec_return_relaxed(atomic64_t *v) | 1178 | atomic64_dec_return_relaxed(atomic64_t *v) |
| 1192 | { | 1179 | { |
| 1193 | __atomic_check_write(v, sizeof(*v)); | 1180 | instrument_atomic_write(v, sizeof(*v)); |
| 1194 | return arch_atomic64_dec_return_relaxed(v); | 1181 | return arch_atomic64_dec_return_relaxed(v); |
| 1195 | } | 1182 | } |
| 1196 | #define atomic64_dec_return_relaxed atomic64_dec_return_relaxed | 1183 | #define atomic64_dec_return_relaxed atomic64_dec_return_relaxed |
| @@ -1200,7 +1187,7 @@ atomic64_dec_return_relaxed(atomic64_t *v) · 3 unmodified lines | |||
| 1200 | static __always_inline s64 | 1187 | static __always_inline s64 |
| 1201 | atomic64_fetch_dec(atomic64_t *v) | 1188 | atomic64_fetch_dec(atomic64_t *v) |
| 1202 | { | 1189 | { |
| 1203 | __atomic_check_write(v, sizeof(*v)); | 1190 | instrument_atomic_write(v, sizeof(*v)); |
| 1204 | return arch_atomic64_fetch_dec(v); | 1191 | return arch_atomic64_fetch_dec(v); |
| 1205 | } | 1192 | } |
| 1206 | #define atomic64_fetch_dec atomic64_fetch_dec | 1193 | #define atomic64_fetch_dec atomic64_fetch_dec |
| @@ -1210,7 +1197,7 @@ atomic64_fetch_dec(atomic64_t *v) · 3 unmodified lines | |||
| 1210 | static __always_inline s64 | 1197 | static __always_inline s64 |
| 1211 | atomic64_fetch_dec_acquire(atomic64_t *v) | 1198 | atomic64_fetch_dec_acquire(atomic64_t *v) |
| 1212 | { | 1199 | { |
| 1213 | __atomic_check_write(v, sizeof(*v)); | 1200 | instrument_atomic_write(v, sizeof(*v)); |
| 1214 | return arch_atomic64_fetch_dec_acquire(v); | 1201 | return arch_atomic64_fetch_dec_acquire(v); |
| 1215 | } | 1202 | } |
| 1216 | #define atomic64_fetch_dec_acquire atomic64_fetch_dec_acquire | 1203 | #define atomic64_fetch_dec_acquire atomic64_fetch_dec_acquire |
| @@ -1220,7 +1207,7 @@ atomic64_fetch_dec_acquire(atomic64_t *v) · 3 unmodified lines | |||
| 1220 | static __always_inline s64 | 1207 | static __always_inline s64 |
| 1221 | atomic64_fetch_dec_release(atomic64_t *v) | 1208 | atomic64_fetch_dec_release(atomic64_t *v) |
| 1222 | { | 1209 | { |
| 1223 | __atomic_check_write(v, sizeof(*v)); | 1210 | instrument_atomic_write(v, sizeof(*v)); |
| 1224 | return arch_atomic64_fetch_dec_release(v); | 1211 | return arch_atomic64_fetch_dec_release(v); |
| 1225 | } | 1212 | } |
| 1226 | #define atomic64_fetch_dec_release atomic64_fetch_dec_release | 1213 | #define atomic64_fetch_dec_release atomic64_fetch_dec_release |
| @@ -1230,7 +1217,7 @@ atomic64_fetch_dec_release(atomic64_t *v) · 3 unmodified lines | |||
| 1230 | static __always_inline s64 | 1217 | static __always_inline s64 |
| 1231 | atomic64_fetch_dec_relaxed(atomic64_t *v) | 1218 | atomic64_fetch_dec_relaxed(atomic64_t *v) |
| 1232 | { | 1219 | { |
| 1233 | __atomic_check_write(v, sizeof(*v)); | 1220 | instrument_atomic_write(v, sizeof(*v)); |
| 1234 | return arch_atomic64_fetch_dec_relaxed(v); | 1221 | return arch_atomic64_fetch_dec_relaxed(v); |
| 1235 | } | 1222 | } |
| 1236 | #define atomic64_fetch_dec_relaxed atomic64_fetch_dec_relaxed | 1223 | #define atomic64_fetch_dec_relaxed atomic64_fetch_dec_relaxed |
| @@ -1239,7 +1226,7 @@ atomic64_fetch_dec_relaxed(atomic64_t *v) · 2 unmodified lines | |||
| 1239 | static __always_inline void | 1226 | static __always_inline void |
| 1240 | atomic64_and(s64 i, atomic64_t *v) | 1227 | atomic64_and(s64 i, atomic64_t *v) |
| 1241 | { | 1228 | { |
| 1242 | __atomic_check_write(v, sizeof(*v)); | 1229 | instrument_atomic_write(v, sizeof(*v)); |
| 1243 | arch_atomic64_and(i, v); | 1230 | arch_atomic64_and(i, v); |
| 1244 | } | 1231 | } |
| 1245 | #define atomic64_and atomic64_and | 1232 | #define atomic64_and atomic64_and |
| @@ -1248,7 +1235,7 @@ atomic64_and(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 1248 | static __always_inline s64 | 1235 | static __always_inline s64 |
| 1249 | atomic64_fetch_and(s64 i, atomic64_t *v) | 1236 | atomic64_fetch_and(s64 i, atomic64_t *v) |
| 1250 | { | 1237 | { |
| 1251 | __atomic_check_write(v, sizeof(*v)); | 1238 | instrument_atomic_write(v, sizeof(*v)); |
| 1252 | return arch_atomic64_fetch_and(i, v); | 1239 | return arch_atomic64_fetch_and(i, v); |
| 1253 | } | 1240 | } |
| 1254 | #define atomic64_fetch_and atomic64_fetch_and | 1241 | #define atomic64_fetch_and atomic64_fetch_and |
| @@ -1258,7 +1245,7 @@ atomic64_fetch_and(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1258 | static __always_inline s64 | 1245 | static __always_inline s64 |
| 1259 | atomic64_fetch_and_acquire(s64 i, atomic64_t *v) | 1246 | atomic64_fetch_and_acquire(s64 i, atomic64_t *v) |
| 1260 | { | 1247 | { |
| 1261 | __atomic_check_write(v, sizeof(*v)); | 1248 | instrument_atomic_write(v, sizeof(*v)); |
| 1262 | return arch_atomic64_fetch_and_acquire(i, v); | 1249 | return arch_atomic64_fetch_and_acquire(i, v); |
| 1263 | } | 1250 | } |
| 1264 | #define atomic64_fetch_and_acquire atomic64_fetch_and_acquire | 1251 | #define atomic64_fetch_and_acquire atomic64_fetch_and_acquire |
| @@ -1268,7 +1255,7 @@ atomic64_fetch_and_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1268 | static __always_inline s64 | 1255 | static __always_inline s64 |
| 1269 | atomic64_fetch_and_release(s64 i, atomic64_t *v) | 1256 | atomic64_fetch_and_release(s64 i, atomic64_t *v) |
| 1270 | { | 1257 | { |
| 1271 | __atomic_check_write(v, sizeof(*v)); | 1258 | instrument_atomic_write(v, sizeof(*v)); |
| 1272 | return arch_atomic64_fetch_and_release(i, v); | 1259 | return arch_atomic64_fetch_and_release(i, v); |
| 1273 | } | 1260 | } |
| 1274 | #define atomic64_fetch_and_release atomic64_fetch_and_release | 1261 | #define atomic64_fetch_and_release atomic64_fetch_and_release |
| @@ -1278,7 +1265,7 @@ atomic64_fetch_and_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1278 | static __always_inline s64 | 1265 | static __always_inline s64 |
| 1279 | atomic64_fetch_and_relaxed(s64 i, atomic64_t *v) | 1266 | atomic64_fetch_and_relaxed(s64 i, atomic64_t *v) |
| 1280 | { | 1267 | { |
| 1281 | __atomic_check_write(v, sizeof(*v)); | 1268 | instrument_atomic_write(v, sizeof(*v)); |
| 1282 | return arch_atomic64_fetch_and_relaxed(i, v); | 1269 | return arch_atomic64_fetch_and_relaxed(i, v); |
| 1283 | } | 1270 | } |
| 1284 | #define atomic64_fetch_and_relaxed atomic64_fetch_and_relaxed | 1271 | #define atomic64_fetch_and_relaxed atomic64_fetch_and_relaxed |
| @@ -1288,7 +1275,7 @@ atomic64_fetch_and_relaxed(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1288 | static __always_inline void | 1275 | static __always_inline void |
| 1289 | atomic64_andnot(s64 i, atomic64_t *v) | 1276 | atomic64_andnot(s64 i, atomic64_t *v) |
| 1290 | { | 1277 | { |
| 1291 | __atomic_check_write(v, sizeof(*v)); | 1278 | instrument_atomic_write(v, sizeof(*v)); |
| 1292 | arch_atomic64_andnot(i, v); | 1279 | arch_atomic64_andnot(i, v); |
| 1293 | } | 1280 | } |
| 1294 | #define atomic64_andnot atomic64_andnot | 1281 | #define atomic64_andnot atomic64_andnot |
| @@ -1298,7 +1285,7 @@ atomic64_andnot(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1298 | static __always_inline s64 | 1285 | static __always_inline s64 |
| 1299 | atomic64_fetch_andnot(s64 i, atomic64_t *v) | 1286 | atomic64_fetch_andnot(s64 i, atomic64_t *v) |
| 1300 | { | 1287 | { |
| 1301 | __atomic_check_write(v, sizeof(*v)); | 1288 | instrument_atomic_write(v, sizeof(*v)); |
| 1302 | return arch_atomic64_fetch_andnot(i, v); | 1289 | return arch_atomic64_fetch_andnot(i, v); |
| 1303 | } | 1290 | } |
| 1304 | #define atomic64_fetch_andnot atomic64_fetch_andnot | 1291 | #define atomic64_fetch_andnot atomic64_fetch_andnot |
| @@ -1308,7 +1295,7 @@ atomic64_fetch_andnot(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1308 | static __always_inline s64 | 1295 | static __always_inline s64 |
| 1309 | atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v) | 1296 | atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v) |
| 1310 | { | 1297 | { |
| 1311 | __atomic_check_write(v, sizeof(*v)); | 1298 | instrument_atomic_write(v, sizeof(*v)); |
| 1312 | return arch_atomic64_fetch_andnot_acquire(i, v); | 1299 | return arch_atomic64_fetch_andnot_acquire(i, v); |
| 1313 | } | 1300 | } |
| 1314 | #define atomic64_fetch_andnot_acquire atomic64_fetch_andnot_acquire | 1301 | #define atomic64_fetch_andnot_acquire atomic64_fetch_andnot_acquire |
| @@ -1318,7 +1305,7 @@ atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1318 | static __always_inline s64 | 1305 | static __always_inline s64 |
| 1319 | atomic64_fetch_andnot_release(s64 i, atomic64_t *v) | 1306 | atomic64_fetch_andnot_release(s64 i, atomic64_t *v) |
| 1320 | { | 1307 | { |
| 1321 | __atomic_check_write(v, sizeof(*v)); | 1308 | instrument_atomic_write(v, sizeof(*v)); |
| 1322 | return arch_atomic64_fetch_andnot_release(i, v); | 1309 | return arch_atomic64_fetch_andnot_release(i, v); |
| 1323 | } | 1310 | } |
| 1324 | #define atomic64_fetch_andnot_release atomic64_fetch_andnot_release | 1311 | #define atomic64_fetch_andnot_release atomic64_fetch_andnot_release |
| @@ -1328,7 +1315,7 @@ atomic64_fetch_andnot_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1328 | static __always_inline s64 | 1315 | static __always_inline s64 |
| 1329 | atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v) | 1316 | atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v) |
| 1330 | { | 1317 | { |
| 1331 | __atomic_check_write(v, sizeof(*v)); | 1318 | instrument_atomic_write(v, sizeof(*v)); |
| 1332 | return arch_atomic64_fetch_andnot_relaxed(i, v); | 1319 | return arch_atomic64_fetch_andnot_relaxed(i, v); |
| 1333 | } | 1320 | } |
| 1334 | #define atomic64_fetch_andnot_relaxed atomic64_fetch_andnot_relaxed | 1321 | #define atomic64_fetch_andnot_relaxed atomic64_fetch_andnot_relaxed |
| @@ -1337,7 +1324,7 @@ atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 1337 | static __always_inline void | 1324 | static __always_inline void |
| 1338 | atomic64_or(s64 i, atomic64_t *v) | 1325 | atomic64_or(s64 i, atomic64_t *v) |
| 1339 | { | 1326 | { |
| 1340 | __atomic_check_write(v, sizeof(*v)); | 1327 | instrument_atomic_write(v, sizeof(*v)); |
| 1341 | arch_atomic64_or(i, v); | 1328 | arch_atomic64_or(i, v); |
| 1342 | } | 1329 | } |
| 1343 | #define atomic64_or atomic64_or | 1330 | #define atomic64_or atomic64_or |
| @@ -1346,7 +1333,7 @@ atomic64_or(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 1346 | static __always_inline s64 | 1333 | static __always_inline s64 |
| 1347 | atomic64_fetch_or(s64 i, atomic64_t *v) | 1334 | atomic64_fetch_or(s64 i, atomic64_t *v) |
| 1348 | { | 1335 | { |
| 1349 | __atomic_check_write(v, sizeof(*v)); | 1336 | instrument_atomic_write(v, sizeof(*v)); |
| 1350 | return arch_atomic64_fetch_or(i, v); | 1337 | return arch_atomic64_fetch_or(i, v); |
| 1351 | } | 1338 | } |
| 1352 | #define atomic64_fetch_or atomic64_fetch_or | 1339 | #define atomic64_fetch_or atomic64_fetch_or |
| @@ -1356,7 +1343,7 @@ atomic64_fetch_or(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1356 | static __always_inline s64 | 1343 | static __always_inline s64 |
| 1357 | atomic64_fetch_or_acquire(s64 i, atomic64_t *v) | 1344 | atomic64_fetch_or_acquire(s64 i, atomic64_t *v) |
| 1358 | { | 1345 | { |
| 1359 | __atomic_check_write(v, sizeof(*v)); | 1346 | instrument_atomic_write(v, sizeof(*v)); |
| 1360 | return arch_atomic64_fetch_or_acquire(i, v); | 1347 | return arch_atomic64_fetch_or_acquire(i, v); |
| 1361 | } | 1348 | } |
| 1362 | #define atomic64_fetch_or_acquire atomic64_fetch_or_acquire | 1349 | #define atomic64_fetch_or_acquire atomic64_fetch_or_acquire |
| @@ -1366,7 +1353,7 @@ atomic64_fetch_or_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1366 | static __always_inline s64 | 1353 | static __always_inline s64 |
| 1367 | atomic64_fetch_or_release(s64 i, atomic64_t *v) | 1354 | atomic64_fetch_or_release(s64 i, atomic64_t *v) |
| 1368 | { | 1355 | { |
| 1369 | __atomic_check_write(v, sizeof(*v)); | 1356 | instrument_atomic_write(v, sizeof(*v)); |
| 1370 | return arch_atomic64_fetch_or_release(i, v); | 1357 | return arch_atomic64_fetch_or_release(i, v); |
| 1371 | } | 1358 | } |
| 1372 | #define atomic64_fetch_or_release atomic64_fetch_or_release | 1359 | #define atomic64_fetch_or_release atomic64_fetch_or_release |
| @@ -1376,7 +1363,7 @@ atomic64_fetch_or_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1376 | static __always_inline s64 | 1363 | static __always_inline s64 |
| 1377 | atomic64_fetch_or_relaxed(s64 i, atomic64_t *v) | 1364 | atomic64_fetch_or_relaxed(s64 i, atomic64_t *v) |
| 1378 | { | 1365 | { |
| 1379 | __atomic_check_write(v, sizeof(*v)); | 1366 | instrument_atomic_write(v, sizeof(*v)); |
| 1380 | return arch_atomic64_fetch_or_relaxed(i, v); | 1367 | return arch_atomic64_fetch_or_relaxed(i, v); |
| 1381 | } | 1368 | } |
| 1382 | #define atomic64_fetch_or_relaxed atomic64_fetch_or_relaxed | 1369 | #define atomic64_fetch_or_relaxed atomic64_fetch_or_relaxed |
| @@ -1385,7 +1372,7 @@ atomic64_fetch_or_relaxed(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 1385 | static __always_inline void | 1372 | static __always_inline void |
| 1386 | atomic64_xor(s64 i, atomic64_t *v) | 1373 | atomic64_xor(s64 i, atomic64_t *v) |
| 1387 | { | 1374 | { |
| 1388 | __atomic_check_write(v, sizeof(*v)); | 1375 | instrument_atomic_write(v, sizeof(*v)); |
| 1389 | arch_atomic64_xor(i, v); | 1376 | arch_atomic64_xor(i, v); |
| 1390 | } | 1377 | } |
| 1391 | #define atomic64_xor atomic64_xor | 1378 | #define atomic64_xor atomic64_xor |
| @@ -1394,7 +1381,7 @@ atomic64_xor(s64 i, atomic64_t *v) · 2 unmodified lines | |||
| 1394 | static __always_inline s64 | 1381 | static __always_inline s64 |
| 1395 | atomic64_fetch_xor(s64 i, atomic64_t *v) | 1382 | atomic64_fetch_xor(s64 i, atomic64_t *v) |
| 1396 | { | 1383 | { |
| 1397 | __atomic_check_write(v, sizeof(*v)); | 1384 | instrument_atomic_write(v, sizeof(*v)); |
| 1398 | return arch_atomic64_fetch_xor(i, v); | 1385 | return arch_atomic64_fetch_xor(i, v); |
| 1399 | } | 1386 | } |
| 1400 | #define atomic64_fetch_xor atomic64_fetch_xor | 1387 | #define atomic64_fetch_xor atomic64_fetch_xor |
| @@ -1404,7 +1391,7 @@ atomic64_fetch_xor(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1404 | static __always_inline s64 | 1391 | static __always_inline s64 |
| 1405 | atomic64_fetch_xor_acquire(s64 i, atomic64_t *v) | 1392 | atomic64_fetch_xor_acquire(s64 i, atomic64_t *v) |
| 1406 | { | 1393 | { |
| 1407 | __atomic_check_write(v, sizeof(*v)); | 1394 | instrument_atomic_write(v, sizeof(*v)); |
| 1408 | return arch_atomic64_fetch_xor_acquire(i, v); | 1395 | return arch_atomic64_fetch_xor_acquire(i, v); |
| 1409 | } | 1396 | } |
| 1410 | #define atomic64_fetch_xor_acquire atomic64_fetch_xor_acquire | 1397 | #define atomic64_fetch_xor_acquire atomic64_fetch_xor_acquire |
| @@ -1414,7 +1401,7 @@ atomic64_fetch_xor_acquire(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1414 | static __always_inline s64 | 1401 | static __always_inline s64 |
| 1415 | atomic64_fetch_xor_release(s64 i, atomic64_t *v) | 1402 | atomic64_fetch_xor_release(s64 i, atomic64_t *v) |
| 1416 | { | 1403 | { |
| 1417 | __atomic_check_write(v, sizeof(*v)); | 1404 | instrument_atomic_write(v, sizeof(*v)); |
| 1418 | return arch_atomic64_fetch_xor_release(i, v); | 1405 | return arch_atomic64_fetch_xor_release(i, v); |
| 1419 | } | 1406 | } |
| 1420 | #define atomic64_fetch_xor_release atomic64_fetch_xor_release | 1407 | #define atomic64_fetch_xor_release atomic64_fetch_xor_release |
| @@ -1424,7 +1411,7 @@ atomic64_fetch_xor_release(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1424 | static __always_inline s64 | 1411 | static __always_inline s64 |
| 1425 | atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v) | 1412 | atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v) |
| 1426 | { | 1413 | { |
| 1427 | __atomic_check_write(v, sizeof(*v)); | 1414 | instrument_atomic_write(v, sizeof(*v)); |
| 1428 | return arch_atomic64_fetch_xor_relaxed(i, v); | 1415 | return arch_atomic64_fetch_xor_relaxed(i, v); |
| 1429 | } | 1416 | } |
| 1430 | #define atomic64_fetch_xor_relaxed atomic64_fetch_xor_relaxed | 1417 | #define atomic64_fetch_xor_relaxed atomic64_fetch_xor_relaxed |
| @@ -1434,7 +1421,7 @@ atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1434 | static __always_inline s64 | 1421 | static __always_inline s64 |
| 1435 | atomic64_xchg(atomic64_t *v, s64 i) | 1422 | atomic64_xchg(atomic64_t *v, s64 i) |
| 1436 | { | 1423 | { |
| 1437 | __atomic_check_write(v, sizeof(*v)); | 1424 | instrument_atomic_write(v, sizeof(*v)); |
| 1438 | return arch_atomic64_xchg(v, i); | 1425 | return arch_atomic64_xchg(v, i); |
| 1439 | } | 1426 | } |
| 1440 | #define atomic64_xchg atomic64_xchg | 1427 | #define atomic64_xchg atomic64_xchg |
| @@ -1444,7 +1431,7 @@ atomic64_xchg(atomic64_t *v, s64 i) · 3 unmodified lines | |||
| 1444 | static __always_inline s64 | 1431 | static __always_inline s64 |
| 1445 | atomic64_xchg_acquire(atomic64_t *v, s64 i) | 1432 | atomic64_xchg_acquire(atomic64_t *v, s64 i) |
| 1446 | { | 1433 | { |
| 1447 | __atomic_check_write(v, sizeof(*v)); | 1434 | instrument_atomic_write(v, sizeof(*v)); |
| 1448 | return arch_atomic64_xchg_acquire(v, i); | 1435 | return arch_atomic64_xchg_acquire(v, i); |
| 1449 | } | 1436 | } |
| 1450 | #define atomic64_xchg_acquire atomic64_xchg_acquire | 1437 | #define atomic64_xchg_acquire atomic64_xchg_acquire |
| @@ -1454,7 +1441,7 @@ atomic64_xchg_acquire(atomic64_t *v, s64 i) · 3 unmodified lines | |||
| 1454 | static __always_inline s64 | 1441 | static __always_inline s64 |
| 1455 | atomic64_xchg_release(atomic64_t *v, s64 i) | 1442 | atomic64_xchg_release(atomic64_t *v, s64 i) |
| 1456 | { | 1443 | { |
| 1457 | __atomic_check_write(v, sizeof(*v)); | 1444 | instrument_atomic_write(v, sizeof(*v)); |
| 1458 | return arch_atomic64_xchg_release(v, i); | 1445 | return arch_atomic64_xchg_release(v, i); |
| 1459 | } | 1446 | } |
| 1460 | #define atomic64_xchg_release atomic64_xchg_release | 1447 | #define atomic64_xchg_release atomic64_xchg_release |
| @@ -1464,7 +1451,7 @@ atomic64_xchg_release(atomic64_t *v, s64 i) · 3 unmodified lines | |||
| 1464 | static __always_inline s64 | 1451 | static __always_inline s64 |
| 1465 | atomic64_xchg_relaxed(atomic64_t *v, s64 i) | 1452 | atomic64_xchg_relaxed(atomic64_t *v, s64 i) |
| 1466 | { | 1453 | { |
| 1467 | __atomic_check_write(v, sizeof(*v)); | 1454 | instrument_atomic_write(v, sizeof(*v)); |
| 1468 | return arch_atomic64_xchg_relaxed(v, i); | 1455 | return arch_atomic64_xchg_relaxed(v, i); |
| 1469 | } | 1456 | } |
| 1470 | #define atomic64_xchg_relaxed atomic64_xchg_relaxed | 1457 | #define atomic64_xchg_relaxed atomic64_xchg_relaxed |
| @@ -1474,7 +1461,7 @@ atomic64_xchg_relaxed(atomic64_t *v, s64 i) · 3 unmodified lines | |||
| 1474 | static __always_inline s64 | 1461 | static __always_inline s64 |
| 1475 | atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new) | 1462 | atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new) |
| 1476 | { | 1463 | { |
| 1477 | __atomic_check_write(v, sizeof(*v)); | 1464 | instrument_atomic_write(v, sizeof(*v)); |
| 1478 | return arch_atomic64_cmpxchg(v, old, new); | 1465 | return arch_atomic64_cmpxchg(v, old, new); |
| 1479 | } | 1466 | } |
| 1480 | #define atomic64_cmpxchg atomic64_cmpxchg | 1467 | #define atomic64_cmpxchg atomic64_cmpxchg |
| @@ -1484,7 +1471,7 @@ atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new) · 3 unmodified lines | |||
| 1484 | static __always_inline s64 | 1471 | static __always_inline s64 |
| 1485 | atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new) | 1472 | atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new) |
| 1486 | { | 1473 | { |
| 1487 | __atomic_check_write(v, sizeof(*v)); | 1474 | instrument_atomic_write(v, sizeof(*v)); |
| 1488 | return arch_atomic64_cmpxchg_acquire(v, old, new); | 1475 | return arch_atomic64_cmpxchg_acquire(v, old, new); |
| 1489 | } | 1476 | } |
| 1490 | #define atomic64_cmpxchg_acquire atomic64_cmpxchg_acquire | 1477 | #define atomic64_cmpxchg_acquire atomic64_cmpxchg_acquire |
| @@ -1494,7 +1481,7 @@ atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new) · 3 unmodified lines | |||
| 1494 | static __always_inline s64 | 1481 | static __always_inline s64 |
| 1495 | atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new) | 1482 | atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new) |
| 1496 | { | 1483 | { |
| 1497 | __atomic_check_write(v, sizeof(*v)); | 1484 | instrument_atomic_write(v, sizeof(*v)); |
| 1498 | return arch_atomic64_cmpxchg_release(v, old, new); | 1485 | return arch_atomic64_cmpxchg_release(v, old, new); |
| 1499 | } | 1486 | } |
| 1500 | #define atomic64_cmpxchg_release atomic64_cmpxchg_release | 1487 | #define atomic64_cmpxchg_release atomic64_cmpxchg_release |
| @@ -1504,7 +1491,7 @@ atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new) · 3 unmodified lines | |||
| 1504 | static __always_inline s64 | 1491 | static __always_inline s64 |
| 1505 | atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new) | 1492 | atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new) |
| 1506 | { | 1493 | { |
| 1507 | __atomic_check_write(v, sizeof(*v)); | 1494 | instrument_atomic_write(v, sizeof(*v)); |
| 1508 | return arch_atomic64_cmpxchg_relaxed(v, old, new); | 1495 | return arch_atomic64_cmpxchg_relaxed(v, old, new); |
| 1509 | } | 1496 | } |
| 1510 | #define atomic64_cmpxchg_relaxed atomic64_cmpxchg_relaxed | 1497 | #define atomic64_cmpxchg_relaxed atomic64_cmpxchg_relaxed |
| @@ -1514,8 +1501,8 @@ atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new) · 3 unmodified lines | |||
| 1514 | static __always_inline bool | 1501 | static __always_inline bool |
| 1515 | atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new) | 1502 | atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new) |
| 1516 | { | 1503 | { |
| 1517 | __atomic_check_write(v, sizeof(*v)); | 1504 | instrument_atomic_write(v, sizeof(*v)); |
| 1518 | __atomic_check_write(old, sizeof(*old)); | 1505 | instrument_atomic_write(old, sizeof(*old)); |
| 1519 | return arch_atomic64_try_cmpxchg(v, old, new); | 1506 | return arch_atomic64_try_cmpxchg(v, old, new); |
| 1520 | } | 1507 | } |
| 1521 | #define atomic64_try_cmpxchg atomic64_try_cmpxchg | 1508 | #define atomic64_try_cmpxchg atomic64_try_cmpxchg |
| @@ -1525,8 +1512,8 @@ atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new) · 3 unmodified lines | |||
| 1525 | static __always_inline bool | 1512 | static __always_inline bool |
| 1526 | atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new) | 1513 | atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new) |
| 1527 | { | 1514 | { |
| 1528 | __atomic_check_write(v, sizeof(*v)); | 1515 | instrument_atomic_write(v, sizeof(*v)); |
| 1529 | __atomic_check_write(old, sizeof(*old)); | 1516 | instrument_atomic_write(old, sizeof(*old)); |
| 1530 | return arch_atomic64_try_cmpxchg_acquire(v, old, new); | 1517 | return arch_atomic64_try_cmpxchg_acquire(v, old, new); |
| 1531 | } | 1518 | } |
| 1532 | #define atomic64_try_cmpxchg_acquire atomic64_try_cmpxchg_acquire | 1519 | #define atomic64_try_cmpxchg_acquire atomic64_try_cmpxchg_acquire |
| @@ -1536,8 +1523,8 @@ atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new) · 3 unmodified lines | |||
| 1536 | static __always_inline bool | 1523 | static __always_inline bool |
| 1537 | atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new) | 1524 | atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new) |
| 1538 | { | 1525 | { |
| 1539 | __atomic_check_write(v, sizeof(*v)); | 1526 | instrument_atomic_write(v, sizeof(*v)); |
| 1540 | __atomic_check_write(old, sizeof(*old)); | 1527 | instrument_atomic_write(old, sizeof(*old)); |
| 1541 | return arch_atomic64_try_cmpxchg_release(v, old, new); | 1528 | return arch_atomic64_try_cmpxchg_release(v, old, new); |
| 1542 | } | 1529 | } |
| 1543 | #define atomic64_try_cmpxchg_release atomic64_try_cmpxchg_release | 1530 | #define atomic64_try_cmpxchg_release atomic64_try_cmpxchg_release |
| @@ -1547,8 +1534,8 @@ atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new) · 3 unmodified lines | |||
| 1547 | static __always_inline bool | 1534 | static __always_inline bool |
| 1548 | atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new) | 1535 | atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new) |
| 1549 | { | 1536 | { |
| 1550 | __atomic_check_write(v, sizeof(*v)); | 1537 | instrument_atomic_write(v, sizeof(*v)); |
| 1551 | __atomic_check_write(old, sizeof(*old)); | 1538 | instrument_atomic_write(old, sizeof(*old)); |
| 1552 | return arch_atomic64_try_cmpxchg_relaxed(v, old, new); | 1539 | return arch_atomic64_try_cmpxchg_relaxed(v, old, new); |
| 1553 | } | 1540 | } |
| 1554 | #define atomic64_try_cmpxchg_relaxed atomic64_try_cmpxchg_relaxed | 1541 | #define atomic64_try_cmpxchg_relaxed atomic64_try_cmpxchg_relaxed |
| @@ -1558,7 +1545,7 @@ atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new) · 3 unmodified lines | |||
| 1558 | static __always_inline bool | 1545 | static __always_inline bool |
| 1559 | atomic64_sub_and_test(s64 i, atomic64_t *v) | 1546 | atomic64_sub_and_test(s64 i, atomic64_t *v) |
| 1560 | { | 1547 | { |
| 1561 | __atomic_check_write(v, sizeof(*v)); | 1548 | instrument_atomic_write(v, sizeof(*v)); |
| 1562 | return arch_atomic64_sub_and_test(i, v); | 1549 | return arch_atomic64_sub_and_test(i, v); |
| 1563 | } | 1550 | } |
| 1564 | #define atomic64_sub_and_test atomic64_sub_and_test | 1551 | #define atomic64_sub_and_test atomic64_sub_and_test |
| @@ -1568,7 +1555,7 @@ atomic64_sub_and_test(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1568 | static __always_inline bool | 1555 | static __always_inline bool |
| 1569 | atomic64_dec_and_test(atomic64_t *v) | 1556 | atomic64_dec_and_test(atomic64_t *v) |
| 1570 | { | 1557 | { |
| 1571 | __atomic_check_write(v, sizeof(*v)); | 1558 | instrument_atomic_write(v, sizeof(*v)); |
| 1572 | return arch_atomic64_dec_and_test(v); | 1559 | return arch_atomic64_dec_and_test(v); |
| 1573 | } | 1560 | } |
| 1574 | #define atomic64_dec_and_test atomic64_dec_and_test | 1561 | #define atomic64_dec_and_test atomic64_dec_and_test |
| @@ -1578,7 +1565,7 @@ atomic64_dec_and_test(atomic64_t *v) · 3 unmodified lines | |||
| 1578 | static __always_inline bool | 1565 | static __always_inline bool |
| 1579 | atomic64_inc_and_test(atomic64_t *v) | 1566 | atomic64_inc_and_test(atomic64_t *v) |
| 1580 | { | 1567 | { |
| 1581 | __atomic_check_write(v, sizeof(*v)); | 1568 | instrument_atomic_write(v, sizeof(*v)); |
| 1582 | return arch_atomic64_inc_and_test(v); | 1569 | return arch_atomic64_inc_and_test(v); |
| 1583 | } | 1570 | } |
| 1584 | #define atomic64_inc_and_test atomic64_inc_and_test | 1571 | #define atomic64_inc_and_test atomic64_inc_and_test |
| @@ -1588,7 +1575,7 @@ atomic64_inc_and_test(atomic64_t *v) · 3 unmodified lines | |||
| 1588 | static __always_inline bool | 1575 | static __always_inline bool |
| 1589 | atomic64_add_negative(s64 i, atomic64_t *v) | 1576 | atomic64_add_negative(s64 i, atomic64_t *v) |
| 1590 | { | 1577 | { |
| 1591 | __atomic_check_write(v, sizeof(*v)); | 1578 | instrument_atomic_write(v, sizeof(*v)); |
| 1592 | return arch_atomic64_add_negative(i, v); | 1579 | return arch_atomic64_add_negative(i, v); |
| 1593 | } | 1580 | } |
| 1594 | #define atomic64_add_negative atomic64_add_negative | 1581 | #define atomic64_add_negative atomic64_add_negative |
| @@ -1598,7 +1585,7 @@ atomic64_add_negative(s64 i, atomic64_t *v) · 3 unmodified lines | |||
| 1598 | static __always_inline s64 | 1585 | static __always_inline s64 |
| 1599 | atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u) | 1586 | atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u) |
| 1600 | { | 1587 | { |
| 1601 | __atomic_check_write(v, sizeof(*v)); | 1588 | instrument_atomic_write(v, sizeof(*v)); |
| 1602 | return arch_atomic64_fetch_add_unless(v, a, u); | 1589 | return arch_atomic64_fetch_add_unless(v, a, u); |
| 1603 | } | 1590 | } |
| 1604 | #define atomic64_fetch_add_unless atomic64_fetch_add_unless | 1591 | #define atomic64_fetch_add_unless atomic64_fetch_add_unless |
| @@ -1608,7 +1595,7 @@ atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u) · 3 unmodified lines | |||
| 1608 | static __always_inline bool | 1595 | static __always_inline bool |
| 1609 | atomic64_add_unless(atomic64_t *v, s64 a, s64 u) | 1596 | atomic64_add_unless(atomic64_t *v, s64 a, s64 u) |
| 1610 | { | 1597 | { |
| 1611 | __atomic_check_write(v, sizeof(*v)); | 1598 | instrument_atomic_write(v, sizeof(*v)); |
| 1612 | return arch_atomic64_add_unless(v, a, u); | 1599 | return arch_atomic64_add_unless(v, a, u); |
| 1613 | } | 1600 | } |
| 1614 | #define atomic64_add_unless atomic64_add_unless | 1601 | #define atomic64_add_unless atomic64_add_unless |
| @@ -1618,7 +1605,7 @@ atomic64_add_unless(atomic64_t *v, s64 a, s64 u) · 3 unmodified lines | |||
| 1618 | static __always_inline bool | 1605 | static __always_inline bool |
| 1619 | atomic64_inc_not_zero(atomic64_t *v) | 1606 | atomic64_inc_not_zero(atomic64_t *v) |
| 1620 | { | 1607 | { |
| 1621 | __atomic_check_write(v, sizeof(*v)); | 1608 | instrument_atomic_write(v, sizeof(*v)); |
| 1622 | return arch_atomic64_inc_not_zero(v); | 1609 | return arch_atomic64_inc_not_zero(v); |
| 1623 | } | 1610 | } |
| 1624 | #define atomic64_inc_not_zero atomic64_inc_not_zero | 1611 | #define atomic64_inc_not_zero atomic64_inc_not_zero |
| @@ -1628,7 +1615,7 @@ atomic64_inc_not_zero(atomic64_t *v) · 3 unmodified lines | |||
| 1628 | static __always_inline bool | 1615 | static __always_inline bool |
| 1629 | atomic64_inc_unless_negative(atomic64_t *v) | 1616 | atomic64_inc_unless_negative(atomic64_t *v) |
| 1630 | { | 1617 | { |
| 1631 | __atomic_check_write(v, sizeof(*v)); | 1618 | instrument_atomic_write(v, sizeof(*v)); |
| 1632 | return arch_atomic64_inc_unless_negative(v); | 1619 | return arch_atomic64_inc_unless_negative(v); |
| 1633 | } | 1620 | } |
| 1634 | #define atomic64_inc_unless_negative atomic64_inc_unless_negative | 1621 | #define atomic64_inc_unless_negative atomic64_inc_unless_negative |
| @@ -1638,7 +1625,7 @@ atomic64_inc_unless_negative(atomic64_t *v) · 3 unmodified lines | |||
| 1638 | static __always_inline bool | 1625 | static __always_inline bool |
| 1639 | atomic64_dec_unless_positive(atomic64_t *v) | 1626 | atomic64_dec_unless_positive(atomic64_t *v) |
| 1640 | { | 1627 | { |
| 1641 | __atomic_check_write(v, sizeof(*v)); | 1628 | instrument_atomic_write(v, sizeof(*v)); |
| 1642 | return arch_atomic64_dec_unless_positive(v); | 1629 | return arch_atomic64_dec_unless_positive(v); |
| 1643 | } | 1630 | } |
| 1644 | #define atomic64_dec_unless_positive atomic64_dec_unless_positive | 1631 | #define atomic64_dec_unless_positive atomic64_dec_unless_positive |
| @@ -1648,7 +1635,7 @@ atomic64_dec_unless_positive(atomic64_t *v) · 3 unmodified lines | |||
| 1648 | static __always_inline s64 | 1635 | static __always_inline s64 |
| 1649 | atomic64_dec_if_positive(atomic64_t *v) | 1636 | atomic64_dec_if_positive(atomic64_t *v) |
| 1650 | { | 1637 | { |
| 1651 | __atomic_check_write(v, sizeof(*v)); | 1638 | instrument_atomic_write(v, sizeof(*v)); |
| 1652 | return arch_atomic64_dec_if_positive(v); | 1639 | return arch_atomic64_dec_if_positive(v); |
| 1653 | } | 1640 | } |
| 1654 | #define atomic64_dec_if_positive atomic64_dec_if_positive | 1641 | #define atomic64_dec_if_positive atomic64_dec_if_positive |
| @@ -1658,7 +1645,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 3 unmodified lines | |||
| 1658 | #define xchg(ptr, ...) \ | 1645 | #define xchg(ptr, ...) \ |
| 1659 | ({ \ | 1646 | ({ \ |
| 1660 | typeof(ptr) __ai_ptr = (ptr); \ | 1647 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1661 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1648 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1662 | arch_xchg(__ai_ptr, __VA_ARGS__); \ | 1649 | arch_xchg(__ai_ptr, __VA_ARGS__); \ |
| 1663 | }) | 1650 | }) |
| 1664 | #endif | 1651 | #endif |
| @@ -1667,7 +1654,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1667 | #define xchg_acquire(ptr, ...) \ | 1654 | #define xchg_acquire(ptr, ...) \ |
| 1668 | ({ \ | 1655 | ({ \ |
| 1669 | typeof(ptr) __ai_ptr = (ptr); \ | 1656 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1670 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1657 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1671 | arch_xchg_acquire(__ai_ptr, __VA_ARGS__); \ | 1658 | arch_xchg_acquire(__ai_ptr, __VA_ARGS__); \ |
| 1672 | }) | 1659 | }) |
| 1673 | #endif | 1660 | #endif |
| @@ -1676,7 +1663,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1676 | #define xchg_release(ptr, ...) \ | 1663 | #define xchg_release(ptr, ...) \ |
| 1677 | ({ \ | 1664 | ({ \ |
| 1678 | typeof(ptr) __ai_ptr = (ptr); \ | 1665 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1679 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1666 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1680 | arch_xchg_release(__ai_ptr, __VA_ARGS__); \ | 1667 | arch_xchg_release(__ai_ptr, __VA_ARGS__); \ |
| 1681 | }) | 1668 | }) |
| 1682 | #endif | 1669 | #endif |
| @@ -1685,7 +1672,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1685 | #define xchg_relaxed(ptr, ...) \ | 1672 | #define xchg_relaxed(ptr, ...) \ |
| 1686 | ({ \ | 1673 | ({ \ |
| 1687 | typeof(ptr) __ai_ptr = (ptr); \ | 1674 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1688 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1675 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1689 | arch_xchg_relaxed(__ai_ptr, __VA_ARGS__); \ | 1676 | arch_xchg_relaxed(__ai_ptr, __VA_ARGS__); \ |
| 1690 | }) | 1677 | }) |
| 1691 | #endif | 1678 | #endif |
| @@ -1694,7 +1681,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1694 | #define cmpxchg(ptr, ...) \ | 1681 | #define cmpxchg(ptr, ...) \ |
| 1695 | ({ \ | 1682 | ({ \ |
| 1696 | typeof(ptr) __ai_ptr = (ptr); \ | 1683 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1697 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1684 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1698 | arch_cmpxchg(__ai_ptr, __VA_ARGS__); \ | 1685 | arch_cmpxchg(__ai_ptr, __VA_ARGS__); \ |
| 1699 | }) | 1686 | }) |
| 1700 | #endif | 1687 | #endif |
| @@ -1703,7 +1690,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1703 | #define cmpxchg_acquire(ptr, ...) \ | 1690 | #define cmpxchg_acquire(ptr, ...) \ |
| 1704 | ({ \ | 1691 | ({ \ |
| 1705 | typeof(ptr) __ai_ptr = (ptr); \ | 1692 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1706 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1693 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1707 | arch_cmpxchg_acquire(__ai_ptr, __VA_ARGS__); \ | 1694 | arch_cmpxchg_acquire(__ai_ptr, __VA_ARGS__); \ |
| 1708 | }) | 1695 | }) |
| 1709 | #endif | 1696 | #endif |
| @@ -1712,7 +1699,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1712 | #define cmpxchg_release(ptr, ...) \ | 1699 | #define cmpxchg_release(ptr, ...) \ |
| 1713 | ({ \ | 1700 | ({ \ |
| 1714 | typeof(ptr) __ai_ptr = (ptr); \ | 1701 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1715 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1702 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1716 | arch_cmpxchg_release(__ai_ptr, __VA_ARGS__); \ | 1703 | arch_cmpxchg_release(__ai_ptr, __VA_ARGS__); \ |
| 1717 | }) | 1704 | }) |
| 1718 | #endif | 1705 | #endif |
| @@ -1721,7 +1708,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1721 | #define cmpxchg_relaxed(ptr, ...) \ | 1708 | #define cmpxchg_relaxed(ptr, ...) \ |
| 1722 | ({ \ | 1709 | ({ \ |
| 1723 | typeof(ptr) __ai_ptr = (ptr); \ | 1710 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1724 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1711 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1725 | arch_cmpxchg_relaxed(__ai_ptr, __VA_ARGS__); \ | 1712 | arch_cmpxchg_relaxed(__ai_ptr, __VA_ARGS__); \ |
| 1726 | }) | 1713 | }) |
| 1727 | #endif | 1714 | #endif |
| @@ -1730,7 +1717,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1730 | #define cmpxchg64(ptr, ...) \ | 1717 | #define cmpxchg64(ptr, ...) \ |
| 1731 | ({ \ | 1718 | ({ \ |
| 1732 | typeof(ptr) __ai_ptr = (ptr); \ | 1719 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1733 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1720 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1734 | arch_cmpxchg64(__ai_ptr, __VA_ARGS__); \ | 1721 | arch_cmpxchg64(__ai_ptr, __VA_ARGS__); \ |
| 1735 | }) | 1722 | }) |
| 1736 | #endif | 1723 | #endif |
| @@ -1739,7 +1726,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1739 | #define cmpxchg64_acquire(ptr, ...) \ | 1726 | #define cmpxchg64_acquire(ptr, ...) \ |
| 1740 | ({ \ | 1727 | ({ \ |
| 1741 | typeof(ptr) __ai_ptr = (ptr); \ | 1728 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1742 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1729 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1743 | arch_cmpxchg64_acquire(__ai_ptr, __VA_ARGS__); \ | 1730 | arch_cmpxchg64_acquire(__ai_ptr, __VA_ARGS__); \ |
| 1744 | }) | 1731 | }) |
| 1745 | #endif | 1732 | #endif |
| @@ -1748,7 +1735,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1748 | #define cmpxchg64_release(ptr, ...) \ | 1735 | #define cmpxchg64_release(ptr, ...) \ |
| 1749 | ({ \ | 1736 | ({ \ |
| 1750 | typeof(ptr) __ai_ptr = (ptr); \ | 1737 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1751 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1738 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1752 | arch_cmpxchg64_release(__ai_ptr, __VA_ARGS__); \ | 1739 | arch_cmpxchg64_release(__ai_ptr, __VA_ARGS__); \ |
| 1753 | }) | 1740 | }) |
| 1754 | #endif | 1741 | #endif |
| @@ -1757,7 +1744,7 @@ atomic64_dec_if_positive(atomic64_t *v) · 2 unmodified lines | |||
| 1757 | #define cmpxchg64_relaxed(ptr, ...) \ | 1744 | #define cmpxchg64_relaxed(ptr, ...) \ |
| 1758 | ({ \ | 1745 | ({ \ |
| 1759 | typeof(ptr) __ai_ptr = (ptr); \ | 1746 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1760 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1747 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1761 | arch_cmpxchg64_relaxed(__ai_ptr, __VA_ARGS__); \ | 1748 | arch_cmpxchg64_relaxed(__ai_ptr, __VA_ARGS__); \ |
| 1762 | }) | 1749 | }) |
| 1763 | #endif | 1750 | #endif |
| @@ -1765,28 +1752,28 @@ atomic64_dec_if_positive(atomic64_t *v) · 1 unmodified line | |||
| 1765 | #define cmpxchg_local(ptr, ...) \ | 1752 | #define cmpxchg_local(ptr, ...) \ |
| 1766 | ({ \ | 1753 | ({ \ |
| 1767 | typeof(ptr) __ai_ptr = (ptr); \ | 1754 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1768 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1755 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1769 | arch_cmpxchg_local(__ai_ptr, __VA_ARGS__); \ | 1756 | arch_cmpxchg_local(__ai_ptr, __VA_ARGS__); \ |
| 1770 | }) | 1757 | }) |
| 1771 | 1758 | ||
| 1772 | #define cmpxchg64_local(ptr, ...) \ | 1759 | #define cmpxchg64_local(ptr, ...) \ |
| 1773 | ({ \ | 1760 | ({ \ |
| 1774 | typeof(ptr) __ai_ptr = (ptr); \ | 1761 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1775 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1762 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1776 | arch_cmpxchg64_local(__ai_ptr, __VA_ARGS__); \ | 1763 | arch_cmpxchg64_local(__ai_ptr, __VA_ARGS__); \ |
| 1777 | }) | 1764 | }) |
| 1778 | 1765 | ||
| 1779 | #define sync_cmpxchg(ptr, ...) \ | 1766 | #define sync_cmpxchg(ptr, ...) \ |
| 1780 | ({ \ | 1767 | ({ \ |
| 1781 | typeof(ptr) __ai_ptr = (ptr); \ | 1768 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1782 | __atomic_check_write(__ai_ptr, sizeof(*__ai_ptr)); \ | 1769 | instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); \ |
| 1783 | arch_sync_cmpxchg(__ai_ptr, __VA_ARGS__); \ | 1770 | arch_sync_cmpxchg(__ai_ptr, __VA_ARGS__); \ |
| 1784 | }) | 1771 | }) |
| 1785 | 1772 | ||
| 1786 | #define cmpxchg_double(ptr, ...) \ | 1773 | #define cmpxchg_double(ptr, ...) \ |
| 1787 | ({ \ | 1774 | ({ \ |
| 1788 | typeof(ptr) __ai_ptr = (ptr); \ | 1775 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1789 | __atomic_check_write(__ai_ptr, 2 * sizeof(*__ai_ptr)); \ | 1776 | instrument_atomic_write(__ai_ptr, 2 * sizeof(*__ai_ptr)); \ |
| 1790 | arch_cmpxchg_double(__ai_ptr, __VA_ARGS__); \ | 1777 | arch_cmpxchg_double(__ai_ptr, __VA_ARGS__); \ |
| 1791 | }) | 1778 | }) |
| 1792 | 1779 | ||
| @@ -1794,9 +1781,9 @@ atomic64_dec_if_positive(atomic64_t *v) · 1 unmodified line | |||
| 1794 | #define cmpxchg_double_local(ptr, ...) \ | 1781 | #define cmpxchg_double_local(ptr, ...) \ |
| 1795 | ({ \ | 1782 | ({ \ |
| 1796 | typeof(ptr) __ai_ptr = (ptr); \ | 1783 | typeof(ptr) __ai_ptr = (ptr); \ |
| 1797 | __atomic_check_write(__ai_ptr, 2 * sizeof(*__ai_ptr)); \ | 1784 | instrument_atomic_write(__ai_ptr, 2 * sizeof(*__ai_ptr)); \ |
| 1798 | arch_cmpxchg_double_local(__ai_ptr, __VA_ARGS__); \ | 1785 | arch_cmpxchg_double_local(__ai_ptr, __VA_ARGS__); \ |
| 1799 | }) | 1786 | }) |
| 1800 | 1787 | ||
| 1801 | #endif /* _ASM_GENERIC_ATOMIC_INSTRUMENTED_H */ | 1788 | #endif /* _ASM_GENERIC_ATOMIC_INSTRUMENTED_H */ |
| 1802 | // 7b7e2af0e75c8ecb6f02298a7075f503f30d244c | 1789 | // 89bf97f3a7509b740845e51ddf31055b48a81f40 |
| @@ -20,7 +20,7 @@ gen_param_check() · 19 unmodified lines | |||
| 20 | # We don't write to constant parameters | 20 | # We don't write to constant parameters |
| 21 | [ ${type#c} != ${type} ] && rw="read" | 21 | [ ${type#c} != ${type} ] && rw="read" |
| 22 | 22 | ||
| 23 | printf "\t__atomic_check_${rw}(${name}, sizeof(*${name}));\n" | 23 | printf "\tinstrument_atomic_${rw}(${name}, sizeof(*${name}));\n" |
| 24 | } | 24 | } |
| 25 | 25 | ||
| 26 | #gen_param_check(arg...) | 26 | #gen_param_check(arg...) |
| @@ -107,7 +107,7 @@ cat <<EOF · 80 unmodified lines | |||
| 107 | #define ${xchg}(ptr, ...) \\ | 107 | #define ${xchg}(ptr, ...) \\ |
| 108 | ({ \\ | 108 | ({ \\ |
| 109 | typeof(ptr) __ai_ptr = (ptr); \\ | 109 | typeof(ptr) __ai_ptr = (ptr); \\ |
| 110 | __atomic_check_write(__ai_ptr, ${mult}sizeof(*__ai_ptr)); \\ | 110 | instrument_atomic_write(__ai_ptr, ${mult}sizeof(*__ai_ptr)); \\ |
| 111 | arch_${xchg}(__ai_ptr, __VA_ARGS__); \\ | 111 | arch_${xchg}(__ai_ptr, __VA_ARGS__); \\ |
| 112 | }) | 112 | }) |
| 113 | EOF | 113 | EOF |
| @@ -148,20 +148,7 @@ cat << EOF · 34 unmodified lines | |||
| 148 | 148 | ||
| 149 | #include <linux/build_bug.h> | 149 | #include <linux/build_bug.h> |
| 150 | #include <linux/compiler.h> | 150 | #include <linux/compiler.h> |
| 151 | #include <linux/kasan-checks.h> | 151 | #include <linux/instrumented.h> |
| 152 | #include <linux/kcsan-checks.h> | ||
| 153 | |||
| 154 | static __always_inline void __atomic_check_read(const volatile void *v, size_t size) | ||
| 155 | { | ||
| 156 | kasan_check_read(v, size); | ||
| 157 | kcsan_check_atomic_read(v, size); | ||
| 158 | } | ||
| 159 | |||
| 160 | static __always_inline void __atomic_check_write(const volatile void *v, size_t size) | ||
| 161 | { | ||
| 162 | kasan_check_write(v, size); | ||
| 163 | kcsan_check_atomic_write(v, size); | ||
| 164 | } | ||
| 165 | 152 | ||
| 166 | EOF | 153 | EOF |
| 167 | 154 | ||