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 _LINUX_ATOMIC_LONG_H 7#define _LINUX_ATOMIC_LONG_H 8 9#include <linux/compiler.h> 10#include <asm/types.h> 11 12#ifdef CONFIG_64BIT 13typedef atomic64_t atomic_long_t; 14#define ATOMIC_LONG_INIT(i) ATOMIC64_INIT(i) 15#define atomic_long_cond_read_acquire atomic64_cond_read_acquire 16#define atomic_long_cond_read_relaxed atomic64_cond_read_relaxed 17#else 18typedef atomic_t atomic_long_t; 19#define ATOMIC_LONG_INIT(i) ATOMIC_INIT(i) 20#define atomic_long_cond_read_acquire atomic_cond_read_acquire 21#define atomic_long_cond_read_relaxed atomic_cond_read_relaxed 22#endif 23 24/** 25 * raw_atomic_long_read() - atomic load with relaxed ordering 26 * @v: pointer to atomic_long_t 27 * 28 * Atomically loads the value of @v with relaxed ordering. 29 * 30 * Safe to use in noinstr code; prefer atomic_long_read() elsewhere. 31 * 32 * Return: The value loaded from @v. 33 */ 34static __always_inline long 35raw_atomic_long_read(const atomic_long_t *v) 36{ 37#ifdef CONFIG_64BIT 38 return raw_atomic64_read(v); 39#else 40 return raw_atomic_read(v); 41#endif 42} 43 44/** 45 * raw_atomic_long_read_acquire() - atomic load with acquire ordering 46 * @v: pointer to atomic_long_t 47 * 48 * Atomically loads the value of @v with acquire ordering. 49 * 50 * Safe to use in noinstr code; prefer atomic_long_read_acquire() elsewhere. 51 * 52 * Return: The value loaded from @v. 53 */ 54static __always_inline long 55raw_atomic_long_read_acquire(const atomic_long_t *v) 56{ 57#ifdef CONFIG_64BIT 58 return raw_atomic64_read_acquire(v); 59#else 60 return raw_atomic_read_acquire(v); 61#endif 62} 63 64/** 65 * raw_atomic_long_set() - atomic set with relaxed ordering 66 * @v: pointer to atomic_long_t 67 * @i: long value to assign 68 * 69 * Atomically sets @v to @i with relaxed ordering. 70 * 71 * Safe to use in noinstr code; prefer atomic_long_set() elsewhere. 72 * 73 * Return: Nothing. 74 */ 75static __always_inline void 76raw_atomic_long_set(atomic_long_t *v, long i) 77{ 78#ifdef CONFIG_64BIT 79 raw_atomic64_set(v, i); 80#else 81 raw_atomic_set(v, i); 82#endif 83} 84 85/** 86 * raw_atomic_long_set_release() - atomic set with release ordering 87 * @v: pointer to atomic_long_t 88 * @i: long value to assign 89 * 90 * Atomically sets @v to @i with release ordering. 91 * 92 * Safe to use in noinstr code; prefer atomic_long_set_release() elsewhere. 93 * 94 * Return: Nothing. 95 */ 96static __always_inline void 97raw_atomic_long_set_release(atomic_long_t *v, long i) 98{ 99#ifdef CONFIG_64BIT 100 raw_atomic64_set_release(v, i); 101#else 102 raw_atomic_set_release(v, i); 103#endif 104} 105 106/** 107 * raw_atomic_long_add() - atomic add with relaxed ordering 108 * @i: long value to add 109 * @v: pointer to atomic_long_t 110 * 111 * Atomically updates @v to (@v + @i) with relaxed ordering. 112 * 113 * Safe to use in noinstr code; prefer atomic_long_add() elsewhere. 114 * 115 * Return: Nothing. 116 */ 117static __always_inline void 118raw_atomic_long_add(long i, atomic_long_t *v) 119{ 120#ifdef CONFIG_64BIT 121 raw_atomic64_add(i, v); 122#else 123 raw_atomic_add(i, v); 124#endif 125} 126 127/** 128 * raw_atomic_long_add_return() - atomic add with full ordering 129 * @i: long value to add 130 * @v: pointer to atomic_long_t 131 * 132 * Atomically updates @v to (@v + @i) with full ordering. 133 * 134 * Safe to use in noinstr code; prefer atomic_long_add_return() elsewhere. 135 * 136 * Return: The updated value of @v. 137 */ 138static __always_inline long 139raw_atomic_long_add_return(long i, atomic_long_t *v) 140{ 141#ifdef CONFIG_64BIT 142 return raw_atomic64_add_return(i, v); 143#else 144 return raw_atomic_add_return(i, v); 145#endif 146} 147 148/** 149 * raw_atomic_long_add_return_acquire() - atomic add with acquire ordering 150 * @i: long value to add 151 * @v: pointer to atomic_long_t 152 * 153 * Atomically updates @v to (@v + @i) with acquire ordering. 154 * 155 * Safe to use in noinstr code; prefer atomic_long_add_return_acquire() elsewhere. 156 * 157 * Return: The updated value of @v. 158 */ 159static __always_inline long 160raw_atomic_long_add_return_acquire(long i, atomic_long_t *v) 161{ 162#ifdef CONFIG_64BIT 163 return raw_atomic64_add_return_acquire(i, v); 164#else 165 return raw_atomic_add_return_acquire(i, v); 166#endif 167} 168 169/** 170 * raw_atomic_long_add_return_release() - atomic add with release ordering 171 * @i: long value to add 172 * @v: pointer to atomic_long_t 173 * 174 * Atomically updates @v to (@v + @i) with release ordering. 175 * 176 * Safe to use in noinstr code; prefer atomic_long_add_return_release() elsewhere. 177 * 178 * Return: The updated value of @v. 179 */ 180static __always_inline long 181raw_atomic_long_add_return_release(long i, atomic_long_t *v) 182{ 183#ifdef CONFIG_64BIT 184 return raw_atomic64_add_return_release(i, v); 185#else 186 return raw_atomic_add_return_release(i, v); 187#endif 188} 189 190/** 191 * raw_atomic_long_add_return_relaxed() - atomic add with relaxed ordering 192 * @i: long value to add 193 * @v: pointer to atomic_long_t 194 * 195 * Atomically updates @v to (@v + @i) with relaxed ordering. 196 * 197 * Safe to use in noinstr code; prefer atomic_long_add_return_relaxed() elsewhere. 198 * 199 * Return: The updated value of @v. 200 */ 201static __always_inline long 202raw_atomic_long_add_return_relaxed(long i, atomic_long_t *v) 203{ 204#ifdef CONFIG_64BIT 205 return raw_atomic64_add_return_relaxed(i, v); 206#else 207 return raw_atomic_add_return_relaxed(i, v); 208#endif 209} 210 211/** 212 * raw_atomic_long_fetch_add() - atomic add with full ordering 213 * @i: long value to add 214 * @v: pointer to atomic_long_t 215 * 216 * Atomically updates @v to (@v + @i) with full ordering. 217 * 218 * Safe to use in noinstr code; prefer atomic_long_fetch_add() elsewhere. 219 * 220 * Return: The original value of @v. 221 */ 222static __always_inline long 223raw_atomic_long_fetch_add(long i, atomic_long_t *v) 224{ 225#ifdef CONFIG_64BIT 226 return raw_atomic64_fetch_add(i, v); 227#else 228 return raw_atomic_fetch_add(i, v); 229#endif 230} 231 232/** 233 * raw_atomic_long_fetch_add_acquire() - atomic add with acquire ordering 234 * @i: long value to add 235 * @v: pointer to atomic_long_t 236 * 237 * Atomically updates @v to (@v + @i) with acquire ordering. 238 * 239 * Safe to use in noinstr code; prefer atomic_long_fetch_add_acquire() elsewhere. 240 * 241 * Return: The original value of @v. 242 */ 243static __always_inline long 244raw_atomic_long_fetch_add_acquire(long i, atomic_long_t *v) 245{ 246#ifdef CONFIG_64BIT 247 return raw_atomic64_fetch_add_acquire(i, v); 248#else 249 return raw_atomic_fetch_add_acquire(i, v); 250#endif 251} 252 253/** 254 * raw_atomic_long_fetch_add_release() - atomic add with release ordering 255 * @i: long value to add 256 * @v: pointer to atomic_long_t 257 * 258 * Atomically updates @v to (@v + @i) with release ordering. 259 * 260 * Safe to use in noinstr code; prefer atomic_long_fetch_add_release() elsewhere. 261 * 262 * Return: The original value of @v. 263 */ 264static __always_inline long 265raw_atomic_long_fetch_add_release(long i, atomic_long_t *v) 266{ 267#ifdef CONFIG_64BIT 268 return raw_atomic64_fetch_add_release(i, v); 269#else 270 return raw_atomic_fetch_add_release(i, v); 271#endif 272} 273 274/** 275 * raw_atomic_long_fetch_add_relaxed() - atomic add with relaxed ordering 276 * @i: long value to add 277 * @v: pointer to atomic_long_t 278 * 279 * Atomically updates @v to (@v + @i) with relaxed ordering. 280 * 281 * Safe to use in noinstr code; prefer atomic_long_fetch_add_relaxed() elsewhere. 282 * 283 * Return: The original value of @v. 284 */ 285static __always_inline long 286raw_atomic_long_fetch_add_relaxed(long i, atomic_long_t *v) 287{ 288#ifdef CONFIG_64BIT 289 return raw_atomic64_fetch_add_relaxed(i, v); 290#else 291 return raw_atomic_fetch_add_relaxed(i, v); 292#endif 293} 294 295/** 296 * raw_atomic_long_sub() - atomic subtract with relaxed ordering 297 * @i: long value to subtract 298 * @v: pointer to atomic_long_t 299 * 300 * Atomically updates @v to (@v - @i) with relaxed ordering. 301 * 302 * Safe to use in noinstr code; prefer atomic_long_sub() elsewhere. 303 * 304 * Return: Nothing. 305 */ 306static __always_inline void 307raw_atomic_long_sub(long i, atomic_long_t *v) 308{ 309#ifdef CONFIG_64BIT 310 raw_atomic64_sub(i, v); 311#else 312 raw_atomic_sub(i, v); 313#endif 314} 315 316/** 317 * raw_atomic_long_sub_return() - atomic subtract with full ordering 318 * @i: long value to subtract 319 * @v: pointer to atomic_long_t 320 * 321 * Atomically updates @v to (@v - @i) with full ordering. 322 * 323 * Safe to use in noinstr code; prefer atomic_long_sub_return() elsewhere. 324 * 325 * Return: The updated value of @v. 326 */ 327static __always_inline long 328raw_atomic_long_sub_return(long i, atomic_long_t *v) 329{ 330#ifdef CONFIG_64BIT 331 return raw_atomic64_sub_return(i, v); 332#else 333 return raw_atomic_sub_return(i, v); 334#endif 335} 336 337/** 338 * raw_atomic_long_sub_return_acquire() - atomic subtract with acquire ordering 339 * @i: long value to subtract 340 * @v: pointer to atomic_long_t 341 * 342 * Atomically updates @v to (@v - @i) with acquire ordering. 343 * 344 * Safe to use in noinstr code; prefer atomic_long_sub_return_acquire() elsewhere. 345 * 346 * Return: The updated value of @v. 347 */ 348static __always_inline long 349raw_atomic_long_sub_return_acquire(long i, atomic_long_t *v) 350{ 351#ifdef CONFIG_64BIT 352 return raw_atomic64_sub_return_acquire(i, v); 353#else 354 return raw_atomic_sub_return_acquire(i, v); 355#endif 356} 357 358/** 359 * raw_atomic_long_sub_return_release() - atomic subtract with release ordering 360 * @i: long value to subtract 361 * @v: pointer to atomic_long_t 362 * 363 * Atomically updates @v to (@v - @i) with release ordering. 364 * 365 * Safe to use in noinstr code; prefer atomic_long_sub_return_release() elsewhere. 366 * 367 * Return: The updated value of @v. 368 */ 369static __always_inline long 370raw_atomic_long_sub_return_release(long i, atomic_long_t *v) 371{ 372#ifdef CONFIG_64BIT 373 return raw_atomic64_sub_return_release(i, v); 374#else 375 return raw_atomic_sub_return_release(i, v); 376#endif 377} 378 379/** 380 * raw_atomic_long_sub_return_relaxed() - atomic subtract with relaxed ordering 381 * @i: long value to subtract 382 * @v: pointer to atomic_long_t 383 * 384 * Atomically updates @v to (@v - @i) with relaxed ordering. 385 * 386 * Safe to use in noinstr code; prefer atomic_long_sub_return_relaxed() elsewhere. 387 * 388 * Return: The updated value of @v. 389 */ 390static __always_inline long 391raw_atomic_long_sub_return_relaxed(long i, atomic_long_t *v) 392{ 393#ifdef CONFIG_64BIT 394 return raw_atomic64_sub_return_relaxed(i, v); 395#else 396 return raw_atomic_sub_return_relaxed(i, v); 397#endif 398} 399 400/** 401 * raw_atomic_long_fetch_sub() - atomic subtract with full ordering 402 * @i: long value to subtract 403 * @v: pointer to atomic_long_t 404 * 405 * Atomically updates @v to (@v - @i) with full ordering. 406 * 407 * Safe to use in noinstr code; prefer atomic_long_fetch_sub() elsewhere. 408 * 409 * Return: The original value of @v. 410 */ 411static __always_inline long 412raw_atomic_long_fetch_sub(long i, atomic_long_t *v) 413{ 414#ifdef CONFIG_64BIT 415 return raw_atomic64_fetch_sub(i, v); 416#else 417 return raw_atomic_fetch_sub(i, v); 418#endif 419} 420 421/** 422 * raw_atomic_long_fetch_sub_acquire() - atomic subtract with acquire ordering 423 * @i: long value to subtract 424 * @v: pointer to atomic_long_t 425 * 426 * Atomically updates @v to (@v - @i) with acquire ordering. 427 * 428 * Safe to use in noinstr code; prefer atomic_long_fetch_sub_acquire() elsewhere. 429 * 430 * Return: The original value of @v. 431 */ 432static __always_inline long 433raw_atomic_long_fetch_sub_acquire(long i, atomic_long_t *v) 434{ 435#ifdef CONFIG_64BIT 436 return raw_atomic64_fetch_sub_acquire(i, v); 437#else 438 return raw_atomic_fetch_sub_acquire(i, v); 439#endif 440} 441 442/** 443 * raw_atomic_long_fetch_sub_release() - atomic subtract with release ordering 444 * @i: long value to subtract 445 * @v: pointer to atomic_long_t 446 * 447 * Atomically updates @v to (@v - @i) with release ordering. 448 * 449 * Safe to use in noinstr code; prefer atomic_long_fetch_sub_release() elsewhere. 450 * 451 * Return: The original value of @v. 452 */ 453static __always_inline long 454raw_atomic_long_fetch_sub_release(long i, atomic_long_t *v) 455{ 456#ifdef CONFIG_64BIT 457 return raw_atomic64_fetch_sub_release(i, v); 458#else 459 return raw_atomic_fetch_sub_release(i, v); 460#endif 461} 462 463/** 464 * raw_atomic_long_fetch_sub_relaxed() - atomic subtract with relaxed ordering 465 * @i: long value to subtract 466 * @v: pointer to atomic_long_t 467 * 468 * Atomically updates @v to (@v - @i) with relaxed ordering. 469 * 470 * Safe to use in noinstr code; prefer atomic_long_fetch_sub_relaxed() elsewhere. 471 * 472 * Return: The original value of @v. 473 */ 474static __always_inline long 475raw_atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v) 476{ 477#ifdef CONFIG_64BIT 478 return raw_atomic64_fetch_sub_relaxed(i, v); 479#else 480 return raw_atomic_fetch_sub_relaxed(i, v); 481#endif 482} 483 484/** 485 * raw_atomic_long_inc() - atomic increment with relaxed ordering 486 * @v: pointer to atomic_long_t 487 * 488 * Atomically updates @v to (@v + 1) with relaxed ordering. 489 * 490 * Safe to use in noinstr code; prefer atomic_long_inc() elsewhere. 491 * 492 * Return: Nothing. 493 */ 494static __always_inline void 495raw_atomic_long_inc(atomic_long_t *v) 496{ 497#ifdef CONFIG_64BIT 498 raw_atomic64_inc(v); 499#else 500 raw_atomic_inc(v); 501#endif 502} 503 504/** 505 * raw_atomic_long_inc_return() - atomic increment with full ordering 506 * @v: pointer to atomic_long_t 507 * 508 * Atomically updates @v to (@v + 1) with full ordering. 509 * 510 * Safe to use in noinstr code; prefer atomic_long_inc_return() elsewhere. 511 * 512 * Return: The updated value of @v. 513 */ 514static __always_inline long 515raw_atomic_long_inc_return(atomic_long_t *v) 516{ 517#ifdef CONFIG_64BIT 518 return raw_atomic64_inc_return(v); 519#else 520 return raw_atomic_inc_return(v); 521#endif 522} 523 524/** 525 * raw_atomic_long_inc_return_acquire() - atomic increment with acquire ordering 526 * @v: pointer to atomic_long_t 527 * 528 * Atomically updates @v to (@v + 1) with acquire ordering. 529 * 530 * Safe to use in noinstr code; prefer atomic_long_inc_return_acquire() elsewhere. 531 * 532 * Return: The updated value of @v. 533 */ 534static __always_inline long 535raw_atomic_long_inc_return_acquire(atomic_long_t *v) 536{ 537#ifdef CONFIG_64BIT 538 return raw_atomic64_inc_return_acquire(v); 539#else 540 return raw_atomic_inc_return_acquire(v); 541#endif 542} 543 544/** 545 * raw_atomic_long_inc_return_release() - atomic increment with release ordering 546 * @v: pointer to atomic_long_t 547 * 548 * Atomically updates @v to (@v + 1) with release ordering. 549 * 550 * Safe to use in noinstr code; prefer atomic_long_inc_return_release() elsewhere. 551 * 552 * Return: The updated value of @v. 553 */ 554static __always_inline long 555raw_atomic_long_inc_return_release(atomic_long_t *v) 556{ 557#ifdef CONFIG_64BIT 558 return raw_atomic64_inc_return_release(v); 559#else 560 return raw_atomic_inc_return_release(v); 561#endif 562} 563 564/** 565 * raw_atomic_long_inc_return_relaxed() - atomic increment with relaxed ordering 566 * @v: pointer to atomic_long_t 567 * 568 * Atomically updates @v to (@v + 1) with relaxed ordering. 569 * 570 * Safe to use in noinstr code; prefer atomic_long_inc_return_relaxed() elsewhere. 571 * 572 * Return: The updated value of @v. 573 */ 574static __always_inline long 575raw_atomic_long_inc_return_relaxed(atomic_long_t *v) 576{ 577#ifdef CONFIG_64BIT 578 return raw_atomic64_inc_return_relaxed(v); 579#else 580 return raw_atomic_inc_return_relaxed(v); 581#endif 582} 583 584/** 585 * raw_atomic_long_fetch_inc() - atomic increment with full ordering 586 * @v: pointer to atomic_long_t 587 * 588 * Atomically updates @v to (@v + 1) with full ordering. 589 * 590 * Safe to use in noinstr code; prefer atomic_long_fetch_inc() elsewhere. 591 * 592 * Return: The original value of @v. 593 */ 594static __always_inline long 595raw_atomic_long_fetch_inc(atomic_long_t *v) 596{ 597#ifdef CONFIG_64BIT 598 return raw_atomic64_fetch_inc(v); 599#else 600 return raw_atomic_fetch_inc(v); 601#endif 602} 603 604/** 605 * raw_atomic_long_fetch_inc_acquire() - atomic increment with acquire ordering 606 * @v: pointer to atomic_long_t 607 * 608 * Atomically updates @v to (@v + 1) with acquire ordering. 609 * 610 * Safe to use in noinstr code; prefer atomic_long_fetch_inc_acquire() elsewhere. 611 * 612 * Return: The original value of @v. 613 */ 614static __always_inline long 615raw_atomic_long_fetch_inc_acquire(atomic_long_t *v) 616{ 617#ifdef CONFIG_64BIT 618 return raw_atomic64_fetch_inc_acquire(v); 619#else 620 return raw_atomic_fetch_inc_acquire(v); 621#endif 622} 623 624/** 625 * raw_atomic_long_fetch_inc_release() - atomic increment with release ordering 626 * @v: pointer to atomic_long_t 627 * 628 * Atomically updates @v to (@v + 1) with release ordering. 629 * 630 * Safe to use in noinstr code; prefer atomic_long_fetch_inc_release() elsewhere. 631 * 632 * Return: The original value of @v. 633 */ 634static __always_inline long 635raw_atomic_long_fetch_inc_release(atomic_long_t *v) 636{ 637#ifdef CONFIG_64BIT 638 return raw_atomic64_fetch_inc_release(v); 639#else 640 return raw_atomic_fetch_inc_release(v); 641#endif 642} 643 644/** 645 * raw_atomic_long_fetch_inc_relaxed() - atomic increment with relaxed ordering 646 * @v: pointer to atomic_long_t 647 * 648 * Atomically updates @v to (@v + 1) with relaxed ordering. 649 * 650 * Safe to use in noinstr code; prefer atomic_long_fetch_inc_relaxed() elsewhere. 651 * 652 * Return: The original value of @v. 653 */ 654static __always_inline long 655raw_atomic_long_fetch_inc_relaxed(atomic_long_t *v) 656{ 657#ifdef CONFIG_64BIT 658 return raw_atomic64_fetch_inc_relaxed(v); 659#else 660 return raw_atomic_fetch_inc_relaxed(v); 661#endif 662} 663 664/** 665 * raw_atomic_long_dec() - atomic decrement with relaxed ordering 666 * @v: pointer to atomic_long_t 667 * 668 * Atomically updates @v to (@v - 1) with relaxed ordering. 669 * 670 * Safe to use in noinstr code; prefer atomic_long_dec() elsewhere. 671 * 672 * Return: Nothing. 673 */ 674static __always_inline void 675raw_atomic_long_dec(atomic_long_t *v) 676{ 677#ifdef CONFIG_64BIT 678 raw_atomic64_dec(v); 679#else 680 raw_atomic_dec(v); 681#endif 682} 683 684/** 685 * raw_atomic_long_dec_return() - atomic decrement with full ordering 686 * @v: pointer to atomic_long_t 687 * 688 * Atomically updates @v to (@v - 1) with full ordering. 689 * 690 * Safe to use in noinstr code; prefer atomic_long_dec_return() elsewhere. 691 * 692 * Return: The updated value of @v. 693 */ 694static __always_inline long 695raw_atomic_long_dec_return(atomic_long_t *v) 696{ 697#ifdef CONFIG_64BIT 698 return raw_atomic64_dec_return(v); 699#else 700 return raw_atomic_dec_return(v); 701#endif 702} 703 704/** 705 * raw_atomic_long_dec_return_acquire() - atomic decrement with acquire ordering 706 * @v: pointer to atomic_long_t 707 * 708 * Atomically updates @v to (@v - 1) with acquire ordering. 709 * 710 * Safe to use in noinstr code; prefer atomic_long_dec_return_acquire() elsewhere. 711 * 712 * Return: The updated value of @v. 713 */ 714static __always_inline long 715raw_atomic_long_dec_return_acquire(atomic_long_t *v) 716{ 717#ifdef CONFIG_64BIT 718 return raw_atomic64_dec_return_acquire(v); 719#else 720 return raw_atomic_dec_return_acquire(v); 721#endif 722} 723 724/** 725 * raw_atomic_long_dec_return_release() - atomic decrement with release ordering 726 * @v: pointer to atomic_long_t 727 * 728 * Atomically updates @v to (@v - 1) with release ordering. 729 * 730 * Safe to use in noinstr code; prefer atomic_long_dec_return_release() elsewhere. 731 * 732 * Return: The updated value of @v. 733 */ 734static __always_inline long 735raw_atomic_long_dec_return_release(atomic_long_t *v) 736{ 737#ifdef CONFIG_64BIT 738 return raw_atomic64_dec_return_release(v); 739#else 740 return raw_atomic_dec_return_release(v); 741#endif 742} 743 744/** 745 * raw_atomic_long_dec_return_relaxed() - atomic decrement with relaxed ordering 746 * @v: pointer to atomic_long_t 747 * 748 * Atomically updates @v to (@v - 1) with relaxed ordering. 749 * 750 * Safe to use in noinstr code; prefer atomic_long_dec_return_relaxed() elsewhere. 751 * 752 * Return: The updated value of @v. 753 */ 754static __always_inline long 755raw_atomic_long_dec_return_relaxed(atomic_long_t *v) 756{ 757#ifdef CONFIG_64BIT 758 return raw_atomic64_dec_return_relaxed(v); 759#else 760 return raw_atomic_dec_return_relaxed(v); 761#endif 762} 763 764/** 765 * raw_atomic_long_fetch_dec() - atomic decrement with full ordering 766 * @v: pointer to atomic_long_t 767 * 768 * Atomically updates @v to (@v - 1) with full ordering. 769 * 770 * Safe to use in noinstr code; prefer atomic_long_fetch_dec() elsewhere. 771 * 772 * Return: The original value of @v. 773 */ 774static __always_inline long 775raw_atomic_long_fetch_dec(atomic_long_t *v) 776{ 777#ifdef CONFIG_64BIT 778 return raw_atomic64_fetch_dec(v); 779#else 780 return raw_atomic_fetch_dec(v); 781#endif 782} 783 784/** 785 * raw_atomic_long_fetch_dec_acquire() - atomic decrement with acquire ordering 786 * @v: pointer to atomic_long_t 787 * 788 * Atomically updates @v to (@v - 1) with acquire ordering. 789 * 790 * Safe to use in noinstr code; prefer atomic_long_fetch_dec_acquire() elsewhere. 791 * 792 * Return: The original value of @v. 793 */ 794static __always_inline long 795raw_atomic_long_fetch_dec_acquire(atomic_long_t *v) 796{ 797#ifdef CONFIG_64BIT 798 return raw_atomic64_fetch_dec_acquire(v); 799#else 800 return raw_atomic_fetch_dec_acquire(v); 801#endif 802} 803 804/** 805 * raw_atomic_long_fetch_dec_release() - atomic decrement with release ordering 806 * @v: pointer to atomic_long_t 807 * 808 * Atomically updates @v to (@v - 1) with release ordering. 809 * 810 * Safe to use in noinstr code; prefer atomic_long_fetch_dec_release() elsewhere. 811 * 812 * Return: The original value of @v. 813 */ 814static __always_inline long 815raw_atomic_long_fetch_dec_release(atomic_long_t *v) 816{ 817#ifdef CONFIG_64BIT 818 return raw_atomic64_fetch_dec_release(v); 819#else 820 return raw_atomic_fetch_dec_release(v); 821#endif 822} 823 824/** 825 * raw_atomic_long_fetch_dec_relaxed() - atomic decrement with relaxed ordering 826 * @v: pointer to atomic_long_t 827 * 828 * Atomically updates @v to (@v - 1) with relaxed ordering. 829 * 830 * Safe to use in noinstr code; prefer atomic_long_fetch_dec_relaxed() elsewhere. 831 * 832 * Return: The original value of @v. 833 */ 834static __always_inline long 835raw_atomic_long_fetch_dec_relaxed(atomic_long_t *v) 836{ 837#ifdef CONFIG_64BIT 838 return raw_atomic64_fetch_dec_relaxed(v); 839#else 840 return raw_atomic_fetch_dec_relaxed(v); 841#endif 842} 843 844/** 845 * raw_atomic_long_and() - atomic bitwise AND with relaxed ordering 846 * @i: long value 847 * @v: pointer to atomic_long_t 848 * 849 * Atomically updates @v to (@v & @i) with relaxed ordering. 850 * 851 * Safe to use in noinstr code; prefer atomic_long_and() elsewhere. 852 * 853 * Return: Nothing. 854 */ 855static __always_inline void 856raw_atomic_long_and(long i, atomic_long_t *v) 857{ 858#ifdef CONFIG_64BIT 859 raw_atomic64_and(i, v); 860#else 861 raw_atomic_and(i, v); 862#endif 863} 864 865/** 866 * raw_atomic_long_fetch_and() - atomic bitwise AND with full ordering 867 * @i: long value 868 * @v: pointer to atomic_long_t 869 * 870 * Atomically updates @v to (@v & @i) with full ordering. 871 * 872 * Safe to use in noinstr code; prefer atomic_long_fetch_and() elsewhere. 873 * 874 * Return: The original value of @v. 875 */ 876static __always_inline long 877raw_atomic_long_fetch_and(long i, atomic_long_t *v) 878{ 879#ifdef CONFIG_64BIT 880 return raw_atomic64_fetch_and(i, v); 881#else 882 return raw_atomic_fetch_and(i, v); 883#endif 884} 885 886/** 887 * raw_atomic_long_fetch_and_acquire() - atomic bitwise AND with acquire ordering 888 * @i: long value 889 * @v: pointer to atomic_long_t 890 * 891 * Atomically updates @v to (@v & @i) with acquire ordering. 892 * 893 * Safe to use in noinstr code; prefer atomic_long_fetch_and_acquire() elsewhere. 894 * 895 * Return: The original value of @v. 896 */ 897static __always_inline long 898raw_atomic_long_fetch_and_acquire(long i, atomic_long_t *v) 899{ 900#ifdef CONFIG_64BIT 901 return raw_atomic64_fetch_and_acquire(i, v); 902#else 903 return raw_atomic_fetch_and_acquire(i, v); 904#endif 905} 906 907/** 908 * raw_atomic_long_fetch_and_release() - atomic bitwise AND with release ordering 909 * @i: long value 910 * @v: pointer to atomic_long_t 911 * 912 * Atomically updates @v to (@v & @i) with release ordering. 913 * 914 * Safe to use in noinstr code; prefer atomic_long_fetch_and_release() elsewhere. 915 * 916 * Return: The original value of @v. 917 */ 918static __always_inline long 919raw_atomic_long_fetch_and_release(long i, atomic_long_t *v) 920{ 921#ifdef CONFIG_64BIT 922 return raw_atomic64_fetch_and_release(i, v); 923#else 924 return raw_atomic_fetch_and_release(i, v); 925#endif 926} 927 928/** 929 * raw_atomic_long_fetch_and_relaxed() - atomic bitwise AND with relaxed ordering 930 * @i: long value 931 * @v: pointer to atomic_long_t 932 * 933 * Atomically updates @v to (@v & @i) with relaxed ordering. 934 * 935 * Safe to use in noinstr code; prefer atomic_long_fetch_and_relaxed() elsewhere. 936 * 937 * Return: The original value of @v. 938 */ 939static __always_inline long 940raw_atomic_long_fetch_and_relaxed(long i, atomic_long_t *v) 941{ 942#ifdef CONFIG_64BIT 943 return raw_atomic64_fetch_and_relaxed(i, v); 944#else 945 return raw_atomic_fetch_and_relaxed(i, v); 946#endif 947} 948 949/** 950 * raw_atomic_long_andnot() - atomic bitwise AND NOT with relaxed ordering 951 * @i: long value 952 * @v: pointer to atomic_long_t 953 * 954 * Atomically updates @v to (@v & ~@i) with relaxed ordering. 955 * 956 * Safe to use in noinstr code; prefer atomic_long_andnot() elsewhere. 957 * 958 * Return: Nothing. 959 */ 960static __always_inline void 961raw_atomic_long_andnot(long i, atomic_long_t *v) 962{ 963#ifdef CONFIG_64BIT 964 raw_atomic64_andnot(i, v); 965#else 966 raw_atomic_andnot(i, v); 967#endif 968} 969 970/** 971 * raw_atomic_long_fetch_andnot() - atomic bitwise AND NOT with full ordering 972 * @i: long value 973 * @v: pointer to atomic_long_t 974 * 975 * Atomically updates @v to (@v & ~@i) with full ordering. 976 * 977 * Safe to use in noinstr code; prefer atomic_long_fetch_andnot() elsewhere. 978 * 979 * Return: The original value of @v. 980 */ 981static __always_inline long 982raw_atomic_long_fetch_andnot(long i, atomic_long_t *v) 983{ 984#ifdef CONFIG_64BIT 985 return raw_atomic64_fetch_andnot(i, v); 986#else 987 return raw_atomic_fetch_andnot(i, v); 988#endif 989} 990 991/** 992 * raw_atomic_long_fetch_andnot_acquire() - atomic bitwise AND NOT with acquire ordering 993 * @i: long value 994 * @v: pointer to atomic_long_t 995 * 996 * Atomically updates @v to (@v & ~@i) with acquire ordering. 997 * 998 * Safe to use in noinstr code; prefer atomic_long_fetch_andnot_acquire() elsewhere. 999 * 1000 * Return: The original value of @v. 1001 */ 1002static __always_inline long 1003raw_atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v) 1004{ 1005#ifdef CONFIG_64BIT 1006 return raw_atomic64_fetch_andnot_acquire(i, v); 1007#else 1008 return raw_atomic_fetch_andnot_acquire(i, v); 1009#endif 1010} 1011 1012/** 1013 * raw_atomic_long_fetch_andnot_release() - atomic bitwise AND NOT with release ordering 1014 * @i: long value 1015 * @v: pointer to atomic_long_t 1016 * 1017 * Atomically updates @v to (@v & ~@i) with release ordering. 1018 * 1019 * Safe to use in noinstr code; prefer atomic_long_fetch_andnot_release() elsewhere. 1020 * 1021 * Return: The original value of @v. 1022 */ 1023static __always_inline long 1024raw_atomic_long_fetch_andnot_release(long i, atomic_long_t *v) 1025{ 1026#ifdef CONFIG_64BIT 1027 return raw_atomic64_fetch_andnot_release(i, v); 1028#else 1029 return raw_atomic_fetch_andnot_release(i, v); 1030#endif 1031} 1032 1033/** 1034 * raw_atomic_long_fetch_andnot_relaxed() - atomic bitwise AND NOT with relaxed ordering 1035 * @i: long value 1036 * @v: pointer to atomic_long_t 1037 * 1038 * Atomically updates @v to (@v & ~@i) with relaxed ordering. 1039 * 1040 * Safe to use in noinstr code; prefer atomic_long_fetch_andnot_relaxed() elsewhere. 1041 * 1042 * Return: The original value of @v. 1043 */ 1044static __always_inline long 1045raw_atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v) 1046{ 1047#ifdef CONFIG_64BIT 1048 return raw_atomic64_fetch_andnot_relaxed(i, v); 1049#else 1050 return raw_atomic_fetch_andnot_relaxed(i, v); 1051#endif 1052} 1053 1054/** 1055 * raw_atomic_long_or() - atomic bitwise OR with relaxed ordering 1056 * @i: long value 1057 * @v: pointer to atomic_long_t 1058 * 1059 * Atomically updates @v to (@v | @i) with relaxed ordering. 1060 * 1061 * Safe to use in noinstr code; prefer atomic_long_or() elsewhere. 1062 * 1063 * Return: Nothing. 1064 */ 1065static __always_inline void 1066raw_atomic_long_or(long i, atomic_long_t *v) 1067{ 1068#ifdef CONFIG_64BIT 1069 raw_atomic64_or(i, v); 1070#else 1071 raw_atomic_or(i, v); 1072#endif 1073} 1074 1075/** 1076 * raw_atomic_long_fetch_or() - atomic bitwise OR with full ordering 1077 * @i: long value 1078 * @v: pointer to atomic_long_t 1079 * 1080 * Atomically updates @v to (@v | @i) with full ordering. 1081 * 1082 * Safe to use in noinstr code; prefer atomic_long_fetch_or() elsewhere. 1083 * 1084 * Return: The original value of @v. 1085 */ 1086static __always_inline long 1087raw_atomic_long_fetch_or(long i, atomic_long_t *v) 1088{ 1089#ifdef CONFIG_64BIT 1090 return raw_atomic64_fetch_or(i, v); 1091#else 1092 return raw_atomic_fetch_or(i, v); 1093#endif 1094} 1095 1096/** 1097 * raw_atomic_long_fetch_or_acquire() - atomic bitwise OR with acquire ordering 1098 * @i: long value 1099 * @v: pointer to atomic_long_t 1100 * 1101 * Atomically updates @v to (@v | @i) with acquire ordering. 1102 * 1103 * Safe to use in noinstr code; prefer atomic_long_fetch_or_acquire() elsewhere. 1104 * 1105 * Return: The original value of @v. 1106 */ 1107static __always_inline long 1108raw_atomic_long_fetch_or_acquire(long i, atomic_long_t *v) 1109{ 1110#ifdef CONFIG_64BIT 1111 return raw_atomic64_fetch_or_acquire(i, v); 1112#else 1113 return raw_atomic_fetch_or_acquire(i, v); 1114#endif 1115} 1116 1117/** 1118 * raw_atomic_long_fetch_or_release() - atomic bitwise OR with release ordering 1119 * @i: long value 1120 * @v: pointer to atomic_long_t 1121 * 1122 * Atomically updates @v to (@v | @i) with release ordering. 1123 * 1124 * Safe to use in noinstr code; prefer atomic_long_fetch_or_release() elsewhere. 1125 * 1126 * Return: The original value of @v. 1127 */ 1128static __always_inline long 1129raw_atomic_long_fetch_or_release(long i, atomic_long_t *v) 1130{ 1131#ifdef CONFIG_64BIT 1132 return raw_atomic64_fetch_or_release(i, v); 1133#else 1134 return raw_atomic_fetch_or_release(i, v); 1135#endif 1136} 1137 1138/** 1139 * raw_atomic_long_fetch_or_relaxed() - atomic bitwise OR with relaxed ordering 1140 * @i: long value 1141 * @v: pointer to atomic_long_t 1142 * 1143 * Atomically updates @v to (@v | @i) with relaxed ordering. 1144 * 1145 * Safe to use in noinstr code; prefer atomic_long_fetch_or_relaxed() elsewhere. 1146 * 1147 * Return: The original value of @v. 1148 */ 1149static __always_inline long 1150raw_atomic_long_fetch_or_relaxed(long i, atomic_long_t *v) 1151{ 1152#ifdef CONFIG_64BIT 1153 return raw_atomic64_fetch_or_relaxed(i, v); 1154#else 1155 return raw_atomic_fetch_or_relaxed(i, v); 1156#endif 1157} 1158 1159/** 1160 * raw_atomic_long_xor() - atomic bitwise XOR with relaxed ordering 1161 * @i: long value 1162 * @v: pointer to atomic_long_t 1163 * 1164 * Atomically updates @v to (@v ^ @i) with relaxed ordering. 1165 * 1166 * Safe to use in noinstr code; prefer atomic_long_xor() elsewhere. 1167 * 1168 * Return: Nothing. 1169 */ 1170static __always_inline void 1171raw_atomic_long_xor(long i, atomic_long_t *v) 1172{ 1173#ifdef CONFIG_64BIT 1174 raw_atomic64_xor(i, v); 1175#else 1176 raw_atomic_xor(i, v); 1177#endif 1178} 1179 1180/** 1181 * raw_atomic_long_fetch_xor() - atomic bitwise XOR with full ordering 1182 * @i: long value 1183 * @v: pointer to atomic_long_t 1184 * 1185 * Atomically updates @v to (@v ^ @i) with full ordering. 1186 * 1187 * Safe to use in noinstr code; prefer atomic_long_fetch_xor() elsewhere. 1188 * 1189 * Return: The original value of @v. 1190 */ 1191static __always_inline long 1192raw_atomic_long_fetch_xor(long i, atomic_long_t *v) 1193{ 1194#ifdef CONFIG_64BIT 1195 return raw_atomic64_fetch_xor(i, v); 1196#else 1197 return raw_atomic_fetch_xor(i, v); 1198#endif 1199} 1200 1201/** 1202 * raw_atomic_long_fetch_xor_acquire() - atomic bitwise XOR with acquire ordering 1203 * @i: long value 1204 * @v: pointer to atomic_long_t 1205 * 1206 * Atomically updates @v to (@v ^ @i) with acquire ordering. 1207 * 1208 * Safe to use in noinstr code; prefer atomic_long_fetch_xor_acquire() elsewhere. 1209 * 1210 * Return: The original value of @v. 1211 */ 1212static __always_inline long 1213raw_atomic_long_fetch_xor_acquire(long i, atomic_long_t *v) 1214{ 1215#ifdef CONFIG_64BIT 1216 return raw_atomic64_fetch_xor_acquire(i, v); 1217#else 1218 return raw_atomic_fetch_xor_acquire(i, v); 1219#endif 1220} 1221 1222/** 1223 * raw_atomic_long_fetch_xor_release() - atomic bitwise XOR with release ordering 1224 * @i: long value 1225 * @v: pointer to atomic_long_t 1226 * 1227 * Atomically updates @v to (@v ^ @i) with release ordering. 1228 * 1229 * Safe to use in noinstr code; prefer atomic_long_fetch_xor_release() elsewhere. 1230 * 1231 * Return: The original value of @v. 1232 */ 1233static __always_inline long 1234raw_atomic_long_fetch_xor_release(long i, atomic_long_t *v) 1235{ 1236#ifdef CONFIG_64BIT 1237 return raw_atomic64_fetch_xor_release(i, v); 1238#else 1239 return raw_atomic_fetch_xor_release(i, v); 1240#endif 1241} 1242 1243/** 1244 * raw_atomic_long_fetch_xor_relaxed() - atomic bitwise XOR with relaxed ordering 1245 * @i: long value 1246 * @v: pointer to atomic_long_t 1247 * 1248 * Atomically updates @v to (@v ^ @i) with relaxed ordering. 1249 * 1250 * Safe to use in noinstr code; prefer atomic_long_fetch_xor_relaxed() elsewhere. 1251 * 1252 * Return: The original value of @v. 1253 */ 1254static __always_inline long 1255raw_atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v) 1256{ 1257#ifdef CONFIG_64BIT 1258 return raw_atomic64_fetch_xor_relaxed(i, v); 1259#else 1260 return raw_atomic_fetch_xor_relaxed(i, v); 1261#endif 1262} 1263 1264/** 1265 * raw_atomic_long_xchg() - atomic exchange with full ordering 1266 * @v: pointer to atomic_long_t 1267 * @new: long value to assign 1268 * 1269 * Atomically updates @v to @new with full ordering. 1270 * 1271 * Safe to use in noinstr code; prefer atomic_long_xchg() elsewhere. 1272 * 1273 * Return: The original value of @v. 1274 */ 1275static __always_inline long 1276raw_atomic_long_xchg(atomic_long_t *v, long new) 1277{ 1278#ifdef CONFIG_64BIT 1279 return raw_atomic64_xchg(v, new); 1280#else 1281 return raw_atomic_xchg(v, new); 1282#endif 1283} 1284 1285/** 1286 * raw_atomic_long_xchg_acquire() - atomic exchange with acquire ordering 1287 * @v: pointer to atomic_long_t 1288 * @new: long value to assign 1289 * 1290 * Atomically updates @v to @new with acquire ordering. 1291 * 1292 * Safe to use in noinstr code; prefer atomic_long_xchg_acquire() elsewhere. 1293 * 1294 * Return: The original value of @v. 1295 */ 1296static __always_inline long 1297raw_atomic_long_xchg_acquire(atomic_long_t *v, long new) 1298{ 1299#ifdef CONFIG_64BIT 1300 return raw_atomic64_xchg_acquire(v, new); 1301#else 1302 return raw_atomic_xchg_acquire(v, new); 1303#endif 1304} 1305 1306/** 1307 * raw_atomic_long_xchg_release() - atomic exchange with release ordering 1308 * @v: pointer to atomic_long_t 1309 * @new: long value to assign 1310 * 1311 * Atomically updates @v to @new with release ordering. 1312 * 1313 * Safe to use in noinstr code; prefer atomic_long_xchg_release() elsewhere. 1314 * 1315 * Return: The original value of @v. 1316 */ 1317static __always_inline long 1318raw_atomic_long_xchg_release(atomic_long_t *v, long new) 1319{ 1320#ifdef CONFIG_64BIT 1321 return raw_atomic64_xchg_release(v, new); 1322#else 1323 return raw_atomic_xchg_release(v, new); 1324#endif 1325} 1326 1327/** 1328 * raw_atomic_long_xchg_relaxed() - atomic exchange with relaxed ordering 1329 * @v: pointer to atomic_long_t 1330 * @new: long value to assign 1331 * 1332 * Atomically updates @v to @new with relaxed ordering. 1333 * 1334 * Safe to use in noinstr code; prefer atomic_long_xchg_relaxed() elsewhere. 1335 * 1336 * Return: The original value of @v. 1337 */ 1338static __always_inline long 1339raw_atomic_long_xchg_relaxed(atomic_long_t *v, long new) 1340{ 1341#ifdef CONFIG_64BIT 1342 return raw_atomic64_xchg_relaxed(v, new); 1343#else 1344 return raw_atomic_xchg_relaxed(v, new); 1345#endif 1346} 1347 1348/** 1349 * raw_atomic_long_cmpxchg() - atomic compare and exchange with full ordering 1350 * @v: pointer to atomic_long_t 1351 * @old: long value to compare with 1352 * @new: long value to assign 1353 * 1354 * If (@v == @old), atomically updates @v to @new with full ordering. 1355 * Otherwise, @v is not modified and relaxed ordering is provided. 1356 * 1357 * Safe to use in noinstr code; prefer atomic_long_cmpxchg() elsewhere. 1358 * 1359 * Return: The original value of @v. 1360 */ 1361static __always_inline long 1362raw_atomic_long_cmpxchg(atomic_long_t *v, long old, long new) 1363{ 1364#ifdef CONFIG_64BIT 1365 return raw_atomic64_cmpxchg(v, old, new); 1366#else 1367 return raw_atomic_cmpxchg(v, old, new); 1368#endif 1369} 1370 1371/** 1372 * raw_atomic_long_cmpxchg_acquire() - atomic compare and exchange with acquire ordering 1373 * @v: pointer to atomic_long_t 1374 * @old: long value to compare with 1375 * @new: long value to assign 1376 * 1377 * If (@v == @old), atomically updates @v to @new with acquire ordering. 1378 * Otherwise, @v is not modified and relaxed ordering is provided. 1379 * 1380 * Safe to use in noinstr code; prefer atomic_long_cmpxchg_acquire() elsewhere. 1381 * 1382 * Return: The original value of @v. 1383 */ 1384static __always_inline long 1385raw_atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new) 1386{ 1387#ifdef CONFIG_64BIT 1388 return raw_atomic64_cmpxchg_acquire(v, old, new); 1389#else 1390 return raw_atomic_cmpxchg_acquire(v, old, new); 1391#endif 1392} 1393 1394/** 1395 * raw_atomic_long_cmpxchg_release() - atomic compare and exchange with release ordering 1396 * @v: pointer to atomic_long_t 1397 * @old: long value to compare with 1398 * @new: long value to assign 1399 * 1400 * If (@v == @old), atomically updates @v to @new with release ordering. 1401 * Otherwise, @v is not modified and relaxed ordering is provided. 1402 * 1403 * Safe to use in noinstr code; prefer atomic_long_cmpxchg_release() elsewhere. 1404 * 1405 * Return: The original value of @v. 1406 */ 1407static __always_inline long 1408raw_atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new) 1409{ 1410#ifdef CONFIG_64BIT 1411 return raw_atomic64_cmpxchg_release(v, old, new); 1412#else 1413 return raw_atomic_cmpxchg_release(v, old, new); 1414#endif 1415} 1416 1417/** 1418 * raw_atomic_long_cmpxchg_relaxed() - atomic compare and exchange with relaxed ordering 1419 * @v: pointer to atomic_long_t 1420 * @old: long value to compare with 1421 * @new: long value to assign 1422 * 1423 * If (@v == @old), atomically updates @v to @new with relaxed ordering. 1424 * Otherwise, @v is not modified and relaxed ordering is provided. 1425 * 1426 * Safe to use in noinstr code; prefer atomic_long_cmpxchg_relaxed() elsewhere. 1427 * 1428 * Return: The original value of @v. 1429 */ 1430static __always_inline long 1431raw_atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new) 1432{ 1433#ifdef CONFIG_64BIT 1434 return raw_atomic64_cmpxchg_relaxed(v, old, new); 1435#else 1436 return raw_atomic_cmpxchg_relaxed(v, old, new); 1437#endif 1438} 1439 1440/** 1441 * raw_atomic_long_try_cmpxchg() - atomic compare and exchange with full ordering 1442 * @v: pointer to atomic_long_t 1443 * @old: pointer to long value to compare with 1444 * @new: long value to assign 1445 * 1446 * If (@v == @old), atomically updates @v to @new with full ordering. 1447 * Otherwise, @v is not modified, @old is updated to the current value of @v, 1448 * and relaxed ordering is provided. 1449 * 1450 * Safe to use in noinstr code; prefer atomic_long_try_cmpxchg() elsewhere. 1451 * 1452 * Return: @true if the exchange occured, @false otherwise. 1453 */ 1454static __always_inline bool 1455raw_atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new) 1456{ 1457#ifdef CONFIG_64BIT 1458 return raw_atomic64_try_cmpxchg(v, (s64 *)old, new); 1459#else 1460 return raw_atomic_try_cmpxchg(v, (int *)old, new); 1461#endif 1462} 1463 1464/** 1465 * raw_atomic_long_try_cmpxchg_acquire() - atomic compare and exchange with acquire ordering 1466 * @v: pointer to atomic_long_t 1467 * @old: pointer to long value to compare with 1468 * @new: long value to assign 1469 * 1470 * If (@v == @old), atomically updates @v to @new with acquire ordering. 1471 * Otherwise, @v is not modified, @old is updated to the current value of @v, 1472 * and relaxed ordering is provided. 1473 * 1474 * Safe to use in noinstr code; prefer atomic_long_try_cmpxchg_acquire() elsewhere. 1475 * 1476 * Return: @true if the exchange occured, @false otherwise. 1477 */ 1478static __always_inline bool 1479raw_atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new) 1480{ 1481#ifdef CONFIG_64BIT 1482 return raw_atomic64_try_cmpxchg_acquire(v, (s64 *)old, new); 1483#else 1484 return raw_atomic_try_cmpxchg_acquire(v, (int *)old, new); 1485#endif 1486} 1487 1488/** 1489 * raw_atomic_long_try_cmpxchg_release() - atomic compare and exchange with release ordering 1490 * @v: pointer to atomic_long_t 1491 * @old: pointer to long value to compare with 1492 * @new: long value to assign 1493 * 1494 * If (@v == @old), atomically updates @v to @new with release ordering. 1495 * Otherwise, @v is not modified, @old is updated to the current value of @v, 1496 * and relaxed ordering is provided. 1497 * 1498 * Safe to use in noinstr code; prefer atomic_long_try_cmpxchg_release() elsewhere. 1499 * 1500 * Return: @true if the exchange occured, @false otherwise. 1501 */ 1502static __always_inline bool 1503raw_atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new) 1504{ 1505#ifdef CONFIG_64BIT 1506 return raw_atomic64_try_cmpxchg_release(v, (s64 *)old, new); 1507#else 1508 return raw_atomic_try_cmpxchg_release(v, (int *)old, new); 1509#endif 1510} 1511 1512/** 1513 * raw_atomic_long_try_cmpxchg_relaxed() - atomic compare and exchange with relaxed ordering 1514 * @v: pointer to atomic_long_t 1515 * @old: pointer to long value to compare with 1516 * @new: long value to assign 1517 * 1518 * If (@v == @old), atomically updates @v to @new with relaxed ordering. 1519 * Otherwise, @v is not modified, @old is updated to the current value of @v, 1520 * and relaxed ordering is provided. 1521 * 1522 * Safe to use in noinstr code; prefer atomic_long_try_cmpxchg_relaxed() elsewhere. 1523 * 1524 * Return: @true if the exchange occured, @false otherwise. 1525 */ 1526static __always_inline bool 1527raw_atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new) 1528{ 1529#ifdef CONFIG_64BIT 1530 return raw_atomic64_try_cmpxchg_relaxed(v, (s64 *)old, new); 1531#else 1532 return raw_atomic_try_cmpxchg_relaxed(v, (int *)old, new); 1533#endif 1534} 1535 1536/** 1537 * raw_atomic_long_sub_and_test() - atomic subtract and test if zero with full ordering 1538 * @i: long value to add 1539 * @v: pointer to atomic_long_t 1540 * 1541 * Atomically updates @v to (@v - @i) with full ordering. 1542 * 1543 * Safe to use in noinstr code; prefer atomic_long_sub_and_test() elsewhere. 1544 * 1545 * Return: @true if the resulting value of @v is zero, @false otherwise. 1546 */ 1547static __always_inline bool 1548raw_atomic_long_sub_and_test(long i, atomic_long_t *v) 1549{ 1550#ifdef CONFIG_64BIT 1551 return raw_atomic64_sub_and_test(i, v); 1552#else 1553 return raw_atomic_sub_and_test(i, v); 1554#endif 1555} 1556 1557/** 1558 * raw_atomic_long_dec_and_test() - atomic decrement and test if zero with full ordering 1559 * @v: pointer to atomic_long_t 1560 * 1561 * Atomically updates @v to (@v - 1) with full ordering. 1562 * 1563 * Safe to use in noinstr code; prefer atomic_long_dec_and_test() elsewhere. 1564 * 1565 * Return: @true if the resulting value of @v is zero, @false otherwise. 1566 */ 1567static __always_inline bool 1568raw_atomic_long_dec_and_test(atomic_long_t *v) 1569{ 1570#ifdef CONFIG_64BIT 1571 return raw_atomic64_dec_and_test(v); 1572#else 1573 return raw_atomic_dec_and_test(v); 1574#endif 1575} 1576 1577/** 1578 * raw_atomic_long_inc_and_test() - atomic increment and test if zero with full ordering 1579 * @v: pointer to atomic_long_t 1580 * 1581 * Atomically updates @v to (@v + 1) with full ordering. 1582 * 1583 * Safe to use in noinstr code; prefer atomic_long_inc_and_test() elsewhere. 1584 * 1585 * Return: @true if the resulting value of @v is zero, @false otherwise. 1586 */ 1587static __always_inline bool 1588raw_atomic_long_inc_and_test(atomic_long_t *v) 1589{ 1590#ifdef CONFIG_64BIT 1591 return raw_atomic64_inc_and_test(v); 1592#else 1593 return raw_atomic_inc_and_test(v); 1594#endif 1595} 1596 1597/** 1598 * raw_atomic_long_add_negative() - atomic add and test if negative with full ordering 1599 * @i: long value to add 1600 * @v: pointer to atomic_long_t 1601 * 1602 * Atomically updates @v to (@v + @i) with full ordering. 1603 * 1604 * Safe to use in noinstr code; prefer atomic_long_add_negative() elsewhere. 1605 * 1606 * Return: @true if the resulting value of @v is negative, @false otherwise. 1607 */ 1608static __always_inline bool 1609raw_atomic_long_add_negative(long i, atomic_long_t *v) 1610{ 1611#ifdef CONFIG_64BIT 1612 return raw_atomic64_add_negative(i, v); 1613#else 1614 return raw_atomic_add_negative(i, v); 1615#endif 1616} 1617 1618/** 1619 * raw_atomic_long_add_negative_acquire() - atomic add and test if negative with acquire ordering 1620 * @i: long value to add 1621 * @v: pointer to atomic_long_t 1622 * 1623 * Atomically updates @v to (@v + @i) with acquire ordering. 1624 * 1625 * Safe to use in noinstr code; prefer atomic_long_add_negative_acquire() elsewhere. 1626 * 1627 * Return: @true if the resulting value of @v is negative, @false otherwise. 1628 */ 1629static __always_inline bool 1630raw_atomic_long_add_negative_acquire(long i, atomic_long_t *v) 1631{ 1632#ifdef CONFIG_64BIT 1633 return raw_atomic64_add_negative_acquire(i, v); 1634#else 1635 return raw_atomic_add_negative_acquire(i, v); 1636#endif 1637} 1638 1639/** 1640 * raw_atomic_long_add_negative_release() - atomic add and test if negative with release ordering 1641 * @i: long value to add 1642 * @v: pointer to atomic_long_t 1643 * 1644 * Atomically updates @v to (@v + @i) with release ordering. 1645 * 1646 * Safe to use in noinstr code; prefer atomic_long_add_negative_release() elsewhere. 1647 * 1648 * Return: @true if the resulting value of @v is negative, @false otherwise. 1649 */ 1650static __always_inline bool 1651raw_atomic_long_add_negative_release(long i, atomic_long_t *v) 1652{ 1653#ifdef CONFIG_64BIT 1654 return raw_atomic64_add_negative_release(i, v); 1655#else 1656 return raw_atomic_add_negative_release(i, v); 1657#endif 1658} 1659 1660/** 1661 * raw_atomic_long_add_negative_relaxed() - atomic add and test if negative with relaxed ordering 1662 * @i: long value to add 1663 * @v: pointer to atomic_long_t 1664 * 1665 * Atomically updates @v to (@v + @i) with relaxed ordering. 1666 * 1667 * Safe to use in noinstr code; prefer atomic_long_add_negative_relaxed() elsewhere. 1668 * 1669 * Return: @true if the resulting value of @v is negative, @false otherwise. 1670 */ 1671static __always_inline bool 1672raw_atomic_long_add_negative_relaxed(long i, atomic_long_t *v) 1673{ 1674#ifdef CONFIG_64BIT 1675 return raw_atomic64_add_negative_relaxed(i, v); 1676#else 1677 return raw_atomic_add_negative_relaxed(i, v); 1678#endif 1679} 1680 1681/** 1682 * raw_atomic_long_fetch_add_unless() - atomic add unless value with full ordering 1683 * @v: pointer to atomic_long_t 1684 * @a: long value to add 1685 * @u: long value to compare with 1686 * 1687 * If (@v != @u), atomically updates @v to (@v + @a) with full ordering. 1688 * Otherwise, @v is not modified and relaxed ordering is provided. 1689 * 1690 * Safe to use in noinstr code; prefer atomic_long_fetch_add_unless() elsewhere. 1691 * 1692 * Return: The original value of @v. 1693 */ 1694static __always_inline long 1695raw_atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u) 1696{ 1697#ifdef CONFIG_64BIT 1698 return raw_atomic64_fetch_add_unless(v, a, u); 1699#else 1700 return raw_atomic_fetch_add_unless(v, a, u); 1701#endif 1702} 1703 1704/** 1705 * raw_atomic_long_add_unless() - atomic add unless value with full ordering 1706 * @v: pointer to atomic_long_t 1707 * @a: long value to add 1708 * @u: long value to compare with 1709 * 1710 * If (@v != @u), atomically updates @v to (@v + @a) with full ordering. 1711 * Otherwise, @v is not modified and relaxed ordering is provided. 1712 * 1713 * Safe to use in noinstr code; prefer atomic_long_add_unless() elsewhere. 1714 * 1715 * Return: @true if @v was updated, @false otherwise. 1716 */ 1717static __always_inline bool 1718raw_atomic_long_add_unless(atomic_long_t *v, long a, long u) 1719{ 1720#ifdef CONFIG_64BIT 1721 return raw_atomic64_add_unless(v, a, u); 1722#else 1723 return raw_atomic_add_unless(v, a, u); 1724#endif 1725} 1726 1727/** 1728 * raw_atomic_long_inc_not_zero() - atomic increment unless zero with full ordering 1729 * @v: pointer to atomic_long_t 1730 * 1731 * If (@v != 0), atomically updates @v to (@v + 1) with full ordering. 1732 * Otherwise, @v is not modified and relaxed ordering is provided. 1733 * 1734 * Safe to use in noinstr code; prefer atomic_long_inc_not_zero() elsewhere. 1735 * 1736 * Return: @true if @v was updated, @false otherwise. 1737 */ 1738static __always_inline bool 1739raw_atomic_long_inc_not_zero(atomic_long_t *v) 1740{ 1741#ifdef CONFIG_64BIT 1742 return raw_atomic64_inc_not_zero(v); 1743#else 1744 return raw_atomic_inc_not_zero(v); 1745#endif 1746} 1747 1748/** 1749 * raw_atomic_long_inc_unless_negative() - atomic increment unless negative with full ordering 1750 * @v: pointer to atomic_long_t 1751 * 1752 * If (@v >= 0), atomically updates @v to (@v + 1) with full ordering. 1753 * Otherwise, @v is not modified and relaxed ordering is provided. 1754 * 1755 * Safe to use in noinstr code; prefer atomic_long_inc_unless_negative() elsewhere. 1756 * 1757 * Return: @true if @v was updated, @false otherwise. 1758 */ 1759static __always_inline bool 1760raw_atomic_long_inc_unless_negative(atomic_long_t *v) 1761{ 1762#ifdef CONFIG_64BIT 1763 return raw_atomic64_inc_unless_negative(v); 1764#else 1765 return raw_atomic_inc_unless_negative(v); 1766#endif 1767} 1768 1769/** 1770 * raw_atomic_long_dec_unless_positive() - atomic decrement unless positive with full ordering 1771 * @v: pointer to atomic_long_t 1772 * 1773 * If (@v <= 0), atomically updates @v to (@v - 1) with full ordering. 1774 * Otherwise, @v is not modified and relaxed ordering is provided. 1775 * 1776 * Safe to use in noinstr code; prefer atomic_long_dec_unless_positive() elsewhere. 1777 * 1778 * Return: @true if @v was updated, @false otherwise. 1779 */ 1780static __always_inline bool 1781raw_atomic_long_dec_unless_positive(atomic_long_t *v) 1782{ 1783#ifdef CONFIG_64BIT 1784 return raw_atomic64_dec_unless_positive(v); 1785#else 1786 return raw_atomic_dec_unless_positive(v); 1787#endif 1788} 1789 1790/** 1791 * raw_atomic_long_dec_if_positive() - atomic decrement if positive with full ordering 1792 * @v: pointer to atomic_long_t 1793 * 1794 * If (@v > 0), atomically updates @v to (@v - 1) with full ordering. 1795 * Otherwise, @v is not modified and relaxed ordering is provided. 1796 * 1797 * Safe to use in noinstr code; prefer atomic_long_dec_if_positive() elsewhere. 1798 * 1799 * Return: The old value of (@v - 1), regardless of whether @v was updated. 1800 */ 1801static __always_inline long 1802raw_atomic_long_dec_if_positive(atomic_long_t *v) 1803{ 1804#ifdef CONFIG_64BIT 1805 return raw_atomic64_dec_if_positive(v); 1806#else 1807 return raw_atomic_dec_if_positive(v); 1808#endif 1809} 1810 1811#endif /* _LINUX_ATOMIC_LONG_H */ 1812// 1c4a26fc77f345342953770ebe3c4d08e7ce2f9a 1813