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