atomic64_test.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Testsuite for atomic64_t functions
  4. *
  5. * Copyright © 2010 Luca Barbieri
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/init.h>
  9. #include <linux/bug.h>
  10. #include <linux/kernel.h>
  11. #include <linux/atomic.h>
  12. #include <linux/module.h>
  13. #ifdef CONFIG_X86
  14. #include <asm/cpufeature.h> /* for boot_cpu_has below */
  15. #endif
  16. #define TEST(bit, op, c_op, val) \
  17. do { \
  18. atomic##bit##_set(&v, v0); \
  19. r = v0; \
  20. atomic##bit##_##op(val, &v); \
  21. r c_op val; \
  22. WARN(atomic##bit##_read(&v) != r, "%Lx != %Lx\n", \
  23. (unsigned long long)atomic##bit##_read(&v), \
  24. (unsigned long long)r); \
  25. } while (0)
  26. /*
  27. * Test for a atomic operation family,
  28. * @test should be a macro accepting parameters (bit, op, ...)
  29. */
  30. #define FAMILY_TEST(test, bit, op, args...) \
  31. do { \
  32. test(bit, op, ##args); \
  33. test(bit, op##_acquire, ##args); \
  34. test(bit, op##_release, ##args); \
  35. test(bit, op##_relaxed, ##args); \
  36. } while (0)
  37. #define TEST_RETURN(bit, op, c_op, val) \
  38. do { \
  39. atomic##bit##_set(&v, v0); \
  40. r = v0; \
  41. r c_op val; \
  42. BUG_ON(atomic##bit##_##op(val, &v) != r); \
  43. BUG_ON(atomic##bit##_read(&v) != r); \
  44. } while (0)
  45. #define TEST_FETCH(bit, op, c_op, val) \
  46. do { \
  47. atomic##bit##_set(&v, v0); \
  48. r = v0; \
  49. r c_op val; \
  50. BUG_ON(atomic##bit##_##op(val, &v) != v0); \
  51. BUG_ON(atomic##bit##_read(&v) != r); \
  52. } while (0)
  53. #define RETURN_FAMILY_TEST(bit, op, c_op, val) \
  54. do { \
  55. FAMILY_TEST(TEST_RETURN, bit, op, c_op, val); \
  56. } while (0)
  57. #define FETCH_FAMILY_TEST(bit, op, c_op, val) \
  58. do { \
  59. FAMILY_TEST(TEST_FETCH, bit, op, c_op, val); \
  60. } while (0)
  61. #define TEST_ARGS(bit, op, init, ret, expect, args...) \
  62. do { \
  63. atomic##bit##_set(&v, init); \
  64. BUG_ON(atomic##bit##_##op(&v, ##args) != ret); \
  65. BUG_ON(atomic##bit##_read(&v) != expect); \
  66. } while (0)
  67. #define XCHG_FAMILY_TEST(bit, init, new) \
  68. do { \
  69. FAMILY_TEST(TEST_ARGS, bit, xchg, init, init, new, new); \
  70. } while (0)
  71. #define CMPXCHG_FAMILY_TEST(bit, init, new, wrong) \
  72. do { \
  73. FAMILY_TEST(TEST_ARGS, bit, cmpxchg, \
  74. init, init, new, init, new); \
  75. FAMILY_TEST(TEST_ARGS, bit, cmpxchg, \
  76. init, init, init, wrong, new); \
  77. } while (0)
  78. #define INC_RETURN_FAMILY_TEST(bit, i) \
  79. do { \
  80. FAMILY_TEST(TEST_ARGS, bit, inc_return, \
  81. i, (i) + one, (i) + one); \
  82. } while (0)
  83. #define DEC_RETURN_FAMILY_TEST(bit, i) \
  84. do { \
  85. FAMILY_TEST(TEST_ARGS, bit, dec_return, \
  86. i, (i) - one, (i) - one); \
  87. } while (0)
  88. static __init void test_atomic(void)
  89. {
  90. int v0 = 0xaaa31337;
  91. int v1 = 0xdeadbeef;
  92. int onestwos = 0x11112222;
  93. int one = 1;
  94. atomic_t v;
  95. int r;
  96. TEST(, add, +=, onestwos);
  97. TEST(, add, +=, -one);
  98. TEST(, sub, -=, onestwos);
  99. TEST(, sub, -=, -one);
  100. TEST(, or, |=, v1);
  101. TEST(, and, &=, v1);
  102. TEST(, xor, ^=, v1);
  103. TEST(, andnot, &= ~, v1);
  104. RETURN_FAMILY_TEST(, add_return, +=, onestwos);
  105. RETURN_FAMILY_TEST(, add_return, +=, -one);
  106. RETURN_FAMILY_TEST(, sub_return, -=, onestwos);
  107. RETURN_FAMILY_TEST(, sub_return, -=, -one);
  108. FETCH_FAMILY_TEST(, fetch_add, +=, onestwos);
  109. FETCH_FAMILY_TEST(, fetch_add, +=, -one);
  110. FETCH_FAMILY_TEST(, fetch_sub, -=, onestwos);
  111. FETCH_FAMILY_TEST(, fetch_sub, -=, -one);
  112. FETCH_FAMILY_TEST(, fetch_or, |=, v1);
  113. FETCH_FAMILY_TEST(, fetch_and, &=, v1);
  114. FETCH_FAMILY_TEST(, fetch_andnot, &= ~, v1);
  115. FETCH_FAMILY_TEST(, fetch_xor, ^=, v1);
  116. INC_RETURN_FAMILY_TEST(, v0);
  117. DEC_RETURN_FAMILY_TEST(, v0);
  118. XCHG_FAMILY_TEST(, v0, v1);
  119. CMPXCHG_FAMILY_TEST(, v0, v1, onestwos);
  120. }
  121. #define INIT(c) do { atomic64_set(&v, c); r = c; } while (0)
  122. static __init void test_atomic64(void)
  123. {
  124. long long v0 = 0xaaa31337c001d00dLL;
  125. long long v1 = 0xdeadbeefdeafcafeLL;
  126. long long v2 = 0xfaceabadf00df001LL;
  127. long long v3 = 0x8000000000000000LL;
  128. long long onestwos = 0x1111111122222222LL;
  129. long long one = 1LL;
  130. int r_int;
  131. atomic64_t v = ATOMIC64_INIT(v0);
  132. long long r = v0;
  133. BUG_ON(v.counter != r);
  134. atomic64_set(&v, v1);
  135. r = v1;
  136. BUG_ON(v.counter != r);
  137. BUG_ON(atomic64_read(&v) != r);
  138. TEST(64, add, +=, onestwos);
  139. TEST(64, add, +=, -one);
  140. TEST(64, sub, -=, onestwos);
  141. TEST(64, sub, -=, -one);
  142. TEST(64, or, |=, v1);
  143. TEST(64, and, &=, v1);
  144. TEST(64, xor, ^=, v1);
  145. TEST(64, andnot, &= ~, v1);
  146. RETURN_FAMILY_TEST(64, add_return, +=, onestwos);
  147. RETURN_FAMILY_TEST(64, add_return, +=, -one);
  148. RETURN_FAMILY_TEST(64, sub_return, -=, onestwos);
  149. RETURN_FAMILY_TEST(64, sub_return, -=, -one);
  150. FETCH_FAMILY_TEST(64, fetch_add, +=, onestwos);
  151. FETCH_FAMILY_TEST(64, fetch_add, +=, -one);
  152. FETCH_FAMILY_TEST(64, fetch_sub, -=, onestwos);
  153. FETCH_FAMILY_TEST(64, fetch_sub, -=, -one);
  154. FETCH_FAMILY_TEST(64, fetch_or, |=, v1);
  155. FETCH_FAMILY_TEST(64, fetch_and, &=, v1);
  156. FETCH_FAMILY_TEST(64, fetch_andnot, &= ~, v1);
  157. FETCH_FAMILY_TEST(64, fetch_xor, ^=, v1);
  158. INIT(v0);
  159. atomic64_inc(&v);
  160. r += one;
  161. BUG_ON(v.counter != r);
  162. INIT(v0);
  163. atomic64_dec(&v);
  164. r -= one;
  165. BUG_ON(v.counter != r);
  166. INC_RETURN_FAMILY_TEST(64, v0);
  167. DEC_RETURN_FAMILY_TEST(64, v0);
  168. XCHG_FAMILY_TEST(64, v0, v1);
  169. CMPXCHG_FAMILY_TEST(64, v0, v1, v2);
  170. INIT(v0);
  171. BUG_ON(atomic64_add_unless(&v, one, v0));
  172. BUG_ON(v.counter != r);
  173. INIT(v0);
  174. BUG_ON(!atomic64_add_unless(&v, one, v1));
  175. r += one;
  176. BUG_ON(v.counter != r);
  177. INIT(onestwos);
  178. BUG_ON(atomic64_dec_if_positive(&v) != (onestwos - 1));
  179. r -= one;
  180. BUG_ON(v.counter != r);
  181. INIT(0);
  182. BUG_ON(atomic64_dec_if_positive(&v) != -one);
  183. BUG_ON(v.counter != r);
  184. INIT(-one);
  185. BUG_ON(atomic64_dec_if_positive(&v) != (-one - one));
  186. BUG_ON(v.counter != r);
  187. INIT(onestwos);
  188. BUG_ON(!atomic64_inc_not_zero(&v));
  189. r += one;
  190. BUG_ON(v.counter != r);
  191. INIT(0);
  192. BUG_ON(atomic64_inc_not_zero(&v));
  193. BUG_ON(v.counter != r);
  194. INIT(-one);
  195. BUG_ON(!atomic64_inc_not_zero(&v));
  196. r += one;
  197. BUG_ON(v.counter != r);
  198. /* Confirm the return value fits in an int, even if the value doesn't */
  199. INIT(v3);
  200. r_int = atomic64_inc_not_zero(&v);
  201. BUG_ON(!r_int);
  202. }
  203. static __init int test_atomics_init(void)
  204. {
  205. test_atomic();
  206. test_atomic64();
  207. #ifdef CONFIG_X86
  208. pr_info("passed for %s platform %s CX8 and %s SSE\n",
  209. #ifdef CONFIG_X86_64
  210. "x86-64",
  211. #elif defined(CONFIG_X86_CMPXCHG64)
  212. "i586+",
  213. #else
  214. "i386+",
  215. #endif
  216. boot_cpu_has(X86_FEATURE_CX8) ? "with" : "without",
  217. boot_cpu_has(X86_FEATURE_XMM) ? "with" : "without");
  218. #else
  219. pr_info("passed\n");
  220. #endif
  221. return 0;
  222. }
  223. static __exit void test_atomics_exit(void) {}
  224. module_init(test_atomics_init);
  225. module_exit(test_atomics_exit);
  226. MODULE_LICENSE("GPL");