root/include/asm-generic/atomic-long.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM

DEFINITIONS

This source file includes following definitions.
  1. atomic_long_read
  2. atomic_long_read_acquire
  3. atomic_long_set
  4. atomic_long_set_release
  5. atomic_long_add
  6. atomic_long_add_return
  7. atomic_long_add_return_acquire
  8. atomic_long_add_return_release
  9. atomic_long_add_return_relaxed
  10. atomic_long_fetch_add
  11. atomic_long_fetch_add_acquire
  12. atomic_long_fetch_add_release
  13. atomic_long_fetch_add_relaxed
  14. atomic_long_sub
  15. atomic_long_sub_return
  16. atomic_long_sub_return_acquire
  17. atomic_long_sub_return_release
  18. atomic_long_sub_return_relaxed
  19. atomic_long_fetch_sub
  20. atomic_long_fetch_sub_acquire
  21. atomic_long_fetch_sub_release
  22. atomic_long_fetch_sub_relaxed
  23. atomic_long_inc
  24. atomic_long_inc_return
  25. atomic_long_inc_return_acquire
  26. atomic_long_inc_return_release
  27. atomic_long_inc_return_relaxed
  28. atomic_long_fetch_inc
  29. atomic_long_fetch_inc_acquire
  30. atomic_long_fetch_inc_release
  31. atomic_long_fetch_inc_relaxed
  32. atomic_long_dec
  33. atomic_long_dec_return
  34. atomic_long_dec_return_acquire
  35. atomic_long_dec_return_release
  36. atomic_long_dec_return_relaxed
  37. atomic_long_fetch_dec
  38. atomic_long_fetch_dec_acquire
  39. atomic_long_fetch_dec_release
  40. atomic_long_fetch_dec_relaxed
  41. atomic_long_and
  42. atomic_long_fetch_and
  43. atomic_long_fetch_and_acquire
  44. atomic_long_fetch_and_release
  45. atomic_long_fetch_and_relaxed
  46. atomic_long_andnot
  47. atomic_long_fetch_andnot
  48. atomic_long_fetch_andnot_acquire
  49. atomic_long_fetch_andnot_release
  50. atomic_long_fetch_andnot_relaxed
  51. atomic_long_or
  52. atomic_long_fetch_or
  53. atomic_long_fetch_or_acquire
  54. atomic_long_fetch_or_release
  55. atomic_long_fetch_or_relaxed
  56. atomic_long_xor
  57. atomic_long_fetch_xor
  58. atomic_long_fetch_xor_acquire
  59. atomic_long_fetch_xor_release
  60. atomic_long_fetch_xor_relaxed
  61. atomic_long_xchg
  62. atomic_long_xchg_acquire
  63. atomic_long_xchg_release
  64. atomic_long_xchg_relaxed
  65. atomic_long_cmpxchg
  66. atomic_long_cmpxchg_acquire
  67. atomic_long_cmpxchg_release
  68. atomic_long_cmpxchg_relaxed
  69. atomic_long_try_cmpxchg
  70. atomic_long_try_cmpxchg_acquire
  71. atomic_long_try_cmpxchg_release
  72. atomic_long_try_cmpxchg_relaxed
  73. atomic_long_sub_and_test
  74. atomic_long_dec_and_test
  75. atomic_long_inc_and_test
  76. atomic_long_add_negative
  77. atomic_long_fetch_add_unless
  78. atomic_long_add_unless
  79. atomic_long_inc_not_zero
  80. atomic_long_inc_unless_negative
  81. atomic_long_dec_unless_positive
  82. atomic_long_dec_if_positive
  83. atomic_long_read
  84. atomic_long_read_acquire
  85. atomic_long_set
  86. atomic_long_set_release
  87. atomic_long_add
  88. atomic_long_add_return
  89. atomic_long_add_return_acquire
  90. atomic_long_add_return_release
  91. atomic_long_add_return_relaxed
  92. atomic_long_fetch_add
  93. atomic_long_fetch_add_acquire
  94. atomic_long_fetch_add_release
  95. atomic_long_fetch_add_relaxed
  96. atomic_long_sub
  97. atomic_long_sub_return
  98. atomic_long_sub_return_acquire
  99. atomic_long_sub_return_release
  100. atomic_long_sub_return_relaxed
  101. atomic_long_fetch_sub
  102. atomic_long_fetch_sub_acquire
  103. atomic_long_fetch_sub_release
  104. atomic_long_fetch_sub_relaxed
  105. atomic_long_inc
  106. atomic_long_inc_return
  107. atomic_long_inc_return_acquire
  108. atomic_long_inc_return_release
  109. atomic_long_inc_return_relaxed
  110. atomic_long_fetch_inc
  111. atomic_long_fetch_inc_acquire
  112. atomic_long_fetch_inc_release
  113. atomic_long_fetch_inc_relaxed
  114. atomic_long_dec
  115. atomic_long_dec_return
  116. atomic_long_dec_return_acquire
  117. atomic_long_dec_return_release
  118. atomic_long_dec_return_relaxed
  119. atomic_long_fetch_dec
  120. atomic_long_fetch_dec_acquire
  121. atomic_long_fetch_dec_release
  122. atomic_long_fetch_dec_relaxed
  123. atomic_long_and
  124. atomic_long_fetch_and
  125. atomic_long_fetch_and_acquire
  126. atomic_long_fetch_and_release
  127. atomic_long_fetch_and_relaxed
  128. atomic_long_andnot
  129. atomic_long_fetch_andnot
  130. atomic_long_fetch_andnot_acquire
  131. atomic_long_fetch_andnot_release
  132. atomic_long_fetch_andnot_relaxed
  133. atomic_long_or
  134. atomic_long_fetch_or
  135. atomic_long_fetch_or_acquire
  136. atomic_long_fetch_or_release
  137. atomic_long_fetch_or_relaxed
  138. atomic_long_xor
  139. atomic_long_fetch_xor
  140. atomic_long_fetch_xor_acquire
  141. atomic_long_fetch_xor_release
  142. atomic_long_fetch_xor_relaxed
  143. atomic_long_xchg
  144. atomic_long_xchg_acquire
  145. atomic_long_xchg_release
  146. atomic_long_xchg_relaxed
  147. atomic_long_cmpxchg
  148. atomic_long_cmpxchg_acquire
  149. atomic_long_cmpxchg_release
  150. atomic_long_cmpxchg_relaxed
  151. atomic_long_try_cmpxchg
  152. atomic_long_try_cmpxchg_acquire
  153. atomic_long_try_cmpxchg_release
  154. atomic_long_try_cmpxchg_relaxed
  155. atomic_long_sub_and_test
  156. atomic_long_dec_and_test
  157. atomic_long_inc_and_test
  158. atomic_long_add_negative
  159. atomic_long_fetch_add_unless
  160. atomic_long_add_unless
  161. atomic_long_inc_not_zero
  162. atomic_long_inc_unless_negative
  163. atomic_long_dec_unless_positive
  164. atomic_long_dec_if_positive
   1 // SPDX-License-Identifier: GPL-2.0
   2 
   3 // Generated by scripts/atomic/gen-atomic-long.sh
   4 // DO NOT MODIFY THIS FILE DIRECTLY
   5 
   6 #ifndef _ASM_GENERIC_ATOMIC_LONG_H
   7 #define _ASM_GENERIC_ATOMIC_LONG_H
   8 
   9 #include <asm/types.h>
  10 
  11 #ifdef CONFIG_64BIT
  12 typedef atomic64_t atomic_long_t;
  13 #define ATOMIC_LONG_INIT(i)             ATOMIC64_INIT(i)
  14 #define atomic_long_cond_read_acquire   atomic64_cond_read_acquire
  15 #define atomic_long_cond_read_relaxed   atomic64_cond_read_relaxed
  16 #else
  17 typedef atomic_t atomic_long_t;
  18 #define ATOMIC_LONG_INIT(i)             ATOMIC_INIT(i)
  19 #define atomic_long_cond_read_acquire   atomic_cond_read_acquire
  20 #define atomic_long_cond_read_relaxed   atomic_cond_read_relaxed
  21 #endif
  22 
  23 #ifdef CONFIG_64BIT
  24 
  25 static inline long
  26 atomic_long_read(const atomic_long_t *v)
  27 {
  28         return atomic64_read(v);
  29 }
  30 
  31 static inline long
  32 atomic_long_read_acquire(const atomic_long_t *v)
  33 {
  34         return atomic64_read_acquire(v);
  35 }
  36 
  37 static inline void
  38 atomic_long_set(atomic_long_t *v, long i)
  39 {
  40         atomic64_set(v, i);
  41 }
  42 
  43 static inline void
  44 atomic_long_set_release(atomic_long_t *v, long i)
  45 {
  46         atomic64_set_release(v, i);
  47 }
  48 
  49 static inline void
  50 atomic_long_add(long i, atomic_long_t *v)
  51 {
  52         atomic64_add(i, v);
  53 }
  54 
  55 static inline long
  56 atomic_long_add_return(long i, atomic_long_t *v)
  57 {
  58         return atomic64_add_return(i, v);
  59 }
  60 
  61 static inline long
  62 atomic_long_add_return_acquire(long i, atomic_long_t *v)
  63 {
  64         return atomic64_add_return_acquire(i, v);
  65 }
  66 
  67 static inline long
  68 atomic_long_add_return_release(long i, atomic_long_t *v)
  69 {
  70         return atomic64_add_return_release(i, v);
  71 }
  72 
  73 static inline long
  74 atomic_long_add_return_relaxed(long i, atomic_long_t *v)
  75 {
  76         return atomic64_add_return_relaxed(i, v);
  77 }
  78 
  79 static inline long
  80 atomic_long_fetch_add(long i, atomic_long_t *v)
  81 {
  82         return atomic64_fetch_add(i, v);
  83 }
  84 
  85 static inline long
  86 atomic_long_fetch_add_acquire(long i, atomic_long_t *v)
  87 {
  88         return atomic64_fetch_add_acquire(i, v);
  89 }
  90 
  91 static inline long
  92 atomic_long_fetch_add_release(long i, atomic_long_t *v)
  93 {
  94         return atomic64_fetch_add_release(i, v);
  95 }
  96 
  97 static inline long
  98 atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)
  99 {
 100         return atomic64_fetch_add_relaxed(i, v);
 101 }
 102 
 103 static inline void
 104 atomic_long_sub(long i, atomic_long_t *v)
 105 {
 106         atomic64_sub(i, v);
 107 }
 108 
 109 static inline long
 110 atomic_long_sub_return(long i, atomic_long_t *v)
 111 {
 112         return atomic64_sub_return(i, v);
 113 }
 114 
 115 static inline long
 116 atomic_long_sub_return_acquire(long i, atomic_long_t *v)
 117 {
 118         return atomic64_sub_return_acquire(i, v);
 119 }
 120 
 121 static inline long
 122 atomic_long_sub_return_release(long i, atomic_long_t *v)
 123 {
 124         return atomic64_sub_return_release(i, v);
 125 }
 126 
 127 static inline long
 128 atomic_long_sub_return_relaxed(long i, atomic_long_t *v)
 129 {
 130         return atomic64_sub_return_relaxed(i, v);
 131 }
 132 
 133 static inline long
 134 atomic_long_fetch_sub(long i, atomic_long_t *v)
 135 {
 136         return atomic64_fetch_sub(i, v);
 137 }
 138 
 139 static inline long
 140 atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)
 141 {
 142         return atomic64_fetch_sub_acquire(i, v);
 143 }
 144 
 145 static inline long
 146 atomic_long_fetch_sub_release(long i, atomic_long_t *v)
 147 {
 148         return atomic64_fetch_sub_release(i, v);
 149 }
 150 
 151 static inline long
 152 atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)
 153 {
 154         return atomic64_fetch_sub_relaxed(i, v);
 155 }
 156 
 157 static inline void
 158 atomic_long_inc(atomic_long_t *v)
 159 {
 160         atomic64_inc(v);
 161 }
 162 
 163 static inline long
 164 atomic_long_inc_return(atomic_long_t *v)
 165 {
 166         return atomic64_inc_return(v);
 167 }
 168 
 169 static inline long
 170 atomic_long_inc_return_acquire(atomic_long_t *v)
 171 {
 172         return atomic64_inc_return_acquire(v);
 173 }
 174 
 175 static inline long
 176 atomic_long_inc_return_release(atomic_long_t *v)
 177 {
 178         return atomic64_inc_return_release(v);
 179 }
 180 
 181 static inline long
 182 atomic_long_inc_return_relaxed(atomic_long_t *v)
 183 {
 184         return atomic64_inc_return_relaxed(v);
 185 }
 186 
 187 static inline long
 188 atomic_long_fetch_inc(atomic_long_t *v)
 189 {
 190         return atomic64_fetch_inc(v);
 191 }
 192 
 193 static inline long
 194 atomic_long_fetch_inc_acquire(atomic_long_t *v)
 195 {
 196         return atomic64_fetch_inc_acquire(v);
 197 }
 198 
 199 static inline long
 200 atomic_long_fetch_inc_release(atomic_long_t *v)
 201 {
 202         return atomic64_fetch_inc_release(v);
 203 }
 204 
 205 static inline long
 206 atomic_long_fetch_inc_relaxed(atomic_long_t *v)
 207 {
 208         return atomic64_fetch_inc_relaxed(v);
 209 }
 210 
 211 static inline void
 212 atomic_long_dec(atomic_long_t *v)
 213 {
 214         atomic64_dec(v);
 215 }
 216 
 217 static inline long
 218 atomic_long_dec_return(atomic_long_t *v)
 219 {
 220         return atomic64_dec_return(v);
 221 }
 222 
 223 static inline long
 224 atomic_long_dec_return_acquire(atomic_long_t *v)
 225 {
 226         return atomic64_dec_return_acquire(v);
 227 }
 228 
 229 static inline long
 230 atomic_long_dec_return_release(atomic_long_t *v)
 231 {
 232         return atomic64_dec_return_release(v);
 233 }
 234 
 235 static inline long
 236 atomic_long_dec_return_relaxed(atomic_long_t *v)
 237 {
 238         return atomic64_dec_return_relaxed(v);
 239 }
 240 
 241 static inline long
 242 atomic_long_fetch_dec(atomic_long_t *v)
 243 {
 244         return atomic64_fetch_dec(v);
 245 }
 246 
 247 static inline long
 248 atomic_long_fetch_dec_acquire(atomic_long_t *v)
 249 {
 250         return atomic64_fetch_dec_acquire(v);
 251 }
 252 
 253 static inline long
 254 atomic_long_fetch_dec_release(atomic_long_t *v)
 255 {
 256         return atomic64_fetch_dec_release(v);
 257 }
 258 
 259 static inline long
 260 atomic_long_fetch_dec_relaxed(atomic_long_t *v)
 261 {
 262         return atomic64_fetch_dec_relaxed(v);
 263 }
 264 
 265 static inline void
 266 atomic_long_and(long i, atomic_long_t *v)
 267 {
 268         atomic64_and(i, v);
 269 }
 270 
 271 static inline long
 272 atomic_long_fetch_and(long i, atomic_long_t *v)
 273 {
 274         return atomic64_fetch_and(i, v);
 275 }
 276 
 277 static inline long
 278 atomic_long_fetch_and_acquire(long i, atomic_long_t *v)
 279 {
 280         return atomic64_fetch_and_acquire(i, v);
 281 }
 282 
 283 static inline long
 284 atomic_long_fetch_and_release(long i, atomic_long_t *v)
 285 {
 286         return atomic64_fetch_and_release(i, v);
 287 }
 288 
 289 static inline long
 290 atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)
 291 {
 292         return atomic64_fetch_and_relaxed(i, v);
 293 }
 294 
 295 static inline void
 296 atomic_long_andnot(long i, atomic_long_t *v)
 297 {
 298         atomic64_andnot(i, v);
 299 }
 300 
 301 static inline long
 302 atomic_long_fetch_andnot(long i, atomic_long_t *v)
 303 {
 304         return atomic64_fetch_andnot(i, v);
 305 }
 306 
 307 static inline long
 308 atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)
 309 {
 310         return atomic64_fetch_andnot_acquire(i, v);
 311 }
 312 
 313 static inline long
 314 atomic_long_fetch_andnot_release(long i, atomic_long_t *v)
 315 {
 316         return atomic64_fetch_andnot_release(i, v);
 317 }
 318 
 319 static inline long
 320 atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)
 321 {
 322         return atomic64_fetch_andnot_relaxed(i, v);
 323 }
 324 
 325 static inline void
 326 atomic_long_or(long i, atomic_long_t *v)
 327 {
 328         atomic64_or(i, v);
 329 }
 330 
 331 static inline long
 332 atomic_long_fetch_or(long i, atomic_long_t *v)
 333 {
 334         return atomic64_fetch_or(i, v);
 335 }
 336 
 337 static inline long
 338 atomic_long_fetch_or_acquire(long i, atomic_long_t *v)
 339 {
 340         return atomic64_fetch_or_acquire(i, v);
 341 }
 342 
 343 static inline long
 344 atomic_long_fetch_or_release(long i, atomic_long_t *v)
 345 {
 346         return atomic64_fetch_or_release(i, v);
 347 }
 348 
 349 static inline long
 350 atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)
 351 {
 352         return atomic64_fetch_or_relaxed(i, v);
 353 }
 354 
 355 static inline void
 356 atomic_long_xor(long i, atomic_long_t *v)
 357 {
 358         atomic64_xor(i, v);
 359 }
 360 
 361 static inline long
 362 atomic_long_fetch_xor(long i, atomic_long_t *v)
 363 {
 364         return atomic64_fetch_xor(i, v);
 365 }
 366 
 367 static inline long
 368 atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)
 369 {
 370         return atomic64_fetch_xor_acquire(i, v);
 371 }
 372 
 373 static inline long
 374 atomic_long_fetch_xor_release(long i, atomic_long_t *v)
 375 {
 376         return atomic64_fetch_xor_release(i, v);
 377 }
 378 
 379 static inline long
 380 atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)
 381 {
 382         return atomic64_fetch_xor_relaxed(i, v);
 383 }
 384 
 385 static inline long
 386 atomic_long_xchg(atomic_long_t *v, long i)
 387 {
 388         return atomic64_xchg(v, i);
 389 }
 390 
 391 static inline long
 392 atomic_long_xchg_acquire(atomic_long_t *v, long i)
 393 {
 394         return atomic64_xchg_acquire(v, i);
 395 }
 396 
 397 static inline long
 398 atomic_long_xchg_release(atomic_long_t *v, long i)
 399 {
 400         return atomic64_xchg_release(v, i);
 401 }
 402 
 403 static inline long
 404 atomic_long_xchg_relaxed(atomic_long_t *v, long i)
 405 {
 406         return atomic64_xchg_relaxed(v, i);
 407 }
 408 
 409 static inline long
 410 atomic_long_cmpxchg(atomic_long_t *v, long old, long new)
 411 {
 412         return atomic64_cmpxchg(v, old, new);
 413 }
 414 
 415 static inline long
 416 atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)
 417 {
 418         return atomic64_cmpxchg_acquire(v, old, new);
 419 }
 420 
 421 static inline long
 422 atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)
 423 {
 424         return atomic64_cmpxchg_release(v, old, new);
 425 }
 426 
 427 static inline long
 428 atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)
 429 {
 430         return atomic64_cmpxchg_relaxed(v, old, new);
 431 }
 432 
 433 static inline bool
 434 atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)
 435 {
 436         return atomic64_try_cmpxchg(v, (s64 *)old, new);
 437 }
 438 
 439 static inline bool
 440 atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)
 441 {
 442         return atomic64_try_cmpxchg_acquire(v, (s64 *)old, new);
 443 }
 444 
 445 static inline bool
 446 atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)
 447 {
 448         return atomic64_try_cmpxchg_release(v, (s64 *)old, new);
 449 }
 450 
 451 static inline bool
 452 atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)
 453 {
 454         return atomic64_try_cmpxchg_relaxed(v, (s64 *)old, new);
 455 }
 456 
 457 static inline bool
 458 atomic_long_sub_and_test(long i, atomic_long_t *v)
 459 {
 460         return atomic64_sub_and_test(i, v);
 461 }
 462 
 463 static inline bool
 464 atomic_long_dec_and_test(atomic_long_t *v)
 465 {
 466         return atomic64_dec_and_test(v);
 467 }
 468 
 469 static inline bool
 470 atomic_long_inc_and_test(atomic_long_t *v)
 471 {
 472         return atomic64_inc_and_test(v);
 473 }
 474 
 475 static inline bool
 476 atomic_long_add_negative(long i, atomic_long_t *v)
 477 {
 478         return atomic64_add_negative(i, v);
 479 }
 480 
 481 static inline long
 482 atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)
 483 {
 484         return atomic64_fetch_add_unless(v, a, u);
 485 }
 486 
 487 static inline bool
 488 atomic_long_add_unless(atomic_long_t *v, long a, long u)
 489 {
 490         return atomic64_add_unless(v, a, u);
 491 }
 492 
 493 static inline bool
 494 atomic_long_inc_not_zero(atomic_long_t *v)
 495 {
 496         return atomic64_inc_not_zero(v);
 497 }
 498 
 499 static inline bool
 500 atomic_long_inc_unless_negative(atomic_long_t *v)
 501 {
 502         return atomic64_inc_unless_negative(v);
 503 }
 504 
 505 static inline bool
 506 atomic_long_dec_unless_positive(atomic_long_t *v)
 507 {
 508         return atomic64_dec_unless_positive(v);
 509 }
 510 
 511 static inline long
 512 atomic_long_dec_if_positive(atomic_long_t *v)
 513 {
 514         return atomic64_dec_if_positive(v);
 515 }
 516 
 517 #else /* CONFIG_64BIT */
 518 
 519 static inline long
 520 atomic_long_read(const atomic_long_t *v)
 521 {
 522         return atomic_read(v);
 523 }
 524 
 525 static inline long
 526 atomic_long_read_acquire(const atomic_long_t *v)
 527 {
 528         return atomic_read_acquire(v);
 529 }
 530 
 531 static inline void
 532 atomic_long_set(atomic_long_t *v, long i)
 533 {
 534         atomic_set(v, i);
 535 }
 536 
 537 static inline void
 538 atomic_long_set_release(atomic_long_t *v, long i)
 539 {
 540         atomic_set_release(v, i);
 541 }
 542 
 543 static inline void
 544 atomic_long_add(long i, atomic_long_t *v)
 545 {
 546         atomic_add(i, v);
 547 }
 548 
 549 static inline long
 550 atomic_long_add_return(long i, atomic_long_t *v)
 551 {
 552         return atomic_add_return(i, v);
 553 }
 554 
 555 static inline long
 556 atomic_long_add_return_acquire(long i, atomic_long_t *v)
 557 {
 558         return atomic_add_return_acquire(i, v);
 559 }
 560 
 561 static inline long
 562 atomic_long_add_return_release(long i, atomic_long_t *v)
 563 {
 564         return atomic_add_return_release(i, v);
 565 }
 566 
 567 static inline long
 568 atomic_long_add_return_relaxed(long i, atomic_long_t *v)
 569 {
 570         return atomic_add_return_relaxed(i, v);
 571 }
 572 
 573 static inline long
 574 atomic_long_fetch_add(long i, atomic_long_t *v)
 575 {
 576         return atomic_fetch_add(i, v);
 577 }
 578 
 579 static inline long
 580 atomic_long_fetch_add_acquire(long i, atomic_long_t *v)
 581 {
 582         return atomic_fetch_add_acquire(i, v);
 583 }
 584 
 585 static inline long
 586 atomic_long_fetch_add_release(long i, atomic_long_t *v)
 587 {
 588         return atomic_fetch_add_release(i, v);
 589 }
 590 
 591 static inline long
 592 atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)
 593 {
 594         return atomic_fetch_add_relaxed(i, v);
 595 }
 596 
 597 static inline void
 598 atomic_long_sub(long i, atomic_long_t *v)
 599 {
 600         atomic_sub(i, v);
 601 }
 602 
 603 static inline long
 604 atomic_long_sub_return(long i, atomic_long_t *v)
 605 {
 606         return atomic_sub_return(i, v);
 607 }
 608 
 609 static inline long
 610 atomic_long_sub_return_acquire(long i, atomic_long_t *v)
 611 {
 612         return atomic_sub_return_acquire(i, v);
 613 }
 614 
 615 static inline long
 616 atomic_long_sub_return_release(long i, atomic_long_t *v)
 617 {
 618         return atomic_sub_return_release(i, v);
 619 }
 620 
 621 static inline long
 622 atomic_long_sub_return_relaxed(long i, atomic_long_t *v)
 623 {
 624         return atomic_sub_return_relaxed(i, v);
 625 }
 626 
 627 static inline long
 628 atomic_long_fetch_sub(long i, atomic_long_t *v)
 629 {
 630         return atomic_fetch_sub(i, v);
 631 }
 632 
 633 static inline long
 634 atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)
 635 {
 636         return atomic_fetch_sub_acquire(i, v);
 637 }
 638 
 639 static inline long
 640 atomic_long_fetch_sub_release(long i, atomic_long_t *v)
 641 {
 642         return atomic_fetch_sub_release(i, v);
 643 }
 644 
 645 static inline long
 646 atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)
 647 {
 648         return atomic_fetch_sub_relaxed(i, v);
 649 }
 650 
 651 static inline void
 652 atomic_long_inc(atomic_long_t *v)
 653 {
 654         atomic_inc(v);
 655 }
 656 
 657 static inline long
 658 atomic_long_inc_return(atomic_long_t *v)
 659 {
 660         return atomic_inc_return(v);
 661 }
 662 
 663 static inline long
 664 atomic_long_inc_return_acquire(atomic_long_t *v)
 665 {
 666         return atomic_inc_return_acquire(v);
 667 }
 668 
 669 static inline long
 670 atomic_long_inc_return_release(atomic_long_t *v)
 671 {
 672         return atomic_inc_return_release(v);
 673 }
 674 
 675 static inline long
 676 atomic_long_inc_return_relaxed(atomic_long_t *v)
 677 {
 678         return atomic_inc_return_relaxed(v);
 679 }
 680 
 681 static inline long
 682 atomic_long_fetch_inc(atomic_long_t *v)
 683 {
 684         return atomic_fetch_inc(v);
 685 }
 686 
 687 static inline long
 688 atomic_long_fetch_inc_acquire(atomic_long_t *v)
 689 {
 690         return atomic_fetch_inc_acquire(v);
 691 }
 692 
 693 static inline long
 694 atomic_long_fetch_inc_release(atomic_long_t *v)
 695 {
 696         return atomic_fetch_inc_release(v);
 697 }
 698 
 699 static inline long
 700 atomic_long_fetch_inc_relaxed(atomic_long_t *v)
 701 {
 702         return atomic_fetch_inc_relaxed(v);
 703 }
 704 
 705 static inline void
 706 atomic_long_dec(atomic_long_t *v)
 707 {
 708         atomic_dec(v);
 709 }
 710 
 711 static inline long
 712 atomic_long_dec_return(atomic_long_t *v)
 713 {
 714         return atomic_dec_return(v);
 715 }
 716 
 717 static inline long
 718 atomic_long_dec_return_acquire(atomic_long_t *v)
 719 {
 720         return atomic_dec_return_acquire(v);
 721 }
 722 
 723 static inline long
 724 atomic_long_dec_return_release(atomic_long_t *v)
 725 {
 726         return atomic_dec_return_release(v);
 727 }
 728 
 729 static inline long
 730 atomic_long_dec_return_relaxed(atomic_long_t *v)
 731 {
 732         return atomic_dec_return_relaxed(v);
 733 }
 734 
 735 static inline long
 736 atomic_long_fetch_dec(atomic_long_t *v)
 737 {
 738         return atomic_fetch_dec(v);
 739 }
 740 
 741 static inline long
 742 atomic_long_fetch_dec_acquire(atomic_long_t *v)
 743 {
 744         return atomic_fetch_dec_acquire(v);
 745 }
 746 
 747 static inline long
 748 atomic_long_fetch_dec_release(atomic_long_t *v)
 749 {
 750         return atomic_fetch_dec_release(v);
 751 }
 752 
 753 static inline long
 754 atomic_long_fetch_dec_relaxed(atomic_long_t *v)
 755 {
 756         return atomic_fetch_dec_relaxed(v);
 757 }
 758 
 759 static inline void
 760 atomic_long_and(long i, atomic_long_t *v)
 761 {
 762         atomic_and(i, v);
 763 }
 764 
 765 static inline long
 766 atomic_long_fetch_and(long i, atomic_long_t *v)
 767 {
 768         return atomic_fetch_and(i, v);
 769 }
 770 
 771 static inline long
 772 atomic_long_fetch_and_acquire(long i, atomic_long_t *v)
 773 {
 774         return atomic_fetch_and_acquire(i, v);
 775 }
 776 
 777 static inline long
 778 atomic_long_fetch_and_release(long i, atomic_long_t *v)
 779 {
 780         return atomic_fetch_and_release(i, v);
 781 }
 782 
 783 static inline long
 784 atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)
 785 {
 786         return atomic_fetch_and_relaxed(i, v);
 787 }
 788 
 789 static inline void
 790 atomic_long_andnot(long i, atomic_long_t *v)
 791 {
 792         atomic_andnot(i, v);
 793 }
 794 
 795 static inline long
 796 atomic_long_fetch_andnot(long i, atomic_long_t *v)
 797 {
 798         return atomic_fetch_andnot(i, v);
 799 }
 800 
 801 static inline long
 802 atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)
 803 {
 804         return atomic_fetch_andnot_acquire(i, v);
 805 }
 806 
 807 static inline long
 808 atomic_long_fetch_andnot_release(long i, atomic_long_t *v)
 809 {
 810         return atomic_fetch_andnot_release(i, v);
 811 }
 812 
 813 static inline long
 814 atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)
 815 {
 816         return atomic_fetch_andnot_relaxed(i, v);
 817 }
 818 
 819 static inline void
 820 atomic_long_or(long i, atomic_long_t *v)
 821 {
 822         atomic_or(i, v);
 823 }
 824 
 825 static inline long
 826 atomic_long_fetch_or(long i, atomic_long_t *v)
 827 {
 828         return atomic_fetch_or(i, v);
 829 }
 830 
 831 static inline long
 832 atomic_long_fetch_or_acquire(long i, atomic_long_t *v)
 833 {
 834         return atomic_fetch_or_acquire(i, v);
 835 }
 836 
 837 static inline long
 838 atomic_long_fetch_or_release(long i, atomic_long_t *v)
 839 {
 840         return atomic_fetch_or_release(i, v);
 841 }
 842 
 843 static inline long
 844 atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)
 845 {
 846         return atomic_fetch_or_relaxed(i, v);
 847 }
 848 
 849 static inline void
 850 atomic_long_xor(long i, atomic_long_t *v)
 851 {
 852         atomic_xor(i, v);
 853 }
 854 
 855 static inline long
 856 atomic_long_fetch_xor(long i, atomic_long_t *v)
 857 {
 858         return atomic_fetch_xor(i, v);
 859 }
 860 
 861 static inline long
 862 atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)
 863 {
 864         return atomic_fetch_xor_acquire(i, v);
 865 }
 866 
 867 static inline long
 868 atomic_long_fetch_xor_release(long i, atomic_long_t *v)
 869 {
 870         return atomic_fetch_xor_release(i, v);
 871 }
 872 
 873 static inline long
 874 atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)
 875 {
 876         return atomic_fetch_xor_relaxed(i, v);
 877 }
 878 
 879 static inline long
 880 atomic_long_xchg(atomic_long_t *v, long i)
 881 {
 882         return atomic_xchg(v, i);
 883 }
 884 
 885 static inline long
 886 atomic_long_xchg_acquire(atomic_long_t *v, long i)
 887 {
 888         return atomic_xchg_acquire(v, i);
 889 }
 890 
 891 static inline long
 892 atomic_long_xchg_release(atomic_long_t *v, long i)
 893 {
 894         return atomic_xchg_release(v, i);
 895 }
 896 
 897 static inline long
 898 atomic_long_xchg_relaxed(atomic_long_t *v, long i)
 899 {
 900         return atomic_xchg_relaxed(v, i);
 901 }
 902 
 903 static inline long
 904 atomic_long_cmpxchg(atomic_long_t *v, long old, long new)
 905 {
 906         return atomic_cmpxchg(v, old, new);
 907 }
 908 
 909 static inline long
 910 atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)
 911 {
 912         return atomic_cmpxchg_acquire(v, old, new);
 913 }
 914 
 915 static inline long
 916 atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)
 917 {
 918         return atomic_cmpxchg_release(v, old, new);
 919 }
 920 
 921 static inline long
 922 atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)
 923 {
 924         return atomic_cmpxchg_relaxed(v, old, new);
 925 }
 926 
 927 static inline bool
 928 atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)
 929 {
 930         return atomic_try_cmpxchg(v, (int *)old, new);
 931 }
 932 
 933 static inline bool
 934 atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)
 935 {
 936         return atomic_try_cmpxchg_acquire(v, (int *)old, new);
 937 }
 938 
 939 static inline bool
 940 atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)
 941 {
 942         return atomic_try_cmpxchg_release(v, (int *)old, new);
 943 }
 944 
 945 static inline bool
 946 atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)
 947 {
 948         return atomic_try_cmpxchg_relaxed(v, (int *)old, new);
 949 }
 950 
 951 static inline bool
 952 atomic_long_sub_and_test(long i, atomic_long_t *v)
 953 {
 954         return atomic_sub_and_test(i, v);
 955 }
 956 
 957 static inline bool
 958 atomic_long_dec_and_test(atomic_long_t *v)
 959 {
 960         return atomic_dec_and_test(v);
 961 }
 962 
 963 static inline bool
 964 atomic_long_inc_and_test(atomic_long_t *v)
 965 {
 966         return atomic_inc_and_test(v);
 967 }
 968 
 969 static inline bool
 970 atomic_long_add_negative(long i, atomic_long_t *v)
 971 {
 972         return atomic_add_negative(i, v);
 973 }
 974 
 975 static inline long
 976 atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)
 977 {
 978         return atomic_fetch_add_unless(v, a, u);
 979 }
 980 
 981 static inline bool
 982 atomic_long_add_unless(atomic_long_t *v, long a, long u)
 983 {
 984         return atomic_add_unless(v, a, u);
 985 }
 986 
 987 static inline bool
 988 atomic_long_inc_not_zero(atomic_long_t *v)
 989 {
 990         return atomic_inc_not_zero(v);
 991 }
 992 
 993 static inline bool
 994 atomic_long_inc_unless_negative(atomic_long_t *v)
 995 {
 996         return atomic_inc_unless_negative(v);
 997 }
 998 
 999 static inline bool
1000 atomic_long_dec_unless_positive(atomic_long_t *v)
1001 {
1002         return atomic_dec_unless_positive(v);
1003 }
1004 
1005 static inline long
1006 atomic_long_dec_if_positive(atomic_long_t *v)
1007 {
1008         return atomic_dec_if_positive(v);
1009 }
1010 
1011 #endif /* CONFIG_64BIT */
1012 #endif /* _ASM_GENERIC_ATOMIC_LONG_H */
1013 // 77558968132ce4f911ad53f6f52ce423006f6268
/* [<][>][^][v][top][bottom][index][help] */